@staticeng/opencode-litellm 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOp
     config: (cfg: Config) => Promise<void>;
 }>;
 export default LiteLLMPlugin;
-export { buildProvider, mapModels } from "./mapping.js";
+export { buildProvider, mapModels, normalizeModelListResponse, modelListResponseShape, LiteLLMModelListResponseError } from "./mapping.js";
 export { fetchModelInfo } from "./litellm.js";
 export { deepMerge } from "./merge.js";
 export type { LiteLLMPluginOptions, LiteLLMModelInfo, OpenCodeProvider, OpenCodeModel } from "./types.js";

package/dist/index.js

@@ -21,9 +21,11 @@ export const LiteLLMPlugin = async (ctx, options) => {
                 });
             }
             catch (error) {
+                const errorShape = error instanceof Error && "responseShape" in error ? error.responseShape : undefined;
                 await log(ctx, resolved.strict ? "error" : "warn", "failed to load LiteLLM provider metadata", {
                     providerKey: resolved.providerKey,
                     error: error instanceof Error ? error.message : String(error),
+                    ...(errorShape ? { responseShape: errorShape } : {}),
                 });
                 if (resolved.strict)
                     throw error;
@@ -32,6 +34,6 @@ export const LiteLLMPlugin = async (ctx, options) => {
     };
 };
 export default LiteLLMPlugin;
-export { buildProvider, mapModels } from "./mapping.js";
+export { buildProvider, mapModels, normalizeModelListResponse, modelListResponseShape, LiteLLMModelListResponseError } from "./mapping.js";
 export { fetchModelInfo } from "./litellm.js";
 export { deepMerge } from "./merge.js";

package/dist/litellm.d.ts

@@ -1,3 +1,2 @@
 import { type ResolvedOptions } from "./options.js";
-import type { LiteLLMModelInfo } from "./types.js";
-export declare function fetchModelInfo(options: ResolvedOptions, fetchImpl?: typeof fetch): Promise<LiteLLMModelInfo[]>;
+export declare function fetchModelInfo(options: ResolvedOptions, fetchImpl?: typeof fetch): Promise<import("./types.js").LiteLLMModelInfo[]>;

package/dist/litellm.js

@@ -1,7 +1,5 @@
+import { normalizeModelListResponse } from "./mapping.js";
 import { modelInfoURL } from "./options.js";
-function isModelInfoArray(value) {
-    return Array.isArray(value);
-}
 export async function fetchModelInfo(options, fetchImpl = fetch) {
     if (!options.baseURL)
         throw new Error("opencode-litellm requires options.baseURL or LITELLM_BASE_URL");
@@ -20,12 +18,7 @@ export async function fetchModelInfo(options, fetchImpl = fetch) {
         });
         if (!response.ok)
             throw new Error(`LiteLLM /model/info returned HTTP ${response.status}`);
-        const body = (await response.json());
-        if (isModelInfoArray(body))
-            return body;
-        if (isModelInfoArray(body.data))
-            return body.data;
-        throw new Error("LiteLLM /model/info response did not contain a data array");
+        return normalizeModelListResponse(await response.json());
     }
     finally {
         clearTimeout(timeout);

package/dist/mapping.d.ts

@@ -1,5 +1,19 @@
 import type { LiteLLMModelInfo, LiteLLMPluginOptions, OpenCodeModel, OpenCodeProvider } from "./types.js";
-export declare function mapModels(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): {
+export type ModelListResponseShape = {
+    type: string;
+    length?: number;
+    keyCount?: number;
+    arrayFields?: string[];
+    objectValueCount?: number;
+    scalarValueCount?: number;
+};
+export declare function modelListResponseShape(value: unknown): ModelListResponseShape;
+export declare class LiteLLMModelListResponseError extends Error {
+    responseShape: ModelListResponseShape;
+    constructor(response: unknown);
+}
+export declare function normalizeModelListResponse(response: unknown): LiteLLMModelInfo[];
+export declare function mapModels(response: unknown, options?: LiteLLMPluginOptions): {
     [k: string]: OpenCodeModel;
 };
-export declare function buildProvider(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): OpenCodeProvider;
+export declare function buildProvider(models: unknown, options?: LiteLLMPluginOptions): OpenCodeProvider;

package/dist/mapping.js

@@ -2,6 +2,54 @@ import { deepMerge } from "./merge.js";
 const DEFAULT_MODES = new Set(["chat", "responses"]);
 const NON_CHAT_MODES = new Set(["embedding", "rerank"]);
 const TEXT_MODALITY = "text";
+const TEXT_ONLY_MODELS = new Set(["minimax-m2.7", "minimax_m2.7"]);
+const MODEL_LIST_RESPONSE_ERROR_MESSAGE = "LiteLLM model list response did not contain a model array";
+const MODEL_ARRAY_FIELDS = ["data", "models", "model_info"];
+const MODEL_INFO_FIELDS = new Set([
+    "id",
+    "base_model",
+    "mode",
+    "input_cost_per_token",
+    "output_cost_per_token",
+    "max_tokens",
+    "max_input_tokens",
+    "max_output_tokens",
+    "supports_function_calling",
+    "supports_tool_choice",
+    "supports_vision",
+    "supports_pdf_input",
+    "supports_reasoning",
+    "supported_modalities",
+    "output_modalities",
+    "supported_params",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function modelListResponseShape(value) {
+    if (Array.isArray(value))
+        return { type: "array", length: value.length };
+    if (value === null)
+        return { type: "null" };
+    if (!isRecord(value))
+        return { type: typeof value };
+    const values = Object.values(value);
+    return {
+        type: "object",
+        keyCount: Object.keys(value).length,
+        arrayFields: MODEL_ARRAY_FIELDS.filter((field) => Array.isArray(value[field])),
+        objectValueCount: values.filter(isRecord).length,
+        scalarValueCount: values.filter((entry) => !isRecord(entry) && !Array.isArray(entry)).length,
+    };
+}
+export class LiteLLMModelListResponseError extends Error {
+    responseShape;
+    constructor(response) {
+        super(MODEL_LIST_RESPONSE_ERROR_MESSAGE);
+        this.name = "LiteLLMModelListResponseError";
+        this.responseShape = modelListResponseShape(response);
+    }
+}
 function asString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
@@ -19,6 +67,44 @@ function unique(values) {
 function modelName(model) {
     return asString(model.model_name) ?? asString(model.litellm_params?.model) ?? asString(model.model_info?.id);
 }
+function hasModelInfoFields(value) {
+    return Object.keys(value).some((key) => MODEL_INFO_FIELDS.has(key));
+}
+function isPlausibleMappedModel(value) {
+    if (isRecord(value.model_info) && hasModelInfoFields(value.model_info))
+        return true;
+    if (isRecord(value.litellm_params) && typeof value.litellm_params.model === "string")
+        return true;
+    return hasModelInfoFields(value);
+}
+function normalizeMappedModel(name, value) {
+    if (!isRecord(value))
+        return undefined;
+    const model = value;
+    if (modelName(model))
+        return model;
+    if (!isPlausibleMappedModel(value))
+        return undefined;
+    return { ...model, model_name: name };
+}
+export function normalizeModelListResponse(response) {
+    if (Array.isArray(response))
+        return response;
+    if (isRecord(response)) {
+        for (const field of MODEL_ARRAY_FIELDS) {
+            if (Array.isArray(response[field]))
+                return response[field];
+        }
+        if (MODEL_ARRAY_FIELDS.some((field) => field in response))
+            throw new LiteLLMModelListResponseError(response);
+        const mappedModels = Object.entries(response)
+            .map(([name, value]) => normalizeMappedModel(name, value))
+            .filter((model) => Boolean(model));
+        if (mappedModels.length > 0)
+            return mappedModels;
+    }
+    throw new LiteLLMModelListResponseError(response);
+}
 function mode(model) {
     return asString(model.model_info?.mode) ?? "chat";
 }
@@ -62,7 +148,22 @@ function limit(model) {
         output,
     };
 }
+function canonicalModelName(model) {
+    const name = modelName(model);
+    const base = asString(model.model_info?.base_model);
+    const id = asString(model.model_info?.id);
+    return [name, base, id].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
+}
+function isTextOnlyModel(model) {
+    return canonicalModelName(model).some((name) => TEXT_ONLY_MODELS.has(name));
+}
 function modalities(model) {
+    if (isTextOnlyModel(model)) {
+        return {
+            input: [TEXT_MODALITY],
+            output: [TEXT_MODALITY],
+        };
+    }
     return {
         input: unique([
             TEXT_MODALITY,
@@ -95,7 +196,8 @@ function generatedModel(model) {
         ...(model.model_info?.supports_function_calling || model.model_info?.supports_tool_choice ? { tool_call: true } : {}),
     };
 }
-export function mapModels(models, options = {}) {
+export function mapModels(response, options = {}) {
+    const models = normalizeModelListResponse(response);
     return Object.fromEntries(models
         .filter((model) => allowedByFilters(model, options))
         .map((model) => {

package/dist/types.d.ts

@@ -69,8 +69,10 @@ export type LiteLLMModelInfo = JsonObject & {
         supported_params?: string[];
     };
 };
-export type LiteLLMModelInfoResponse = {
+export type LiteLLMModelInfoResponse = LiteLLMModelInfo[] | {
     data?: LiteLLMModelInfo[];
+    models?: LiteLLMModelInfo[];
+    model_info?: LiteLLMModelInfo[];
 };
 export type OpenCodeConfig = {
     provider?: Record<string, OpenCodeProvider>;

package/package.json

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