@staticeng/opencode-litellm 0.2.5 → 0.2.6

package/README.md

@@ -93,6 +93,31 @@ When LiteLLM publishes `model_info.supported_reasoning_efforts`, the plugin maps
 
 Overrides win over built-in contracts and generated values through a recursive deep merge. Model overrides are applied first and provider overrides last. Arrays and scalar values are replaced rather than concatenated.
 
+### GPT Transport
+
+GPT models use `@ai-sdk/openai` and the Responses API through the configured
+LiteLLM base URL (for example, `/v1/responses`). Other models retain
+`@ai-sdk/openai-compatible` and Chat Completions. No OpenAI OAuth endpoint or
+direct upstream URL is introduced.
+
+Selection matches a final `gpt-` plus digit segment (case-insensitive), including
+namespaced aliases, in the routable model name, `base_model`, or
+`litellm_params.model`. Opaque deployment IDs do not override a named alias.
+The routable ID is preserved. O-series and non-GPT models are not migrated merely
+because discovery reports `mode: responses`. Explicit model `provider.npm`
+overrides still win; V2 uses the corresponding `api.package`.
+
+Legacy reasoning options remain `reasoningEffort` (OpenCode places them under
+`providerOptions.openai` for this SDK). V2 GPT request defaults and variants use
+Responses wire bodies: `reasoning: { effort }`, not `reasoning_effort`.
+Use an OpenCode release with AI SDK 5 or newer, where the OpenAI SDK's
+`languageModel()` defaults to Responses. Tests pin the SDK versions used by
+OpenCode at qualification time; these are development dependencies only.
+
+After upgrading, pin the exact plugin version and restart only when active
+sessions can safely stop. Existing processes retain their loaded plugin; do not
+clear global caches to upgrade one plugin.
+
 The built-in mode matrix is:
 
 | Contract | Modes in order | Default |

package/dist/mapping.js

@@ -111,6 +111,10 @@ function enrichMetadata(existing, incoming, key) {
 function modelName(model) {
     return asString(model.model_name) ?? asString(model.litellm_params?.model) ?? asString(model.model_info?.id);
 }
+function usesGPTResponses(model) {
+    // Match a GPT family segment, not an incidental substring or an opaque deployment ID.
+    return [modelName(model), model.model_info?.base_model, model.litellm_params?.model].some((name) => typeof name === "string" && /(?:^|\/)gpt-\d[^/]*$/i.test(name));
+}
 export function mergeModelInfo(deployments, groups) {
     const byName = new Map();
     for (const model of [...deployments, ...groups]) {
@@ -332,6 +336,7 @@ function generatedModel(model, tombstones = false) {
     const generated = {
         id: name,
         name,
+        ...(usesGPTResponses(model) ? { provider: { npm: "@ai-sdk/openai" } } : {}),
         ...(asString(model.model_info?.base_model) ? { family: asString(model.model_info?.base_model) } : {}),
         ...(cost(model) ? { cost: cost(model) } : {}),
         ...(limit(model) ? { limit: limit(model) } : {}),
@@ -403,8 +408,8 @@ function v2Model(model, baseURL) {
         api: {
             ...(id ? { id } : {}),
             type: "aisdk",
-            package: "@ai-sdk/openai-compatible",
-            ...(baseURL ? { url: baseURL } : {}),
+            package: model.provider?.npm ?? "@ai-sdk/openai-compatible",
+            ...(model.provider?.api ?? baseURL ? { url: model.provider?.api ?? baseURL } : {}),
             settings: {},
         },
         capabilities: {
@@ -458,9 +463,32 @@ export function mapModelsV2(models, options = {}) {
     return Object.fromEntries(Object.entries(legacy).map(([name, model]) => {
         const mapped = v2Model(model, options.baseURL);
         const variants = contractV2Variants(name, model, options.overrides?.[name]);
-        return [name, variants ? { ...mapped, variants } : mapped];
+        const result = variants ? { ...mapped, variants } : mapped;
+        if (mapped.api?.package === "@ai-sdk/openai") {
+            const body = responsesBody(isRecord(model.options) ? model.options : {});
+            result.request = { body };
+            result.variants = result.variants?.map((variant) => ({ ...variant, body: responsesBody(variant.body ?? {}) }));
+        }
+        return [name, result];
     }));
 }
+function responsesBody(options) {
+    const body = { ...options };
+    const effort = body.reasoningEffort ?? body.reasoning_effort;
+    const summary = body.reasoningSummary;
+    delete body.reasoningEffort;
+    delete body.reasoning_effort;
+    delete body.reasoningSummary;
+    delete body.variantDefault;
+    if (effort !== undefined || summary !== undefined) {
+        body.reasoning = {
+            ...(isRecord(body.reasoning) ? body.reasoning : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(summary !== undefined ? { summary } : {}),
+        };
+    }
+    return body;
+}
 export function buildProviderV2(models, options = {}) {
     return deepMerge({
         name: options.providerName ?? "LiteLLM",

package/dist/types.d.ts

@@ -27,6 +27,10 @@ export type ModelContract = Readonly<{
     metadata?: ModelContractMetadata;
 }>;
 export type OpenCodeModel = JsonObject & {
+    provider?: {
+        npm?: string;
+        api?: string;
+    };
     id?: string;
     name?: string;
     cost?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staticeng/opencode-litellm",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "OpenCode plugin that discovers LiteLLM models at runtime.",
   "type": "module",
   "license": "MIT",
@@ -30,6 +30,8 @@
     "@opencode-ai/plugin": "*"
   },
   "devDependencies": {
+    "@ai-sdk/openai": "3.0.84",
+    "@ai-sdk/openai-compatible": "2.0.41",
     "@opencode-ai/plugin": "latest",
     "@types/node": "^24.10.1",
     "typescript": "^5.9.3"