opencode-cmd-provider 0.1.0

package/dist/src/provider/converters.js

@@ -0,0 +1,256 @@
+// src/provider/converters.ts — AI SDK v3 messages → Command Code payload (PLAN #2 Part B)
+//
+// Port of pi-commandcode-provider/src/converters.ts. Input is the AI SDK v3
+// prompt format (LanguageModelV3Message / LanguageModelV3Prompt):
+//
+// - { role: "system"; content: string }
+// - { role: "user"; content: string | Array<{ type: "text"; text } | { type: "file"; data; mediaType }> }
+// - { role: "assistant"; content: Array<{ type: "text" } | { type: "reasoning" } | { type: "tool-call" } | { type: "tool-result" }> }
+// - { role: "tool"; content: Array<{ type: "tool-result"; toolCallId; toolName; output }> }
+//
+// Image parts: v3 names them `file` parts with `data`/`mediaType` (image/*).
+// We treat `image`-typed parts as well for forward-compat with other SDK
+// shapes. `getApiKey` lives in ./auth-key.ts; `parseStreamEventLine` and
+// `mapFinishReason` are issue #3.
+import { toJsonSchema } from "./json-schema.js";
+export { toJsonSchema } from "./json-schema.js";
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function recordArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isRecord);
+}
+export function recordOrEmpty(value) {
+    if (isRecord(value))
+        return value;
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            if (isRecord(parsed))
+                return parsed;
+        }
+        catch {
+            // Some providers stream incomplete JSON argument fragments.
+        }
+    }
+    return {};
+}
+export function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+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/")));
+}
+function imageContentError(role) {
+    return new Error(`Selected Command Code model does not support image content in ${role}`);
+}
+export function assertTextOnlyMessages(messages) {
+    for (const message of messages ?? []) {
+        if (imageParts(message.content).length > 0) {
+            const role = message.role === "tool" ? "tool results" : `${String(message.role)} messages`;
+            throw imageContentError(role);
+        }
+    }
+}
+function imageToCommandCode(part) {
+    const raw = stringValue(part.image) ?? stringValue(part.data);
+    const mimeType = stringValue(part.mimeType) ?? stringValue(part.mediaType);
+    if (!raw || raw.length === 0) {
+        throw new Error("Invalid image content: expected a base64 data URL string");
+    }
+    if (raw.startsWith("data:")) {
+        const [mime] = raw.slice(5).split(";base64,");
+        return { type: "image", image: raw, mimeType: mime ?? mimeType ?? "application/octet-stream" };
+    }
+    return {
+        type: "image",
+        image: `data:${mimeType ?? "application/octet-stream"};base64,${raw}`,
+        mimeType: mimeType ?? "application/octet-stream",
+    };
+}
+function userContentToCommandCode(content, allowImages) {
+    if (typeof content === "string")
+        return content;
+    return recordArray(content).flatMap((part) => {
+        if (part.type === "text")
+            return [{ type: "text", text: stringValue(part.text) ?? "" }];
+        if (part.type === "image" || part.type === "file") {
+            if (!allowImages)
+                throw imageContentError("user messages");
+            return [imageToCommandCode(part)];
+        }
+        return [];
+    });
+}
+export function textContent(message) {
+    return recordArray(message.content)
+        .filter((part) => part.type === "text")
+        .map((part) => stringValue(part.text) ?? "")
+        .join("\n");
+}
+export function getEnvironmentInfo() {
+    return `${process.platform}-${process.arch}, Node.js ${process.version}`;
+}
+export function toolsToJson(tools) {
+    if (!tools)
+        return [];
+    if (Array.isArray(tools)) {
+        return tools.map((tool) => ({
+            type: "function",
+            name: tool.name ?? "",
+            description: tool.description,
+            input_schema: tool.parameters ? toJsonSchema(tool.parameters) : {},
+        }));
+    }
+    return Object.entries(tools).map(([name, tool]) => ({
+        type: "function",
+        name,
+        description: tool.description,
+        input_schema: tool.parameters ? toJsonSchema(tool.parameters) : {},
+    }));
+}
+function completeToolCallIds(messages) {
+    const callIds = new Set();
+    const resultIds = new Set();
+    for (const message of messages ?? []) {
+        if (message.role === "assistant") {
+            for (const content of recordArray(message.content)) {
+                if (content.type === "tool-call") {
+                    const id = stringValue(content.toolCallId);
+                    if (id)
+                        callIds.add(id);
+                }
+            }
+        }
+        else if (message.role === "tool") {
+            for (const content of recordArray(message.content)) {
+                const id = stringValue(content.toolCallId);
+                if (id)
+                    resultIds.add(id);
+            }
+        }
+    }
+    return new Set([...callIds].filter((id) => resultIds.has(id)));
+}
+function resultText(result) {
+    if (typeof result === "string")
+        return result;
+    if (Array.isArray(result))
+        return result.map(resultText).filter(Boolean).join("\n");
+    if (result && typeof result === "object") {
+        const text = result.text;
+        if (typeof text === "string")
+            return text;
+        const content = result.content;
+        if (content !== undefined)
+            return resultText(content);
+        return JSON.stringify(result);
+    }
+    return String(result ?? "");
+}
+export function messagesToCC(messages, options = {}) {
+    const allowImages = options.allowImages ?? false;
+    if (!allowImages)
+        assertTextOnlyMessages(messages);
+    const out = [];
+    const pairedToolCallIds = completeToolCallIds(messages);
+    for (const message of messages ?? []) {
+        if (message.role === "user") {
+            out.push({
+                role: "user",
+                content: userContentToCommandCode(message.content, allowImages),
+            });
+        }
+        else if (message.role === "assistant") {
+            const parts = [];
+            for (const content of recordArray(message.content)) {
+                if (content.type === "text") {
+                    parts.push({ type: "text", text: stringValue(content.text) ?? "" });
+                }
+                else if (content.type === "tool-call") {
+                    const toolCallId = stringValue(content.toolCallId) ?? "";
+                    if (!pairedToolCallIds.has(toolCallId))
+                        continue;
+                    parts.push({
+                        type: "tool-call",
+                        toolCallId,
+                        toolName: stringValue(content.toolName) ?? "",
+                        input: recordOrEmpty(content.args ?? content.arguments),
+                    });
+                }
+            }
+            if (parts.length > 0)
+                out.push({ role: "assistant", content: parts });
+        }
+        else if (message.role === "tool") {
+            for (const content of recordArray(message.content)) {
+                const toolCallId = stringValue(content.toolCallId) ?? "";
+                if (!pairedToolCallIds.has(toolCallId))
+                    continue;
+                out.push({
+                    role: "tool",
+                    content: [
+                        {
+                            type: "tool-result",
+                            toolCallId,
+                            toolName: stringValue(content.toolName) ?? "",
+                            output: content.isError
+                                ? { type: "error-text", value: resultText(content.result ?? content.output) }
+                                : { type: "text", value: resultText(content.result ?? content.output) },
+                        },
+                    ],
+                });
+                const images = imageParts(content);
+                if (images.length > 0) {
+                    if (!allowImages)
+                        throw imageContentError("tool results");
+                    out.push({
+                        role: "user",
+                        content: images.map(imageToCommandCode),
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
+function promptPartToText(value, depth = 0) {
+    if (depth > 10)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value
+            .map((v) => promptPartToText(v, depth + 1))
+            .filter(Boolean)
+            .join("\n");
+    if (!isRecord(value))
+        return "";
+    const text = stringValue(value.text);
+    if (text)
+        return text;
+    const content = promptPartToText(value.content, depth + 1);
+    if (content)
+        return content;
+    return "";
+}
+export function systemPromptToText(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value
+            .map((v) => promptPartToText(v, 0))
+            .filter(Boolean)
+            .join("\n\n");
+    return promptPartToText(value, 0);
+}

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

@@ -0,0 +1,19 @@
+import type { CommandCodeModelCost } from "./pricing.js";
+export interface CostUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cacheWrite1h?: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}
+export interface CostModel {
+    cost: CommandCodeModelCost;
+}
+export declare function calculateCommandCodeCost(model: CostModel, usage: CostUsage): void;

package/dist/src/provider/cost.js

@@ -0,0 +1,19 @@
+export function calculateCommandCodeCost(model, usage) {
+    const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+    let rates = model.cost;
+    let matchedThreshold = -1;
+    for (const tier of model.cost.tiers ?? []) {
+        if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+            rates = tier;
+            matchedThreshold = tier.inputTokensAbove;
+        }
+    }
+    const longWrite = usage.cacheWrite1h ?? 0;
+    const shortWrite = usage.cacheWrite - longWrite;
+    usage.cost.input = (rates.input / 1_000_000) * usage.input;
+    usage.cost.output = (rates.output / 1_000_000) * usage.output;
+    usage.cost.cacheRead = (rates.cacheRead / 1_000_000) * usage.cacheRead;
+    usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1_000_000;
+    usage.cost.total =
+        usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}

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

@@ -0,0 +1,5 @@
+import { CommandCodeLanguageModel, type CommandCodeModelOptions } from "./command-code-model.js";
+export declare function createCommandCode(options?: CommandCodeModelOptions): {
+    languageModel(modelId: string): CommandCodeLanguageModel;
+};
+export type { CommandCodeModelOptions } from "./command-code-model.js";

package/dist/src/provider/index.js

@@ -0,0 +1,9 @@
+// src/provider/index.ts — public provider factory (PLAN #8)
+import { CommandCodeLanguageModel } from "./command-code-model.js";
+export function createCommandCode(options = {}) {
+    return {
+        languageModel(modelId) {
+            return new CommandCodeLanguageModel(options, modelId);
+        },
+    };
+}

package/dist/src/provider/json-schema.d.ts

@@ -0,0 +1 @@
+export declare function toJsonSchema(schema: unknown): unknown;

package/dist/src/provider/json-schema.js

@@ -0,0 +1,374 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+const JSON_SCHEMA_TYPES = new Set([
+    "array",
+    "boolean",
+    "integer",
+    "null",
+    "number",
+    "object",
+    "string",
+]);
+const LEGACY_KINDS = new Set([
+    "any",
+    "array",
+    "boolean",
+    "enum",
+    "integer",
+    "intersect",
+    "intersection",
+    "literal",
+    "never",
+    "null",
+    "nullable",
+    "number",
+    "object",
+    "optional",
+    "string",
+    "undefined",
+    "union",
+    "unknown",
+]);
+const LEGACY_FIELDS = new Set([
+    "element",
+    "kind",
+    "inner",
+    "optional",
+    "value",
+    "values",
+    "variants",
+    "wrapped",
+]);
+const SCHEMA_MAP_FIELDS = new Set([
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+    "patternProperties",
+    "properties",
+]);
+const SCHEMA_ARRAY_FIELDS = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const SCHEMA_VALUE_FIELDS = new Set([
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "contentSchema",
+    "else",
+    "if",
+    "items",
+    "not",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+]);
+const SCHEMA_KEYWORDS = new Set([
+    "$anchor",
+    "$comment",
+    "$defs",
+    "$dynamicAnchor",
+    "$dynamicRef",
+    "$id",
+    "$ref",
+    "$schema",
+    "$vocabulary",
+    "additionalItems",
+    "additionalProperties",
+    "allOf",
+    "anyOf",
+    "const",
+    "contains",
+    "contentEncoding",
+    "contentMediaType",
+    "contentSchema",
+    "default",
+    "definitions",
+    "dependentRequired",
+    "dependentSchemas",
+    "description",
+    "else",
+    "enum",
+    "examples",
+    "exclusiveMaximum",
+    "exclusiveMinimum",
+    "format",
+    "if",
+    "items",
+    "maxContains",
+    "maxItems",
+    "maxLength",
+    "maxProperties",
+    "maximum",
+    "minContains",
+    "minItems",
+    "minLength",
+    "minProperties",
+    "minimum",
+    "multipleOf",
+    "not",
+    "oneOf",
+    "pattern",
+    "patternProperties",
+    "prefixItems",
+    "properties",
+    "propertyNames",
+    "readOnly",
+    "required",
+    "title",
+    "type",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+    "uniqueItems",
+    "writeOnly",
+]);
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const values = value.filter((item) => typeof item === "string");
+    return values.length === value.length ? values : undefined;
+}
+function validSchemaType(value) {
+    if (typeof value === "string")
+        return JSON_SCHEMA_TYPES.has(value);
+    if (!Array.isArray(value) || value.length === 0)
+        return false;
+    return value.every((item) => typeof item === "string" && JSON_SCHEMA_TYPES.has(item));
+}
+function legacyKind(schema) {
+    const explicitKind = stringValue(schema.kind)?.toLowerCase();
+    if (explicitKind && LEGACY_KINDS.has(explicitKind))
+        return explicitKind;
+    const type = stringValue(schema.type);
+    const normalized = type?.toLowerCase();
+    if (!normalized || !LEGACY_KINDS.has(normalized))
+        return undefined;
+    if (!validSchemaType(type) || Object.keys(schema).some((key) => LEGACY_FIELDS.has(key))) {
+        return normalized;
+    }
+    return undefined;
+}
+function looksLikeJsonSchema(schema) {
+    if (Object.keys(schema).length === 0)
+        return true;
+    if (schema.type !== undefined && !validSchemaType(schema.type))
+        return false;
+    return Object.keys(schema).some((key) => SCHEMA_KEYWORDS.has(key));
+}
+function isOptionalSchema(schema) {
+    if (!isRecord(schema))
+        return false;
+    if (booleanValue(schema.optional) === true)
+        return true;
+    const kind = legacyKind(schema);
+    if (kind === "optional")
+        return true;
+    if (kind !== "union")
+        return false;
+    const variants = Array.isArray(schema.variants)
+        ? schema.variants
+        : Array.isArray(schema.anyOf)
+            ? schema.anyOf
+            : [];
+    return variants.some((variant) => legacyKind(isRecord(variant) ? variant : {}) === "undefined");
+}
+function schemaValue(value, seen) {
+    if (typeof value === "boolean")
+        return value;
+    if (!isRecord(value))
+        return {};
+    return convertSchema(value, seen);
+}
+function setSchemaProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+function schemaMap(value, seen) {
+    if (!isRecord(value))
+        return {};
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        setSchemaProperty(out, key, schemaValue(item, seen));
+    }
+    return out;
+}
+function schemaArray(value, seen) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => schemaValue(item, seen));
+}
+function isSchemaValue(value) {
+    return typeof value === "boolean" || isRecord(value);
+}
+function copySchemaObject(source, seen, legacy, forcedType) {
+    const out = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (legacy && LEGACY_FIELDS.has(key))
+            continue;
+        if (key === "nullable" || (forcedType !== undefined && key === "type"))
+            continue;
+        if (key === "required") {
+            const required = stringArray(value);
+            if (required)
+                out.required = required;
+        }
+        else if (SCHEMA_MAP_FIELDS.has(key)) {
+            out[key] = schemaMap(value, seen);
+        }
+        else if (SCHEMA_ARRAY_FIELDS.has(key)) {
+            out[key] = schemaArray(value, seen);
+        }
+        else if (SCHEMA_VALUE_FIELDS.has(key)) {
+            out[key] =
+                Array.isArray(value) && key === "items"
+                    ? schemaArray(value, seen)
+                    : schemaValue(value, seen);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    if (forcedType !== undefined)
+        out.type = forcedType;
+    if (booleanValue(source.nullable) === true)
+        return makeNullable(out);
+    return out;
+}
+function makeNullable(schema) {
+    const type = schema.type;
+    if (typeof type === "string") {
+        if (type === "null")
+            return schema;
+        return { ...schema, type: [type, "null"] };
+    }
+    if (Array.isArray(type) && !type.includes("null")) {
+        return { ...schema, type: [...type, "null"] };
+    }
+    if (Array.isArray(schema.anyOf)) {
+        return { ...schema, anyOf: [...schema.anyOf, { type: "null" }] };
+    }
+    return { anyOf: [schema, { type: "null" }] };
+}
+function legacyVariants(schema) {
+    if (Array.isArray(schema.variants))
+        return schema.variants;
+    if (Array.isArray(schema.anyOf))
+        return schema.anyOf;
+    return [];
+}
+function convertLegacySchema(source, kind, seen) {
+    if (kind === "optional")
+        return schemaValue(source.wrapped ?? source.inner, seen);
+    if (kind === "nullable") {
+        const wrapped = schemaValue(source.wrapped ?? source.inner, seen);
+        return typeof wrapped === "boolean" ? wrapped : makeNullable(wrapped);
+    }
+    if (kind === "undefined" || kind === "never" || kind === "any" || kind === "unknown")
+        return {};
+    if (kind === "union" || kind === "intersect" || kind === "intersection") {
+        const variants = legacyVariants(source)
+            .map((variant) => schemaValue(variant, seen))
+            .filter((variant) => isSchemaValue(variant) &&
+            (typeof variant === "boolean" || Object.keys(variant).length > 0));
+        if (variants.length === 0)
+            return copySchemaObject(source, seen, true);
+        if (variants.length === 1)
+            return variants[0] ?? {};
+        const out = copySchemaObject(source, seen, true);
+        if (typeof out !== "boolean")
+            out[kind === "union" ? "anyOf" : "allOf"] = variants;
+        return out;
+    }
+    if (kind === "object") {
+        const converted = copySchemaObject(source, seen, true, "object");
+        if (typeof converted === "boolean")
+            return converted;
+        const out = converted;
+        const sourceProperties = isRecord(source.properties) ? source.properties : undefined;
+        if (!sourceProperties)
+            return out;
+        const properties = {};
+        const optional = stringArray(source.optional) ?? [];
+        for (const [key, value] of Object.entries(sourceProperties)) {
+            setSchemaProperty(properties, key, schemaValue(value, seen));
+        }
+        out.properties = properties;
+        const explicitRequired = stringArray(source.required);
+        const required = explicitRequired ??
+            Object.entries(sourceProperties)
+                .filter(([key, value]) => !optional.includes(key) && !isOptionalSchema(value))
+                .map(([key]) => key);
+        if (required.length > 0)
+            out.required = required;
+        else
+            delete out.required;
+        return out;
+    }
+    if (kind === "array") {
+        const converted = copySchemaObject(source, seen, true, "array");
+        if (typeof converted === "boolean")
+            return converted;
+        const out = converted;
+        if (!("items" in source) && "element" in source)
+            out.items = schemaValue(source.element, seen);
+        return out;
+    }
+    if (kind === "enum") {
+        const converted = copySchemaObject(source, seen, true);
+        if (typeof converted === "boolean")
+            return converted;
+        const out = converted;
+        if (!("enum" in out) && Array.isArray(source.values))
+            out.enum = source.values;
+        return out;
+    }
+    if (kind === "literal") {
+        const converted = copySchemaObject(source, seen, true);
+        if (typeof converted === "boolean")
+            return converted;
+        const out = converted;
+        if (!("const" in out) && "value" in source)
+            out.const = source.value;
+        return out;
+    }
+    const scalarType = kind === "string" ||
+        kind === "number" ||
+        kind === "boolean" ||
+        kind === "integer" ||
+        kind === "null"
+        ? kind
+        : undefined;
+    return scalarType ? copySchemaObject(source, seen, true, scalarType) : {};
+}
+function convertSchema(source, seen) {
+    if (seen.has(source))
+        return {};
+    seen.add(source);
+    try {
+        const kind = legacyKind(source);
+        if (kind)
+            return convertLegacySchema(source, kind, seen);
+        if (!looksLikeJsonSchema(source))
+            return {};
+        return copySchemaObject(source, seen, false);
+    }
+    finally {
+        seen.delete(source);
+    }
+}
+export function toJsonSchema(schema) {
+    if (typeof schema === "boolean")
+        return schema;
+    if (!isRecord(schema))
+        return {};
+    return convertSchema(schema, new WeakSet());
+}

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

@@ -0,0 +1,9 @@
+export type CommandCodeInputType = "text" | "image";
+/**
+ * Model input modalities from the command-code@1.15.1 bundled catalog.
+ * Models omitted here remain text-only so newly discovered IDs never claim
+ * image support without upstream evidence.
+ */
+export declare const MODEL_INPUT_MODALITIES: Readonly<Record<string, readonly CommandCodeInputType[]>>;
+export declare function inputModalitiesForModel(modelId: string): readonly CommandCodeInputType[];
+export declare function modelSupportsImageInput(modelId: string): boolean;