fix(cursor): agent shell commands stream their output while they run

packages/provider-cursor/src/server/CursorAgentSdk.test.ts

@@ -273,6 +273,55 @@ describe("CursorAgentSdkRunner", () => {
     }).pipe(Effect.provide(layerTest)),
   );
 
+  it.effect("forwards the agent's own shell stream output as shell-output-delta", () =>
+    Effect.gen(function* () {
+      const publish = (conversationId: string, data: string) =>
+        (Reflect.get(globalThis, Symbol.for("@cursor/sdk.shellStreamOutput")) as Function)({
+          conversationId,
+          toolCallId: "tool-shell",
+          event: { case: "stdout", value: { data } },
+        });
+      cursorSdkMock.runWait.mockImplementationOnce(async () => {
+        publish("agent-cursor-agent-sdk-test", "tick 1\n");
+        publish("agent-someone-else", "not ours\n");
+        return {
+          id: "run-cursor-agent-sdk-test",
+          requestId: "request-cursor-agent-sdk-test",
+          status: "finished",
+          result: "ok",
+          model: { id: "default" },
+          durationMs: 1,
+        };
+      });
+      const updates: Array<unknown> = [];
+      const runner = yield* CursorAgentSdk.CursorAgentSdkRunner;
+      const session = yield* runner.open({
+        operation: "create",
+        options: {},
+        threadId: ThreadId.make("thread-cursor-agent-sdk-shell"),
+        providerSessionId: ProviderSessionId.make("provider-session-cursor-agent-sdk-shell"),
+      });
+      const run = yield* session.send({
+        message: "run it",
+        onDelta: (update) => Effect.sync(() => updates.push(update)),
+      });
+      yield* run.wait;
+      publish("agent-cursor-agent-sdk-test", "after the run\n");
+
+      assert.deepStrictEqual(
+        updates.filter(
+          (update) => (update as { readonly type: string }).type === "shell-output-delta",
+        ),
+        [
+          {
+            type: "shell-output-delta",
+            event: { case: "stdout", value: { data: "tick 1\n" }, toolCallId: "tool-shell" },
+          },
+        ],
+      );
+    }).pipe(Effect.provide(layerTest)),
+  );
+
   it.effect("forwards Run.steer and reports a missing method as a follow-up", () =>
     Effect.gen(function* () {
       cursorSdkMock.runSteer.mockClear();

packages/provider-cursor/src/server/CursorAgentSdk.ts

@@ -367,6 +367,31 @@ function makeCursorAgentSdkProtocolLogger(input: {
       .pipe(Effect.ignore);
 }
 
+interface CursorShellStreamOutput {
+  readonly conversationId?: unknown;
+  readonly toolCallId?: unknown;
+  readonly event: {
+    readonly case: "stdout" | "stderr";
+    readonly value: { readonly data: unknown };
+  };
+}
+
+// The SDK reports shell-output-delta only for user-started shell commands, so
+// patches/@cursor__sdk@1.2.0.patch publishes agent shell output on this hook.
+const SHELL_STREAM_OUTPUT_HOOK = Symbol.for("@cursor/sdk.shellStreamOutput");
+const shellStreamListeners = new Set<(output: CursorShellStreamOutput) => void>();
+
+function subscribeShellStreamOutput(listener: (output: CursorShellStreamOutput) => void) {
+  const hooks = globalThis as Record<symbol, unknown>;
+  hooks[SHELL_STREAM_OUTPUT_HOOK] ??= (output: CursorShellStreamOutput) => {
+    for (const notify of shellStreamListeners) notify(output);
+  };
+  shellStreamListeners.add(listener);
+  return () => {
+    shellStreamListeners.delete(listener);
+  };
+}
+
 export const makeCursorAgentSdkRunner = Effect.fn("makeCursorAgentSdkRunner")(function* (
   protocolLoggerFor: (input: CursorAgentSdkOpenInput) => CursorAgentSdkProtocolLogger | undefined,
 ) {
@@ -592,6 +617,15 @@ export const makeCursorAgentSdkRunner = Effect.fn("makeCursorAgentSdkRunner")(fu
             },
           });
           callbacksReady = true;
+          const unsubscribeShellOutput = subscribeShellStreamOutput((output) => {
+            if (output.conversationId !== agent.agentId || typeof output.toolCallId !== "string") {
+              return;
+            }
+            void dispatchUpdate({
+              type: "shell-output-delta",
+              event: { ...output.event, toolCallId: output.toolCallId },
+            });
+          });
           for (const update of pendingUpdates) {
             yield* Effect.tryPromise({
               try: () => dispatchUpdate(update),
@@ -613,6 +647,7 @@ export const makeCursorAgentSdkRunner = Effect.fn("makeCursorAgentSdkRunner")(fu
               },
               catch: (cause) => runnerError(cause, "run.wait"),
             }).pipe(
+              Effect.ensuring(Effect.sync(unsubscribeShellOutput)),
               Effect.tap((result) =>
                 log({
                   direction: "incoming",

packages/provider-cursor/src/server/adapter.test.ts

@@ -1219,6 +1219,20 @@ describe("CursorAdapterV2", () => {
             result: { status: "error", error: "lint failed" },
           },
         },
+        ...["slow-shell", "fast-shell"].map((callId) => ({
+          type: "tool-call-started" as const,
+          modelCallId: "native-model-call",
+          callId,
+          toolCall: { type: "shell" as const, args: { command: callId } },
+        })),
+        {
+          type: "shell-output-delta",
+          event: { case: "stdout", value: { data: "tick 1\n" }, toolCallId: "slow-shell" },
+        },
+        {
+          type: "shell-output-delta",
+          event: { case: "exit", value: { code: 0 }, toolCallId: "slow-shell" },
+        },
       ];
       const adapter = yield* makeCursorAdapterV2({
         instanceId,
@@ -1332,6 +1346,21 @@ describe("CursorAdapterV2", () => {
         });
         assert.deepEqual(item.input, { city: "Berlin" });
       }
+      const shellItemIds = new Map(
+        events.flatMap((event) =>
+          event.type === "turn_item.updated" && event.turnItem.type === "command_execution"
+            ? [[event.turnItem.id, event.turnItem.input] as const]
+            : [],
+        ),
+      );
+      assert.deepEqual(
+        events.flatMap((event) =>
+          event.type === "command_output.delta"
+            ? [{ command: shellItemIds.get(event.itemId), chunk: event.chunk }]
+            : [],
+        ),
+        [{ command: "slow-shell", chunk: "tick 1\n" }],
+      );
       assert.deepEqual(toolOutputImages(mcpItems.at(-1)?.output), [
         { mimeType: "image/png", data: "iVBORw0KGgo=" },
       ]);

packages/provider-cursor/src/server/adapter.ts

@@ -1998,15 +1998,10 @@ export const makeCursorAdapterV2 = Effect.fn("makeCursorAdapterV2")(function* (
         });
 
         const shellOutputText = (event: Record<string, unknown>): string => {
-          const candidates = [
-            event.text,
-            event.output,
-            event.data,
-            event.stdout,
-            event.stderr,
-            event.chunk,
-          ];
-          return candidates.filter((value): value is string => typeof value === "string").join("");
+          if (event.case !== "stdout" && event.case !== "stderr") return "";
+          const value = event.value;
+          if (typeof value !== "object" || value === null || !("data" in value)) return "";
+          return typeof value.data === "string" ? value.data : "";
         };
 
         const handleInteractionUpdate = Effect.fnUntraced(function* (
@@ -2071,10 +2066,14 @@ export const makeCursorAdapterV2 = Effect.fn("makeCursorAdapterV2")(function* (
               yield* completeReasoning(context);
               return;
             case "shell-output-delta": {
-              const shell = Array.from(context.tools.values())
-                .toReversed()
-                .find((candidate) => candidate.toolCall.type === "shell");
-              if (shell === undefined) {
+              const toolCallId = update.event.toolCallId;
+              const shell =
+                typeof toolCallId === "string"
+                  ? context.tools.get(toolCallId)
+                  : Array.from(context.tools.values())
+                      .toReversed()
+                      .find((candidate) => candidate.toolCall.type === "shell");
+              if (shell?.toolCall.type !== "shell") {
                 return;
               }
               const chunk = shellOutputText(update.event);