opencode-cmd-provider 0.1.0

package/dist/src/provider/auth-key.js

@@ -0,0 +1,65 @@
+// src/provider/auth-key.ts — API-key resolution (PLAN #2 Part A)
+//
+// Port of pi-commandcode-provider `getApiKey` with an `options.apiKey`
+// precedent added (DESIGN §6.2). Precedence:
+//   1. options.apiKey — set by opencode from /connect credentials or config
+//   2. COMMANDCODE_API_KEY environment variable
+//   3. Legacy auth files: ~/.commandcode/auth.json, ~/.omp/agent/auth.json,
+//      ~/.pi/agent/auth.json (all three record shapes, malformed files skipped)
+// Returns undefined when no key is found (callers emit the AI SDK error).
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { isRecord, stringValue } from "./converters.js";
+function defaultAuthPaths(home) {
+    return [
+        join(home, ".commandcode", "auth.json"),
+        join(home, ".omp", "agent", "auth.json"),
+        join(home, ".pi", "agent", "auth.json"),
+    ];
+}
+function apiKeyFromCredentialRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const type = stringValue(value.type);
+    if (type === "api")
+        return stringValue(value.key);
+    if (type === "oauth")
+        return stringValue(value.access);
+    return stringValue(value.key) ?? stringValue(value.access);
+}
+export function resolveApiKey(options = {}) {
+    if (options.apiKey)
+        return options.apiKey;
+    const env = options.env ?? process.env;
+    if (env.COMMANDCODE_API_KEY)
+        return env.COMMANDCODE_API_KEY;
+    const home = options.homeDir?.() ?? homedir();
+    const authPaths = options.authPaths ?? defaultAuthPaths(home);
+    for (const authPath of authPaths) {
+        try {
+            if (!existsSync(authPath))
+                continue;
+            const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
+            if (!isRecord(parsed))
+                continue;
+            // Legacy: direct apiKey or commandcode field.
+            const apiKey = stringValue(parsed.apiKey);
+            if (apiKey)
+                return apiKey;
+            const commandcode = stringValue(parsed.commandcode);
+            if (commandcode)
+                return commandcode;
+            // pi stores OAuth credentials as {"commandcode": {"type":"oauth","access":"..."}}.
+            // The official Command Code CLI stores API credentials under "command-code".
+            const providerKey = apiKeyFromCredentialRecord(parsed.commandcode) ??
+                apiKeyFromCredentialRecord(parsed["command-code"]);
+            if (providerKey)
+                return providerKey;
+        }
+        catch {
+            // Ignore malformed or unreadable auth files.
+        }
+    }
+    return undefined;
+}

package/dist/src/provider/command-code-model.d.ts

@@ -0,0 +1,39 @@
+import type { LanguageModelV3, LanguageModelV3GenerateResult } from "@ai-sdk/provider";
+import type { LanguageModelV3StreamPart, ModelCallOptions } from "./aisdk-types.js";
+export interface CommandCodeModelOptions {
+    name?: string;
+    baseURL?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+    timeout?: number;
+    maxRetries?: number;
+    maxRetryDelayMs?: number;
+    authPaths?: readonly string[];
+}
+export declare class CommandCodeLanguageModel implements LanguageModelV3 {
+    private readonly options;
+    readonly specificationVersion: "v3";
+    readonly provider = "commandcode";
+    readonly modelId: string;
+    readonly supportsStructuredOutputs = false;
+    readonly supportsParallelCalls = false;
+    readonly supportedUrls: Record<string, RegExp[]>;
+    constructor(options: CommandCodeModelOptions, modelId: string);
+    private apiBase;
+    private costForModel;
+    doGenerate(options: ModelCallOptions): Promise<LanguageModelV3GenerateResult>;
+    doStream(options: ModelCallOptions): Promise<{
+        stream: ReadableStream<LanguageModelV3StreamPart>;
+        error?: unknown;
+    }>;
+    /**
+     * Runs one request/parse pass and collects the v3 parts (doGenerate).
+     * Stream errors surface as error parts; the first error part is also
+     * returned so doGenerate can throw it.
+     */
+    private runOnce;
+    private bodyFor;
+    private headersFor;
+    private runStream;
+}

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

@@ -0,0 +1,425 @@
+// src/provider/command-code-model.ts — AI SDK v3 LanguageModel for Command Code
+// (PLAN #8: doStream tracer bullet; doGenerate lands in #9)
+//
+// Port of pi's createStreamCommandCode loop (core.ts:159-741): SSE parse via
+// #3's stream helpers, retry/abort/timeout via retry.ts, redaction on every
+// surfaced error, v3 stream parts on the wire.
+import { randomUUID } from "node:crypto";
+import { resolveApiKey } from "./auth-key.js";
+import { messagesToCC, toolsToJson, systemPromptToText, getEnvironmentInfo, isRecord, } from "./converters.js";
+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 { modelSupportsImageInput } from "./modalities.js";
+import { isRetryableStatus, retryDelayMs, raceAbort, abortError, timeoutError, delay, } from "./retry.js";
+import { projectSlugFromPath } from "./project-slug.js";
+const COMMAND_CODE_CLI_VERSION = "1.15.1";
+const DEFAULT_GENERATE_MAX_TOKENS = 64_000;
+const DEFAULT_MAX_RETRIES = 0;
+const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
+const DEFAULT_BASE_URL = "https://api.commandcode.ai";
+function promptSystem(prompt) {
+    const system = prompt.filter((m) => m.role === "system").map((m) => m.content);
+    return system.length > 0 ? system.join("\n") : undefined;
+}
+function errorStream(message) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ type: "error", error: new Error(message) });
+            controller.close();
+        },
+    });
+}
+export class CommandCodeLanguageModel {
+    options;
+    specificationVersion = "v3";
+    provider = "commandcode";
+    modelId;
+    supportsStructuredOutputs = false;
+    supportsParallelCalls = false;
+    supportedUrls = {};
+    constructor(options, modelId) {
+        this.options = options;
+        this.modelId = modelId;
+    }
+    apiBase() {
+        return this.options.baseURL ?? DEFAULT_BASE_URL;
+    }
+    costForModel() {
+        return { cost: MODEL_COSTS[this.modelId] ?? ZERO_MODEL_COST };
+    }
+    async doGenerate(options) {
+        const { parts, error } = await this.runOnce(options);
+        if (error)
+            throw error;
+        const content = [];
+        let text = "";
+        let reasoning = "";
+        let finishReason = { unified: "other", raw: "unknown" };
+        let usage;
+        for (const part of parts) {
+            switch (part.type) {
+                case "text-delta":
+                    text += part.delta;
+                    break;
+                case "reasoning-delta":
+                    reasoning += part.delta;
+                    break;
+                case "tool-call":
+                    content.push({
+                        type: "tool-call",
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: part.input,
+                    });
+                    break;
+                case "finish":
+                    finishReason = part.finishReason;
+                    usage = part.usage;
+                    break;
+                case "error":
+                    throw part.error;
+                default:
+                    break;
+            }
+        }
+        if (text)
+            content.push({ type: "text", text });
+        if (reasoning)
+            content.push({ type: "reasoning", text: reasoning });
+        if (!usage) {
+            usage = {
+                inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+                outputTokens: { total: 0, text: 0, reasoning: 0 },
+            };
+        }
+        return { content, finishReason, usage, warnings: [] };
+    }
+    async doStream(options) {
+        return {
+            stream: this.runStream(this.bodyFor(options), this.headersFor(options), options.abortSignal, options),
+        };
+    }
+    /**
+     * Runs one request/parse pass and collects the v3 parts (doGenerate).
+     * Stream errors surface as error parts; the first error part is also
+     * returned so doGenerate can throw it.
+     */
+    async runOnce(options) {
+        const apiKey = resolveApiKey({
+            apiKey: this.options.apiKey,
+            authPaths: this.options.authPaths,
+        });
+        if (!apiKey) {
+            return {
+                parts: [],
+                error: new Error("No Command Code API key. Run /connect and select Command Code, set the COMMANDCODE_API_KEY env var, or configure an auth file."),
+            };
+        }
+        const parts = [];
+        const stream = this.runStream(this.bodyFor(options), this.headersFor(options), options.abortSignal, options, parts);
+        const reader = stream.getReader();
+        for (;;) {
+            const { done } = await reader.read();
+            if (done)
+                break;
+        }
+        await reader.cancel().catch(() => { });
+        const errorPart = parts.find((p) => p.type === "error");
+        return {
+            parts,
+            error: errorPart && errorPart.type === "error" ? errorPart.error : undefined,
+        };
+    }
+    bodyFor(options) {
+        const reasoningEffort = mappedReasoningEffort({
+            reasoning: isReasoningModel(this.modelId),
+            thinkingLevelMap: thinkingMetadataForModel(this.modelId)?.thinkingLevelMap,
+        }, {
+            reasoning: options.providerOptions?.reasoning ??
+                options.providerOptions?.reasoningEffort,
+        });
+        const maxTokens = Math.min(options.maxOutputTokens ?? DEFAULT_GENERATE_MAX_TOKENS, DEFAULT_GENERATE_MAX_TOKENS);
+        const allowImages = modelSupportsImageInput(this.modelId);
+        return {
+            config: {
+                workingDir: process.cwd(),
+                date: new Date().toISOString().split("T")[0],
+                environment: getEnvironmentInfo(),
+                structure: [],
+                isGitRepo: false,
+                currentBranch: "",
+                mainBranch: "",
+                gitStatus: "",
+                recentCommits: [],
+            },
+            memory: null,
+            taste: null,
+            skills: null,
+            params: {
+                model: this.modelId,
+                messages: messagesToCC(options.prompt, { allowImages }),
+                tools: toolsToJson((options.tools ?? [])
+                    .filter((tool) => tool.type === "function")
+                    .map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema,
+                }))),
+                system: systemPromptToText(promptSystem(options.prompt)),
+                max_tokens: maxTokens,
+                temperature: 0.3,
+                stream: true,
+                ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+            },
+            threadId: randomUUID(),
+        };
+    }
+    headersFor(options) {
+        const apiKey = resolveApiKey({
+            apiKey: this.options.apiKey,
+            authPaths: this.options.authPaths,
+        });
+        return {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey ?? ""}`,
+            "x-command-code-version": COMMAND_CODE_CLI_VERSION,
+            "x-cli-environment": "production",
+            "x-project-slug": projectSlugFromPath(process.cwd()),
+            "x-taste-learning": "true",
+            "x-co-flag": "false",
+            ...this.options.headers,
+            ...(options.headers ?? {}),
+        };
+    }
+    runStream(body, headers, signal, options, sink) {
+        const timeoutMs = this.options.timeout;
+        const maxRetries = this.options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const maxRetryDelayMs = this.options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+        const fetchImpl = this.options.fetch ?? fetch;
+        const url = `${this.apiBase()}/alpha/generate`;
+        const bodyStr = JSON.stringify(body);
+        return new ReadableStream({
+            start: async (streamController) => {
+                const emit = (part) => {
+                    sink?.push(part);
+                    streamController.enqueue(part);
+                };
+                const fail = (error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const part = {
+                        type: "error",
+                        error: new Error(redactCommandCodeErrorText(message)),
+                    };
+                    sink?.push(part);
+                    streamController.enqueue(part);
+                    streamController.close();
+                };
+                const key = resolveApiKey({
+                    apiKey: this.options.apiKey,
+                    authPaths: this.options.authPaths,
+                });
+                if (!key) {
+                    fail("No Command Code API key. Run /connect and select Command Code, set the COMMANDCODE_API_KEY env var, or configure an auth file.");
+                    return;
+                }
+                const handleEvent = (event) => {
+                    if (!isRecord(event))
+                        return false;
+                    try {
+                        const parts = ccEventToStreamPart(event);
+                        let finished = false;
+                        for (const part of parts) {
+                            if (part.type === "finish") {
+                                finished = true;
+                                const usage = part.usage;
+                                calculateCommandCodeCost(this.costForModel(), {
+                                    input: usage.inputTokens.total ?? 0,
+                                    output: usage.outputTokens.total ?? 0,
+                                    cacheRead: 0,
+                                    cacheWrite: 0,
+                                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                                });
+                            }
+                            emit(part);
+                        }
+                        return finished;
+                    }
+                    catch (streamError) {
+                        fail(streamError);
+                        return true;
+                    }
+                };
+                let reader;
+                const controller = new AbortController();
+                const onOuterAbort = () => controller.abort();
+                try {
+                    signal?.addEventListener("abort", onOuterAbort, { once: true });
+                    if (signal?.aborted)
+                        throw abortError("Aborted");
+                    let response;
+                    let finished = false;
+                    retryLoop: for (let attempt = 0;; attempt++) {
+                        const attemptController = new AbortController();
+                        let attemptTimedOut = false;
+                        let attemptTimeoutId;
+                        const clearAttemptTimeout = () => {
+                            if (attemptTimeoutId !== undefined) {
+                                clearTimeout(attemptTimeoutId);
+                                attemptTimeoutId = undefined;
+                            }
+                        };
+                        if (timeoutMs !== undefined) {
+                            attemptTimeoutId = setTimeout(() => {
+                                attemptTimedOut = true;
+                                attemptController.abort();
+                            }, timeoutMs);
+                        }
+                        const onOuterAbort2 = () => attemptController.abort();
+                        controller.signal.addEventListener("abort", onOuterAbort2, { once: true });
+                        const raceAttempt = (promise) => raceAbort(promise, attemptController.signal).catch((error) => {
+                            if (attemptTimedOut)
+                                throw timeoutError(timeoutMs);
+                            throw error;
+                        });
+                        try {
+                            try {
+                                response = await fetchImpl(url, {
+                                    method: "POST",
+                                    headers,
+                                    body: bodyStr,
+                                    signal: attemptController.signal,
+                                });
+                            }
+                            catch (fetchError) {
+                                if (controller.signal.aborted)
+                                    throw abortError("Aborted");
+                                if (attemptTimedOut) {
+                                    if (attempt < maxRetries)
+                                        continue retryLoop;
+                                    throw timeoutError(timeoutMs);
+                                }
+                                throw fetchError;
+                            }
+                            // --- HTTP-level retry ---
+                            if (!response.ok && isRetryableStatus(response.status)) {
+                                const retryAfter = response.headers.get("retry-after");
+                                const waitMs = retryDelayMs(attempt, retryAfter, maxRetryDelayMs);
+                                if (waitMs < 0) {
+                                    throw new Error(`Command Code API error ${response.status}: Retry-After delay exceeds max retry delay`);
+                                }
+                                if (attempt < maxRetries) {
+                                    await response.text().catch(() => "");
+                                    if (waitMs > 0)
+                                        await delay(waitMs, controller.signal);
+                                    continue retryLoop;
+                                }
+                            }
+                            if (!response.ok) {
+                                const errBody = await raceAttempt(response.text().catch(() => ""));
+                                let errorDetail;
+                                try {
+                                    const parsedBody = JSON.parse(errBody);
+                                    errorDetail = commandCodeErrorMessage(parsedBody);
+                                }
+                                catch {
+                                    // Preserve useful plain-text provider errors only after secret
+                                    // redaction; upstream/proxy bodies may echo credentials.
+                                }
+                                const safeBody = redactCommandCodeErrorText(errBody).slice(0, 500);
+                                const detail = redactCommandCodeErrorText(errorDetail ?? (safeBody || "Provider returned an error"));
+                                throw new Error(`Command Code API error ${response.status}: ${detail}`);
+                            }
+                            // --- Read response stream ---
+                            reader = response.body?.getReader();
+                            if (!reader)
+                                throw new Error("No response body");
+                            const decoder = new TextDecoder();
+                            let buffer = "";
+                            readLoop: for (;;) {
+                                if (controller.signal.aborted)
+                                    throw abortError("Aborted");
+                                const { done, value } = await raceAbort(reader.read(), attemptController.signal);
+                                if (done) {
+                                    if (buffer.trim())
+                                        handleEvent(parseStreamEventLine(buffer));
+                                    break;
+                                }
+                                if (controller.signal.aborted)
+                                    throw abortError("Aborted");
+                                buffer += decoder.decode(value, { stream: true });
+                                const lines = buffer.split("\n");
+                                buffer = lines.pop() ?? "";
+                                for (const line of lines) {
+                                    if (controller.signal.aborted)
+                                        throw abortError("Aborted");
+                                    if (handleEvent(parseStreamEventLine(line))) {
+                                        finished = true;
+                                        break readLoop;
+                                    }
+                                }
+                            }
+                            // Stream completed successfully.
+                            break retryLoop;
+                        }
+                        catch (streamError) {
+                            // Stream-level error (e.g. API returned 200 OK but sent an error
+                            // event) or per-attempt timeout during stream reading.
+                            await reader?.cancel().catch(() => { });
+                            try {
+                                reader?.releaseLock();
+                            }
+                            catch { }
+                            reader = undefined;
+                            if (controller.signal.aborted)
+                                throw streamError;
+                            // Never retry after visible content was emitted (including timeout mid-stream).
+                            const canRetry = !finished && attempt < maxRetries;
+                            if (canRetry) {
+                                finished = false;
+                                const waitMs = attemptTimedOut ? 0 : retryDelayMs(attempt, null, maxRetryDelayMs);
+                                if (waitMs > 0)
+                                    await delay(waitMs, controller.signal);
+                                continue retryLoop;
+                            }
+                            if (attemptTimedOut)
+                                throw timeoutError(timeoutMs);
+                            throw streamError;
+                        }
+                        finally {
+                            controller.signal.removeEventListener("abort", onOuterAbort2);
+                            clearAttemptTimeout();
+                        }
+                    }
+                    if (!finished) {
+                        // The server closed the stream without a finish event; the AI SDK
+                        // expects a finish part to terminate a stream.
+                        emit({
+                            type: "finish",
+                            finishReason: { unified: "stop", raw: "stop" },
+                            usage: {
+                                inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+                                outputTokens: { total: 0, text: 0, reasoning: 0 },
+                            },
+                        });
+                    }
+                    streamController.close();
+                }
+                catch (error) {
+                    if (controller.signal.aborted) {
+                        // Outer abort: emit a proper AbortError part (AI SDK contract).
+                        fail(abortError());
+                    }
+                    else {
+                        fail(error);
+                    }
+                }
+                finally {
+                    signal?.removeEventListener("abort", onOuterAbort);
+                }
+            },
+        });
+    }
+}

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

@@ -0,0 +1,33 @@
+export { toJsonSchema } from "./json-schema.js";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function stringValue(value: unknown): string | undefined;
+export declare function recordArray(value: unknown): readonly Record<string, unknown>[];
+export declare function recordOrEmpty(value: unknown): Record<string, unknown>;
+export declare function numberValue(value: unknown): number | undefined;
+export type CCImagePart = {
+    type: "image";
+    image: string;
+    mimeType: string;
+};
+export type CCContentPart = {
+    type: "text";
+    text: string;
+} | CCImagePart;
+type PromptLike = readonly {
+    role?: unknown;
+    content?: unknown;
+}[];
+export declare function assertTextOnlyMessages(messages?: PromptLike): void;
+export declare function textContent(message: {
+    content?: unknown;
+}): string;
+export declare function getEnvironmentInfo(): string;
+export interface SdkTool {
+    description?: string;
+    parameters: unknown;
+}
+export declare function toolsToJson(tools?: Record<string, SdkTool> | readonly SdkTool[]): unknown[];
+export declare function messagesToCC(messages: PromptLike, options?: {
+    allowImages?: boolean;
+}): unknown[];
+export declare function systemPromptToText(value: unknown): string;