@playwo/opencode-cursor-oauth 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,306 +1,2 @@
-import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
-import { configurePluginLogger, errorDetails, logPluginError, logPluginWarn } from "./logger";
-import { getCursorModels } from "./models";
-import { startProxy, stopProxy, } from "./proxy";
-const CURSOR_PROVIDER_ID = "cursor";
-let lastModelDiscoveryError = null;
-/**
- * OpenCode plugin that provides Cursor authentication and model access.
- * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
- */
-export const CursorAuthPlugin = async (input) => {
-    configurePluginLogger(input);
-    return {
-        auth: {
-            provider: CURSOR_PROVIDER_ID,
-            async loader(getAuth, provider) {
-                try {
-                    const auth = await getAuth();
-                    if (!auth || auth.type !== "oauth")
-                        return {};
-                    // Ensure we have a valid access token, refreshing if expired
-                    let accessToken = auth.access;
-                    if (!accessToken || auth.expires < Date.now()) {
-                        const refreshed = await refreshCursorToken(auth.refresh);
-                        await input.client.auth.set({
-                            path: { id: CURSOR_PROVIDER_ID },
-                            body: {
-                                type: "oauth",
-                                refresh: refreshed.refresh,
-                                access: refreshed.access,
-                                expires: refreshed.expires,
-                            },
-                        });
-                        accessToken = refreshed.access;
-                    }
-                    let models;
-                    models = await getCursorModels(accessToken);
-                    lastModelDiscoveryError = null;
-                    const port = await startProxy(async () => {
-                        const currentAuth = await getAuth();
-                        if (currentAuth.type !== "oauth") {
-                            const authError = new Error("Cursor auth not configured");
-                            logPluginError("Cursor proxy access token lookup failed", {
-                                stage: "proxy_access_token",
-                                ...errorDetails(authError),
-                            });
-                            throw authError;
-                        }
-                        if (!currentAuth.access || currentAuth.expires < Date.now()) {
-                            const refreshed = await refreshCursorToken(currentAuth.refresh);
-                            await input.client.auth.set({
-                                path: { id: CURSOR_PROVIDER_ID },
-                                body: {
-                                    type: "oauth",
-                                    refresh: refreshed.refresh,
-                                    access: refreshed.access,
-                                    expires: refreshed.expires,
-                                },
-                            });
-                            return refreshed.access;
-                        }
-                        return currentAuth.access;
-                    }, models);
-                    if (provider) {
-                        provider.models = buildCursorProviderModels(models, port);
-                    }
-                    return {
-                        baseURL: `http://localhost:${port}/v1`,
-                        apiKey: "cursor-proxy",
-                        async fetch(requestInput, init) {
-                            if (init?.headers) {
-                                if (init.headers instanceof Headers) {
-                                    init.headers.delete("authorization");
-                                }
-                                else if (Array.isArray(init.headers)) {
-                                    init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
-                                }
-                                else {
-                                    delete init.headers["authorization"];
-                                    delete init.headers["Authorization"];
-                                }
-                            }
-                            return fetch(requestInput, init);
-                        },
-                    };
-                }
-                catch (error) {
-                    const message = error instanceof Error
-                        ? error.message
-                        : "Cursor model discovery failed.";
-                    logPluginError("Cursor auth loader failed", {
-                        stage: "loader",
-                        providerID: CURSOR_PROVIDER_ID,
-                        ...errorDetails(error),
-                    });
-                    stopProxy();
-                    if (provider) {
-                        provider.models = {};
-                    }
-                    if (message !== lastModelDiscoveryError) {
-                        lastModelDiscoveryError = message;
-                        await showDiscoveryFailureToast(input, message);
-                    }
-                    return buildDisabledProviderConfig(message);
-                }
-            },
-            methods: [
-                {
-                    type: "oauth",
-                    label: "Login with Cursor",
-                    async authorize() {
-                        const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
-                        return {
-                            url: loginUrl,
-                            instructions: "Complete login in your browser. This window will close automatically.",
-                            method: "auto",
-                            async callback() {
-                                const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
-                                return {
-                                    type: "success",
-                                    refresh: refreshToken,
-                                    access: accessToken,
-                                    expires: getTokenExpiry(accessToken),
-                                };
-                            },
-                        };
-                    },
-                },
-            ],
-        },
-        async "chat.headers"(incoming, output) {
-            if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
-                return;
-            output.headers["x-opencode-session-id"] = incoming.sessionID;
-            output.headers["x-session-id"] = incoming.sessionID;
-            if (incoming.agent) {
-                output.headers["x-opencode-agent"] = incoming.agent;
-            }
-        },
-    };
-};
-function buildCursorProviderModels(models, port) {
-    return Object.fromEntries(models.map((model) => [
-        model.id,
-        {
-            id: model.id,
-            providerID: CURSOR_PROVIDER_ID,
-            api: {
-                id: model.id,
-                url: `http://localhost:${port}/v1`,
-                npm: "@ai-sdk/openai-compatible",
-            },
-            name: model.name,
-            capabilities: {
-                temperature: true,
-                reasoning: model.reasoning,
-                attachment: false,
-                toolcall: true,
-                input: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                output: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                interleaved: false,
-            },
-            cost: estimateModelCost(model.id),
-            limit: {
-                context: model.contextWindow,
-                output: model.maxTokens,
-            },
-            status: "active",
-            options: {},
-            headers: {},
-            release_date: "",
-            variants: {},
-        },
-    ]));
-}
-async function showDiscoveryFailureToast(input, message) {
-    try {
-        await input.client.tui.showToast({
-            body: {
-                title: "Cursor plugin disabled",
-                message,
-                variant: "error",
-                duration: 8_000,
-            },
-        });
-    }
-    catch (error) {
-        logPluginWarn("Failed to display Cursor plugin toast", {
-            title: "Cursor plugin disabled",
-            message,
-            ...errorDetails(error),
-        });
-    }
-}
-function buildDisabledProviderConfig(message) {
-    return {
-        baseURL: "http://127.0.0.1/cursor-disabled/v1",
-        apiKey: "cursor-disabled",
-        async fetch() {
-            return new Response(JSON.stringify({
-                error: {
-                    message,
-                    type: "server_error",
-                    code: "cursor_model_discovery_failed",
-                },
-            }), {
-                status: 503,
-                headers: { "Content-Type": "application/json" },
-            });
-        },
-    };
-}
-// $/M token rates from cursor.com/docs/models-and-pricing
-const MODEL_COST_TABLE = {
-    // Anthropic
-    "claude-4-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4-sonnet-1m": { input: 6, output: 22.5, cache: { read: 0.6, write: 7.5 } },
-    "claude-4.5-haiku": { input: 1, output: 5, cache: { read: 0.1, write: 1.25 } },
-    "claude-4.5-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.5-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4.6-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.6-opus-fast": { input: 30, output: 150, cache: { read: 3, write: 37.5 } },
-    "claude-4.6-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    // Cursor
-    "composer-1": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "composer-1.5": { input: 3.5, output: 17.5, cache: { read: 0.35, write: 0 } },
-    "composer-2": { input: 0.5, output: 2.5, cache: { read: 0.2, write: 0 } },
-    "composer-2-fast": { input: 1.5, output: 7.5, cache: { read: 0.2, write: 0 } },
-    // Google
-    "gemini-2.5-flash": { input: 0.3, output: 2.5, cache: { read: 0.03, write: 0 } },
-    "gemini-3-flash": { input: 0.5, output: 3, cache: { read: 0.05, write: 0 } },
-    "gemini-3-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3-pro-image": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3.1-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    // OpenAI
-    "gpt-5": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5-fast": { input: 2.5, output: 20, cache: { read: 0.25, write: 0 } },
-    "gpt-5-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-max": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5.2": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.2-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.3-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.4": { input: 2.5, output: 15, cache: { read: 0.25, write: 0 } },
-    "gpt-5.4-mini": { input: 0.75, output: 4.5, cache: { read: 0.075, write: 0 } },
-    "gpt-5.4-nano": { input: 0.2, output: 1.25, cache: { read: 0.02, write: 0 } },
-    // xAI
-    "grok-4.20": { input: 2, output: 6, cache: { read: 0.2, write: 0 } },
-    // Moonshot
-    "kimi-k2.5": { input: 0.6, output: 3, cache: { read: 0.1, write: 0 } },
-};
-// Most-specific first
-const MODEL_COST_PATTERNS = [
-    { match: (id) => /claude.*opus.*fast/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus-fast"] },
-    { match: (id) => /claude.*opus/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus"] },
-    { match: (id) => /claude.*haiku/i.test(id), cost: MODEL_COST_TABLE["claude-4.5-haiku"] },
-    { match: (id) => /claude.*sonnet/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /claude/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /composer-?2/i.test(id), cost: MODEL_COST_TABLE["composer-2"] },
-    { match: (id) => /composer-?1\.5/i.test(id), cost: MODEL_COST_TABLE["composer-1.5"] },
-    { match: (id) => /composer/i.test(id), cost: MODEL_COST_TABLE["composer-1"] },
-    { match: (id) => /gpt-5\.4.*nano/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-nano"] },
-    { match: (id) => /gpt-5\.4.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-mini"] },
-    { match: (id) => /gpt-5\.4/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4"] },
-    { match: (id) => /gpt-5\.3/i.test(id), cost: MODEL_COST_TABLE["gpt-5.3-codex"] },
-    { match: (id) => /gpt-5\.2/i.test(id), cost: MODEL_COST_TABLE["gpt-5.2"] },
-    { match: (id) => /gpt-5\.1.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex-mini"] },
-    { match: (id) => /gpt-5\.1/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex"] },
-    { match: (id) => /gpt-5.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5-mini"] },
-    { match: (id) => /gpt-5.*fast/i.test(id), cost: MODEL_COST_TABLE["gpt-5-fast"] },
-    { match: (id) => /gpt-5/i.test(id), cost: MODEL_COST_TABLE["gpt-5"] },
-    { match: (id) => /gemini.*3\.1/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /gemini.*3.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-3-flash"] },
-    { match: (id) => /gemini.*3/i.test(id), cost: MODEL_COST_TABLE["gemini-3-pro"] },
-    { match: (id) => /gemini.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-2.5-flash"] },
-    { match: (id) => /gemini/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /grok/i.test(id), cost: MODEL_COST_TABLE["grok-4.20"] },
-    { match: (id) => /kimi/i.test(id), cost: MODEL_COST_TABLE["kimi-k2.5"] },
-];
-const DEFAULT_COST = { input: 3, output: 15, cache: { read: 0.3, write: 0 } };
-function estimateModelCost(modelId) {
-    const normalized = modelId.toLowerCase();
-    const exact = MODEL_COST_TABLE[normalized];
-    if (exact)
-        return exact;
-    const stripped = normalized.replace(/-(high|medium|low|preview|thinking|spark-preview)$/g, "");
-    const strippedMatch = MODEL_COST_TABLE[stripped];
-    if (strippedMatch)
-        return strippedMatch;
-    return MODEL_COST_PATTERNS.find((p) => p.match(normalized))?.cost ?? DEFAULT_COST;
-}
-export default CursorAuthPlugin;
+export { CursorAuthPlugin } from "./plugin/cursor-auth-plugin";
+export { CursorAuthPlugin as default } from "./plugin/cursor-auth-plugin";

package/dist/logger.d.ts

@@ -2,5 +2,6 @@ import type { PluginInput } from "@opencode-ai/plugin";
 export declare function configurePluginLogger(input: PluginInput): void;
 export declare function errorDetails(error: unknown): Record<string, unknown>;
 export declare function logPluginWarn(message: string, extra?: Record<string, unknown>): void;
+export declare function logPluginInfo(message: string, extra?: Record<string, unknown>): void;
 export declare function logPluginError(message: string, extra?: Record<string, unknown>): void;
 export declare function flushPluginLogs(): Promise<void>;

package/dist/logger.js

@@ -27,6 +27,9 @@ export function errorDetails(error) {
 export function logPluginWarn(message, extra = {}) {
     logPlugin("warn", message, extra);
 }
+export function logPluginInfo(message, extra = {}) {
+    logPlugin("info", message, extra);
+}
 export function logPluginError(message, extra = {}) {
     logPlugin("error", message, extra);
 }
@@ -103,7 +106,9 @@ function serializeValue(value, depth, seen = new WeakSet()) {
     if (Array.isArray(value)) {
         if (depth >= 3)
             return `[array(${value.length})]`;
-        return value.slice(0, MAX_ARRAY_LENGTH).map((entry) => serializeValue(entry, depth + 1, seen));
+        return value
+            .slice(0, MAX_ARRAY_LENGTH)
+            .map((entry) => serializeValue(entry, depth + 1, seen));
     }
     if (typeof value === "object") {
         if (seen.has(value))
@@ -113,7 +118,10 @@ function serializeValue(value, depth, seen = new WeakSet()) {
             return `[object ${value.constructor?.name || "Object"}]`;
         }
         const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
-        return Object.fromEntries(entries.map(([key, entry]) => [key, serializeValue(entry, depth + 1, seen)]));
+        return Object.fromEntries(entries.map(([key, entry]) => [
+            key,
+            serializeValue(entry, depth + 1, seen),
+        ]));
     }
     return String(value);
 }

package/dist/models.js

@@ -1,7 +1,7 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { z } from "zod";
+import { callCursorUnaryRpc, decodeConnectUnaryBody } from "./cursor";
 import { errorDetails, logPluginError, logPluginWarn } from "./logger";
-import { callCursorUnaryRpc } from "./proxy";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, } from "./proto/agent_pb";
 const GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
@@ -138,28 +138,6 @@ function decodeGetUsableModelsResponse(payload) {
         }
     }
 }
-function decodeConnectUnaryBody(payload) {
-    if (payload.length < 5)
-        return null;
-    let offset = 0;
-    while (offset + 5 <= payload.length) {
-        const flags = payload[offset];
-        const view = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset);
-        const messageLength = view.getUint32(1, false);
-        const frameEnd = offset + 5 + messageLength;
-        if (frameEnd > payload.length)
-            return null;
-        // Compression flag
-        if ((flags & 0b0000_0001) !== 0)
-            return null;
-        // End-of-stream flag — skip trailer frames
-        if ((flags & 0b0000_0010) === 0) {
-            return payload.subarray(offset + 5, frameEnd);
-        }
-        offset = frameEnd;
-    }
-    return null;
-}
 function normalizeCursorModels(models) {
     if (models.length === 0)
         return [];

package/dist/openai/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/index.js

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/messages.d.ts

@@ -0,0 +1,39 @@
+import type { ChatCompletionRequest, OpenAIMessage, OpenAIToolCall } from "./types";
+export interface ToolResultInfo {
+    toolCallId: string;
+    content: string;
+}
+interface ParsedMessages {
+    systemPrompt: string;
+    userText: string;
+    turns: Array<{
+        userText: string;
+        assistantText: string;
+    }>;
+    toolResults: ToolResultInfo[];
+    pendingAssistantSummary: string;
+    completedTurnsFingerprint: string;
+}
+/** Normalize OpenAI message content to a plain string. */
+export declare function textContent(content: OpenAIMessage["content"]): string;
+export declare function parseMessages(messages: OpenAIMessage[]): ParsedMessages;
+export declare function formatToolCallSummary(call: OpenAIToolCall): string;
+export declare function formatToolResultSummary(result: ToolResultInfo): string;
+export declare function buildCompletedTurnsFingerprint(systemPrompt: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>): string;
+export declare function buildToolResumePrompt(userText: string, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildInitialHandoffPrompt(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildTitleSourceText(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function detectTitleRequest(body: ChatCompletionRequest): {
+    matched: boolean;
+    reason: string;
+};
+export {};

package/dist/openai/messages.js

@@ -0,0 +1,228 @@
+import { createHash } from "node:crypto";
+import { OPENCODE_TITLE_REQUEST_MARKER } from "../constants";
+/** Normalize OpenAI message content to a plain string. */
+export function textContent(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join("\n");
+}
+export function parseMessages(messages) {
+    let systemPrompt = "You are a helpful assistant.";
+    // Collect system messages
+    const systemParts = messages
+        .filter((m) => m.role === "system")
+        .map((m) => textContent(m.content));
+    if (systemParts.length > 0) {
+        systemPrompt = systemParts.join("\n");
+    }
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    const parsedTurns = [];
+    let currentTurn;
+    for (const msg of nonSystem) {
+        if (msg.role === "user") {
+            if (currentTurn)
+                parsedTurns.push(currentTurn);
+            currentTurn = {
+                userText: textContent(msg.content),
+                segments: [],
+            };
+            continue;
+        }
+        if (!currentTurn) {
+            currentTurn = { userText: "", segments: [] };
+        }
+        if (msg.role === "assistant") {
+            const text = textContent(msg.content);
+            if (text) {
+                currentTurn.segments.push({ kind: "assistantText", text });
+            }
+            if (msg.tool_calls?.length) {
+                currentTurn.segments.push({
+                    kind: "assistantToolCalls",
+                    toolCalls: msg.tool_calls,
+                });
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            currentTurn.segments.push({
+                kind: "toolResult",
+                result: {
+                    toolCallId: msg.tool_call_id ?? "",
+                    content: textContent(msg.content),
+                },
+            });
+        }
+    }
+    if (currentTurn)
+        parsedTurns.push(currentTurn);
+    let userText = "";
+    let toolResults = [];
+    let pendingAssistantSummary = "";
+    let completedTurnStates = parsedTurns;
+    const lastTurn = parsedTurns.at(-1);
+    if (lastTurn) {
+        const trailingSegments = splitTrailingToolResults(lastTurn.segments);
+        const hasAssistantSummary = trailingSegments.base.length > 0;
+        if (trailingSegments.trailing.length > 0 && hasAssistantSummary) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+            toolResults = trailingSegments.trailing.map((segment) => segment.result);
+            pendingAssistantSummary = summarizeTurnSegments(trailingSegments.base);
+        }
+        else if (lastTurn.userText && lastTurn.segments.length === 0) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+        }
+        else if (lastTurn.userText && hasAssistantSummary) {
+            completedTurnStates = parsedTurns.slice(0, -1);
+            userText = lastTurn.userText;
+            pendingAssistantSummary = summarizeTurnSegments(lastTurn.segments);
+        }
+    }
+    const turns = completedTurnStates
+        .map((turn) => ({
+        userText: turn.userText,
+        assistantText: summarizeTurnSegments(turn.segments),
+    }))
+        .filter((turn) => turn.userText || turn.assistantText);
+    return {
+        systemPrompt,
+        userText,
+        turns,
+        toolResults,
+        pendingAssistantSummary,
+        completedTurnsFingerprint: buildCompletedTurnsFingerprint(systemPrompt, turns),
+    };
+}
+function splitTrailingToolResults(segments) {
+    let index = segments.length;
+    while (index > 0 && segments[index - 1]?.kind === "toolResult") {
+        index -= 1;
+    }
+    return {
+        base: segments.slice(0, index),
+        trailing: segments
+            .slice(index)
+            .filter((segment) => segment.kind === "toolResult"),
+    };
+}
+function summarizeTurnSegments(segments) {
+    const parts = [];
+    for (const segment of segments) {
+        if (segment.kind === "assistantText") {
+            const trimmed = segment.text.trim();
+            if (trimmed)
+                parts.push(trimmed);
+            continue;
+        }
+        if (segment.kind === "assistantToolCalls") {
+            const summary = segment.toolCalls.map(formatToolCallSummary).join("\n\n");
+            if (summary)
+                parts.push(summary);
+            continue;
+        }
+        parts.push(formatToolResultSummary(segment.result));
+    }
+    return parts.join("\n\n").trim();
+}
+export function formatToolCallSummary(call) {
+    const args = call.function.arguments?.trim();
+    return args
+        ? `[assistant requested tool ${call.function.name} id=${call.id}]\n${args}`
+        : `[assistant requested tool ${call.function.name} id=${call.id}]`;
+}
+export function formatToolResultSummary(result) {
+    const label = result.toolCallId
+        ? `[tool result id=${result.toolCallId}]`
+        : "[tool result]";
+    const content = result.content.trim();
+    return content ? `${label}\n${content}` : label;
+}
+export function buildCompletedTurnsFingerprint(systemPrompt, turns) {
+    return createHash("sha256")
+        .update(JSON.stringify({ systemPrompt, turns }))
+        .digest("hex");
+}
+export function buildToolResumePrompt(userText, pendingAssistantSummary, toolResults) {
+    const parts = [userText.trim()];
+    if (pendingAssistantSummary.trim()) {
+        parts.push(`[previous assistant tool activity]\n${pendingAssistantSummary.trim()}`);
+    }
+    if (toolResults.length > 0) {
+        parts.push(toolResults.map(formatToolResultSummary).join("\n\n"));
+    }
+    return parts.filter(Boolean).join("\n\n");
+}
+export function buildInitialHandoffPrompt(userText, turns, pendingAssistantSummary, toolResults) {
+    const transcript = turns.map((turn, index) => {
+        const sections = [`Turn ${index + 1}`];
+        if (turn.userText.trim())
+            sections.push(`User: ${turn.userText.trim()}`);
+        if (turn.assistantText.trim())
+            sections.push(`Assistant: ${turn.assistantText.trim()}`);
+        return sections.join("\n");
+    });
+    const inProgress = buildToolResumePrompt("", pendingAssistantSummary, toolResults).trim();
+    const history = [
+        ...transcript,
+        ...(inProgress ? [`In-progress turn\n${inProgress}`] : []),
+    ]
+        .join("\n\n")
+        .trim();
+    if (!history)
+        return userText;
+    return [
+        "[OpenCode session handoff]",
+        "You are continuing an existing session that previously ran on another provider/model.",
+        "Treat the transcript below as prior conversation history before answering the latest user message.",
+        "",
+        "<previous-session-transcript>",
+        history,
+        "</previous-session-transcript>",
+        "",
+        "Latest user message:",
+        userText.trim(),
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function buildTitleSourceText(userText, turns, pendingAssistantSummary, toolResults) {
+    const history = turns
+        .map((turn) => [
+        isTitleRequestMarker(turn.userText) ? "" : turn.userText.trim(),
+        turn.assistantText.trim(),
+    ]
+        .filter(Boolean)
+        .join("\n"))
+        .filter(Boolean);
+    if (pendingAssistantSummary.trim()) {
+        history.push(pendingAssistantSummary.trim());
+    }
+    if (toolResults.length > 0) {
+        history.push(toolResults.map(formatToolResultSummary).join("\n\n"));
+    }
+    if (userText.trim() && !isTitleRequestMarker(userText)) {
+        history.push(userText.trim());
+    }
+    return history.join("\n\n").trim();
+}
+export function detectTitleRequest(body) {
+    if ((body.tools?.length ?? 0) > 0) {
+        return { matched: false, reason: "tools-present" };
+    }
+    const firstNonSystem = body.messages.find((message) => message.role !== "system");
+    if (firstNonSystem?.role === "user" &&
+        isTitleRequestMarker(textContent(firstNonSystem.content))) {
+        return { matched: true, reason: "opencode-title-marker" };
+    }
+    return { matched: false, reason: "no-title-marker" };
+}
+function isTitleRequestMarker(text) {
+    return text.trim() === OPENCODE_TITLE_REQUEST_MARKER;
+}

package/dist/openai/tools.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolDefinition } from "../proto/agent_pb";
+import type { OpenAIToolDef } from "./types";
+export declare function selectToolsForChoice(tools: OpenAIToolDef[], toolChoice: unknown): OpenAIToolDef[];
+/** Convert OpenAI tool definitions to Cursor's MCP tool protobuf format. */
+export declare function buildMcpToolDefinitions(tools: OpenAIToolDef[]): McpToolDefinition[];
+/** Decode a map of MCP arg values. */
+export declare function decodeMcpArgsMap(args: Record<string, Uint8Array>): Record<string, unknown>;