opencode-cmd-provider 1.2.2 → 1.4.0

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

@@ -31,3 +31,21 @@ export declare function messagesToCC(messages: PromptLike, options?: {
     allowImages?: boolean;
 }): unknown[];
 export declare function systemPromptToText(value: unknown): string;
+declare function openAITools(tools: unknown): unknown[] | undefined;
+declare function anthropicTools(tools: unknown): unknown[] | undefined;
+export interface ProviderRequestOptions {
+    prompt: PromptLike;
+    model?: string;
+    maxOutputTokens?: number;
+    providerOptions?: unknown;
+    tools?: unknown;
+    allowImages?: boolean;
+    systemPrompt?: unknown;
+}
+export declare function messagesToOpenAI(prompt: PromptLike, options?: Omit<ProviderRequestOptions, "prompt"> & {
+    prompt?: PromptLike;
+}): Record<string, unknown>;
+export declare function messagesToAnthropic(prompt: PromptLike, options?: Omit<ProviderRequestOptions, "prompt"> & {
+    prompt?: PromptLike;
+}): Record<string, unknown>;
+export { openAITools, anthropicTools };

package/dist/src/provider/converters.js

@@ -1,5 +1,10 @@
 // src/provider/converters.ts — AI SDK v3 messages → Command Code payload (PLAN #2 Part B)
 //
+// Provider API shapes are documented at https://commandcode.ai/docs/provider:
+// - POST /provider/v1/chat/completions follows OpenAI Chat Completions schema
+// - POST /provider/v1/messages follows Anthropic Messages schema
+// - Text + images only; audio/file/document rejected by schema (FAQ)
+//
 // Port of pi-commandcode-provider/src/converters.ts. Input is the AI SDK v3
 // prompt format (LanguageModelV3Message / LanguageModelV3Prompt):
 //
@@ -13,7 +18,9 @@
 // shapes. `getApiKey` lives in ./auth-key.ts; `parseStreamEventLine` and
 // `mapFinishReason` are issue #3.
 import { toJsonSchema } from "./json-schema.js";
+import { isReasoningModel, mappedReasoningEffort, resolveProviderReasoning, thinkingMetadataForModel, } from "./reasoning.js";
 export { toJsonSchema } from "./json-schema.js";
+const DEFAULT_PROVIDER_MAX_TOKENS = 64_000;
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -45,13 +52,35 @@ export function numberValue(value) {
 }
 function imageParts(value) {
     if (isRecord(value))
-        return value.type === "image" || value.type === "file" ? [value] : [];
-    return recordArray(value).filter((part) => part.type === "image" ||
-        (part.type === "file" && stringValue(part.mediaType)?.startsWith("image/")));
+        return isImageFilePart(value) ? [value] : [];
+    return recordArray(value).filter((part) => isImageFilePart(part));
 }
 function imageContentError(role) {
     return new Error(`Selected Command Code model does not support image content in ${role}`);
 }
+function nonImageFileError(part, role) {
+    const mime = stringValue(part.mediaType) ?? stringValue(part.mimeType) ?? "unknown type";
+    return new Error(`Selected Command Code model only accepts text and images, but ${role} contain a non-image file (${mime}). Remove the attachment or convert it to an image.`);
+}
+function hasImageMediaType(part) {
+    const mime = stringValue(part.mediaType) ?? stringValue(part.mimeType);
+    // A `file` part must declare an image/* media type to be forwarded as an
+    // image; a `file` with no verifiable image type (and any non-image type) is
+    // rejected, since the Provider API accepts text + images only.
+    return mime !== undefined && mime.toLowerCase().startsWith("image/");
+}
+/** True for an `image` part or a `file` part carrying an image/* media type
+ * (mediaType or mimeType). Shared by the rejection guard and the content
+ * encoders so the image classification is consistent everywhere. */
+function isImageFilePart(part) {
+    return part.type === "image" || (part.type === "file" && hasImageMediaType(part));
+}
+function assertProviderContentParts(parts, role) {
+    for (const part of parts) {
+        if (part.type === "file" && !hasImageMediaType(part))
+            throw nonImageFileError(part, role);
+    }
+}
 export function assertTextOnlyMessages(messages) {
     for (const message of messages ?? []) {
         if (imageParts(message.content).length > 0) {
@@ -274,3 +303,435 @@ export function systemPromptToText(value) {
             .join("\n\n");
     return promptPartToText(value, 0);
 }
+function promptSystemText(prompt) {
+    const system = prompt.filter((m) => m.role === "system").map((m) => m.content);
+    return systemPromptToText(system.length > 0 ? system.join("\n") : undefined);
+}
+function cappedMaxTokens(value) {
+    const n = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_PROVIDER_MAX_TOKENS;
+    return Math.min(n, DEFAULT_PROVIDER_MAX_TOKENS);
+}
+function reasoningEffortFor(providerOptions, modelId) {
+    try {
+        const effort = mappedReasoningEffort({
+            reasoning: modelId ? isReasoningModel(modelId) : true,
+            thinkingLevelMap: modelId ? thinkingMetadataForModel(modelId)?.thinkingLevelMap : undefined,
+        }, { reasoning: resolveProviderReasoning(providerOptions, "commandcode") });
+        return effort;
+    }
+    catch {
+        return undefined;
+    }
+}
+function dataToBase64(data) {
+    if (typeof data === "string")
+        return data;
+    if (data instanceof Uint8Array)
+        return Buffer.from(data).toString("base64");
+    if (ArrayBuffer.isView(data))
+        return Buffer.from(data).toString("base64");
+    if (data instanceof ArrayBuffer)
+        return Buffer.from(new Uint8Array(data)).toString("base64");
+    return undefined;
+}
+function toDataUrl(data, mediaType) {
+    const mime = stringValue(mediaType) ?? "application/octet-stream";
+    const raw = dataToBase64(data);
+    if (!raw || raw.length === 0)
+        return undefined;
+    if (raw.startsWith("data:"))
+        return raw;
+    return `data:${mime};base64,${raw}`;
+}
+function filePartToOpenAIImageUrl(part) {
+    const url = toDataUrl(part.data ?? part.image, part.mediaType ?? part.mimeType);
+    if (!url)
+        return undefined;
+    return { type: "image_url", image_url: { url } };
+}
+function filePartToAnthropicImage(part) {
+    const mime = stringValue(part.mediaType) ?? stringValue(part.mimeType) ?? "image/png";
+    let b64;
+    const raw = part.data ?? part.image;
+    if (typeof raw === "string") {
+        if (raw.startsWith("data:")) {
+            const after = raw.split(";base64,")[1];
+            b64 = after ?? raw;
+            const mimeFromUrl = raw.slice(5).split(";")[0];
+            if (mimeFromUrl) {
+                // prefer mime from data URL if present
+                return { type: "image", source: { type: "base64", media_type: mimeFromUrl, data: b64 } };
+            }
+        }
+        else {
+            b64 = raw;
+        }
+    }
+    else {
+        b64 = dataToBase64(raw);
+    }
+    if (!b64)
+        return undefined;
+    return { type: "image", source: { type: "base64", media_type: mime, data: b64 } };
+}
+function textFromPart(part) {
+    return stringValue(part.text) ?? "";
+}
+function openAIUserContent(content, allowImages) {
+    if (typeof content === "string")
+        return content;
+    const parts = recordArray(content);
+    assertProviderContentParts(parts, "user messages");
+    const hasImages = parts.some(isImageFilePart);
+    if (!hasImages) {
+        const texts = parts.filter((p) => p.type === "text").map(textFromPart);
+        if (parts.every((p) => p.type === "text"))
+            return texts.join("\n");
+        const out = [];
+        for (const p of parts) {
+            if (p.type === "text")
+                out.push({ type: "text", text: textFromPart(p) });
+            else if (isImageFilePart(p)) {
+                if (!allowImages)
+                    throw imageContentError("user messages");
+                const img = filePartToOpenAIImageUrl(p);
+                if (img)
+                    out.push(img);
+            }
+        }
+        return out;
+    }
+    if (!allowImages)
+        throw imageContentError("user messages");
+    const out = [];
+    for (const p of parts) {
+        if (p.type === "text")
+            out.push({ type: "text", text: textFromPart(p) });
+        else if (isImageFilePart(p)) {
+            const img = filePartToOpenAIImageUrl(p);
+            if (img)
+                out.push(img);
+        }
+    }
+    return out;
+}
+function anthropicUserContent(content, allowImages) {
+    if (typeof content === "string")
+        return content;
+    const parts = recordArray(content);
+    assertProviderContentParts(parts, "user messages");
+    const hasImages = parts.some(isImageFilePart);
+    // Anthropic docs show string content for simple text: "Count to 5."
+    // Return string for single text-only part to match documented shape, array otherwise
+    if (!hasImages && parts.length === 1 && parts[0]?.type === "text") {
+        return textFromPart(parts[0]);
+    }
+    if (!hasImages && parts.every((p) => p.type === "text")) {
+        // Join multiple text parts with newline — provider accepts string for simple cases
+        const texts = parts.map((p) => textFromPart(p)).filter(Boolean);
+        if (texts.length === 1)
+            return texts[0];
+        // For multiple texts, keep array form to preserve structure
+    }
+    const out = [];
+    for (const p of parts) {
+        if (p.type === "text")
+            out.push({ type: "text", text: textFromPart(p) });
+        else if (isImageFilePart(p)) {
+            if (!allowImages)
+                throw imageContentError("user messages");
+            const img = filePartToAnthropicImage(p);
+            if (img)
+                out.push(img);
+        }
+    }
+    return out;
+}
+function openAITools(tools) {
+    if (!tools)
+        return undefined;
+    let entries;
+    if (Array.isArray(tools)) {
+        entries = tools.map((t) => [
+            stringValue(t.name) ?? "",
+            t,
+        ]);
+    }
+    else if (isRecord(tools)) {
+        entries = Object.entries(tools);
+    }
+    else {
+        return undefined;
+    }
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([name, tool]) => {
+        const rec = isRecord(tool) ? tool : {};
+        const description = stringValue(rec.description);
+        const parameters = rec.parameters ?? rec.inputSchema ?? {};
+        return {
+            type: "function",
+            function: {
+                name,
+                description,
+                parameters: toJsonSchema(parameters),
+            },
+        };
+    });
+}
+function anthropicTools(tools) {
+    if (!tools)
+        return undefined;
+    let entries;
+    if (Array.isArray(tools)) {
+        entries = tools.map((t) => [
+            stringValue(t.name) ?? "",
+            t,
+        ]);
+    }
+    else if (isRecord(tools)) {
+        entries = Object.entries(tools);
+    }
+    else {
+        return undefined;
+    }
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([name, tool]) => {
+        const rec = isRecord(tool) ? tool : {};
+        const description = stringValue(rec.description);
+        const parameters = rec.parameters ?? rec.inputSchema ?? {};
+        return {
+            name,
+            description,
+            input_schema: toJsonSchema(parameters),
+        };
+    });
+}
+function promptToOpenAIMessages(prompt, allowImages) {
+    const out = [];
+    const system = promptSystemText(prompt);
+    if (system)
+        out.push({ role: "system", content: system });
+    const pairedIds = completeToolCallIds(prompt);
+    for (const message of prompt) {
+        if (message.role === "system")
+            continue;
+        if (message.role === "user") {
+            out.push({ role: "user", content: openAIUserContent(message.content, allowImages) });
+        }
+        else if (message.role === "assistant") {
+            const parts = recordArray(message.content);
+            const toolCalls = parts
+                .filter((p) => p.type === "tool-call")
+                .filter((p) => {
+                const id = stringValue(p.toolCallId);
+                return id ? pairedIds.has(id) : false;
+            });
+            const texts = parts
+                .filter((p) => p.type === "text")
+                .map(textFromPart)
+                .filter(Boolean);
+            if (toolCalls.length > 0) {
+                const content = texts.length > 0 ? texts.join("\n") : null;
+                out.push({
+                    role: "assistant",
+                    content,
+                    tool_calls: toolCalls.map((p) => ({
+                        id: stringValue(p.toolCallId) ?? "",
+                        type: "function",
+                        function: {
+                            name: stringValue(p.toolName) ?? "",
+                            arguments: JSON.stringify(recordOrEmpty(p.input ?? p.args ?? p.arguments)),
+                        },
+                    })),
+                });
+            }
+            else if (texts.length > 0) {
+                out.push({ role: "assistant", content: texts.join("\n") });
+            }
+        }
+        else if (message.role === "tool") {
+            const toolContent = recordArray(message.content);
+            assertProviderContentParts(toolContent, "tool results");
+            for (const content of toolContent) {
+                const toolCallId = stringValue(content.toolCallId) ?? "";
+                if (!pairedIds.has(toolCallId))
+                    continue;
+                const output = unwrapToolResult(content.result ?? content.output);
+                out.push({ role: "tool", tool_call_id: toolCallId, content: output });
+                const images = imageParts(content);
+                if (images.length > 0) {
+                    if (!allowImages)
+                        throw imageContentError("tool results");
+                    out.push({
+                        role: "user",
+                        content: images
+                            .map((p) => filePartToOpenAIImageUrl(p))
+                            .filter(Boolean),
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
+function promptToAnthropicMessages(prompt, allowImages) {
+    const out = [];
+    const pairedIds = completeToolCallIds(prompt);
+    for (const message of prompt) {
+        if (message.role === "system")
+            continue;
+        if (message.role === "user") {
+            out.push({ role: "user", content: anthropicUserContent(message.content, allowImages) });
+        }
+        else if (message.role === "assistant") {
+            const parts = recordArray(message.content);
+            const content = [];
+            for (const p of parts) {
+                if (p.type === "text") {
+                    const text = textFromPart(p);
+                    if (text)
+                        content.push({ type: "text", text });
+                }
+                else if (p.type === "tool-call") {
+                    const id = stringValue(p.toolCallId);
+                    if (!id || !pairedIds.has(id))
+                        continue;
+                    content.push({
+                        type: "tool_use",
+                        id,
+                        name: stringValue(p.toolName) ?? "",
+                        input: recordOrEmpty(p.input ?? p.args ?? p.arguments),
+                    });
+                }
+            }
+            if (content.length > 0)
+                out.push({ role: "assistant", content });
+        }
+        else if (message.role === "tool") {
+            const toolContent = recordArray(message.content);
+            assertProviderContentParts(toolContent, "tool results");
+            for (const content of toolContent) {
+                const toolCallId = stringValue(content.toolCallId) ?? "";
+                if (!pairedIds.has(toolCallId))
+                    continue;
+                const output = unwrapToolResult(content.result ?? content.output);
+                out.push({
+                    role: "user",
+                    content: [{ type: "tool_result", tool_use_id: toolCallId, content: output }],
+                });
+                const images = imageParts(content);
+                if (images.length > 0) {
+                    if (!allowImages)
+                        throw imageContentError("tool results");
+                    out.push({
+                        role: "user",
+                        content: images
+                            .map((p) => filePartToAnthropicImage(p))
+                            .filter(Boolean),
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
+/**
+ * OpenAI Chat Completions body for POST /provider/v1/chat/completions.
+ * Docs: https://commandcode.ai/docs/provider#quickstart / #streaming — follows
+ * OpenAI schema; streaming example shows stream:true + stream_options:{include_usage:true}.
+ * Provider FAQ: text + images only; max_tokens honoured for both transports (capped 64k).
+ * reasoning_effort is CLI extension via reasoning.ts (not in provider docs), byte-equivalent to shared helpers.
+ */
+function buildOpenAIBody(options) {
+    const prompt = options.prompt ?? [];
+    const allowImages = options.allowImages ?? false;
+    if (!allowImages)
+        assertTextOnlyMessages(prompt);
+    const messages = promptToOpenAIMessages(prompt, allowImages);
+    const body = {
+        model: options.model ?? "",
+        stream: true,
+        messages,
+    };
+    if (options.tools) {
+        const t = openAITools(options.tools);
+        if (t)
+            body.tools = t;
+    }
+    // Anthropic requires max_tokens; for OpenAI we set capped default to honour #52
+    // (byte-equivalent to shared cappedMaxTokens). Provider models list shows context_length up to 1M
+    // but transport caps at DEFAULT_PROVIDER_MAX_TOKENS.
+    const maxTokens = cappedMaxTokens(options.maxOutputTokens);
+    body.max_tokens = maxTokens;
+    // System is already inside messages for OpenAI, but also accept explicit systemPrompt
+    const explicitSystem = systemPromptToText(options.systemPrompt);
+    if (explicitSystem && !prompt.some((m) => m.role === "system")) {
+        body.messages = [{ role: "system", content: explicitSystem }, ...messages];
+    }
+    const effort = reasoningEffortFor(options.providerOptions, options.model);
+    if (effort)
+        body.reasoning_effort = effort;
+    // OpenAI streaming usage needs stream_options — doc streaming example includes it
+    body.stream_options = { include_usage: true };
+    return body;
+}
+/**
+ * Anthropic Messages body for POST /provider/v1/messages.
+ * Docs: https://commandcode.ai/docs/provider — follows Anthropic schema; system is
+ * top-level string (not in messages), stream:true, max_tokens required (we default/cap 64k).
+ * reasoning_effort same CLI extension as OpenAI path.
+ */
+function buildAnthropicBody(options) {
+    const prompt = options.prompt ?? [];
+    const allowImages = options.allowImages ?? false;
+    if (!allowImages)
+        assertTextOnlyMessages(prompt);
+    const system = promptSystemText(prompt) || systemPromptToText(options.systemPrompt);
+    const messages = promptToAnthropicMessages(prompt, allowImages);
+    const body = {
+        model: options.model ?? "",
+        stream: true,
+        messages,
+    };
+    if (system)
+        body.system = system;
+    if (options.tools) {
+        const t = anthropicTools(options.tools);
+        if (t)
+            body.tools = t;
+    }
+    const maxTokens = cappedMaxTokens(options.maxOutputTokens);
+    body.max_tokens = maxTokens;
+    const effort = reasoningEffortFor(options.providerOptions, options.model);
+    if (effort)
+        body.reasoning_effort = effort;
+    return body;
+}
+// Primary codec helpers — naming follows spec sketch but aliases are provided
+export function messagesToOpenAI(prompt, options = {}) {
+    const p = prompt ?? options.prompt ?? [];
+    // Support both call shapes: messagesToOpenAI(prompt, opts) and messagesToOpenAI({prompt, model, ...})
+    if (Array.isArray(prompt) && isRecord(options) && "prompt" in options) {
+        // Called as messagesToOpenAI({ prompt, model, ... })
+        return buildOpenAIBody(options);
+    }
+    if (Array.isArray(prompt)) {
+        return buildOpenAIBody({ prompt: p, ...options });
+    }
+    // Called as messagesToOpenAI(optionsObject)
+    return buildOpenAIBody(prompt);
+}
+export function messagesToAnthropic(prompt, options = {}) {
+    const p = prompt ?? options.prompt ?? [];
+    if (Array.isArray(prompt) && isRecord(options) && "prompt" in options) {
+        return buildAnthropicBody(options);
+    }
+    if (Array.isArray(prompt)) {
+        return buildAnthropicBody({ prompt: p, ...options });
+    }
+    return buildAnthropicBody(prompt);
+}
+// Canonical codec entry points: messagesToOpenAI / messagesToAnthropic.
+export { openAITools, anthropicTools };

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

@@ -1,2 +1,13 @@
 export declare function redactCommandCodeErrorText(value: string): string;
+/**
+ * Detects the documented Provider API `403 upgrade_required` signal — "You're
+ * on the Go plan, the only plan without API access. Upgrade to GOAT or
+ * higher." (https://commandcode.ai/docs/provider). Tolerant to the documented
+ * variants: the JSON `error.code` / `error.type` may be `upgrade_required` and
+ * the message may phrase the same upgrade intent ("without API access",
+ * "Upgrade to GOAT"). A 403 that merely mentions the Go plan without that
+ * intent (e.g. "forbidden") is not a flip signal, and any status other than
+ * 403 (401, 422 cmd_zdr_no_providers, 429, 5xx, ...) never is either.
+ */
+export declare function isUpgradeRequiredError(status: number, body: unknown): boolean;
 export declare function commandCodeErrorMessage(value: unknown): string | undefined;

package/dist/src/provider/redact.js

@@ -26,6 +26,44 @@ export function redactCommandCodeErrorText(value) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+/**
+ * Detects the documented Provider API `403 upgrade_required` signal — "You're
+ * on the Go plan, the only plan without API access. Upgrade to GOAT or
+ * higher." (https://commandcode.ai/docs/provider). Tolerant to the documented
+ * variants: the JSON `error.code` / `error.type` may be `upgrade_required` and
+ * the message may phrase the same upgrade intent ("without API access",
+ * "Upgrade to GOAT"). A 403 that merely mentions the Go plan without that
+ * intent (e.g. "forbidden") is not a flip signal, and any status other than
+ * 403 (401, 422 cmd_zdr_no_providers, 429, 5xx, ...) never is either.
+ */
+export function isUpgradeRequiredError(status, body) {
+    if (status !== 403)
+        return false;
+    const candidates = [];
+    const pushStrings = (record) => {
+        for (const key of ["code", "type", "message"]) {
+            const part = record[key];
+            if (typeof part === "string")
+                candidates.push(part);
+        }
+    };
+    if (typeof body === "string") {
+        candidates.push(body);
+        try {
+            body = JSON.parse(body);
+        }
+        catch {
+            // keep the raw text as the only candidate below
+        }
+    }
+    if (isRecord(body)) {
+        const error = body.error;
+        if (isRecord(error))
+            pushStrings(error);
+        pushStrings(body);
+    }
+    return candidates.some((c) => /upgrade_required|upgrade to goat|without api access/i.test(c));
+}
 export function commandCodeErrorMessage(value) {
     if (typeof value === "string")
         return value;

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

@@ -3,3 +3,9 @@ export declare function parseStreamEventLine(line: string): unknown | undefined;
 export declare function mapFinishReason(reason: unknown): LanguageModelV3FinishReason;
 export declare function ccUsageToAiSdkUsage(event: Record<string, unknown>): LanguageModelV3Usage | undefined;
 export declare function ccEventToStreamPart(event: unknown): LanguageModelV3StreamPart[];
+export declare function openAIUsageToAiSdkUsage(event: Record<string, unknown>): LanguageModelV3Usage | undefined;
+export declare function anthropicUsageToAiSdkUsage(event: Record<string, unknown>): LanguageModelV3Usage | undefined;
+export declare function openAIEventToStreamPart(event: unknown): LanguageModelV3StreamPart[];
+export declare function anthropicEventToStreamPart(event: unknown): LanguageModelV3StreamPart[];
+export declare function createOpenAIStreamParser(): (event: unknown) => LanguageModelV3StreamPart[];
+export declare function createAnthropicStreamParser(): (event: unknown) => LanguageModelV3StreamPart[];