yepanywhere 0.5.2 → 0.6.1

package/dist/sdk/providers/opencode.js

@@ -19,6 +19,8 @@ import { parseOpenCodeSSEEvent } from "../../../bundled/@yep-anywhere/shared/dis
 import { getLogger } from "../../logging/logger.js";
 import { whichCommand } from "../cli-detection.js";
 import { MessageQueue } from "../messageQueue.js";
+import { mapOpenCodeQuestionAnswers, normalizeOpenCodeTool, } from "./opencode-tools.js";
+import { getLocalGlmModelDescription, LOCAL_GLM_MODEL_PREFIX, parseOpenCodeModelSelection, parseOpenCodeModelVariants, } from "./opencode-models.js";
 const execAsync = promisify(exec);
 function execFileUtf8(file, args, options) {
     return new Promise((resolve, reject) => {
@@ -33,47 +35,14 @@ function execFileUtf8(file, args, options) {
 }
 /** Port counter for unique port assignment */
 let nextPort = 14100;
-const LOCAL_GLM_MODEL_PREFIX = "local-glm/";
-function getLocalGlmModelDescription(modelId) {
-    const servedModelName = modelId.slice(LOCAL_GLM_MODEL_PREFIX.length);
-    const vllmModelArg = servedModelName === "Qwen/Qwen3.6-27B"
-        ? "Qwen/Qwen3.6-27B-FP8"
-        : servedModelName;
-    const command = [
-        "pixi run vllm serve",
-        vllmModelArg,
-        "--served-model-name",
-        servedModelName,
-        "--tool-call-parser qwen3_coder",
-        "--reasoning-parser qwen3",
-        "--enable-auto-tool-choice",
-        "--port 8001",
-    ].join(" ");
-    return `Start matching vLLM server: ${command}`;
-}
 /**
  * Get next available port for OpenCode server.
  */
 function getNextPort() {
     return nextPort++;
 }
-function parseOpenCodeModelSelection(model) {
-    if (!model || model === "default" || model === "auto") {
-        return undefined;
-    }
-    const slashIndex = model.indexOf("/");
-    if (slashIndex <= 0 || slashIndex === model.length - 1) {
-        throw new Error(`OpenCode model must use provider/model format, got "${model}"`);
-    }
-    return {
-        providerID: model.slice(0, slashIndex),
-        modelID: model.slice(slashIndex + 1),
-    };
-}
 function isProcessStillAlive(process) {
-    return (!process.killed &&
-        process.exitCode === null &&
-        process.signalCode === null);
+    return (!process.killed && process.exitCode === null && process.signalCode === null);
 }
 function updateOpenCodeRuntimeEvent(runtime, event) {
     const now = new Date();
@@ -103,6 +72,9 @@ function getOpenCodeEventSessionId(event) {
             return event.properties.part.sessionID;
         case "message.part.delta":
             return event.properties.sessionID;
+        case "permission.asked":
+        case "question.asked":
+            return event.properties.sessionID;
         default:
             return undefined;
     }
@@ -116,14 +88,15 @@ export class OpenCodeProvider {
     name = "opencode";
     displayName = "OpenCode";
     supportsPermissionMode = false; // OpenCode has its own permission model
-    supportsThinkingToggle = false;
+    // OpenCode exposes per-model reasoning effort via model "variants"
+    // (low/medium/high/xhigh/max); the effort selector is gated per-model by
+    // ModelInfo.supportsEffort/supportedEffortLevels from getAvailableModels.
+    supportsThinkingToggle = true;
     supportsSlashCommands = false;
     supportsSteering = false;
     opencodePath;
-    timeout;
     constructor(config = {}) {
         this.opencodePath = config.opencodePath;
-        this.timeout = config.timeout ?? 300000; // 5 minutes default
     }
     /**
      * Check if the OpenCode CLI is installed.
@@ -173,14 +146,20 @@ export class OpenCodeProvider {
                 encoding: "utf-8",
                 timeout: 10000,
             });
+            // Best-effort: learn each model's reasoning-effort variants so the UI can
+            // offer an effort selector for models that support it (e.g. copilot opus).
+            const variantMap = await this.getModelVariantMap(opencodePath);
             const discoveredModels = [];
             for (const line of result.split("\n")) {
                 const trimmed = line.trim();
                 if (trimmed && !trimmed.startsWith("─")) {
-                    discoveredModels.push({
-                        id: trimmed,
-                        name: trimmed,
-                    });
+                    const model = { id: trimmed, name: trimmed };
+                    const effortLevels = variantMap.get(trimmed);
+                    if (effortLevels && effortLevels.length > 0) {
+                        model.supportsEffort = true;
+                        model.supportedEffortLevels = effortLevels;
+                    }
+                    discoveredModels.push(model);
                 }
             }
             const localGlmModels = discoveredModels
@@ -208,6 +187,20 @@ export class OpenCodeProvider {
             ];
         }
     }
+    /**
+     * Best-effort fetch of per-model reasoning-effort variants from
+     * `opencode models --verbose`. Returns an empty map on any failure so model
+     * discovery still works without effort metadata.
+     */
+    async getModelVariantMap(opencodePath) {
+        try {
+            const { stdout } = await execFileUtf8(opencodePath, ["models", "--verbose"], { encoding: "utf-8", timeout: 15000 });
+            return parseOpenCodeModelVariants(stdout);
+        }
+        catch {
+            return new Map();
+        }
+    }
     /**
      * Start a new OpenCode session.
      *
@@ -260,7 +253,10 @@ export class OpenCodeProvider {
             try {
                 const sessionResponse = await fetch(`${baseUrl}/session`, {
                     method: "POST",
-                    headers: { Accept: "application/json", "Content-Type": "application/json" },
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                    },
                     body: JSON.stringify({ title: "Yep Anywhere Session" }),
                 });
                 if (!sessionResponse.ok) {
@@ -296,6 +292,12 @@ export class OpenCodeProvider {
             iterator,
             queue,
             abort: () => abortController.abort(),
+            // Graceful turn interrupt: stop the in-flight turn via the server's own
+            // abort endpoint and keep the per-session `opencode serve` alive so the
+            // session can continue. (abort(), by contrast, ends the session by
+            // killing the server.) The SSE loop already treats the resulting
+            // session.idle as turn-complete.
+            interrupt: () => this.interruptTurn(runtime),
             isProcessAlive: () => isProcessStillAlive(serverProcess),
             probeLiveness: () => this.probeLiveness(runtime),
             getProviderActivity: () => this.getProviderActivity(runtime),
@@ -304,6 +306,29 @@ export class OpenCodeProvider {
             },
         };
     }
+    /**
+     * Stop the current OpenCode turn without killing the per-session server,
+     * via POST /session/:id/abort. Returns true when the request succeeds.
+     */
+    async interruptTurn(runtime) {
+        const log = getLogger();
+        try {
+            const response = await fetch(`${runtime.baseUrl}/session/${runtime.opencodeSessionId}/abort`, {
+                method: "POST",
+                headers: { Accept: "application/json" },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                log.warn({ status: response.status, sessionId: runtime.opencodeSessionId }, "OpenCode turn abort request failed");
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            log.warn({ error, sessionId: runtime.opencodeSessionId }, "OpenCode turn abort request errored");
+            return false;
+        }
+    }
     /**
      * Return a minimal AgentSession whose iterator immediately yields one error message.
      */
@@ -461,6 +486,7 @@ export class OpenCodeProvider {
                 if (signal.aborted)
                     break;
                 let userPrompt = this.extractTextFromMessage(message);
+                const imageParts = this.extractImageFileParts(message);
                 if (isFirstNewMessage && options.globalInstructions) {
                     userPrompt = `[Global context]\n${options.globalInstructions}\n\n---\n\n${userPrompt}`;
                 }
@@ -474,7 +500,7 @@ export class OpenCodeProvider {
                         content: userPrompt,
                     },
                 };
-                yield* this.sendMessageAndStream(runtime, sessionId, userPrompt, options.model, signal);
+                yield* this.sendMessageAndStream(runtime, sessionId, userPrompt, options.model, signal, options.onToolApproval, options.effort, imageParts);
             }
         }
         finally {
@@ -488,7 +514,7 @@ export class OpenCodeProvider {
     /**
      * Send a message to OpenCode and stream the response via SSE.
      */
-    async *sendMessageAndStream(runtime, sessionId, text, model, signal) {
+    async *sendMessageAndStream(runtime, sessionId, text, model, signal, onToolApproval, effort, imageParts = []) {
         const log = getLogger();
         let modelSelection;
         try {
@@ -505,12 +531,13 @@ export class OpenCodeProvider {
         const sseUrl = `${runtime.baseUrl}/event?directory=${encodeURIComponent(runtime.cwd)}`;
         const sseController = new AbortController();
         const streamState = {
-            currentAssistantMessageId: null,
             messageRolesById: new Map(),
             partMessageIdsById: new Map(),
             partTypesById: new Map(),
             partTextById: new Map(),
             partSentLengthsById: new Map(),
+            toolUseEmitted: new Set(),
+            toolResultEmitted: new Set(),
             sawAssistantContent: false,
             usedPostBodyFallback: false,
         };
@@ -564,17 +591,26 @@ export class OpenCodeProvider {
                             const messageEvent = event;
                             streamState.messageRolesById.set(messageEvent.properties.info.id, messageEvent.properties.info.role);
                         }
-                        // Convert to SDK message
-                        const sdkMessage = this.convertSSEEventToSDKMessage(event, sessionId, streamState);
-                        if (sdkMessage) {
+                        // Interactive prompts: route to YA's approval/question UI and POST
+                        // the reply back to opencode. Fire-and-forget so the SSE read loop
+                        // keeps draining (the tool's own progress/result events follow the
+                        // reply). The handlers never throw into the loop.
+                        if (event.type === "permission.asked") {
+                            void this.handlePermissionAsked(runtime, event, onToolApproval, signal);
+                            continue;
+                        }
+                        if (event.type === "question.asked") {
+                            void this.handleQuestionAsked(runtime, event, onToolApproval, signal);
+                            continue;
+                        }
+                        // Convert to SDK messages (a single unified tool part can yield
+                        // both a tool_use and a tool_result, so this is an array).
+                        const sdkMessages = this.convertSSEEventToSDKMessage(event, sessionId, streamState);
+                        for (const sdkMessage of sdkMessages) {
                             if (sdkMessage.type === "assistant") {
                                 if (streamState.usedPostBodyFallback) {
                                     continue;
                                 }
-                                if ("uuid" in sdkMessage && sdkMessage.uuid) {
-                                    streamState.currentAssistantMessageId =
-                                        sdkMessage.uuid;
-                                }
                                 streamState.sawAssistantContent = true;
                             }
                             state.eventBuffer.push(sdkMessage);
@@ -618,7 +654,12 @@ export class OpenCodeProvider {
                 },
                 body: JSON.stringify({
                     ...(modelSelection ? { model: modelSelection } : {}),
-                    parts: [{ type: "text", text }],
+                    // OpenCode selects reasoning effort by naming a model variant; the
+                    // variant keys (low/medium/high/xhigh/max) coincide with YA's
+                    // EffortLevel. Only sent when YA provides an effort (the UI gates
+                    // this to models advertised with supportedEffortLevels).
+                    ...(effort ? { variant: effort } : {}),
+                    parts: [{ type: "text", text }, ...imageParts],
                 }),
                 signal,
             });
@@ -626,7 +667,9 @@ export class OpenCodeProvider {
                 const errorText = await response.text();
                 throw new Error(`Failed to send message: ${response.status} ${errorText}`);
             }
-            const responsePayload = (await response.json().catch(() => null));
+            const responsePayload = (await response
+                .json()
+                .catch(() => null));
             if (!streamState.sawAssistantContent) {
                 const fallbackMessages = this.convertOpenCodeMessageResponseToSDKMessages(responsePayload, sessionId);
                 if (fallbackMessages.length > 0) {
@@ -690,6 +733,81 @@ export class OpenCodeProvider {
             session_id: sessionId,
         };
     }
+    /**
+     * Bridge an opencode permission request to YA's approval UI, then reply.
+     * allow -> "once", deny -> "reject". Never throws; on any failure or missing
+     * approver, reject so the gated tool does not hang.
+     */
+    async handlePermissionAsked(runtime, event, onToolApproval, signal) {
+        const log = getLogger();
+        const { id: requestId, permission, metadata } = event.properties;
+        let reply = "reject";
+        try {
+            if (onToolApproval) {
+                const { name, input } = normalizeOpenCodeTool(permission, metadata);
+                const result = await onToolApproval(name, input, { signal });
+                reply = result.behavior === "allow" ? "once" : "reject";
+            }
+        }
+        catch (error) {
+            log.warn({ error, requestId }, "OpenCode permission approval failed; rejecting");
+        }
+        await this.postOpenCodeReply(runtime, `/permission/${requestId}/reply`, { reply }, requestId);
+    }
+    /**
+     * Bridge an opencode interactive question to YA's AskUserQuestion UI, then
+     * reply with the selected option labels per question (or reject). The
+     * opencode question shape matches YA's AskUserQuestion input, so the existing
+     * pending-input UI handles it. Never throws.
+     */
+    async handleQuestionAsked(runtime, event, onToolApproval, signal) {
+        const log = getLogger();
+        const { id: requestId, questions } = event.properties;
+        try {
+            if (onToolApproval) {
+                const result = await onToolApproval("AskUserQuestion", { questions }, { signal });
+                if (result.behavior === "allow") {
+                    const answers = mapOpenCodeQuestionAnswers(questions, this.extractQuestionAnswers(result.updatedInput));
+                    await this.postOpenCodeReply(runtime, `/question/${requestId}/reply`, { answers }, requestId);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            log.warn({ error, requestId }, "OpenCode question handling failed; rejecting");
+        }
+        await this.postOpenCodeReply(runtime, `/question/${requestId}/reject`, {}, requestId);
+    }
+    extractQuestionAnswers(updatedInput) {
+        if (updatedInput &&
+            typeof updatedInput === "object" &&
+            "answers" in updatedInput) {
+            const answers = updatedInput.answers;
+            if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+                return answers;
+            }
+        }
+        return undefined;
+    }
+    async postOpenCodeReply(runtime, path, body, requestId) {
+        const log = getLogger();
+        try {
+            const response = await fetch(`${runtime.baseUrl}${path}`, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                log.warn({ requestId, status: response.status, path }, "OpenCode interactive reply failed");
+            }
+        }
+        catch (error) {
+            log.warn({ error, requestId, path }, "OpenCode interactive reply request errored");
+        }
+    }
     /**
      * Convert an OpenCode SSE event to an SDK message.
      */
@@ -709,14 +827,15 @@ export class OpenCodeProvider {
                     streamState.partMessageIdsById.get(deltaEvent.properties.partID);
                 const partType = streamState.partTypesById.get(deltaEvent.properties.partID);
                 if (!messageId || !partType || deltaEvent.properties.field !== "text") {
-                    return null;
+                    return [];
                 }
-                return this.convertTextLikePartToSDKMessage({
+                const message = this.convertTextLikePartToSDKMessage({
                     partId: deltaEvent.properties.partID,
                     messageId,
                     partType,
                     delta: deltaEvent.properties.delta,
                 }, sessionId, streamState, streamState.messageRolesById.get(messageId));
+                return message ? [message] : [];
             }
             case "session.idle":
             case "session.status":
@@ -725,9 +844,9 @@ export class OpenCodeProvider {
             case "message.updated":
             case "server.connected":
                 // These are status events, not content - skip
-                return null;
+                return [];
             default:
-                return null;
+                return [];
         }
     }
     convertTextLikePartToSDKMessage(part, sessionId, streamState, messageRole) {
@@ -750,7 +869,12 @@ export class OpenCodeProvider {
         return {
             type: "assistant",
             session_id: sessionId,
-            uuid: streamState.currentAssistantMessageId ?? part.messageId,
+            // Use the part's own OpenCode message id (== the durable message.id), so
+            // the streamed assistant uuid matches the persisted row and the client
+            // dedups by id instead of re-appending the backfilled copy. (Previously a
+            // carried-over "current" id could attribute a later message's parts to an
+            // earlier message, diverging from the durable id.)
+            uuid: part.messageId,
             message: {
                 role: "assistant",
                 content,
@@ -759,7 +883,7 @@ export class OpenCodeProvider {
     }
     convertOpenCodeMessageResponseToSDKMessages(response, sessionId) {
         const info = response?.info ?? response?.message;
-        if (!info || info.role !== "assistant" || !Array.isArray(response?.parts)) {
+        if (info?.role !== "assistant" || !Array.isArray(response?.parts)) {
             return [];
         }
         const contentBlocks = [];
@@ -797,70 +921,145 @@ export class OpenCodeProvider {
     convertPartToSDKMessage(part, sessionId, delta, streamState, messageRole) {
         switch (part.type) {
             case "text":
-            case "reasoning":
-                return this.convertTextLikePartToSDKMessage({
+            case "reasoning": {
+                const message = this.convertTextLikePartToSDKMessage({
                     partId: part.id,
                     messageId: part.messageID,
                     partType: part.type,
                     fullText: part.text,
                     delta,
                 }, sessionId, streamState, messageRole);
+                return message ? [message] : [];
+            }
             case "step-start":
                 // Start of a processing step - no content to emit
-                return null;
+                return [];
             case "step-finish": {
                 // End of processing step - emit usage info if available
                 if (part.tokens) {
-                    return {
-                        type: "result",
-                        session_id: sessionId,
-                        usage: {
-                            input_tokens: part.tokens.input ?? 0,
-                            output_tokens: part.tokens.output ?? 0,
+                    return [
+                        {
+                            type: "result",
+                            session_id: sessionId,
+                            usage: {
+                                input_tokens: part.tokens.input ?? 0,
+                                output_tokens: part.tokens.output ?? 0,
+                            },
                         },
-                    };
+                    ];
                 }
-                return null;
+                return [];
             }
+            // Unified tool part (opencode 1.16+): one type:"tool" part streams
+            // pending -> running -> completed/error. Emit the tool_use once the call
+            // is underway, then the tool_result once it settles, deduped by callID.
+            case "tool":
+                return this.convertUnifiedToolPart(part, sessionId, streamState);
             case "tool-use": {
-                // Tool invocation
-                return {
-                    type: "assistant",
-                    session_id: sessionId,
-                    message: {
-                        role: "assistant",
-                        content: [
-                            {
-                                type: "tool_use",
-                                id: part.id,
-                                name: part.tool ?? "unknown",
-                                input: part.input ?? {},
-                            },
-                        ],
+                // Legacy split tool invocation (older opencode)
+                const normalized = normalizeOpenCodeTool(part.tool, part.input);
+                return [
+                    {
+                        type: "assistant",
+                        session_id: sessionId,
+                        message: {
+                            role: "assistant",
+                            content: [
+                                {
+                                    type: "tool_use",
+                                    id: part.id,
+                                    name: normalized.name,
+                                    input: normalized.input,
+                                },
+                            ],
+                        },
                     },
-                };
+                ];
             }
             case "tool-result": {
-                // Tool result
-                return {
-                    type: "user",
-                    session_id: sessionId,
-                    message: {
-                        role: "user",
-                        content: [
-                            {
-                                type: "tool_result",
-                                tool_use_id: part.id,
-                                content: part.error ?? String(part.output ?? ""),
-                            },
-                        ],
+                // Legacy split tool result (older opencode)
+                return [
+                    {
+                        type: "user",
+                        session_id: sessionId,
+                        message: {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "tool_result",
+                                    tool_use_id: part.id,
+                                    content: part.error ?? String(part.output ?? ""),
+                                },
+                            ],
+                        },
                     },
-                };
+                ];
             }
             default:
-                return null;
+                return [];
         }
     }
+    /**
+     * Convert a unified `type:"tool"` part into YA tool_use/tool_result messages.
+     *
+     * The same part is delivered repeatedly as its `state.status` advances
+     * (pending -> running -> completed/error) and `state.input`/`state.output`
+     * fill in. Emit the tool_use once the call is underway (running or settled)
+     * and the tool_result once it settles, each deduped by callID so a streamed
+     * tool appears exactly once. A fast tool whose first update is already
+     * completed yields both messages at once.
+     */
+    convertUnifiedToolPart(part, sessionId, streamState) {
+        const callId = part.callID;
+        if (!callId)
+            return [];
+        const status = part.state?.status;
+        const settled = status === "completed" || status === "error";
+        const underway = status === "running" || settled;
+        const messages = [];
+        if (underway && !streamState.toolUseEmitted.has(callId)) {
+            streamState.toolUseEmitted.add(callId);
+            const normalized = normalizeOpenCodeTool(part.tool, part.state?.input);
+            messages.push({
+                type: "assistant",
+                session_id: sessionId,
+                message: {
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "tool_use",
+                            id: callId,
+                            name: normalized.name,
+                            input: normalized.input,
+                        },
+                    ],
+                },
+            });
+        }
+        if (settled && !streamState.toolResultEmitted.has(callId)) {
+            streamState.toolResultEmitted.add(callId);
+            const error = part.state?.error;
+            const output = part.state?.output;
+            const content = error ??
+                (typeof output === "string" ? output : JSON.stringify(output ?? ""));
+            messages.push({
+                type: "user",
+                session_id: sessionId,
+                message: {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: callId,
+                            content,
+                            is_error: status === "error" || Boolean(error),
+                        },
+                    ],
+                },
+            });
+        }
+        return messages;
+    }
     /**
      * Wait for server to be ready.
      */
@@ -900,6 +1099,31 @@ export class OpenCodeProvider {
         }
         return "";
     }
+    /**
+     * Convert any base64 image content blocks on a user message into OpenCode
+     * file parts (a data-URL `url` + mime), so pasted/uploaded images are sent to
+     * OpenCode instead of being dropped. Non-image content is untouched.
+     */
+    extractImageFileParts(message) {
+        const content = message.message?.content;
+        if (!Array.isArray(content))
+            return [];
+        const parts = [];
+        for (const block of content) {
+            if (typeof block !== "object" || block === null)
+                continue;
+            const b = block;
+            if (b.type === "image" && b.source?.type === "base64" && b.source.data) {
+                const mime = b.source.media_type || "image/png";
+                parts.push({
+                    type: "file",
+                    mime,
+                    url: `data:${mime};base64,${b.source.data}`,
+                });
+            }
+        }
+        return parts;
+    }
     /**
      * Find the OpenCode CLI path.
      */
@@ -908,8 +1132,11 @@ export class OpenCodeProvider {
         if (this.opencodePath && existsSync(this.opencodePath)) {
             return this.opencodePath;
         }
-        // Check common locations
+        // Check common locations. `~/.opencode/bin` is the official installer
+        // location (curl opencode.ai/install); it is on PATH for login shells but
+        // a server not launched through one may miss it, so check it explicitly.
         const commonPaths = [
+            join(homedir(), ".opencode", "bin", "opencode"),
             join(homedir(), ".local", "bin", "opencode"),
             "/usr/local/bin/opencode",
             join(homedir(), "bin", "opencode"),