pi-provider-litellm 2.2.1 → 2.3.0

package/README.md

@@ -44,12 +44,14 @@ To configure an API key, run `/login`, choose `Sign in with an API key`, then ch
 
 You'll be prompted for the base URL and API key. Credentials are persisted to `~/.pi/agent/auth.json`.
 
+If a proxy URL is already known — from `providers.<name>.baseUrl`, `LITELLM_BASE_URL`, or a previous login — pi offers it as the first option instead of asking you to retype it. Pick `Enter a different URL…` to point at another proxy.
+
 #### Enterprise SSO login
 
 If your LiteLLM proxy requires SSO/OAuth authentication (enterprise deployments), you can authenticate through LiteLLM's CLI SSO flow:
 
 1. Run `/login litellm` inside pi and select `Sign in with LiteLLM SSO`
-2. Enter the proxy URL
+2. Confirm the offered proxy URL, or enter one if this is the first login
 3. Pi displays a verification code and opens the LiteLLM SSO login URL automatically
 4. Authenticate in the browser and confirm the displayed code
 5. If your account belongs to multiple teams, select the team for this session in Pi
@@ -236,6 +238,7 @@ Opening `/model` refreshes configured provider catalogs in the background using
 | Symptom | Likely cause |
 |---|---|
 | "no credentials" warning at startup | Env vars not set and no OAuth credential — run `/login litellm` |
+| `No models available` at startup, gone after a restart | A Pi startup race, not discovery — see [`No models available` at startup](#no-models-available-at-startup) |
 | "discovered no models" | Proxy returned an empty list — check pi's startup log and verify `/model/info`, `/v1/models`, or `/health` responds |
 | `/model/info` returning 401/403/404 | Expected behavior with virtual keys — extension falls back to `/v1/models` |
 | Discovery times out | Increase `LITELLM_DISCOVERY_TIMEOUT_MS` or set `LITELLM_OFFLINE=1` to fall back on cached models |
@@ -248,6 +251,27 @@ Opening `/model` refreshes configured provider catalogs in the background using
 | MCP tools not showing | Verify the proxy exposes `/mcp-rest/tools/list` and open `/model` after fixing the proxy |
 | Skills not affecting prompts | Verify the proxy exposes `/claude-code/marketplace.json` or `/v1/skills` and returns enabled skills |
 
+### `No models available` at startup
+
+Pi 0.84.0 and later can finish startup before the provider availability snapshot is written, so the
+initial model pick sees nothing even though discovery succeeded. The warning is intermittent and a
+restart usually clears it. Nothing is wrong with the catalog: `/model` in the same session still
+lists every discovered model, and picking one there fixes that session.
+
+Scoping models keeps selection off that path, because Pi resolves the scope with its own awaited
+availability pass before it picks a model. In `~/.pi/agent/settings.json`:
+
+```json
+{
+  "enabledModels": ["litellm/*"]
+}
+```
+
+Your `defaultProvider` and `defaultModel` still win as long as they match a pattern. `/model` then
+opens on the scoped list, with a toggle inside the picker for the full catalog.
+
+The extension cannot set this for you — Pi reads `enabledModels` before extensions activate.
+
 ## License
 
 MIT — see [LICENSE](./LICENSE).

package/dist/discover.d.ts

@@ -3,7 +3,7 @@ import type { DiscoveredModel, DiscoveryOptions, DiscoveryResult } from "./types
 export declare function normalizeBaseUrl(input: string, allowInsecureHttp?: boolean): string;
 export declare function isMoonshotModel(modelId: string): boolean;
 export declare function isGpt55Model(modelId: string): boolean;
-export declare function shouldSuppressReasoningContent(modelId: string): boolean;
+export declare function emitsThinkTags(modelId: string): boolean;
 export declare function buildCompat(modelId: string): DiscoveredModel["compat"];
 export declare function enrichCachedModel(model: Model<Api>): Model<Api>;
 export declare function discoverModels(baseUrl: string, apiKey: string, options?: DiscoveryOptions & {

package/dist/discover.js

@@ -38,7 +38,36 @@ export function isMoonshotModel(modelId) {
 export function isGpt55Model(modelId) {
     return GPT55_MODEL_PATTERN.test(modelId);
 }
-export function shouldSuppressReasoningContent(modelId) {
+const MOONSHOT_ROUTE_PROVIDERS = new Set(["moonshot", "moonshotai"]);
+function isMoonshotRoute(entry) {
+    const params = entry.litellm_params;
+    if (!params)
+        return false;
+    const model = params.model?.trim();
+    if (!model)
+        return false;
+    const providers = [
+        params.custom_llm_provider?.trim(),
+        model.includes("/") ? model.split("/", 1)[0] : undefined,
+    ].filter((provider) => Boolean(provider));
+    return providers.length > 0 && providers.every((provider) => MOONSHOT_ROUTE_PROVIDERS.has(provider.toLowerCase()));
+}
+function shouldSuppressReasoningContent(modelId, entry) {
+    const routeModelId = entry.litellm_params?.model;
+    return (isMoonshotRoute(entry) &&
+        !FORCED_THINKING_MODEL_PATTERN.test(modelId) &&
+        !(routeModelId && FORCED_THINKING_MODEL_PATTERN.test(routeModelId)));
+}
+function aggregateSuppressionEvidence(evidence) {
+    let hasEvidence = false;
+    for (const suppress of evidence) {
+        hasEvidence = true;
+        if (!suppress)
+            return false;
+    }
+    return hasEvidence;
+}
+export function emitsThinkTags(modelId) {
     return isMoonshotModel(modelId) && !FORCED_THINKING_MODEL_PATTERN.test(modelId);
 }
 export function buildCompat(modelId) {
@@ -172,7 +201,7 @@ function mapReasoningEfforts(info) {
         .map(([level, value, supported]) => [level, supported ? value : null]));
     return Object.keys(map).length > 0 ? map : undefined;
 }
-function mapFromModelInfo(entry) {
+function mapFromModelInfo(entry, suppressReasoningContent = shouldSuppressReasoningContent(entry.model_name ?? "", entry)) {
     const id = entry.model_name;
     if (!id)
         return undefined;
@@ -195,6 +224,7 @@ function mapFromModelInfo(entry) {
         contextWindow: info.max_input_tokens ?? DEFAULT_CONTEXT_WINDOW,
         maxTokens: info.max_output_tokens ?? DEFAULT_MAX_TOKENS,
         compat: buildCompat(id),
+        ...(suppressReasoningContent ? { suppressReasoningContent: true } : {}),
         ...(responsesMode ? { api: "openai-responses" } : {}),
     };
 }
@@ -266,12 +296,23 @@ async function discoverFromHealth(base, apiKey, options) {
     return models.filter((model) => model !== undefined);
 }
 function deduplicateModels(models) {
-    const seen = new Set();
-    return models.filter((m) => {
-        if (seen.has(m.id))
-            return false;
-        seen.add(m.id);
-        return true;
+    const entries = new Map();
+    for (const model of models) {
+        const existing = entries.get(model.id);
+        if (existing) {
+            existing.suppressions.push(model.suppressReasoningContent === true);
+        }
+        else {
+            entries.set(model.id, { model, suppressions: [model.suppressReasoningContent === true] });
+        }
+    }
+    return [...entries.values()].map(({ model, suppressions }) => {
+        const deduplicated = { ...model };
+        if (aggregateSuppressionEvidence(suppressions))
+            deduplicated.suppressReasoningContent = true;
+        else
+            delete deduplicated.suppressReasoningContent;
+        return deduplicated;
     });
 }
 export async function discoverModels(baseUrl, apiKey, options = {}) {
@@ -281,17 +322,23 @@ export async function discoverModels(baseUrl, apiKey, options = {}) {
     const infoResult = await fetchJson(`${base}/model/info`, apiKey, options);
     if (infoResult.ok) {
         const entries = new Map();
+        const suppressionEvidence = new Map();
         for (const entry of infoResult.data.data ?? []) {
             if (!entry.model_name)
                 continue;
             const previous = entries.get(entry.model_name);
+            const suppressions = suppressionEvidence.get(entry.model_name) ?? new Set();
+            suppressions.add(shouldSuppressReasoningContent(entry.model_name, entry));
+            suppressionEvidence.set(entry.model_name, suppressions);
             entries.set(entry.model_name, {
                 ...previous,
                 ...entry,
                 model_info: { ...previous?.model_info, ...entry.model_info },
             });
         }
-        let models = [...entries.values()].map(mapFromModelInfo).filter((m) => m !== undefined);
+        let models = [...entries.entries()]
+            .map(([id, entry]) => mapFromModelInfo(entry, aggregateSuppressionEvidence(suppressionEvidence.get(id))))
+            .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

package/dist/index.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { getAgentDir, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { setupLiteLLMCostTracking } from "./cost.js";
-import { discoverModels, isGpt55Model, isMoonshotModel, normalizeBaseUrl, shouldSuppressReasoningContent, } from "./discover.js";
+import { discoverModels, emitsThinkTags, isGpt55Model, isMoonshotModel, normalizeBaseUrl } from "./discover.js";
 import { getGcloudToken, getGcloudTokenCacheKey, getGcloudTokenCommand, isGcloudTokenAuthEnabled, } from "./gcloud-token.js";
 import { getSessionIdFromFile } from "./litellm.js";
 import { createMcpToolDefinitions } from "./mcp-tools.js";
@@ -406,7 +406,51 @@ function getProviderDefinitions(settings) {
     }
     return definitions;
 }
-async function loginApiKey(interaction, allowInsecureHttp = false) {
+const DIFFERENT_BASE_URL = "enter-a-different-url";
+/**
+ * The proxy URL is the one thing a user has to retype on every re-login, and an expired SSO token is
+ * the common reason to re-login. Offer whatever we already know: settings, env, or the credential the
+ * dead session was issued against.
+ */
+function knownBaseUrl(definition) {
+    const stored = readStoredCredential(definition.name, join(getAgentDir(), "auth.json"));
+    const candidates = [
+        [cleanConfig(definition.baseUrl), "configured"],
+        [definition.useDefaultEnv ? cleanConfig(process.env[ENV_BASE_URL]) : undefined, `$${ENV_BASE_URL}`],
+        [
+            stored?.type === "oauth"
+                ? cleanConfig(typeof stored.baseUrl === "string" ? stored.baseUrl : undefined)
+                : cleanConfig(stored?.env?.[ENV_BASE_URL]),
+            "previous login",
+        ],
+    ];
+    for (const [candidate, source] of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            return { url: normalizeBaseUrl(candidate, definition.allowInsecureHttp), source };
+        }
+        catch {
+            // A URL we could not use anyway is not worth offering; try the next candidate.
+        }
+    }
+    return undefined;
+}
+async function promptBaseUrl(interaction, definition) {
+    const known = knownBaseUrl(definition);
+    if (known) {
+        const choice = await interaction.prompt({
+            type: "select",
+            message: "LiteLLM proxy URL:",
+            // Pi's login selector renders labels only, so the source has to ride along in the label.
+            options: [
+                { id: known.url, label: `${known.url} (${known.source})` },
+                { id: DIFFERENT_BASE_URL, label: "Enter a different URL…" },
+            ],
+        });
+        if (choice === known.url)
+            return known.url;
+    }
     const rawBaseUrl = (await interaction.prompt({
         type: "text",
         message: "Enter LiteLLM proxy URL (no trailing /v1):",
@@ -414,10 +458,14 @@ async function loginApiKey(interaction, allowInsecureHttp = false) {
     })).trim();
     if (!rawBaseUrl)
         throw new Error("Base URL is required");
+    return normalizeBaseUrl(rawBaseUrl, definition.allowInsecureHttp);
+}
+async function loginApiKey(interaction, definition) {
+    const baseUrl = await promptBaseUrl(interaction, definition);
     const key = (await interaction.prompt({ type: "secret", message: "Enter API key:" })).trim();
     if (!key)
         throw new Error("Both base URL and API key are required");
-    return { type: "api_key", key, env: { [ENV_BASE_URL]: normalizeBaseUrl(rawBaseUrl, allowInsecureHttp) } };
+    return { type: "api_key", key, env: { [ENV_BASE_URL]: baseUrl } };
 }
 async function startCliSso(baseUrl, signal, headers) {
     const response = await fetch(`${baseUrl}/sso/cli/start`, {
@@ -560,15 +608,9 @@ async function loginWithPastedToken(interaction, baseUrl, headers) {
     }
     return { type: "oauth", access, refresh: "", expires, baseUrl };
 }
-async function loginOAuth(interaction, headers, allowInsecureHttp = false) {
-    const rawBaseUrl = (await interaction.prompt({
-        type: "text",
-        message: "Enter LiteLLM proxy URL (no trailing /v1):",
-        placeholder: "https://litellm.example.com",
-    })).trim();
-    if (!rawBaseUrl)
-        throw new Error("Base URL is required");
-    const baseUrl = normalizeBaseUrl(rawBaseUrl, allowInsecureHttp);
+async function loginOAuth(interaction, definition) {
+    const headers = resolveHeaders(definition);
+    const baseUrl = await promptBaseUrl(interaction, definition);
     const cliSso = await startCliSso(baseUrl, interaction.signal, headers);
     if (!cliSso)
         return loginWithPastedToken(interaction, baseUrl, headers);
@@ -666,9 +708,7 @@ function createProviderAuth(definition) {
     return {
         apiKey: {
             name: `${definition.displayName} API key`,
-            login: definition.name === PROVIDER_NAME
-                ? (interaction) => loginApiKey(interaction, definition.allowInsecureHttp)
-                : undefined,
+            login: definition.name === PROVIDER_NAME ? (interaction) => loginApiKey(interaction, definition) : undefined,
             check: async ({ ctx, credential }) => {
                 const baseUrl = credential?.env?.[ENV_BASE_URL] ??
                     definition.baseUrl ??
@@ -704,7 +744,7 @@ function createProviderAuth(definition) {
             ? {
                 name: "LiteLLM SSO",
                 loginLabel: "Sign in with LiteLLM SSO",
-                login: (interaction) => loginOAuth(interaction, resolveHeaders(definition), definition.allowInsecureHttp),
+                login: (interaction) => loginOAuth(interaction, definition),
                 refresh: async (credential, signal) => ({
                     ...(await refreshLiteLLM(credential, signal)),
                     type: "oauth",
@@ -782,7 +822,9 @@ const REASONING_SUPPRESSION_DEFAULTS = {
     thinking: { type: "disabled" },
 };
 const GEMINI_MODEL_PATTERN = /(?:^|[-_/.:])gemini(?=$|[-_/.:])/i;
-function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
+function prepareLiteLLMRequestPayload(payload, model, sessionId) {
+    const modelId = model?.id;
+    const api = model?.api;
     let next;
     const update = (key, value) => {
         if (payload[key] !== undefined)
@@ -790,7 +832,7 @@ function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
         next ??= { ...payload };
         next[key] = value;
     };
-    if (api !== "openai-responses" && modelId && shouldSuppressReasoningContent(modelId)) {
+    if (api !== "openai-responses" && model?.suppressReasoningContent === true) {
         for (const [key, value] of Object.entries(REASONING_SUPPRESSION_DEFAULTS)) {
             if (key !== "thinking")
                 update(key, value);
@@ -867,7 +909,7 @@ function prepareLiteLLMRequestPayload(payload, modelId, api, sessionId) {
     return next;
 }
 function normalizeThinkTags(message, litellmProviderNames) {
-    if (!litellmProviderNames.has(message.provider) || !shouldSuppressReasoningContent(message.model))
+    if (!litellmProviderNames.has(message.provider) || !emitsThinkTags(message.model))
         return;
     let changed = false;
     const content = [];
@@ -1146,7 +1188,7 @@ export default async function (pi) {
             return;
         if (typeof event.payload !== "object" || event.payload === null)
             return;
-        return prepareLiteLLMRequestPayload(event.payload, ctx.model?.id, ctx.model?.api, sessionId);
+        return prepareLiteLLMRequestPayload(event.payload, ctx.model, sessionId);
     });
     // Skills enrichment is best-effort: an expired credential or an unreachable proxy must not
     // report an extension error on every turn. The failing model request states the real problem.

package/dist/provider.d.ts

@@ -1,5 +1,5 @@
-import { type Credential, type Model, type Provider, type ProviderAuth } from "@earendil-works/pi-ai";
-import type { DiscoveredModel, DiscoveryResult, LiteLLMApi } from "./types.js";
+import { type Credential, type Provider, type ProviderAuth } from "@earendil-works/pi-ai";
+import type { DiscoveredModel, DiscoveryResult, LiteLLMApi, LiteLLMModel } from "./types.js";
 export type LiteLLMProviderOptions = {
     id: string;
     name: string;
@@ -7,10 +7,10 @@ export type LiteLLMProviderOptions = {
     auth: ProviderAuth;
     /** Catalog discovered during activation. Pi's startup refresh never allows network access, so
      * without a seed the provider stays empty until the user opens /model. */
-    models?: readonly Model<LiteLLMApi>[];
+    models?: readonly LiteLLMModel[];
     discover(credential: Credential, signal?: AbortSignal): Promise<DiscoveryResult & {
         baseUrl?: string;
     }>;
 };
-export declare function toNativeModels(provider: string, baseUrl: string, models: readonly DiscoveredModel[]): Model<LiteLLMApi>[];
+export declare function toNativeModels(provider: string, baseUrl: string, models: readonly DiscoveredModel[]): LiteLLMModel[];
 export declare function createLiteLLMProvider(options: LiteLLMProviderOptions): Provider<LiteLLMApi>;

package/dist/types.d.ts

@@ -9,6 +9,10 @@ export type LiteLLMRuntimeAuth = {
 };
 export type DiscoveredModel = Omit<Model<"openai-completions">, "provider" | "api" | "baseUrl"> & {
     api?: LiteLLMApi;
+    suppressReasoningContent?: boolean;
+};
+export type LiteLLMModel = Model<LiteLLMApi> & {
+    suppressReasoningContent?: boolean;
 };
 export interface DiscoveryResult {
     models: DiscoveredModel[];
@@ -22,6 +26,10 @@ export interface DiscoveryOptions {
 }
 export interface ModelInfoEntry {
     model_name?: string;
+    litellm_params?: {
+        model?: string;
+        custom_llm_provider?: string;
+    };
     model_info?: {
         mode?: string | null;
         input_cost_per_token?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -46,7 +46,7 @@
     "typecheck": "tsgo --noEmit",
     "lint": "biome check --error-on-warnings .",
     "format": "biome check --write .",
-    "test": "vitest --run",
+    "test": "vitest --run --dir tests",
     "supply-chain:guard": "tsx scripts/supply-chain-guard.ts",
     "check": "npm run lint && npm run typecheck && npm test",
     "prepublishOnly": "npm run check && npm run clean && npm run build && npm run supply-chain:guard"