opencode-cmd-provider 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.1.2 - 2026-08-15
+
+Fix: tool-call history round-trip and reasoning effort. Live probes against the Command Code API with opencode confirmed the AI SDK v3 shapes differ from what the converters expected:
+
+- Assistant tool-call parts carry arguments under `input`, not `args`/`arguments` — the converter read the legacy fields, so every prior tool call was re-sent with empty `{}` arguments, corrupting multi-turn context.
+- Tool-result outputs use the v3 `{ type: "text" | "error-text" | "json" | "content", ... }` shapes — `resultText` stringified the wrapper, double-encoding results in history. Replaced with `unwrapToolResult`.
+- `reasoning_effort` was silently dropped: opencode passes `providerOptions` namespaced per provider (`{ commandcode: { reasoningEffort } }`), but the model read the top-level keys. Added `resolveProviderReasoning` (namespaced + top-level fallback) so the configured thinking level actually reaches the API.
+
+Also: remove duplicated README disclaimer; bump `@ai-sdk/provider` to 4.x and `@types/node` to 26.x.
+
+## 0.1.1 - 2026-08-15
+
+Fix: emit `text-start`/`text-end` and `reasoning-start`/`reasoning-end` stream parts. The live Command Code API sends start/end events with ids; the AI SDK's streamText consumer requires them before deltas, so reasoning-capable models (e.g. `deepseek/deepseek-v4-flash`) failed with "reasoning part <id> not found".
+
 ## 0.1.0 - 2026-08-15
 
-Initial release: Command Code provider + plugin for opencode.
+Initial release: Command Code provider + plugin for opencode. Published to npm as `opencode-cmd-provider@0.1.0` (`latest`), tagged `v0.1.0`.
+
+- `createCommandCode(options)` AI SDK provider (LanguageModelV3) + `default` V1 opencode plugin module in one package.
+- `/connect` browser auth flow, `COMMANDCODE_API_KEY` env var, and legacy auth file support (`~/.commandcode/auth.json`, `~/.omp/agent/auth.json`, `~/.pi/agent/auth.json`).
+- Model catalog fetch, parse, and cache with offline fallback; pricing/cost display; image input; reasoning effort.
+- Config-declared `models` map required under `provider.commandcode` until `commandcode` lands in opencode's models.dev catalog.

package/README.md

@@ -1,6 +1,7 @@
 # opencode-cmd-provider
 
 [![CI](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml/badge.svg)](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/opencode-cmd-provider)](https://www.npmjs.com/package/opencode-cmd-provider)
 
 A provider and plugin for [opencode](https://opencode.ai) that connects to the [Command Code](https://commandcode.ai) Provider API.
 
@@ -25,20 +26,27 @@ Add the package to your opencode configuration:
           "name": "Claude Sonnet 5",
           "limit": { "context": 200000, "output": 65536 },
         },
+        "deepseek/deepseek-v4-flash": {
+          "name": "DeepSeek V4 Flash",
+        },
       },
     },
   },
 }
 ```
 
-> **The `models` map is required.** opencode only fires a provider's `models`
-> discovery hook for providers already in its [models.dev](https://models.dev)
-> catalog, and `commandcode` is not in that catalog yet. Declaring the models you
-> want in `provider.commandcode.models` is what makes them appear in `/models`
-> and usable with `opencode run --model commandcode/...`. The reference config is
-> the one written by `scripts/opencode-fixture.mjs`. When `commandcode` lands in
-> the models.dev catalog, this map becomes optional and discovery works via the
-> plugin's `provider.models` hook.
+> **The `models` map is required, and each key must be the model's full Command
+> Code catalog ID.** opencode only fires a provider's `models` discovery hook for
+> providers already in its [models.dev](https://models.dev) catalog, and
+> `commandcode` is not in that catalog yet — so you must declare the models you
+> want. The keys are passed straight to the Command Code API, so use the exact
+> catalog IDs (some are prefixed, e.g. `deepseek/deepseek-v4-flash`,
+> `google/gemini-3.5-flash`, `xai/grok-4.5`). List the current catalog from the
+> terminal with `opencode run --model commandcode/... "hi"` after connecting, or
+> hit `https://api.commandcode.ai/provider/v1/models`. An unprefixed or wrong ID
+> fails with a `403 Model/provider not recognized` error. When `commandcode`
+> lands in the models.dev catalog, this map becomes optional and discovery works
+> via the plugin's `provider.models` hook.
 
 Start or reload opencode, then authenticate:
 

package/dist/src/provider/command-code-model.js

@@ -11,7 +11,7 @@ import { parseStreamEventLine, ccEventToStreamPart } from "./stream.js";
 import { redactCommandCodeErrorText, commandCodeErrorMessage } from "./redact.js";
 import { calculateCommandCodeCost } from "./cost.js";
 import { ZERO_MODEL_COST, MODEL_COSTS } from "./pricing.js";
-import { mappedReasoningEffort, thinkingMetadataForModel, isReasoningModel } from "./reasoning.js";
+import { mappedReasoningEffort, resolveProviderReasoning, thinkingMetadataForModel, isReasoningModel, } from "./reasoning.js";
 import { modelSupportsImageInput } from "./modalities.js";
 import { isRetryableStatus, retryDelayMs, raceAbort, abortError, timeoutError, delay, } from "./retry.js";
 import { projectSlugFromPath } from "./project-slug.js";
@@ -138,8 +138,7 @@ export class CommandCodeLanguageModel {
             reasoning: isReasoningModel(this.modelId),
             thinkingLevelMap: thinkingMetadataForModel(this.modelId)?.thinkingLevelMap,
         }, {
-            reasoning: options.providerOptions?.reasoning ??
-                options.providerOptions?.reasoningEffort,
+            reasoning: resolveProviderReasoning(options.providerOptions, "commandcode"),
         });
         const maxTokens = Math.min(options.maxOutputTokens ?? DEFAULT_GENERATE_MAX_TOKENS, DEFAULT_GENERATE_MAX_TOKENS);
         const allowImages = modelSupportsImageInput(this.modelId);

package/dist/src/provider/converters.js

@@ -140,21 +140,41 @@ function completeToolCallIds(messages) {
     }
     return new Set([...callIds].filter((id) => resultIds.has(id)));
 }
-function resultText(result) {
+function unwrapToolResult(result) {
     if (typeof result === "string")
         return result;
     if (Array.isArray(result))
-        return result.map(resultText).filter(Boolean).join("\n");
-    if (result && typeof result === "object") {
-        const text = result.text;
-        if (typeof text === "string")
+        return result.map(unwrapToolResult).filter(Boolean).join("\n");
+    if (!isRecord(result))
+        return String(result ?? "");
+    switch (result.type) {
+        case "text":
+        case "error-text":
+            return stringValue(result.value) ?? "";
+        case "json":
+        case "error-json":
+            return JSON.stringify(result.value);
+        case "execution-denied":
+            return stringValue(result.reason) ?? "Tool execution denied.";
+        case "content": {
+            const text = Array.isArray(result.value)
+                ? result.value
+                    .map((entry) => isRecord(entry) && entry.type === "text" ? (stringValue(entry.text) ?? "") : "")
+                    .filter(Boolean)
+                    .join("\n")
+                : "";
             return text;
-        const content = result.content;
-        if (content !== undefined)
-            return resultText(content);
-        return JSON.stringify(result);
+        }
+        default: {
+            const text = stringValue(result.text);
+            if (text !== undefined)
+                return text;
+            const content = result.content;
+            if (content !== undefined)
+                return unwrapToolResult(content);
+            return JSON.stringify(result);
+        }
     }
-    return String(result ?? "");
 }
 export function messagesToCC(messages, options = {}) {
     const allowImages = options.allowImages ?? false;
@@ -183,7 +203,7 @@ export function messagesToCC(messages, options = {}) {
                         type: "tool-call",
                         toolCallId,
                         toolName: stringValue(content.toolName) ?? "",
-                        input: recordOrEmpty(content.args ?? content.arguments),
+                        input: recordOrEmpty(content.input ?? content.args ?? content.arguments),
                     });
                 }
             }
@@ -203,8 +223,8 @@ export function messagesToCC(messages, options = {}) {
                             toolCallId,
                             toolName: stringValue(content.toolName) ?? "",
                             output: content.isError
-                                ? { type: "error-text", value: resultText(content.result ?? content.output) }
-                                : { type: "text", value: resultText(content.result ?? content.output) },
+                                ? { type: "error-text", value: unwrapToolResult(content.result ?? content.output) }
+                                : { type: "text", value: unwrapToolResult(content.result ?? content.output) },
                         },
                     ],
                 });

package/dist/src/provider/reasoning.d.ts

@@ -26,4 +26,13 @@ export declare function mappedReasoningEffort(model: {
 }, options?: {
     reasoning?: string;
 }): string | undefined;
+/**
+ * Resolves the user's requested reasoning effort from AI SDK v3 call
+ * providerOptions. The v3 shape namespaces options per provider
+ * (`{ commandcode: { reasoningEffort } }`), but some runtimes pass the
+ * effort at the top level — accept both. Without this, opencode's
+ * `reasoningEffort` agent setting is silently dropped and the API falls
+ * back to its default reasoning depth.
+ */
+export declare function resolveProviderReasoning(providerOptions: unknown, providerId: string): string | undefined;
 export {};

package/dist/src/provider/reasoning.js

@@ -72,3 +72,29 @@ export function mappedReasoningEffort(model, options) {
     const mapped = model.thinkingLevelMap?.[level];
     return typeof mapped === "string" && mapped !== "off" ? mapped : undefined;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/**
+ * Resolves the user's requested reasoning effort from AI SDK v3 call
+ * providerOptions. The v3 shape namespaces options per provider
+ * (`{ commandcode: { reasoningEffort } }`), but some runtimes pass the
+ * effort at the top level — accept both. Without this, opencode's
+ * `reasoningEffort` agent setting is silently dropped and the API falls
+ * back to its default reasoning depth.
+ */
+export function resolveProviderReasoning(providerOptions, providerId) {
+    if (!isRecord(providerOptions))
+        return undefined;
+    const topLevel = stringValue(providerOptions.reasoning) ?? stringValue(providerOptions.reasoningEffort);
+    if (topLevel)
+        return topLevel;
+    const namespaced = providerOptions[providerId];
+    if (isRecord(namespaced)) {
+        return stringValue(namespaced.reasoning) ?? stringValue(namespaced.reasoningEffort);
+    }
+    return undefined;
+}

package/dist/src/provider/stream.js

@@ -56,16 +56,30 @@ export function ccEventToStreamPart(event) {
     if (!isRecord(event))
         return [];
     switch (event.type) {
+        case "text-start": {
+            const id = toolCallIdOf(event) || "text";
+            return [{ type: "text-start", id }];
+        }
         case "text-delta": {
             const id = toolCallIdOf(event) || "text";
             return [{ type: "text-delta", id, delta: stringValue(event.text) ?? "" }];
         }
+        case "text-end": {
+            const id = toolCallIdOf(event) || "text";
+            return [{ type: "text-end", id }];
+        }
+        case "reasoning-start": {
+            const id = toolCallIdOf(event) || "reasoning";
+            return [{ type: "reasoning-start", id }];
+        }
         case "reasoning-delta": {
             const id = toolCallIdOf(event) || "reasoning";
             return [{ type: "reasoning-delta", id, delta: stringValue(event.text) ?? "" }];
         }
-        case "reasoning-start":
-        case "reasoning-end":
+        case "reasoning-end": {
+            const id = toolCallIdOf(event) || "reasoning";
+            return [{ type: "reasoning-end", id }];
+        }
         case "tool-result":
             return [];
         case "tool-call": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cmd-provider",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Command Code provider + plugin for opencode",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,11 +38,11 @@
     "url": "git+https://github.com/rashidrazak/opencode-cmd-provider.git"
   },
   "dependencies": {
-    "@ai-sdk/provider": "^3.0.8"
+    "@ai-sdk/provider": "^4.0.7"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "*",
-    "@types/node": "^25.9.5",
+    "@types/node": "^26.2.0",
     "prettier": "^3.9.6",
     "tsx": "^4.23.12",
     "typescript": "^7.0.2"