pi-provider-litellm 1.2.9 → 2.0.0

package/dist/litellm.js

@@ -1,10 +1,8 @@
+import { basename } from "node:path";
 export function getSessionIdFromFile(sessionFile) {
     if (!sessionFile)
         return undefined;
-    const filename = sessionFile
-        .split("/")
-        .pop()
-        ?.replace(/\.jsonl$/i, "");
+    const filename = basename(sessionFile).replace(/\.jsonl$/i, "");
     if (!filename)
         return undefined;
     const uuidMatch = filename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);

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[]>;
+import { type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { LiteLLMMcpTool, LiteLLMRuntimeAuth } from "./types.js";
+export declare function discoverMcpTools(baseUrl: string, apiKey: string, headers?: Record<string, string>, onProgress?: (message: string) => void, parentSignal?: AbortSignal): 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(getAuth: (ctx?: ExtensionContext) => Promise<LiteLLMRuntimeAuth>, onProgress?: (message: string) => void, signal?: AbortSignal): Promise<ToolDefinition[]>;

package/dist/mcp-tools.js

@@ -6,14 +6,6 @@ const CALL_TIMEOUT_MS = 30_000;
 const MCP_RETRY_DELAY_MS = 350;
 const MCP_RETRY_ATTEMPTS = 1;
 const RETRYABLE_HTTP_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
-function withTimeout(timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
-    return {
-        signal: controller.signal,
-        cancel: () => clearTimeout(timer),
-    };
-}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
@@ -57,29 +49,35 @@ function normalizeMcpTool(value) {
         input_schema: inputSchema,
     };
 }
-export async function discoverMcpTools(baseUrl, apiKey, headers) {
-    const { signal, cancel } = withTimeout(LIST_TIMEOUT_MS);
+export async function discoverMcpTools(baseUrl, apiKey, headers, onProgress, parentSignal) {
+    onProgress?.("Discovering MCP tools from server...");
     try {
+        onProgress?.("Querying MCP tools/list endpoint...");
         const response = await fetch(`${normalizeBaseUrl(baseUrl)}/mcp-rest/tools/list`, {
             headers: {
                 ...headers,
                 Authorization: `Bearer ${apiKey}`,
                 "Content-Type": "application/json",
             },
-            signal,
+            signal: parentSignal
+                ? AbortSignal.any([parentSignal, AbortSignal.timeout(LIST_TIMEOUT_MS)])
+                : AbortSignal.timeout(LIST_TIMEOUT_MS),
         });
-        if (!response.ok)
-            return [];
+        if (!response.ok) {
+            onProgress?.(`MCP tools discovery failed with status ${response.status}`);
+            throw new Error(`HTTP ${response.status}`);
+        }
         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);
-    }
-    catch {
-        return [];
+        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;
     }
-    finally {
-        cancel();
+    catch (error) {
+        onProgress?.("MCP tools discovery encountered an error");
+        throw error;
     }
 }
 export async function executeMcpTool(baseUrl, apiKey, serverId, toolName, args, headers) {
@@ -94,7 +92,6 @@ export async function executeMcpTool(baseUrl, apiKey, serverId, toolName, args,
     return `Error calling ${toolName} on ${serverId}: retry attempts exhausted`;
 }
 async function executeMcpToolOnce(baseUrl, apiKey, serverId, toolName, args, headers) {
-    const { signal, cancel } = withTimeout(CALL_TIMEOUT_MS);
     try {
         let response;
         try {
@@ -106,7 +103,7 @@ async function executeMcpToolOnce(baseUrl, apiKey, serverId, toolName, args, hea
                     "Content-Type": "application/json",
                 },
                 body: JSON.stringify({ server_id: serverId, name: toolName, arguments: args }),
-                signal,
+                signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
             });
         }
         catch (error) {
@@ -136,9 +133,6 @@ async function executeMcpToolOnce(baseUrl, apiKey, serverId, toolName, args, hea
     catch (error) {
         return { text: formatMcpToolError(toolName, serverId, error), retryable: false };
     }
-    finally {
-        cancel();
-    }
 }
 function sanitizeName(name) {
     const sanitized = name
@@ -156,9 +150,9 @@ function buildParameters(inputSchema) {
     }
     return Type.Unsafe(inputSchema);
 }
-export async function createMcpToolDefinitions(baseUrl, getApiKey, headers) {
-    const discoveryApiKey = await getApiKey();
-    const tools = await discoverMcpTools(baseUrl, discoveryApiKey, headers);
+export async function createMcpToolDefinitions(getAuth, onProgress, signal) {
+    const discoveryAuth = await getAuth();
+    const tools = await discoverMcpTools(discoveryAuth.baseUrl, discoveryAuth.apiKey, discoveryAuth.headers, onProgress, signal);
     return tools.map((mcpTool) => {
         const safeServer = sanitizeName(mcpTool.server_name);
         const safeTool = sanitizeName(mcpTool.name);
@@ -170,13 +164,13 @@ export async function createMcpToolDefinitions(baseUrl, getApiKey, headers) {
             promptSnippet: `${mcpTool.description} via ${mcpTool.server_name} MCP server`,
             executionMode: "parallel",
             parameters,
-            async execute(_toolCallId, params) {
-                const apiKey = await getApiKey();
+            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+                const auth = await getAuth(ctx);
                 const rawParams = params;
                 const args = Object.keys(rawParams).length === 1 && rawParams.args && typeof rawParams.args === "object"
                     ? rawParams.args
                     : rawParams;
-                const text = await executeMcpTool(baseUrl, apiKey, mcpTool.server_id ?? mcpTool.server_name, mcpTool.name, args, headers);
+                const text = await executeMcpTool(auth.baseUrl, auth.apiKey, mcpTool.server_id ?? mcpTool.server_name, mcpTool.name, args, auth.headers);
                 return {
                     content: [{ type: "text", text }],
                     details: { server: mcpTool.server_name, serverId: mcpTool.server_id, tool: mcpTool.name },

package/dist/provider.d.ts

@@ -0,0 +1,13 @@
+import { type Credential, type Model, type Provider, type ProviderAuth } from "@earendil-works/pi-ai";
+import type { DiscoveredModel, DiscoveryResult, LiteLLMApi } from "./types.js";
+export type LiteLLMProviderOptions = {
+    id: string;
+    name: string;
+    baseUrl: string;
+    auth: ProviderAuth;
+    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 createLiteLLMProvider(options: LiteLLMProviderOptions): Provider<LiteLLMApi>;

package/dist/provider.js

@@ -0,0 +1,30 @@
+import { createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+export function toNativeModels(provider, baseUrl, models) {
+    return models.map((model) => ({
+        ...model,
+        provider,
+        api: model.api ?? "openai-completions",
+        baseUrl,
+    }));
+}
+export function createLiteLLMProvider(options) {
+    return createProvider({
+        id: options.id,
+        name: options.name,
+        baseUrl: options.baseUrl,
+        auth: options.auth,
+        models: [],
+        async fetchModels(context) {
+            if (!context.credential)
+                throw new Error("LiteLLM model discovery requires a credential");
+            const result = await options.discover(context.credential, context.signal);
+            return toNativeModels(options.id, result.baseUrl ?? options.baseUrl, result.models);
+        },
+        api: {
+            "openai-completions": openAICompletionsApi(),
+            "openai-responses": openAIResponsesApi(),
+        },
+    });
+}

package/dist/skills.d.ts

@@ -1,5 +1,5 @@
-import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { LiteLLMSkill } from "./types.js";
+import { type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { LiteLLMRuntimeAuth, LiteLLMSkill } from "./types.js";
 export declare function listSkills(baseUrl: string, apiKey: string, headers?: Record<string, string>): Promise<LiteLLMSkill[]>;
 export declare function createSkill(baseUrl: string, apiKey: string, input: {
     name: string;
@@ -10,5 +10,5 @@ export declare function createSkill(baseUrl: string, apiKey: string, input: {
 }, headers?: Record<string, string>): Promise<unknown>;
 export declare function deleteSkill(baseUrl: string, apiKey: string, skillId: string, headers?: Record<string, string>): Promise<void>;
 export declare function createSkillsPromptSection(skills: LiteLLMSkill[]): string | undefined;
-export declare function createSkillToolDefinitions(baseUrl: string, getApiKey: () => Promise<string>, headers?: Record<string, string>): ToolDefinition[];
+export declare function createSkillToolDefinitions(getAuth: (ctx?: ExtensionContext) => Promise<LiteLLMRuntimeAuth>): ToolDefinition[];
 export declare function resetSkillsCache(): void;

package/dist/skills.js

@@ -172,7 +172,7 @@ function parseJsonObject(value, fieldName) {
     }
     return parsed;
 }
-export function createSkillToolDefinitions(baseUrl, getApiKey, headers) {
+export function createSkillToolDefinitions(getAuth) {
     return [
         defineTool({
             name: "litellm_skill_list",
@@ -180,9 +180,9 @@ export function createSkillToolDefinitions(baseUrl, getApiKey, headers) {
             description: "List skills registered on the LiteLLM proxy Skills Gateway.",
             promptSnippet: "List LiteLLM Skills Gateway skills",
             parameters: Type.Object({}),
-            async execute() {
-                const apiKey = await getApiKey();
-                const skills = await listSkills(baseUrl, apiKey, headers);
+            async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+                const auth = await getAuth(ctx);
+                const skills = await listSkills(auth.baseUrl, auth.apiKey, auth.headers);
                 return { content: [{ type: "text", text: formatSkills(skills) }], details: { count: skills.length } };
             },
         }),
@@ -191,19 +191,19 @@ export function createSkillToolDefinitions(baseUrl, getApiKey, headers) {
             label: "Create LiteLLM Skill",
             description: "Create a skill on the LiteLLM proxy Skills Gateway.",
             parameters: CreateSkillParams,
-            async execute(_toolCallId, params) {
-                const apiKey = await getApiKey();
+            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+                const auth = await getAuth(ctx);
                 const source = params.sourceJson ? parseJsonObject(params.sourceJson, "sourceJson") : undefined;
                 const inputSchema = params.inputSchemaJson
                     ? parseJsonObject(params.inputSchemaJson, "inputSchemaJson")
                     : undefined;
-                const result = await createSkill(baseUrl, apiKey, {
+                const result = await createSkill(auth.baseUrl, auth.apiKey, {
                     name: params.name,
                     description: params.description,
                     source,
                     code: params.code,
                     inputSchema,
-                }, headers);
+                }, auth.headers);
                 return { content: [{ type: "text", text: "LiteLLM skill created." }], details: { result } };
             },
         }),
@@ -212,9 +212,9 @@ export function createSkillToolDefinitions(baseUrl, getApiKey, headers) {
             label: "Delete LiteLLM Skill",
             description: "Delete a skill from the LiteLLM proxy Skills Gateway.",
             parameters: DeleteSkillParams,
-            async execute(_toolCallId, params) {
-                const apiKey = await getApiKey();
-                await deleteSkill(baseUrl, apiKey, params.skillId, headers);
+            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+                const auth = await getAuth(ctx);
+                await deleteSkill(auth.baseUrl, auth.apiKey, params.skillId, auth.headers);
                 return { content: [{ type: "text", text: `LiteLLM skill deleted: ${params.skillId}` }], details: {} };
             },
         }),

package/dist/types.d.ts

@@ -1,26 +1,29 @@
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
 export type DiscoverySource = "model_info" | "models_list" | "health";
-export interface CacheFile {
+export type LiteLLMApi = "openai-completions" | "openai-responses";
+export type LiteLLMRuntimeAuth = {
     baseUrl: string;
-    apiKeyFingerprint: string;
-    headersFingerprint?: string;
-    fetchedAt: number;
-    source: DiscoverySource;
-    models: ProviderModelConfig[];
-}
+    apiKey: string;
+    headers?: Record<string, string>;
+};
+export type DiscoveredModel = Omit<Model<"openai-completions">, "provider" | "api" | "baseUrl"> & {
+    api?: LiteLLMApi;
+};
 export interface DiscoveryResult {
-    models: ProviderModelConfig[];
+    models: DiscoveredModel[];
     source: DiscoverySource;
 }
 export interface DiscoveryOptions {
     timeoutMs?: number;
     signal?: AbortSignal;
     headers?: Record<string, string>;
+    modelsDev?: boolean;
+    modelsDevCachePath?: string;
 }
 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": "2.0.0",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -55,18 +55,19 @@
     "node": ">=22.19.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": ">=0.81.0",
+    "@earendil-works/pi-coding-agent": ">=0.81.0"
   },
   "overrides": {
     "basic-ftp": "6.0.1",
     "fast-xml-builder": "1.2.0",
-    "protobufjs": "8.2.1"
+    "protobufjs": "8.7.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.80.2",
-    "@earendil-works/pi-coding-agent": "^0.80.2",
     "@biomejs/biome": "^2.4.15",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@kitlangton/terminal-control": "0.6.0",
     "@types/node": "^26.0.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "tsx": "^4.21.0",