@heventure/model-provider-x 0.2.1 → 0.2.2

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:

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

@@ -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,7 +119,7 @@ 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") {
@@ -172,15 +173,17 @@ async function collectProviderSelection(rl, command, 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));
@@ -362,6 +365,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heventure/model-provider-x",
-  "version": "0.2.1",
+  "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",