@staticeng/opencode-litellm 0.1.8 → 0.1.9

package/README.md

@@ -15,7 +15,7 @@ npm install @staticeng/opencode-litellm
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
     [
-      "@staticeng/opencode-litellm",
+      "@staticeng/opencode-litellm@0.1.9",
       {
         "baseURL": "https://litellm.example.com/v1",
         "apiKeyEnv": "LITELLM_API_KEY"
@@ -33,6 +33,8 @@ export LITELLM_API_KEY="..."
 
 Do not put real API keys in `opencode.json`. If you pass `apiKey` directly, the plugin uses it only in memory and never logs it, but environment variables are recommended.
 
+Shared or synchronized OpenCode configuration must use the published, pinned npm package as shown above. Do not use a local path or `file://` plugin reference for shared configuration.
+
 ## Options
 
 | Option | Default | Purpose |
@@ -56,6 +58,10 @@ The LiteLLM key must have permission to call `GET /model/info` and root `GET /mo
 
 LiteLLM metadata does not expose every OpenCode model field. Use `overrides` to add variants, thinking controls, cache costs, interleaved reasoning settings, limits, modalities, timeouts, or provider-specific options.
 
+When LiteLLM publishes `model_info.supported_reasoning_efforts`, the plugin maps
+that list to OpenCode variants automatically. It does not guess effort levels
+from model names; the LiteLLM catalog remains the source of truth.
+
 ```json
 {
   "plugin": [
@@ -68,7 +74,7 @@ LiteLLM metadata does not expose every OpenCode model field. Use `overrides` to
           "chatgpt/gpt-5.5": {
             "limit": { "context": 262144, "output": 128000 },
             "variants": {
-              "high": { "options": { "reasoning_effort": "high" } }
+              "high": { "reasoningEffort": "high" }
             },
             "interleaved": { "field": "reasoning_details" }
           }
@@ -86,6 +92,10 @@ LiteLLM metadata does not expose every OpenCode model field. Use `overrides` to
 
 Overrides win over generated values through a recursive deep merge. Arrays and scalar values are replaced rather than concatenated.
 
+The exact model groups `deepseek-v4-flash-fp8-mtp` and `deepseek-v4-flash-fp8-mtp-norefusal` are an exception: the plugin exposes only `off`, `low`, `high`, and `max`. Semantic `off` emits canonical `none`; the other values pass through unchanged. At the OpenCode config boundary, disabled `medium` and `xhigh` tombstones remove generic generated variants, while the model-scoped `variantDefault: false` capability hides the UI's default sentinel on compatible OpenCode builds. The plugin strips that UI-only marker in `chat.params` only when both the LiteLLM provider and an exact target alias match. Target model and provider overrides cannot change these controls. No manual model entry in `opencode.json` is needed.
+
+The exact model group `qwen3.8-27b-refusal-dial` similarly exposes only `off`, `low`, `medium`, and `xhigh`. Its semantic `off` sends `chat_template_kwargs.enable_thinking=false` without a `reasoning_effort`; the native effort modes pass through unchanged. Disabled `none`, `minimal`, `high`, and `max` tombstones suppress OpenCode's unsupported generated variants. Official OpenCode 1.18.23 still owns an intrinsic default selection (`Predeterminado`) outside model variants; plugin configuration cannot remove it, and leaving it selected omits reasoning controls and preserves the model's deployed default.
+
 ## Runtime Behavior
 
 - Fetches `${baseURL}/model/info`, then root `/model_group/info`, with separate authenticated and timed requests.
@@ -93,8 +103,11 @@ Overrides win over generated values through a recursive deep merge. Arrays and s
 - Adds or replaces both legacy `cfg.provider[providerKey]` and V2 `cfg.providers[providerKey]` during the config hook.
 - Keeps namespaced deployment IDs and augments them with exact bare model-group IDs; exact collisions are enriched deterministically.
 - Skips malformed group rows without a nonblank `model_group` and exposes reasoning capability on legacy and V2 model metadata.
+- Generates exact DeepSeek V4 and Qwen3.8 reasoning variants for the supported aliases and sanitizes conflicting target overrides after merging.
 - Warns safely and keeps deployment models when group discovery fails in non-strict mode; strict mode mutates neither config surface on failure.
 - Does not write `opencode.json`, cache model metadata, or persist generated provider data.
+- Emits the required `limit.output` as `0` when LiteLLM reports a context/input limit but no output
+  limit. The zero sentinel retains known metadata without inventing a positive output allowance.
 - Includes `chat` and `responses` modes by default; non-chat modes such as `embedding` and `rerank` are excluded unless explicitly included.
 - No HuggingFace fallback is included in v1.
 
@@ -110,3 +123,8 @@ npm pack --dry-run
 ```
 
 Confirm package contents before publishing and keep secrets out of fixtures, docs, logs, and config examples.
+
+Publishing uses npm trusted publishing from the `npm-production` GitHub environment. Provenance
+requires this GitHub repository to remain public. Before a release, configure npm's trusted
+publisher for package `@staticeng/opencode-litellm` with this repository, workflow
+`publish.yml`, and environment `npm-production`; no npm token is used by the workflow.

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-export { buildProvider, buildProviderV2, mapModels, mapModelsV2, mergeModelInfo, normalizeModelListResponse, modelListResponseShape, } from "./mapping.js";
+export { addOpenCodeVariantTombstones, buildProvider, buildProviderV2, isDeepSeekV4ReasoningModel, mapModels, mapModelsV2, mergeModelInfo, normalizeModelListResponse, modelListResponseShape, } from "./mapping.js";
 export { fetchModelGroupInfo, fetchModelInfo, normalizeModelGroupResponse } from "./litellm.js";
 export { modelGroupInfoURL, modelInfoURL } from "./options.js";
 export { deepMerge } from "./merge.js";

package/dist/helpers.js

@@ -1,4 +1,4 @@
-export { buildProvider, buildProviderV2, mapModels, mapModelsV2, mergeModelInfo, normalizeModelListResponse, modelListResponseShape, } from "./mapping.js";
+export { addOpenCodeVariantTombstones, buildProvider, buildProviderV2, isDeepSeekV4ReasoningModel, mapModels, mapModelsV2, mergeModelInfo, normalizeModelListResponse, modelListResponseShape, } from "./mapping.js";
 export { fetchModelGroupInfo, fetchModelInfo, normalizeModelGroupResponse } from "./litellm.js";
 export { modelGroupInfoURL, modelInfoURL } from "./options.js";
 export { deepMerge } from "./merge.js";

package/dist/index.d.ts

@@ -2,5 +2,18 @@ import type { Config, PluginInput } from "@opencode-ai/plugin";
 import type { LiteLLMPluginOptions } from "./types.js";
 declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOptions) => Promise<{
     config: (cfg: Config) => Promise<void>;
+    "chat.params": (input: {
+        sessionID: string;
+        agent: string;
+        model: import("@opencode-ai/sdk").Model;
+        provider: import("@opencode-ai/plugin").ProviderContext;
+        message: import("@opencode-ai/sdk").UserMessage;
+    }, output: {
+        temperature: number;
+        topP: number;
+        topK: number;
+        maxOutputTokens: number | undefined;
+        options: Record<string, any>;
+    }) => Promise<void>;
 }>;
 export default LiteLLMPlugin;

package/dist/index.js

@@ -1,5 +1,5 @@
 import { fetchModelGroupInfo, fetchModelInfo } from "./litellm.js";
-import { buildProvider, buildProviderV2, mergeModelInfo } from "./mapping.js";
+import { addOpenCodeVariantTombstones, buildProvider, buildProviderV2, isContractReasoningModel, mergeModelInfo, } from "./mapping.js";
 import { resolveOptions } from "./options.js";
 async function log(ctx, level, message, extra = {}) {
     await ctx.client?.app?.log?.({ body: { service: "opencode-litellm", level, message, extra } });
@@ -25,7 +25,7 @@ const LiteLLMPlugin = async (ctx, options) => {
                         throw error;
                 }
                 const models = mergeModelInfo(deployments, groups);
-                const provider = buildProvider(models, resolved);
+                const provider = addOpenCodeVariantTombstones(buildProvider(models, resolved));
                 const config = cfg;
                 const providerV2 = buildProviderV2(models, resolved);
                 cfg.provider = {
@@ -53,6 +53,14 @@ const LiteLLMPlugin = async (ctx, options) => {
                     throw error;
             }
         },
+        "chat.params": (async (input, output) => {
+            const provider = input.provider;
+            if ((provider.info?.id ?? provider.id) !== resolved.providerKey)
+                return;
+            if (!isContractReasoningModel(input.model.id))
+                return;
+            delete output.options.variantDefault;
+        }),
     };
 };
 export default LiteLLMPlugin;

package/dist/mapping.d.ts

@@ -10,6 +10,9 @@ export type ModelListResponseShape = {
 export declare function modelListResponseShape(value: unknown): ModelListResponseShape;
 export declare function mergeModelInfo(deployments: LiteLLMModelInfo[], groups: LiteLLMModelInfo[]): LiteLLMModelInfo[];
 export declare function normalizeModelListResponse(response: unknown): LiteLLMModelInfo[];
+export declare function isDeepSeekV4ReasoningModel(name: string | undefined): boolean;
+export declare function isContractReasoningModel(name: string | undefined): boolean;
+export declare function addOpenCodeVariantTombstones(provider: OpenCodeProvider): OpenCodeProvider;
 export declare function mapModels(response: unknown, options?: LiteLLMPluginOptions): {
     [k: string]: OpenCodeModel;
 };

package/dist/mapping.js

@@ -4,6 +4,37 @@ const NON_CHAT_MODES = new Set(["embedding", "rerank"]);
 const TEXT_MODALITY = "text";
 const OPENCODE_MODALITIES = new Set(["text", "audio", "image", "video", "pdf"]);
 const TEXT_ONLY_MODELS = new Set(["minimax-m2.7", "minimax_m2.7"]);
+const DEEPSEEK_V4_REASONING_MODELS = new Set([
+    "deepseek-v4-flash-fp8-mtp",
+    "deepseek-v4-flash-fp8-mtp-norefusal",
+]);
+const QWEN_38_REASONING_MODELS = new Set(["qwen3.8-27b-refusal-dial"]);
+const DEEPSEEK_V4_VARIANTS = {
+    off: { reasoningEffort: "none" },
+    low: { reasoningEffort: "low" },
+    high: { reasoningEffort: "high" },
+    max: { reasoningEffort: "max" },
+};
+const DEEPSEEK_V4_VARIANTS_V2 = [
+    { id: "off", body: { reasoning_effort: "none" } },
+    { id: "low", body: { reasoning_effort: "low" } },
+    { id: "high", body: { reasoning_effort: "high" } },
+    { id: "max", body: { reasoning_effort: "max" } },
+];
+const QWEN_38_VARIANTS = {
+    off: { chat_template_kwargs: { enable_thinking: false } },
+    low: { reasoningEffort: "low" },
+    medium: { reasoningEffort: "medium" },
+    xhigh: { reasoningEffort: "xhigh" },
+};
+const QWEN_38_VARIANTS_V2 = [
+    { id: "off", body: { chat_template_kwargs: { enable_thinking: false } } },
+    { id: "low", body: { reasoning_effort: "low" } },
+    { id: "medium", body: { reasoning_effort: "medium" } },
+    { id: "xhigh", body: { reasoning_effort: "xhigh" } },
+];
+const REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+const REASONING_EFFORT_SET = new Set(REASONING_EFFORTS);
 const NUMERIC_MODEL_INFO_FIELDS = new Set([
     "input_cost_per_token",
     "output_cost_per_token",
@@ -96,6 +127,9 @@ function enrichMetadata(existing, incoming, key) {
         }
         return merged;
     }
+    if (key === "supports_reasoning" && typeof existing === "boolean" && typeof incoming === "boolean") {
+        return existing && incoming;
+    }
     if (typeof existing === "boolean" && typeof incoming === "boolean")
         return existing || incoming;
     if (isValidMetadata(existing, key))
@@ -205,12 +239,12 @@ function v2Cost(model) {
 function limit(model) {
     const context = asNumber(model.model_info?.max_input_tokens) ?? asNumber(model.model_info?.max_tokens);
     const output = asNumber(model.model_info?.max_output_tokens) ?? asNumber(model.model_info?.max_tokens);
-    if (context === undefined || output === undefined)
+    if (context === undefined)
         return undefined;
     return {
         context,
         ...(asNumber(model.model_info?.max_input_tokens) === undefined ? {} : { input: asNumber(model.model_info?.max_input_tokens) }),
-        output,
+        output: output ?? 0,
     };
 }
 function canonicalModelName(model) {
@@ -240,10 +274,70 @@ function modalities(model) {
     };
 }
 function supportsReasoning(model) {
-    return Boolean(model.model_info?.supports_reasoning ||
-        model.model_info?.supported_params?.includes("reasoning_effort") ||
+    if (typeof model.model_info?.supports_reasoning === "boolean")
+        return model.model_info.supports_reasoning;
+    return Boolean(model.model_info?.supported_params?.includes("reasoning_effort") ||
         model.model_info?.supported_params?.includes("thinking"));
 }
+export function isDeepSeekV4ReasoningModel(name) {
+    return name !== undefined && DEEPSEEK_V4_REASONING_MODELS.has(name);
+}
+export function isContractReasoningModel(name) {
+    return isDeepSeekV4ReasoningModel(name) || (name !== undefined && QWEN_38_REASONING_MODELS.has(name));
+}
+function enforceReasoningVariants(model) {
+    const name = asString(model.id) ?? asString(model.name);
+    if (!isContractReasoningModel(name))
+        return model;
+    return {
+        ...model,
+        reasoning: true,
+        options: { ...(isRecord(model.options) ? model.options : {}), variantDefault: false },
+        variants: isDeepSeekV4ReasoningModel(name) ? DEEPSEEK_V4_VARIANTS : QWEN_38_VARIANTS,
+    };
+}
+function enforceReasoningProviderModels(provider) {
+    return {
+        ...provider,
+        models: Object.fromEntries(Object.entries(provider.models).map(([name, model]) => [
+            name,
+            isContractReasoningModel(name) ? enforceReasoningVariants({ ...model, id: name }) : model,
+        ])),
+    };
+}
+export function addOpenCodeVariantTombstones(provider) {
+    return {
+        ...provider,
+        models: Object.fromEntries(Object.entries(provider.models).map(([name, model]) => [
+            name,
+            isContractReasoningModel(name)
+                ? {
+                    ...model,
+                    variants: {
+                        ...(isDeepSeekV4ReasoningModel(name) ? DEEPSEEK_V4_VARIANTS : QWEN_38_VARIANTS),
+                        ...(isDeepSeekV4ReasoningModel(name)
+                            ? { medium: { disabled: true }, xhigh: { disabled: true } }
+                            : {
+                                none: { disabled: true },
+                                minimal: { disabled: true },
+                                high: { disabled: true },
+                                max: { disabled: true },
+                            }),
+                    },
+                }
+                : model,
+        ])),
+    };
+}
+function reasoningVariants(model) {
+    const reported = new Set((model.model_info?.supported_reasoning_efforts ?? [])
+        .map((effort) => asString(effort)?.toLowerCase())
+        .filter((effort) => effort !== undefined && REASONING_EFFORT_SET.has(effort)));
+    const efforts = REASONING_EFFORTS.filter((effort) => reported.has(effort));
+    if (!efforts.length)
+        return undefined;
+    return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]));
+}
 function generatedModel(model) {
     const name = modelName(model);
     if (!name)
@@ -258,6 +352,7 @@ function generatedModel(model) {
         modalities: mappedModalities,
         ...(mappedModalities.input.includes("image") || mappedModalities.input.includes("pdf") ? { attachment: true } : {}),
         ...(supportsReasoning(model) ? { reasoning: true } : {}),
+        ...(supportsReasoning(model) && reasoningVariants(model) ? { variants: reasoningVariants(model) } : {}),
         ...(model.model_info?.supports_function_calling || model.model_info?.supports_tool_choice ? { tool_call: true } : {}),
     };
 }
@@ -306,6 +401,7 @@ function v2Model(model, baseURL) {
             input: supportedModalities(model.modalities?.input ?? [TEXT_MODALITY]),
             output: supportedModalities(model.modalities?.output ?? [TEXT_MODALITY]),
         },
+        ...(isRecord(model.options) ? { options: { ...model.options } } : {}),
         ...(v2Cost(model) ? { cost: v2Cost(model) } : {}),
         ...(model.limit ? { limit: { ...model.limit } } : {}),
         ...(v2Variants(model) ? { variants: v2Variants(model) } : {}),
@@ -319,13 +415,16 @@ export function mapModels(response, options = {}) {
         const name = modelName(model);
         const generated = generatedModel(model);
         return name && generated
-            ? [name, finalizedModel(deepMerge(generated, options.overrides?.[name]), options.overrides?.[name])]
+            ? [
+                name,
+                enforceReasoningVariants(finalizedModel(deepMerge(generated, options.overrides?.[name]), options.overrides?.[name])),
+            ]
             : undefined;
     })
         .filter((entry) => Boolean(entry)));
 }
 export function buildProvider(models, options = {}) {
-    return deepMerge({
+    return enforceReasoningProviderModels(deepMerge({
         id: options.providerKey ?? "LiteLLM",
         name: options.providerName ?? "LiteLLM",
         npm: "@ai-sdk/openai-compatible",
@@ -336,14 +435,14 @@ export function buildProvider(models, options = {}) {
             ...(options.apiKey ? { body: { apiKey: options.apiKey } } : {}),
         },
         models: mapModels(models, options),
-    }, options.providerOverrides);
+    }, options.providerOverrides));
 }
 export function mapModelsV2(models, options = {}) {
     const legacy = mapModels(models, options);
     return Object.fromEntries(Object.entries(legacy).map(([name, model]) => [name, v2Model(model, options.baseURL)]));
 }
 export function buildProviderV2(models, options = {}) {
-    return deepMerge({
+    const provider = deepMerge({
         name: options.providerName ?? "LiteLLM",
         api: {
             type: "aisdk",
@@ -358,4 +457,24 @@ export function buildProviderV2(models, options = {}) {
         },
         models: mapModelsV2(models, options),
     }, options.providerOverrides);
+    return {
+        ...provider,
+        models: Object.fromEntries(Object.entries(provider.models).map(([name, model]) => [
+            name,
+            isContractReasoningModel(name)
+                ? {
+                    ...model,
+                    capabilities: {
+                        tools: model.capabilities?.tools ?? false,
+                        reasoning: true,
+                        attachment: model.capabilities?.attachment ?? false,
+                        input: model.capabilities?.input ?? [TEXT_MODALITY],
+                        output: model.capabilities?.output ?? [TEXT_MODALITY],
+                    },
+                    options: { ...(isRecord(model.options) ? model.options : {}), variantDefault: false },
+                    variants: isDeepSeekV4ReasoningModel(name) ? DEEPSEEK_V4_VARIANTS_V2 : QWEN_38_VARIANTS_V2,
+                }
+                : model,
+        ])),
+    };
 }

package/dist/types.d.ts

@@ -20,6 +20,7 @@ export type OpenCodeModel = JsonObject & {
     attachment?: boolean;
     reasoning?: boolean;
     tool_call?: boolean;
+    variants?: Record<string, JsonObject>;
 };
 export type OpenCodeModelV2 = JsonObject & {
     family?: string;
@@ -120,6 +121,10 @@ export type LiteLLMModelInfo = JsonObject & {
         supports_vision?: boolean;
         supports_pdf_input?: boolean;
         supports_reasoning?: boolean;
+        supported_reasoning_efforts?: string[];
+        supports_low_reasoning_effort?: boolean;
+        supports_xhigh_reasoning_effort?: boolean;
+        supports_max_reasoning_effort?: boolean;
         supported_modalities?: string[];
         output_modalities?: string[];
         supported_params?: string[];
@@ -145,6 +150,7 @@ export type LiteLLMModelGroup = JsonObject & {
     supports_vision?: boolean;
     supports_pdf_input?: boolean;
     supports_reasoning?: boolean;
+    supported_reasoning_efforts?: string[];
     supported_modalities?: string[];
     output_modalities?: string[];
     supported_openai_params?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staticeng/opencode-litellm",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "OpenCode plugin that discovers LiteLLM models at runtime.",
   "type": "module",
   "license": "MIT",