@heventure/model-provider-x 0.2.1 → 0.2.3

package/README.md

@@ -56,6 +56,18 @@ node dist/cli/index.js \
 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:
@@ -113,6 +125,9 @@ Proxy mode gives the broadest compatibility:
 - `/v1/chat/completions` and `/v1/completions` passthrough for OpenAI-compatible clients.
 - `/v1/messages` for Claude Code.
 
+When proxy mode is selected interactively, the wizard confirms whether to reuse the current proxy token, generate a new one, or enter your own.
+Non-interactive `--yes` runs keep the existing token or use the generated default.
+
 You can force either mode non-interactively:
 
 ```bash

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;
@@ -100,6 +103,7 @@ 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.
@@ -111,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/index.js

@@ -3,7 +3,7 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { readProxyStatus, startProxyProcess, stopProxyProcess } from "../core/proxy-process.js";
-import { getDefaultToolConfigPath, readToolConfig, upsertProviderProfile } from "../core/tool-config.js";
+import { createProxyAuthToken, getDefaultToolConfigPath, readToolConfig, upsertProviderProfile, writeToolConfig } from "../core/tool-config.js";
 import { discoverOpenCodeConfigs, getDefaultConfigPath, writeProviderToConfig } from "../core/config.js";
 import { buildProviderConfig, detectProviderCapabilities, recommendProxyMode, validateAndFetchModels } from "../core/provider.js";
 import { startProxyServer } from "../proxy/server.js";
@@ -81,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);
@@ -118,11 +119,11 @@ async function runSetup(command) {
         const target = await resolveSetupTarget(rl, command.target);
         const useProxy = await resolveProxyMode(rl, command.options, capabilities, target);
         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);
+            await writeCodexSetup(rl, command, selection, useProxy);
             return;
         }
         await writeClaudeCodeSetup(rl, command, selection, useProxy);
@@ -172,15 +173,20 @@ async function collectProviderSelection(rl, command, providerInput) {
         toolConfigPath
     };
 }
-async function writeOpenCodeSetup(rl, command, selection, useProxy) {
+async function writeOpenCodeSetup(rl, command, selection, useProxy, capabilities) {
+    if (useProxy) {
+        await ensureProxyAuthToken(rl, command, selection);
+    }
     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));
@@ -205,6 +211,9 @@ async function writeOpenCodeSetup(rl, command, selection, useProxy) {
     }
 }
 async function writeClaudeCodeSetup(rl, command, selection, useProxy) {
+    if (useProxy) {
+        await ensureProxyAuthToken(rl, command, selection);
+    }
     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({
@@ -233,7 +242,10 @@ async function writeClaudeCodeSetup(rl, command, selection, useProxy) {
         output.write(`Started proxy: ${proxy.baseURL}\n`);
     }
 }
-async function writeCodexSetup(_command, selection, useProxy) {
+async function writeCodexSetup(rl, command, selection, useProxy) {
+    if (useProxy) {
+        await ensureProxyAuthToken(rl, command, selection);
+    }
     const proxyBaseURL = useProxy
         ? `http://${selection.config.proxy.host}:${selection.config.proxy.port}/v1`
         : selection.upstreamBaseURL;
@@ -312,6 +324,48 @@ async function runProxyCommand(command) {
         process.once("SIGTERM", stop);
     });
 }
+async function ensureProxyAuthToken(rl, command, selection) {
+    if (command.options.yes || !rl) {
+        return;
+    }
+    const current = selection.config.proxy.authToken;
+    const action = canUseTui()
+        ? await selectChoice("Proxy token", [
+            { label: "Use existing proxy token", value: "use", hint: tokenHint(current) },
+            { label: "Generate a new proxy token", value: "generate" },
+            { label: "Enter a proxy token", value: "input" }
+        ])
+        : await promptProxyTokenAction(rl, current);
+    if (action === "use") {
+        return;
+    }
+    const nextToken = action === "generate"
+        ? createProxyAuthToken()
+        : await requiredOption(rl, undefined, "Proxy token");
+    selection.config.proxy.authToken = nextToken;
+    await writeToolConfig(selection.toolConfigPath, selection.config);
+}
+async function promptProxyTokenAction(rl, current) {
+    output.write(`Proxy token found (${tokenHint(current)}).\n`);
+    const answer = await rl.question("Use existing, generate new, or enter your own? [use/generate/input] ");
+    const value = answer.trim().toLowerCase();
+    if (!value || value === "use" || value === "u") {
+        return "use";
+    }
+    if (value === "generate" || value === "g") {
+        return "generate";
+    }
+    if (value === "input" || value === "i" || value === "byok") {
+        return "input";
+    }
+    throw new Error(`Unknown proxy token action: ${answer}`);
+}
+function tokenHint(token) {
+    if (token.length <= 10) {
+        return token;
+    }
+    return `${token.slice(0, 8)}...${token.slice(-4)}`;
+}
 async function requiredOption(rl, value, label) {
     const answer = value ?? (await rl.question(`${label}: `));
     if (!answer.trim()) {
@@ -362,6 +416,77 @@ 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)) {

package/dist/core/provider.js

@@ -71,15 +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,
-            setCacheKey: true
+            baseURL
         },
         models: Object.fromEntries(input.models.map((model) => [model, { name: model }]))
     };
+    if (opencodeApiType !== "messages") {
+        provider.options.setCacheKey = true;
+    }
     if (apiKey) {
         provider.options.apiKey = apiKey;
     }
@@ -90,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 &&

package/dist/core/tool-config.js

@@ -40,10 +40,13 @@ function createDefaultToolConfig() {
         proxy: {
             host: "127.0.0.1",
             port: 4141,
-            authToken: `mpx-${randomBytes(18).toString("base64url")}`
+            authToken: createProxyAuthToken()
         }
     };
 }
+export function createProxyAuthToken() {
+    return `mpx-${randomBytes(18).toString("base64url")}`;
+}
 function normalizeToolConfig(config) {
     const fallback = createDefaultToolConfig();
     const profiles = isRecord(config.profiles) ? config.profiles : {};

package/package.json

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