@lightharu/krouter 1.8.0

package/out-server/main/proxy/clientConfig.js

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureProxyClients = configureProxyClients;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
+const modelCatalog_1 = require("./modelCatalog");
+function dedupeClientModels(models) {
+    const modelMap = new Map();
+    for (const model of models) {
+        const id = model.id?.trim();
+        if (!id)
+            continue;
+        const key = (0, modelCatalog_1.normalizeKiroModelIdForCompare)(id);
+        if (!modelMap.has(key)) {
+            modelMap.set(key, { ...model, id });
+            continue;
+        }
+        const existing = modelMap.get(key);
+        modelMap.set(key, {
+            ...model,
+            ...existing,
+            id: existing.id,
+            name: existing.name || model.name,
+            inputTypes: existing.inputTypes?.length ? existing.inputTypes : model.inputTypes,
+            maxInputTokens: existing.maxInputTokens || model.maxInputTokens,
+            maxOutputTokens: existing.maxOutputTokens || model.maxOutputTokens
+        });
+    }
+    return Array.from(modelMap.values());
+}
+function buildOpenClawModels(context) {
+    return dedupeClientModels(context.models).filter(model => !(0, modelCatalog_1.isAutoKiroModelId)(model.id));
+}
+function openClawModelsToClientModels(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!isRecord(item))
+            return null;
+        const id = typeof item.id === 'string' ? item.id.trim() : '';
+        if (!id)
+            return null;
+        const input = Array.isArray(item.input)
+            ? item.input.filter((entry) => typeof entry === 'string').map(entry => entry.toUpperCase())
+            : undefined;
+        return {
+            id,
+            name: typeof item.name === 'string' ? item.name : id,
+            inputTypes: input,
+            maxInputTokens: typeof item.contextWindow === 'number'
+                ? item.contextWindow
+                : typeof item.contextTokens === 'number' ? item.contextTokens : undefined,
+            maxOutputTokens: typeof item.maxTokens === 'number' ? item.maxTokens : undefined
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+function pickOpenClawPrimaryModel(context, models) {
+    const selected = context.modelId.trim();
+    if (selected && !(0, modelCatalog_1.isAutoKiroModelId)(selected)) {
+        const match = models.find(model => (0, modelCatalog_1.normalizeKiroModelIdForCompare)(model.id) === (0, modelCatalog_1.normalizeKiroModelIdForCompare)(selected));
+        if (match)
+            return match.id;
+    }
+    for (const preferredId of modelCatalog_1.KIRO_PROXY_PREFERRED_MODEL_IDS) {
+        const match = models.find(model => (0, modelCatalog_1.normalizeKiroModelIdForCompare)(model.id) === (0, modelCatalog_1.normalizeKiroModelIdForCompare)(preferredId));
+        if (match)
+            return match.id;
+    }
+    return models[0]?.id || (selected && !(0, modelCatalog_1.isAutoKiroModelId)(selected) ? selected : 'claude-sonnet-4.5');
+}
+function buildOpenClawFallbackRefs(providerId, primaryModelId, models) {
+    const byNormalizedId = new Map();
+    for (const model of models) {
+        const id = model.id?.trim();
+        if (!id || (0, modelCatalog_1.isAutoKiroModelId)(id))
+            continue;
+        byNormalizedId.set((0, modelCatalog_1.normalizeKiroModelIdForCompare)(id), id);
+    }
+    const preferredFallbackOrder = [
+        'claude-opus-4.8',
+        'claude-opus-4.7',
+        'claude-opus-4.5',
+        'claude-sonnet-4.5',
+        'claude-sonnet-4',
+        'claude-haiku-4.5',
+        ...modelCatalog_1.KIRO_PROXY_PREFERRED_MODEL_IDS
+    ];
+    const primaryKey = (0, modelCatalog_1.normalizeKiroModelIdForCompare)(primaryModelId);
+    const refs = [];
+    const seen = new Set();
+    for (const modelId of preferredFallbackOrder) {
+        const match = byNormalizedId.get((0, modelCatalog_1.normalizeKiroModelIdForCompare)(modelId));
+        if (!match)
+            continue;
+        const key = (0, modelCatalog_1.normalizeKiroModelIdForCompare)(match);
+        if (key === primaryKey || seen.has(key))
+            continue;
+        seen.add(key);
+        refs.push(`${providerId}/${match}`);
+    }
+    return refs;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(content, path) {
+    const parsed = JSON.parse(path.endsWith('.jsonc') ? stripJsonc(content) : content);
+    if (!isRecord(parsed)) {
+        throw new Error(`${path} root must be a JSON object`);
+    }
+    return parsed;
+}
+function stripJsonc(content) {
+    let output = '';
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+    for (let index = 0; index < content.length; index++) {
+        const current = content[index];
+        const next = content[index + 1];
+        if (inString) {
+            output += current;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (current === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (current === quote) {
+                inString = false;
+                quote = '';
+            }
+            continue;
+        }
+        if (current === '"' || current === "'") {
+            inString = true;
+            quote = current;
+            output += current;
+            continue;
+        }
+        if (current === '/' && next === '/') {
+            while (index < content.length && content[index] !== '\n')
+                index++;
+            output += '\n';
+            continue;
+        }
+        if (current === '/' && next === '*') {
+            index += 2;
+            while (index < content.length && !(content[index] === '*' && content[index + 1] === '/'))
+                index++;
+            index++;
+            continue;
+        }
+        output += current;
+    }
+    return removeTrailingJsonCommas(output);
+}
+function removeTrailingJsonCommas(content) {
+    let output = '';
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index++) {
+        const current = content[index];
+        if (inString) {
+            output += current;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (current === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (current === '"')
+                inString = false;
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            output += current;
+            continue;
+        }
+        if (current === ',') {
+            let nextIndex = index + 1;
+            while (/\s/.test(content[nextIndex] || ''))
+                nextIndex++;
+            if (content[nextIndex] === '}' || content[nextIndex] === ']')
+                continue;
+        }
+        output += current;
+    }
+    return output;
+}
+function escapeTomlString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function outputLimit(model) {
+    if (typeof model.maxOutputTokens === 'number' && model.maxOutputTokens > 0)
+        return model.maxOutputTokens;
+    if (model.id.toLowerCase().includes('haiku'))
+        return 8192;
+    return 32000;
+}
+function contextLimit(model) {
+    if (typeof model.maxInputTokens === 'number' && model.maxInputTokens > 0)
+        return model.maxInputTokens;
+    return 200000;
+}
+function inputModalities(model) {
+    const values = new Set(['text']);
+    for (const item of model.inputTypes ?? []) {
+        const lower = item.toLowerCase();
+        if (lower.includes('image'))
+            values.add('image');
+        if (lower.includes('pdf') || lower.includes('document') || lower.includes('file'))
+            values.add('pdf');
+    }
+    return Array.from(values);
+}
+function buildProxyOrigin(input) {
+    const host = input.host === '0.0.0.0' ? '127.0.0.1' : input.host === '::' ? '::1' : input.host;
+    const urlHost = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+    return `${input.tlsEnabled ? 'https' : 'http'}://${urlHost}:${input.port}`;
+}
+async function exists(path) {
+    return (0, promises_1.access)(path, fs_1.constants.F_OK).then(() => true, () => false);
+}
+async function backupIfExists(path) {
+    if (!(await exists(path)))
+        return [];
+    const backupPath = `${path}.kiro-backup-${Date.now()}`;
+    await (0, promises_1.copyFile)(path, backupPath);
+    return [backupPath];
+}
+async function readJsonObject(path) {
+    if (!(await exists(path)))
+        return {};
+    return parseJsonObject(await (0, promises_1.readFile)(path, 'utf-8'), path);
+}
+async function writeJsonObject(path, value) {
+    await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+    const backupPaths = await backupIfExists(path);
+    await (0, promises_1.writeFile)(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+    return backupPaths;
+}
+async function writeText(path, value) {
+    await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+    const backupPaths = await backupIfExists(path);
+    await (0, promises_1.writeFile)(path, value.endsWith('\n') ? value : `${value}\n`, 'utf-8');
+    return backupPaths;
+}
+function getClaudeSettingsPath() {
+    const settingsPath = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json');
+    const legacyPath = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'claude.json');
+    return (0, fs_1.existsSync)(settingsPath) || !(0, fs_1.existsSync)(legacyPath) ? settingsPath : legacyPath;
+}
+function getOpenCodeConfigPath() {
+    const dir = (0, path_1.join)((0, os_1.homedir)(), '.config', 'opencode');
+    const candidates = [(0, path_1.join)(dir, 'opencode.jsonc'), (0, path_1.join)(dir, 'opencode.json'), (0, path_1.join)(dir, 'config.json')];
+    return candidates.find(path => (0, fs_1.existsSync)(path)) || candidates[1];
+}
+function getCodexAuthPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.codex', 'auth.json');
+}
+function getCodexConfigPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.codex', 'config.toml');
+}
+function ensureObjectField(target, key) {
+    if (!isRecord(target[key]))
+        target[key] = {};
+    return target[key];
+}
+async function configureClaudeCode(context) {
+    const path = getClaudeSettingsPath();
+    const config = await readJsonObject(path);
+    const env = ensureObjectField(config, 'env');
+    env.ANTHROPIC_BASE_URL = context.proxyOrigin;
+    env.ANTHROPIC_AUTH_TOKEN = context.apiKey;
+    env.ANTHROPIC_API_KEY = context.apiKey;
+    env.ANTHROPIC_MODEL = context.modelId;
+    // 默认模型映射：让 Claude Code 的 haiku/opus/sonnet 快捷调用都走代理支持的模型
+    const haikuModel = context.models.find(m => m.id.toLowerCase().includes('haiku'))?.id || 'claude-haiku-4.5';
+    const opusModel = context.models.find(m => m.id.toLowerCase().includes('opus'))?.id || context.modelId;
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = haikuModel;
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = opusModel;
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = context.modelId;
+    return { paths: [path], backupPaths: await writeJsonObject(path, config) };
+}
+function openCodeModelConfig(model) {
+    const modalities = inputModalities(model);
+    return {
+        name: model.name || model.id,
+        attachment: modalities.some(item => item !== 'text'),
+        reasoning: false,
+        temperature: true,
+        tool_call: true,
+        limit: {
+            context: contextLimit(model),
+            output: outputLimit(model)
+        },
+        modalities: {
+            input: modalities,
+            output: ['text']
+        }
+    };
+}
+function openClawModelConfig(model) {
+    const input = inputModalities(model);
+    return {
+        id: model.id,
+        name: model.name || model.id,
+        reasoning: false,
+        input,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: contextLimit(model),
+        contextTokens: contextLimit(model),
+        maxTokens: outputLimit(model)
+    };
+}
+async function configureOpenCode(context) {
+    const path = getOpenCodeConfigPath();
+    const config = await readJsonObject(path);
+    const provider = ensureObjectField(config, 'provider');
+    provider.kiro = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Kiro Proxy',
+        options: {
+            baseURL: context.openaiBaseUrl,
+            apiKey: context.apiKey
+        },
+        models: Object.fromEntries(context.models.map(model => [model.id, openCodeModelConfig(model)]))
+    };
+    config.$schema = typeof config.$schema === 'string' ? config.$schema : 'https://opencode.ai/config.json';
+    config.model = `kiro/${context.modelId}`;
+    if (typeof config.small_model !== 'string' || config.small_model.startsWith('kiro/')) {
+        config.small_model = `kiro/${context.modelId}`;
+    }
+    if (Array.isArray(config.enabled_providers) && !config.enabled_providers.includes('kiro')) {
+        config.enabled_providers = [...config.enabled_providers, 'kiro'];
+    }
+    return { paths: [path], backupPaths: await writeJsonObject(path, config) };
+}
+function upsertRootTomlString(content, key, value) {
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.length === 0 ? [] : content.split(/\r?\n/);
+    const sectionIndex = lines.findIndex(line => /^\s*\[/.test(line));
+    const rootEnd = sectionIndex === -1 ? lines.length : sectionIndex;
+    const nextLines = [];
+    let written = false;
+    for (let index = 0; index < lines.length; index++) {
+        if (index < rootEnd && new RegExp(`^\\s*${key}\\s*=`).test(lines[index])) {
+            if (!written) {
+                nextLines.push(`${key} = "${escapeTomlString(value)}"`);
+                written = true;
+            }
+            continue;
+        }
+        if (!written && index === rootEnd) {
+            nextLines.push(`${key} = "${escapeTomlString(value)}"`);
+            written = true;
+        }
+        nextLines.push(lines[index]);
+    }
+    if (!written)
+        nextLines.push(`${key} = "${escapeTomlString(value)}"`);
+    return nextLines.join(newline);
+}
+function removeTomlSection(content, section) {
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.length === 0 ? [] : content.split(/\r?\n/);
+    const nextLines = [];
+    let skipping = false;
+    const escapedSection = section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const line of lines) {
+        if (new RegExp(`^\\s*\\[${escapedSection}\\]\\s*$`).test(line)) {
+            skipping = true;
+            continue;
+        }
+        if (skipping && /^\s*\[/.test(line))
+            skipping = false;
+        if (!skipping)
+            nextLines.push(line);
+    }
+    return nextLines.join(newline).trimEnd();
+}
+function upsertCodexConfig(content, context) {
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const withProvider = upsertRootTomlString(upsertRootTomlString(content, 'model_provider', 'kiro'), 'model', context.modelId);
+    const withoutKiro = removeTomlSection(removeTomlSection(withProvider, 'model_providers.kiro'), 'model_providers."kiro"');
+    const separator = withoutKiro.trim() ? `${newline}${newline}` : '';
+    return `${withoutKiro.trimEnd()}${separator}[model_providers.kiro]${newline}name = "Kiro Proxy"${newline}base_url = "${escapeTomlString(context.openaiBaseUrl)}"${newline}wire_api = "responses"${newline}`;
+}
+async function configureCodex(context) {
+    const authPath = getCodexAuthPath();
+    const configPath = getCodexConfigPath();
+    const auth = await readJsonObject(authPath);
+    auth.OPENAI_API_KEY = context.apiKey;
+    const authBackups = await writeJsonObject(authPath, auth);
+    const config = (await exists(configPath)) ? await (0, promises_1.readFile)(configPath, 'utf-8') : '';
+    const configBackups = await writeText(configPath, upsertCodexConfig(config, context));
+    return { paths: [authPath, configPath], backupPaths: [...authBackups, ...configBackups] };
+}
+// Gemini CLI: ~/.gemini/.env + ~/.gemini/settings.json
+function getGeminiEnvPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.gemini', '.env');
+}
+function getGeminiSettingsPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.gemini', 'settings.json');
+}
+function buildEnvContent(entries) {
+    return Object.entries(entries).map(([k, v]) => `${k}=${v}`).join('\n') + '\n';
+}
+function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const idx = trimmed.indexOf('=');
+        if (idx > 0)
+            result[trimmed.substring(0, idx).trim()] = trimmed.substring(idx + 1).trim();
+    }
+    return result;
+}
+async function configureGemini(context) {
+    const envPath = getGeminiEnvPath();
+    const settingsPath = getGeminiSettingsPath();
+    const allPaths = [envPath, settingsPath];
+    const allBackups = [];
+    // .env
+    const existingEnv = (await exists(envPath)) ? parseEnvFile(await (0, promises_1.readFile)(envPath, 'utf-8')) : {};
+    existingEnv.GEMINI_API_KEY = context.apiKey;
+    existingEnv.GOOGLE_GEMINI_BASE_URL = `${context.proxyOrigin}/v1beta`;
+    existingEnv.GEMINI_MODEL = context.modelId;
+    allBackups.push(...await writeText(envPath, buildEnvContent(existingEnv)));
+    // settings.json
+    const settings = await readJsonObject(settingsPath);
+    const security = ensureObjectField(settings, 'security');
+    const auth = ensureObjectField(security, 'auth');
+    auth.selectedType = 'gemini-api-key';
+    allBackups.push(...await writeJsonObject(settingsPath, settings));
+    return { paths: allPaths, backupPaths: allBackups };
+}
+// Hermes: ~/.hermes/config.yaml
+function getHermesConfigPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.hermes', 'config.yaml');
+}
+async function configureHermes(context) {
+    const configPath = getHermesConfigPath();
+    const existing = (await exists(configPath)) ? await (0, promises_1.readFile)(configPath, 'utf-8') : '';
+    const newline = existing.includes('\r\n') ? '\r\n' : '\n';
+    // 构建 models dict
+    const modelsYaml = context.models.map(m => {
+        const ctx = typeof m.maxInputTokens === 'number' && m.maxInputTokens > 0 ? m.maxInputTokens : 200000;
+        return `      ${m.id}:${newline}        context_length: ${ctx}`;
+    }).join(newline);
+    const providerBlock = [
+        `  - name: kiro`,
+        `    base_url: ${context.openaiBaseUrl}`,
+        `    api_key: ${context.apiKey}`,
+        `    model: ${context.modelId}`,
+        `    models:`,
+        modelsYaml
+    ].join(newline);
+    // 简单追加/替换 custom_providers 中的 kiro 条目
+    let content = existing;
+    const kiroProviderRegex = /^\s*- name:\s*kiro\b[\s\S]*?(?=^\s*- name:|^[a-z]|$)/gm;
+    if (kiroProviderRegex.test(content)) {
+        content = content.replace(kiroProviderRegex, providerBlock + newline);
+    }
+    else if (content.includes('custom_providers:')) {
+        content = content.replace(/(custom_providers:\s*)/, `$1${newline}${providerBlock}${newline}`);
+    }
+    else {
+        content = `${content.trimEnd()}${newline}${newline}custom_providers:${newline}${providerBlock}${newline}`;
+    }
+    // 更新 model section
+    const modelSection = `model:${newline}  default: "kiro/${context.modelId}"${newline}  provider: "kiro"${newline}`;
+    if (/^model:/m.test(content)) {
+        content = content.replace(/^model:.*(?:\n(?=\s).*)*$/m, modelSection.trimEnd());
+    }
+    else {
+        content = `${content.trimEnd()}${newline}${newline}${modelSection}`;
+    }
+    const backups = await writeText(configPath, content);
+    return { paths: [configPath], backupPaths: backups };
+}
+// OpenClaw: ~/.openclaw/openclaw.json
+function getOpenClawConfigPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.openclaw', 'openclaw.json');
+}
+async function configureOpenClaw(context) {
+    const configPath = getOpenClawConfigPath();
+    const config = await readJsonObject(configPath);
+    const providerId = 'krouter';
+    const legacyProviderId = ['kiro', 'manager'].join('-');
+    // models.providers.kiro
+    const models = ensureObjectField(config, 'models');
+    if (typeof models.mode !== 'string')
+        models.mode = 'merge';
+    const providers = ensureObjectField(models, 'providers');
+    if (isRecord(providers.kiro) && (providers.kiro.base_url || providers.kiro.api_key || providers.kiro.api === 'openai-chat')) {
+        delete providers.kiro;
+    }
+    const existingProvider = isRecord(providers[providerId])
+        ? providers[providerId]
+        : isRecord(providers[legacyProviderId])
+            ? providers[legacyProviderId]
+            : {};
+    const existingModels = openClawModelsToClientModels(existingProvider.models);
+    const openClawModels = dedupeClientModels([
+        ...existingModels,
+        ...buildOpenClawModels(context)
+    ]).filter(model => !(0, modelCatalog_1.isAutoKiroModelId)(model.id));
+    const primaryModelId = pickOpenClawPrimaryModel(context, openClawModels);
+    providers[providerId] = {
+        baseUrl: context.openaiBaseUrl,
+        apiKey: context.apiKey,
+        auth: 'api-key',
+        api: 'openai-completions',
+        models: openClawModels.map(openClawModelConfig)
+    };
+    delete providers[legacyProviderId];
+    // agents.defaults.model
+    const agents = ensureObjectField(config, 'agents');
+    const defaults = ensureObjectField(agents, 'defaults');
+    defaults.model = {
+        primary: `${providerId}/${primaryModelId}`,
+        fallbacks: buildOpenClawFallbackRefs(providerId, primaryModelId, openClawModels)
+    };
+    const defaultsModels = ensureObjectField(defaults, 'models');
+    for (const model of openClawModels) {
+        const ref = `${providerId}/${model.id}`;
+        defaultsModels[ref] = isRecord(defaultsModels[ref]) ? defaultsModels[ref] : {};
+    }
+    const backups = await writeJsonObject(configPath, config);
+    return { paths: [configPath], backupPaths: backups };
+}
+const ALL_CLIENT_TARGETS = ['claudeCode', 'opencode', 'codex', 'gemini', 'hermes', 'openclaw'];
+async function configureClient(client, context) {
+    try {
+        const result = client === 'claudeCode' ? await configureClaudeCode(context)
+            : client === 'opencode' ? await configureOpenCode(context)
+                : client === 'codex' ? await configureCodex(context)
+                    : client === 'gemini' ? await configureGemini(context)
+                        : client === 'hermes' ? await configureHermes(context)
+                            : await configureOpenClaw(context);
+        return { client, success: true, ...result };
+    }
+    catch (error) {
+        return { client, success: false, paths: [], backupPaths: [], error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+async function configureProxyClients(input) {
+    const modelId = input.modelId.trim();
+    const apiKey = input.apiKey?.trim();
+    if (!Array.isArray(input.clients))
+        throw new Error('Client targets are required');
+    const clients = Array.from(new Set(input.clients));
+    if (!modelId)
+        throw new Error('Model is required');
+    if (!apiKey)
+        throw new Error('API Key is required');
+    if (clients.length === 0)
+        throw new Error('At least one client is required');
+    if (clients.some(client => !ALL_CLIENT_TARGETS.includes(client)))
+        throw new Error('Unsupported client target');
+    const proxyOrigin = buildProxyOrigin(input);
+    const modelMap = new Map((input.models?.length ? input.models : [{ id: modelId, name: input.modelName || modelId }]).map(model => [model.id, model]));
+    if (!modelMap.has(modelId))
+        modelMap.set(modelId, { id: modelId, name: input.modelName || modelId });
+    const context = {
+        proxyOrigin,
+        openaiBaseUrl: `${proxyOrigin.replace(/\/$/, '')}/v1`,
+        apiKey,
+        modelId,
+        models: Array.from(modelMap.values())
+    };
+    const results = [];
+    for (const client of clients) {
+        results.push(await configureClient(client, context));
+    }
+    return {
+        success: results.every(result => result.success),
+        proxyOrigin,
+        openaiBaseUrl: context.openaiBaseUrl,
+        apiKey: { key: apiKey },
+        results
+    };
+}

package/out-server/main/proxy/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyServer = void 0;
+// Kiro Proxy 模块导出
+__exportStar(require("./types"), exports);
+__exportStar(require("./accountPool"), exports);
+__exportStar(require("./kiroApi"), exports);
+__exportStar(require("./translator"), exports);
+__exportStar(require("./clientConfig"), exports);
+var proxyServer_1 = require("./proxyServer");
+Object.defineProperty(exports, "ProxyServer", { enumerable: true, get: function () { return proxyServer_1.ProxyServer; } });