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.tsindex 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<ReadableStasync 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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("'", "'\\''")}'`;+}