opencode-ext-connector 0.3.0

package/dist/opencode/v1-session-auth.js

@@ -0,0 +1,98 @@
+import { readCommandCodeAccessToken } from "../providers/command-code/auth";
+import { readCursorAccessToken } from "../providers/cursor/auth";
+import { productionOllamaFetch } from "../providers/ollama/http";
+import { probeLocalOllama } from "./ollama-probe";
+const CURSOR_SESSION_MARKER = "cli-session:cursor";
+const COMMAND_CODE_SESSION_MARKER = "cli-session:command-code";
+const OLLAMA_SESSION_MARKER = "cli-session:ollama";
+const OLLAMA_AVAILABLE_INSTRUCTIONS = "The connector will reuse the running local Ollama daemon. Cloud access remains managed by `ollama signin`; this plugin does not run sign-in.";
+const OLLAMA_UNAVAILABLE_INSTRUCTIONS = "Start the local Ollama daemon, then retry.";
+function sessionMethod(options) {
+    return {
+        type: "oauth",
+        label: options.label,
+        authorize: async () => {
+            const available = await options.verify();
+            return {
+                url: "",
+                instructions: available
+                    ? options.instructions
+                    : `No logged-in ${options.label} session was found. Log in with the vendor CLI, then retry.`,
+                method: "auto",
+                callback: async () => available
+                    ? {
+                        type: "success",
+                        provider: options.provider,
+                        key: options.marker,
+                    }
+                    : { type: "failed" },
+            };
+        },
+    };
+}
+async function hasCursorSession(env) {
+    return (await readCursorAccessToken(env, new AbortController().signal)) !== null;
+}
+async function hasCommandCodeSession(env) {
+    return (await readCommandCodeAccessToken(env, new AbortController().signal)) !== null;
+}
+export function createCursorSessionAuth(env) {
+    return {
+        provider: "cursor",
+        methods: [
+            sessionMethod({
+                provider: "cursor",
+                label: "Cursor CLI login",
+                instructions: "Using the existing Cursor CLI login/token.",
+                marker: CURSOR_SESSION_MARKER,
+                verify: () => hasCursorSession(env),
+            }),
+        ],
+    };
+}
+export function createCommandCodeSessionAuth(env) {
+    return {
+        provider: "command-code",
+        methods: [
+            sessionMethod({
+                provider: "command-code",
+                label: "Command Code CLI login",
+                instructions: "Using the existing Command Code CLI session.",
+                marker: COMMAND_CODE_SESSION_MARKER,
+                verify: () => hasCommandCodeSession(env),
+            }),
+            {
+                type: "api",
+                label: "Command Code API key",
+            },
+        ],
+    };
+}
+export function createOllamaSessionAuth(fetch = productionOllamaFetch) {
+    return {
+        provider: "ollama",
+        methods: [
+            {
+                type: "oauth",
+                label: "Ollama local daemon",
+                authorize: async () => {
+                    const available = await probeLocalOllama(fetch);
+                    return {
+                        url: "",
+                        instructions: available
+                            ? OLLAMA_AVAILABLE_INSTRUCTIONS
+                            : OLLAMA_UNAVAILABLE_INSTRUCTIONS,
+                        method: "auto",
+                        callback: async () => (await probeLocalOllama(fetch))
+                            ? {
+                                type: "success",
+                                provider: "ollama",
+                                key: OLLAMA_SESSION_MARKER,
+                            }
+                            : { type: "failed" },
+                    };
+                },
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { ProviderAdapter } from "../../core/adapter";
+import type { AdapterModel } from "../../core/models";
+export type ClaudeAdapterOptions = {
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly listModels: (token: string, signal: AbortSignal) => Promise<readonly AdapterModel[]>;
+};
+export declare function createClaudeAdapter(options: ClaudeAdapterOptions): ProviderAdapter;

package/dist/providers/claude/adapter.js

@@ -0,0 +1,37 @@
+import { OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { createAsyncDisposable } from "../../core/lifecycle";
+export function createClaudeAdapter(options) {
+    const providerId = parseProviderId("claude");
+    const disposal = createAsyncDisposable(() => undefined);
+    let lastModels = null;
+    return {
+        providerId,
+        snapshot: async (signal) => {
+            if (signal.aborted) {
+                throw new OperationCancelledError("claude-snapshot");
+            }
+            const token = await options.readAccessToken(signal);
+            if (token === null) {
+                return { status: "unavailable", providerId, reason: "invalid-data" };
+            }
+            try {
+                const models = await options.listModels(token, signal);
+                if (models.length === 0) {
+                    return lastModels === null
+                        ? { status: "unavailable", providerId, reason: "invalid-data" }
+                        : { status: "stale", providerId, models: lastModels, reason: "invalid-data" };
+                }
+                lastModels = models;
+                return { status: "ready", providerId, models };
+            }
+            catch {
+                return lastModels === null
+                    ? { status: "unavailable", providerId, reason: "transport-error" }
+                    : { status: "stale", providerId, models: lastModels, reason: "transport-error" };
+            }
+        },
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}

package/dist/providers/claude/atomic-private-file.d.ts

@@ -0,0 +1,13 @@
+export declare class ClaudeCredentialSymlinkError extends Error {
+    readonly path: string;
+    readonly name = "ClaudeCredentialSymlinkError";
+    constructor(path: string);
+}
+export declare class ClaudeCredentialCleanupError extends Error {
+    readonly path: string;
+    readonly primaryFailure: unknown;
+    readonly cleanupFailures: readonly unknown[];
+    readonly name = "ClaudeCredentialCleanupError";
+    constructor(path: string, primaryFailure: unknown, cleanupFailures: readonly unknown[]);
+}
+export declare function writeClaudePrivateFile(path: string, body: string): Promise<void>;

package/dist/providers/claude/atomic-private-file.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+export class ClaudeCredentialSymlinkError extends Error {
+    path;
+    name = "ClaudeCredentialSymlinkError";
+    constructor(path) {
+        super(`refusing to replace symbolic link at ${path}`);
+        this.path = path;
+    }
+}
+export class ClaudeCredentialCleanupError extends Error {
+    path;
+    primaryFailure;
+    cleanupFailures;
+    name = "ClaudeCredentialCleanupError";
+    constructor(path, primaryFailure, cleanupFailures) {
+        super(`credential write failed and temporary-file cleanup also failed for ${path}`, {
+            cause: primaryFailure,
+        });
+        this.path = path;
+        this.primaryFailure = primaryFailure;
+        this.cleanupFailures = cleanupFailures;
+    }
+}
+class CleanupRejectionError extends Error {
+    rejection;
+    name = "CleanupRejectionError";
+    constructor(rejection) {
+        super("temporary-file cleanup rejected with a non-Error value", { cause: rejection });
+        this.rejection = rejection;
+    }
+}
+function errorCode(error) {
+    return "code" in error ? Reflect.get(error, "code") : undefined;
+}
+async function rejectSymbolicLink(path) {
+    try {
+        const destination = await lstat(path);
+        if (destination.isSymbolicLink()) {
+            throw new ClaudeCredentialSymlinkError(path);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && errorCode(error) === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+}
+export async function writeClaudePrivateFile(path, body) {
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true });
+    await rejectSymbolicLink(path);
+    const candidate = join(directory, `.${basename(path)}.${randomUUID()}.tmp`);
+    let temporaryPath = null;
+    let handle = null;
+    try {
+        handle = await open(candidate, "wx", 0o600);
+        temporaryPath = candidate;
+        await handle.writeFile(body, { encoding: "utf8" });
+        await handle.chmod(0o600);
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await rename(candidate, path);
+        temporaryPath = null;
+    }
+    catch (primaryFailure) {
+        const cleanupFailures = [];
+        if (handle !== null) {
+            try {
+                await handle.close();
+            }
+            catch (error) {
+                cleanupFailures.push(error instanceof Error ? error : new CleanupRejectionError(error));
+            }
+        }
+        if (temporaryPath !== null) {
+            try {
+                await unlink(temporaryPath);
+            }
+            catch (error) {
+                if (!(error instanceof Error && errorCode(error) === "ENOENT")) {
+                    cleanupFailures.push(error);
+                }
+            }
+        }
+        if (cleanupFailures.length > 0) {
+            throw new ClaudeCredentialCleanupError(path, primaryFailure, cleanupFailures);
+        }
+        throw primaryFailure;
+    }
+}

package/dist/providers/claude/auth-json.d.ts

@@ -0,0 +1,2 @@
+import type { ClaudeCredentials } from "./credentials";
+export declare function mergeOpencodeAuthJson(existing: unknown, credentials: ClaudeCredentials): string;

package/dist/providers/claude/auth-json.js

@@ -0,0 +1,14 @@
+export function mergeOpencodeAuthJson(existing, credentials) {
+    const root = typeof existing === "object" && existing !== null && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    return `${JSON.stringify({
+        ...root,
+        anthropic: {
+            type: "oauth",
+            access: credentials.accessToken,
+            refresh: credentials.refreshToken,
+            expires: credentials.expiresAtMs,
+        },
+    }, null, 2)}\n`;
+}

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

@@ -0,0 +1,24 @@
+import type { Clock } from "../../core/clock";
+import type { HttpTransport } from "../../core/http";
+import type { CredentialRefreshPolicy } from "../../core/options";
+import { type ClaudeCredentials } from "./credentials";
+export type ClaudeAuthLookup = {
+    readonly readKeychain?: (service: string, signal: AbortSignal) => Promise<string | null>;
+};
+export declare function readClaudeAccessToken(env: Readonly<Record<string, string | undefined>>, signal: AbortSignal, lookup?: ClaudeAuthLookup): Promise<string | null>;
+export declare function readClaudeCredentials(env: Readonly<Record<string, string | undefined>>, signal: AbortSignal, lookup?: ClaudeAuthLookup): Promise<ClaudeCredentials | null>;
+type ClaudeTokenOptions = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly clock: Clock;
+    readonly transport: HttpTransport;
+    readonly lookup?: ClaudeAuthLookup;
+    readonly refresh?: CredentialRefreshPolicy;
+    readonly writeBack?: (credentials: ClaudeCredentials) => Promise<void>;
+};
+export type ClaudeTokenManager = {
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly forceRefreshAccessToken: (signal: AbortSignal) => Promise<string | null>;
+};
+export declare function createClaudeTokenManager(options: ClaudeTokenOptions): ClaudeTokenManager;
+export declare function createClaudeTokenReader(options: ClaudeTokenOptions): (signal: AbortSignal) => Promise<string | null>;
+export {};

package/dist/providers/claude/auth.js

@@ -0,0 +1,200 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { OperationCancelledError } from "../../core/errors";
+import { claudeAccessNeedsRefresh, parseClaudeCredentials, } from "./credentials";
+import { refreshClaudeAccessTokenResult } from "./refresh";
+const execFileAsync = promisify(execFile);
+const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+function credentialsFromRaw(raw) {
+    try {
+        return parseClaudeCredentials(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+function keychainFailure(error) {
+    if (typeof error !== "object" || error === null) {
+        return new Error("Failed to read Claude Code credentials from macOS Keychain.", {
+            cause: error,
+        });
+    }
+    const status = "status" in error ? error.status : undefined;
+    const code = "code" in error ? error.code : undefined;
+    const killed = "killed" in error ? error.killed : undefined;
+    if (killed === true || code === "ETIMEDOUT") {
+        return new Error("Claude Code Keychain read timed out.", { cause: error });
+    }
+    if (status === 36) {
+        return new Error("macOS Keychain is locked.", { cause: error });
+    }
+    if (status === 128) {
+        return new Error("macOS Keychain access was denied.", { cause: error });
+    }
+    return status === 44
+        ? null
+        : new Error("Failed to read Claude Code credentials.", { cause: error });
+}
+async function defaultReadKeychain(service, signal) {
+    if (process.platform !== "darwin") {
+        return null;
+    }
+    try {
+        const result = await execFileAsync("security", ["find-generic-password", "-s", service, "-w"], {
+            timeout: 2_000,
+            signal,
+        });
+        const text = result.stdout.trim();
+        return text.length > 0 ? text : null;
+    }
+    catch (error) {
+        const failure = keychainFailure(error);
+        if (failure !== null) {
+            throw failure;
+        }
+        return null;
+    }
+}
+export async function readClaudeAccessToken(env, signal, lookup = {}) {
+    const credentials = await readClaudeCredentials(env, signal, lookup);
+    return credentials?.accessToken ?? null;
+}
+export async function readClaudeCredentials(env, signal, lookup = {}) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("claude-read-credentials");
+    }
+    const readKeychain = lookup.readKeychain ?? defaultReadKeychain;
+    const keychainRaw = await readKeychain(CLAUDE_KEYCHAIN_SERVICE, signal);
+    if (signal.aborted) {
+        throw new OperationCancelledError("claude-read-credentials");
+    }
+    if (keychainRaw !== null) {
+        const fromKeychain = credentialsFromRaw(keychainRaw);
+        if (fromKeychain !== null) {
+            return fromKeychain;
+        }
+    }
+    const configDir = env["CLAUDE_CONFIG_DIR"] ?? join(homedir(), ".claude");
+    const credentialPath = join(configDir, ".credentials.json");
+    try {
+        const text = await readFile(credentialPath, "utf8");
+        if (signal.aborted) {
+            throw new OperationCancelledError("claude-read-credentials");
+        }
+        return parseClaudeCredentials(JSON.parse(text));
+    }
+    catch (error) {
+        if (error instanceof OperationCancelledError) {
+            throw error;
+        }
+        return null;
+    }
+}
+const DefaultRefreshPolicy = { mode: "auto", leadMs: 60_000 };
+export function createClaudeTokenManager(options) {
+    const policy = options.refresh ?? DefaultRefreshPolicy;
+    let cached = null;
+    let lastStored = null;
+    let refreshing = null;
+    let refreshRetryAtMs = 0;
+    let consecutiveRefreshFailures = 0;
+    const persist = async (credentials) => {
+        cached = credentials;
+        if (options.writeBack !== undefined) {
+            await options.writeBack(credentials);
+        }
+    };
+    const readSource = async (signal) => {
+        const latest = await readClaudeCredentials(options.env, signal, options.lookup ?? {});
+        if (latest !== null &&
+            (lastStored === null ||
+                latest.accessToken !== lastStored.accessToken ||
+                latest.refreshToken !== lastStored.refreshToken ||
+                latest.expiresAtMs !== lastStored.expiresAtMs)) {
+            lastStored = latest;
+            cached = latest;
+        }
+        return cached;
+    };
+    const refresh = async (credentials, signal) => {
+        if (credentials.refreshToken === null) {
+            return credentials.accessToken;
+        }
+        if (options.clock.nowMs() < refreshRetryAtMs) {
+            return null;
+        }
+        if (refreshing !== null) {
+            return refreshing;
+        }
+        const operation = (async () => {
+            const result = await refreshClaudeAccessTokenResult({
+                transport: options.transport,
+                clock: options.clock,
+                refreshToken: credentials.refreshToken ?? "",
+                signal,
+            });
+            if (!result.ok) {
+                if (result.kind === "transient") {
+                    consecutiveRefreshFailures += 1;
+                    const scheduled = Math.min(60_000, 15_000 * 2 ** Math.max(0, consecutiveRefreshFailures - 1));
+                    refreshRetryAtMs =
+                        options.clock.nowMs() + Math.min(60_000, result.retryAfterMs ?? scheduled);
+                }
+                else {
+                    consecutiveRefreshFailures = 0;
+                    refreshRetryAtMs = 0;
+                }
+                return null;
+            }
+            const refreshed = result.credentials;
+            consecutiveRefreshFailures = 0;
+            refreshRetryAtMs = 0;
+            await persist(refreshed);
+            return refreshed.accessToken;
+        })();
+        refreshing = operation;
+        try {
+            return await operation;
+        }
+        finally {
+            if (refreshing === operation) {
+                refreshing = null;
+            }
+        }
+    };
+    const readAccessToken = async (signal) => {
+        const source = await readSource(signal);
+        if (source === null) {
+            return null;
+        }
+        if (policy.mode === "never" ||
+            source.refreshToken === null ||
+            !claudeAccessNeedsRefresh(source, options.clock.nowMs(), policy.leadMs)) {
+            return source.accessToken;
+        }
+        const refreshedToken = await refresh(source, signal);
+        if (refreshedToken === null) {
+            return source.accessToken;
+        }
+        return refreshedToken;
+    };
+    const forceRefreshAccessToken = async (signal) => {
+        const previous = cached?.accessToken ?? null;
+        const source = await readSource(signal);
+        if (source === null) {
+            return null;
+        }
+        if (policy.mode === "never") {
+            return source.accessToken === previous ? null : source.accessToken;
+        }
+        return refresh(source, signal);
+    };
+    return { readAccessToken, forceRefreshAccessToken };
+}
+export function createClaudeTokenReader(options) {
+    const manager = createClaudeTokenManager(options);
+    return manager.readAccessToken;
+}

package/dist/providers/claude/cli-version.d.ts

@@ -0,0 +1,10 @@
+import type { HttpTransport } from "../../core/http";
+export type ClaudeVersionResolver = (signal: AbortSignal) => Promise<string | null>;
+export type ClaudeVersionResolverOptions = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly transport: HttpTransport;
+    readonly readInstalledVersion?: () => string | null;
+};
+export declare function parseClaudeCliVersion(stdout: string): string | null;
+export declare function readInstalledClaudeVersion(env: Readonly<Record<string, string | undefined>>): string | null;
+export declare function createClaudeVersionResolver(options: ClaudeVersionResolverOptions): ClaudeVersionResolver;

package/dist/providers/claude/cli-version.js

@@ -0,0 +1,36 @@
+import { spawnSync } from "node:child_process";
+import { createPackageVersionResolver } from "../../http/package-version";
+const CLAUDE_CODE_PACKAGE = "@anthropic-ai/claude-code";
+export function parseClaudeCliVersion(stdout) {
+    const match = /(\d+\.\d+\.\d+)/.exec(stdout);
+    return match?.[1] ?? null;
+}
+export function readInstalledClaudeVersion(env) {
+    const result = spawnSync("claude", ["--version"], {
+        encoding: "utf8",
+        timeout: 3_000,
+        env: { ...env },
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        return null;
+    }
+    return parseClaudeCliVersion(result.stdout);
+}
+export function createClaudeVersionResolver(options) {
+    const readInstalled = options.readInstalledVersion ?? (() => readInstalledClaudeVersion(options.env));
+    const readPublished = createPackageVersionResolver({
+        transport: options.transport,
+        packageName: CLAUDE_CODE_PACKAGE,
+    });
+    let local;
+    return async (signal) => {
+        if (local === undefined) {
+            const override = options.env["ANTHROPIC_CLI_VERSION"]?.trim();
+            local =
+                override !== undefined && override.length > 0
+                    ? parseClaudeCliVersion(override)
+                    : readInstalled();
+        }
+        return local ?? readPublished(signal);
+    };
+}

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

@@ -0,0 +1,5 @@
+export declare function claudeExcludedBetas(modelId: string): ReadonlySet<string>;
+export declare function excludeClaudeBeta(modelId: string, beta: string): void;
+export declare function nextClaudeBetaToExclude(modelId: string): string | null;
+export declare function isClaudeLongContextError(body: string): boolean;
+export declare function claudeModelBetas(modelId: string): readonly string[];

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

@@ -0,0 +1,54 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { CLAUDE_BASE_BETAS, CLAUDE_LONG_CONTEXT_BETAS, claudeModelOverride } from "./compat-config";
+const excludedBetas = new Map();
+let lastFlags = process.env["ANTHROPIC_BETA_FLAGS"];
+let lastModelId;
+function requiredBetas() {
+    return (process.env["ANTHROPIC_BETA_FLAGS"] ?? CLAUDE_BASE_BETAS.join(","))
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+export function claudeExcludedBetas(modelId) {
+    const flags = process.env["ANTHROPIC_BETA_FLAGS"];
+    if (flags !== lastFlags || (lastModelId !== undefined && lastModelId !== modelId)) {
+        excludedBetas.clear();
+    }
+    lastFlags = flags;
+    lastModelId = modelId;
+    return excludedBetas.get(modelId) ?? new Set();
+}
+export function excludeClaudeBeta(modelId, beta) {
+    const excluded = excludedBetas.get(modelId) ?? new Set();
+    excluded.add(beta);
+    excludedBetas.set(modelId, excluded);
+}
+export function nextClaudeBetaToExclude(modelId) {
+    const excluded = claudeExcludedBetas(modelId);
+    for (const beta of CLAUDE_LONG_CONTEXT_BETAS) {
+        if (!excluded.has(beta)) {
+            return beta;
+        }
+    }
+    return null;
+}
+export function isClaudeLongContextError(body) {
+    return (body.includes("Extra usage is required for long context requests") ||
+        body.includes("long context beta is not yet available") ||
+        body.includes("You're out of extra usage"));
+}
+export function claudeModelBetas(modelId) {
+    let betas = requiredBetas();
+    const override = claudeModelOverride(modelId);
+    if (override?.exclude !== undefined) {
+        betas = betas.filter((beta) => !override.exclude?.includes(beta));
+    }
+    for (const beta of override?.add ?? []) {
+        if (!betas.includes(beta)) {
+            betas.push(beta);
+        }
+    }
+    const excluded = claudeExcludedBetas(modelId);
+    return betas.filter((beta) => !excluded.has(beta));
+}

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

@@ -0,0 +1,8 @@
+export type ClaudeModelOverride = {
+    readonly exclude?: readonly string[];
+    readonly add?: readonly string[];
+    readonly disableEffort?: boolean;
+};
+export declare const CLAUDE_BASE_BETAS: readonly string[];
+export declare const CLAUDE_LONG_CONTEXT_BETAS: readonly string[];
+export declare function claudeModelOverride(modelId: string): ClaudeModelOverride | null;

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

@@ -0,0 +1,31 @@
+// Derived from griffinmartin/opencode-claude-auth@0f0ff6f12c367339130cbfd250393863ed2c8d9e.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+export const CLAUDE_BASE_BETAS = [
+    "claude-code-20250219",
+    "oauth-2025-04-20",
+    "interleaved-thinking-2025-05-14",
+    "prompt-caching-scope-2026-01-05",
+    "context-management-2025-06-27",
+    "advisor-tool-2026-03-01",
+    "thinking-token-count-2026-05-13",
+    "extended-cache-ttl-2025-04-11",
+];
+export const CLAUDE_LONG_CONTEXT_BETAS = [
+    "context-1m-2025-08-07",
+    "interleaved-thinking-2025-05-14",
+];
+const MODEL_OVERRIDES = {
+    sonnet: { exclude: ["effort-2025-11-24"] },
+    haiku: { exclude: ["effort-2025-11-24"], disableEffort: true },
+    "4-6": { add: ["effort-2025-11-24"] },
+    "4-7": { add: ["effort-2025-11-24"] },
+};
+export function claudeModelOverride(modelId) {
+    const lower = modelId.toLowerCase();
+    for (const [pattern, override] of Object.entries(MODEL_OVERRIDES)) {
+        if (lower.includes(pattern)) {
+            return override;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,12 @@
+export type ClaudeCompatibilityHeaderOptions = {
+    readonly accessToken: string;
+    readonly modelId: string;
+    readonly version: string;
+    readonly incoming?: Headers;
+};
+export declare function createClaudeCompatibilityHeaders(options: ClaudeCompatibilityHeaderOptions): Headers;
+export declare function createClaudeCompatibilityFetch(options: {
+    readonly readVersion: (signal: AbortSignal) => Promise<string | null>;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly forceRefreshAccessToken: (signal: AbortSignal) => Promise<string | null>;
+}): (input: string | URL | Request, init?: RequestInit) => Promise<Response>;