opencode-ext-connector 0.3.0

package/dist/providers/claude/compat-request.js

@@ -0,0 +1,151 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { randomUUID } from "node:crypto";
+import { claudeModelBetas, excludeClaudeBeta, isClaudeLongContextError, nextClaudeBetaToExclude, } from "./compat-betas";
+import { transformClaudeResponse } from "./compat-response";
+import { transformClaudeBody } from "./compat-transform";
+const sessionId = randomUUID();
+function requestUrl(input) {
+    const raw = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const url = new URL(raw);
+    if (url.pathname === "/v1/messages" && !url.searchParams.has("beta")) {
+        url.searchParams.set("beta", "true");
+    }
+    return typeof input === "string" ? url.toString() : url;
+}
+function modelFromBody(body) {
+    if (typeof body !== "string") {
+        return "unknown";
+    }
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed === "object" && parsed !== null && "model" in parsed) {
+            const model = Reflect.get(parsed, "model");
+            return typeof model === "string" ? model : "unknown";
+        }
+    }
+    catch { }
+    return "unknown";
+}
+export function createClaudeCompatibilityHeaders(options) {
+    const headers = new Headers(options.incoming);
+    const incoming = (headers.get("anthropic-beta") ?? "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    headers.set("authorization", `Bearer ${options.accessToken}`);
+    headers.set("anthropic-version", "2023-06-01");
+    headers.set("anthropic-beta", [...new Set([...claudeModelBetas(options.modelId), ...incoming])].join(","));
+    headers.set("anthropic-dangerous-direct-browser-access", "true");
+    headers.set("x-app", "cli");
+    headers.set("user-agent", process.env["ANTHROPIC_USER_AGENT"] ?? `claude-cli/${options.version} (external, sdk-cli)`);
+    headers.set("x-client-request-id", randomUUID());
+    headers.set("X-Claude-Code-Session-Id", sessionId);
+    const stainless = {
+        "x-stainless-arch": process.arch === "arm64" ? "arm64" : process.arch,
+        "x-stainless-lang": "js",
+        "x-stainless-os": process.platform === "darwin" ? "MacOS" : process.platform,
+        "x-stainless-package-version": "0.81.0",
+        "x-stainless-retry-count": "0",
+        "x-stainless-runtime": "node",
+        "x-stainless-runtime-version": process.version,
+        "x-stainless-timeout": "600",
+    };
+    for (const [key, value] of Object.entries(stainless)) {
+        if (!headers.has(key)) {
+            headers.set(key, value);
+        }
+    }
+    headers.delete("x-api-key");
+    return headers;
+}
+function maxRetryDelayMs() {
+    const value = Number.parseInt(process.env["OPENCODE_CLAUDE_AUTH_MAX_RETRY_MS"] ?? "", 10);
+    return Number.isFinite(value) && value > 0 ? value : 30_000;
+}
+async function sleepUnlessAborted(ms, signal) {
+    await new Promise((resolve) => {
+        if (signal?.aborted === true) {
+            resolve();
+            return;
+        }
+        const finish = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        signal?.addEventListener("abort", finish, { once: true });
+    });
+}
+async function fetchWithRetry(input, init) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const response = await globalThis.fetch(input, init);
+        if ((response.status !== 429 && response.status !== 529) || attempt === 2) {
+            return response;
+        }
+        const retryAfter = Number.parseInt(response.headers.get("retry-after") ?? "", 10);
+        const delay = Number.isFinite(retryAfter) ? retryAfter * 1_000 : (attempt + 1) * 2_000;
+        if (delay > maxRetryDelayMs()) {
+            return response;
+        }
+        await sleepUnlessAborted(delay, init.signal);
+        if (init.signal?.aborted === true) {
+            return response;
+        }
+    }
+    return globalThis.fetch(input, init);
+}
+export function createClaudeCompatibilityFetch(options) {
+    return async (input, requestInit = {}) => {
+        const signal = requestInit.signal ?? new AbortController().signal;
+        let token = await options.readAccessToken(signal);
+        if (token === null) {
+            throw new Error("Claude Code credentials are unavailable or expired. Provide a valid `~/.claude/.credentials.json`.");
+        }
+        const version = await options.readVersion(signal);
+        if (version === null) {
+            throw new Error("Claude Code client version is unavailable. Set ANTHROPIC_CLI_VERSION or allow access to registry.npmjs.org.");
+        }
+        const modelId = modelFromBody(requestInit.body);
+        const body = transformClaudeBody(requestInit.body, version);
+        const url = requestUrl(input);
+        const send = (accessToken) => {
+            const incoming = new Headers(input instanceof Request ? input.headers : undefined);
+            new Headers(requestInit.headers).forEach((value, key) => {
+                incoming.set(key, value);
+            });
+            return fetchWithRetry(url, {
+                ...requestInit,
+                body,
+                headers: createClaudeCompatibilityHeaders({
+                    accessToken,
+                    modelId,
+                    version,
+                    incoming,
+                }),
+            });
+        };
+        let response = await send(token);
+        if (response.status === 401) {
+            const refreshed = await options.forceRefreshAccessToken(signal);
+            if (refreshed !== null) {
+                token = refreshed;
+                response = await send(refreshed);
+            }
+        }
+        for (let attempt = 0; !response.ok && attempt < 2; attempt += 1) {
+            const bodyText = await response.clone().text();
+            if (!isClaudeLongContextError(bodyText)) {
+                break;
+            }
+            const excluded = nextClaudeBetaToExclude(modelId);
+            if (excluded === null) {
+                break;
+            }
+            excludeClaudeBeta(modelId, excluded);
+            response = await send(token);
+        }
+        return transformClaudeResponse(response);
+    };
+}

package/dist/providers/claude/compat-response.d.ts

@@ -0,0 +1 @@
+export declare function transformClaudeResponse(response: Response): Response;

package/dist/providers/claude/compat-response.js

@@ -0,0 +1,54 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { stripClaudeToolPrefix } from "./compat-transform";
+export function transformClaudeResponse(response) {
+    if (response.body === null) {
+        return response;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let buffer = "";
+    const stream = new ReadableStream({
+        async pull(controller) {
+            if (!response.ok) {
+                const next = await reader.read();
+                if (next.done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(encoder.encode(stripClaudeToolPrefix(decoder.decode(next.value))));
+                return;
+            }
+            for (;;) {
+                const boundary = buffer.indexOf("\n\n");
+                if (boundary !== -1) {
+                    const event = buffer.slice(0, boundary + 2);
+                    buffer = buffer.slice(boundary + 2);
+                    controller.enqueue(encoder.encode(stripClaudeToolPrefix(event)));
+                    return;
+                }
+                const next = await reader.read();
+                if (next.done) {
+                    if (buffer.length > 0) {
+                        controller.enqueue(encoder.encode(stripClaudeToolPrefix(buffer)));
+                        buffer = "";
+                    }
+                    else {
+                        controller.close();
+                    }
+                    return;
+                }
+                buffer += decoder.decode(next.value, { stream: true });
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+        },
+    });
+    return new Response(stream, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}

package/dist/providers/claude/compat-signing.d.ts

@@ -0,0 +1,9 @@
+type SigningMessage = {
+    readonly role?: string;
+    readonly content?: string | readonly {
+        readonly type?: string;
+        readonly text?: string;
+    }[];
+};
+export declare function claudeBillingHeader(messages: readonly SigningMessage[], version: string, entrypoint: string): string;
+export {};

package/dist/providers/claude/compat-signing.js

@@ -0,0 +1,24 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { createHash } from "node:crypto";
+const BILLING_SALT = "59cf53e54c78";
+function firstUserText(messages) {
+    const message = messages.find((candidate) => candidate.role === "user");
+    if (message === undefined) {
+        return "";
+    }
+    if (typeof message.content === "string") {
+        return message.content;
+    }
+    return message.content?.find((block) => block.type === "text")?.text ?? "";
+}
+function hashPrefix(value, length) {
+    return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+export function claudeBillingHeader(messages, version, entrypoint) {
+    const text = firstUserText(messages);
+    const sampled = [4, 7, 20].map((index) => text[index] ?? "0").join("");
+    const suffix = hashPrefix(`${BILLING_SALT}${sampled}${version}`, 3);
+    const cch = hashPrefix(text, 5);
+    return `x-anthropic-billing-header: cc_version=${version}.${suffix}; cc_entrypoint=${entrypoint}; cch=${cch};`;
+}

package/dist/providers/claude/compat-transform.d.ts

@@ -0,0 +1,3 @@
+export declare const CLAUDE_SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+export declare function transformClaudeBody(body: RequestInit["body"], version: string): RequestInit["body"];
+export declare function stripClaudeToolPrefix(text: string): string;

package/dist/providers/claude/compat-transform.js

@@ -0,0 +1,224 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { claudeModelOverride } from "./compat-config";
+import { claudeBillingHeader } from "./compat-signing";
+export const CLAUDE_SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+const BILLING_PREFIX = "x-anthropic-billing-header";
+const TOOL_PREFIX = "mcp_";
+const TOOL_RESULT_PLACEHOLDER = "Tool result unavailable (removed during context compaction).";
+function record(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = Reflect.get(value, key);
+    }
+    return result;
+}
+function stringField(value, key) {
+    const field = value[key];
+    return typeof field === "string" ? field : undefined;
+}
+function prefixToolName(name) {
+    return `${TOOL_PREFIX}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+}
+function contentRecords(message) {
+    const content = message["content"];
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    return content.map(record).filter((part) => part !== null);
+}
+function toolIds(message, type) {
+    if (message === undefined) {
+        return [];
+    }
+    const key = type === "tool_use" ? "id" : "tool_use_id";
+    return (contentRecords(message) ?? [])
+        .filter((part) => part["type"] === type)
+        .map((part) => stringField(part, key))
+        .filter((id) => id !== undefined);
+}
+function repairToolPairs(messages) {
+    const withoutOrphanResults = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message === undefined) {
+            continue;
+        }
+        const content = contentRecords(message);
+        if (content === null) {
+            withoutOrphanResults.push(message);
+            continue;
+        }
+        const previousUses = new Set(toolIds(messages[index - 1], "tool_use"));
+        const filtered = content.filter((part) => {
+            const resultId = part["type"] === "tool_result" ? stringField(part, "tool_use_id") : undefined;
+            return resultId === undefined || previousUses.has(resultId);
+        });
+        if (filtered.length > 0 || content.length === 0) {
+            withoutOrphanResults.push({ ...message, content: filtered });
+        }
+    }
+    const output = [];
+    for (let index = 0; index < withoutOrphanResults.length; index += 1) {
+        const message = withoutOrphanResults[index];
+        if (message === undefined) {
+            continue;
+        }
+        output.push(message);
+        const uses = toolIds(message, "tool_use");
+        if (uses.length === 0) {
+            continue;
+        }
+        const next = withoutOrphanResults[index + 1];
+        const results = new Set(toolIds(next, "tool_result"));
+        const missing = uses.filter((id) => !results.has(id));
+        if (missing.length === 0) {
+            continue;
+        }
+        const synthetic = missing.map((id) => ({
+            type: "tool_result",
+            tool_use_id: id,
+            content: TOOL_RESULT_PLACEHOLDER,
+            is_error: true,
+        }));
+        if (next?.["role"] === "user") {
+            const nextContent = next["content"];
+            const merged = typeof nextContent === "string"
+                ? [...synthetic, ...(nextContent.length > 0 ? [{ type: "text", text: nextContent }] : [])]
+                : [...synthetic, ...(contentRecords(next) ?? [])];
+            output.push({ ...next, content: merged });
+            index += 1;
+        }
+        else {
+            output.push({ role: "user", content: synthetic });
+        }
+    }
+    return output;
+}
+function transformTools(body) {
+    const tools = body["tools"];
+    if (Array.isArray(tools)) {
+        body["tools"] = tools.map((value) => {
+            const tool = record(value);
+            if (tool === null) {
+                return value;
+            }
+            const name = stringField(tool, "name");
+            return name === undefined ? tool : { ...tool, name: prefixToolName(name) };
+        });
+    }
+}
+function transformMessages(body) {
+    const raw = body["messages"];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const messages = raw
+        .map(record)
+        .filter((value) => value !== null);
+    const prefixed = messages.map((message) => {
+        const content = contentRecords(message);
+        if (content === null) {
+            return message;
+        }
+        return {
+            ...message,
+            content: content.map((part) => {
+                const name = part["type"] === "tool_use" ? stringField(part, "name") : undefined;
+                return name === undefined ? part : { ...part, name: prefixToolName(name) };
+            }),
+        };
+    });
+    return repairToolPairs(prefixed);
+}
+function transformSystem(body, messages, version) {
+    const system = body["system"];
+    const entries = Array.isArray(system)
+        ? system.map(record).filter((value) => value !== null)
+        : typeof system === "string"
+            ? [{ type: "text", text: system }]
+            : [];
+    const billing = claudeBillingHeader(messages, version, process.env["CLAUDE_CODE_ENTRYPOINT"] ?? "sdk-cli");
+    const moved = [];
+    const kept = [{ type: "text", text: billing }];
+    let hasIdentity = false;
+    for (const entry of entries) {
+        const text = stringField(entry, "text") ?? "";
+        if (text.startsWith(BILLING_PREFIX)) {
+            continue;
+        }
+        if (text.startsWith(CLAUDE_SYSTEM_IDENTITY)) {
+            kept.push({ type: "text", text: CLAUDE_SYSTEM_IDENTITY });
+            hasIdentity = true;
+            const remainder = text.slice(CLAUDE_SYSTEM_IDENTITY.length).replace(/^\n+/, "");
+            if (remainder.length > 0) {
+                moved.push(remainder);
+            }
+        }
+        else if (text.length > 0) {
+            moved.push(text);
+        }
+    }
+    if (!hasIdentity) {
+        kept.push({ type: "text", text: CLAUDE_SYSTEM_IDENTITY });
+    }
+    if (moved.length > 0) {
+        const firstUser = messages.find((message) => message["role"] === "user");
+        if (firstUser !== undefined) {
+            const prefix = moved.join("\n\n");
+            const content = firstUser["content"];
+            firstUser["content"] =
+                typeof content === "string"
+                    ? `${prefix}\n\n${content}`
+                    : [{ type: "text", text: prefix }, ...(contentRecords(firstUser) ?? [])];
+        }
+    }
+    body["system"] = kept;
+}
+function stripUnsupportedEffort(body) {
+    const model = typeof body["model"] === "string" ? body["model"] : "";
+    if (claudeModelOverride(model)?.disableEffort !== true) {
+        return;
+    }
+    for (const key of ["output_config", "thinking"]) {
+        const value = record(body[key]);
+        if (value === null) {
+            continue;
+        }
+        delete value["effort"];
+        if (Object.keys(value).length === 0) {
+            delete body[key];
+        }
+        else {
+            body[key] = value;
+        }
+    }
+}
+export function transformClaudeBody(body, version) {
+    if (typeof body !== "string") {
+        return body;
+    }
+    try {
+        const parsed = record(JSON.parse(body));
+        if (parsed === null) {
+            return body;
+        }
+        const messages = transformMessages(parsed);
+        parsed["messages"] = messages;
+        transformSystem(parsed, messages, version);
+        transformTools(parsed);
+        stripUnsupportedEffort(parsed);
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return body;
+    }
+}
+export function stripClaudeToolPrefix(text) {
+    return text.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, (_match, name) => {
+        return `"name": "${name.charAt(0).toLowerCase()}${name.slice(1)}"`;
+    });
+}

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

@@ -0,0 +1,7 @@
+export type ClaudeCredentials = {
+    readonly accessToken: string;
+    readonly refreshToken: string | null;
+    readonly expiresAtMs: number | null;
+};
+export declare function parseClaudeCredentials(value: unknown): ClaudeCredentials | null;
+export declare function claudeAccessNeedsRefresh(credentials: ClaudeCredentials, nowMs: number, skewMs?: number): boolean;

package/dist/providers/claude/credentials.js

@@ -0,0 +1,37 @@
+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) ? Math.trunc(field) : null;
+}
+export function parseClaudeCredentials(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const oauth = "claudeAiOauth" in value ? Reflect.get(value, "claudeAiOauth") : value;
+    if (typeof oauth !== "object" || oauth === null) {
+        return null;
+    }
+    const accessToken = stringField(oauth, "accessToken");
+    const refreshToken = stringField(oauth, "refreshToken");
+    const expiresAtMs = numberField(oauth, "expiresAt");
+    if (accessToken === null || refreshToken === null || expiresAtMs === null) {
+        return null;
+    }
+    return {
+        accessToken,
+        refreshToken,
+        expiresAtMs,
+    };
+}
+export function claudeAccessNeedsRefresh(credentials, nowMs, skewMs = 60_000) {
+    return credentials.expiresAtMs !== null && credentials.expiresAtMs - skewMs <= nowMs;
+}

package/dist/providers/claude/emit-stream.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export declare function emitClaudeSseChunks(chunks: AsyncIterable<Uint8Array>, controller: ReadableStreamDefaultController<LanguageModelV3StreamPart>): Promise<void>;

package/dist/providers/claude/emit-stream.js

@@ -0,0 +1,62 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { createSseParseState, mapStopReason, parseAnthropicSse } from "./sse";
+export async function emitClaudeSseChunks(chunks, controller) {
+    controller.enqueue({ type: "stream-start", warnings: [] });
+    let finishReason = { unified: "stop", raw: "end_turn" };
+    let textBlockIndex = 0;
+    let toolBlockIndex = 0;
+    let state = createSseParseState();
+    const emit = (chunk) => {
+        const parsed = parseAnthropicSse(chunk, state);
+        state = parsed.state;
+        for (const event of parsed.events) {
+            if (event.kind === "part") {
+                const part = event.part;
+                if (part.type === "text-start") {
+                    textBlockIndex += 1;
+                    controller.enqueue({ ...part, id: `text-${textBlockIndex}` });
+                }
+                else if (part.type === "text-delta" || part.type === "text-end") {
+                    controller.enqueue({ ...part, id: `text-${textBlockIndex}` });
+                }
+                else if (part.type === "tool-input-start") {
+                    toolBlockIndex += 1;
+                    controller.enqueue({ ...part, id: part.id });
+                }
+                else if (part.type === "tool-input-delta" || part.type === "tool-input-end") {
+                    controller.enqueue({ ...part, id: `tool-${toolBlockIndex}` });
+                }
+                else {
+                    controller.enqueue(part);
+                }
+            }
+            else if (event.kind === "finish") {
+                finishReason = mapStopReason(event.stopReason);
+            }
+            else if (event.kind === "error") {
+                controller.error(event.error);
+                return;
+            }
+        }
+    };
+    for await (const chunk of chunks) {
+        emit(chunk);
+    }
+    if (state.buffer.length > 0 || state.event !== null) {
+        emit(new TextEncoder().encode("\n"));
+    }
+    controller.enqueue({
+        type: "finish",
+        finishReason,
+        usage: {
+            inputTokens: {
+                total: undefined,
+                noCache: undefined,
+                cacheRead: undefined,
+                cacheWrite: undefined,
+            },
+            outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+        },
+    });
+}

package/dist/providers/claude/keychain-account.d.ts

@@ -0,0 +1 @@
+export declare function parseKeychainAccount(dump: string): string | null;

package/dist/providers/claude/keychain-account.js

@@ -0,0 +1,14 @@
+const ACCT_MARKER = '"acct"<blob>="';
+export function parseKeychainAccount(dump) {
+    const start = dump.indexOf(ACCT_MARKER);
+    if (start === -1) {
+        return null;
+    }
+    const valueStart = start + ACCT_MARKER.length;
+    const end = dump.indexOf('"', valueStart);
+    if (end === -1) {
+        return null;
+    }
+    const account = dump.slice(valueStart, end);
+    return account.length > 0 ? account : null;
+}

package/dist/providers/claude/language-model.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { HttpTransport } from "../../core/http";
+export type ClaudeLanguageModelOptions = {
+    readonly modelId: string;
+    readonly transport: HttpTransport;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+};
+export declare function createClaudeLanguageModel(options: ClaudeLanguageModelOptions): LanguageModelV3;