pi-provider-litellm 1.2.9 → 1.3.0

package/README.md

@@ -119,6 +119,25 @@ Provider fields:
 
 `/login litellm` and Google ADC token auth remain scoped to the default `litellm` provider. Aliases use their configured `apiKey` or manually stored auth entries matching the alias name.
 
+### Optional LiteLLM features
+
+LiteLLM Skills and MCP integration are enabled by default. Disable either feature globally in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "litellm": {
+    "skills": {
+      "enabled": false
+    },
+    "mcp": {
+      "enabled": false
+    }
+  }
+}
+```
+
+Setting `skills.enabled` to `false` disables the Skills Gateway management tools, skill fetching, and system-prompt injection. Setting `mcp.enabled` to `false` disables LiteLLM MCP discovery and tool registration. Restart Pi after changing these settings so previously registered tools are removed.
+
 ## Use
 
 ```
@@ -133,10 +152,10 @@ Provider fields:
 | `LITELLM_HEADERS` | unset | JSON object of extra headers sent to LiteLLM provider, discovery, MCP, and Skills Gateway requests. Provider aliases can use it with `"headers": "$LITELLM_HEADERS"`. |
 | `LITELLM_GCLOUD_TOKEN_AUTH` | unset | If set to a non-empty value other than `0`, use Google Application Default Credentials as the LiteLLM bearer token source. This takes precedence over `LITELLM_API_KEY_HELPER` and `LITELLM_API_KEY` when no stored `/login litellm` credential exists. |
 | `GOOGLE_APPLICATION_CREDENTIALS` | Google default ADC path | Optional path to an ADC JSON file used by `LITELLM_GCLOUD_TOKEN_AUTH`. If unset, the extension checks the default gcloud ADC locations. |
-| `LITELLM_OFFLINE` | unset | If `1`, skip discovery on this start; use cache only |
-| `LITELLM_DISCOVERY_TIMEOUT_MS` | `5000` | Discovery fetch timeout in ms; `0` to skip discovery |
+| `LITELLM_OFFLINE` | unset | If `1`, disable all model and MCP discovery, including `/litellm-refresh` and post-login MCP discovery; use cached models only |
+| `LITELLM_DISCOVERY_TIMEOUT_MS` | `5000` | Background and explicit discovery fetch timeout in ms; `0` disables automatic discovery |
 
-`LITELLM_DISCOVERY_TIMEOUT_MS=0` only disables startup and refresh model discovery. It does not replace the base URL or API key settings required to send requests when you are not using `/login litellm`.
+`LITELLM_DISCOVERY_TIMEOUT_MS=0` disables automatic and explicit refresh model discovery. It does not replace the base URL or API key settings required to send requests when you are not using `/login litellm`.
 
 ### Google ADC token auth
 
@@ -157,7 +176,7 @@ If your LiteLLM proxy exposes MCP REST endpoints, this extension discovers tools
 - `GET /mcp-rest/tools/list`
 - `POST /mcp-rest/tools/call`
 
-Each discovered tool is registered as a native Pi tool named `mcp_<server>_<tool>`, with simple JSON Schema parameters mapped to Pi/TypeBox parameters. Complex schemas fall back to a single `args` object. MCP discovery runs after successful live model discovery, `/login litellm`, or `/litellm-refresh`; it does not force network or helper-token access when a fresh model cache is used. MCP tools run in Pi's parallel tool mode and retry transient failures once.
+Each discovered tool is registered as a native Pi tool named `mcp_<server>_<tool>`, with simple JSON Schema parameters mapped to Pi/TypeBox parameters. Complex schemas fall back to a single `args` object. MCP discovery runs after background model discovery, `/login litellm`, or `/litellm-refresh`; extension activation never waits for it. MCP tools run in Pi's parallel tool mode and retry transient failures once.
 
 ## LiteLLM Skill Hub
 
@@ -171,11 +190,11 @@ If your LiteLLM proxy exposes `/claude-code/marketplace.json`, enabled skills ar
 
 The `LiteLLM Smoke` GitHub Actions workflow starts VidaiMock and a real LiteLLM proxy on the runner. LiteLLM exposes OpenAI-compatible and Anthropic routes whose upstreams are served by VidaiMock, then this extension's smoke runner discovers those models through LiteLLM and sends `/v1/chat/completions` requests through the proxy.
 
-This keeps the LiteLLM integration path under test but does not call real LLM APIs. No provider API keys or GitHub Models permission are required. The smoke runner also asserts that discovery came from `/model/info` (`LITELLM_SMOKE_EXPECT_SOURCE`) so a silent fallback to `/v1/models` fails the run. The workflow also runs auth checks plus optional Postgres-backed auth checks when `LITELLM_LICENSE` is configured for virtual-key and admin-route behavior, then runs a non-interactive Pi CLI smoke with `--list-models` and `-p` against both the OpenAI-compatible and Anthropic-backed routes, so extension loading, model discovery, and real completion paths are covered without opening the TUI.
+This keeps the LiteLLM integration path under test but does not call real LLM APIs. No provider API keys or GitHub Models permission are required. The smoke runner also asserts that discovery came from `/model/info` (`LITELLM_SMOKE_EXPECT_SOURCE`) so a silent fallback to `/v1/models` fails the run. The workflow also runs auth checks plus optional Postgres-backed auth checks when `LITELLM_LICENSE` is configured for virtual-key and admin-route behavior, then runs a non-interactive Pi CLI smoke with `--list-models` and `-p` against both the OpenAI-compatible and Anthropic-backed routes, so extension loading, model discovery, and real completion paths are covered without opening the TUI. It also runs an interactive Pi TUI smoke covering `/login litellm`, `/litellm-refresh`, and `/model`.
 
 ## Development
 
-This package requires Node.js `>=22.19.0`. CI currently uses Node `24.16.0`.
+This package requires Node.js `>=22.19.0`. CI currently uses Node `26.5.0`.
 
 ```bash
 npm ci
@@ -209,7 +228,7 @@ Before tagging a release, keep `package.json` and `package-lock.json` versions i
 
 The default provider model list is cached at `~/.pi/agent/litellm-models.json` with a keyed fingerprint of the base URL + API key. Alias provider caches use `~/.pi/agent/litellm-models-<provider>.json`. Changing the base URL or key invalidates that provider's cache automatically.
 
-If the cache is older than 24 hours, the extension refreshes it in the background on session start (non-blocking). Failures are silent — the cached models remain in use. Run `/litellm-refresh` to force an immediate refresh.
+When the cache is missing, invalid, or older than 24 hours, the extension starts without waiting for discovery and refreshes models in the background on session start. Existing cached models remain available while an invalid or stale cache refreshes. Failures are silent; run `/litellm-refresh` to force an immediate refresh and see its result.
 
 ## Troubleshooting
 

package/dist/cost.d.ts

@@ -1,10 +1,4 @@
 import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-export interface ModelCostInfo {
-    inputCostPerToken: number;
-    outputCostPerToken: number;
-    cacheReadCostPerToken: number;
-    cacheWriteCostPerToken: number;
-}
 export interface ProviderModels {
     provider: string;
     models: ProviderModelConfig[];

package/dist/discover.d.ts

@@ -9,4 +9,6 @@ export declare function withTimeout(timeoutMs: number, signal?: AbortSignal): {
     signal: AbortSignal;
     cancel: () => void;
 };
-export declare function discoverModels(baseUrl: string, apiKey: string, options?: DiscoveryOptions): Promise<DiscoveryResult>;
+export declare function discoverModels(baseUrl: string, apiKey: string, options?: DiscoveryOptions & {
+    onProgress?: (message: string) => void;
+}): Promise<DiscoveryResult>;

package/dist/discover.js

@@ -10,10 +10,10 @@ export function normalizeBaseUrl(input) {
 }
 const RESPONSES_MODE_PATTERN = /^responses?$/i;
 function isResponsesMode(mode) {
-    return mode !== undefined && RESPONSES_MODE_PATTERN.test(mode);
+    return mode != null && RESPONSES_MODE_PATTERN.test(mode);
 }
 function isChatStyleMode(mode) {
-    return mode === undefined || mode === "chat" || isResponsesMode(mode);
+    return mode == null || mode === "chat" || isResponsesMode(mode);
 }
 // Matches both the conventional `anthropic/...` prefix and aliases that
 // LiteLLM deployments commonly assign to Anthropic-backed routes (e.g.
@@ -104,6 +104,7 @@ function mapModelInfoCost(info, fallback) {
         cacheWrite: info.cache_creation_input_token_cost !== undefined
             ? info.cache_creation_input_token_cost * 1_000_000
             : (fallback?.cacheWrite ?? 0),
+        ...(fallback?.tiers ? { tiers: fallback.tiers } : {}),
     };
 }
 function getFallbackProviderAndModel(id, ownedBy) {
@@ -221,6 +222,7 @@ function mapFromModelInfo(entry) {
         id,
         name: id,
         reasoning: info.supports_reasoning ?? false,
+        ...(catalogModel?.thinkingLevelMap ? { thinkingLevelMap: catalogModel.thinkingLevelMap } : {}),
         input: info.supports_vision ? ["text", "image"] : ["text"],
         cost: mapModelInfoCost(info, catalogModel?.cost),
         contextWindow: info.max_input_tokens ?? DEFAULT_CONTEXT_WINDOW,
@@ -286,45 +288,75 @@ function mapFromModelsList(entry, modelsDev) {
     };
 }
 async function discoverFromHealth(base, apiKey, options) {
+    options.onProgress?.("Querying /health endpoint...");
     const healthResult = await fetchJson(`${base}/health`, apiKey, options);
     if (!healthResult.ok)
         return [];
     const endpoints = (healthResult.data.healthy_endpoints ?? []).filter((entry) => entry.model || entry.model_id);
+    options.onProgress?.(`Discovered ${endpoints.length} model endpoints, fetching details...`);
+    let completed = 0;
     const models = await Promise.all(endpoints.map(async (endpoint) => {
-        if (!endpoint.model_id)
-            return mapFromHealthEndpoint(endpoint);
-        const infoResult = await fetchJson(`${base}/model/info?litellm_model_id=${encodeURIComponent(endpoint.model_id)}`, apiKey, options);
-        if (!infoResult.ok)
-            return mapFromHealthEndpoint(endpoint);
-        const entry = infoResult.data.data?.[0];
-        return entry ? mapFromHealthModelInfo(entry, endpoint.model) : mapFromHealthEndpoint(endpoint);
+        let model = mapFromHealthEndpoint(endpoint);
+        if (endpoint.model_id) {
+            const infoResult = await fetchJson(`${base}/model/info?litellm_model_id=${encodeURIComponent(endpoint.model_id)}`, apiKey, options);
+            const entry = infoResult.ok ? infoResult.data.data?.[0] : undefined;
+            if (entry)
+                model = mapFromHealthModelInfo(entry, endpoint.model);
+        }
+        completed++;
+        if (completed % 10 === 0 || completed === endpoints.length) {
+            options.onProgress?.(`Fetched ${completed}/${endpoints.length} models...`);
+        }
+        return model;
     }));
     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;
+    });
+}
 export async function discoverModels(baseUrl, apiKey, options = {}) {
     const base = normalizeBaseUrl(baseUrl);
+    options.onProgress?.("Querying /model/info endpoint...");
     const infoResult = await fetchJson(`${base}/model/info`, apiKey, options);
     if (infoResult.ok) {
-        const models = (infoResult.data.data ?? [])
-            .map(mapFromModelInfo)
-            .filter((m) => m !== undefined);
+        const entries = new Map();
+        for (const entry of infoResult.data.data ?? []) {
+            if (!entry.model_name)
+                continue;
+            const previous = entries.get(entry.model_name);
+            entries.set(entry.model_name, {
+                ...previous,
+                ...entry,
+                model_info: { ...previous?.model_info, ...entry.model_info },
+            });
+        }
+        const models = [...entries.values()].map(mapFromModelInfo).filter((m) => m !== undefined);
         return { source: "model_info", models };
     }
     if (![401, 403, 404].includes(infoResult.status)) {
         throw new Error(`/model/info returned ${infoResult.status}`);
     }
+    options.onProgress?.("/model/info unavailable, trying /v1/models...");
     const listResult = await fetchJson(`${base}/v1/models`, apiKey, options);
     if (!listResult.ok) {
         if ([401, 403, 404].includes(listResult.status)) {
+            options.onProgress?.("/v1/models unavailable, falling back to /health endpoint...");
             const models = await discoverFromHealth(base, apiKey, options);
             if (models.length > 0)
-                return { source: "health", models };
+                return { source: "health", models: deduplicateModels(models) };
         }
         throw new Error(`/v1/models returned ${listResult.status}`);
     }
+    options.onProgress?.("Fetching models.dev catalog for metadata enrichment...");
     const modelsDev = await getModelsDevCatalog(options);
     const models = (listResult.data.data ?? [])
         .map((entry) => mapFromModelsList(entry, modelsDev))
         .filter((m) => m !== undefined);
-    return { source: "models_list", models };
+    return { source: "models_list", models: deduplicateModels(models) };
 }

package/dist/index.js

@@ -1,7 +1,7 @@
-import { execSync, spawn } from "node:child_process";
+import { execSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { AuthStorage, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { fingerprint, readCache, writeCache } from "./cache.js";
 import { setupLiteLLMCostTracking } from "./cost.js";
 import { discoverModels, isGpt55Model, normalizeBaseUrl, shouldSuppressReasoningContent, withTimeout, } from "./discover.js";
@@ -24,6 +24,21 @@ const CACHE_STALE_MS = 24 * 60 * 60 * 1000;
 const TOKEN_REFRESH_LEAD_MS = 5 * 60 * 1000;
 const PERMANENT_TOKEN_EXPIRES_AT = Number.MAX_SAFE_INTEGER;
 const EXPIRE_TOKEN_IMMEDIATELY = 0;
+function credentialsFromRefresh(state, credential) {
+    const apiKey = credential.type === "oauth" ? credential.access : credential.key;
+    const credentialBaseUrl = credential.type === "oauth" ? credential.baseUrl : undefined;
+    const fingerprintSource = credential.type === "api_key" && state.creds.apiKeyConfig?.startsWith("!")
+        ? state.creds.apiKeyConfig
+        : credential.type === "oauth" && credential.refresh.startsWith("!")
+            ? credential.refresh
+            : apiKey;
+    return {
+        ...state.creds,
+        baseUrl: typeof credentialBaseUrl === "string" ? normalizeBaseUrl(credentialBaseUrl) : state.creds.baseUrl,
+        apiKey,
+        apiKeyFingerprint: fingerprintSource ? fingerprint(fingerprintSource) : undefined,
+    };
+}
 function getAuthPath() {
     return join(getAgentDir(), "auth.json");
 }
@@ -48,7 +63,9 @@ function stripJsonComments(input) {
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const COST_RATE_FIELDS = ["input", "output", "cacheRead", "cacheWrite"];
+const COST_TIER_FIELDS = [...COST_RATE_FIELDS, "inputTokensAbove"];
 // Mirrors pi core's ModelOverrideSchema: core rejects the whole models.json on invalid values,
 // so anything dropped here would also have been flagged for built-in providers. Headers matter
 // most: pi resolves each header value as a config string, so non-strings break requests.
@@ -61,7 +78,13 @@ const MODEL_OVERRIDE_VALIDATORS = {
     maxTokens: (value) => typeof value === "number",
     headers: (value) => isPlainObject(value) && Object.values(value).every((entry) => typeof entry === "string"),
     compat: isPlainObject,
-    cost: (value) => isPlainObject(value) && Object.values(value).every((entry) => typeof entry === "number"),
+    cost: (value) => isPlainObject(value) &&
+        Object.entries(value).every(([key, entry]) => key === "tiers"
+            ? Array.isArray(entry) &&
+                entry.every((tier) => isPlainObject(tier) &&
+                    COST_TIER_FIELDS.every((field) => typeof tier[field] === "number") &&
+                    Object.keys(tier).every((field) => COST_TIER_FIELDS.includes(field)))
+            : COST_RATE_FIELDS.includes(key) && typeof entry === "number"),
 };
 function sanitizeModelOverride(modelId, raw) {
     if (!isPlainObject(raw)) {
@@ -160,15 +183,8 @@ function applyModelOverrides(models, overrides) {
 async function applyOverrides(providerName, models) {
     return applyModelOverrides(models, await readModelOverrides(providerName));
 }
-async function readAuthEntry(providerName = PROVIDER_NAME) {
-    try {
-        const raw = await readFile(getAuthPath(), "utf8");
-        const parsed = JSON.parse(raw);
-        return parsed?.[providerName];
-    }
-    catch {
-        return undefined;
-    }
+function readAuthEntry(providerName = PROVIDER_NAME) {
+    return readStoredCredential(providerName, getAuthPath());
 }
 async function readGlobalLiteLLMSettings() {
     try {
@@ -220,19 +236,6 @@ function tokenExpiresAt(apiKey, opaqueFallback = PERMANENT_TOKEN_EXPIRES_AT) {
         return opaqueFallback;
     }
 }
-function openInBrowser(url) {
-    // Never invoke a shell here: cmd.exe re-parses metacharacters before `start`
-    // runs, which would make URL contents injectable. Launch is best-effort; the
-    // URL is also shown to the user, so launcher failures must not crash the process.
-    const [cmd, args] = process.platform === "darwin"
-        ? ["open", [url]]
-        : process.platform === "win32"
-            ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
-            : ["xdg-open", [url]];
-    spawn(cmd, args, { stdio: "ignore", detached: true })
-        .on("error", () => undefined)
-        .unref();
-}
 async function generateVirtualKey(baseUrl, userToken, signal, headers) {
     const { signal: boundedSignal, cancel } = withTimeout(LOGIN_TIMEOUT_MS, signal);
     try {
@@ -394,8 +397,8 @@ async function resolveCredentials(definition, { executeHelpers = true } = {}) {
     const gcloudCacheKey = useGcloudToken && !entry ? ((await getGcloudTokenCacheKey()) ?? undefined) : undefined;
     const authKey = entry?.type === "oauth"
         ? (executeHelpers ? resolveOAuthApiKey(entry) : entry.access).trim()
-        : entry?.type === "api_key"
-            ? (await AuthStorage.create(getAuthPath()).getApiKey(definition.name, { includeFallback: false }))?.trim()
+        : entry?.type === "api_key" && typeof entry.key === "string"
+            ? resolveConfigValue(entry.key, { executeCommands: executeHelpers })?.trim()
             : undefined;
     const gcloudKey = executeHelpers && gcloudCacheKey ? (await getGcloudToken())?.trim() : undefined;
     // Resolved lazily so a `!command` key is not executed when a
@@ -478,8 +481,11 @@ function normalizeProviderSettings(raw) {
         return undefined;
     return record;
 }
-async function getProviderDefinitions() {
-    const settings = await readGlobalLiteLLMSettings();
+function isFeatureEnabled(settings, feature) {
+    const raw = settings?.[feature];
+    return !isPlainObject(raw) || raw.enabled !== false;
+}
+function getProviderDefinitions(settings) {
     const rawProviders = settings?.providers && typeof settings.providers === "object" ? settings.providers : undefined;
     const providerSettings = rawProviders;
     const defaultSettings = normalizeProviderSettings(providerSettings?.[PROVIDER_NAME]);
@@ -593,6 +599,7 @@ async function loginLiteLLM(callbacks, options) {
         timeoutMs: LOGIN_TIMEOUT_MS,
         signal: callbacks.signal,
         headers: options.headers,
+        onProgress: (message) => callbacks.onProgress?.(`LiteLLM: ${message}`),
     });
     const cache = {
         baseUrl,
@@ -750,7 +757,10 @@ function normalizeThinkTags(message, litellmProviderNames) {
     return { ...message, content };
 }
 export default async function (pi) {
-    const definitions = await getProviderDefinitions();
+    const settings = await readGlobalLiteLLMSettings();
+    const definitions = getProviderDefinitions(settings);
+    const skillsEnabled = isFeatureEnabled(settings, "skills");
+    const mcpEnabled = isFeatureEnabled(settings, "mcp");
     const providerNames = new Set(definitions.map((definition) => definition.name));
     function discoveryDisabledReason() {
         if (isOffline())
@@ -772,12 +782,10 @@ export default async function (pi) {
             cache.baseUrl === creds.baseUrl &&
             cache.apiKeyFingerprint === fp &&
             cache.headersFingerprint === headersFp;
-        let models = cacheValid && cache ? cache.models : [];
-        const shouldFetch = creds.baseUrl !== undefined &&
-            fp !== undefined &&
-            !isOffline() &&
-            getDiscoveryTimeoutMs() > 0 &&
-            (!cacheValid || isListModelsMode());
+        let models = cache?.models ?? [];
+        const canDiscover = creds.baseUrl !== undefined && fp !== undefined && !isOffline() && getDiscoveryTimeoutMs() > 0;
+        const shouldFetch = canDiscover && isListModelsMode();
+        const refreshOnStart = canDiscover && !cacheValid && !shouldFetch;
         let credentialWarning;
         let liveDiscoveryApiKey;
         if (shouldFetch) {
@@ -806,6 +814,7 @@ export default async function (pi) {
             const { result, warning } = await discoverWithFallback(creds.baseUrl, creds.apiKey, {
                 timeoutMs,
                 headers,
+                onProgress: (message) => process.stderr.write(`LiteLLM: ${message}\n`),
             });
             if (warning) {
                 if (cacheValid && cache) {
@@ -837,7 +846,16 @@ export default async function (pi) {
         }
         // The cache keeps raw discovery output; overrides are applied freshly at each registration.
         models = await applyOverrides(definition.name, models);
-        return { definition, creds, headers, models, cacheFetchedAt, liveDiscoveryApiKey, refreshInProgress: null };
+        return {
+            definition,
+            creds,
+            headers,
+            models,
+            cacheFetchedAt,
+            refreshOnStart,
+            liveDiscoveryApiKey,
+            refreshInProgress: null,
+        };
     }
     const providerStates = await Promise.all(definitions.map(loadProviderState));
     const defaultState = providerStates.find((state) => state.definition.name === PROVIDER_NAME) ?? providerStates[0];
@@ -861,6 +879,9 @@ export default async function (pi) {
             api: "openai-completions",
             headers: escapeHeaderConfig(state.headers),
             models,
+            refreshModels: ({ allowNetwork, credential, signal }) => allowNetwork && !discoveryDisabledReason()
+                ? runRefresh(state, undefined, credential, signal).then((result) => result.models)
+                : Promise.resolve(state.models),
             oauth: definition.enableOAuth ? oauth : undefined,
         });
     }
@@ -899,7 +920,7 @@ export default async function (pi) {
         return fresh.apiKey;
     }
     function registerSkillTools(state = defaultState) {
-        if (!state.creds.baseUrl)
+        if (!skillsEnabled || !state.creds.baseUrl)
             return;
         for (const tool of createSkillToolDefinitions(state.creds.baseUrl, () => resolveRuntimeApiKey(state), state.headers)) {
             pi.registerTool(tool);
@@ -916,11 +937,11 @@ export default async function (pi) {
             return resolveRuntimeApiKey(state);
         };
     }
-    async function registerMcpTools(state) {
-        if (!state.creds.baseUrl || !state.liveDiscoveryApiKey || discoveryDisabledReason())
+    async function registerMcpTools(state, onProgress) {
+        if (!mcpEnabled || !state.creds.baseUrl || !state.liveDiscoveryApiKey || discoveryDisabledReason())
             return;
         try {
-            const tools = await createMcpToolDefinitions(state.creds.baseUrl, seededRuntimeApiKey(state, state.liveDiscoveryApiKey), state.headers);
+            const tools = await createMcpToolDefinitions(state.creds.baseUrl, seededRuntimeApiKey(state, state.liveDiscoveryApiKey), state.headers, (message) => onProgress ? onProgress(`LiteLLM MCP: ${message}`) : process.stderr.write(`LiteLLM MCP: ${message}\n`));
             for (const tool of tools) {
                 pi.registerTool(tool);
             }
@@ -930,17 +951,22 @@ export default async function (pi) {
         }
     }
     registerSkillTools(defaultState);
-    await registerMcpTools(defaultState);
-    async function refreshModelsAndCosts(state) {
-        const fresh = await resolveCredentials(state.definition);
+    async function refreshModelsAndCosts(state, onProgress, credential, signal) {
+        const fresh = credential ? credentialsFromRefresh(state, credential) : await resolveCredentials(state.definition);
         const freshFp = fresh.apiKeyFingerprint;
         if (!fresh.baseUrl || !fresh.apiKey || !freshFp) {
             throw new Error(`no credentials for ${state.definition.name}. Run /login litellm or set env vars.`);
         }
+        const progress = onProgress
+            ? (message) => onProgress(`LiteLLM: ${message}`)
+            : (message) => process.stderr.write(`LiteLLM: ${message}\n`);
         const result = await discoverModels(fresh.baseUrl, fresh.apiKey, {
             timeoutMs: getDiscoveryTimeoutMs(),
+            signal,
             headers: state.headers,
+            onProgress: progress,
         });
+        signal?.throwIfAborted();
         const now = Date.now();
         await writeCache(getCachePath(state.definition.name), {
             baseUrl: fresh.baseUrl,
@@ -955,60 +981,19 @@ export default async function (pi) {
         state.models = overridden;
         state.liveDiscoveryApiKey = fresh.apiKey;
         state.cacheFetchedAt = now;
+        state.refreshOnStart = false;
         registerProvider(state, overridden, fresh.apiKeyConfig);
         updateAllCosts();
         if (state.definition.name === PROVIDER_NAME)
-            await registerMcpTools(state);
+            await registerMcpTools(state, onProgress);
         return { providerName: state.definition.name, models: overridden, source: result.source };
     }
-    function runRefresh(state) {
-        state.refreshInProgress ??= refreshModelsAndCosts(state).finally(() => {
+    function runRefresh(state, onProgress, credential, signal) {
+        state.refreshInProgress ??= refreshModelsAndCosts(state, onProgress, credential, signal).finally(() => {
             state.refreshInProgress = null;
         });
         return state.refreshInProgress;
     }
-    async function runLogin(ctx) {
-        const credential = await loginLiteLLM({
-            onAuth: ({ url, instructions }) => {
-                openInBrowser(url);
-                ctx.ui.notify(instructions ? `${url} — ${instructions}` : url, "info");
-            },
-            onDeviceCode: () => undefined,
-            onPrompt: async ({ message, placeholder }) => {
-                const value = await ctx.ui.input(message, placeholder);
-                if (value === undefined)
-                    throw new Error("Login cancelled");
-                return value;
-            },
-            onProgress: (message) => ctx.ui.notify(message, "info"),
-            onSelect: async () => undefined,
-            signal: ctx.signal,
-        }, defaultLoginOptions());
-        ctx.modelRegistry.authStorage.set(PROVIDER_NAME, { type: "oauth", ...credential });
-        ctx.modelRegistry.refresh();
-        const credentialBaseUrl = credential.baseUrl;
-        const credentialAccess = typeof credential.access === "string" ? credential.access : undefined;
-        defaultState.creds = { ...defaultState.creds, baseUrl: credentialBaseUrl };
-        defaultState.liveDiscoveryApiKey = credentialAccess;
-        registerSkillTools(defaultState);
-        await registerMcpTools(defaultState);
-        ctx.ui.notify(`Logged in to LiteLLM. Credentials saved to ${getAuthPath()}`, "info");
-    }
-    pi.on("input", async (event, ctx) => {
-        if (event.text.trim() !== `/login ${PROVIDER_NAME}`)
-            return { action: "continue" };
-        if (!ctx.hasUI)
-            return { action: "continue" };
-        try {
-            await runLogin(ctx);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (message !== "Login cancelled")
-                ctx.ui.notify(`LiteLLM login failed: ${message}`, "error");
-        }
-        return { action: "handled" };
-    });
     pi.registerCommand("litellm-refresh", {
         description: "Re-discover models from the LiteLLM proxy.",
         handler: async (args, ctx) => {
@@ -1025,7 +1010,7 @@ export default async function (pi) {
                 ctx.ui.notify(`LiteLLM refresh failed: unknown provider ${requestedProvider}`, "error");
                 return;
             }
-            const settled = await Promise.allSettled(statesToRefresh.map(runRefresh));
+            const settled = await Promise.allSettled(statesToRefresh.map((state) => runRefresh(state, (message) => ctx.ui.notify(message, "info"))));
             const succeeded = settled.filter((result) => result.status === "fulfilled").map((result) => result.value);
             const failed = settled
                 .map((result, index) => ({ result, name: statesToRefresh[index].definition.name }))
@@ -1061,9 +1046,11 @@ export default async function (pi) {
         if (discoveryDisabledReason())
             return;
         for (const state of providerStates) {
-            if (!state.cacheFetchedAt || Date.now() - state.cacheFetchedAt <= CACHE_STALE_MS)
+            const cacheIsStale = state.cacheFetchedAt > 0 && Date.now() - state.cacheFetchedAt > CACHE_STALE_MS;
+            if (!state.refreshOnStart && !cacheIsStale)
                 continue;
-            void runRefresh(state).catch(() => undefined);
+            const progress = ctx.ui?.notify ? (message) => ctx.ui.notify(message, "info") : undefined;
+            void runRefresh(state, progress).catch(() => undefined);
         }
     });
     pi.on("before_provider_request", (event, ctx) => {
@@ -1074,7 +1061,7 @@ export default async function (pi) {
         return prepareLiteLLMRequestPayload(event.payload, ctx.model?.id, ctx.model?.api, sessionId);
     });
     pi.on("before_agent_start", async (event) => {
-        if (discoveryDisabledReason())
+        if (!skillsEnabled || discoveryDisabledReason())
             return;
         const fresh = await resolveCredentials(defaultState.definition);
         if (!fresh.baseUrl || !fresh.apiKey)

package/dist/mcp-tools.d.ts

@@ -1,5 +1,5 @@
 import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { LiteLLMMcpTool } from "./types.js";
-export declare function discoverMcpTools(baseUrl: string, apiKey: string, headers?: Record<string, string>): Promise<LiteLLMMcpTool[]>;
+export declare function discoverMcpTools(baseUrl: string, apiKey: string, headers?: Record<string, string>, onProgress?: (message: string) => void): Promise<LiteLLMMcpTool[]>;
 export declare function executeMcpTool(baseUrl: string, apiKey: string, serverId: string, toolName: string, args: Record<string, unknown>, headers?: Record<string, string>): Promise<string>;
-export declare function createMcpToolDefinitions(baseUrl: string, getApiKey: () => Promise<string>, headers?: Record<string, string>): Promise<ToolDefinition[]>;
+export declare function createMcpToolDefinitions(baseUrl: string, getApiKey: () => Promise<string>, headers?: Record<string, string>, onProgress?: (message: string) => void): Promise<ToolDefinition[]>;

package/dist/mcp-tools.js

@@ -57,9 +57,11 @@ function normalizeMcpTool(value) {
         input_schema: inputSchema,
     };
 }
-export async function discoverMcpTools(baseUrl, apiKey, headers) {
+export async function discoverMcpTools(baseUrl, apiKey, headers, onProgress) {
+    onProgress?.("Discovering MCP tools from server...");
     const { signal, cancel } = withTimeout(LIST_TIMEOUT_MS);
     try {
+        onProgress?.("Querying MCP tools/list endpoint...");
         const response = await fetch(`${normalizeBaseUrl(baseUrl)}/mcp-rest/tools/list`, {
             headers: {
                 ...headers,
@@ -68,14 +70,20 @@ export async function discoverMcpTools(baseUrl, apiKey, headers) {
             },
             signal,
         });
-        if (!response.ok)
+        if (!response.ok) {
+            onProgress?.(`MCP tools discovery failed with status ${response.status}`);
             return [];
+        }
         const body = (await response.json());
         const bodyRecord = asRecord(body);
         const rawTools = Array.isArray(body) ? body : Array.isArray(bodyRecord?.tools) ? bodyRecord.tools : [];
-        return rawTools.map(normalizeMcpTool).filter((tool) => tool !== undefined);
+        onProgress?.(`Found ${rawTools.length} raw MCP tools, normalizing...`);
+        const tools = rawTools.map(normalizeMcpTool).filter((tool) => tool !== undefined);
+        onProgress?.(`Successfully discovered ${tools.length} MCP tools`);
+        return tools;
     }
     catch {
+        onProgress?.("MCP tools discovery encountered an error");
         return [];
     }
     finally {
@@ -156,9 +164,9 @@ function buildParameters(inputSchema) {
     }
     return Type.Unsafe(inputSchema);
 }
-export async function createMcpToolDefinitions(baseUrl, getApiKey, headers) {
+export async function createMcpToolDefinitions(baseUrl, getApiKey, headers, onProgress) {
     const discoveryApiKey = await getApiKey();
-    const tools = await discoverMcpTools(baseUrl, discoveryApiKey, headers);
+    const tools = await discoverMcpTools(baseUrl, discoveryApiKey, headers, onProgress);
     return tools.map((mcpTool) => {
         const safeServer = sanitizeName(mcpTool.server_name);
         const safeTool = sanitizeName(mcpTool.name);

package/dist/types.d.ts

@@ -20,7 +20,7 @@ export interface DiscoveryOptions {
 export interface ModelInfoEntry {
     model_name?: string;
     model_info?: {
-        mode?: string;
+        mode?: string | null;
         input_cost_per_token?: number;
         output_cost_per_token?: number;
         cache_read_input_token_cost?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -64,9 +64,10 @@
     "protobufjs": "8.2.1"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
     "@earendil-works/pi-ai": "^0.80.2",
     "@earendil-works/pi-coding-agent": "^0.80.2",
-    "@biomejs/biome": "^2.4.15",
+    "@kitlangton/terminal-control": "0.3.1",
     "@types/node": "^26.0.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "tsx": "^4.21.0",