opencode-cmd-provider 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 1.5.1 - 2026-08-24
+
+Fix: provider parsers now synthesize the full reasoning and text lifecycle —
+`reasoning-start`/`reasoning-end` and `text-start`/`text-end` — for both
+OpenAI-style and Anthropic-style streams, so AI SDK consumers see balanced
+section boundaries instead of missing or duplicated end events.
+
+### Fixes
+
+- **OpenAI-style streams** now emit `reasoning-start` before the first
+  reasoning delta and `reasoning-end` before text, tool calls, or finish; the
+  same for `text-start`/`text-end`. Reasoning and text sections use stable ids
+  from the first chunk (instead of per-chunk ids), and unfinished sections are
+  closed when the stream finishes.
+- **Anthropic-style streams** now recognize `thinking` blocks and emit
+  `reasoning-start`/`reasoning-delta`/`reasoning-end` for them. `content_block_stop`
+  closes each block with the correct end event per its type (`text-end`,
+  `reasoning-end`, or `tool-input-end` + a single `tool-call`), replacing the
+  previous "emit both text-end and tool-input-end" pair that left consumers to
+  ignore the spurious one.
+- New `tests/stream.test.ts` cases cover the OpenAI reasoning→text ordering,
+  reasoning-only finishes, and the Anthropic thinking-block lifecycle;
+  `tests/provider-parity.test.ts` accepts `text-start` as the first text part.
+
 ## 1.5.0 - 2026-08-23
 
 Feature: the `[CMD] ` display-name prefix for auto-registered models is now

package/dist/src/catalog/facts.d.ts

@@ -1,7 +1,7 @@
 export declare const FACTS_SOURCE_URL = "https://unpkg.com/command-code@1.32.1/dist/bundled/command-code-knowledge/reference/models.md";
 export declare const MODALITIES_SOURCE_URL = "https://unpkg.com/command-code@1.32.1/dist/cli.mjs";
 export declare const FACTS_PACKAGE_VERSION = "1.32.1";
-export declare const FACTS_LAST_REFRESHED = "2026-08-23";
+export declare const FACTS_LAST_REFRESHED = "2026-08-24";
 export declare const MODEL_EFFORTS: Readonly<Record<string, readonly string[]>>;
 export declare const MODEL_COSTS: Readonly<Record<string, {
     input: number;

package/dist/src/catalog/facts.js

@@ -7,7 +7,7 @@
 export const FACTS_SOURCE_URL = "https://unpkg.com/command-code@1.32.1/dist/bundled/command-code-knowledge/reference/models.md";
 export const MODALITIES_SOURCE_URL = "https://unpkg.com/command-code@1.32.1/dist/cli.mjs";
 export const FACTS_PACKAGE_VERSION = "1.32.1";
-export const FACTS_LAST_REFRESHED = "2026-08-23";
+export const FACTS_LAST_REFRESHED = "2026-08-24";
 export const MODEL_EFFORTS = {
     "deepseek/deepseek-v4-pro": ["high", "max"],
     "deepseek/deepseek-v4-flash": ["high", "max"],

package/dist/src/deals/catalog.d.ts

@@ -51,5 +51,5 @@ export interface ModelDeals {
 export declare const MODEL_DEALS: Readonly<Record<string, ModelDeals>>;
 export declare const PLAN_CATALOG: Readonly<Record<PlanId, PlanInfo>>;
 export declare const DEAL_SOURCE_URL = "https://commandcode.ai/docs/resources/pricing-limits";
-export declare const DEAL_LAST_REFRESHED = "2026-08-23";
+export declare const DEAL_LAST_REFRESHED = "2026-08-24";
 export declare const DEAL_PACKAGE_VERSION = "docs";

package/dist/src/deals/catalog.js

@@ -74,5 +74,5 @@ export const PLAN_CATALOG = {
     provider: { price: 15, credits: 0, window5h: 0, windowWeek: 0, display: "Provider" },
 };
 export const DEAL_SOURCE_URL = "https://commandcode.ai/docs/resources/pricing-limits";
-export const DEAL_LAST_REFRESHED = "2026-08-23";
+export const DEAL_LAST_REFRESHED = "2026-08-24";
 export const DEAL_PACKAGE_VERSION = "docs";

package/dist/src/provider/stream.js

@@ -338,6 +338,10 @@ export function anthropicEventToStreamPart(event) {
             const id = `text-${index}`;
             return [{ type: "text-start", id }];
         }
+        if (blockType === "thinking") {
+            const id = stringValue(block?.id) ?? `thinking-${index}`;
+            return [{ type: "reasoning-start", id }];
+        }
         if (blockType === "tool_use") {
             const id = stringValue(block?.id) ?? `tool-${index}`;
             const name = stringValue(block?.name) ?? "";
@@ -345,16 +349,32 @@ export function anthropicEventToStreamPart(event) {
         }
         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) {
+            const id = `text-${index}`;
+            return [{ type: "text-delta", id, delta: text }];
+        }
+        const thinking = stringValue(delta?.thinking);
+        if (typeof thinking === "string" && thinking.length > 0) {
+            const id = `thinking-${index}`;
+            return [{ type: "reasoning-delta", id, delta: thinking }];
+        }
+        // Tool input delta: { type: "input_json_delta", partial_json: "..." }
+        const partial = stringValue(delta?.partial_json);
+        if (typeof partial === "string" && partial.length > 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_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).
+        // Anthropic streams either `text`, `thinking` or `tool_use` blocks; the AI SDK expects
+        // `text-end` for text, `reasoning-end` for thinking, and `tool-input-end` for tool_use.
         const index = numberValue(event.index) ?? 0;
         const idText = `text-${index}`;
         const idTool = `tool-${index}`;
@@ -395,6 +415,26 @@ export function createOpenAIStreamParser() {
     // finish_reason here so the usage-only chunk's finish keeps the real reason
     // (e.g. "length") instead of defaulting to "stop".
     let lastFinishReason;
+    let reasoningStarted = false;
+    let reasoningEnded = false;
+    let reasoningId;
+    let textStarted = false;
+    let textEnded = false;
+    let textId;
+    function closeReasoning() {
+        if (reasoningStarted && !reasoningEnded && reasoningId) {
+            reasoningEnded = true;
+            return [{ type: "reasoning-end", id: reasoningId }];
+        }
+        return [];
+    }
+    function closeText() {
+        if (textStarted && !textEnded && textId) {
+            textEnded = true;
+            return [{ type: "text-end", id: textId }];
+        }
+        return [];
+    }
     return (event) => {
         if (!isRecord(event))
             return [];
@@ -405,17 +445,42 @@ export function createOpenAIStreamParser() {
         const parts = [];
         const choice = firstChoice(event);
         const delta = choice ? deltaFromChoice(choice) : undefined;
+        const eventId = stringValue(event.id);
         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));
+                if (!reasoningStarted || reasoningEnded) {
+                    if (textStarted && !textEnded) {
+                        parts.push(...closeText());
+                    }
+                    reasoningStarted = true;
+                    reasoningEnded = false;
+                    reasoningId = eventId || "reasoning-0";
+                    parts.push({ type: "reasoning-start", id: reasoningId });
+                }
+                parts.push(reasoningDeltaPart(reasoningId ?? eventId, reasoning));
+            }
+            const content = stringValue(delta.content);
+            if (typeof content === "string" && content.length > 0) {
+                if (reasoningStarted && !reasoningEnded) {
+                    parts.push(...closeReasoning());
+                }
+                if (!textStarted || textEnded) {
+                    textStarted = true;
+                    textEnded = false;
+                    textId = eventId || "text-0";
+                    parts.push({ type: "text-start", id: textId });
+                }
+                parts.push(textDeltaPart(textId ?? eventId, content));
             }
             const toolCalls = delta.tool_calls ?? delta.toolCalls;
             if (Array.isArray(toolCalls)) {
+                if (reasoningStarted && !reasoningEnded) {
+                    parts.push(...closeReasoning());
+                }
+                if (textStarted && !textEnded) {
+                    parts.push(...closeText());
+                }
                 for (const tc of toolCalls) {
                     if (!isRecord(tc))
                         continue;
@@ -475,6 +540,12 @@ export function createOpenAIStreamParser() {
         if (finishReason)
             lastFinishReason = finishReason;
         if (lastFinishReason || hasUsage) {
+            if (reasoningStarted && !reasoningEnded) {
+                parts.push(...closeReasoning());
+            }
+            if (textStarted && !textEnded) {
+                parts.push(...closeText());
+            }
             // Flush any tool call whose terminal args chunk never arrived.
             for (const [index, buffer] of toolBuffers) {
                 if (buffer.started && !buffer.emitted) {
@@ -498,6 +569,7 @@ export function createOpenAIStreamParser() {
 }
 export function createAnthropicStreamParser() {
     const toolBlocks = new Map();
+    const blockTypes = new Map();
     return (event) => {
         if (!isRecord(event))
             return [];
@@ -507,13 +579,21 @@ export function createAnthropicStreamParser() {
             const index = numberValue(event.index) ?? 0;
             const blockType = stringValue(block?.type);
             if (blockType === "tool_use") {
+                blockTypes.set(index, "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")
+            if (blockType === "thinking") {
+                blockTypes.set(index, "thinking");
+                const id = stringValue(block?.id) ?? `thinking-${index}`;
+                return [{ type: "reasoning-start", id }];
+            }
+            if (blockType === "text") {
+                blockTypes.set(index, "text");
                 return [{ type: "text-start", id: `text-${index}` }];
+            }
             return [];
         }
         if (type === "content_block_delta") {
@@ -523,6 +603,10 @@ export function createAnthropicStreamParser() {
             if (typeof text === "string" && text.length > 0) {
                 return [{ type: "text-delta", id: `text-${index}`, delta: text }];
             }
+            const thinking = stringValue(delta?.thinking);
+            if (typeof thinking === "string" && thinking.length > 0) {
+                return [{ type: "reasoning-delta", id: `thinking-${index}`, delta: thinking }];
+            }
             const partial = stringValue(delta?.partial_json);
             if (typeof partial === "string" && partial.length > 0) {
                 const block = toolBlocks.get(index);
@@ -557,6 +641,28 @@ export function createAnthropicStreamParser() {
         }
         if (type === "content_block_stop") {
             const index = numberValue(event.index) ?? 0;
+            const bType = blockTypes.get(index);
+            blockTypes.delete(index);
+            if (bType === "tool_use") {
+                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,
+                        },
+                    ];
+                }
+            }
+            else if (bType === "thinking") {
+                return [{ type: "reasoning-end", id: `thinking-${index}` }];
+            }
             const block = toolBlocks.get(index);
             if (block) {
                 toolBlocks.delete(index);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cmd-provider",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Command Code provider + plugin for opencode",
   "type": "module",
   "main": "./dist/index.js",