pi-provider-litellm 2.0.1 → 2.0.3

package/dist/discover.js

@@ -85,6 +85,8 @@ function catalogLookupIds(id) {
     const match = /^(?:claude-)?(opus|sonnet|haiku)-(\d+)-(\d+)$/.exec(anthropicAlias);
     if (match)
         lookupIds.add(`claude-${match[1]}-${match[2]}-${match[3]}`);
+    if (anthropicAlias === "fable-5")
+        lookupIds.add("claude-fable-5");
     return [...lookupIds];
 }
 function findCatalogModelInProvider(provider, lookupIds) {
@@ -439,8 +441,31 @@ export async function discoverModels(baseUrl, apiKey, options = {}) {
                 model_info: { ...previous?.model_info, ...entry.model_info },
             });
         }
-        const models = [...entries.values()].map(mapFromModelInfo).filter((m) => m !== undefined);
-        return { source: "model_info", models };
+        let models = [...entries.values()].map(mapFromModelInfo).filter((m) => m !== undefined);
+        // LiteLLM's /model/info does NOT expand wildcard model_name entries (e.g.
+        // "lemonade/*" backed by model: openai/* + check_provider_endpoint: true)
+        // — it returns the literal wildcard only. The discovered ids live in
+        // /v1/models instead. When /model/info contains any wildcard id, also query
+        // /v1/models and merge the expanded (non-wildcard) entries in, dropping the
+        // raw wildcard row so it doesn't surface as a phantom model choice.
+        // Ref: docs.litellm.ai/docs/proxy/model_discovery
+        if (models.some((m) => m.id.includes("*"))) {
+            progress?.("/model/info has wildcard entries, expanding via /v1/models...");
+            let modelsDev;
+            if (options.modelsDev !== false) {
+                progress?.("Loading models.dev catalog for metadata enrichment...");
+                modelsDev = await getModelsDevCatalog(options);
+            }
+            const listResult = await fetchJson(`${base}/v1/models`, apiKey, options);
+            if (listResult.ok) {
+                const expanded = (listResult.data.data ?? [])
+                    .map((entry) => mapFromModelsList(entry, modelsDev))
+                    .filter((m) => m !== undefined && !m.id.includes("*"));
+                const seen = new Set(models.map((m) => m.id));
+                models = [...models.filter((m) => !m.id.includes("*")), ...expanded.filter((m) => !seen.has(m.id))];
+            }
+        }
+        return { source: "model_info", models: deduplicateModels(models) };
     }
     if (![401, 403, 404].includes(infoResult.status)) {
         throw new Error(`/model/info returned ${infoResult.status}`);

package/dist/index.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { setupLiteLLMCostTracking } from "./cost.js";
-import { discoverModels, isGpt55Model, normalizeBaseUrl, shouldSuppressReasoningContent } from "./discover.js";
+import { discoverModels, isGpt55Model, isMoonshotModel, normalizeBaseUrl, shouldSuppressReasoningContent, } from "./discover.js";
 import { getGcloudToken, getGcloudTokenCacheKey, getGcloudTokenCommand, isGcloudTokenAuthEnabled, } from "./gcloud-token.js";
 import { getSessionIdFromFile } from "./litellm.js";
 import { createMcpToolDefinitions } from "./mcp-tools.js";
@@ -579,6 +579,56 @@ function createProviderAuth(definition) {
 function isReasoningItem(item) {
     return typeof item === "object" && item !== null && item.type === "reasoning";
 }
+// Returns the original array reference when no normalization is needed.
+function normalizeStrictToolMessages(messages) {
+    const normalized = [];
+    let imageParts = [];
+    let changed = false;
+    const flushImages = () => {
+        if (imageParts.length === 0)
+            return;
+        normalized.push({
+            role: "user",
+            content: [{ type: "text", text: "Attached image(s) from tool result:" }, ...imageParts],
+        });
+        imageParts = [];
+    };
+    for (const message of messages) {
+        if (message.role !== "tool")
+            flushImages();
+        if (message.role === "assistant" &&
+            Array.isArray(message.tool_calls) &&
+            message.tool_calls.length > 0 &&
+            message.content == null) {
+            normalized.push({ ...message, content: "" });
+            changed = true;
+        }
+        else if (message.role === "tool" && Array.isArray(message.content)) {
+            const previousImageCount = imageParts.length;
+            const content = message.content
+                .map((part) => {
+                if (typeof part === "string")
+                    return part;
+                if (part?.type === "text")
+                    return part.text || "";
+                if (part?.type === "image_url")
+                    imageParts.push(part);
+                return "";
+            })
+                .join("");
+            normalized.push({
+                ...message,
+                content: content || (imageParts.length > previousImageCount ? "(see attached image)" : "(no tool output)"),
+            });
+            changed = true;
+        }
+        else {
+            normalized.push(message);
+        }
+    }
+    flushImages();
+    return changed ? normalized : messages;
+}
 // Reasoning fields LiteLLM forwards to chat-completions providers. The Moonshot
 // path defaults them off; the gpt-5.5 tool path strips them entirely.
 const REASONING_SUPPRESSION_DEFAULTS = {
@@ -587,6 +637,7 @@ const REASONING_SUPPRESSION_DEFAULTS = {
     merge_reasoning_content_in_choices: true,
     thinking: { type: "disabled" },
 };
+const GEMINI_MODEL_PATTERN = /(?:^|[-_/.:])gemini(?=$|[-_/.:])/i;
 function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
     let next;
     const update = (key, value) => {
@@ -596,8 +647,10 @@ function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
         next[key] = value;
     };
     if (api !== "openai-responses" && modelId && shouldSuppressReasoningContent(modelId)) {
-        for (const [key, value] of Object.entries(REASONING_SUPPRESSION_DEFAULTS))
-            update(key, value);
+        for (const [key, value] of Object.entries(REASONING_SUPPRESSION_DEFAULTS)) {
+            if (key !== "thinking")
+                update(key, value);
+        }
     }
     // LiteLLM still routes gpt-5.5 tool+reasoning requests through chat completions.
     // Drop reasoning until the gateway honors /v1/responses for this route.
@@ -630,6 +683,39 @@ function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
             next.input = input.filter((item) => !isReasoningItem(item));
         }
     }
+    // Moonshot/Kimi applies strict OpenAI schema validation: assistant tool calls
+    // must carry string content, and tool results must be plain text.
+    if (modelId && isMoonshotModel(modelId)) {
+        const messages = (next ?? payload).messages;
+        if (Array.isArray(messages)) {
+            const normalized = normalizeStrictToolMessages(messages);
+            if (normalized !== messages) {
+                next ??= { ...payload };
+                next.messages = normalized;
+            }
+        }
+    }
+    if (modelId && GEMINI_MODEL_PATTERN.test(modelId)) {
+        const currentPayload = next ?? payload;
+        if (typeof currentPayload.reasoning_effort === "string") {
+            const lower = currentPayload.reasoning_effort.toLowerCase();
+            if (currentPayload.reasoning_effort !== lower) {
+                next ??= { ...payload };
+                next.reasoning_effort = lower;
+            }
+        }
+        const reasoningPayload = next ?? payload;
+        if (isPlainObject(reasoningPayload.reasoning) && typeof reasoningPayload.reasoning.effort === "string") {
+            const lower = reasoningPayload.reasoning.effort.toLowerCase();
+            if (reasoningPayload.reasoning.effort !== lower) {
+                next ??= { ...payload };
+                next.reasoning = {
+                    ...next.reasoning,
+                    effort: lower,
+                };
+            }
+        }
+    }
     if (sessionId) {
         next ??= { ...payload };
         next.litellm_session_id = sessionId;
@@ -862,7 +948,11 @@ export default async function (pi) {
                     context.credential) {
                     const auth = await authForCredential(definition, context.credential);
                     defaultRuntimeAuth = auth;
-                    await registerMcpTools(auth, context.signal);
+                    const registration = registerMcpTools(auth, context.signal);
+                    if (context.signal)
+                        await registration;
+                    else
+                        void registration.catch(() => undefined);
                 }
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -65,8 +65,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.15",
-    "@earendil-works/pi-ai": "^0.81.1",
-    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-ai": "^0.82.1",
+    "@earendil-works/pi-coding-agent": "^0.82.1",
     "@kitlangton/terminal-control": "0.6.0",
     "@types/node": "^26.0.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",