@heventure/model-provider-x 0.2.0 → 0.2.2

package/README.md

@@ -24,7 +24,7 @@ Or run the published package directly:
 npx @heventure/model-provider-x --help
 ```
 
-## OpenCode Setup
+## Unified Setup
 
 Run the TUI wizard:
 
@@ -32,7 +32,17 @@ Run the TUI wizard:
 node dist/cli/index.js
 ```
 
-Or print a config fragment without writing files:
+The wizard asks for:
+
+1. Provider.
+2. Models.
+3. Agent platform: OpenCode, Codex, or Claude Code.
+4. Direct or proxy mode, with a recommendation based on provider API support.
+5. Any platform-specific install target.
+
+## OpenCode Setup
+
+Print a config fragment without writing files:
 
 ```bash
 node dist/cli/index.js \
@@ -43,6 +53,21 @@ node dist/cli/index.js \
   --print
 ```
 
+OpenCode provider entries include `options.setCacheKey=true` by default.
+This lets OpenCode pass a stable cache key through the OpenAI-compatible provider path so relays or local providers that support prompt caching can route repeated context to the same cache.
+
+When targeting OpenCode, choose the direct API type interactively or pass `--opencode-api`:
+
+```bash
+node dist/cli/index.js setup --target opencode --provider lmstudio --direct --opencode-api responses
+```
+
+Supported values are:
+
+- `chat`: writes `npm: "@ai-sdk/openai-compatible"` for `/v1/chat/completions`.
+- `responses`: writes `npm: "@ai-sdk/openai"` for `/v1/responses`.
+- `messages`: writes `npm: "@ai-sdk/anthropic"` for Anthropic-compatible `/v1/messages`.
+
 ## Claude Code Setup
 
 Create or update a provider profile and write Claude Code user settings:
@@ -61,6 +86,9 @@ node dist/cli/index.js proxy up --profile unsloth
 ```
 
 The Claude Code setup writes gateway environment values to `~/.claude/settings.json`.
+Claude Code appends `/v1/messages` itself, so direct Anthropic-compatible provider URLs are written without a trailing `/v1`.
+For example, entering `http://localhost:1234/v1` for LM Studio writes `ANTHROPIC_BASE_URL=http://localhost:1234`.
+The setup uses `ANTHROPIC_API_KEY` and removes stale `ANTHROPIC_AUTH_TOKEN` values to avoid Claude Code auth conflicts.
 Upstream provider keys are stored in `~/.config/model-provider-x/config.jsonc`, not in Claude Code settings.
 
 ## Codex Setup
@@ -82,9 +110,9 @@ The Codex setup writes a Responses-compatible provider to `~/.codex/config.toml`
 It also configures command-backed authentication so Codex can fetch the local proxy token automatically.
 The proxy currently supports non-streaming `/v1/responses` requests and forwards them to upstream OpenAI-compatible `/v1/chat/completions`.
 
-## Unified Setup Flow
+## Setup Modes
 
-Use the unified setup wizard to install a provider into OpenCode, Codex, or Claude Code:
+You can also run the unified setup wizard through the explicit setup command:
 
 ```bash
 node dist/cli/index.js setup --provider lmstudio

package/dist/cli/args.js

@@ -35,6 +35,9 @@ export function parseCliArgs(argv) {
             case "--provider":
                 options.providerPreset = next();
                 break;
+            case "--opencode-api":
+                options.opencodeApiType = parseOpenCodeApiType(next());
+                break;
             case "--proxy":
                 options.proxy = true;
                 break;
@@ -92,6 +95,7 @@ export function usage() {
 
 Usage:
   model-provider-x [options]
+  model-provider-x setup [options]
 
 Options:
   --base-url <url>     OpenAI-compatible API base URL, for example http://localhost:8888/v1
@@ -99,10 +103,11 @@ Options:
   --name <name>        Provider display name.
   --id <id>            Provider id used under provider.<id>.
   --provider <id>      Use a built-in provider preset, for example lmstudio or openai.
+  --opencode-api <api> OpenCode API type: chat, responses, or messages.
   --proxy              Write agent config through the local compatibility proxy.
   --direct             Write agent config directly to the upstream provider.
   --models <list>      Comma-separated model ids. Skips interactive model selection.
-  --config <path>      OpenCode config path to write.
+  --config <path>      OpenCode config path to write when targeting OpenCode.
   --print              Print generated JSON and do not write config.
   --yes, -y            Accept defaults in non-interactive prompts.
   --help, -h           Show this help.
@@ -110,6 +115,18 @@ Options:
 }
 export class HelpRequested extends Error {
 }
+function parseOpenCodeApiType(value) {
+    if (value === "chat" || value === "chat-completions" || value === "openai-compatible") {
+        return "chat";
+    }
+    if (value === "responses" || value === "openai-responses") {
+        return "responses";
+    }
+    if (value === "messages" || value === "anthropic-messages") {
+        return "messages";
+    }
+    throw new Error(`Unknown OpenCode API type: ${value}`);
+}
 function addModelByOneBasedIndex(selected, models, index) {
     const model = models[index - 1];
     if (!model) {

package/dist/cli/commands.js

@@ -2,7 +2,7 @@ import { HelpRequested, parseCliArgs, usage } from "./args.js";
 export function parseCommand(argv) {
     const [command, ...rest] = argv;
     if (!command || command.startsWith("--")) {
-        return { command: "opencode", options: parseCliArgs(argv) };
+        return { command: "setup", target: undefined, options: parseCliArgs(argv) };
     }
     if (command === "setup") {
         return parseSetupCommand(rest);

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import { getDefaultToolConfigPath, readToolConfig, upsertProviderProfile } from
 import { discoverOpenCodeConfigs, getDefaultConfigPath, writeProviderToConfig } from "../core/config.js";
 import { buildProviderConfig, detectProviderCapabilities, recommendProxyMode, validateAndFetchModels } from "../core/provider.js";
 import { startProxyServer } from "../proxy/server.js";
-import { getDefaultClaudeSettingsPath, writeClaudeCodeSettings } from "../targets/claude-code.js";
+import { defaultClaudeModelMapping, getDefaultClaudeSettingsPath, writeClaudeCodeSettings } from "../targets/claude-code.js";
 import { getDefaultCodexConfigPath, writeCodexConfig } from "../targets/codex.js";
 import { HelpRequested, parseModelSelection } from "./args.js";
 import { commandUsage, parseCommand } from "./commands.js";
@@ -34,6 +34,10 @@ export async function runCommand(command) {
         return;
     }
     if (command.command === "setup") {
+        if (command.options.print) {
+            await runCli(command.options);
+            return;
+        }
         await runSetup(command);
         return;
     }
@@ -77,7 +81,8 @@ export async function runCli(options) {
             providerName,
             baseURL: fetched.baseURL,
             apiKey,
-            models: selectedModels
+            models: selectedModels,
+            opencodeApiType: options.opencodeApiType ?? "chat"
         });
         const provider = fragment.provider[providerId];
         const json = JSON.stringify(fragment, null, 2);
@@ -110,18 +115,18 @@ async function runSetup(command) {
         const providerInput = await collectProviderInput(rl, command);
         output.write("Detecting provider capabilities...\n");
         const capabilities = await detectProviderCapabilities({ baseURL: providerInput.baseURL, apiKey: providerInput.apiKey });
+        const selection = await collectProviderSelection(rl, command, providerInput);
         const target = await resolveSetupTarget(rl, command.target);
         const useProxy = await resolveProxyMode(rl, command.options, capabilities, target);
-        const selection = await collectProviderSelection(rl, command, target, providerInput);
         if (target === "opencode") {
-            await writeOpenCodeSetup(rl, command, selection, useProxy);
+            await writeOpenCodeSetup(rl, command, selection, useProxy, capabilities);
             return;
         }
         if (target === "codex") {
             await writeCodexSetup(command, selection, useProxy);
             return;
         }
-        await writeClaudeCodeSetup(command, selection, useProxy);
+        await writeClaudeCodeSetup(rl, command, selection, useProxy);
     }
     finally {
         rl.close();
@@ -135,18 +140,14 @@ async function collectProviderInput(rl, command) {
     const apiKey = await resolveApiKey(rl, command.options.apiKey, providerDefaults.preset, "Upstream API key");
     return { providerId, providerName, baseURL, apiKey };
 }
-async function collectProviderSelection(rl, command, target, providerInput) {
+async function collectProviderSelection(rl, command, providerInput) {
     output.write("Fetching models...\n");
     const fetched = await validateAndFetchModels({ baseURL: providerInput.baseURL, apiKey: providerInput.apiKey });
     const selectedModels = command.options.models ??
         (canUseTui()
-            ? await multiSelectChoices(target === "codex"
-                ? "Select Codex Responses gateway models"
-                : target === "claude-code"
-                    ? "Select Claude Code gateway models"
-                    : "Select models", createModelChoices(fetched.models))
+            ? await multiSelectChoices("Select models", createModelChoices(fetched.models))
             : parseModelSelection(await rl.question(formatModelPrompt(fetched.models)), fetched.models));
-    const defaultModel = command.defaultModel ?? selectedModels[0];
+    const defaultModel = await resolveDefaultModel(rl, command, selectedModels);
     if (!defaultModel) {
         throw new Error("Select at least one model");
     }
@@ -172,15 +173,17 @@ async function collectProviderSelection(rl, command, target, providerInput) {
         toolConfigPath
     };
 }
-async function writeOpenCodeSetup(rl, command, selection, useProxy) {
+async function writeOpenCodeSetup(rl, command, selection, useProxy, capabilities) {
     const baseURL = useProxy ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}/v1` : selection.upstreamBaseURL;
     const apiKey = useProxy ? selection.config.proxy.authToken : selection.apiKey;
+    const opencodeApiType = await resolveOpenCodeApiType(rl, command, capabilities, useProxy);
     const fragment = buildProviderConfig({
         providerId: selection.providerId,
         providerName: selection.providerName,
         baseURL,
         apiKey,
-        models: selection.selectedModels
+        models: selection.selectedModels,
+        opencodeApiType
     });
     const provider = fragment.provider[selection.providerId];
     const targetPath = command.options.configPath ?? (await chooseConfigPath(rl, selection.providerId, command.options.yes));
@@ -204,15 +207,18 @@ async function writeOpenCodeSetup(rl, command, selection, useProxy) {
         output.write(`Started proxy: ${proxy.baseURL}\n`);
     }
 }
-async function writeClaudeCodeSetup(command, selection, useProxy) {
+async function writeClaudeCodeSetup(rl, command, selection, useProxy) {
     const proxyBaseURL = useProxy ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}` : selection.upstreamBaseURL;
+    const modelMapping = await resolveClaudeModelMapping(rl, command, selection);
     const result = await writeClaudeCodeSettings({
         targetPath: getDefaultClaudeSettingsPath(),
         proxy: {
             baseURL: proxyBaseURL,
             authToken: useProxy ? selection.config.proxy.authToken : selection.apiKey,
             enableModelDiscovery: useProxy,
-            defaultModel: command.defaultModel
+            defaultModel: selection.defaultModel,
+            models: selection.selectedModels,
+            modelMapping
         }
     });
     output.write(`Saved profile ${selection.providerId} to ${selection.toolConfigPath}\n`);
@@ -359,6 +365,132 @@ async function resolveProxyMode(rl, options, capabilities, target) {
     const accepted = !answer.trim() || answer.trim().toLowerCase() === "y";
     return recommendedProxy ? accepted : !accepted;
 }
+async function resolveOpenCodeApiType(rl, command, capabilities, useProxy) {
+    if (command.options.opencodeApiType) {
+        return command.options.opencodeApiType;
+    }
+    const availableApis = useProxy ? new Set(["openai-compatible", "openai-responses", "anthropic-messages"]) : new Set(capabilities.apis);
+    const recommended = recommendedOpenCodeApiType(availableApis);
+    if (command.options.yes) {
+        return recommended;
+    }
+    const choices = [
+        {
+            label: "Responses API",
+            value: "responses",
+            hint: choiceHint("openai-responses", recommended, "responses", availableApis)
+        },
+        {
+            label: "Chat Completions API",
+            value: "chat",
+            hint: choiceHint("openai-compatible", recommended, "chat", availableApis)
+        },
+        {
+            label: "Anthropic Messages API",
+            value: "messages",
+            hint: choiceHint("anthropic-messages", recommended, "messages", availableApis)
+        }
+    ];
+    if (canUseTui()) {
+        return selectChoice("OpenCode API type", choices);
+    }
+    output.write("OpenCode API types:\n");
+    choices.forEach((choice, index) => {
+        output.write(`${index + 1}. ${choice.label}${choice.hint ? ` - ${choice.hint}` : ""}\n`);
+    });
+    const answer = await rl.question(`OpenCode API type [${recommended}]: `);
+    const value = answer.trim();
+    if (!value) {
+        return recommended;
+    }
+    if (value === "1" || value === "responses") {
+        return "responses";
+    }
+    if (value === "2" || value === "chat" || value === "chat-completions") {
+        return "chat";
+    }
+    if (value === "3" || value === "messages") {
+        return "messages";
+    }
+    throw new Error(`Unknown OpenCode API type: ${value}`);
+}
+function recommendedOpenCodeApiType(apis) {
+    if (apis.has("openai-responses")) {
+        return "responses";
+    }
+    if (apis.has("openai-compatible")) {
+        return "chat";
+    }
+    if (apis.has("anthropic-messages")) {
+        return "messages";
+    }
+    return "chat";
+}
+function choiceHint(api, recommended, value, availableApis) {
+    const hints = [];
+    if (value === recommended) {
+        hints.push("recommended");
+    }
+    if (!availableApis.has(api)) {
+        hints.push("not detected");
+    }
+    return hints.join(", ");
+}
+async function resolveDefaultModel(rl, command, selectedModels) {
+    if (command.defaultModel) {
+        if (!selectedModels.includes(command.defaultModel)) {
+            throw new Error(`Default model is not in the selected model list: ${command.defaultModel}`);
+        }
+        return command.defaultModel;
+    }
+    if (selectedModels.length === 0) {
+        throw new Error("Select at least one model");
+    }
+    if (selectedModels.length === 1 || command.options.yes) {
+        return selectedModels[0];
+    }
+    if (canUseTui()) {
+        return selectChoice("Choose default model", selectedModels.map((model) => ({ label: model, value: model })));
+    }
+    const answer = await rl.question(`Default model [${selectedModels[0]}]: `);
+    const model = answer.trim() || selectedModels[0];
+    if (!selectedModels.includes(model)) {
+        throw new Error(`Default model is not in the selected model list: ${model}`);
+    }
+    return model;
+}
+async function resolveClaudeModelMapping(rl, command, selection) {
+    const defaultMapping = defaultClaudeModelMapping(selection.defaultModel);
+    if (selection.selectedModels.length <= 1 || command.options.yes) {
+        return defaultMapping;
+    }
+    const customize = canUseTui()
+        ? await selectChoice("Claude Code model mapping", [
+            { label: "Use default model for Opus, Sonnet, Haiku", value: false, hint: "recommended" },
+            { label: "Customize Opus, Sonnet, Haiku models", value: true }
+        ])
+        : (await rl.question("Use default model for Opus, Sonnet, Haiku? [Y/n] ")).trim().toLowerCase() === "n";
+    if (!customize) {
+        return defaultMapping;
+    }
+    return {
+        opus: await selectModelForRole(rl, "Opus model", selection.selectedModels, selection.defaultModel),
+        sonnet: await selectModelForRole(rl, "Sonnet model", selection.selectedModels, selection.defaultModel),
+        haiku: await selectModelForRole(rl, "Haiku model", selection.selectedModels, selection.defaultModel),
+        subagent: await selectModelForRole(rl, "Subagent model", selection.selectedModels, selection.defaultModel)
+    };
+}
+async function selectModelForRole(rl, label, models, defaultModel) {
+    if (canUseTui()) {
+        return selectChoice(label, models.map((model) => ({ label: model, value: model, hint: model === defaultModel ? "default" : undefined })));
+    }
+    const answer = await rl.question(`${label} [${defaultModel}]: `);
+    const model = answer.trim() || defaultModel;
+    if (!models.includes(model)) {
+        throw new Error(`${label} is not in the selected model list: ${model}`);
+    }
+    return model;
+}
 async function resolveSetupTarget(rl, target) {
     if (target) {
         return target;

package/dist/core/provider.js

@@ -51,7 +51,7 @@ export async function detectProviderCapabilities(input, fetchImpl = globalThis.f
         apis.add("openai-responses");
     }
     const messages = await probe(`${baseURL}/messages`, { method: "POST", headers: { ...headers, "content-type": "application/json" }, body: "{}" }, fetchImpl);
-    if (messages.reachable) {
+    if (messages.reachable && (await isAnthropicMessagesProbe(messages.response))) {
         apis.add("anthropic-messages");
     }
     return { baseURL, apis: [...apis] };
@@ -71,14 +71,18 @@ export function recommendProxyMode(capabilities, target) {
 export function buildProviderConfig(input) {
     const baseURL = normalizeBaseUrl(input.baseURL);
     const apiKey = input.apiKey?.trim();
+    const opencodeApiType = input.opencodeApiType ?? "chat";
     const provider = {
-        npm: "@ai-sdk/openai-compatible",
+        npm: npmPackageForOpenCodeApiType(opencodeApiType),
         name: input.providerName.trim(),
         options: {
             baseURL
         },
         models: Object.fromEntries(input.models.map((model) => [model, { name: model }]))
     };
+    if (opencodeApiType !== "messages") {
+        provider.options.setCacheKey = true;
+    }
     if (apiKey) {
         provider.options.apiKey = apiKey;
     }
@@ -89,6 +93,15 @@ export function buildProviderConfig(input) {
         }
     };
 }
+export function npmPackageForOpenCodeApiType(apiType) {
+    if (apiType === "responses") {
+        return "@ai-sdk/openai";
+    }
+    if (apiType === "messages") {
+        return "@ai-sdk/anthropic";
+    }
+    return "@ai-sdk/openai-compatible";
+}
 function isModelListResponse(body) {
     return (typeof body === "object" &&
         body !== null &&
@@ -104,9 +117,48 @@ function isOpenCodeCompatibleModel(model) {
 async function probe(input, init, fetchImpl) {
     try {
         const response = await fetchImpl(input, init);
-        return { reachable: response.ok || response.status === 400 || response.status === 401 || response.status === 422 };
+        return {
+            reachable: response.ok || response.status === 400 || response.status === 401 || response.status === 422,
+            response
+        };
     }
     catch {
         return { reachable: false };
     }
 }
+async function isAnthropicMessagesProbe(response) {
+    if (!response) {
+        return false;
+    }
+    const status = response.status ?? (response.ok ? 200 : undefined);
+    if (status === 404 || status === undefined) {
+        return false;
+    }
+    if (!response.json) {
+        return !response.ok && (status === 400 || status === 401 || status === 422);
+    }
+    try {
+        const body = await response.json();
+        if (isAnthropicMessageResponse(body) || isAnthropicErrorResponse(body)) {
+            return true;
+        }
+        return !response.ok && (status === 400 || status === 401 || status === 422);
+    }
+    catch {
+        return !response.ok && (status === 400 || status === 401 || status === 422);
+    }
+}
+function isAnthropicMessageResponse(body) {
+    return (typeof body === "object" &&
+        body !== null &&
+        body.type === "message" &&
+        typeof body.role === "string" &&
+        Array.isArray(body.content));
+}
+function isAnthropicErrorResponse(body) {
+    return (typeof body === "object" &&
+        body !== null &&
+        body.type === "error" &&
+        typeof body.error === "object" &&
+        body.error !== null);
+}

package/dist/proxy/server.js

@@ -114,7 +114,7 @@ async function handleResponses(request, response, profile, fetchImpl) {
     writeJson(response, 200, chatCompletionToResponses((await upstream.json())));
 }
 async function handleMessages(request, response, profile, fetchImpl) {
-    const body = (await readJson(request));
+    const body = normalizeAnthropicModel((await readJson(request)), profile);
     const chatRequest = anthropicMessageToChatRequest(body);
     const upstream = await fetchImpl(`${profile.baseURL.replace(/\/+$/, "")}/chat/completions`, {
         method: "POST",
@@ -150,6 +150,18 @@ async function handleMessages(request, response, profile, fetchImpl) {
     }
     writeJson(response, 200, chatCompletionToAnthropicMessage((await upstream.json())));
 }
+function normalizeAnthropicModel(body, profile) {
+    if (!isClaudeModelAlias(body.model) || profile.models.includes(body.model) || profile.models.length === 0) {
+        return body;
+    }
+    return {
+        ...body,
+        model: profile.models[0]
+    };
+}
+function isClaudeModelAlias(model) {
+    return /(^claude-|sonnet|opus|haiku)/i.test(model);
+}
 function isAuthorized(request, authToken) {
     const authorization = request.headers.authorization;
     const apiKey = request.headers["x-api-key"];

package/dist/targets/claude-code.js

@@ -1,25 +1,85 @@
 import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+const OPUS_MODEL_OVERRIDE_KEYS = [
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-opus-4-5",
+    "claude-opus-4-1",
+    "claude-opus-4-0",
+    "claude-3-opus-latest",
+    "claude-3-opus-20240229"
+];
+const SONNET_MODEL_OVERRIDE_KEYS = [
+    "claude-sonnet-4-6",
+    "claude-sonnet-4-5",
+    "claude-sonnet-4-0",
+    "claude-3-7-sonnet-latest",
+    "claude-3-7-sonnet-20250219",
+    "claude-3-5-sonnet-latest",
+    "claude-3-5-sonnet-20241022",
+    "claude-3-5-sonnet-20240620"
+];
+const HAIKU_MODEL_OVERRIDE_KEYS = [
+    "claude-haiku-4-5",
+    "claude-3-5-haiku-latest",
+    "claude-3-5-haiku-20241022",
+    "claude-3-haiku-20240307"
+];
 export function getDefaultClaudeSettingsPath(homeDir = homedir()) {
     return join(homeDir, ".claude", "settings.json");
 }
 export function mergeClaudeCodeSettings(settings, proxy) {
     const env = {
         ...(isRecord(settings.env) ? stringifyRecord(settings.env) : {}),
-        ANTHROPIC_BASE_URL: proxy.baseURL,
-        ANTHROPIC_AUTH_TOKEN: proxy.authToken
+        ANTHROPIC_BASE_URL: normalizeClaudeCodeBaseURL(proxy.baseURL),
+        ANTHROPIC_API_KEY: proxy.authToken
     };
+    delete env.ANTHROPIC_AUTH_TOKEN;
     if (proxy.enableModelDiscovery) {
         env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     }
     if (proxy.defaultModel) {
+        const mapping = proxy.modelMapping ?? defaultClaudeModelMapping(proxy.defaultModel);
         env.ANTHROPIC_MODEL = proxy.defaultModel;
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL = mapping.opus;
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL = mapping.sonnet;
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = mapping.haiku;
+        env.CLAUDE_CODE_SUBAGENT_MODEL = mapping.subagent;
     }
-    return {
+    const next = {
         ...settings,
         env
     };
+    if (proxy.defaultModel) {
+        const defaultModel = proxy.defaultModel;
+        const mapping = proxy.modelMapping ?? defaultClaudeModelMapping(defaultModel);
+        next.model = defaultModel;
+        next.modelOverrides = {
+            ...(isRecord(settings.modelOverrides) ? stringifyRecord(settings.modelOverrides) : {}),
+            ...modelOverridesForMapping(mapping)
+        };
+    }
+    const availableModels = uniqueStrings([
+        ...(Array.isArray(settings.availableModels) ? settings.availableModels.map(String) : []),
+        ...(proxy.models ?? []),
+        ...(proxy.defaultModel ? [proxy.defaultModel] : [])
+    ]);
+    if (availableModels.length > 0) {
+        next.availableModels = availableModels;
+    }
+    return next;
+}
+export function defaultClaudeModelMapping(defaultModel) {
+    return {
+        opus: defaultModel,
+        sonnet: defaultModel,
+        haiku: defaultModel,
+        subagent: defaultModel
+    };
+}
+export function normalizeClaudeCodeBaseURL(baseURL) {
+    return baseURL.trim().replace(/\/+$/, "").replace(/\/v1$/i, "");
 }
 export async function writeClaudeCodeSettings(input) {
     const targetPath = input.targetPath ?? getDefaultClaudeSettingsPath();
@@ -46,6 +106,16 @@ async function fileExists(path) {
 function stringifyRecord(record) {
     return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, String(value)]));
 }
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function modelOverridesForMapping(mapping) {
+    return {
+        ...Object.fromEntries(OPUS_MODEL_OVERRIDE_KEYS.map((model) => [model, mapping.opus])),
+        ...Object.fromEntries(SONNET_MODEL_OVERRIDE_KEYS.map((model) => [model, mapping.sonnet])),
+        ...Object.fromEntries(HAIKU_MODEL_OVERRIDE_KEYS.map((model) => [model, mapping.haiku]))
+    };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heventure/model-provider-x",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "TUI configurator and local API proxy for wiring custom model providers into OpenCode and Claude Code.",
   "private": false,
   "license": "MIT",