fix(execution): address observer review feedback

Author: aryasaatvik

packages/core/api/src/server/execution-stack.ts

@@ -110,10 +110,6 @@ export const makeExecutionStack = <
     const codeExecutor = yield* CodeExecutorProvider;
     const { decorate } = yield* EngineDecorator;
 
-    // Compose every registered plugin's runtime.executionObserver, bound to the
-    // executor's own extensions. Resolves to a no-op when no plugin observes,
-    // so a stack with no history/metrics plugin is unaffected. `plugins()` is
-    // the erased AnyPlugin[]; the caller's TPlugins phantom recovers the tuple.
     const { plugins } = yield* PluginsProvider;
     // PluginsProvider erases the tuple to AnyPlugin[]; recover the caller's
     // TPlugins phantom so the extensions arg (the executor) lines up.

packages/core/execution/src/engine-observer.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Predicate } from "effect";
+import { Effect, Predicate, Schema } from "effect";
 
-import { createExecutor, definePlugin } from "@executor-js/sdk";
+import { createExecutor, definePlugin, ElicitationResponse, tool } from "@executor-js/sdk";
 import type { ExecutionEvent, ExecutionObserver } from "@executor-js/sdk";
 import { makeTestConfig } from "@executor-js/sdk/testing";
 import type { CodeExecutor, ExecuteResult } from "@executor-js/codemode-core";
@@ -14,8 +14,32 @@ const emptyPlugin = definePlugin(() => ({
   staticSources: () => [],
 }));
 
+const approvalPlugin = definePlugin(() => ({
+  id: "observer-approval-test" as const,
+  storage: () => ({}),
+  staticSources: () => [
+    {
+      id: "approval.ctl",
+      kind: "control" as const,
+      name: "Approval Ctl",
+      tools: [
+        tool({
+          name: "run",
+          description: "Requires approval",
+          annotations: { requiresApproval: true } as const,
+          inputSchema: Schema.toStandardSchemaV1(Schema.toStandardJSONSchemaV1(Schema.Struct({}))),
+          execute: () => Effect.succeed("ran"),
+        }),
+      ],
+    },
+  ],
+}));
+
 const makeExecutor = () => createExecutor(makeTestConfig({ plugins: [emptyPlugin()] as const }));
 
+const makeApprovalExecutor = () =>
+  createExecutor(makeTestConfig({ plugins: [approvalPlugin()] as const }));
+
 // A code executor that issues one builtin tool call (tools.search) and then
 // completes, enough to exercise the full event sequence.
 const toolCallingExecutor: CodeExecutor = {
@@ -25,6 +49,13 @@ const toolCallingExecutor: CodeExecutor = {
       .pipe(Effect.as({ result: "ok", logs: [] } satisfies ExecuteResult), Effect.orDie),
 };
 
+const approvalCallingExecutor: CodeExecutor = {
+  execute: (_code, invoker) =>
+    invoker
+      .invoke({ path: "approval.ctl.run", args: {} })
+      .pipe(Effect.as({ result: "ok", logs: [] } satisfies ExecuteResult), Effect.orDie),
+};
+
 const collectingObserver = () => {
   const events: ExecutionEvent[] = [];
   const observer: ExecutionObserver = {
@@ -70,6 +101,35 @@ describe("execution engine observer emission", () => {
     }),
   );
 
+  it.effect("emits inline interaction events when execute handles elicitation", () =>
+    Effect.gen(function* () {
+      const executor = yield* makeApprovalExecutor();
+      const { events, observer } = collectingObserver();
+      const engine = createExecutionEngine({
+        executor,
+        codeExecutor: approvalCallingExecutor,
+        observer,
+      });
+
+      const result = yield* engine.execute("noop", {
+        trigger: { kind: "test" },
+        onElicitation: () => Effect.succeed(ElicitationResponse.make({ action: "accept" })),
+      });
+      expect(result.result).toBe("ok");
+
+      const started = events.find((e) => Predicate.isTagged(e, "ExecutionStarted"));
+      const interactionStarted = events.find((e) => Predicate.isTagged(e, "InteractionStarted"));
+      const interactionResolved = events.find((e) => Predicate.isTagged(e, "InteractionResolved"));
+
+      expect(interactionStarted?.executionId).toBe(started?.executionId);
+      expect(interactionResolved?.executionId).toBe(started?.executionId);
+      expect(interactionResolved?.interactionId).toBe(interactionStarted?.interactionId);
+      expect(interactionStarted?.context.request.message).toContain("approval");
+      expect(interactionResolved?.status).toBe("accepted");
+      expect(interactionResolved?.response?.action).toBe("accept");
+    }),
+  );
+
   it.effect("does nothing observable when no observer is configured", () =>
     Effect.gen(function* () {
       const executor = yield* makeExecutor();

packages/core/sdk/src/execution-observer.ts

@@ -107,7 +107,7 @@ const logExecutionObserverFailure = (
 ): Effect.Effect<void> =>
   Effect.logWarning("execution observer failed", {
     cause: Cause.pretty(cause),
-    event: event.constructor.name,
+    event: event._tag,
     ...(pluginId ? { pluginId } : {}),
   });