@jeffreyjyz/opencode-command-code 0.2.11 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin as PluginV1 } from "@opencode-ai/plugin";
 export declare const CommandCodePlugin: PluginV1;
+export { createCommandCode } from "./provider";
 declare const _default: {
     /** v1 entrypoint (opencode >=1.18.29 object entrypoints). */
     server: PluginV1;

package/dist/index.js

@@ -3054,6 +3054,654 @@ async function loadModels(key) {
   return { claude, open };
 }
 
+// src/provider/stream.ts
+function sseDecoder(onEvent) {
+  let buffer = "";
+  return (text) => {
+    buffer += text;
+    for (;; ) {
+      const nl = buffer.indexOf(`
+`);
+      if (nl < 0)
+        return;
+      const line = buffer.slice(0, nl).replace(/\r$/, "");
+      buffer = buffer.slice(nl + 1);
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith(":") || trimmed.startsWith("event:"))
+        continue;
+      const payload = trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+      if (!payload || payload === "[DONE]")
+        continue;
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === "object")
+          onEvent(parsed);
+      } catch {}
+    }
+  };
+}
+var text = (v) => typeof v === "string" ? v : "";
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var rec = (v) => v && typeof v === "object" ? v : {};
+var TOOL_FINISH = new Set(["tool_use", "tool_calls", "tool-call", "function_call"]);
+var LENGTH_FINISH = new Set(["length", "max_tokens", "max_output_tokens", "model_context_window_exceeded"]);
+function finishReason(raw) {
+  const value = (raw ?? "unknown").toLowerCase();
+  if (TOOL_FINISH.has(value))
+    return { unified: "tool-calls", raw };
+  if (LENGTH_FINISH.has(value))
+    return { unified: "length", raw };
+  if (value === "error")
+    return { unified: "error", raw };
+  return { unified: "stop", raw };
+}
+function usageFrom(total, noCache, cacheRead, cacheWrite, output, reasoning) {
+  return {
+    inputTokens: { total, noCache, cacheRead, cacheWrite },
+    outputTokens: { total: output, text: Math.max(0, output - reasoning), reasoning }
+  };
+}
+function anthropicUsage(raw) {
+  const total = num(raw.input_tokens);
+  const cacheRead = num(raw.cache_read_input_tokens);
+  const cacheWrite = num(raw.cache_creation_input_tokens);
+  const output = num(raw.output_tokens);
+  return usageFrom(total, Math.max(0, total - cacheRead - cacheWrite), cacheRead, cacheWrite, output, 0);
+}
+function openaiUsage(raw) {
+  const total = num(raw.prompt_tokens);
+  const cached = num(rec(raw.prompt_tokens_details).cached_tokens);
+  const output = num(raw.completion_tokens);
+  const reasoning = num(rec(raw.completion_tokens_details).reasoning_tokens);
+  return usageFrom(total, Math.max(0, total - cached), cached, 0, output, reasoning);
+}
+function anthropicReducer() {
+  const blocks = new Map;
+  let finished = false;
+  let warningsEmitted = false;
+  let last = { unified: "stop", raw: "unknown" };
+  const open = (index, kind) => {
+    const id = `${kind === "text" ? "text" : "reasoning"}-${index}`;
+    blocks.set(index, { type: kind, id });
+    return [{ type: kind === "text" ? "text-start" : "reasoning-start", id }];
+  };
+  return {
+    feed(event) {
+      const type = text(event.type);
+      if (type === "message_start") {
+        if (warningsEmitted)
+          return [];
+        warningsEmitted = true;
+        return [{ type: "stream-start", warnings: [] }];
+      }
+      if (type === "content_block_start") {
+        const index = num(event.index);
+        const block = rec(event.content_block);
+        const blockType = text(block.type);
+        if (blockType === "text")
+          return open(index, "text");
+        if (blockType === "thinking")
+          return open(index, "thinking");
+        if (blockType === "tool_use") {
+          const id = text(block.id) || `tool-${index}`;
+          blocks.set(index, { type: "tool_use", id });
+          return [{ type: "tool-input-start", id, toolName: text(block.name) }];
+        }
+        blocks.set(index, { type: "other", id: `block-${index}` });
+        return [];
+      }
+      if (type === "content_block_delta") {
+        const index = num(event.index);
+        const delta = rec(event.delta);
+        const block = blocks.get(index);
+        const textDelta = text(delta.text);
+        if (textDelta) {
+          const parts = block?.type === "text" ? [] : open(index, "text");
+          const id = blocks.get(index)?.id ?? `text-${index}`;
+          return [...parts, { type: "text-delta", id, delta: textDelta }];
+        }
+        const thinking = text(delta.thinking);
+        if (thinking) {
+          const parts = block?.type === "thinking" ? [] : open(index, "thinking");
+          const id = blocks.get(index)?.id ?? `reasoning-${index}`;
+          return [...parts, { type: "reasoning-delta", id, delta: thinking }];
+        }
+        const partial = text(delta.partial_json);
+        if (partial && block?.type === "tool_use") {
+          return [{ type: "tool-input-delta", id: block.id, delta: partial }];
+        }
+        return [];
+      }
+      if (type === "content_block_stop") {
+        const index = num(event.index);
+        const block = blocks.get(index);
+        if (!block)
+          return [];
+        blocks.delete(index);
+        if (block.type === "text")
+          return [{ type: "text-end", id: block.id }];
+        if (block.type === "thinking")
+          return [{ type: "reasoning-end", id: block.id }];
+        if (block.type === "tool_use")
+          return [{ type: "tool-input-end", id: block.id }];
+        return [];
+      }
+      if (type === "message_delta") {
+        const delta = rec(event.delta);
+        last = finishReason(text(delta.stop_reason) || undefined);
+        if (text(delta.stop_reason) === "pause_turn")
+          last = { unified: "stop", raw: "pause_turn" };
+        if (finished)
+          return [];
+        finished = true;
+        return [{ type: "finish", finishReason: last, usage: anthropicUsage(rec(event.usage)) }];
+      }
+      if (type === "message_stop" && !finished) {
+        finished = true;
+        return [{ type: "finish", finishReason: last, usage: usageFrom(0, 0, 0, 0, 0, 0) }];
+      }
+      return [];
+    },
+    close() {
+      const parts = [];
+      for (const block of blocks.values()) {
+        if (block.type === "text")
+          parts.push({ type: "text-end", id: block.id });
+        if (block.type === "thinking")
+          parts.push({ type: "reasoning-end", id: block.id });
+        if (block.type === "tool_use")
+          parts.push({ type: "tool-input-end", id: block.id });
+      }
+      blocks.clear();
+      return parts;
+    }
+  };
+}
+function openaiReducer() {
+  const tools = new Map;
+  let textId;
+  let reasoningId;
+  let pending;
+  let usage;
+  let finished = false;
+  const closeText = () => {
+    if (!textId)
+      return [];
+    const id = textId;
+    textId = undefined;
+    return [{ type: "text-end", id }];
+  };
+  const closeReasoning = () => {
+    if (!reasoningId)
+      return [];
+    const id = reasoningId;
+    reasoningId = undefined;
+    return [{ type: "reasoning-end", id }];
+  };
+  const completeIfParsed = (buffer) => {
+    if (!buffer.opened || buffer.closed)
+      return [];
+    try {
+      JSON.parse(buffer.input);
+    } catch {
+      return [];
+    }
+    buffer.closed = true;
+    return [
+      { type: "tool-input-end", id: buffer.id },
+      { type: "tool-call", toolCallId: buffer.id, toolName: buffer.name, input: buffer.input }
+    ];
+  };
+  const flushTools = () => {
+    const parts = [];
+    for (const [index, buffer] of tools) {
+      if (buffer.opened && !buffer.closed) {
+        parts.push({ type: "tool-input-end", id: buffer.id });
+        parts.push({ type: "tool-call", toolCallId: buffer.id, toolName: buffer.name, input: buffer.input });
+        buffer.closed = true;
+      }
+      tools.delete(index);
+    }
+    return parts;
+  };
+  return {
+    feed(event) {
+      if (text(event.type) === "error" || event.error !== undefined) {
+        const message = text(rec(event.error).message) || text(event.message) || "provider stream error";
+        return [{ type: "error", error: new Error(message) }];
+      }
+      const parts = [];
+      const choices = Array.isArray(event.choices) ? event.choices : [];
+      const choice = rec(choices[0]);
+      const delta = rec(choice.delta);
+      const reasoning = text(delta.reasoning) || text(delta.reasoning_content);
+      if (reasoning) {
+        if (!reasoningId) {
+          parts.push(...closeText());
+          reasoningId = "reasoning-0";
+          parts.push({ type: "reasoning-start", id: reasoningId });
+        }
+        parts.push({ type: "reasoning-delta", id: reasoningId, delta: reasoning });
+      }
+      const content = text(delta.content);
+      if (content) {
+        if (reasoningId)
+          parts.push(...closeReasoning());
+        if (!textId) {
+          textId = "text-0";
+          parts.push({ type: "text-start", id: textId });
+        }
+        parts.push({ type: "text-delta", id: textId, delta: content });
+      }
+      const calls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+      if (calls.length > 0) {
+        parts.push(...closeReasoning(), ...closeText());
+        for (const raw of calls) {
+          const call = rec(raw);
+          const fn = rec(call.function);
+          const index = typeof call.index === "number" ? call.index : tools.size;
+          let buffer = tools.get(index);
+          if (!buffer) {
+            buffer = { id: text(call.id) || `tool-${index}`, name: text(fn.name), input: "", opened: false, closed: false };
+            tools.set(index, buffer);
+          }
+          if (text(call.id))
+            buffer.id = text(call.id);
+          if (text(fn.name))
+            buffer.name = text(fn.name);
+          const args = text(fn.arguments);
+          if (!buffer.opened && buffer.name) {
+            buffer.opened = true;
+            parts.push({ type: "tool-input-start", id: buffer.id, toolName: buffer.name });
+            if (buffer.input)
+              parts.push({ type: "tool-input-delta", id: buffer.id, delta: buffer.input });
+          } else if (args && !buffer.closed) {
+            parts.push({ type: "tool-input-delta", id: buffer.id, delta: args });
+          }
+          if (!buffer.closed) {
+            buffer.input += args;
+            parts.push(...completeIfParsed(buffer));
+          }
+        }
+      }
+      const rawFinish = text(choice.finish_reason) || text(choice.finishReason) || text(event.finish_reason) || text(event.finishReason);
+      if (rawFinish)
+        pending = finishReason(rawFinish);
+      if (event.usage !== undefined && event.usage !== null)
+        usage = openaiUsage(rec(event.usage));
+      if (pending && !finished && (usage !== undefined || choices.length === 0)) {
+        finished = true;
+        parts.push(...closeReasoning(), ...closeText(), ...flushTools());
+        parts.push({ type: "finish", finishReason: pending, usage: usage ?? usageFrom(0, 0, 0, 0, 0, 0) });
+      }
+      return parts;
+    },
+    close() {
+      const parts = [...closeReasoning(), ...closeText(), ...flushTools()];
+      if (pending && !finished) {
+        finished = true;
+        parts.push({ type: "finish", finishReason: pending, usage: usage ?? usageFrom(0, 0, 0, 0, 0, 0) });
+      }
+      return parts;
+    }
+  };
+}
+
+// src/provider/wire.ts
+var DEFAULT_MAX_TOKENS = 64000;
+function capTokens(value) {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_MAX_TOKENS;
+  return Math.min(n, DEFAULT_MAX_TOKENS);
+}
+function textOf(part) {
+  const p = part;
+  return typeof p.text === "string" ? p.text : "";
+}
+function resultText(part) {
+  const output = part.output ?? part.result;
+  if (typeof output === "string")
+    return output;
+  if (output && typeof output === "object") {
+    const o = output;
+    if (typeof o.value === "string")
+      return o.value;
+    if (o.value !== undefined)
+      return JSON.stringify(o.value);
+    if (typeof o.reason === "string")
+      return o.reason;
+  }
+  return JSON.stringify(output ?? "");
+}
+function imageUrl(part) {
+  const p = part;
+  const mime = p.mediaType ?? p.mimeType ?? "application/octet-stream";
+  const data = p.data;
+  if (typeof data === "string")
+    return data.startsWith("data:") ? data : `data:${mime};base64,${data}`;
+  if (data instanceof Uint8Array)
+    return `data:${mime};base64,${Buffer.from(data).toString("base64")}`;
+  if (data instanceof URL)
+    return data.href;
+  return;
+}
+function pairedToolCallIds(prompt) {
+  const calls = new Set;
+  const results = new Set;
+  for (const message of prompt) {
+    for (const part of message.content) {
+      if (part.type === "tool-call" && typeof part.toolCallId === "string")
+        calls.add(part.toolCallId);
+      if (part.type === "tool-result" && typeof part.toolCallId === "string")
+        results.add(part.toolCallId);
+    }
+  }
+  return new Set([...calls].filter((id) => results.has(id)));
+}
+function systemText(prompt) {
+  return prompt.filter((m) => m.role === "system").map((m) => m.content).join(`
+`);
+}
+function anthropicUserContent(content, images) {
+  if (typeof content === "string")
+    return content;
+  const parts = content ?? [];
+  const blocks = [];
+  for (const part of parts) {
+    if (part.type === "text")
+      blocks.push({ type: "text", text: textOf(part) });
+    else if (part.type === "file" && images) {
+      const url = imageUrl(part);
+      if (url?.startsWith("data:")) {
+        const [head, b64] = url.slice(5).split(";base64,");
+        blocks.push({ type: "image", source: { type: "base64", media_type: head, data: b64 } });
+      }
+    }
+  }
+  if (blocks.length === 1 && blocks[0].type === "text") {
+    return blocks[0].text;
+  }
+  return blocks;
+}
+function openaiUserContent(content, images) {
+  if (typeof content === "string")
+    return content;
+  const parts = content ?? [];
+  const blocks = [];
+  for (const part of parts) {
+    if (part.type === "text")
+      blocks.push({ type: "text", text: textOf(part) });
+    else if (part.type === "file" && images) {
+      const url = imageUrl(part);
+      if (url)
+        blocks.push({ type: "image_url", image_url: { url } });
+    }
+  }
+  if (blocks.every((b) => b.type === "text")) {
+    return blocks.map((b) => b.text).join(`
+`);
+  }
+  return blocks;
+}
+function anthropicBody(model, prompt, options) {
+  const paired = pairedToolCallIds(prompt);
+  const messages = [];
+  for (const message of prompt) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      messages.push({ role: "user", content: anthropicUserContent(message.content, options.images) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          const text = textOf(part);
+          if (text)
+            content.push({ type: "text", text });
+        } else if (part.type === "tool-call" && paired.has(String(part.toolCallId))) {
+          content.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input: part.input ?? {} });
+        }
+      }
+      if (content.length > 0)
+        messages.push({ role: "assistant", content });
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || !paired.has(String(part.toolCallId)))
+        continue;
+      messages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: part.toolCallId,
+            content: resultText(part)
+          }
+        ]
+      });
+    }
+  }
+  const system = systemText(prompt);
+  const body = { model, stream: true, messages, max_tokens: capTokens(options.maxOutputTokens) };
+  if (system)
+    body.system = [{ type: "text", text: system, cache_control: { type: "ephemeral" } }];
+  if (options.tools?.length) {
+    body.tools = options.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema ?? {} }));
+  }
+  if (options.temperature !== undefined)
+    body.temperature = options.temperature;
+  if (options.reasoningEffort)
+    body.reasoning_effort = options.reasoningEffort;
+  return body;
+}
+function openaiBody(model, prompt, options) {
+  const paired = pairedToolCallIds(prompt);
+  const messages = [];
+  const system = systemText(prompt);
+  if (system)
+    messages.push({ role: "system", content: system });
+  for (const message of prompt) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      messages.push({ role: "user", content: openaiUserContent(message.content, options.images) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const calls = message.content.filter((p) => p.type === "tool-call" && paired.has(String(p.toolCallId)));
+      const texts = message.content.filter((p) => p.type === "text").map(textOf).filter(Boolean);
+      const reasoning = message.content.filter((p) => p.type === "reasoning").map(textOf).join("");
+      if (calls.length > 0) {
+        messages.push({
+          role: "assistant",
+          ...reasoning ? { reasoning_content: reasoning } : {},
+          content: texts.length ? texts.join(`
+`) : null,
+          tool_calls: calls.map((c) => ({
+            id: c.toolCallId,
+            type: "function",
+            function: { name: c.toolName, arguments: JSON.stringify(c.input ?? {}) }
+          }))
+        });
+      } else if (texts.length > 0) {
+        messages.push({ role: "assistant", ...reasoning ? { reasoning_content: reasoning } : {}, content: texts.join(`
+`) });
+      }
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || !paired.has(String(part.toolCallId)))
+        continue;
+      messages.push({
+        role: "tool",
+        tool_call_id: part.toolCallId,
+        content: resultText(part)
+      });
+    }
+  }
+  const body = { model, stream: true, messages, max_tokens: capTokens(options.maxOutputTokens) };
+  if (options.tools?.length) {
+    body.tools = options.tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.inputSchema ?? {} }
+    }));
+  }
+  if (options.temperature !== undefined)
+    body.temperature = options.temperature;
+  if (options.reasoningEffort)
+    body.reasoning_effort = options.reasoningEffort;
+  body.stream_options = { include_usage: true };
+  return body;
+}
+function requestBody(lane, model, prompt, options) {
+  return lane === "anthropic" ? anthropicBody(model, prompt, options) : openaiBody(model, prompt, options);
+}
+
+// src/provider/index.ts
+var DEFAULT_BASE_URL = "https://api.commandcode.ai";
+function laneOf(modelId) {
+  const bare = modelId.includes("/") ? modelId.slice(modelId.lastIndexOf("/") + 1) : modelId;
+  return bare.toLowerCase().startsWith("claude") ? "anthropic" : "openai";
+}
+function endpoint(lane) {
+  return lane === "anthropic" ? "/provider/v1/messages" : "/provider/v1/chat/completions";
+}
+function effortFrom(options) {
+  const providerOptions = options.providerOptions ?? {};
+  const top = providerOptions.reasoning ?? providerOptions.reasoningEffort;
+  if (typeof top === "string")
+    return top;
+  const namespaced = providerOptions.commandcode;
+  if (namespaced && typeof namespaced === "object") {
+    const value = namespaced.reasoning ?? namespaced.reasoningEffort;
+    if (typeof value === "string")
+      return value;
+  }
+  return;
+}
+function toolsOf(options) {
+  const tools = options.tools ?? [];
+  if (tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: "description" in tool ? tool.description : undefined,
+    inputSchema: tool.inputSchema ?? {}
+  }));
+}
+function createCommandCode(options = {}, images = () => false) {
+  const baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const doFetch = options.fetch ?? fetch;
+  function model(modelId) {
+    const lane = laneOf(modelId);
+    return {
+      specificationVersion: "v3",
+      provider: "command-code",
+      modelId,
+      supportedUrls: {},
+      async doStream(callOptions) {
+        const body = requestBody(lane, modelId, callOptions.prompt, {
+          maxOutputTokens: callOptions.maxOutputTokens,
+          temperature: callOptions.temperature,
+          tools: toolsOf(callOptions),
+          reasoningEffort: effortFrom(callOptions) ?? options.reasoningEffort,
+          images: images(modelId)
+        });
+        const response = await doFetch(`${baseURL}${endpoint(lane)}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${options.apiKey ?? ""}`,
+            ...options.headers ?? {},
+            ...callOptions.headers ?? {}
+          },
+          body: JSON.stringify(body),
+          signal: callOptions.abortSignal
+        });
+        if (!response.ok || !response.body) {
+          const detail = await response.text().catch(() => "");
+          throw new Error(`command-code ${lane} ${response.status}: ${detail.slice(0, 300)}`);
+        }
+        const reducer = lane === "anthropic" ? anthropicReducer() : openaiReducer();
+        const stream = new ReadableStream({
+          async start(controller) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder;
+            const emit = (parts) => {
+              for (const part of parts)
+                controller.enqueue(part);
+            };
+            const decode = sseDecoder((event) => emit(reducer.feed(event)));
+            try {
+              for (;; ) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                decode(decoder.decode(value, { stream: true }));
+              }
+              emit(reducer.close());
+              controller.close();
+            } catch (error) {
+              controller.enqueue({ type: "error", error });
+              controller.close();
+            }
+          }
+        });
+        return { stream, response: { headers: Object.fromEntries(response.headers) } };
+      },
+      async doGenerate(callOptions) {
+        const { stream } = await this.doStream(callOptions);
+        const reader = stream.getReader();
+        const content = [];
+        let finish = { unified: "stop", raw: "unknown" };
+        let usage = {
+          inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 0, text: 0, reasoning: 0 }
+        };
+        const textOf = {};
+        const toolsById = new Map;
+        for (;; ) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          const part = value;
+          if (part.type === "text-delta")
+            textOf[String(part.id)] = (textOf[String(part.id)] ?? "") + String(part.delta);
+          else if (part.type === "reasoning-delta") {
+            content.push({ type: "reasoning", text: String(part.delta) });
+          } else if (part.type === "tool-input-start") {
+            toolsById.set(String(part.id), { name: String(part.toolName), input: "" });
+          } else if (part.type === "tool-input-delta") {
+            const buffer = toolsById.get(String(part.id));
+            if (buffer)
+              buffer.input += String(part.delta);
+          } else if (part.type === "tool-call") {
+            content.push({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            });
+          } else if (part.type === "finish") {
+            finish = part;
+            usage = part.usage;
+          }
+        }
+        for (const [id, value] of Object.entries(textOf))
+          content.push({ type: "text", text: value, id });
+        return {
+          content,
+          finishReason: finish.finishReason,
+          usage,
+          warnings: []
+        };
+      }
+    };
+  }
+  return { languageModel: model };
+}
+
 // src/v2.ts
 var PLUGIN_ID = "command-code";
 var PROVIDER_BASE = "https://api.commandcode.ai/provider/v1";
@@ -3149,6 +3797,17 @@ var commandCodeV2 = {
         method: { type: "key", label: "Command Code API key" }
       });
     });
+    const images = (modelId) => inputModalities(modelId).includes("image");
+    for (const lane of LANES) {
+      await ctx.aisdk.hook("sdk", (event) => {
+        const options = event.options ?? {};
+        event.sdk = createCommandCode({
+          apiKey: typeof options.apiKey === "string" ? options.apiKey : undefined,
+          baseURL: typeof options.baseURL === "string" ? options.baseURL : PROVIDER_BASE,
+          headers: options.headers
+        }, images);
+      }, { providerID: lane.id });
+    }
     const seed = staticSeedModels();
     await ctx.provider.transform((editor) => {
       for (const lane of LANES) {
@@ -3221,8 +3880,58 @@ var commandCodeV2 = {
     };
   }
 };
+// package.json
+var package_default = {
+  name: "@jeffreyjyz/opencode-command-code",
+  version: "0.3.0",
+  description: "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
+  scripts: {
+    build: "rm -rf dist && bun build src/index.ts --outdir dist --target bun --external @opencode-ai/plugin --external @opencode/plugin --external @opencode/plugin/tui && bun scripts/build-tui.ts && tsc -p tsconfig.build.json",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    "build:tui": "bun scripts/build-tui.ts",
+    "extract:catalog": "bun scripts/extract-catalog.ts"
+  },
+  dependencies: {
+    "@opentui/core": "^0.5.4",
+    "@opentui/solid": "^0.5.4",
+    "solid-js": "1.9.12",
+    zod: "4.1.8"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5",
+    "@opencode-ai/plugin": "*",
+    "@opencode/plugin": "^2.0.11",
+    "@ai-sdk/provider": "3.0.8"
+  },
+  files: [
+    "dist",
+    "tui.js",
+    "LICENSE"
+  ],
+  keywords: [
+    "opencode",
+    "command-code",
+    "plugin",
+    "provider",
+    "ai-sdk"
+  ],
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  }
+};
 
 // src/index.ts
+var PROVIDER_NPM = `${package_default.name}@${package_default.version}`;
 function tool(input) {
   return input;
 }
@@ -3318,18 +4027,18 @@ var CommandCodePlugin = async (_input) => {
           console.warn("[command-code] model list unavailable:", e);
         }
       }
-      const claudeDefs = split ? toModelDefs(split.claude, "command-code-anthropic", "@ai-sdk/anthropic") : {};
-      const openDefs = split ? toModelDefs(split.open, "command-code-openai", "@ai-sdk/openai-compatible", { field: "reasoning_content" }) : {};
+      const claudeDefs = split ? toModelDefs(split.claude, "command-code-anthropic", PROVIDER_NPM) : {};
+      const openDefs = split ? toModelDefs(split.open, "command-code-openai", PROVIDER_NPM, { field: "reasoning_content" }) : {};
       const userAnthropic = existing("command-code-anthropic");
       cfg.provider["command-code-anthropic"] = {
-        npm: userAnthropic.npm ?? "@ai-sdk/anthropic",
+        npm: userAnthropic.npm ?? PROVIDER_NPM,
         name: userAnthropic.name ?? "Command Code (Anthropic)",
         options: { baseURL: PROVIDER_BASE, ...userAnthropic.options },
         models: { ...claudeDefs, ...userAnthropic.models }
       };
       const userOpenai = existing("command-code-openai");
       cfg.provider["command-code-openai"] = {
-        npm: userOpenai.npm ?? "@ai-sdk/openai-compatible",
+        npm: userOpenai.npm ?? PROVIDER_NPM,
         name: userOpenai.name ?? "Command Code (OpenAI)",
         options: {
           baseURL: PROVIDER_BASE,
@@ -3352,7 +4061,7 @@ var CommandCodePlugin = async (_input) => {
           return a?.type === "api" && a.key ? { key: a.key } : undefined;
         });
         const split = await loadModels(key);
-        return toModelDefs(split.claude, "command-code-anthropic", "@ai-sdk/anthropic");
+        return toModelDefs(split.claude, "command-code-anthropic", PROVIDER_NPM);
       }
     },
     tool: {
@@ -3375,5 +4084,6 @@ var src_default = {
 };
 export {
   CommandCodePlugin,
+  createCommandCode,
   src_default as default
 };

package/dist/provider/index.d.ts

@@ -0,0 +1,22 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { type WireLane } from "./wire";
+export declare const DEFAULT_BASE_URL = "https://api.commandcode.ai";
+export interface CommandCodeProviderOptions {
+    /** Bearer key; the v2 host passes the resolved connection credential here. */
+    apiKey?: string;
+    baseURL?: string;
+    /** Extra headers (host-supplied), merged last. */
+    headers?: Record<string, string>;
+    /** Reasoning effort the host wants (`providerOptions.commandcode.reasoning`). */
+    reasoningEffort?: string;
+    /** Injected for tests. */
+    fetch?: typeof fetch;
+}
+export interface CommandCodeProvider {
+    languageModel(modelId: string): LanguageModelV3;
+}
+/** Claude models use the Anthropic wire; everything else chat completions. */
+export declare function laneOf(modelId: string): WireLane;
+/** True when the model advertises image input; the caller passes the table in. */
+export type ImagesFor = (modelId: string) => boolean;
+export declare function createCommandCode(options?: CommandCodeProviderOptions, images?: ImagesFor): CommandCodeProvider;

package/dist/provider/stream.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageModelV3FinishReason, LanguageModelV3StreamPart, LanguageModelV3Usage } from "@ai-sdk/provider";
+type Part = LanguageModelV3StreamPart;
+/** Split an SSE byte stream into JSON events, tolerating partial chunks. */
+export declare function sseDecoder(onEvent: (event: Record<string, unknown>) => void): (text: string) => void;
+/** Wire stop reason → unified v3 finish reason; unknown reasons completed. */
+export declare function finishReason(raw: string | undefined): LanguageModelV3FinishReason;
+/** Anthropic `message_start`/`message_delta` usage → v3 usage. */
+export declare function anthropicUsage(raw: Record<string, unknown>): LanguageModelV3Usage;
+/** OpenAI usage → v3 usage (`prompt_tokens_details.cached_tokens` is cache read). */
+export declare function openaiUsage(raw: Record<string, unknown>): LanguageModelV3Usage;
+export interface Reducer {
+    /** Feed one parsed SSE event; returns the parts it produced. */
+    feed(event: Record<string, unknown>): Part[];
+    /** Close open parts when the transport ends (abort/error). */
+    close(): Part[];
+}
+/** Anthropic Messages reducer. */
+export declare function anthropicReducer(): Reducer;
+/** OpenAI Chat Completions reducer. */
+export declare function openaiReducer(): Reducer;
+export {};

package/dist/provider/wire.d.ts

@@ -0,0 +1,22 @@
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
+export type WireLane = "anthropic" | "openai";
+/** The subset of tools we serialize (V3 FunctionTool already matches). */
+export interface WireTool {
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}
+export interface WireOptions {
+    maxOutputTokens?: number;
+    temperature?: number;
+    tools?: WireTool[];
+    /** Wire extension both gates honour (`reasoning_effort`). */
+    reasoningEffort?: string;
+    /** Whether the model advertises image input (catalog-derived). */
+    images: boolean;
+}
+/** Anthropic body: POST /provider/v1/messages. */
+export declare function anthropicBody(model: string, prompt: LanguageModelV3Prompt, options: WireOptions): Record<string, unknown>;
+/** OpenAI body: POST /provider/v1/chat/completions. */
+export declare function openaiBody(model: string, prompt: LanguageModelV3Prompt, options: WireOptions): Record<string, unknown>;
+export declare function requestBody(lane: WireLane, model: string, prompt: LanguageModelV3Prompt, options: WireOptions): Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "@jeffreyjyz/opencode-command-code",
- "version": "0.2.11",
+ "version": "0.3.0",
  "description": "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
  "type": "module",
  "main": "dist/index.js",
@@ -26,7 +26,8 @@
   "@types/bun": "latest",
   "typescript": "^5",
   "@opencode-ai/plugin": "*",
-  "@opencode/plugin": "^2.0.11"
+  "@opencode/plugin": "^2.0.11",
+  "@ai-sdk/provider": "3.0.8"
  },
  "files": [
   "dist",