pi-provider-litellm 1.2.0 → 1.2.2

package/README.md

@@ -1,6 +1,6 @@
 # pi-provider-litellm
 
-LiteLLM proxy provider extension for [pi-mono](https://github.com/badlogic/pi-mono).
+LiteLLM proxy provider extension for [Pi](https://pi.dev).
 
 Discovers models from a self-hosted LiteLLM proxy and registers them under the `litellm` provider. Supports `/login litellm` and `/litellm-refresh`. Tries `/model/info` first (admin endpoint with rich metadata), falls back to `/v1/models` (OpenAI-compatible) on 401/403/404.
 
@@ -32,14 +32,7 @@ npm run build
 
 ## Configure
 
-### Option A — environment variables
-
-```bash
-export LITELLM_BASE_URL="https://litellm.your-domain.com"
-export LITELLM_API_KEY="sk-..."
-```
-
-### Option B — interactive login
+### Option A — interactive login
 
 Inside pi:
 
@@ -49,16 +42,21 @@ Inside pi:
 
 You'll be prompted for the base URL and API key. Credentials are persisted to `~/.pi/agent/auth.json`.
 
+### Option B — environment variables
+
+```bash
+export LITELLM_BASE_URL="https://litellm.your-domain.com"
+export LITELLM_API_KEY="sk-..."
+```
+
 Stored pi credentials for `litellm` take precedence over `LITELLM_API_KEY`; the environment key is used when no saved credential exists. `LITELLM_BASE_URL` is used when no saved login base URL exists.
 
 ## Use
 
 ```
-/model litellm/anthropic/claude-3-5-sonnet
+/model
 ```
 
-(Whatever model IDs your proxy exposes — see the discovered list at startup.)
-
 ## Optional environment variables
 
 | Variable | Default | Effect |
@@ -74,7 +72,7 @@ Stored pi credentials for `litellm` take precedence over `LITELLM_API_KEY`; the
 
 ## Cache
 
-The model list is cached at `~/.pi/agent/litellm-models.json` with a sha256 fingerprint of the base URL + API key. Changing either invalidates the cache automatically.
+The model list is cached at `~/.pi/agent/litellm-models.json` with a keyed fingerprint of the base URL + API key. Changing either invalidates the cache automatically.
 
 ## Troubleshooting
 

package/dist/cache.js

@@ -1,8 +1,9 @@
-import { createHash } from "node:crypto";
+import { scryptSync } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+const FINGERPRINT_SALT = "pi-provider-litellm-cache-fingerprint-v1";
 export function fingerprint(apiKey) {
-    return createHash("sha256").update(apiKey).digest("hex");
+    return scryptSync(apiKey, FINGERPRINT_SALT, 32).toString("hex");
 }
 export function isCacheValid(cache, baseUrl, apiKey) {
     if (!cache)

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

@@ -10,7 +10,24 @@ export function normalizeBaseUrl(input) {
 // `cacheControlFormat: "anthropic"` flag, pi never relays cache_control markers
 // 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 (isMoonshotModel(modelId)) {
+        return {
+            supportsStore: false,
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false,
+            supportsStrictMode: false,
+            maxTokensField: "max_tokens",
+        };
+    }
     if (ANTHROPIC_MODEL_PATTERN.test(modelId)) {
         return { supportsStore: false, cacheControlFormat: "anthropic" };
     }

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,7 +1,7 @@
 {
   "name": "pi-provider-litellm",
-  "version": "1.2.0",
-  "description": "LiteLLM proxy provider extension for pi-mono.",
+  "version": "1.2.2",
+  "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
   "author": "Dávid Balatoni <balcsida@gmail.com>",
@@ -57,6 +57,11 @@
     "@earendil-works/pi-ai": "^0.74.0",
     "@earendil-works/pi-coding-agent": "^0.74.0"
   },
+  "overrides": {
+    "basic-ftp": "6.0.1",
+    "fast-xml-builder": "1.2.0",
+    "protobufjs": "8.2.1"
+  },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.74.0",
     "@earendil-works/pi-coding-agent": "^0.74.0",