@darthph0enix/commandcode-go-opencode-provider 0.5.0

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@darthph0enix/commandcode-go-opencode-provider",
+  "version": "0.5.0",
+  "author": "Brent Weatherall",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Darthph0enix7/opencode-commandcode-provider.git"
+  },
+  "main": "index.ts",
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "ai": "6.0.191",
+    "typescript": "^6.0.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.ts"
+    },
+    "./server": {
+      "import": "./plugin.ts"
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/Darthph0enix7/opencode-commandcode-provider/issues"
+  },
+  "description": "Command Code API provider for opencode — use Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, MiniMax, and Step models via Command Code",
+  "engines": { "bun": ">=1.0.0" },
+  "files": ["index.ts", "plugin.ts", "models.json", "src/"],
+  "homepage": "https://github.com/Darthph0enix7/opencode-commandcode-provider#readme",
+  "keywords": [
+    "opencode",
+    "opencode-provider",
+    "opencode-plugin",
+    "commandcode",
+    "ai",
+    "llm",
+    "claude",
+    "gpt",
+    "gemini",
+    "deepseek",
+    "qwen",
+    "kimi",
+    "glm",
+    "minimax"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "test": "bun test tests/unit/",
+    "test:integration": "bun test tests/integration/",
+    "test:all": "bun test",
+    "typecheck": "tsc --noEmit",
+    "generate-readme": "bun run scripts/generate-readme.ts",
+    "sync": "bun run scripts/sync-models.ts",
+    "sync:global": "bun run scripts/sync-models.ts --update-global"
+  },
+  "type": "module",
+  "types": "index.ts",
+  "peerDependencies": {
+    "ai": ">=6.0.0"
+  }
+}

package/plugin.ts

@@ -0,0 +1,75 @@
+import { loadSyncedModels } from "./src/model-sync.js"
+
+function toConfigKey(id: string): string {
+  const slashIdx = id.indexOf("/")
+  const short = slashIdx >= 0 ? id.slice(slashIdx + 1) : id
+  return short.toLowerCase()
+}
+
+export default async function commandcodePlugin() {
+  return {
+    config: async (config: Record<string, unknown>) => {
+      const providers = config.provider as Record<string, Record<string, unknown>> | undefined
+      if (!providers) {
+        (config as Record<string, unknown>).provider = { commandcode: {} }
+      }
+      const cc = ((config as Record<string, unknown>).provider as Record<string, Record<string, unknown>>)?.commandcode as Record<string, unknown> | undefined
+      if (!cc) return
+
+      if (!cc.npm) cc.npm = "commandcode-go-opencode-provider"
+      if (!cc.name) cc.name = "Command Code"
+      if (!cc.env) cc.env = ["COMMANDCODE_API_KEY"]
+
+      if (!cc.models) {
+        const { models } = await loadSyncedModels()
+        const modelsObj: Record<string, unknown> = {}
+        for (const entry of models) {
+          const key = toConfigKey(entry.id)
+          const costObj: Record<string, number> = { input: entry.cost.input, output: entry.cost.output }
+          if (entry.cost.cache_read !== undefined) costObj.cache_read = entry.cost.cache_read
+          if (entry.cost.cache_write !== undefined) costObj.cache_write = entry.cost.cache_write
+
+          modelsObj[key] = {
+            id: entry.id,
+            name: entry.name,
+            reasoning: entry.reasoning,
+            tool_call: entry.tool_call,
+            attachment: entry.attachment ?? (entry.modalities?.input?.some((m) => m !== "text") ?? false),
+            modalities: entry.modalities ?? { input: ["text"], output: ["text"] },
+            variants: entry.variants,
+            cost: costObj,
+            limit: entry.limit,
+          }
+        }
+        cc.models = modelsObj
+      }
+    },
+
+    auth: {
+      provider: "commandcode",
+      methods: [
+        {
+          type: "api",
+          label: "API Key",
+          authorize: async (inputs: Record<string, unknown> | undefined) => {
+            const rawKey = inputs?.key
+            if (typeof rawKey !== "string") return { type: "failed" as const }
+            const key = rawKey.trim()
+            if (!key) return { type: "failed" as const }
+            return { type: "success" as const, key }
+          },
+        },
+      ],
+      loader: async (getAuth: () => Promise<{ type: string; key?: string } | null>) => {
+        try {
+          const auth = await getAuth()
+          if (!auth) return {}
+          if (auth.type === "api" && auth.key) return { apiKey: auth.key }
+          return {}
+        } catch {
+          return {}
+        }
+      },
+    },
+  }
+}

package/src/auth.ts

@@ -0,0 +1,42 @@
+import { readFileSync, existsSync } from "fs"
+import { homedir } from "os"
+import { join } from "path"
+
+export function resolveApiKey(options: {
+  apiKey?: string
+  env?: Record<string, string | undefined>
+}): string | undefined {
+  if (options.apiKey) return options.apiKey
+
+  const envKey = options.env?.COMMANDCODE_API_KEY ?? process.env.COMMANDCODE_API_KEY
+  if (envKey) return envKey
+
+  const authPaths = [
+    join(homedir(), ".commandcode", "auth.json"),
+    join(homedir(), ".pi", "agent", "auth.json"),
+  ]
+
+  for (const p of authPaths) {
+    if (!existsSync(p)) continue
+    try {
+      const parsed = JSON.parse(readFileSync(p, "utf-8"))
+      if (typeof parsed === "object" && parsed !== null) {
+        if (typeof parsed.apiKey === "string") return parsed.apiKey
+        if (typeof parsed.commandcode === "string") return parsed.commandcode
+        if (
+          typeof parsed.commandcode === "object" &&
+          parsed.commandcode !== null &&
+          parsed.commandcode.type === "oauth" &&
+          typeof parsed.commandcode.access === "string"
+        ) {
+          return parsed.commandcode.access
+        }
+      }
+    } catch {
+      // intentionally silent: skip unreadable or malformed auth files
+      continue
+    }
+  }
+
+  return undefined
+}

package/src/convert.ts

@@ -0,0 +1,308 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider"
+import type {
+  LanguageModelV3FunctionTool,
+  LanguageModelV3Message,
+  LanguageModelV3TextPart,
+  LanguageModelV3ReasoningPart,
+  LanguageModelV3ToolCallPart,
+  LanguageModelV3ToolResultPart,
+  LanguageModelV3ToolResultOutput,
+} from "@ai-sdk/provider"
+
+type CCMessage =
+  | { role: "user"; content: string | unknown[] }
+  | { role: "assistant"; content: CCAssistantContent[] }
+  | { role: "tool"; content: CCToolResultContent[] }
+
+type CCAssistantContent =
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "tool-call"; toolCallId: string; toolName: string; input: unknown }
+
+type CCToolResultContent = {
+  type: "tool-result"
+  toolCallId: string
+  toolName: string
+  output: { type: "text"; value: string } | { type: "error-text"; value: string }
+}
+
+type CCTool = {
+  type: "function"
+  name: string
+  description?: string
+  input_schema: unknown
+}
+
+interface CCRequestEnvelope {
+  config: {
+    workingDir: string
+    date: string
+    environment: string
+    structure: unknown[]
+    isGitRepo: boolean
+    currentBranch: string
+    mainBranch: string
+    gitStatus: string
+    recentCommits: unknown[]
+  }
+  memory: string
+  taste: string
+  skills: null
+  permissionMode: string
+  params: {
+    model: string
+    messages: CCMessage[]
+    tools: CCTool[]
+    system: string
+    max_tokens: number
+    stream: true
+    temperature?: number
+    top_p?: number
+    top_k?: number
+    reasoning_effort?: string
+  }
+}
+
+function hasType(p: unknown, type: string): boolean {
+  return typeof p === "object" && p !== null && (p as { type?: string }).type === type
+}
+
+function isTextPart(p: unknown): p is LanguageModelV3TextPart {
+  return hasType(p, "text")
+}
+
+function isReasoningPart(p: unknown): p is LanguageModelV3ReasoningPart {
+  return hasType(p, "reasoning")
+}
+
+function isToolCallPart(p: unknown): p is LanguageModelV3ToolCallPart {
+  return hasType(p, "tool-call")
+}
+
+function isToolResultPart(p: unknown): p is LanguageModelV3ToolResultPart {
+  return hasType(p, "tool-result")
+}
+
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content
+  if (Array.isArray(content)) {
+    const textParts = content.filter(isTextPart) as LanguageModelV3TextPart[]
+    return textParts.map((p) => p.text).join("\n")
+  }
+  return ""
+}
+
+function toDataUriOrUrl(data: string | Uint8Array | URL, defaultMime: string = "image/png"): string {
+  if (typeof data === "string") {
+    if (data.startsWith("data:") || data.startsWith("http://") || data.startsWith("https://")) {
+      return data
+    }
+    return `data:${defaultMime};base64,${data}`
+  }
+  if (data instanceof URL) {
+    return data.toString()
+  }
+  if (data instanceof Uint8Array || (typeof Buffer !== "undefined" && Buffer.isBuffer(data))) {
+    const b64 = Buffer.from(data).toString("base64")
+    return `data:${defaultMime};base64,${b64}`
+  }
+  return String(data)
+}
+
+function convertUserContent(content: unknown): string | Array<{ type: string; [key: string]: unknown }> {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+
+  const parts: Array<{ type: string; [key: string]: unknown }> = []
+  let hasMultimodal = false
+
+  for (const p of content) {
+    if (!p || typeof p !== "object") continue
+    const item = p as Record<string, unknown>
+
+    if (item.type === "text" && typeof item.text === "string") {
+      parts.push({ type: "text", text: item.text })
+    } else if (item.type === "image" && item.image) {
+      hasMultimodal = true
+      const mimeType = typeof item.mimeType === "string" ? item.mimeType : "image/png"
+      const imgUrl = toDataUriOrUrl(item.image as string | Uint8Array | URL, mimeType)
+      parts.push({ type: "image", image: imgUrl, mimeType })
+    } else if (item.type === "file" && item.data) {
+      const mimeType = typeof item.mimeType === "string" ? item.mimeType : "application/octet-stream"
+      if (mimeType.startsWith("image/")) {
+        hasMultimodal = true
+        const imgUrl = toDataUriOrUrl(item.data as string | Uint8Array | URL, mimeType)
+        parts.push({ type: "image", image: imgUrl, mimeType })
+      } else if (typeof item.data === "string" && !item.data.startsWith("data:")) {
+        parts.push({ type: "text", text: item.data })
+      }
+    }
+  }
+
+  if (!hasMultimodal) {
+    return parts.map((p) => (p.type === "text" ? String(p.text) : "")).join("\n")
+  }
+  return parts
+}
+
+function convertToolResultOutput(output: LanguageModelV3ToolResultOutput): CCToolResultContent["output"] {
+  switch (output.type) {
+    case "text":
+      return { type: "text", value: output.value }
+    case "error-text":
+      return { type: "error-text", value: output.value }
+    case "json":
+      return { type: "text", value: JSON.stringify(output.value) }
+    case "execution-denied":
+      return { type: "error-text", value: output.reason ?? "Execution denied" }
+    case "error-json":
+      return { type: "error-text", value: JSON.stringify(output.value) }
+    case "content":
+      return { type: "text", value: output.value.map((v: Record<string, unknown>) => ("text" in v ? v.text : JSON.stringify(v))).join("\n") }
+    default:
+      return { type: "text", value: JSON.stringify(output) }
+  }
+}
+
+function convertMessage(msg: LanguageModelV3Message): CCMessage | null {
+  switch (msg.role) {
+    case "user": {
+      const content = convertUserContent(msg.content)
+      return { role: "user", content: content as any }
+    }
+    case "assistant": {
+      const parts: CCAssistantContent[] = []
+      for (const part of msg.content) {
+        if (isTextPart(part)) {
+          parts.push({ type: "text", text: part.text })
+        } else if (isReasoningPart(part)) {
+          parts.push({ type: "reasoning", text: part.text })
+        } else if (isToolCallPart(part)) {
+          parts.push({
+            type: "tool-call",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.input,
+          })
+        }
+      }
+      return { role: "assistant", content: parts }
+    }
+    case "tool": {
+      const parts: CCToolResultContent[] = []
+      for (const part of msg.content) {
+        if (isToolResultPart(part)) {
+          parts.push({
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            output: convertToolResultOutput(part.output),
+          })
+        }
+      }
+      return { role: "tool", content: parts }
+    }
+    default:
+      return null
+  }
+}
+
+function convertTools(
+  tools: Array<LanguageModelV3FunctionTool | { type: "provider"; id: `${string}.${string}`; name: string; args: Record<string, unknown> }> | undefined,
+): CCTool[] {
+  if (!tools) return []
+  return tools
+    .filter((t): t is LanguageModelV3FunctionTool => t.type === "function")
+    .map((t) => ({
+      type: "function" as const,
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema,
+    }))
+}
+
+function extractReasoningEffort(options: LanguageModelV3CallOptions): string | undefined {
+  const opt = options as Record<string, unknown>
+  if (typeof opt.reasoning_effort === "string") return opt.reasoning_effort
+  if (typeof opt.reasoningEffort === "string") return opt.reasoningEffort
+  if (typeof opt.effort === "string") return opt.effort
+  if (typeof opt.variant === "string") return opt.variant
+
+  if (opt.providerOptions && typeof opt.providerOptions === "object") {
+    const po = opt.providerOptions as Record<string, unknown>
+    for (const key of Object.keys(po)) {
+      const val = po[key]
+      if (val && typeof val === "object") {
+        const sub = val as Record<string, unknown>
+        if (typeof sub.reasoning_effort === "string") return sub.reasoning_effort
+        if (typeof sub.reasoningEffort === "string") return sub.reasoningEffort
+        if (typeof sub.effort === "string") return sub.effort
+        if (typeof sub.variant === "string") return sub.variant
+      }
+    }
+  }
+
+  if (opt.options && typeof opt.options === "object") {
+    const sub = opt.options as Record<string, unknown>
+    if (typeof sub.reasoning_effort === "string") return sub.reasoning_effort
+    if (typeof sub.reasoningEffort === "string") return sub.reasoningEffort
+    if (typeof sub.effort === "string") return sub.effort
+    if (typeof sub.variant === "string") return sub.variant
+  }
+
+  return undefined
+}
+
+export function buildRequest(
+  modelId: string,
+  options: LanguageModelV3CallOptions,
+): CCRequestEnvelope {
+  let systemPrompt = ""
+  const messages: CCMessage[] = []
+
+  for (const msg of options.prompt) {
+    if (msg.role === "system") {
+      systemPrompt += (systemPrompt ? "\n\n" : "") + msg.content
+      continue
+    }
+    const converted = convertMessage(msg)
+    if (converted) messages.push(converted)
+  }
+
+  const effort = extractReasoningEffort(options)
+
+  const params: CCRequestEnvelope["params"] = {
+    model: modelId,
+    messages,
+    tools: convertTools(options.tools),
+    system: systemPrompt,
+    max_tokens: options.maxOutputTokens ?? 16384,
+    stream: true,
+    ...(effort ? { reasoning_effort: effort } : {}),
+  }
+
+  if (options.temperature !== undefined) params.temperature = options.temperature
+  if (options.topP !== undefined) params.top_p = options.topP
+  if (options.topK !== undefined) params.top_k = options.topK
+
+  return {
+    config: {
+      workingDir: process.cwd() ?? "/",
+      date: new Date().toISOString().split("T")[0] ?? "",
+      environment: `${process.platform}-${process.arch}`,
+      // Stub: opencode does not expose project structure context
+      structure: [],
+      isGitRepo: false,
+      currentBranch: "",
+      mainBranch: "",
+      gitStatus: "",
+      recentCommits: [],
+    },
+    memory: "",
+    // Stub: taste/memory/permissionMode are Command Code CLI features not exposed via provider API
+    taste: "",
+    skills: null,
+    permissionMode: "standard",
+    params,
+  }
+}