cursor-opencode-provider 0.7.6 → 0.8.1

package/dist/protocol/tools.d.ts

@@ -1,3 +1,4 @@
+import type { CursorImageInput } from "../image-input.js";
 import { type CursorExecVariant } from "./exec-variants.js";
 import { type CursorShellOutcome } from "../shell-timeout.js";
 export declare const REQUEST_CONTEXT_RESULT_FIELD = 10;
@@ -8,6 +9,10 @@ export type OpencodeToolDef = {
     /** Original flattened identity when `name` is a Cursor-facing alias. */
     sourceName?: string;
 };
+/** Check explicit required keys after normalization, before host execution. */
+export declare function missingRequiredToolArguments(tool: OpencodeToolDef | undefined, args: Record<string, unknown>): string[];
+/** Canonical file/search tools must not silently ignore a misplaced shell command. */
+export declare function misplacedShellCommand(tool: OpencodeToolDef | undefined, args: Record<string, unknown>): boolean;
 /** Host file-tool argument key. OpenCode 1.x uses `filePath`; 2.0 uses `path`. */
 export type HostFilePathKey = "path" | "filePath";
 /** Host shell tool id. OpenCode 1.x uses `bash`; 2.0 uses `shell`. */
@@ -18,6 +23,7 @@ export type HostToolDialect = {
     filePathKey: HostFilePathKey;
     shellTool: HostShellTool;
     skillArgKey: HostSkillArgKey;
+    shellDescription?: "optional" | "required";
 };
 export declare const OPENCODE_1_TOOL_DIALECT: HostToolDialect;
 export declare const OPENCODE_2_TOOL_DIALECT: HostToolDialect;
@@ -61,7 +67,9 @@ export declare function sanitizeMcpServerId(value: string): string;
 export declare function resolveToolServerIdentity(opencodeName: string, defaultServer?: string, knownMcpServers?: Iterable<string>): ToolServerIdentity;
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
- * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
+ * entries for session exec remap / bridges. These are not sent on
+ * RequestContext.tools (#7) or AgentRunRequest.mcp_tools (both omitted/empty
+ * on the wire). Exec #36 still uses the same identity fields.
  *
  * Builtins and unknown plugin/custom tools are advertised under the synthetic
  * default server (`opencode`). Tools whose prefixes match configured MCP
@@ -79,12 +87,13 @@ export declare function toolsToDescriptors(tools: OpencodeToolDef[], providerIde
 export declare function buildCustomWebToolAliases(tools: OpencodeToolDef[]): AliasedToolCatalog;
 export declare function resolveCustomWebToolAlias(toolName: string, aliases: ToolAliasRegistry | undefined): string;
 /**
- * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
- * and unknown tools under the synthetic default; configured MCP tools under
- * their upstream server id).
+ * Nested MCP descriptors. Full name/description/schema is for exec #36.
+ * RequestContext `mcp_meta_tool_options` uses `{ namesOnly: true }` (`tool_name`
+ * only). File-system `mcp_descriptors` are omitted on the wire.
  */
-export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Array<Record<string, unknown>>;
+export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>, options?: {
+    namesOnly?: boolean;
+}): Array<Record<string, unknown>>;
 /**
  * @deprecated Prefer `buildRequestContext` from `../context/build.js`.
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
@@ -277,7 +286,16 @@ export type ToolResultInput = {
      * often $HOME and would re-advertise the wrong folder to the model.
      */
     workspaceRoot?: string;
+    /** Images the host tool returned; see `execResultImages` for which results carry them. */
+    images?: readonly CursorImageInput[];
 };
+/**
+ * The leading tool-result images an exec result can carry on a held Run.
+ * Cursor's own read executor answers an image file with its bytes in
+ * `ReadSuccess.data` (#5) and no text; its MCP executor appends each MCP image
+ * as an `McpImageContent` item (#2). Other result shapes have no image field.
+ */
+export declare function execResultImages(resultField: string, images: readonly CursorImageInput[] | undefined): CursorImageInput[];
 /**
  * Build one or more ExecClientMessage frames for a tool result.
  * Shell replies are a sequence of ShellStream oneofs under the same id —
@@ -318,7 +336,7 @@ export declare function unwrapReadOutput(output: string): string;
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export declare function buildTypedExecResult(resultField: string, output: string, error?: string, toolName?: string, resultMetadata?: Record<string, unknown>, shellOutcome?: CursorShellOutcome, workspaceRoot?: string): Record<string, unknown>;
+export declare function buildTypedExecResult(resultField: string, output: string, error?: string, toolName?: string, resultMetadata?: Record<string, unknown>, shellOutcome?: CursorShellOutcome, workspaceRoot?: string, images?: readonly CursorImageInput[]): Record<string, unknown>;
 export declare function buildToolCallPart(execMsg: ParsedExecRequest, sessionId: string): {
     toolCallId: string;
     toolName: string;
@@ -340,11 +358,15 @@ export declare function detectExecVariantField(agentServerPayload: Uint8Array):
  */
 export declare function buildRequestContextResult(execId: number, requestContext: Record<string, unknown>): Uint8Array;
 /**
- * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
- * in RequestContext. OpenCode remains the executor; this only confirms that the
- * provider's virtual MCP servers and their tools are available.
+ * Answer Cursor's exec #36 MCP-state probe from the session's live tool
+ * descriptors: `toolsToDescriptors` output for the advertised catalog (after
+ * web-tool aliasing), refreshed on every `doStream`. These are the same
+ * identities the names-only RequestContext advertises and exec remap uses, so
+ * Cursor's native get_mcp_tools can correlate the later
+ * provider_identifier/tool_name request. OpenCode remains the executor; this
+ * only confirms those tools are available, with full name/description/schema.
  */
-export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, requestContext: Record<string, unknown>): Uint8Array;
+export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, toolDescriptors: ReadonlyArray<Record<string, unknown>>): Uint8Array;
 /**
  * Total fallback for Cursor's native MCP-resource exec channel (agent.v1
  * fields #17/#18, tasks/plans/fix-cursor-mcp-resource-exec.md). Under Option B

package/dist/protocol/tools.js

@@ -9,10 +9,36 @@ import { trace, traceRequestContextPaths } from "../debug.js";
 import { cursorExecVariantByRequestName, FORCE_BACKGROUND_STATUS_ERROR, } from "./exec-variants.js";
 import { APPLY_PATCH_TOOL, buildAddFilePatch, buildUpdateFilePatch, planSubstringEdit, } from "./apply-patch.js";
 import { BACKGROUND_SHELL_MARKER, buildBackgroundShellCommand, } from "../shell-timeout.js";
+import { normalizeOpencodeQuestionArgs } from "./ask-question.js";
+import { normalizeOpencodeTodoArgs } from "../todo-store.js";
 // Exec variant field number whose reply is the server-initiated request_context
 // probe (ExecServerMessage #10 → ExecClientMessage #10). request/result share a
 // field number for every exec variant, so this is also the result field.
 export const REQUEST_CONTEXT_RESULT_FIELD = 10;
+/** Check explicit required keys after normalization, before host execution. */
+export function missingRequiredToolArguments(tool, args) {
+    const schema = tool?.inputSchema;
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return [];
+    const required = schema.required;
+    if (!Array.isArray(required))
+        return [];
+    return required.filter((key) => typeof key === "string" && (!Object.hasOwn(args, key) || args[key] === undefined));
+}
+/** Canonical file/search tools must not silently ignore a misplaced shell command. */
+export function misplacedShellCommand(tool, args) {
+    if (!tool || args.command === undefined)
+        return false;
+    if (!["read", "write", "edit", "grep", "glob", "ls"].includes(tool.name))
+        return false;
+    const schema = tool.inputSchema;
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return false;
+    const properties = schema.properties;
+    if (!properties || typeof properties !== "object" || Array.isArray(properties))
+        return false;
+    return !Object.hasOwn(properties, "command");
+}
 export const OPENCODE_1_TOOL_DIALECT = {
     filePathKey: "filePath",
     shellTool: "bash",
@@ -88,7 +114,20 @@ export function hostToolDialectFromTools(tools, defaultDialect = OPENCODE_1_TOOL
             ? "id"
             : defaultDialect.skillArgKey;
     }
-    return { filePathKey, shellTool, skillArgKey };
+    const shellSchema = tools.find((tool) => tool.name === shellTool)?.inputSchema;
+    const shellProps = jsonSchemaProperties(shellSchema);
+    const description = shellProps?.description;
+    const required = shellSchema && typeof shellSchema === "object" && !Array.isArray(shellSchema)
+        ? shellSchema.required
+        : undefined;
+    return {
+        filePathKey, shellTool, skillArgKey,
+        ...(description && typeof description === "object"
+            && description.type === "string"
+            ? { shellDescription: Array.isArray(required) && required.includes("description")
+                    ? "required" : "optional" }
+            : {}),
+    };
 }
 function assignHostFilePath(args, filePath, dialect) {
     delete args.filePath;
@@ -132,7 +171,9 @@ export function resolveToolServerIdentity(opencodeName, defaultServer = "opencod
 }
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
- * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
+ * entries for session exec remap / bridges. These are not sent on
+ * RequestContext.tools (#7) or AgentRunRequest.mcp_tools (both omitted/empty
+ * on the wire). Exec #36 still uses the same identity fields.
  *
  * Builtins and unknown plugin/custom tools are advertised under the synthetic
  * default server (`opencode`). Tools whose prefixes match configured MCP
@@ -249,15 +290,15 @@ export function resolveCustomWebToolAlias(toolName, aliases) {
     return toolName;
 }
 /**
- * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
- * and unknown tools under the synthetic default; configured MCP tools under
- * their upstream server id).
+ * Nested MCP descriptors. Full name/description/schema is for exec #36.
+ * RequestContext `mcp_meta_tool_options` uses `{ namesOnly: true }` (`tool_name`
+ * only). File-system `mcp_descriptors` are omitted on the wire.
  */
-export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
+export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = [], options) {
     if (tools.length === 0)
         return [];
     const byServer = new Map();
+    const namesOnly = options?.namesOnly === true;
     // Walk advertised order: first-seen server, then append tools onto that
     // server. Same-set host reorder is resolved by `resolveTurnToolState`
     // before encode so this walk stays epoch-stable.
@@ -268,11 +309,14 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
             list = [];
             byServer.set(id.server, list);
         }
-        list.push({
-            tool_name: t.sourceName ? t.name : id.toolName,
-            description: t.description ?? "",
-            input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
-        });
+        const toolName = t.sourceName ? t.name : id.toolName;
+        list.push(namesOnly
+            ? { tool_name: toolName }
+            : {
+                tool_name: toolName,
+                description: t.description ?? "",
+                input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
+            });
     }
     return [...byServer.keys()].map((server) => ({
         server_name: server,
@@ -285,20 +329,17 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
  */
 export function buildLiveRequestContext(tools, providerIdentifier = "opencode", knownMcpServers = []) {
-    const flat = toolsToDescriptors(tools, providerIdentifier, knownMcpServers);
-    const nested = toolsToMcpDescriptors(tools, providerIdentifier, knownMcpServers);
+    const slim = toolsToMcpDescriptors(tools, providerIdentifier, knownMcpServers, { namesOnly: true });
     const cwd = process.cwd();
     const ctx = {
         env: buildEnv(cwd),
-        tools: flat,
         mcp_file_system_options: {
             enabled: true,
             workspace_project_dir: ensureOpencodeProjectDir(cwd),
-            mcp_descriptors: nested,
         },
         mcp_meta_tool_options: {
             enabled: true,
-            mcp_descriptors: nested,
+            ...(slim.length > 0 ? { mcp_descriptors: slim } : {}),
         },
         web_search_enabled: false,
         web_fetch_enabled: false,
@@ -1161,10 +1202,9 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OP
     // as any other bash tool call.
     if (execVariant === "delete_args") {
         const target = str(cleaned.path) ?? str(cleaned.filePath);
-        return {
-            toolName: dialect.shellTool,
-            args: target ? { command: `rm -f -- ${shellQuote(target)}` } : { command: "true" },
-        };
+        return mapCursorArgsToOpencode(dialect.shellTool, {
+            command: target ? `rm -f -- ${shellQuote(target)}` : "true",
+        }, undefined, dialect);
     }
     switch (toolName) {
         case "read": {
@@ -1235,6 +1275,14 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OP
             const command = str(cleaned.command);
             if (command)
                 args.command = command;
+            if (dialect.shellDescription) {
+                const description = str(cleaned.description)
+                    ?? (dialect.shellDescription === "required" && command
+                        ? `Run: ${command.length > 60 ? `${command.slice(0, 57)}...` : command}`
+                        : undefined);
+                if (description)
+                    args.description = description;
+            }
             const workdir = str(cleaned.workdir) ?? str(cleaned.working_directory);
             if (workdir)
                 args.workdir = workdir;
@@ -1286,6 +1334,22 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OP
                 args[dialect.skillArgKey] = value;
             return { toolName: "skill", args };
         }
+        case "todowrite": {
+            // OpenCode requires `priority` on every todo item. Cursor TodoWrite /
+            // model MCP calls often omit it; fill host defaults before validation.
+            return {
+                toolName: "todowrite",
+                args: normalizeOpencodeTodoArgs(cleaned),
+            };
+        }
+        case "question": {
+            // OpenCode requires `header` on every question. Model MCP calls often
+            // omit it (AskQuestion bridge already fills it); default before validation.
+            return {
+                toolName: "question",
+                args: normalizeOpencodeQuestionArgs(cleaned),
+            };
+        }
         default:
             return { toolName, args: cleaned };
     }
@@ -1537,6 +1601,24 @@ export function buildReadRejectionMessages(execId, readResult) {
         buildExecStreamClose(execId),
     ];
 }
+/**
+ * The leading tool-result images an exec result can carry on a held Run.
+ * Cursor's own read executor answers an image file with its bytes in
+ * `ReadSuccess.data` (#5) and no text; its MCP executor appends each MCP image
+ * as an `McpImageContent` item (#2). Other result shapes have no image field.
+ */
+export function execResultImages(resultField, images) {
+    if (!images?.length)
+        return [];
+    if (resultField === "read_result")
+        return [images[0]];
+    if (resultField === "mcp_result")
+        return [...images];
+    return [];
+}
+function mcpImageItems(images) {
+    return images.map((image) => ({ image: { data: image.data, mime_type: image.mimeType } }));
+}
 /**
  * Build one or more ExecClientMessage frames for a tool result.
  * Shell replies are a sequence of ShellStream oneofs under the same id —
@@ -1592,7 +1674,7 @@ export function buildExecClientMessages(input) {
             id: input.execId,
             local_execution_time_ms: input.executionTimeMs ?? 0,
         };
-        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error, input.toolName, input.resultMetadata, input.shellOutcome, input.workspaceRoot);
+        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error, input.toolName, input.resultMetadata, input.shellOutcome, input.workspaceRoot, execResultImages(resultField, input.images));
         frames.push(encodeMessage("AgentClientMessage", {
             exec_client_message: clientMsg,
         }));
@@ -2461,7 +2543,7 @@ export function unwrapReadOutput(output) {
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export function buildTypedExecResult(resultField, output, error, toolName, resultMetadata, shellOutcome, workspaceRoot) {
+export function buildTypedExecResult(resultField, output, error, toolName, resultMetadata, shellOutcome, workspaceRoot, images = []) {
     // Prefer the session workspace; never advertise the host process cwd (daemon
     // often starts in $HOME) as the path Cursor shows the model for glob/ls.
     const trimmedRoot = typeof workspaceRoot === "string" ? workspaceRoot.trim() : "";
@@ -2481,6 +2563,18 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             const readPath = resolveToolPath(rawPath, resultRoot);
             if (error)
                 return { error: { path: readPath, error } };
+            const image = images[0];
+            if (image) {
+                return {
+                    success: {
+                        path: readPath,
+                        data: image.data,
+                        total_lines: 0,
+                        file_size: readFileSize(readPath) || image.data.length,
+                        truncated: false,
+                    },
+                };
+            }
             // The host may have resolved an alternate spelling after the request
             // (for example a Unicode-space filename). Use the result's own path for
             // local stat/newline recovery while preserving the requested path in the
@@ -2748,18 +2842,20 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             if (toolName === "grep" || toolName === "glob") {
                 return {
                     success: {
-                        content: [{ text: { text: groundSearchOutput(output, resultRoot) } }],
+                        content: [{ text: { text: groundSearchOutput(output, resultRoot) } }, ...mcpImageItems(images)],
                         is_error: false,
                     },
                 };
             }
             if (toolName !== "read") {
-                return { success: { content: [{ text: { text: output } }], is_error: false } };
+                return {
+                    success: { content: [{ text: { text: output } }, ...mcpImageItems(images)], is_error: false },
+                };
             }
             const listing = parseOpenCode2DirectoryListing(output, resultRoot);
             if (listing) {
                 return {
-                    success: { content: [{ text: { text: listing.text } }], is_error: false },
+                    success: { content: [{ text: { text: listing.text } }, ...mcpImageItems(images)], is_error: false },
                 };
             }
             // Carry the truncation notice as its own content item: the file content
@@ -2773,6 +2869,7 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
                     content: [
                         { text: { text: unwrapReadOutput(output) } },
                         ...notices.map((notice) => ({ text: { text: notice } })),
+                        ...mcpImageItems(images),
                     ],
                     is_error: false,
                 },
@@ -3196,41 +3293,52 @@ export function buildRequestContextResult(execId, requestContext) {
     });
 }
 /**
- * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
- * in RequestContext. OpenCode remains the executor; this only confirms that the
- * provider's virtual MCP servers and their tools are available.
+ * Answer Cursor's exec #36 MCP-state probe from the session's live tool
+ * descriptors: `toolsToDescriptors` output for the advertised catalog (after
+ * web-tool aliasing), refreshed on every `doStream`. These are the same
+ * identities the names-only RequestContext advertises and exec remap uses, so
+ * Cursor's native get_mcp_tools can correlate the later
+ * provider_identifier/tool_name request. OpenCode remains the executor; this
+ * only confirms those tools are available, with full name/description/schema.
  */
-export function buildMcpStateResult(execId, args, requestContext) {
+export function buildMcpStateResult(execId, args, toolDescriptors) {
     const requested = new Set(Array.isArray(args.server_identifiers)
         ? args.server_identifiers.filter((id) => typeof id === "string" && id.length > 0)
         : []);
-    const fsOptions = recordValue(requestContext.mcp_file_system_options);
-    const nested = Array.isArray(fsOptions?.mcp_descriptors)
-        ? fsOptions.mcp_descriptors.map(recordValue).filter((d) => !!d)
-        : [];
-    const descriptors = nested.length > 0 ? nested : descriptorsFromFlatTools(requestContext.tools);
-    const flatTools = Array.isArray(requestContext.tools)
-        ? requestContext.tools.map(recordValue).filter((tool) => !!tool)
-        : [];
-    const servers = descriptors
-        .filter((descriptor) => {
-        const id = stringValue(descriptor.server_identifier);
-        return requested.size === 0 || (id !== undefined && requested.has(id));
-    })
-        .map((descriptor) => {
-        const serverIdentifier = stringValue(descriptor.server_identifier) ?? stringValue(descriptor.server_name) ?? "";
-        const tools = Array.isArray(descriptor.tools)
-            ? descriptor.tools
-                .map(recordValue)
-                .filter((tool) => !!tool)
-                .map((tool) => mcpStateToolDefinition(serverIdentifier, tool, flatTools))
-            : [];
-        return {
-            server_name: stringValue(descriptor.server_name) ?? serverIdentifier,
-            server_identifier: serverIdentifier,
-            tools,
-        };
-    });
+    // Group in advertised order: first-seen server, then its tools.
+    const byServer = new Map();
+    for (const tool of toolDescriptors) {
+        const server = stringValue(tool.provider_identifier);
+        const toolName = stringValue(tool.tool_name);
+        if (!server || !toolName)
+            continue;
+        if (requested.size > 0 && !requested.has(server))
+            continue;
+        let list = byServer.get(server);
+        if (!list) {
+            list = [];
+            byServer.set(server, list);
+        }
+        list.push({
+            name: stringValue(tool.name) ?? `${server}-${toolName}`,
+            // GetDynamicTools exposes the inner schema without the outer call identity.
+            // Keep the exact identity in the definition, including truncated searches.
+            description: `CallDynamicTool identity: ${JSON.stringify({ namespace: server, toolName })}. `
+                + `Complete outer envelope: ${JSON.stringify({ namespace: server, toolName, arguments: {} })}. `
+                + "Replace arguments with this inputSchema's object; keep both identity fields outside it. "
+                + "Write namespace and toolName FIRST, then arguments containing this inputSchema's object. "
+                + "All three outer fields are required on every invocation.\n\n"
+                + (stringValue(tool.description) ?? ""),
+            input_schema: tool.input_schema,
+            provider_identifier: server,
+            tool_name: toolName,
+        });
+    }
+    const servers = [...byServer].map(([server, tools]) => ({
+        server_name: server,
+        server_identifier: server,
+        tools,
+    }));
     return encodeMessage("AgentClientMessage", {
         exec_client_message: {
             id: execId,
@@ -3238,24 +3346,6 @@ export function buildMcpStateResult(execId, args, requestContext) {
         },
     });
 }
-/**
- * Exec #36 uses McpToolDefinition, not the narrower McpToolDescriptor used by
- * RequestContext's filesystem/meta-tool catalogs. Rehydrate the full identity
- * from RequestContext.tools so Cursor's native get_mcp_tools can correlate the
- * discovered definition with the later provider_identifier/tool_name request.
- */
-function mcpStateToolDefinition(serverIdentifier, descriptor, flatTools) {
-    const toolName = stringValue(descriptor.tool_name) ?? "";
-    const advertised = flatTools.find((tool) => stringValue(tool.provider_identifier) === serverIdentifier
-        && stringValue(tool.tool_name) === toolName);
-    return {
-        name: stringValue(advertised?.name) ?? `${serverIdentifier}-${toolName}`,
-        description: stringValue(advertised?.description) ?? stringValue(descriptor.description) ?? "",
-        input_schema: advertised?.input_schema ?? descriptor.input_schema,
-        provider_identifier: serverIdentifier,
-        tool_name: toolName,
-    };
-}
 /**
  * Total fallback for Cursor's native MCP-resource exec channel (agent.v1
  * fields #17/#18, tasks/plans/fix-cursor-mcp-resource-exec.md). Under Option B
@@ -3285,31 +3375,3 @@ export function buildReadMcpResourceFallback(execId, server, uri) {
         },
     });
 }
-function recordValue(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function descriptorsFromFlatTools(value) {
-    if (!Array.isArray(value))
-        return [];
-    const byServer = new Map();
-    for (const raw of value) {
-        const tool = recordValue(raw);
-        if (!tool)
-            continue;
-        const server = stringValue(tool.provider_identifier) ?? "opencode";
-        const tools = byServer.get(server) ?? [];
-        tools.push({
-            tool_name: stringValue(tool.tool_name) ?? stringValue(tool.name) ?? "",
-            description: stringValue(tool.description) ?? "",
-            input_schema: tool.input_schema,
-        });
-        byServer.set(server, tools);
-    }
-    return [...byServer].map(([server, tools]) => ({
-        server_name: server,
-        server_identifier: server,
-        tools,
-    }));
-}

package/dist/protocol/turn-provenance.d.ts

@@ -0,0 +1,52 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+/** Mirrors MAX_TURN_STATE_SESSIONS; evicted sessions re-hydrate from disk. */
+export declare const MAX_PROVENANCE_SESSIONS = 256;
+export type TurnProvenance = {
+    conversationId: string;
+    /** Tool call ids emitted in the latest non-empty step. */
+    toolCallIds: string[];
+    /** Whitespace-free text emitted in the latest non-empty step (first 4 KiB). */
+    text: string;
+    /**
+     * Whitespace-free reasoning and text of the same step in emission order
+     * (first 4 KiB). OpenCode 1.x replays a previous model's reasoning as text
+     * parts after a model switch (`session/message-v2.ts` `differentModel`), and
+     * OpenCode 2 does the same for an assistant message that ended in error.
+     */
+    textWithReasoning: string;
+};
+export type ForeignHistoryReason = "foreign-assistant";
+/**
+ * Mark the start of one host step (one doStream). The previous step stays
+ * recorded until this one emits content, because hosts drop empty assistant
+ * turns from history.
+ */
+export declare function beginEmittedStep(sessionKey: string, conversationId: string): void;
+/** Record one stream part this provider handed to the host. */
+export declare function recordEmittedPart(sessionKey: string, conversationId: string, part: {
+    type: string;
+    delta?: unknown;
+    toolCallId?: unknown;
+}): void;
+/**
+ * Bind provenance to the conversation a Run was opened on. A reminted
+ * conversation starts with an empty record, so it never inherits the previous
+ * conversation's steps.
+ */
+export declare function trackTurnProvenance(sessionKey: string, conversationId: string): void;
+export declare function getTurnProvenance(sessionKey: string): TurnProvenance | undefined;
+export declare function restoreTurnProvenance(sessionKey: string, value: TurnProvenance): void;
+export declare function resetTurnProvenanceForTests(): void;
+export declare function serializeTurnProvenance(value: TurnProvenance): string;
+export declare function parseTurnProvenance(raw: string): TurnProvenance | undefined;
+/**
+ * Decide whether the host history moved past this Cursor conversation.
+ * Returns undefined when there is no evidence either way (no record for this
+ * conversation, or no assistant turn yet), so unknown state never forces a
+ * rebase.
+ */
+export declare function detectForeignHistory(input: {
+    sessionKey: string | undefined;
+    conversationId: string;
+    prompt: LanguageModelV3CallOptions["prompt"];
+}): ForeignHistoryReason | undefined;