pi-provider-litellm 1.2.1 → 1.2.2

package/dist/discover.d.ts

@@ -1,5 +1,7 @@
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { DiscoveryOptions, DiscoveryResult } from "./types.js";
 export declare function normalizeBaseUrl(input: string): string;
+export declare function isMoonshotModel(modelId: string): boolean;
+export declare function shouldSuppressReasoningContent(modelId: string): boolean;
 export declare function buildCompat(modelId: string): ProviderModelConfig["compat"];
 export declare function discoverModels(baseUrl: string, apiKey: string, options?: DiscoveryOptions): Promise<DiscoveryResult>;

package/dist/discover.js

@@ -11,8 +11,15 @@ export function normalizeBaseUrl(input) {
 // through the proxy, so prompt caching silently no-ops on Claude models.
 const ANTHROPIC_MODEL_PATTERN = /^(anthropic\/|claude|opus|sonnet|haiku)/i;
 const MOONSHOT_MODEL_PATTERN = /^(moonshotai\/|moonshot\/|kimi[-/])/i;
+const FORCED_THINKING_MODEL_PATTERN = /(?:^|[-/])thinking(?:[-/]|$)/i;
+export function isMoonshotModel(modelId) {
+    return MOONSHOT_MODEL_PATTERN.test(modelId);
+}
+export function shouldSuppressReasoningContent(modelId) {
+    return isMoonshotModel(modelId) && !FORCED_THINKING_MODEL_PATTERN.test(modelId);
+}
 export function buildCompat(modelId) {
-    if (MOONSHOT_MODEL_PATTERN.test(modelId)) {
+    if (isMoonshotModel(modelId)) {
         return {
             supportsStore: false,
             supportsDeveloperRole: false,

package/dist/index.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { AuthStorage, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { fingerprint, readCache, writeCache } from "./cache.js";
 import { setupLiteLLMCostTracking } from "./cost.js";
-import { discoverModels, normalizeBaseUrl } from "./discover.js";
+import { discoverModels, normalizeBaseUrl, shouldSuppressReasoningContent } from "./discover.js";
 import { getSessionIdFromFile } from "./litellm.js";
 const PROVIDER_NAME = "litellm";
 const ENV_BASE_URL = "LITELLM_BASE_URL";
@@ -109,6 +109,87 @@ function modifyLiteLLMModels(models, cred) {
         return models;
     return models.map((m) => (m.provider === PROVIDER_NAME ? { ...m, baseUrl: `${baseUrl}/v1` } : m));
 }
+function prepareLiteLLMRequestPayload(payload, modelId, sessionId) {
+    let next;
+    const update = (key, value) => {
+        if (payload[key] !== undefined)
+            return;
+        next ??= { ...payload };
+        next[key] = value;
+    };
+    if (modelId && shouldSuppressReasoningContent(modelId)) {
+        update("include_reasoning", false);
+        update("reasoning_content", false);
+        update("merge_reasoning_content_in_choices", true);
+        update("thinking", { type: "disabled" });
+    }
+    if (sessionId) {
+        next ??= { ...payload };
+        next.litellm_session_id = sessionId;
+    }
+    return next;
+}
+function normalizeThinkTags(message) {
+    if (message.provider !== PROVIDER_NAME || !shouldSuppressReasoningContent(message.model))
+        return;
+    let changed = false;
+    const content = [];
+    const appendText = (text) => {
+        if (!text)
+            return;
+        const last = content.at(-1);
+        if (last?.type === "text") {
+            last.text += text;
+            return;
+        }
+        content.push({ type: "text", text });
+    };
+    const appendThinking = (thinking) => {
+        if (!thinking)
+            return;
+        const last = content.at(-1);
+        if (last?.type === "thinking") {
+            last.thinking += thinking;
+            return;
+        }
+        content.push({ type: "thinking", thinking });
+    };
+    for (let blockIndex = 0; blockIndex < message.content.length; blockIndex++) {
+        const block = message.content[blockIndex];
+        if (block.type !== "text") {
+            content.push(block);
+            continue;
+        }
+        let index = 0;
+        while (index < block.text.length) {
+            const start = block.text.indexOf("<think>", index);
+            if (start === -1) {
+                appendText(block.text.slice(index));
+                break;
+            }
+            changed = true;
+            appendText(block.text.slice(index, start));
+            const thinkingStart = start + "<think>".length;
+            const end = block.text.indexOf("</think>", thinkingStart);
+            if (end === -1) {
+                const isBeforeNonTextContent = message.content
+                    .slice(blockIndex + 1)
+                    .some((nextBlock) => nextBlock.type !== "text");
+                if (isBeforeNonTextContent)
+                    appendThinking(block.text.slice(thinkingStart));
+                else
+                    appendText(block.text.slice(thinkingStart));
+                index = block.text.length;
+                break;
+            }
+            appendThinking(block.text.slice(thinkingStart, end));
+            index = end + "</think>".length;
+        }
+    }
+    if (!changed)
+        return;
+    return { ...message, content };
+}
 export default async function (pi) {
     const creds = await resolveCredentials();
     const cache = await readCache(getCachePath());
@@ -214,14 +295,19 @@ export default async function (pi) {
     pi.on("session_start", async (_event, ctx) => {
         sessionId = getSessionIdFromFile(ctx.sessionManager.getSessionFile());
     });
-    pi.on("before_provider_request", (event) => {
-        if (!sessionId)
+    pi.on("before_provider_request", (event, ctx) => {
+        if (ctx.model?.provider !== PROVIDER_NAME)
             return;
         if (typeof event.payload !== "object" || event.payload === null)
             return;
-        return {
-            ...event.payload,
-            litellm_session_id: sessionId,
-        };
+        return prepareLiteLLMRequestPayload(event.payload, ctx.model?.id, sessionId);
+    });
+    pi.on("message_end", (event) => {
+        if (event.message.role !== "assistant")
+            return;
+        const message = normalizeThinkTags(event.message);
+        if (!message)
+            return;
+        return { message };
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",