opencode-cmd-provider 1.4.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # 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
+configurable via `provider.commandcode.options.display_prefix`.
+
+### Features
+
+- **Configurable display-name prefix** (issue #60): a string value replaces the
+  default `[CMD] ` prefix, and an empty string disables it entirely. The option
+  is read-only at resolution time — nothing is persisted into the user's config
+  (unlike `npm`/`name`/`env`/`options.baseURL`, which are filled when unset).
+- Non-string values fall back to the default `[CMD] ` prefix.
+- Declared model entries are never renamed — the prefix applies only to models
+  auto-registered from the bundled snapshot.
+
+### Chores
+
+- New `tests/plugin-models.test.ts` cases: `resolveDisplayPrefix` fallback,
+  prefix override (`"CC/"`), empty string disabling the prefix (with non-name
+  metadata unaffected), and declared models keeping their names regardless of
+  the setting.
+
 ## 1.4.0 - 2026-08-23
 
 Feature: after a successful `/connect`, the credential is mirrored under

package/README.md

@@ -133,6 +133,24 @@ can still declare your own `provider.commandcode` entry; your declarations
 always win and the snapshot fills in only what's missing (`whitelist`/
 `blacklist` on a declared entry filter the auto-registered models too).
 
+The `[CMD] ` display-name prefix is configurable through the declared
+provider entry's options:
+
+```jsonc
+{
+  "provider": {
+    "commandcode": {
+      "options": {
+        "display_prefix": "", // default "[CMD] "; empty string disables
+      },
+    },
+  },
+}
+```
+
+Declared model entries are never renamed; the prefix applies to
+auto-registered models only.
+
 - Snapshot — `src/catalog/snapshot.ts` (model ids, names, context lengths) plus
   `src/catalog/facts.ts` (reasoning efforts, per-1M-token rates, input
   modalities). Regenerated from the live catalog via `npm run refresh:snapshot`.

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-22";
+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-22";
+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-22";
+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-22";
+export const DEAL_LAST_REFRESHED = "2026-08-24";
 export const DEAL_PACKAGE_VERSION = "docs";

package/dist/src/plugin/models.d.ts

@@ -1,5 +1,13 @@
-import type { Config } from "@opencode-ai/sdk/v2";
+import type { Config, ProviderConfig } from "@opencode-ai/sdk/v2";
 import type { CatalogModel } from "../catalog/snapshot.js";
+export declare const DEFAULT_DISPLAY_PREFIX = "[CMD] ";
+/**
+ * Resolves the auto-registration display-name prefix from the user-declared
+ * `provider.commandcode.options.display_prefix` key. A string value is used
+ * verbatim (empty string disables the prefix); anything else falls back to
+ * `[CMD] `. Read-only: never persisted into the user's config.
+ */
+export declare function resolveDisplayPrefix(entry: ProviderConfig | undefined): string;
 export interface AutoRegisterOptions {
     npm: string;
     name: string;
@@ -24,6 +32,9 @@ export interface AutoRegisterOptions {
  *   config key or by the entry's `id`);
  * - declared models are never modified, and declared models that left the
  *   catalog stay usable.
+ * - `options.display_prefix` (string) overrides the default `[CMD] `
+ *   display-name prefix for auto-registered models; an empty string disables
+ *   the prefix.
  */
 export declare function autoRegister(config: Config, snapshot: readonly CatalogModel[], options: AutoRegisterOptions): Config;
 /**

package/dist/src/plugin/models.js

@@ -2,6 +2,17 @@ import { MODEL_COSTS, ZERO_MODEL_COST } from "../provider/pricing.js";
 import { reasoningVariantsForModel, isReasoningModel } from "../provider/reasoning.js";
 import { inputModalitiesForModel } from "../provider/modalities.js";
 const DEFAULT_MAX_OUTPUT_TOKENS = 65_536;
+export const DEFAULT_DISPLAY_PREFIX = "[CMD] ";
+/**
+ * Resolves the auto-registration display-name prefix from the user-declared
+ * `provider.commandcode.options.display_prefix` key. A string value is used
+ * verbatim (empty string disables the prefix); anything else falls back to
+ * `[CMD] `. Read-only: never persisted into the user's config.
+ */
+export function resolveDisplayPrefix(entry) {
+    const value = entry?.options?.display_prefix;
+    return typeof value === "string" ? value : DEFAULT_DISPLAY_PREFIX;
+}
 /**
  * Registers the `commandcode` provider entry into opencode's config so every
  * snapshot model is available without any user declaration.
@@ -21,6 +32,9 @@ const DEFAULT_MAX_OUTPUT_TOKENS = 65_536;
  *   config key or by the entry's `id`);
  * - declared models are never modified, and declared models that left the
  *   catalog stay usable.
+ * - `options.display_prefix` (string) overrides the default `[CMD] `
+ *   display-name prefix for auto-registered models; an empty string disables
+ *   the prefix.
  */
 export function autoRegister(config, snapshot, options) {
     if (snapshot.length === 0)
@@ -33,13 +47,14 @@ export function autoRegister(config, snapshot, options) {
     entry.options ??= {};
     entry.options.baseURL ??= options.baseURL;
     entry.models ??= {};
+    const prefix = resolveDisplayPrefix(entry);
     const declaredById = new Set(Object.values(entry.models)
         .map((model) => model?.id)
         .filter((id) => typeof id === "string"));
     for (const model of snapshot) {
         if (entry.models[model.id] !== undefined || declaredById.has(model.id))
             continue;
-        entry.models[model.id] = configModelFor(model);
+        entry.models[model.id] = configModelFor(model, prefix);
     }
     return config;
 }
@@ -73,15 +88,15 @@ export function augmentConfigCommandCodeModels(config) {
 }
 /**
  * Config-schema model entry (not the SDK `Model` shape) for a snapshot model:
- * `[CMD]`-prefixed display name, context/output limits with output capped at
+ * prefixed display name, context/output limits with output capped at
  * 65_536, and metadata enriched from the reasoning, modality, and pricing
  * tables.
  */
-function configModelFor(model) {
+function configModelFor(model, prefix = DEFAULT_DISPLAY_PREFIX) {
     const variants = reasoningVariantsForModel(model.id);
     const costs = MODEL_COSTS[model.id] ?? ZERO_MODEL_COST;
     return {
-        name: `[CMD] ${model.name}`,
+        name: `${prefix}${model.name}`,
         limit: {
             context: model.contextLength,
             output: Math.min(model.contextLength, DEFAULT_MAX_OUTPUT_TOKENS),

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.4.0",
+  "version": "1.5.1",
   "description": "Command Code provider + plugin for opencode",
   "type": "module",
   "main": "./dist/index.js",