Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

bridge cursor shell tools through claude bash

Raine Virtaef90e2189a74
diff --git a/src/providers/cursor/client.ts b/src/providers/cursor/client.ts
index 03dacd9..13ae75c 100644
--- a/src/providers/cursor/client.ts
+++ b/src/providers/cursor/client.ts
@@ -18,6 +18,7 @@ export interface CursorRunOptions {
ctx: RequestContext;
proto?: CursorProto;
openRunStream?: CursorRunStreamFactory;
+ shellStreamHandler?: CursorShellStreamHandler;
}
export type CursorRunStreamFactory = (opts: {
@@ -33,6 +34,29 @@ export interface CursorRunStream {
close(): void;
}
+export interface CursorShellStreamExec {
+ id?: number;
+ execId?: string;
+ message?: { case?: string; value?: unknown };
+}
+
+export interface CursorShellStreamResult {
+ stdout?: string;
+ stderr?: string;
+ exitCode: number;
+ cwd?: string;
+ aborted?: boolean;
+ abortReason?: string;
+ localExecutionTimeMs?: number;
+}
+
+export type CursorAppendMessage = (messageJson: unknown) => Promise<void>;
+
+export type CursorShellStreamHandler = (
+ exec: CursorShellStreamExec,
+ append: CursorAppendMessage,
+) => Promise<void>;
+
export type CursorAgentMode = "AGENT_MODE_AGENT" | "AGENT_MODE_PLAN" | "AGENT_MODE_ASK";
export interface CursorModelRequest {
@@ -150,7 +174,7 @@ export async function runCursorAgent(opts: CursorRunOptions): Promise<ReadableSt
async transform(chunk, controller) {
opts.ctx.traffic?.writeBytes("030-cursor-run-response-chunk", chunk);
controller.enqueue(chunk);
- await processServerControlFrames(chunk, proto, append, opts.ctx, (text) => {
+ await processServerControlFrames(chunk, proto, append, opts.ctx, opts.shellStreamHandler, (text) => {
if (!text || controller.desiredSize === null) return;
try {
opts.ctx.traffic?.writeJsonEvent("038-cursor-tool-trace", { text });
@@ -329,6 +353,7 @@ async function processServerControlFrames(
proto: CursorProto,
append: (messageJson: unknown) => Promise<void>,
ctx?: RequestContext,
+ shellStreamHandler?: CursorShellStreamHandler,
emitTrace?: (text: string) => void,
): Promise<void> {
const state = controlFrameState.get(append) ?? {
@@ -367,7 +392,11 @@ async function processServerControlFrames(
await append({ execClientMessage: await buildGrepResult(oneof.value) });
await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
} else if (oneof.value?.message?.case === "shellStreamArgs") {
- await runShellStream(oneof.value, append, emitTrace);
+ if (shellStreamHandler) {
+ await shellStreamHandler(oneof.value, append);
+ } else {
+ await runShellStream(oneof.value, append, emitTrace);
+ }
}
} else if (oneof?.case === "kvServerMessage") {
const kv = oneof.value;
@@ -384,6 +413,20 @@ async function processServerControlFrames(
}
}
+export function cursorShellStreamArgs(exec: CursorShellStreamExec): {
+ command: string;
+ workingDirectory: string;
+ timeoutMs: number;
+} {
+ const args = asRecord(exec.message?.value);
+ const command = typeof args?.command === "string" ? args.command : "";
+ const workingDirectory = typeof args?.workingDirectory === "string" && args.workingDirectory
+ ? args.workingDirectory
+ : process.cwd();
+ const timeoutMs = typeof args?.timeout === "number" && args.timeout > 0 ? args.timeout : 30_000;
+ return { command, workingDirectory, timeoutMs };
+}
+
async function buildReadResult(exec: {
id?: number;
execId?: string;
@@ -427,12 +470,7 @@ async function runShellStream(
append: (messageJson: unknown) => Promise<void>,
emitTrace?: (text: string) => void,
): Promise<void> {
- const args = asRecord(exec.message?.value);
- const command = typeof args?.command === "string" ? args.command : "";
- const workingDirectory = typeof args?.workingDirectory === "string" && args.workingDirectory
- ? args.workingDirectory
- : process.cwd();
- const timeoutMs = typeof args?.timeout === "number" && args.timeout > 0 ? args.timeout : 30_000;
+ const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);
const started = Date.now();
let outputStarted = false;
const emitOutputTrace = (data: string) => {
@@ -499,6 +537,33 @@ async function runShellStream(
}
}
+export async function appendCursorShellStreamResult(
+ exec: CursorShellStreamExec,
+ result: CursorShellStreamResult,
+ append: CursorAppendMessage,
+): Promise<void> {
+ const cwd = result.cwd || cursorShellStreamArgs(exec).workingDirectory;
+ await append({ execClientMessage: buildShellStream(exec, { start: {} }) });
+ if (result.stdout) {
+ await append({ execClientMessage: buildShellStream(exec, { stdout: { data: result.stdout } }) });
+ }
+ if (result.stderr) {
+ await append({ execClientMessage: buildShellStream(exec, { stderr: { data: result.stderr } }) });
+ }
+ await append({
+ execClientMessage: buildShellStream(exec, {
+ exit: {
+ code: result.exitCode,
+ cwd,
+ aborted: Boolean(result.aborted),
+ ...(result.abortReason ? { abortReason: result.abortReason } : {}),
+ localExecutionTimeMs: result.localExecutionTimeMs ?? 0,
+ },
+ }),
+ });
+ await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
+}
+
async function appendShellOutput(
exec: { id?: number; execId?: string },
stream: ReadableStream<Uint8Array> | null,
diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.ts
index 745824d..10e6ea9 100644
--- a/src/providers/cursor/index.test.ts
+++ b/src/providers/cursor/index.test.ts
@@ -1,7 +1,7 @@
import { afterEach, describe, expect, it } from "bun:test";
import { cursorProvider, createCursorProvider } from "./index.ts";
import type { RequestContext } from "../types.ts";
-import { encodeConnectFrame } from "./client.ts";
+import { encodeConnectFrame, runCursorAgent } from "./client.ts";
import type { CursorProto, ProtoClass, ProtoMessage } from "./proto-loader.ts";
import { parseSseStream } from "../../sse.ts";
@@ -138,6 +138,129 @@ describe("Cursor provider messages", () => {
expect(body.error.message).toContain("resource_exhausted");
expect(body.error.message).toContain("free requests limit");
});
+
+ it("bridges Cursor shellStreamArgs through Claude Bash tool_use and resumes from tool_result", async () => {
+ let serverController!: ReadableStreamDefaultController<Uint8Array>;
+ const sentFrames: Array<Record<string, any>> = [];
+ let finalResponseSent = false;
+ const workingDirectory = "/tmp/cursor bridge cwd";
+ const serverReadable = new ReadableStream<Uint8Array>({
+ start(controller) {
+ serverController = controller;
+ queueMicrotask(() => {
+ controller.enqueue(frame({
+ message: {
+ case: "execServerMessage",
+ value: {
+ id: 11,
+ execId: "exec-shell",
+ message: {
+ case: "shellStreamArgs",
+ value: {
+ command: "printf should-not-run",
+ workingDirectory,
+ timeout: 5000,
+ },
+ },
+ },
+ },
+ }));
+ });
+ },
+ });
+ const provider = createCursorProvider({
+ loadAuth: async () => ({ accessToken: "token", source: "test" }),
+ runAgent: async (opts) =>
+ runCursorAgent({
+ ...opts,
+ proto: fakeProto,
+ openRunStream: async () => ({
+ readable: serverReadable,
+ status: Promise.resolve({ status: 200 }),
+ async write(frameBytes) {
+ const message = decodeFrameJson(frameBytes) as Record<string, any>;
+ sentFrames.push(message);
+ if (message.execClientMessage?.shellStream?.exit && !finalResponseSent) {
+ finalResponseSent = true;
+ serverController.enqueue(frame({
+ interactionUpdate: { textDelta: { text: "resumed after native shell" } },
+ }));
+ serverController.enqueue(frame({
+ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "3" } },
+ }));
+ serverController.close();
+ }
+ },
+ close() {},
+ }),
+ }),
+ proto: fakeProto,
+ });
+
+ const initial = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ tools: [{ name: "Bash", input_schema: { type: "object" } }],
+ messages: [{ role: "user", content: "run shell" }],
+ },
+ fakeCtx(),
+ );
+ const initialEvents = await collectSse(initial);
+ const toolStart = initialEvents.find((event) => event.event === "content_block_start"
+ && event.data.content_block?.type === "tool_use");
+
+ expect(toolStart?.data.content_block.name).toBe("Bash");
+ expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
+ const toolInputDelta = initialEvents.find((event) => event.event === "content_block_delta"
+ && event.data.delta?.type === "input_json_delta");
+ expect(JSON.parse(toolInputDelta?.data.delta.partial_json).command).toBe(
+ "cd '/tmp/cursor bridge cwd' && printf should-not-run",
+ );
+ expect(initialEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("tool_use");
+ expect(sentFrames.some((message) => message.execClientMessage?.shellStream?.stdout)).toBe(false);
+
+ const resume = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ messages: [
+ {
+ role: "assistant",
+ content: [{
+ type: "tool_use",
+ id: toolStart!.data.content_block.id,
+ name: "Bash",
+ input: { command: "printf should-not-run" },
+ }],
+ },
+ {
+ role: "user",
+ content: [{
+ type: "tool_result",
+ tool_use_id: toolStart!.data.content_block.id,
+ content: "native shell output",
+ is_error: false,
+ }],
+ },
+ ],
+ },
+ fakeCtx(),
+ );
+ const resumeEvents = await collectSse(resume);
+
+ expect(sentFrames.some((message) =>
+ message.execClientMessage?.shellStream?.stdout?.data === "native shell output"
+ )).toBe(true);
+ expect(sentFrames.some((message) =>
+ message.execClientMessage?.shellStream?.stdout?.data === "should-not-run"
+ )).toBe(false);
+ expect(resumeEvents.find((event) => event.event === "content_block_delta")?.data.delta.text).toBe(
+ "resumed after native shell",
+ );
+ expect(resumeEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("end_turn");
+ expect(resumeEvents.at(-1)?.event).toBe("message_stop");
+ });
});
function fakeCtx(): RequestContext {
@@ -157,6 +280,14 @@ function fakeCtx(): RequestContext {
};
}
+async function collectSse(response: Response): Promise<Array<{ event: string; data: any }>> {
+ const events = [];
+ for await (const event of parseSseStream(response.body!)) {
+ events.push({ event: event.event ?? "message", data: JSON.parse(event.data) });
+ }
+ return events;
+}
+
function jwt(payload: Record<string, unknown>): string {
return [
Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
@@ -185,14 +316,17 @@ function jsonProtoClass(): ProtoClass {
}
function messageFromJson(json: unknown): ProtoMessage {
- return {
- toBinary(): Uint8Array {
- return jsonBytes(json);
- },
- toJson(): unknown {
- return json;
+ return Object.assign(
+ {
+ toBinary(): Uint8Array {
+ return jsonBytes(json);
+ },
+ toJson(): unknown {
+ return json;
+ },
},
- };
+ json && typeof json === "object" && !Array.isArray(json) ? json : {},
+ );
}
function frame(json: unknown): Uint8Array {
@@ -203,6 +337,11 @@ function jsonBytes(json: unknown): Uint8Array {
return encoder.encode(JSON.stringify(json));
}
+function decodeFrameJson(frame: Uint8Array): unknown {
+ const len = Buffer.from(frame).readUInt32BE(1);
+ return JSON.parse(decoder.decode(frame.slice(5, 5 + len)));
+}
+
function streamFromChunks(chunks: Uint8Array[]): ReadableStream<Uint8Array> {
return new ReadableStream<Uint8Array>({
start(controller) {
diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.ts
index def68d7..15f58af 100644
--- a/src/providers/cursor/index.ts
+++ b/src/providers/cursor/index.ts
@@ -27,6 +27,11 @@ import {
cursorConversationForRequest,
recordCursorConversation,
} from "./session.ts";
+import {
+ canBridgeCursorShellTools,
+ createCursorShellToolBridge,
+ resumeCursorShellToolBridge,
+} from "./tool-bridge.ts";
import type { CursorAuth } from "./auth/token-store.ts";
import type { CursorProto } from "./proto-loader.ts";
@@ -56,6 +61,9 @@ async function handleMessages(
): Promise<Response> {
const log = ctx.childLogger("provider.cursor");
const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
+ const resumed = resumeCursorShellToolBridge(body, ctx, messageId);
+ if (resumed) return resumed;
+
const selection = resolveCursorModel(body);
const prompt = renderCursorPrompt(body);
const wantStream = wantsDownstreamStream(body);
@@ -78,6 +86,22 @@ async function handleMessages(
return jsonError(401, "authentication_error", expiredAuthMessage(auth));
}
+ const onSession = (cursorSessionId: string) => {
+ recordCursorConversation(ctx.sessionId, cursorSessionId);
+ log.debug("cursor session observed", { cursorSessionId });
+ };
+ const shellBridge = wantStream && ctx.sessionId && canBridgeCursorShellTools(body, ctx)
+ ? createCursorShellToolBridge({
+ sessionId: ctx.sessionId,
+ messageId,
+ model: body.model,
+ log: ctx.childLogger("cursor.bridge"),
+ traffic: ctx.traffic,
+ proto: deps.proto,
+ onSession,
+ })
+ : undefined;
+
let upstream: ReadableStream<Uint8Array>;
try {
upstream = await deps.runAgent({
@@ -87,6 +111,7 @@ async function handleMessages(
model: selection.requestedModel,
auth,
ctx,
+ shellStreamHandler: shellBridge?.shellStreamHandler,
});
} catch (err) {
if (err instanceof CursorError) {
@@ -101,13 +126,8 @@ async function handleMessages(
throw err;
}
- const onSession = (cursorSessionId: string) => {
- recordCursorConversation(ctx.sessionId, cursorSessionId);
- log.debug("cursor session observed", { cursorSessionId });
- };
-
if (wantStream) {
- const stream = translateCursorStream(upstream, {
+ const stream = shellBridge?.stream(upstream, ctx.signal) ?? translateCursorStream(upstream, {
messageId,
model: body.model,
log: ctx.childLogger("cursor.stream"),
diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.ts
new file mode 100644
index 0000000..4ca3a74
--- /dev/null
+++ b/src/providers/cursor/tool-bridge.ts
@@ -0,0 +1,397 @@
+import { encodeSseEvent } from "../../sse.ts";
+import type { AnthropicRequest, AnthropicToolResultBlock } from "../../anthropic/schema.ts";
+import type { Logger } from "../../log.ts";
+import type { RequestContext } from "../types.ts";
+import {
+ appendCursorShellStreamResult,
+ cursorShellStreamArgs,
+ decodeCursorStream,
+ type CursorAppendMessage,
+ type CursorShellStreamExec,
+ type CursorStreamEvent,
+ type CursorUsage,
+} from "./client.ts";
+import type { CursorProto } from "./proto-loader.ts";
+import { cursorUsageToAnthropic } from "./translate/response.ts";
+
+interface PendingShellTool {
+ toolUseId: string;
+ exec: CursorShellStreamExec;
+ command: string;
+ workingDirectory: string;
+ timeoutMs: number;
+ startedAt: number;
+ append: CursorAppendMessage;
+ resolve(result: ShellToolResult): void;
+ result: Promise<ShellToolResult>;
+}
+
+interface ShellToolResult {
+ content: string;
+ isError: boolean;
+}
+
+interface CursorBridgeState {
+ sessionId: string;
+ messageId: string;
+ model: string;
+ iterator: AsyncGenerator<CursorStreamEvent>;
+ pendingNext?: Promise<IteratorResult<CursorStreamEvent>>;
+ pendingTool?: PendingShellTool;
+ waiters: Array<(tool: PendingShellTool) => void>;
+ log: Logger;
+ traffic?: RequestContext["traffic"];
+ onSession?: (sessionId: string) => void;
+}
+
+const bridgeStates = new Map<string, CursorBridgeState>();
+
+export function canBridgeCursorShellTools(body: AnthropicRequest, ctx: RequestContext): boolean {
+ return Boolean(ctx.sessionId && body.stream && body.tools?.some((tool) => tool.name === "Bash"));
+}
+
+export function createCursorShellToolBridge(opts: {
+ sessionId: string;
+ messageId: string;
+ model: string;
+ log: Logger;
+ traffic?: RequestContext["traffic"];
+ proto?: CursorProto;
+ onSession?: (sessionId: string) => void;
+}): {
+ shellStreamHandler: (exec: CursorShellStreamExec, append: CursorAppendMessage) => Promise<void>;
+ stream: (upstream: ReadableStream<Uint8Array>, signal?: AbortSignal) => ReadableStream<Uint8Array>;
+} {
+ const state: CursorBridgeState = {
+ sessionId: opts.sessionId,
+ messageId: opts.messageId,
+ model: opts.model,
+ iterator: undefined as unknown as AsyncGenerator<CursorStreamEvent>,
+ waiters: [],
+ log: opts.log,
+ traffic: opts.traffic,
+ onSession: opts.onSession,
+ };
+
+ const notifyTool = (tool: PendingShellTool) => {
+ state.pendingTool = tool;
+ for (const waiter of state.waiters.splice(0)) waiter(tool);
+ };
+
+ return {
+ async shellStreamHandler(exec, append) {
+ const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);
+ const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;
+ let resolve!: (result: ShellToolResult) => void;
+ const result = new Promise<ShellToolResult>((r) => {
+ resolve = r;
+ });
+ const tool: PendingShellTool = {
+ toolUseId,
+ exec,
+ command,
+ workingDirectory,
+ timeoutMs,
+ startedAt: Date.now(),
+ append,
+ resolve,
+ result,
+ };
+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
+ toolUseId,
+ command,
+ workingDirectory,
+ timeoutMs,
+ });
+ notifyTool(tool);
+ const shellResult = await result;
+ await appendCursorShellStreamResult(
+ exec,
+ {
+ stdout: shellResult.isError ? undefined : shellResult.content,
+ stderr: shellResult.isError ? shellResult.content : undefined,
+ exitCode: shellResult.isError ? 1 : 0,
+ cwd: workingDirectory,
+ localExecutionTimeMs: Date.now() - tool.startedAt,
+ },
+ append,
+ );
+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
+ toolUseId,
+ isError: shellResult.isError,
+ contentChars: shellResult.content.length,
+ });
+ },
+ stream(upstream, signal) {
+ state.iterator = decodeCursorStream(upstream, opts.proto, {
+ traffic: opts.traffic,
+ log: opts.log,
+ });
+ bridgeStates.set(opts.sessionId, state);
+ return streamBridgeUntilToolOrEnd(state, signal);
+ },
+ };
+}
+
+export function resumeCursorShellToolBridge(
+ body: AnthropicRequest,
+ ctx: RequestContext,
+ messageId: string,
+): Response | undefined {
+ const sessionId = ctx.sessionId;
+ if (!sessionId) return undefined;
+ const state = bridgeStates.get(sessionId);
+ const tool = state?.pendingTool;
+ if (!state || !tool) return undefined;
+ const result = findToolResult(body, tool.toolUseId);
+ if (!result) return undefined;
+
+ state.pendingTool = undefined;
+ state.messageId = messageId;
+ state.model = body.model;
+ tool.resolve({
+ content: renderToolResultContent(result.content),
+ isError: Boolean(result.is_error),
+ });
+
+ const stream = streamBridgeUntilToolOrEnd(state, ctx.signal);
+ return new Response(stream, {
+ headers: {
+ "content-type": "text/event-stream",
+ "cache-control": "no-cache",
+ "connection": "keep-alive",
+ },
+ });
+}
+
+function streamBridgeUntilToolOrEnd(
+ state: CursorBridgeState,
+ signal?: AbortSignal,
+): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return new ReadableStream<Uint8Array>({
+ async start(controller) {
+ let closed = false;
+ let started = false;
+ let thinkingOpen = false;
+ let textOpen = false;
+ let nextIndex = 0;
+ let thinkingIndex = -1;
+ let textIndex = -1;
+ let finalUsage: CursorUsage | undefined;
+
+ const emit = (event: string, data: unknown) => {
+ if (closed || signal?.aborted || controller.desiredSize === null) return false;
+ state.traffic?.writeJsonEvent("050-downstream-event", { event, data });
+ controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
+ return true;
+ };
+
+ const ensureStart = () => {
+ if (started) return;
+ started = true;
+ emit("message_start", {
+ type: "message_start",
+ message: {
+ id: state.messageId,
+ type: "message",
+ role: "assistant",
+ model: state.model,
+ content: [],
+ stop_reason: null,
+ stop_sequence: null,
+ usage: {
+ input_tokens: 0,
+ output_tokens: 0,
+ cache_creation_input_tokens: 0,
+ cache_read_input_tokens: 0,
+ },
+ },
+ });
+ emit("ping", { type: "ping" });
+ };
+
+ const openThinking = () => {
+ if (thinkingOpen) return;
+ ensureStart();
+ thinkingOpen = true;
+ thinkingIndex = nextIndex++;
+ emit("content_block_start", {
+ type: "content_block_start",
+ index: thinkingIndex,
+ content_block: { type: "thinking", thinking: "", signature: "" },
+ });
+ };
+
+ const openText = () => {
+ if (textOpen) return;
+ ensureStart();
+ textOpen = true;
+ textIndex = nextIndex++;
+ emit("content_block_start", {
+ type: "content_block_start",
+ index: textIndex,
+ content_block: { type: "text", text: "" },
+ });
+ };
+
+ const closeOpenBlocks = () => {
+ if (thinkingOpen) {
+ emit("content_block_stop", { type: "content_block_stop", index: thinkingIndex });
+ thinkingOpen = false;
+ }
+ if (textOpen) {
+ emit("content_block_stop", { type: "content_block_stop", index: textIndex });
+ textOpen = false;
+ }
+ };
+
+ const emitToolUseAndPause = (tool: PendingShellTool) => {
+ closeOpenBlocks();
+ ensureStart();
+ const index = nextIndex++;
+ const input = JSON.stringify({
+ command: claudeBashCommand(tool),
+ timeout: tool.timeoutMs,
+ description: "Run Cursor-requested shell command",
+ run_in_background: false,
+ dangerouslyDisableSandbox: false,
+ });
+ emit("content_block_start", {
+ type: "content_block_start",
+ index,
+ content_block: {
+ type: "tool_use",
+ id: tool.toolUseId,
+ name: "Bash",
+ input: {},
+ },
+ });
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index,
+ delta: { type: "input_json_delta", partial_json: input },
+ });
+ emit("content_block_stop", { type: "content_block_stop", index });
+ emit("message_delta", {
+ type: "message_delta",
+ delta: { stop_reason: "tool_use", stop_sequence: null },
+ usage: cursorUsageToAnthropic(finalUsage),
+ });
+ emit("message_stop", { type: "message_stop" });
+ };
+
+ try {
+ while (!signal?.aborted) {
+ const next = state.pendingNext ?? state.iterator.next();
+ state.pendingNext = next;
+ const result = await Promise.race([
+ next.then((value) => ({ type: "event" as const, value })),
+ waitForPendingTool(state).then((tool) => ({ type: "tool" as const, tool })),
+ ]);
+
+ if (result.type === "tool") {
+ emitToolUseAndPause(result.tool);
+ return;
+ }
+
+ state.pendingNext = undefined;
+ if (result.value.done) break;
+ const event = result.value.value;
+ state.traffic?.writeJsonEvent("040-cursor-event", event);
+ switch (event.type) {
+ case "session":
+ state.onSession?.(event.sessionId);
+ break;
+ case "thinking_delta":
+ openThinking();
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index: thinkingIndex,
+ delta: { type: "thinking_delta", thinking: event.text },
+ });
+ break;
+ case "text_delta":
+ if (thinkingOpen) {
+ emit("content_block_stop", { type: "content_block_stop", index: thinkingIndex });
+ thinkingOpen = false;
+ }
+ openText();
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index: textIndex,
+ delta: { type: "text_delta", text: event.text },
+ });
+ break;
+ case "usage":
+ finalUsage = event.usage;
+ break;
+ case "end":
+ break;
+ }
+ }
+
+ ensureStart();
+ closeOpenBlocks();
+ emit("message_delta", {
+ type: "message_delta",
+ delta: { stop_reason: "end_turn", stop_sequence: null },
+ usage: cursorUsageToAnthropic(finalUsage),
+ });
+ emit("message_stop", { type: "message_stop" });
+ bridgeStates.delete(state.sessionId);
+ } catch (err) {
+ state.log.warn("cursor bridge stream error", { err: String(err) });
+ ensureStart();
+ closeOpenBlocks();
+ emit("error", {
+ type: "error",
+ error: { type: "api_error", message: String(err) },
+ });
+ bridgeStates.delete(state.sessionId);
+ } finally {
+ closed = true;
+ try {
+ controller.close();
+ } catch {}
+ }
+ },
+ });
+}
+
+function waitForPendingTool(state: CursorBridgeState): Promise<PendingShellTool> {
+ if (state.pendingTool) return Promise.resolve(state.pendingTool);
+ return new Promise((resolve) => state.waiters.push(resolve));
+}
+
+function findToolResult(body: AnthropicRequest, toolUseId: string): AnthropicToolResultBlock | undefined {
+ for (let i = body.messages.length - 1; i >= 0; i--) {
+ const message = body.messages[i];
+ if (!message || message.role !== "user" || typeof message.content === "string") continue;
+ for (const block of message.content) {
+ if (block.type === "tool_result" && block.tool_use_id === toolUseId) return block;
+ }
+ }
+ return undefined;
+}
+
+function renderToolResultContent(content: AnthropicToolResultBlock["content"]): string {
+ if (typeof content === "string") return content;
+ return content
+ .map((block) => {
+ if (block.type === "text") return block.text;
+ if (block.type === "image") return "[image result omitted]";
+ if (block.type === "thinking") return block.thinking;
+ return JSON.stringify(block);
+ })
+ .join("\n");
+}
+
+function claudeBashCommand(tool: PendingShellTool): string {
+ if (!tool.workingDirectory || tool.workingDirectory === process.cwd()) return tool.command;
+ return `cd ${shellQuote(tool.workingDirectory)} && ${tool.command}`;
+}
+
+function shellQuote(value: string): string {
+ return `'${value.replaceAll("'", "'\\''")}'`;
+}