opencode-ext-connector 0.3.0

package/dist/providers/command-code/emit-stream.js

@@ -0,0 +1,226 @@
+// Derived from brent-weatherall/opencode-commandcode-provider@6cf3f22d4aae469db3723e589291c736285373c1 src/stream.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { z } from "zod";
+import { commandCodeNdjsonError } from "./errors";
+import { commandCodeRecords } from "./record-stream";
+const tokenDetailsSchema = z
+    .object({
+    noCacheTokens: z.number().optional(),
+    cacheReadTokens: z.number().optional(),
+    cacheWriteTokens: z.number().optional(),
+    textTokens: z.number().optional(),
+    reasoningTokens: z.number().optional(),
+})
+    .passthrough();
+const usageSchema = z
+    .object({
+    inputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    inputTokenDetails: tokenDetailsSchema.optional(),
+    outputTokenDetails: tokenDetailsSchema.optional(),
+})
+    .passthrough();
+const providerErrorSchema = z
+    .object({
+    message: z.string(),
+    code: z.string().optional(),
+    statusCode: z.number().int().min(100).max(599).optional(),
+    isRetryable: z.boolean().optional(),
+})
+    .passthrough()
+    .transform((error) => ({
+    ...(error.code === undefined ? {} : { code: error.code }),
+    ...(error.statusCode === undefined ? {} : { statusCode: error.statusCode }),
+    ...(error.isRetryable === undefined ? {} : { isRetryable: error.isRetryable }),
+}));
+const streamEventSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("start") }).passthrough(),
+    z.object({ type: z.literal("abort") }).passthrough(),
+    z
+        .object({
+        type: z.enum([
+            "text-start",
+            "text-end",
+            "reasoning-start",
+            "reasoning-end",
+            "tool-input-end",
+        ]),
+        id: z.string().optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.enum(["text-delta", "reasoning-delta", "tool-input-delta"]),
+        id: z.string().optional(),
+        text: z.string().optional(),
+        delta: z.string().optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("tool-input-start"),
+        id: z.string().optional(),
+        toolName: z.string().optional(),
+        dynamic: z.boolean().optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("tool-call"),
+        toolCallId: z.string().optional(),
+        id: z.string().optional(),
+        toolName: z.string().optional(),
+        input: z.unknown().optional(),
+        args: z.unknown().optional(),
+        arguments: z.unknown().optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("finish-step"),
+        finishReason: z.string().optional(),
+        usage: usageSchema.optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("finish"),
+        finishReason: z.string().optional(),
+        rawFinishReason: z.string().optional(),
+        totalUsage: usageSchema.optional(),
+        usage: usageSchema.optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("response-metadata"),
+        id: z.string().optional(),
+        modelId: z.string().optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("error"),
+        error: z.union([z.string(), providerErrorSchema]).optional(),
+        message: z.string().optional(),
+    })
+        .passthrough(),
+]);
+function finishReason(raw) {
+    switch (raw) {
+        case "stop":
+        case "end_turn":
+            return { unified: "stop", raw };
+        case "tool_calls":
+        case "tool-calls":
+        case "tool_use":
+            return { unified: "tool-calls", raw };
+        case "length":
+        case "max_tokens":
+        case "max-tokens":
+        case "max_output_tokens":
+            return { unified: "length", raw };
+        case "content_filter":
+            return { unified: "content-filter", raw };
+        default:
+            return { unified: "other", raw };
+    }
+}
+function usageFromEvent(event) {
+    const usage = event.totalUsage ?? event.usage;
+    return {
+        inputTokens: {
+            total: usage?.inputTokens,
+            noCache: usage?.inputTokenDetails?.noCacheTokens,
+            cacheRead: usage?.inputTokenDetails?.cacheReadTokens,
+            cacheWrite: usage?.inputTokenDetails?.cacheWriteTokens,
+        },
+        outputTokens: {
+            total: usage?.outputTokens,
+            text: usage?.outputTokenDetails?.textTokens,
+            reasoning: usage?.outputTokenDetails?.reasoningTokens,
+        },
+    };
+}
+function toolCallPart(event) {
+    const input = event.input ?? event.args ?? event.arguments ?? {};
+    return {
+        type: "tool-call",
+        toolCallId: event.toolCallId ?? event.id ?? "",
+        toolName: event.toolName ?? "",
+        input: typeof input === "string" ? input : JSON.stringify(input),
+    };
+}
+function streamPart(event) {
+    switch (event.type) {
+        case "start":
+            return { type: "stream-start", warnings: [] };
+        case "abort":
+        case "finish-step":
+            return null;
+        case "text-start":
+        case "text-end":
+        case "reasoning-start":
+        case "reasoning-end":
+        case "tool-input-end":
+            return { type: event.type, id: event.id ?? "" };
+        case "text-delta":
+        case "reasoning-delta":
+        case "tool-input-delta":
+            return { type: event.type, id: event.id ?? "", delta: event.text ?? event.delta ?? "" };
+        case "tool-input-start":
+            return {
+                type: event.type,
+                id: event.id ?? "",
+                toolName: event.toolName ?? "",
+                ...(event.dynamic === undefined ? {} : { dynamic: event.dynamic }),
+            };
+        case "tool-call":
+            return toolCallPart(event);
+        case "finish": {
+            const raw = event.rawFinishReason ?? event.finishReason ?? "stop";
+            return { type: "finish", finishReason: finishReason(raw), usage: usageFromEvent(event) };
+        }
+        case "response-metadata":
+            return {
+                type: event.type,
+                ...(event.id === undefined ? {} : { id: event.id }),
+                ...(event.modelId === undefined ? {} : { modelId: event.modelId }),
+            };
+        case "error":
+            return { type: "error", error: commandCodeNdjsonError(event.error) };
+    }
+}
+function parseEvent(line) {
+    try {
+        const parsed = JSON.parse(line);
+        const result = streamEventSchema.safeParse(parsed);
+        return result.success ? result.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function emitCommandCodeChunks(chunks, controller) {
+    let finished = false;
+    const consumeLine = (line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith(":") || trimmed === "[DONE]") {
+            return;
+        }
+        const payload = trimmed.startsWith("data:") ? trimmed.slice(5).trimStart() : trimmed;
+        const event = parseEvent(payload);
+        if (event === null || (event.type === "finish" && finished)) {
+            return;
+        }
+        const part = streamPart(event);
+        if (part !== null) {
+            controller.enqueue(part);
+        }
+        if (event.type === "finish") {
+            finished = true;
+        }
+    };
+    for await (const line of commandCodeRecords(chunks))
+        consumeLine(line);
+}

package/dist/providers/command-code/errors.d.ts

@@ -0,0 +1,33 @@
+export declare const COMMAND_CODE_PROVIDER_ERROR = "COMMAND_CODE_PROVIDER_ERROR";
+export declare const commandCodeProviderErrorStages: readonly ["http-response", "ndjson-stream", "response-body"];
+export type CommandCodeProviderErrorStage = (typeof commandCodeProviderErrorStages)[number];
+export declare const commandCodeProviderErrorReasons: readonly ["http-status", "ndjson-event", "missing-response-body", "response-body-too-large", "stream-record-too-large"];
+export type CommandCodeProviderErrorReason = (typeof commandCodeProviderErrorReasons)[number];
+type CommandCodeProviderErrorOptions = {
+    readonly stage: CommandCodeProviderErrorStage;
+    readonly reason: CommandCodeProviderErrorReason;
+    readonly statusCode: number | null;
+    readonly providerCode: string | null;
+    readonly retryable: boolean;
+};
+export type CommandCodeProviderMetadata = {
+    readonly code?: string;
+    readonly statusCode?: number;
+    readonly isRetryable?: boolean;
+};
+export declare class CommandCodeProviderError extends Error {
+    readonly name = "CommandCodeProviderError";
+    readonly code: typeof COMMAND_CODE_PROVIDER_ERROR;
+    readonly stage: CommandCodeProviderErrorStage;
+    readonly reason: CommandCodeProviderErrorReason;
+    readonly statusCode: number | null;
+    readonly providerCode: string | null;
+    readonly retryable: boolean;
+    constructor(options: CommandCodeProviderErrorOptions);
+}
+export declare function commandCodeHttpError(statusCode: number, body: string): CommandCodeProviderError;
+export declare function commandCodeNdjsonError(error: string | CommandCodeProviderMetadata | undefined): CommandCodeProviderError;
+export declare function commandCodeMissingBodyError(statusCode: number): CommandCodeProviderError;
+export declare function commandCodeResponseBodyTooLargeError(): CommandCodeProviderError;
+export declare function commandCodeStreamRecordTooLargeError(): CommandCodeProviderError;
+export {};

package/dist/providers/command-code/errors.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+export const COMMAND_CODE_PROVIDER_ERROR = "COMMAND_CODE_PROVIDER_ERROR";
+export const commandCodeProviderErrorStages = [
+    "http-response",
+    "ndjson-stream",
+    "response-body",
+];
+export const commandCodeProviderErrorReasons = [
+    "http-status",
+    "ndjson-event",
+    "missing-response-body",
+    "response-body-too-large",
+    "stream-record-too-large",
+];
+const commandCodeProviderMetadataSchema = z
+    .object({
+    code: z.string().optional(),
+    statusCode: z.number().int().min(100).max(599).optional(),
+    isRetryable: z.boolean().optional(),
+})
+    .passthrough();
+const httpErrorBodySchema = z.union([
+    z.object({ error: commandCodeProviderMetadataSchema }).transform((value) => value.error),
+    commandCodeProviderMetadataSchema,
+]);
+export class CommandCodeProviderError extends Error {
+    name = "CommandCodeProviderError";
+    code = COMMAND_CODE_PROVIDER_ERROR;
+    stage;
+    reason;
+    statusCode;
+    providerCode;
+    retryable;
+    constructor(options) {
+        super("Command Code provider request failed");
+        this.stage = options.stage;
+        this.reason = options.reason;
+        this.statusCode = options.statusCode;
+        this.providerCode = options.providerCode;
+        this.retryable = options.retryable;
+    }
+}
+function parseHttpMetadata(body) {
+    try {
+        const parsed = JSON.parse(body);
+        const result = httpErrorBodySchema.safeParse(parsed);
+        if (!result.success)
+            return null;
+        return {
+            ...(result.data.code === undefined ? {} : { code: result.data.code }),
+            ...(result.data.statusCode === undefined ? {} : { statusCode: result.data.statusCode }),
+            ...(result.data.isRetryable === undefined ? {} : { isRetryable: result.data.isRetryable }),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function commandCodeHttpError(statusCode, body) {
+    const metadata = parseHttpMetadata(body);
+    return new CommandCodeProviderError({
+        stage: "http-response",
+        reason: "http-status",
+        statusCode,
+        providerCode: metadata?.code ?? null,
+        retryable: metadata?.isRetryable ?? (statusCode === 429 || statusCode >= 500),
+    });
+}
+export function commandCodeNdjsonError(error) {
+    const metadata = typeof error === "object" ? error : undefined;
+    return new CommandCodeProviderError({
+        stage: "ndjson-stream",
+        reason: "ndjson-event",
+        statusCode: metadata?.statusCode ?? null,
+        providerCode: metadata?.code ?? null,
+        retryable: metadata?.isRetryable ?? false,
+    });
+}
+export function commandCodeMissingBodyError(statusCode) {
+    return new CommandCodeProviderError({
+        stage: "response-body",
+        reason: "missing-response-body",
+        statusCode,
+        providerCode: null,
+        retryable: false,
+    });
+}
+export function commandCodeResponseBodyTooLargeError() {
+    return new CommandCodeProviderError({
+        stage: "response-body",
+        reason: "response-body-too-large",
+        statusCode: null,
+        providerCode: null,
+        retryable: false,
+    });
+}
+export function commandCodeStreamRecordTooLargeError() {
+    return new CommandCodeProviderError({
+        stage: "ndjson-stream",
+        reason: "stream-record-too-large",
+        statusCode: null,
+        providerCode: null,
+        retryable: false,
+    });
+}

package/dist/providers/command-code/language-model.d.ts

@@ -0,0 +1,15 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { HttpTransport } from "../../core/http";
+import { type CommandCodeVersionResolver } from "./cli-version";
+export type CommandCodeLanguageModelOptions = {
+    readonly modelId: string;
+    readonly transport: HttpTransport;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly readCliVersion?: CommandCodeVersionResolver;
+    readonly baseURL?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly timeoutMs?: number;
+    readonly generateSessionId?: () => string;
+};
+export declare function createCommandCodeLanguageModel(options: CommandCodeLanguageModelOptions): LanguageModelV3;

package/dist/providers/command-code/language-model.js

@@ -0,0 +1,203 @@
+// Derived from brent-weatherall/opencode-commandcode-provider src/model.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { AdapterError, OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { openHttpBody } from "../../http/read-body";
+import { createCommandCodeVersionResolver } from "./cli-version";
+import { emitCommandCodeChunks } from "./emit-stream";
+import { commandCodeMissingBodyError } from "./errors";
+import { buildBody, buildHeaders } from "./request";
+import { commandCodeHttpError, createCommandCodeRequestLifecycle, readCommandCodeErrorBody, } from "./request-lifecycle";
+import { createCommandCodeSessionId } from "./session";
+function buildRequestOptions(options, call, token, cliVersion) {
+    const bodyOptions = {
+        modelId: options.modelId,
+        call,
+        sessionId: options.sessionId,
+    };
+    const headerOptions = {
+        token,
+        cliVersion,
+        sessionId: options.sessionId,
+    };
+    return {
+        url: `${(options.baseURL ?? "https://api.commandcode.ai").replace(/\/+$/, "")}/alpha/generate`,
+        headers: {
+            ...buildHeaders(headerOptions),
+            ...options.headers,
+            ...Object.fromEntries(Object.entries(call.headers ?? {}).filter((entry) => entry[1] !== undefined)),
+        },
+        body: new TextEncoder().encode(JSON.stringify(buildBody(bodyOptions))),
+    };
+}
+function createUsage() {
+    return {
+        inputTokens: {
+            total: undefined,
+            noCache: undefined,
+            cacheRead: undefined,
+            cacheWrite: undefined,
+        },
+        outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    };
+}
+function createFinishReason() {
+    return { unified: "stop", raw: "stop" };
+}
+async function streamCommandCode(options, call) {
+    if (call.abortSignal?.aborted === true) {
+        throw new OperationCancelledError("command-code-stream");
+    }
+    const lifecycle = createCommandCodeRequestLifecycle(call.abortSignal, options.timeoutMs ?? 5 * 60 * 1_000);
+    const token = await options.readAccessToken(lifecycle.signal);
+    if (token === null) {
+        lifecycle.dispose();
+        throw new AdapterError({
+            operation: "command-code-missing-credentials",
+            retryable: false,
+            cause: null,
+            providerId: parseProviderId("command-code"),
+        });
+    }
+    const cliVersion = await options.readCliVersion(lifecycle.signal);
+    if (cliVersion === null) {
+        lifecycle.dispose();
+        throw new AdapterError({
+            operation: "command-code-cli-version",
+            retryable: false,
+            cause: null,
+            providerId: parseProviderId("command-code"),
+        });
+    }
+    const requestOptions = buildRequestOptions(options, call, token, cliVersion);
+    let opened;
+    try {
+        opened = await openHttpBody(options.transport, {
+            method: "POST",
+            url: requestOptions.url,
+            headers: requestOptions.headers,
+            body: requestOptions.body,
+        }, lifecycle.signal);
+    }
+    catch (error) {
+        lifecycle.dispose();
+        throw error;
+    }
+    if (opened.status < 200 || opened.status >= 300) {
+        let errorBody;
+        try {
+            errorBody = await readCommandCodeErrorBody(opened.chunks);
+        }
+        catch (error) {
+            lifecycle.abort();
+            throw error;
+        }
+        finally {
+            lifecycle.dispose();
+        }
+        throw commandCodeHttpError(opened.status, errorBody);
+    }
+    if (!opened.bodyPresent) {
+        lifecycle.dispose();
+        throw commandCodeMissingBodyError(opened.status);
+    }
+    let cancelled = false;
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                await emitCommandCodeChunks(opened.chunks, controller);
+            }
+            catch (error) {
+                if (!cancelled) {
+                    controller.enqueue({ type: "error", error });
+                }
+            }
+            finally {
+                lifecycle.dispose();
+                if (!cancelled) {
+                    controller.close();
+                }
+            }
+        },
+        cancel() {
+            cancelled = true;
+            lifecycle.abort();
+            lifecycle.dispose();
+        },
+    });
+    return {
+        stream,
+        request: { body: new TextDecoder().decode(requestOptions.body) },
+        response: { headers: opened.headers },
+    };
+}
+export function createCommandCodeLanguageModel(options) {
+    const provider = parseProviderId("command-code");
+    const sessionId = createCommandCodeSessionId(options.generateSessionId);
+    const readCliVersion = options.readCliVersion ??
+        createCommandCodeVersionResolver({
+            env: options.env ?? process.env,
+            transport: options.transport,
+        });
+    const runtime = { ...options, sessionId, readCliVersion };
+    return {
+        specificationVersion: "v3",
+        provider,
+        modelId: options.modelId,
+        supportedUrls: {},
+        doGenerate: async (call) => {
+            const { stream } = await streamCommandCode(runtime, call);
+            const content = [];
+            const text = [];
+            const reasoning = [];
+            let finish = createFinishReason();
+            let usage = createUsage();
+            const reader = stream.getReader();
+            try {
+                for (;;) {
+                    const next = await reader.read();
+                    if (next.done) {
+                        break;
+                    }
+                    const part = next.value;
+                    switch (part.type) {
+                        case "text-delta":
+                            text.push(part.delta);
+                            break;
+                        case "reasoning-delta":
+                            reasoning.push(part.delta);
+                            break;
+                        case "tool-call":
+                            content.push({
+                                type: "tool-call",
+                                toolCallId: part.toolCallId,
+                                toolName: part.toolName,
+                                input: part.input,
+                            });
+                            break;
+                        case "finish":
+                            finish = part.finishReason;
+                            usage = part.usage;
+                            break;
+                        case "error":
+                            throw part.error;
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+                await stream.cancel();
+            }
+            const textValue = text.join("");
+            if (textValue.length > 0) {
+                content.unshift({ type: "text", text: textValue });
+            }
+            const reasoningValue = reasoning.join("");
+            if (reasoningValue.length > 0) {
+                content.unshift({ type: "reasoning", text: reasoningValue });
+            }
+            return { content, finishReason: finish, usage, warnings: [] };
+        },
+        doStream: (call) => streamCommandCode(runtime, call),
+    };
+}

package/dist/providers/command-code/models.d.ts

@@ -0,0 +1,3 @@
+import type { HttpTransport } from "../../core/http";
+import type { AdapterModel } from "../../core/models";
+export declare function listCommandCodeModels(transport: HttpTransport, token: string, signal: AbortSignal): Promise<readonly AdapterModel[]>;

package/dist/providers/command-code/models.js

@@ -0,0 +1,18 @@
+import { parseModelIdList } from "../../catalog/parse-ids";
+export async function listCommandCodeModels(transport, token, signal) {
+    const response = await transport.request({
+        method: "GET",
+        url: "https://api.commandcode.ai/provider/v1/models",
+        headers: { authorization: `Bearer ${token}` },
+        body: null,
+    }, signal);
+    if (response.status >= 400) {
+        return [];
+    }
+    try {
+        return parseModelIdList(JSON.parse(new TextDecoder().decode(response.body)));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/providers/command-code/record-stream.d.ts

@@ -0,0 +1 @@
+export declare function commandCodeRecords(chunks: AsyncIterable<Uint8Array>): AsyncIterable<string>;

package/dist/providers/command-code/record-stream.js

@@ -0,0 +1,61 @@
+import { commandCodeStreamRecordTooLargeError } from "./errors";
+const MAX_STREAM_RECORD_BYTES = 1024 * 1024;
+const CARRIAGE_RETURN = 13;
+const LINE_FEED = 10;
+export async function* commandCodeRecords(chunks) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let recordBytes = 0;
+    let pendingCarriageReturn = false;
+    const append = (segment) => {
+        recordBytes += segment.byteLength;
+        if (recordBytes > MAX_STREAM_RECORD_BYTES) {
+            throw commandCodeStreamRecordTooLargeError();
+        }
+        buffer += decoder.decode(segment, { stream: true });
+    };
+    const complete = () => {
+        const record = buffer + decoder.decode();
+        buffer = "";
+        recordBytes = 0;
+        return record;
+    };
+    for await (const chunk of chunks) {
+        let start = 0;
+        if (pendingCarriageReturn && chunk.byteLength === 0)
+            continue;
+        if (pendingCarriageReturn) {
+            pendingCarriageReturn = false;
+            if (chunk[0] === LINE_FEED) {
+                yield complete();
+                start = 1;
+            }
+            else {
+                append(new Uint8Array([CARRIAGE_RETURN]));
+            }
+        }
+        for (let index = 0; index < chunk.byteLength; index += 1) {
+            if (index < start)
+                continue;
+            if (chunk[index] !== LINE_FEED)
+                continue;
+            const contentEnd = chunk[index - 1] === CARRIAGE_RETURN ? index - 1 : index;
+            append(chunk.subarray(start, contentEnd));
+            yield complete();
+            start = index + 1;
+        }
+        const trailing = chunk.subarray(start);
+        if (trailing.at(-1) === CARRIAGE_RETURN) {
+            append(trailing.subarray(0, trailing.byteLength - 1));
+            pendingCarriageReturn = true;
+        }
+        else {
+            append(trailing);
+        }
+    }
+    if (pendingCarriageReturn)
+        append(new Uint8Array([CARRIAGE_RETURN]));
+    buffer += decoder.decode();
+    if (buffer.trim().length > 0)
+        yield buffer;
+}

package/dist/providers/command-code/request-lifecycle.d.ts

@@ -0,0 +1,8 @@
+export { commandCodeHttpError } from "./errors";
+export type CommandCodeRequestLifecycle = {
+    readonly signal: AbortSignal;
+    readonly abort: () => void;
+    readonly dispose: () => void;
+};
+export declare function createCommandCodeRequestLifecycle(parent: AbortSignal | undefined, timeoutMs: number): CommandCodeRequestLifecycle;
+export declare function readCommandCodeErrorBody(chunks: AsyncIterable<Uint8Array>): Promise<string>;