@staticeng/opencode-litellm 0.1.3 → 0.1.5

package/dist/helpers.d.ts

@@ -1,4 +1,4 @@
-export { buildProvider, mapModels, normalizeModelListResponse, modelListResponseShape } from "./mapping.js";
+export { buildProvider, buildProviderV2, mapModels, mapModelsV2 } from "./mapping.js";
 export { fetchModelInfo } from "./litellm.js";
 export { deepMerge } from "./merge.js";
-export type { LiteLLMPluginOptions, LiteLLMModelInfo, OpenCodeProvider, OpenCodeModel } from "./types.js";
+export type { LiteLLMModelInfo, LiteLLMPluginOptions, OpenCodeModel, OpenCodeModelV2, OpenCodeProvider, OpenCodeProviderV2, } from "./types.js";

package/dist/helpers.js

@@ -1,3 +1,3 @@
-export { buildProvider, mapModels, normalizeModelListResponse, modelListResponseShape } from "./mapping.js";
+export { buildProvider, buildProviderV2, mapModels, mapModelsV2 } from "./mapping.js";
 export { fetchModelInfo } from "./litellm.js";
 export { deepMerge } from "./merge.js";

package/dist/index.d.ts

@@ -4,4 +4,3 @@ declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOptions)
     config: (cfg: Config) => Promise<void>;
 }>;
 export default LiteLLMPlugin;
-export type { LiteLLMPluginOptions, LiteLLMModelInfo, OpenCodeProvider, OpenCodeModel } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { fetchModelInfo } from "./litellm.js";
-import { buildProvider } from "./mapping.js";
+import { buildProvider, buildProviderV2 } 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 } });
@@ -11,21 +11,26 @@ const LiteLLMPlugin = async (ctx, options) => {
             try {
                 const models = await fetchModelInfo(resolved);
                 const provider = buildProvider(models, resolved);
+                const config = cfg;
+                const providerV2 = buildProviderV2(models, resolved);
                 cfg.provider = {
                     ...(cfg.provider ?? {}),
                     [resolved.providerKey]: provider,
                 };
+                config.providers = {
+                    ...(config.providers ?? {}),
+                    [resolved.providerKey]: providerV2,
+                };
                 await log(ctx, "info", "loaded LiteLLM provider metadata", {
                     providerKey: resolved.providerKey,
                     modelCount: Object.keys(provider.models ?? {}).length,
+                    configProviderV2: true,
                 });
             }
             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;

package/dist/litellm.d.ts

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

package/dist/litellm.js

@@ -1,5 +1,7 @@
-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");
@@ -18,7 +20,12 @@ export async function fetchModelInfo(options, fetchImpl = fetch) {
         });
         if (!response.ok)
             throw new Error(`LiteLLM /model/info returned HTTP ${response.status}`);
-        return normalizeModelListResponse(await response.json());
+        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");
     }
     finally {
         clearTimeout(timeout);

package/dist/mapping.d.ts

@@ -1,15 +1,9 @@
-import type { LiteLLMModelInfo, LiteLLMPluginOptions, OpenCodeModel, OpenCodeProvider } from "./types.js";
-export type ModelListResponseShape = {
-    type: string;
-    length?: number;
-    keyCount?: number;
-    arrayFields?: string[];
-    objectValueCount?: number;
-    scalarValueCount?: number;
-};
-export declare function modelListResponseShape(value: unknown): ModelListResponseShape;
-export declare function normalizeModelListResponse(response: unknown): LiteLLMModelInfo[];
-export declare function mapModels(response: unknown, options?: LiteLLMPluginOptions): {
+import type { LiteLLMModelInfo, LiteLLMPluginOptions, OpenCodeModel, OpenCodeModelV2, OpenCodeProvider, OpenCodeProviderV2 } from "./types.js";
+export declare function mapModels(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): {
     [k: string]: OpenCodeModel;
 };
-export declare function buildProvider(models: unknown, options?: LiteLLMPluginOptions): OpenCodeProvider;
+export declare function buildProvider(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): OpenCodeProvider;
+export declare function mapModelsV2(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): {
+    [k: string]: OpenCodeModelV2;
+};
+export declare function buildProviderV2(models: LiteLLMModelInfo[], options?: LiteLLMPluginOptions): OpenCodeProviderV2;

package/dist/mapping.js

@@ -3,51 +3,6 @@ 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,
-    };
-}
-function modelListResponseError(response) {
-    return Object.assign(new Error(MODEL_LIST_RESPONSE_ERROR_MESSAGE), {
-        name: "LiteLLMModelListResponseError",
-        responseShape: modelListResponseShape(response),
-    });
-}
 function asString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
@@ -65,44 +20,6 @@ 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 modelListResponseError(response);
-        const mappedModels = Object.entries(response)
-            .map(([name, value]) => normalizeMappedModel(name, value))
-            .filter((model) => Boolean(model));
-        if (mappedModels.length > 0)
-            return mappedModels;
-    }
-    throw modelListResponseError(response);
-}
 function mode(model) {
     return asString(model.model_info?.mode) ?? "chat";
 }
@@ -135,6 +52,22 @@ function cost(model) {
             : { cache_read: perMillion(model.model_info?.cache_read_input_token_cost) }),
     };
 }
+function v2Cost(model) {
+    if (!model.cost)
+        return undefined;
+    return {
+        input: model.cost.input,
+        output: model.cost.output,
+        ...(!model.cost.cache_read && !model.cost.cache_write
+            ? {}
+            : {
+                cache: {
+                    ...(model.cost.cache_read === undefined ? {} : { read: model.cost.cache_read }),
+                    ...(model.cost.cache_write === undefined ? {} : { write: model.cost.cache_write }),
+                },
+            }),
+    };
+}
 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);
@@ -183,7 +116,7 @@ function generatedModel(model) {
         return undefined;
     const mappedModalities = modalities(model);
     return {
-        id: asString(model.model_info?.id) ?? name,
+        id: name,
         name,
         ...(asString(model.model_info?.base_model) ? { family: asString(model.model_info?.base_model) } : {}),
         ...(cost(model) ? { cost: cost(model) } : {}),
@@ -194,8 +127,43 @@ function generatedModel(model) {
         ...(model.model_info?.supports_function_calling || model.model_info?.supports_tool_choice ? { tool_call: true } : {}),
     };
 }
-export function mapModels(response, options = {}) {
-    const models = normalizeModelListResponse(response);
+function v2Variants(model) {
+    const variants = model.variants;
+    if (!variants || typeof variants !== "object" || Array.isArray(variants))
+        return undefined;
+    return Object.entries(variants).map(([id, value]) => {
+        const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+        const body = raw.options && typeof raw.options === "object" && !Array.isArray(raw.options)
+            ? raw.options
+            : raw;
+        return { id, body };
+    });
+}
+function v2Model(model, baseURL) {
+    const id = asString(model.id) ?? asString(model.name);
+    const name = asString(model.name);
+    const family = asString(model.family);
+    return {
+        ...(family ? { family } : {}),
+        ...(name ? { name } : {}),
+        api: {
+            ...(id ? { id } : {}),
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            ...(baseURL ? { url: baseURL } : {}),
+            settings: {},
+        },
+        capabilities: {
+            tools: model.tool_call ?? false,
+            input: model.modalities?.input ?? [TEXT_MODALITY],
+            output: model.modalities?.output ?? [TEXT_MODALITY],
+        },
+        ...(v2Cost(model) ? { cost: v2Cost(model) } : {}),
+        ...(model.limit ? { limit: { ...model.limit } } : {}),
+        ...(v2Variants(model) ? { variants: v2Variants(model) } : {}),
+    };
+}
+export function mapModels(models, options = {}) {
     return Object.fromEntries(models
         .filter((model) => allowedByFilters(model, options))
         .map((model) => {
@@ -218,3 +186,24 @@ export function buildProvider(models, options = {}) {
         models: mapModels(models, options),
     }, 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 {
+        name: options.providerName ?? "LiteLLM",
+        api: {
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            ...(options.baseURL ? { url: options.baseURL } : {}),
+            settings: {},
+        },
+        request: {
+            body: {
+                ...(options.apiKey ? { apiKey: options.apiKey } : {}),
+            },
+        },
+        models: mapModelsV2(models, options),
+    };
+}

package/dist/types.d.ts

@@ -21,6 +21,46 @@ export type OpenCodeModel = JsonObject & {
     reasoning?: boolean;
     tool_call?: boolean;
 };
+export type OpenCodeModelV2 = JsonObject & {
+    family?: string;
+    name?: string;
+    api?: {
+        id?: string;
+        type: "aisdk";
+        package: string;
+        url?: string;
+        settings?: JsonObject;
+    };
+    capabilities?: {
+        tools: boolean;
+        input: string[];
+        output: string[];
+    };
+    request?: {
+        headers?: Record<string, string>;
+        body?: JsonObject;
+        variant?: string;
+    };
+    variants?: Array<{
+        id: string;
+        headers?: Record<string, string>;
+        body?: JsonObject;
+    }>;
+    cost?: {
+        input: number;
+        output: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    };
+    disabled?: boolean;
+    limit?: {
+        context?: number;
+        input?: number;
+        output?: number;
+    };
+};
 export type OpenCodeProvider = JsonObject & {
     id?: string;
     name?: string;
@@ -29,6 +69,20 @@ export type OpenCodeProvider = JsonObject & {
     options?: JsonObject;
     models: Record<string, OpenCodeModel>;
 };
+export type OpenCodeProviderV2 = JsonObject & {
+    name?: string;
+    api: {
+        type: "aisdk";
+        package: string;
+        url?: string;
+        settings?: JsonObject;
+    };
+    request: {
+        headers?: Record<string, string>;
+        body: JsonObject;
+    };
+    models: Record<string, OpenCodeModelV2>;
+};
 export type LiteLLMPluginOptions = {
     baseURL?: string;
     apiKey?: string;
@@ -69,13 +123,12 @@ export type LiteLLMModelInfo = JsonObject & {
         supported_params?: string[];
     };
 };
-export type LiteLLMModelInfoResponse = LiteLLMModelInfo[] | {
+export type LiteLLMModelInfoResponse = {
     data?: LiteLLMModelInfo[];
-    models?: LiteLLMModelInfo[];
-    model_info?: LiteLLMModelInfo[];
 };
 export type OpenCodeConfig = {
     provider?: Record<string, OpenCodeProvider>;
+    providers?: Record<string, OpenCodeProviderV2>;
 };
 export type PluginContext = {
     client?: {

package/package.json

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