opencode-cmd-provider 1.2.2 → 1.3.0

package/dist/src/provider/stream.js

@@ -1,5 +1,5 @@
 import { isRecord, stringValue, numberValue, recordOrEmpty } from "./converters.js";
-import { commandCodeErrorMessage } from "./redact.js";
+import { commandCodeErrorMessage, redactCommandCodeErrorText } from "./redact.js";
 export function parseStreamEventLine(line) {
     let trimmed = line.trim();
     if (!trimmed || trimmed.startsWith(":") || trimmed.startsWith("event:"))
@@ -25,7 +25,7 @@ export function mapFinishReason(reason) {
         raw === "max_output_tokens") {
         return { unified: "length", raw };
     }
-    if (raw === "stop")
+    if (raw === "stop" || raw === "end_turn" || raw === "stop_sequence")
         return { unified: "stop", raw };
     if (raw === "error")
         return { unified: "error", raw };
@@ -111,9 +111,473 @@ export function ccEventToStreamPart(event) {
             const message = commandCodeErrorMessage(event.error) ??
                 commandCodeErrorMessage(event.message) ??
                 "Command Code stream error";
-            throw new Error(message);
+            throw new Error(redactCommandCodeErrorText(message));
         }
         default:
             return [];
     }
 }
+function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function extractUsageTokens(usage) {
+    const rec = asRecord(usage);
+    if (!rec)
+        return undefined;
+    // OpenAI: prompt_tokens / completion_tokens / total_tokens
+    // Anthropic: input_tokens / output_tokens / cache_read_input_tokens / cache_creation_input_tokens
+    // Generic: inputTokens / outputTokens / input_tokens etc.
+    const input = numberValue(rec.prompt_tokens) ??
+        numberValue(rec.input_tokens) ??
+        numberValue(rec.inputTokens) ??
+        numberValue(rec.promptTokens) ??
+        0;
+    const output = numberValue(rec.completion_tokens) ??
+        numberValue(rec.output_tokens) ??
+        numberValue(rec.outputTokens) ??
+        numberValue(rec.completionTokens) ??
+        0;
+    const cacheRead = numberValue(rec.cache_read_input_tokens) ??
+        numberValue(rec.cacheReadTokens) ??
+        numberValue(rec.cacheRead) ??
+        0;
+    const cacheWrite = numberValue(rec.cache_creation_input_tokens) ??
+        numberValue(rec.cacheWriteTokens) ??
+        numberValue(rec.cacheWrite) ??
+        0;
+    // If nothing meaningful, signal undefined so caller can fallback
+    if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) {
+        // Could be empty usage object — still return zeroed usage for finish
+        // but let caller decide if usage was present at all
+        const hasAnyKey = "prompt_tokens" in rec ||
+            "input_tokens" in rec ||
+            "inputTokens" in rec ||
+            "completion_tokens" in rec ||
+            "output_tokens" in rec ||
+            "outputTokens" in rec;
+        if (!hasAnyKey)
+            return undefined;
+    }
+    return { input, output, cacheRead, cacheWrite };
+}
+function usageToAiSdk(usage) {
+    const tokens = extractUsageTokens(usage);
+    if (!tokens)
+        return undefined;
+    const totalInput = tokens.input;
+    const noCache = Math.max(0, totalInput - tokens.cacheRead - tokens.cacheWrite);
+    return {
+        inputTokens: {
+            total: totalInput,
+            noCache,
+            cacheRead: tokens.cacheRead,
+            cacheWrite: tokens.cacheWrite,
+        },
+        outputTokens: { total: tokens.output, text: tokens.output, reasoning: 0 },
+    };
+}
+function firstChoice(event) {
+    const choices = event.choices;
+    if (Array.isArray(choices) && choices.length > 0 && isRecord(choices[0]))
+        return choices[0];
+    return undefined;
+}
+function deltaFromChoice(choice) {
+    const delta = choice.delta;
+    return isRecord(delta) ? delta : undefined;
+}
+export function openAIUsageToAiSdkUsage(event) {
+    // event may be the full chunk or just the usage object
+    const usage = event.usage ?? event;
+    return usageToAiSdk(usage);
+}
+export function anthropicUsageToAiSdkUsage(event) {
+    const usage = event.usage ?? event;
+    return usageToAiSdk(usage);
+}
+// --- Shared stream-part constructors ---
+// Single construction surface for the parts both the stateless mappers and
+// the per-stream stateful parsers emit (issue #55 kept tool-call completion
+// stateful; everything else stays shared).
+function zeroedUsage() {
+    return {
+        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+        outputTokens: { total: 0, text: 0, reasoning: 0 },
+    };
+}
+function finishPart(finishReason, usage) {
+    return {
+        type: "finish",
+        finishReason: finishReason ?? { unified: "stop", raw: "stop" },
+        usage: usage ?? zeroedUsage(),
+    };
+}
+function textDeltaPart(id, delta) {
+    return { type: "text-delta", id: stringValue(id) ?? "text", delta };
+}
+function reasoningDeltaPart(id, delta) {
+    return { type: "reasoning-delta", id: stringValue(id) ?? "reasoning", delta };
+}
+// --- OpenAI Chat Completions streaming ---
+export function openAIEventToStreamPart(event) {
+    if (!isRecord(event))
+        return [];
+    // Error handling — OpenAI errors have { error: { message, type, code } } or top-level error
+    if (event.error !== undefined) {
+        const message = commandCodeErrorMessage(event.error) ??
+            commandCodeErrorMessage(event) ??
+            "Provider stream error";
+        throw new Error(redactCommandCodeErrorText(message));
+    }
+    if (stringValue(event.type) === "error") {
+        const message = commandCodeErrorMessage(event.error) ??
+            commandCodeErrorMessage(event.message) ??
+            "Provider stream error";
+        throw new Error(redactCommandCodeErrorText(message));
+    }
+    // Extract usage if present (terminal chunk)
+    const rawUsage = event.usage;
+    const hasUsage = rawUsage !== undefined && rawUsage !== null;
+    const usage = hasUsage ? usageToAiSdk(rawUsage) : undefined;
+    // Determine finish reason
+    const choice = firstChoice(event);
+    const finishReasonRaw = stringValue(choice?.finish_reason) ??
+        stringValue(choice?.finishReason) ??
+        stringValue(event.finish_reason) ??
+        stringValue(event.finishReason);
+    const finishReason = finishReasonRaw ? mapFinishReason(finishReasonRaw) : undefined;
+    const parts = [];
+    // Text delta
+    const delta = choice ? deltaFromChoice(choice) : undefined;
+    if (delta) {
+        const content = stringValue(delta.content);
+        if (typeof content === "string" && content.length > 0) {
+            parts.push(textDeltaPart(event.id, content));
+        }
+        // Tool calls streaming — map to tool-input deltas
+        const toolCalls = delta.tool_calls ?? delta.toolCalls;
+        if (Array.isArray(toolCalls)) {
+            for (const tc of toolCalls) {
+                if (!isRecord(tc))
+                    continue;
+                const id = stringValue(tc.id) ?? "";
+                const fn = isRecord(tc.function) ? tc.function : {};
+                const name = stringValue(fn.name) ?? stringValue(tc.name) ?? "";
+                const args = stringValue(fn.arguments) ?? "";
+                if (id || name || args) {
+                    if (name)
+                        parts.push({ type: "tool-input-start", id: id || name, toolName: name });
+                    if (args)
+                        parts.push({ type: "tool-input-delta", id: id || name, delta: args });
+                    // Only emit end+call when we have a complete tool call (id + name + non-empty args that looks like JSON)
+                    if (id && name && args) {
+                        // Try to avoid emitting malformed fragments as complete calls
+                        try {
+                            JSON.parse(args);
+                            parts.push({ type: "tool-input-end", id });
+                            parts.push({ type: "tool-call", toolCallId: id, toolName: name, input: args });
+                        }
+                        catch {
+                            // Fragment — wait for final delta to emit call; just keep delta
+                        }
+                    }
+                }
+            }
+        }
+        // Reasoning delta (OpenAI reasoning)
+        const reasoning = stringValue(delta.reasoning) ?? stringValue(delta.reasoning_content);
+        if (typeof reasoning === "string" && reasoning.length > 0) {
+            parts.push(reasoningDeltaPart(event.id, reasoning));
+        }
+    }
+    // If this chunk carries finish reason or usage, emit finish
+    if (finishReason || hasUsage) {
+        const finalUsage = usage ?? (hasUsage ? zeroedUsage() : undefined);
+        // Only emit finish if we have usage or explicit finish reason indicating completion
+        if (finalUsage || finishReason) {
+            parts.push(finishPart(finishReason, finalUsage));
+        }
+    }
+    return parts;
+}
+// --- Anthropic Messages streaming ---
+export function anthropicEventToStreamPart(event) {
+    if (!isRecord(event))
+        return [];
+    const type = stringValue(event.type);
+    if (type === "error" || event.error !== undefined) {
+        const message = commandCodeErrorMessage(event.error) ??
+            commandCodeErrorMessage(event.message) ??
+            "Provider stream error";
+        throw new Error(redactCommandCodeErrorText(message));
+    }
+    // Content delta: { type: "content_block_delta", delta: { type: "text_delta", text: "..." } }
+    if (type === "content_block_delta") {
+        const delta = asRecord(event.delta);
+        const text = stringValue(delta?.text);
+        if (typeof text === "string" && text.length > 0) {
+            const index = numberValue(event.index) ?? 0;
+            const id = `text-${index}`;
+            return [{ type: "text-delta", id, delta: text }];
+        }
+        // Tool input delta: { type: "input_json_delta", partial_json: "..." }
+        const partial = stringValue(delta?.partial_json);
+        if (typeof partial === "string" && partial.length > 0) {
+            const index = numberValue(event.index) ?? 0;
+            const id = `tool-${index}`;
+            // Emit as tool-input-delta; caller may have started tool
+            return [{ type: "tool-input-delta", id, delta: partial }];
+        }
+        return [];
+    }
+    if (type === "content_block_start") {
+        const block = asRecord(event.content_block);
+        const blockType = stringValue(block?.type);
+        const index = numberValue(event.index) ?? 0;
+        if (blockType === "text") {
+            const id = `text-${index}`;
+            return [{ type: "text-start", id }];
+        }
+        if (blockType === "tool_use") {
+            const id = stringValue(block?.id) ?? `tool-${index}`;
+            const name = stringValue(block?.name) ?? "";
+            return [{ type: "tool-input-start", id, toolName: name }];
+        }
+        return [];
+    }
+    if (type === "content_block_stop") {
+        // Stateless codec: the STOP event carries only `index`, not the block type.
+        // Anthropic streams either `text` or `tool_use` blocks; the AI SDK expects
+        // `text-end` for the former and `tool-input-end` for the latter. Emitting
+        // both is noisy (previous emitted two parts) but guarantees the right end
+        // is seen regardless of block type, and the consumer ignores the spurious
+        // one per AI SDK spec. Emit a single text-end here would break tool_use
+        // streams that rely on tool-input-end, so we keep the conservative pair
+        // with an explicit note referencing provider doc streaming (message_delta
+        // carries the final usage/finish; per-block ends are AI SDK concerns).
+        const index = numberValue(event.index) ?? 0;
+        const idText = `text-${index}`;
+        const idTool = `tool-${index}`;
+        return [
+            { type: "text-end", id: idText },
+            { type: "tool-input-end", id: idTool },
+        ];
+    }
+    // Terminal message_delta: { type: "message_delta", delta: { stop_reason }, usage: { ... } }
+    if (type === "message_delta") {
+        const delta = asRecord(event.delta);
+        const stopReason = stringValue(delta?.stop_reason) ?? stringValue(delta?.stopReason) ?? "stop";
+        return [finishPart(mapFinishReason(stopReason), usageToAiSdk(event.usage))];
+    }
+    // Alternative terminal: { type: "message_stop" } without usage — emit generic finish
+    if (type === "message_stop") {
+        return [finishPart(undefined, undefined)];
+    }
+    // Ping/heartbeat or other known non-content types
+    if (type === "ping" || type === "message_start")
+        return [];
+    // Fallback: check for usage at top level without type (some providers send final usage as top-level)
+    if (event.usage !== undefined) {
+        const usage = usageToAiSdk(event.usage);
+        if (usage) {
+            return [
+                finishPart(mapFinishReason(stringValue(event.finish_reason) ?? "stop"), usage),
+            ];
+        }
+    }
+    return [];
+}
+export function createOpenAIStreamParser() {
+    const toolBuffers = new Map();
+    let nextIndex = 0;
+    // OpenAI streams finish_reason on the last content chunk, then the real
+    // usage on a separate trailing usage-only chunk (choices:[]). Remember the
+    // finish_reason here so the usage-only chunk's finish keeps the real reason
+    // (e.g. "length") instead of defaulting to "stop".
+    let lastFinishReason;
+    return (event) => {
+        if (!isRecord(event))
+            return [];
+        // Error events flow through the stateless mapper (redacted throw).
+        if (event.error !== undefined || stringValue(event.type) === "error") {
+            return openAIEventToStreamPart(event);
+        }
+        const parts = [];
+        const choice = firstChoice(event);
+        const delta = choice ? deltaFromChoice(choice) : undefined;
+        if (delta) {
+            const content = stringValue(delta.content);
+            if (typeof content === "string" && content.length > 0) {
+                parts.push(textDeltaPart(event.id, content));
+            }
+            const reasoning = stringValue(delta.reasoning) ?? stringValue(delta.reasoning_content);
+            if (typeof reasoning === "string" && reasoning.length > 0) {
+                parts.push(reasoningDeltaPart(event.id, reasoning));
+            }
+            const toolCalls = delta.tool_calls ?? delta.toolCalls;
+            if (Array.isArray(toolCalls)) {
+                for (const tc of toolCalls) {
+                    if (!isRecord(tc))
+                        continue;
+                    const fn = isRecord(tc.function) ? tc.function : {};
+                    const name = stringValue(fn.name) ?? stringValue(tc.name) ?? "";
+                    const args = stringValue(fn.arguments) ?? "";
+                    const id = stringValue(tc.id) ?? "";
+                    let index = numberValue(tc.index);
+                    if (index === undefined) {
+                        // Fragments usually carry `index`; when absent, continue the most
+                        // recent tool call (OpenAI includes id+name only on the first chunk).
+                        index = toolBuffers.size > 0 ? Math.max(...toolBuffers.keys()) : nextIndex++;
+                    }
+                    let buffer = toolBuffers.get(index);
+                    if (!buffer) {
+                        buffer = { id: id || `tool-${index}`, name, input: "", started: false, emitted: false };
+                        toolBuffers.set(index, buffer);
+                    }
+                    if (id)
+                        buffer.id = id;
+                    if (name)
+                        buffer.name = name;
+                    if (!buffer.started && buffer.name) {
+                        buffer.started = true;
+                        parts.push({ type: "tool-input-start", id: buffer.id, toolName: buffer.name });
+                    }
+                    if (args && !buffer.emitted) {
+                        buffer.input += args;
+                        parts.push({ type: "tool-input-delta", id: buffer.id, delta: args });
+                        // Complete as soon as the accumulated arguments parse as JSON; the
+                        // finish chunk below flushes anything that never completes.
+                        try {
+                            JSON.parse(buffer.input);
+                            buffer.emitted = true;
+                            parts.push({ type: "tool-input-end", id: buffer.id });
+                            parts.push({
+                                type: "tool-call",
+                                toolCallId: buffer.id,
+                                toolName: buffer.name,
+                                input: buffer.input,
+                            });
+                        }
+                        catch {
+                            // fragment — keep accumulating
+                        }
+                    }
+                }
+            }
+        }
+        const rawUsage = event.usage;
+        const hasUsage = rawUsage !== undefined && rawUsage !== null;
+        const finishReasonRaw = stringValue(choice?.finish_reason) ??
+            stringValue(choice?.finishReason) ??
+            stringValue(event.finish_reason) ??
+            stringValue(event.finishReason);
+        const finishReason = finishReasonRaw ? mapFinishReason(finishReasonRaw) : undefined;
+        if (finishReason)
+            lastFinishReason = finishReason;
+        if (lastFinishReason || hasUsage) {
+            // Flush any tool call whose terminal args chunk never arrived.
+            for (const [index, buffer] of toolBuffers) {
+                if (buffer.started && !buffer.emitted) {
+                    parts.push({ type: "tool-input-end", id: buffer.id });
+                    parts.push({
+                        type: "tool-call",
+                        toolCallId: buffer.id,
+                        toolName: buffer.name,
+                        input: buffer.input,
+                    });
+                }
+                toolBuffers.delete(index);
+            }
+            // The usage-only trailing chunk carries no finish_reason; reuse the one
+            // captured from the finish_reason chunk so the real reason survives.
+            const reason = finishReason ?? lastFinishReason;
+            parts.push(finishPart(reason, hasUsage ? usageToAiSdk(rawUsage) : undefined));
+        }
+        return parts;
+    };
+}
+export function createAnthropicStreamParser() {
+    const toolBlocks = new Map();
+    return (event) => {
+        if (!isRecord(event))
+            return [];
+        const type = stringValue(event.type);
+        if (type === "content_block_start") {
+            const block = asRecord(event.content_block);
+            const index = numberValue(event.index) ?? 0;
+            const blockType = stringValue(block?.type);
+            if (blockType === "tool_use") {
+                const id = stringValue(block?.id) ?? `tool-${index}`;
+                const name = stringValue(block?.name) ?? "";
+                toolBlocks.set(index, { id, name, input: "", started: true, emitted: false });
+                return [{ type: "tool-input-start", id, toolName: name }];
+            }
+            if (blockType === "text")
+                return [{ type: "text-start", id: `text-${index}` }];
+            return [];
+        }
+        if (type === "content_block_delta") {
+            const delta = asRecord(event.delta);
+            const index = numberValue(event.index) ?? 0;
+            const text = stringValue(delta?.text);
+            if (typeof text === "string" && text.length > 0) {
+                return [{ type: "text-delta", id: `text-${index}`, delta: text }];
+            }
+            const partial = stringValue(delta?.partial_json);
+            if (typeof partial === "string" && partial.length > 0) {
+                const block = toolBlocks.get(index);
+                if (block) {
+                    if (block.emitted)
+                        return [];
+                    block.input += partial;
+                    const out = [
+                        { type: "tool-input-delta", id: block.id, delta: partial },
+                    ];
+                    // Complete early when a single delta already carries valid JSON;
+                    // content_block_stop below flushes multi-delta accumulation.
+                    try {
+                        JSON.parse(block.input);
+                        block.emitted = true;
+                        out.push({ type: "tool-input-end", id: block.id });
+                        out.push({
+                            type: "tool-call",
+                            toolCallId: block.id,
+                            toolName: block.name,
+                            input: block.input,
+                        });
+                    }
+                    catch {
+                        // fragment — keep accumulating until stop
+                    }
+                    return out;
+                }
+                return [{ type: "tool-input-delta", id: `tool-${index}`, delta: partial }];
+            }
+            return [];
+        }
+        if (type === "content_block_stop") {
+            const index = numberValue(event.index) ?? 0;
+            const block = toolBlocks.get(index);
+            if (block) {
+                toolBlocks.delete(index);
+                if (block.emitted)
+                    return [];
+                return [
+                    { type: "tool-input-end", id: block.id },
+                    {
+                        type: "tool-call",
+                        toolCallId: block.id,
+                        toolName: block.name,
+                        input: block.input,
+                    },
+                ];
+            }
+            return [{ type: "text-end", id: `text-${index}` }];
+        }
+        // Everything else (message_delta, message_stop, ping, error, …) shares the
+        // stateless mapper's handling.
+        return anthropicEventToStreamPart(event);
+    };
+}
+// Canonical stream entry points: openAIEventToStreamPart / anthropicEventToStreamPart
+// and the per-stream stateful parsers createOpenAIStreamParser / createAnthropicStreamParser.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cmd-provider",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Command Code provider + plugin for opencode",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "refresh:deals": "node scripts/refresh-deals.mjs",
     "refresh": "npm run refresh:snapshot && npm run refresh:deals -- --fixtures",
     "test": "npm run typecheck && npm run test:unit && npm run test:integration && npm run test:contract && npm run format:check",
-    "test:unit": "tsx tests/env.test.ts && tsx tests/auth-key.test.ts && tsx tests/converters.test.ts && tsx tests/stream.test.ts && tsx tests/redact.test.ts && tsx tests/cost.test.ts && tsx tests/retry.test.ts && tsx tests/reasoning.test.ts && tsx tests/modalities.test.ts && tsx tests/snapshot.test.ts && tsx tests/refresh-snapshot.test.ts && tsx tests/oauth.test.ts && tsx tests/parse-facts.test.ts && tsx tests/parse-modalities.test.ts && tsx tests/catalog-metadata.test.ts && tsx tests/plugin-models.test.ts && tsx tests/vendor.test.ts && tsx tests/deals-enrichment.test.ts && tsx tests/plan-summary.test.ts && tsx tests/html-tables.test.ts && tsx tests/parse-docs.test.ts && tsx tests/refresh-deals.test.ts && tsx tests/tui-deals-panel.test.ts && tsx tests/plugin-install.test.ts",
+    "test:unit": "tsx tests/env.test.ts && tsx tests/auth-key.test.ts && tsx tests/converters.test.ts && tsx tests/stream.test.ts && tsx tests/provider-codecs.test.ts && tsx tests/provider-transport.test.ts && tsx tests/provider-parity.test.ts && tsx tests/provider-upgrade-fallback.test.ts && tsx tests/provider-zdr.test.ts && tsx tests/redact.test.ts && tsx tests/cost.test.ts && tsx tests/retry.test.ts && tsx tests/reasoning.test.ts && tsx tests/modalities.test.ts && tsx tests/snapshot.test.ts && tsx tests/refresh-snapshot.test.ts && tsx tests/oauth.test.ts && tsx tests/parse-facts.test.ts && tsx tests/parse-modalities.test.ts && tsx tests/catalog-metadata.test.ts && tsx tests/plugin-models.test.ts && tsx tests/vendor.test.ts && tsx tests/deals-enrichment.test.ts && tsx tests/deals-coverage.test.ts && tsx tests/plan-summary.test.ts && tsx tests/html-tables.test.ts && tsx tests/parse-docs.test.ts && tsx tests/refresh-deals.test.ts && tsx tests/tui-deals-panel.test.ts && tsx tests/plugin-install.test.ts",
     "test:integration": "tsx tests/integration-do-stream.test.ts && tsx tests/integration-do-generate.test.ts",
     "test:contract": "tsx tests/contract.test.ts",
     "test:e2e": "node tests/e2e-opencode.mjs",