@evanovation/open-cursor 2.4.15

package/src/provider.ts

@@ -0,0 +1,268 @@
+import { SimpleCursorClient } from "./client/simple.js";
+import { createProxyServer } from "./proxy/server.js";
+import { parseOpenAIRequest } from "./proxy/handler.js";
+import { createChatCompletionResponse, createChatCompletionChunk } from "./proxy/formatter.js";
+import { StreamToAiSdkParts } from "./streaming/ai-sdk-parts.js";
+import { ToolMapper, type ToolUpdate } from "./acp/tools.js";
+
+export interface ProviderOptions {
+  baseURL?: string;
+  apiKey?: string;
+  mode?: 'direct' | 'proxy';
+  proxyConfig?: { port?: number; host?: string };
+  toolUpdateCallback?: (updates: ToolUpdate[]) => void;
+  sessionId?: string;
+}
+
+/**
+ * Creates a Cursor ACP provider compatible with OpenCode
+ * Exports a factory function for @ai-sdk/provider compatibility
+ */
+export function createCursorProvider(options: ProviderOptions = {}) {
+  const providerOptions = options;
+  const mode = options.mode || 'direct';
+
+  if (mode === 'proxy') {
+    // Start proxy server
+    const proxy = createProxyServer(options.proxyConfig || {});
+    let baseURL: string = options.baseURL ?? proxy.getBaseURL();
+
+    // Create the provider object
+    const provider = {
+      id: "cursor-acp",
+      name: "Cursor ACP Provider (Proxy Mode)",
+      proxy,
+      baseURL: '',
+
+      /**
+       * Initialize the provider (starts the proxy server)
+       */
+      async init(): Promise<any> {
+        baseURL = await proxy.start();
+        this.baseURL = baseURL;
+        return this;
+      },
+
+      /**
+       * Returns a language model for the given model ID
+       */
+      languageModel(modelId: string = "cursor-acp/auto") {
+        const model = modelId.replace("cursor-acp/", "") || "auto";
+
+        return {
+          modelId,
+          provider: "cursor-acp",
+
+          /**
+           * Generate text (non-streaming)
+           */
+          async doGenerate({ prompt, messages }: any) {
+            // Use HTTP API
+            const response = await fetch(`${baseURL}/chat/completions`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: modelId,
+                messages: messages || [{ role: "user", content: prompt }],
+                stream: false
+              })
+            });
+
+            const result: any = await response.json();
+            return {
+              text: result.choices?.[0]?.message?.content || "",
+              finishReason: "stop",
+              usage: result.usage
+            };
+          },
+
+          /**
+           * Stream text
+           */
+          async doStream({ prompt, messages }: any) {
+            const response = await fetch(`${baseURL}/chat/completions`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: modelId,
+                messages: messages || [{ role: "user", content: prompt }],
+                stream: true
+              })
+            });
+
+            return {
+              stream: response.body,
+              rawResponse: { headers: Object.fromEntries(response.headers) }
+            };
+          }
+        };
+      }
+    };
+
+    return provider;
+  }
+
+  // Direct mode - existing implementation
+  const client = new SimpleCursorClient({
+    timeout: 30000,
+    maxRetries: 3
+  });
+
+  return {
+    id: "cursor-acp",
+    name: "Cursor ACP Provider",
+
+    /**
+     * Returns a language model for the given model ID
+     */
+    languageModel(modelId: string = "cursor-acp/auto") {
+      const model = modelId.replace("cursor-acp/", "") || "auto";
+
+      return {
+        modelId,
+        provider: "cursor-acp",
+
+        /**
+         * Generate text (non-streaming)
+         */
+        async doGenerate(options: any = {}) {
+          // Handle both direct prompt and OpenAI-style messages format
+          let prompt = "";
+
+          // Try to extract prompt from various sources
+          if (options.prompt) {
+            // OpenCode passes prompt as array of messages
+            if (Array.isArray(options.prompt)) {
+              const lines = [];
+              for (const msg of options.prompt) {
+                if (msg && typeof msg.content === 'string') {
+                  lines.push(`${msg.role || 'user'}: ${msg.content}`);
+                }
+              }
+              prompt = lines.join('\n\n');
+            } else if (typeof options.prompt === 'string') {
+              prompt = options.prompt;
+            }
+          } else if (options.inputFormat === "messages" && options.messages) {
+            // OpenAI-style messages format
+            const messages = Array.isArray(options.messages) ? options.messages : [];
+            const lines = [];
+            for (const msg of messages) {
+              if (msg && typeof msg.content === 'string') {
+                lines.push(`${msg.role || 'user'}: ${msg.content}`);
+              }
+            }
+            prompt = lines.join('\n\n');
+          } else if (options.messages) {
+            // Alternative format
+            const messages = Array.isArray(options.messages) ? options.messages : [];
+            prompt = messages.map((m: any) => m?.content || '').filter(Boolean).join('\n\n');
+          }
+
+          // Fallback for empty prompt
+          if (!prompt) {
+            prompt = "Hello";
+          }
+
+          const result = await client.executePrompt(prompt, { model });
+
+          return {
+            text: result.content || result.error || "No response",
+            finishReason: result.done ? "stop" : "other",
+            usage: {
+              promptTokens: 0,
+              completionTokens: 0
+            }
+          };
+        },
+
+        /**
+         * Stream text - returns a proper ReadableStream for pipeThrough support
+         */
+        async doStream(options: any = {}) {
+          // Handle both direct prompt and OpenAI-style messages format
+          let prompt = "";
+
+          // Try to extract prompt from various sources
+          if (options.prompt) {
+            // OpenCode passes prompt as array of messages
+            if (Array.isArray(options.prompt)) {
+              const lines = [];
+              for (const msg of options.prompt) {
+                if (msg && typeof msg.content === 'string') {
+                  lines.push(`${msg.role || 'user'}: ${msg.content}`);
+                }
+              }
+              prompt = lines.join('\n\n');
+            } else if (typeof options.prompt === 'string') {
+              prompt = options.prompt;
+            }
+          } else if (options.inputFormat === "messages" && options.messages) {
+            // OpenAI-style messages format
+            const messages = Array.isArray(options.messages) ? options.messages : [];
+            const lines = [];
+            for (const msg of messages) {
+              if (msg && typeof msg.content === 'string') {
+                lines.push(`${msg.role || 'user'}: ${msg.content}`);
+              }
+            }
+            prompt = lines.join('\n\n');
+          } else if (options.messages) {
+            // Alternative format
+            const messages = Array.isArray(options.messages) ? options.messages : [];
+            prompt = messages.map((m: any) => m?.content || '').filter(Boolean).join('\n\n');
+          }
+
+          // Fallback for empty prompt
+          if (!prompt) {
+            prompt = "Hello";
+          }
+
+          const stream = client.executePromptStream(prompt, { model });
+          const converter = new StreamToAiSdkParts();
+          const toolMapper = providerOptions.toolUpdateCallback ? new ToolMapper() : null;
+          const toolSessionId = providerOptions.sessionId
+            ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+          // Create a proper ReadableStream that OpenCode can use with pipeThrough
+          const readableStream = new ReadableStream({
+            async start(controller) {
+              try {
+                for await (const event of stream) {
+                  if (toolMapper && event.type === "tool_call") {
+                    const updates = await toolMapper.mapCursorEventToAcp(
+                      event,
+                      event.session_id ?? toolSessionId,
+                    );
+                    if (updates.length > 0) {
+                      providerOptions.toolUpdateCallback?.(updates);
+                    }
+                  }
+                  const parts = converter.handleEvent(event);
+                  for (const part of parts) {
+                    controller.enqueue(part);
+                  }
+                }
+                controller.enqueue({ type: "text-delta", textDelta: "" });
+                controller.close();
+              } catch (error) {
+                controller.error(error);
+              }
+            },
+          });
+
+          return {
+            stream: readableStream,
+            rawResponse: { headers: {} }
+          };
+        }
+      };
+    }
+  };
+}
+
+// Factory function export for OpenCode compatibility
+export const cursor = createCursorProvider;
+
+// Default export
+export default createCursorProvider;

package/src/proxy/formatter.ts

@@ -0,0 +1,60 @@
+import type { OpenAiUsage } from "../usage.js";
+
+export function createChatCompletionResponse(
+  model: string,
+  content: string,
+  usage?: OpenAiUsage,
+) {
+  const response: {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+      index: number;
+      message: { role: string; content: string };
+      finish_reason: string;
+    }>;
+    usage?: OpenAiUsage;
+  } = {
+    id: `cursor-acp-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: `cursor-acp/${model}`,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content },
+        finish_reason: "stop",
+      }
+    ],
+  };
+
+  if (usage) {
+    response.usage = usage;
+  }
+
+  return response;
+}
+
+export function createChatCompletionChunk(
+  id: string,
+  created: number,
+  model: string,
+  deltaContent: string,
+  done = false,
+) {
+  return {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: `cursor-acp/${model}`,
+    choices: [
+      {
+        index: 0,
+        delta: deltaContent ? { content: deltaContent } : {},
+        finish_reason: done ? "stop" : null,
+      }
+    ],
+  };
+}

package/src/proxy/handler.ts

@@ -0,0 +1,29 @@
+export interface ParsedRequest {
+  model: string;
+  prompt: string;
+  stream: boolean;
+  tools?: any[];
+}
+
+export function parseOpenAIRequest(body: any): ParsedRequest {
+  const model = body.model?.replace("cursor-acp/", "") || "auto";
+  const stream = body.stream === true;
+
+  // Convert messages array to prompt string
+  let prompt = "";
+  if (Array.isArray(body.messages)) {
+    const lines = body.messages.map((msg: any) => {
+      const role = msg.role?.toUpperCase() || "USER";
+      const content = typeof msg.content === "string" ? msg.content : "";
+      return `${role}: ${content}`;
+    });
+    prompt = lines.join("\n\n");
+  }
+
+  return {
+    model,
+    prompt,
+    stream,
+    tools: body.tools
+  };
+}

package/src/proxy/incremental-prompt.ts

@@ -0,0 +1,74 @@
+/**
+ * Build a delta prompt for cursor-agent --resume sessions.
+ * When resuming, cursor-agent already holds conversation state — only send
+ * the new turn content instead of replaying the full flattened history.
+ */
+
+type TextContentPart = { type: "text"; text: string };
+type ImageContentPart = { type: "image_url"; image_url: { url: string } };
+export type ContentPart = TextContentPart | ImageContentPart | Record<string, unknown>;
+
+export type ProxyMessage = {
+  role: string;
+  content?: string | ContentPart[] | unknown;
+  tool_call_id?: string;
+  tool_calls?: Array<{
+    id?: string;
+    function?: { name?: string; arguments?: string };
+  }>;
+};
+
+/**
+ * Extract text from a message content value that may be a plain string or an
+ * array of content parts. Non-text parts (images, audio, etc.) are ignored.
+ */
+export function extractTextContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => (part?.type === "text" && typeof part.text === "string" ? part.text : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+/**
+ * Returns prompt text for a resumed session. Falls back to null when delta
+ * mode cannot be determined safely (caller should use full prompt builder).
+ */
+export function buildIncrementalPrompt(messages: Array<ProxyMessage>): string | null {
+  if (messages.length === 0) return null;
+
+  const last = messages[messages.length - 1];
+
+  // Tool-loop continuation: last messages are tool results
+  if (last?.role === "tool") {
+    const lines: string[] = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (m?.role !== "tool") break;
+      const callId = m.tool_call_id || "unknown";
+      const body = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
+      lines.unshift(`TOOL_RESULT (call_id: ${callId}): ${body}`);
+    }
+    // Defensive: loop always unshifts at least once, so this is unreachable today.
+    if (lines.length === 0) return null;
+    lines.push("The above tool calls have been executed. Continue your response based on these results.");
+    return lines.join("\n\n");
+  }
+
+  // Normal follow-up: latest user message only
+  if (last?.role === "user") {
+    const text = extractTextContent(last.content);
+    if (!text.trim()) return null;
+    // Mixed multimodal follow-ups must fall back to the full prompt so image/audio
+    // parts are not silently dropped.
+    if (Array.isArray(last.content) && last.content.some((part) => part?.type && part.type !== "text")) {
+      return null;
+    }
+    return text.trim();
+  }
+
+  return null;
+}

package/src/proxy/prompt-builder.ts

@@ -0,0 +1,204 @@
+import { createHash } from "node:crypto";
+import { createLogger } from "../utils/logger.js";
+
+const log = createLogger("proxy:prompt-builder");
+
+// Cache the tool schema block — tools don't change between requests in a session.
+let _cachedToolFingerprint = "";
+let _cachedToolBlock = "";
+
+/** Clear cached tool schema block (for testing only). */
+export function _resetToolSchemaCache(): void {
+  _cachedToolFingerprint = "";
+  _cachedToolBlock = "";
+}
+
+/** Short, collision-resistant digest used in the tool schema fingerprint. */
+function shortHash(value: string): string {
+  return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+
+/** Build a compact fingerprint of the tool schema for cache validation. */
+export function buildToolFingerprint(tools: Array<any>): string {
+  if (tools.length === 0) return "";
+  // Include names + descriptions + parameter names + required fields to detect
+  // schema changes without the cost of full JSON.stringify on every request.
+  // The description is hashed (not length-only) so edits that preserve length
+  // still invalidate the cache; required is copied before sorting so the
+  // caller's schema array is not mutated in place.
+  const parts = tools.map((t: any) => {
+    const fn = t.function || t;
+    const name = fn.name || "?";
+    const desc = fn.description || "";
+    const paramProps = fn.parameters?.properties || {};
+    const paramKeys = Object.keys(paramProps).sort().join(",");
+    const required = [...(fn.parameters?.required || [])].sort().join(",");
+    return `${name}:${shortHash(desc)}:${paramKeys}:${required}`;
+  });
+  parts.sort();
+  return `${parts.length}:${parts.join("|")}`;
+}
+
+function buildToolSchemaBlock(tools: Array<any>): string {
+  const fingerprint = buildToolFingerprint(tools);
+  if (fingerprint && fingerprint === _cachedToolFingerprint) {
+    return _cachedToolBlock;
+  }
+
+  const toolDescs = tools
+    .map((t: any) => {
+      const fn = t.function || t;
+      const name = fn.name || "unknown";
+      const desc = fn.description || "";
+      const params = fn.parameters;
+      const paramStr = params ? JSON.stringify(params) : "{}";
+      return `- ${name}: ${desc}\n  Parameters: ${paramStr}`;
+    })
+    .join("\n");
+
+  const block =
+    `SYSTEM: You have access to the following tools. When you need to use one, respond with a tool_call in the standard OpenAI format.\n` +
+    `Tool guidance: prefer write/edit for file changes; use bash mainly to run commands/tests.\n\nAvailable tools:\n${toolDescs}`;
+
+  if (fingerprint) {
+    _cachedToolFingerprint = fingerprint;
+    _cachedToolBlock = block;
+  }
+
+  return block;
+}
+
+/**
+ * Build a text prompt from OpenAI chat messages + tool definitions.
+ * Handles role:"tool" result messages and assistant tool_calls that
+ * plain text flattening would silently drop.
+ */
+export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>, subagentNames: string[] = []): string {
+  if (log.isDebugEnabled()) {
+    const messageSummary = messages.map((m: any, i: number) => {
+      const role = m?.role ?? "?";
+      const hasToolCalls = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
+      const tcNames = hasToolCalls > 0 ? m.tool_calls.map((tc: any) => tc?.function?.name).join(",") : "";
+      const contentType = typeof m?.content;
+      const contentLen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr:${m.content.length}` : "null";
+      const toolCallId = m?.tool_call_id ?? null;
+      return { i, role, hasToolCalls, tcNames, contentType, contentLen, toolCallId };
+    });
+
+    const assistantWithToolCalls = messages.filter((m: any) => m?.role === "assistant" && Array.isArray(m?.tool_calls) && m.tool_calls.length > 0);
+    const assistantEmpty = messages.filter((m: any) => m?.role === "assistant" && (!m?.tool_calls || m.tool_calls.length === 0) && (!m?.content || m.content === "" || m.content === null));
+    const toolResults = messages.filter((m: any) => m?.role === "tool");
+
+    log.debug("buildPromptFromMessages", {
+      totalMessages: messages.length,
+      totalTools: tools.length,
+      messageSummary,
+      stats: {
+        assistantWithToolCalls: assistantWithToolCalls.length,
+        assistantEmpty: assistantEmpty.length,
+        toolResults: toolResults.length,
+      },
+      assistantDetails: assistantWithToolCalls.length > 0 ? assistantWithToolCalls.map((m: any, i: number) => ({
+        index: i,
+        toolCallCount: Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0,
+        toolCallIds: Array.isArray(m?.tool_calls) ? m.tool_calls.map((tc: any) => tc?.id).join(",") : "",
+        toolCallNames: Array.isArray(m?.tool_calls) ? m.tool_calls.map((tc: any) => tc?.function?.name).join(",") : "",
+        contentType: typeof m?.content,
+        contentPreview: typeof m?.content === "string" ? m.content.slice(0, 50) : typeof m?.content,
+      })) : [],
+      emptyAssistantDetails: assistantEmpty.length > 0 ? assistantEmpty.map((m: any, i: number) => ({
+        index: i,
+        contentType: typeof m?.content,
+        contentPreview: typeof m?.content === "string" ? m.content.slice(0, 50) : typeof m?.content,
+      })) : [],
+      toolResultDetails: toolResults.length > 0 ? toolResults.map((m: any, i: number) => ({
+        index: i,
+        toolCallId: m?.tool_call_id,
+        contentPreview: typeof m?.content === "string" ? m.content.slice(0, 100) : typeof m?.content,
+      })) : [],
+    });
+  }
+
+  const lines: string[] = [];
+
+  if (tools.length > 0) {
+    lines.push(buildToolSchemaBlock(tools));
+    const hasTaskTool = tools.some((t: any) => {
+      const name = (t?.function?.name ?? t?.name ?? "").toLowerCase();
+      return name === "task";
+    });
+    if (hasTaskTool && subagentNames.length > 0) {
+      lines.push(
+        `When calling the task tool, set subagent_type to one of: ${subagentNames.join(", ")}. Do not omit this parameter.`
+      );
+    }
+  }
+
+  for (const message of messages) {
+    const role = typeof message.role === "string" ? message.role : "user";
+
+    // tool result messages (from multi-turn tool execution loop)
+    if (role === "tool") {
+      const callId = message.tool_call_id || "unknown";
+      const body =
+        typeof message.content === "string"
+          ? message.content
+          : JSON.stringify(message.content ?? "");
+      lines.push(`TOOL_RESULT (call_id: ${callId}): ${body}`);
+      continue;
+    }
+
+    // assistant messages that contain tool_calls (previous turn's tool invocations)
+    if (
+      role === "assistant" &&
+      Array.isArray(message.tool_calls) &&
+      message.tool_calls.length > 0
+    ) {
+      const tcTexts = message.tool_calls.map((tc: any) => {
+        const fn = tc.function || {};
+        return `tool_call(id: ${tc.id || "?"}, name: ${fn.name || "?"}, args: ${fn.arguments || "{}"})`;
+      });
+      const text = typeof message.content === "string" ? message.content : "";
+      lines.push(`ASSISTANT: ${text ? text + "\n" : ""}${tcTexts.join("\n")}`);
+      continue;
+    }
+
+    // standard text messages
+    const content = message.content;
+    if (typeof content === "string") {
+      lines.push(`${role.toUpperCase()}: ${content}`);
+    } else if (Array.isArray(content)) {
+      const textParts = content
+        .map((part: any) => {
+          if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+            return part.text;
+          }
+          return "";
+        })
+        .filter(Boolean);
+      if (textParts.length) {
+        lines.push(`${role.toUpperCase()}: ${textParts.join("\n")}`);
+      }
+    }
+  }
+
+  // Add continuation suffix after tool results to anchor model on completed state
+  const hasToolResults = messages.some((m: any) => m?.role === "tool");
+  if (hasToolResults) {
+    lines.push(
+      "The above tool calls have been executed. Continue your response based on these results."
+    );
+  }
+
+  const finalPrompt = lines.join("\n\n");
+  log.debug("buildPromptFromMessages: final prompt", {
+    lineCount: lines.length,
+    promptLength: finalPrompt.length,
+    promptPreview: finalPrompt.slice(0, 500),
+    hasToolResultFormat: finalPrompt.includes("TOOL_RESULT"),
+    hasAssistantToolCallFormat: finalPrompt.includes("tool_call(id:"),
+    hasCompletionSignal: finalPrompt.includes("The above tool calls have been executed"),
+  });
+
+  return finalPrompt;
+}