@nvae/llmswitch 0.2.0

package/dist/adapters/index.js

@@ -0,0 +1,33 @@
+import { applyClaudeProfile, deactivateClaudeProfile } from "./claude.js";
+import { applyCodexProfile, deactivateCodexProfile } from "./codex.js";
+import { applyOpenCodeProfile, deactivateOpenCodeProfile } from "./opencode.js";
+import { assertCompatible } from "../formats/compatibility.js";
+import { clearActiveProfile } from "../store/profiles.js";
+export async function applyProfile(tool, profile) {
+    assertCompatible(tool, profile.apiFormat);
+    switch (tool) {
+        case "claude":
+            return applyClaudeProfile(profile);
+        case "codex":
+            return applyCodexProfile(profile);
+        case "opencode":
+            return applyOpenCodeProfile(profile);
+    }
+}
+/** Disable the currently applied provider and clear tool-side managed config. */
+export async function deactivateProfile(tool, profileName) {
+    let result;
+    switch (tool) {
+        case "claude":
+            result = await deactivateClaudeProfile();
+            break;
+        case "codex":
+            result = await deactivateCodexProfile(profileName);
+            break;
+        case "opencode":
+            result = deactivateOpenCodeProfile(profileName);
+            break;
+    }
+    clearActiveProfile(tool);
+    return result;
+}

package/dist/adapters/merge.js

@@ -0,0 +1,21 @@
+export function deepMerge(base, patch) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            continue;
+        const prev = out[key];
+        if (isPlainObject(prev) &&
+            isPlainObject(value)) {
+            out[key] = deepMerge(prev, value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value));
+}

package/dist/adapters/opencode.js

@@ -0,0 +1,162 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { assertCompatible } from "../formats/compatibility.js";
+import { normalizeBaseUrlForFormat } from "../utils/base-url.js";
+import { atomicWriteFile, backupFile, ensureDir } from "../utils/fs.js";
+import { applyProxyToEnvRecord, clearProxyEnvKeys } from "../utils/proxy.js";
+import { getBackupsDir, getOpenCodeAuthPath, getOpenCodeConfigDir, getOpenCodeConfigPath, } from "../utils/paths.js";
+import { setActiveProfile } from "../store/profiles.js";
+function providerId(name) {
+    return `llms-${name}`.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function npmForFormat(format) {
+    switch (format) {
+        case "anthropic":
+            return "@ai-sdk/anthropic";
+        case "openai-responses":
+            return "@ai-sdk/openai";
+        case "openai-chat":
+            return "@ai-sdk/openai-compatible";
+    }
+}
+export function readOpenCodeConfig(path = getOpenCodeConfigPath()) {
+    if (!existsSync(path)) {
+        return { $schema: "https://opencode.ai/config.json" };
+    }
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+export function readOpenCodeAuth(path = getOpenCodeAuthPath()) {
+    if (!existsSync(path))
+        return {};
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+export function buildOpenCodeProviderBlock(profile) {
+    const models = {};
+    for (const id of profile.models.list) {
+        models[id] = { name: id };
+    }
+    if (!models[profile.models.default]) {
+        models[profile.models.default] = { name: profile.models.default };
+    }
+    const options = {
+        baseURL: normalizeBaseUrlForFormat(profile.apiFormat, profile.baseUrl),
+    };
+    if (profile.apiKey) {
+        options.apiKey = profile.apiKey;
+    }
+    if (profile.headers && Object.keys(profile.headers).length > 0) {
+        options.headers = { ...profile.headers };
+    }
+    return {
+        npm: npmForFormat(profile.apiFormat),
+        name: profile.displayName || profile.name,
+        options,
+        models,
+    };
+}
+export function buildOpenCodeConfig(existing, profile) {
+    assertCompatible("opencode", profile.apiFormat);
+    const id = providerId(profile.name);
+    const providers = {
+        ...(existing.provider || {}),
+    };
+    providers[id] = buildOpenCodeProviderBlock(profile);
+    // Optional top-level env for proxy (OpenCode may pass through)
+    const env = {
+        ...(existing.env || {}),
+    };
+    clearProxyEnvKeys(env);
+    applyProxyToEnvRecord(env, profile.proxy);
+    const next = {
+        ...existing,
+        $schema: existing.$schema || "https://opencode.ai/config.json",
+        provider: providers,
+        model: `${id}/${profile.models.default}`,
+    };
+    if (Object.keys(env).length > 0) {
+        next.env = env;
+    }
+    else {
+        delete next.env;
+    }
+    return next;
+}
+export function buildOpenCodeAuth(existing, profile) {
+    const id = providerId(profile.name);
+    const next = { ...existing };
+    if (profile.apiKey) {
+        next[id] = {
+            type: "api",
+            key: profile.apiKey,
+        };
+    }
+    return next;
+}
+export function applyOpenCodeProfile(profile) {
+    assertCompatible("opencode", profile.apiFormat);
+    ensureDir(getOpenCodeConfigDir());
+    ensureDir(dirname(getOpenCodeAuthPath()));
+    const configPath = getOpenCodeConfigPath();
+    const authPath = getOpenCodeAuthPath();
+    const existing = readOpenCodeConfig(configPath);
+    const backupPath = backupFile(configPath, getBackupsDir("opencode"), "opencode");
+    backupFile(authPath, getBackupsDir("opencode"), "auth");
+    const nextConfig = buildOpenCodeConfig(existing, profile);
+    atomicWriteFile(configPath, JSON.stringify(nextConfig, null, 2) + "\n");
+    const nextAuth = buildOpenCodeAuth(readOpenCodeAuth(authPath), profile);
+    atomicWriteFile(authPath, JSON.stringify(nextAuth, null, 2) + "\n");
+    setActiveProfile("opencode", profile.name);
+    return {
+        tool: "opencode",
+        profile: profile.name,
+        configPath,
+        backupPath,
+        restartHint: "请重新启动 OpenCode 会话以使配置与代理生效。",
+    };
+}
+export function deactivateOpenCodeProfile(profileName) {
+    ensureDir(getOpenCodeConfigDir());
+    ensureDir(dirname(getOpenCodeAuthPath()));
+    const configPath = getOpenCodeConfigPath();
+    const authPath = getOpenCodeAuthPath();
+    const existing = readOpenCodeConfig(configPath);
+    const backupPath = backupFile(configPath, getBackupsDir("opencode"), "opencode");
+    backupFile(authPath, getBackupsDir("opencode"), "auth");
+    const providers = {
+        ...(existing.provider || {}),
+    };
+    const id = profileName ? providerId(profileName) : null;
+    if (id)
+        delete providers[id];
+    const env = {
+        ...(existing.env || {}),
+    };
+    clearProxyEnvKeys(env);
+    const next = {
+        ...existing,
+        provider: providers,
+    };
+    if (id && typeof existing.model === "string" && existing.model.startsWith(`${id}/`)) {
+        delete next.model;
+    }
+    if (Object.keys(env).length > 0)
+        next.env = env;
+    else
+        delete next.env;
+    atomicWriteFile(configPath, JSON.stringify(next, null, 2) + "\n");
+    if (id) {
+        const auth = readOpenCodeAuth(authPath);
+        if (auth[id]) {
+            const nextAuth = { ...auth };
+            delete nextAuth[id];
+            atomicWriteFile(authPath, JSON.stringify(nextAuth, null, 2) + "\n");
+        }
+    }
+    return {
+        tool: "opencode",
+        profile: profileName || "",
+        configPath,
+        backupPath,
+        restartHint: "已禁用供应商。请重新启动 OpenCode 会话使变更生效。",
+    };
+}

package/dist/bridge/anthropic-translate-request.js

@@ -0,0 +1,226 @@
+/**
+ * Translate Anthropic Messages API requests → OpenAI Chat Completions.
+ */
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function extractTextBlocks(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        const row = asRecord(part);
+        if (!row)
+            continue;
+        if (row.type === "text" && typeof row.text === "string") {
+            parts.push(row.text);
+        }
+        else if (typeof row.text === "string") {
+            parts.push(row.text);
+        }
+    }
+    return parts.join("");
+}
+function systemToMessage(system) {
+    if (typeof system === "string" && system.trim()) {
+        return { role: "system", content: system };
+    }
+    if (Array.isArray(system)) {
+        const text = extractTextBlocks(system);
+        if (text.trim())
+            return { role: "system", content: text };
+    }
+    return null;
+}
+function mapAssistantContent(content) {
+    if (typeof content === "string") {
+        return { role: "assistant", content };
+    }
+    if (!Array.isArray(content)) {
+        return { role: "assistant", content: "" };
+    }
+    const textParts = [];
+    const toolCalls = [];
+    for (const part of content) {
+        const row = asRecord(part);
+        if (!row)
+            continue;
+        if (row.type === "text" && typeof row.text === "string") {
+            textParts.push(row.text);
+            continue;
+        }
+        if (row.type === "tool_use") {
+            const id = String(row.id || `tool_${toolCalls.length}`);
+            const name = String(row.name || "tool");
+            let args = "{}";
+            try {
+                args = JSON.stringify(row.input ?? {});
+            }
+            catch {
+                args = "{}";
+            }
+            toolCalls.push({
+                id,
+                type: "function",
+                function: { name, arguments: args },
+            });
+        }
+    }
+    const msg = {
+        role: "assistant",
+        content: textParts.length ? textParts.join("") : toolCalls.length ? null : "",
+    };
+    if (toolCalls.length)
+        msg.tool_calls = toolCalls;
+    return msg;
+}
+function mapUserContent(content) {
+    if (typeof content === "string") {
+        return [{ role: "user", content }];
+    }
+    if (!Array.isArray(content)) {
+        return [{ role: "user", content: "" }];
+    }
+    const textParts = [];
+    const toolResults = [];
+    for (const part of content) {
+        const row = asRecord(part);
+        if (!row)
+            continue;
+        if (row.type === "text" && typeof row.text === "string") {
+            textParts.push(row.text);
+            continue;
+        }
+        if (row.type === "tool_result") {
+            const toolCallId = String(row.tool_use_id || row.id || "");
+            let resultContent = "";
+            if (typeof row.content === "string")
+                resultContent = row.content;
+            else if (Array.isArray(row.content)) {
+                resultContent = extractTextBlocks(row.content);
+            }
+            else if (row.content != null) {
+                try {
+                    resultContent = JSON.stringify(row.content);
+                }
+                catch {
+                    resultContent = String(row.content);
+                }
+            }
+            toolResults.push({
+                role: "tool",
+                tool_call_id: toolCallId,
+                content: resultContent,
+            });
+        }
+    }
+    const out = [];
+    if (textParts.length) {
+        out.push({ role: "user", content: textParts.join("") });
+    }
+    out.push(...toolResults);
+    if (!out.length)
+        out.push({ role: "user", content: "" });
+    return out;
+}
+export function anthropicMessagesToChatMessages(body) {
+    const messages = [];
+    const system = systemToMessage(body.system);
+    if (system)
+        messages.push(system);
+    const rawMessages = Array.isArray(body.messages) ? body.messages : [];
+    for (const item of rawMessages) {
+        const row = asRecord(item);
+        if (!row)
+            continue;
+        const role = row.role;
+        if (role === "assistant") {
+            messages.push(mapAssistantContent(row.content));
+            continue;
+        }
+        if (role === "user") {
+            messages.push(...mapUserContent(row.content));
+            continue;
+        }
+    }
+    return messages;
+}
+export function mapAnthropicTools(tools) {
+    if (!Array.isArray(tools) || tools.length === 0)
+        return undefined;
+    const out = [];
+    for (const tool of tools) {
+        const row = asRecord(tool);
+        if (!row)
+            continue;
+        const name = String(row.name || "").trim();
+        if (!name)
+            continue;
+        out.push({
+            type: "function",
+            function: {
+                name,
+                description: typeof row.description === "string" ? row.description : undefined,
+                parameters: row.input_schema ?? row.parameters ?? { type: "object", properties: {} },
+            },
+        });
+    }
+    return out.length ? out : undefined;
+}
+export function mapAnthropicToolChoice(toolChoice) {
+    if (toolChoice == null)
+        return undefined;
+    if (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required") {
+        return toolChoice;
+    }
+    const obj = asRecord(toolChoice);
+    if (!obj)
+        return "auto";
+    if (obj.type === "auto")
+        return "auto";
+    if (obj.type === "any")
+        return "required";
+    if (obj.type === "none")
+        return "none";
+    if (obj.type === "tool") {
+        const name = String(obj.name || "");
+        if (!name)
+            return "auto";
+        return { type: "function", function: { name } };
+    }
+    return "auto";
+}
+export function anthropicToChatRequest(body) {
+    const stream = Boolean(body.stream);
+    const req = {
+        model: String(body.model || ""),
+        messages: anthropicMessagesToChatMessages(body),
+        stream,
+    };
+    if (stream) {
+        req.stream_options = { include_usage: true };
+    }
+    const tools = mapAnthropicTools(body.tools);
+    if (tools)
+        req.tools = tools;
+    if (body.tool_choice !== undefined) {
+        req.tool_choice = mapAnthropicToolChoice(body.tool_choice);
+    }
+    if (typeof body.temperature === "number")
+        req.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        req.top_p = body.top_p;
+    if (typeof body.max_tokens === "number") {
+        req.max_tokens = body.max_tokens;
+        req.max_completion_tokens = body.max_tokens;
+    }
+    if (typeof body.stop_sequences !== "undefined") {
+        req.stop = body.stop_sequences;
+    }
+    return req;
+}

package/dist/bridge/anthropic-translate-response.js

@@ -0,0 +1,265 @@
+/**
+ * Translate Chat Completions (stream/non-stream) → Anthropic Messages API.
+ */
+import { parseChatSseLine } from "./translate-response.js";
+function newId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function numberOr(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function parseToolArguments(raw) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw !== "string" || !raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+export function mapFinishReason(reason) {
+    if (reason === "tool_calls" || reason === "function_call")
+        return "tool_use";
+    if (reason === "length")
+        return "max_tokens";
+    if (reason === "stop" || reason === "end_turn")
+        return "end_turn";
+    return reason == null ? null : "end_turn";
+}
+export function chatCompletionToAnthropicMessage(chat, fallbackModel) {
+    const choice = Array.isArray(chat.choices)
+        ? asRecord(chat.choices[0])
+        : null;
+    const message = choice ? asRecord(choice.message) : null;
+    const content = [];
+    const text = typeof message?.content === "string"
+        ? message.content
+        : message?.content == null
+            ? ""
+            : String(message.content);
+    if (text) {
+        content.push({ type: "text", text });
+    }
+    const toolCalls = Array.isArray(message?.tool_calls)
+        ? message.tool_calls
+        : [];
+    for (const call of toolCalls) {
+        const row = asRecord(call);
+        if (!row)
+            continue;
+        const fn = asRecord(row.function);
+        content.push({
+            type: "tool_use",
+            id: String(row.id || newId("toolu")),
+            name: String(fn?.name || "tool"),
+            input: parseToolArguments(fn?.arguments),
+        });
+    }
+    if (!content.length) {
+        content.push({ type: "text", text: "" });
+    }
+    const usage = asRecord(chat.usage);
+    const stopReason = mapFinishReason(choice?.finish_reason) ||
+        (toolCalls.length ? "tool_use" : "end_turn");
+    return {
+        id: typeof chat.id === "string" ? `msg_${chat.id}` : newId("msg"),
+        type: "message",
+        role: "assistant",
+        model: String(chat.model || fallbackModel || ""),
+        content,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: numberOr(usage?.prompt_tokens) ?? numberOr(usage?.input_tokens) ?? 0,
+            output_tokens: numberOr(usage?.completion_tokens) ??
+                numberOr(usage?.output_tokens) ??
+                0,
+        },
+    };
+}
+export function createAnthropicStreamState(model, messageId) {
+    return {
+        messageId: messageId || newId("msg"),
+        model,
+        textIndex: null,
+        textStarted: false,
+        fullText: "",
+        toolCalls: new Map(),
+        nextBlockIndex: 0,
+        started: false,
+        stopped: false,
+        stopReason: null,
+    };
+}
+function sseData(payload) {
+    return `event: ${String(payload.type)}\ndata: ${JSON.stringify(payload)}\n\n`;
+}
+function ensureMessageStart(state, out) {
+    if (state.started)
+        return;
+    state.started = true;
+    out.push(sseData({
+        type: "message_start",
+        message: {
+            id: state.messageId,
+            type: "message",
+            role: "assistant",
+            model: state.model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+        },
+    }));
+}
+function ensureTextBlock(state, out) {
+    if (state.textStarted)
+        return;
+    state.textStarted = true;
+    state.textIndex = state.nextBlockIndex++;
+    out.push(sseData({
+        type: "content_block_start",
+        index: state.textIndex,
+        content_block: { type: "text", text: "" },
+    }));
+}
+function closeTextBlock(state, out) {
+    if (!state.textStarted || state.textIndex == null)
+        return;
+    out.push(sseData({
+        type: "content_block_stop",
+        index: state.textIndex,
+    }));
+    state.textStarted = false;
+    state.textIndex = null;
+}
+export function chatChunkToAnthropicEvents(chunk, state) {
+    const out = [];
+    ensureMessageStart(state, out);
+    if (chunk.model && typeof chunk.model === "string") {
+        state.model = chunk.model;
+    }
+    const usage = asRecord(chunk.usage);
+    if (usage) {
+        state.usage = {
+            input_tokens: numberOr(usage.prompt_tokens) ?? numberOr(usage.input_tokens) ?? 0,
+            output_tokens: numberOr(usage.completion_tokens) ??
+                numberOr(usage.output_tokens) ??
+                0,
+        };
+    }
+    const choice = Array.isArray(chunk.choices)
+        ? asRecord(chunk.choices[0])
+        : null;
+    if (!choice)
+        return out;
+    const finish = mapFinishReason(choice.finish_reason);
+    if (finish)
+        state.stopReason = finish;
+    const delta = asRecord(choice.delta) || asRecord(choice.message);
+    if (!delta)
+        return out;
+    if (typeof delta.content === "string" && delta.content.length) {
+        ensureTextBlock(state, out);
+        state.fullText += delta.content;
+        out.push(sseData({
+            type: "content_block_delta",
+            index: state.textIndex,
+            delta: { type: "text_delta", text: delta.content },
+        }));
+    }
+    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+    for (const call of toolCalls) {
+        const row = asRecord(call);
+        if (!row)
+            continue;
+        const index = typeof row.index === "number" ? row.index : state.toolCalls.size;
+        let entry = state.toolCalls.get(index);
+        const fn = asRecord(row.function);
+        if (!entry) {
+            // Close text before tool blocks when tools start
+            closeTextBlock(state, out);
+            entry = {
+                blockIndex: state.nextBlockIndex++,
+                id: String(row.id || newId("toolu")),
+                name: String(fn?.name || ""),
+                arguments: "",
+                started: false,
+            };
+            state.toolCalls.set(index, entry);
+        }
+        if (row.id)
+            entry.id = String(row.id);
+        if (fn?.name)
+            entry.name = String(fn.name);
+        if (typeof fn?.arguments === "string") {
+            entry.arguments += fn.arguments;
+        }
+        if (!entry.started && entry.name) {
+            entry.started = true;
+            out.push(sseData({
+                type: "content_block_start",
+                index: entry.blockIndex,
+                content_block: {
+                    type: "tool_use",
+                    id: entry.id,
+                    name: entry.name,
+                    input: {},
+                },
+            }));
+        }
+        if (entry.started && typeof fn?.arguments === "string" && fn.arguments) {
+            out.push(sseData({
+                type: "content_block_delta",
+                index: entry.blockIndex,
+                delta: {
+                    type: "input_json_delta",
+                    partial_json: fn.arguments,
+                },
+            }));
+        }
+    }
+    return out;
+}
+export function forceCompleteAnthropicStream(state) {
+    if (state.stopped)
+        return [];
+    state.stopped = true;
+    const out = [];
+    ensureMessageStart(state, out);
+    closeTextBlock(state, out);
+    for (const entry of state.toolCalls.values()) {
+        if (entry.started) {
+            out.push(sseData({
+                type: "content_block_stop",
+                index: entry.blockIndex,
+            }));
+        }
+    }
+    const stopReason = state.stopReason ||
+        (state.toolCalls.size > 0 ? "tool_use" : "end_turn");
+    out.push(sseData({
+        type: "message_delta",
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        usage: {
+            output_tokens: state.usage?.output_tokens ?? 0,
+        },
+    }));
+    out.push(sseData({ type: "message_stop" }));
+    return out;
+}
+export { parseChatSseLine };