opencode-ext-connector 0.3.0

package/dist/providers/claude/language-model.js

@@ -0,0 +1,109 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// 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 { emitClaudeSseChunks } from "./emit-stream";
+import { buildRequestBody, emptyUsage, parseAssistantText, promptToAnthropicMessages, } from "./prompt";
+export function createClaudeLanguageModel(options) {
+    const provider = parseProviderId("claude");
+    return {
+        specificationVersion: "v3",
+        provider,
+        modelId: options.modelId,
+        supportedUrls: {},
+        doGenerate: async (call) => {
+            const signal = call.abortSignal ?? new AbortController().signal;
+            if (signal.aborted) {
+                throw new OperationCancelledError("claude-generate");
+            }
+            const token = await options.readAccessToken(signal);
+            if (token === null) {
+                throw new AdapterError({
+                    operation: "claude-missing-credentials",
+                    retryable: false,
+                    cause: null,
+                    providerId: provider,
+                });
+            }
+            const mapped = promptToAnthropicMessages(call.prompt);
+            const requestBody = buildRequestBody(options, mapped, false);
+            const response = await options.transport.request({
+                method: "POST",
+                url: "https://api.anthropic.com/v1/messages",
+                headers: {
+                    "anthropic-version": "2023-06-01",
+                    authorization: `Bearer ${token}`,
+                    "content-type": "application/json",
+                    "user-agent": "claude-cli/2.1.6 (external, sdk-cli)",
+                },
+                body: new TextEncoder().encode(JSON.stringify(requestBody)),
+            }, signal);
+            if (response.status >= 400) {
+                throw new AdapterError({
+                    operation: "claude-http",
+                    retryable: response.status >= 500,
+                    cause: null,
+                    providerId: provider,
+                });
+            }
+            const text = parseAssistantText(response.body);
+            return {
+                content: [{ type: "text", text }],
+                finishReason: { unified: "stop", raw: "end_turn" },
+                usage: emptyUsage(),
+                warnings: [],
+            };
+        },
+        doStream: async (call) => {
+            const signal = call.abortSignal ?? new AbortController().signal;
+            if (signal.aborted) {
+                throw new OperationCancelledError("claude-stream");
+            }
+            const token = await options.readAccessToken(signal);
+            if (token === null) {
+                throw new AdapterError({
+                    operation: "claude-missing-credentials",
+                    retryable: false,
+                    cause: null,
+                    providerId: provider,
+                });
+            }
+            const mapped = promptToAnthropicMessages(call.prompt);
+            const requestBody = buildRequestBody(options, mapped, true);
+            const opened = await openHttpBody(options.transport, {
+                method: "POST",
+                url: "https://api.anthropic.com/v1/messages",
+                headers: {
+                    "anthropic-version": "2023-06-01",
+                    authorization: `Bearer ${token}`,
+                    "content-type": "application/json",
+                    "user-agent": "claude-cli/2.1.6 (external, sdk-cli)",
+                },
+                body: new TextEncoder().encode(JSON.stringify(requestBody)),
+            }, signal);
+            if (opened.status >= 400) {
+                throw new AdapterError({
+                    operation: "claude-http",
+                    retryable: opened.status >= 500,
+                    cause: null,
+                    providerId: provider,
+                });
+            }
+            const stream = new ReadableStream({
+                async start(controller) {
+                    try {
+                        await emitClaudeSseChunks(opened.chunks, controller);
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                    finally {
+                        controller.close();
+                    }
+                },
+            });
+            return { stream };
+        },
+    };
+}

package/dist/providers/claude/models.d.ts

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

package/dist/providers/claude/models.js

@@ -0,0 +1,24 @@
+import { parseModelIdList } from "../../catalog/parse-ids";
+import { createClaudeCompatibilityHeaders } from "./compat-request";
+export async function listClaudeModels(options) {
+    const headers = createClaudeCompatibilityHeaders({
+        accessToken: options.token,
+        modelId: "unknown",
+        version: options.version,
+    });
+    const response = await options.transport.request({
+        method: "GET",
+        url: "https://api.anthropic.com/v1/models",
+        headers: Object.fromEntries(headers.entries()),
+        body: null,
+    }, options.signal);
+    if (response.status >= 400) {
+        return [];
+    }
+    try {
+        return parseModelIdList(JSON.parse(new TextDecoder().decode(response.body)));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/providers/claude/prompt.d.ts

@@ -0,0 +1,42 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import { type RequestBody } from "./transform";
+type AnthropicContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "tool_use";
+    readonly id: string;
+    readonly name: string;
+    readonly input: Record<string, unknown>;
+} | {
+    readonly type: "tool_result";
+    readonly tool_use_id: string;
+    readonly content: string;
+    readonly is_error: boolean;
+};
+export declare function promptToAnthropicMessages(prompt: LanguageModelV3CallOptions["prompt"]): {
+    readonly system: string;
+    readonly messages: readonly {
+        readonly role: "user" | "assistant";
+        readonly content: readonly AnthropicContentPart[];
+    }[];
+};
+export declare function buildRequestBody(options: {
+    readonly modelId: string;
+    readonly maxOutputTokens?: number;
+}, mapped: ReturnType<typeof promptToAnthropicMessages>, stream: boolean): RequestBody;
+export declare function parseAssistantText(body: Uint8Array): string;
+export declare function emptyUsage(): {
+    readonly inputTokens: {
+        readonly total: undefined;
+        readonly noCache: undefined;
+        readonly cacheRead: undefined;
+        readonly cacheWrite: undefined;
+    };
+    readonly outputTokens: {
+        readonly total: undefined;
+        readonly text: undefined;
+        readonly reasoning: undefined;
+    };
+};
+export {};

package/dist/providers/claude/prompt.js

@@ -0,0 +1,134 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { repairOrphanToolUses } from "./transform";
+const CLAUDE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+function isTextPart(part) {
+    return (typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        Reflect.get(part, "type") === "text");
+}
+function isToolCallPart(part) {
+    return (typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        Reflect.get(part, "type") === "tool-call");
+}
+function isToolResultPart(part) {
+    return (typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        Reflect.get(part, "type") === "tool-result");
+}
+function toolResultOutputToString(output) {
+    if (output.type === "text") {
+        return output.value;
+    }
+    return JSON.stringify(output);
+}
+function toRecord(value) {
+    if (typeof value === "object" && value !== null) {
+        const result = {};
+        for (const key of Object.keys(value)) {
+            result[key] = Reflect.get(value, key);
+        }
+        return result;
+    }
+    return {};
+}
+function contentPartToAnthropic(part) {
+    if (isTextPart(part)) {
+        return { type: "text", text: part.text };
+    }
+    if (isToolCallPart(part)) {
+        return {
+            type: "tool_use",
+            id: part.toolCallId,
+            name: part.toolName,
+            input: toRecord(part.input),
+        };
+    }
+    if (isToolResultPart(part)) {
+        return {
+            type: "tool_result",
+            tool_use_id: part.toolCallId,
+            content: toolResultOutputToString(part.output),
+            is_error: false,
+        };
+    }
+    return { type: "text", text: "" };
+}
+export function promptToAnthropicMessages(prompt) {
+    const messages = [];
+    const systems = [CLAUDE_IDENTITY];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                systems.push(message.content);
+                break;
+            case "user": {
+                const content = [];
+                for (const part of message.content) {
+                    if (isTextPart(part) || isToolCallPart(part) || isToolResultPart(part)) {
+                        content.push(contentPartToAnthropic(part));
+                    }
+                }
+                messages.push({ role: "user", content });
+                break;
+            }
+            case "assistant": {
+                const content = [];
+                for (const part of message.content) {
+                    if (isTextPart(part) || isToolCallPart(part) || isToolResultPart(part)) {
+                        content.push(contentPartToAnthropic(part));
+                    }
+                }
+                messages.push({ role: "assistant", content });
+                break;
+            }
+            case "tool":
+                break;
+        }
+    }
+    return { system: systems.join("\n"), messages };
+}
+export function buildRequestBody(options, mapped, stream) {
+    const baseBody = {
+        model: options.modelId,
+        max_tokens: options.maxOutputTokens ?? 4096,
+        system: mapped.system,
+        messages: mapped.messages,
+    };
+    const requestBody = stream ? { ...baseBody, stream: true } : baseBody;
+    return repairOrphanToolUses(requestBody);
+}
+export function parseAssistantText(body) {
+    const parsed = JSON.parse(new TextDecoder().decode(body));
+    if (typeof parsed !== "object" || parsed === null || !("content" in parsed)) {
+        return "";
+    }
+    const content = parsed.content;
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const texts = [];
+    for (const part of content) {
+        if (typeof part === "object" && part !== null && "type" in part && "text" in part) {
+            if (part.type === "text" && typeof part.text === "string") {
+                texts.push(part.text);
+            }
+        }
+    }
+    return texts.join("");
+}
+export function emptyUsage() {
+    return {
+        inputTokens: {
+            total: undefined,
+            noCache: undefined,
+            cacheRead: undefined,
+            cacheWrite: undefined,
+        },
+        outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    };
+}

package/dist/providers/claude/refresh.d.ts

@@ -0,0 +1,19 @@
+import type { Clock } from "../../core/clock";
+import type { HttpTransport } from "../../core/http";
+import type { ClaudeCredentials } from "./credentials";
+export type RefreshClaudeOptions = {
+    readonly transport: HttpTransport;
+    readonly clock: Clock;
+    readonly refreshToken: string;
+    readonly signal: AbortSignal;
+};
+export type ClaudeRefreshResult = {
+    readonly ok: true;
+    readonly credentials: ClaudeCredentials;
+} | {
+    readonly ok: false;
+    readonly kind: "transient" | "terminal";
+    readonly retryAfterMs: number | null;
+};
+export declare function refreshClaudeAccessTokenResult(options: RefreshClaudeOptions): Promise<ClaudeRefreshResult>;
+export declare function refreshClaudeAccessToken(options: RefreshClaudeOptions): Promise<ClaudeCredentials | null>;

package/dist/providers/claude/refresh.js

@@ -0,0 +1,85 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+const OAUTH_TOKEN_URL = "https://claude.ai/v1/oauth/token";
+const OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+function stringField(value, key) {
+    if (!(key in value)) {
+        return null;
+    }
+    const field = Reflect.get(value, key);
+    return typeof field === "string" && field.length > 0 ? field : null;
+}
+function numberField(value, key) {
+    if (!(key in value)) {
+        return null;
+    }
+    const field = Reflect.get(value, key);
+    return typeof field === "number" && Number.isFinite(field) ? field : null;
+}
+function retryAfterMs(headers) {
+    const seconds = Number.parseInt(headers["retry-after"] ?? "", 10);
+    return Number.isFinite(seconds) && seconds > 0 ? seconds * 1_000 : null;
+}
+export async function refreshClaudeAccessTokenResult(options) {
+    const body = new TextEncoder().encode(new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: OAUTH_CLIENT_ID,
+        refresh_token: options.refreshToken,
+    }).toString());
+    const response = await options.transport.request({
+        method: "POST",
+        url: OAUTH_TOKEN_URL,
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body,
+    }, options.signal);
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(response.body));
+    }
+    catch {
+        return {
+            ok: false,
+            kind: "transient",
+            retryAfterMs: retryAfterMs(response.headers),
+        };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return { ok: false, kind: "transient", retryAfterMs: null };
+    }
+    if (response.status < 200 || response.status >= 300) {
+        const oauthError = stringField(parsed, "error");
+        const terminal = new Set([
+            "invalid_grant",
+            "invalid_client",
+            "unauthorized_client",
+            "unsupported_grant_type",
+        ]);
+        return {
+            ok: false,
+            kind: oauthError !== null && terminal.has(oauthError) ? "terminal" : "transient",
+            retryAfterMs: retryAfterMs(response.headers),
+        };
+    }
+    const accessToken = stringField(parsed, "access_token");
+    if (accessToken === null) {
+        return { ok: false, kind: "transient", retryAfterMs: null };
+    }
+    const nowMs = options.clock.nowMs();
+    const expiresAt = numberField(parsed, "expires_at");
+    const expiresIn = numberField(parsed, "expires_in");
+    const expiresAtMs = expiresAt !== null && expiresAt > nowMs
+        ? Math.trunc(expiresAt)
+        : Math.trunc(nowMs + (expiresIn ?? 36_000) * 1000);
+    return {
+        ok: true,
+        credentials: {
+            accessToken,
+            refreshToken: stringField(parsed, "refresh_token") ?? options.refreshToken,
+            expiresAtMs,
+        },
+    };
+}
+export async function refreshClaudeAccessToken(options) {
+    const result = await refreshClaudeAccessTokenResult(options);
+    return result.ok ? result.credentials : null;
+}

package/dist/providers/claude/sse-convert.d.ts

@@ -0,0 +1,6 @@
+import type { AnthropicSseEvent, SseParseResult } from "./sse";
+export declare function convertEventToPart(event: AnthropicSseEvent): SseParseResult | null;
+export declare function mapStopReason(reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null): {
+    unified: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other";
+    raw: string;
+};

package/dist/providers/claude/sse-convert.js

@@ -0,0 +1,74 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+export function convertEventToPart(event) {
+    switch (event.type) {
+        case "message_start": {
+            return { kind: "part", part: { type: "stream-start", warnings: [] } };
+        }
+        case "content_block_start": {
+            const block = event.content_block;
+            if (block.type === "text") {
+                return { kind: "part", part: { type: "text-start", id: `text-${event.index}` } };
+            }
+            if (block.type === "tool_use" && block.id !== undefined && block.name !== undefined) {
+                return {
+                    kind: "part",
+                    part: {
+                        type: "tool-input-start",
+                        id: block.id,
+                        toolName: block.name,
+                        providerExecuted: false,
+                        dynamic: false,
+                    },
+                };
+            }
+            return null;
+        }
+        case "content_block_delta": {
+            const delta = event.delta;
+            if (delta.type === "text_delta" && delta.text !== undefined) {
+                return {
+                    kind: "part",
+                    part: { type: "text-delta", id: `text-${event.index}`, delta: delta.text },
+                };
+            }
+            if (delta.type === "input_json_delta" && delta.partial_json !== undefined) {
+                return {
+                    kind: "part",
+                    part: { type: "tool-input-delta", id: `tool-${event.index}`, delta: delta.partial_json },
+                };
+            }
+            return null;
+        }
+        case "content_block_stop": {
+            return { kind: "part", part: { type: "text-end", id: `text-${event.index}` } };
+        }
+        case "message_delta": {
+            const stopReason = event.delta.stop_reason;
+            if (stopReason !== null) {
+                return { kind: "finish", stopReason };
+            }
+            return null;
+        }
+        case "message_stop": {
+            return { kind: "finish", stopReason: "end_turn" };
+        }
+        case "error": {
+            return { kind: "error", error: new Error(`Anthropic API error: ${event.error.message}`) };
+        }
+    }
+}
+export function mapStopReason(reason) {
+    switch (reason) {
+        case "end_turn":
+            return { unified: "stop", raw: "end_turn" };
+        case "max_tokens":
+            return { unified: "length", raw: "max_tokens" };
+        case "stop_sequence":
+            return { unified: "stop", raw: "stop_sequence" };
+        case "tool_use":
+            return { unified: "tool-calls", raw: "tool_use" };
+        default:
+            return { unified: "other", raw: "unknown" };
+    }
+}

package/dist/providers/claude/sse.d.ts

@@ -0,0 +1,71 @@
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export type AnthropicSseEvent = {
+    readonly type: "message_start";
+    readonly message: {
+        readonly id: string;
+        readonly type: "message";
+        readonly role: "assistant";
+        readonly content: readonly unknown[];
+        readonly model: string;
+        readonly stop_reason: null;
+        readonly stop_sequence: null;
+        readonly usage: {
+            readonly input_tokens: number;
+            readonly output_tokens: number;
+        };
+    };
+} | {
+    readonly type: "content_block_start";
+    readonly index: number;
+    readonly content_block: {
+        readonly type: "text" | "tool_use";
+        readonly id?: string;
+        readonly name?: string;
+        readonly input?: Record<string, unknown>;
+    };
+} | {
+    readonly type: "content_block_delta";
+    readonly index: number;
+    readonly delta: {
+        readonly type: "text_delta" | "input_json_delta";
+        readonly text?: string;
+        readonly partial_json?: string;
+    };
+} | {
+    readonly type: "content_block_stop";
+    readonly index: number;
+} | {
+    readonly type: "message_delta";
+    readonly delta: {
+        readonly stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
+        readonly stop_sequence: string | null;
+    };
+} | {
+    readonly type: "message_stop";
+} | {
+    readonly type: "error";
+    readonly error: {
+        readonly type: string;
+        readonly message: string;
+    };
+};
+export type SseParseResult = {
+    readonly kind: "part";
+    readonly part: LanguageModelV3StreamPart;
+} | {
+    readonly kind: "finish";
+    readonly stopReason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
+} | {
+    readonly kind: "error";
+    readonly error: Error;
+};
+export type SseParseState = {
+    readonly buffer: string;
+    readonly event: string | null;
+};
+export declare function createSseParseState(): SseParseState;
+export declare function parseAnthropicSse(chunk: Uint8Array, state: SseParseState): {
+    readonly events: readonly SseParseResult[];
+    readonly state: SseParseState;
+};
+export { convertEventToPart, mapStopReason } from "./sse-convert";