pi-provider-litellm 1.2.7 → 1.2.9

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): Promise<LiteLLMMcpTool[]>;
-export declare function executeMcpTool(baseUrl: string, apiKey: string, serverId: string, toolName: string, args: Record<string, unknown>): Promise<string>;
-export declare function createMcpToolDefinitions(baseUrl: string, getApiKey: () => Promise<string>): Promise<ToolDefinition[]>;
+export declare function discoverMcpTools(baseUrl: string, apiKey: string, headers?: Record<string, string>): 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[]>;

package/dist/mcp-tools.js

@@ -3,6 +3,9 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { normalizeBaseUrl } from "./discover.js";
 const LIST_TIMEOUT_MS = 10_000;
 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);
@@ -14,6 +17,23 @@ function withTimeout(timeoutMs) {
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatMcpToolError(toolName, serverId, error) {
+    return `Error calling ${toolName} on ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+}
+function isRetryableTransportError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "AbortError" || error.name === "TimeoutError")
+        return true;
+    if (error.message.startsWith("Timed out after "))
+        return true;
+    if (error.name !== "TypeError")
+        return false;
+    return /fetch failed|failed to fetch|network|terminated|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|socket/i.test(error.message);
+}
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -37,11 +57,12 @@ function normalizeMcpTool(value) {
         input_schema: inputSchema,
     };
 }
-export async function discoverMcpTools(baseUrl, apiKey) {
+export async function discoverMcpTools(baseUrl, apiKey, headers) {
     const { signal, cancel } = withTimeout(LIST_TIMEOUT_MS);
     try {
         const response = await fetch(`${normalizeBaseUrl(baseUrl)}/mcp-rest/tools/list`, {
             headers: {
+                ...headers,
                 Authorization: `Bearer ${apiKey}`,
                 "Content-Type": "application/json",
             },
@@ -61,25 +82,59 @@ export async function discoverMcpTools(baseUrl, apiKey) {
         cancel();
     }
 }
-export async function executeMcpTool(baseUrl, apiKey, serverId, toolName, args) {
+export async function executeMcpTool(baseUrl, apiKey, serverId, toolName, args, headers) {
+    for (let attempt = 0; attempt <= MCP_RETRY_ATTEMPTS; attempt++) {
+        const result = await executeMcpToolOnce(baseUrl, apiKey, serverId, toolName, args, headers);
+        if (attempt < MCP_RETRY_ATTEMPTS && result.retryable) {
+            await sleep(MCP_RETRY_DELAY_MS);
+            continue;
+        }
+        return result.text;
+    }
+    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 {
-        const response = await fetch(`${normalizeBaseUrl(baseUrl)}/mcp-rest/tools/call`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ server_id: serverId, name: toolName, arguments: args }),
-            signal,
-        });
-        if (!response.ok)
-            return `Error calling ${toolName} on ${serverId}: HTTP ${response.status}`;
-        const body = (await response.json());
-        return JSON.stringify("result" in body ? body.result : body, null, 2);
+        let response;
+        try {
+            response = await fetch(`${normalizeBaseUrl(baseUrl)}/mcp-rest/tools/call`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ server_id: serverId, name: toolName, arguments: args }),
+                signal,
+            });
+        }
+        catch (error) {
+            return {
+                text: formatMcpToolError(toolName, serverId, error),
+                retryable: isRetryableTransportError(error),
+            };
+        }
+        if (!response.ok) {
+            return {
+                text: `Error calling ${toolName} on ${serverId}: HTTP ${response.status}`,
+                retryable: RETRYABLE_HTTP_STATUS.has(response.status),
+            };
+        }
+        try {
+            const body = (await response.json());
+            const bodyRecord = asRecord(body);
+            return {
+                text: JSON.stringify(bodyRecord && "result" in bodyRecord ? bodyRecord.result : body, null, 2),
+                retryable: false,
+            };
+        }
+        catch (error) {
+            return { text: formatMcpToolError(toolName, serverId, error), retryable: false };
+        }
     }
     catch (error) {
-        return `Error calling ${toolName} on ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+        return { text: formatMcpToolError(toolName, serverId, error), retryable: false };
     }
     finally {
         cancel();
@@ -92,37 +147,6 @@ function sanitizeName(name) {
         .replace(/^_+|_+$/g, "");
     return sanitized || "tool";
 }
-function isMappableSchema(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const schema = value;
-    if ("$ref" in schema || "anyOf" in schema || "oneOf" in schema || "allOf" in schema)
-        return false;
-    if (["string", "number", "integer", "boolean"].includes(String(schema.type)))
-        return true;
-    if (schema.type === "array") {
-        const items = schema.items;
-        return items?.type === "string";
-    }
-    return false;
-}
-function mapPropertySchema(name, schema) {
-    const description = typeof schema.description === "string" ? schema.description : name;
-    switch (schema.type) {
-        case "string":
-            return Type.String({ description });
-        case "number":
-            return Type.Number({ description });
-        case "integer":
-            return Type.Integer({ description });
-        case "boolean":
-            return Type.Boolean({ description });
-        case "array":
-            return Type.Array(Type.String(), { description });
-        default:
-            return Type.Unknown({ description });
-    }
-}
 function buildParameters(inputSchema) {
     const properties = inputSchema.properties;
     if (!properties || typeof properties !== "object") {
@@ -130,24 +154,11 @@ function buildParameters(inputSchema) {
             args: Type.Record(Type.String(), Type.Unknown(), { description: "Tool arguments as key-value pairs" }),
         });
     }
-    const required = Array.isArray(inputSchema.required)
-        ? inputSchema.required.filter((key) => typeof key === "string")
-        : [];
-    const mapped = {};
-    for (const [key, property] of Object.entries(properties)) {
-        if (!isMappableSchema(property)) {
-            return Type.Object({
-                args: Type.Record(Type.String(), Type.Unknown(), { description: "Tool arguments as key-value pairs" }),
-            });
-        }
-        const field = mapPropertySchema(key, property);
-        mapped[key] = required.includes(key) ? field : Type.Optional(field);
-    }
-    return Type.Object(mapped);
+    return Type.Unsafe(inputSchema);
 }
-export async function createMcpToolDefinitions(baseUrl, getApiKey) {
+export async function createMcpToolDefinitions(baseUrl, getApiKey, headers) {
     const discoveryApiKey = await getApiKey();
-    const tools = await discoverMcpTools(baseUrl, discoveryApiKey);
+    const tools = await discoverMcpTools(baseUrl, discoveryApiKey, headers);
     return tools.map((mcpTool) => {
         const safeServer = sanitizeName(mcpTool.server_name);
         const safeTool = sanitizeName(mcpTool.name);
@@ -157,6 +168,7 @@ export async function createMcpToolDefinitions(baseUrl, getApiKey) {
             label: `${mcpTool.server_name}: ${mcpTool.name}`,
             description: `${mcpTool.description} (via ${mcpTool.server_name} MCP server)`,
             promptSnippet: `${mcpTool.description} via ${mcpTool.server_name} MCP server`,
+            executionMode: "parallel",
             parameters,
             async execute(_toolCallId, params) {
                 const apiKey = await getApiKey();
@@ -164,7 +176,7 @@ export async function createMcpToolDefinitions(baseUrl, getApiKey) {
                 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);
+                const text = await executeMcpTool(baseUrl, apiKey, mcpTool.server_id ?? mcpTool.server_name, mcpTool.name, args, headers);
                 return {
                     content: [{ type: "text", text }],
                     details: { server: mcpTool.server_name, serverId: mcpTool.server_id, tool: mcpTool.name },

package/dist/skills.d.ts

@@ -1,13 +1,14 @@
 import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { LiteLLMSkill } from "./types.js";
-export declare function listSkills(baseUrl: string, apiKey: string): Promise<LiteLLMSkill[]>;
+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;
-    description: string;
-    code: string;
+    description?: string;
+    source?: Record<string, unknown>;
+    code?: string;
     inputSchema?: Record<string, unknown>;
-}): Promise<unknown>;
-export declare function deleteSkill(baseUrl: string, apiKey: string, skillId: string): Promise<void>;
+}, 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>): ToolDefinition[];
+export declare function createSkillToolDefinitions(baseUrl: string, getApiKey: () => Promise<string>, headers?: Record<string, string>): ToolDefinition[];
 export declare function resetSkillsCache(): void;

package/dist/skills.js

@@ -8,6 +8,8 @@ function getSkillsFromBody(body) {
         return body;
     if (body && typeof body === "object") {
         const record = body;
+        if (Array.isArray(record.plugins))
+            return record.plugins;
         if (Array.isArray(record.data))
             return record.data;
         if (Array.isArray(record.skills))
@@ -15,7 +17,7 @@ function getSkillsFromBody(body) {
     }
     return [];
 }
-export async function listSkills(baseUrl, apiKey) {
+export async function listSkills(baseUrl, apiKey, headers) {
     const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
     if (skillsCache &&
         skillsCache.baseUrl === normalizedBaseUrl &&
@@ -23,47 +25,110 @@ export async function listSkills(baseUrl, apiKey) {
         Date.now() - skillsCache.fetchedAt < SKILLS_CACHE_TTL_MS) {
         return skillsCache.skills;
     }
-    try {
-        const response = await fetch(`${normalizedBaseUrl}/v1/skills`, {
-            headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (!response.ok)
+    const fetchSkills = async (path) => {
+        try {
+            const response = await fetch(`${normalizedBaseUrl}${path}`, {
+                headers: { ...headers, Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+                signal: AbortSignal.timeout(10_000),
+            });
+            return response.ok ? getSkillsFromBody(await response.json()) : [];
+        }
+        catch {
             return [];
-        const skills = getSkillsFromBody(await response.json());
-        skillsCache = { baseUrl: normalizedBaseUrl, apiKey, fetchedAt: Date.now(), skills };
-        return skills;
-    }
-    catch {
-        return [];
-    }
+        }
+    };
+    const [skillHub, legacy] = await Promise.all([
+        fetchSkills("/claude-code/marketplace.json"),
+        fetchSkills("/v1/skills"),
+    ]);
+    const skillHubNames = new Set(skillHub.map((skill) => skill.name));
+    const skills = [...skillHub, ...legacy.filter((skill) => !skillHubNames.has(skill.name))];
+    skillsCache = { baseUrl: normalizedBaseUrl, apiKey, fetchedAt: Date.now(), skills };
+    return skills;
 }
-export async function createSkill(baseUrl, apiKey, input) {
-    const response = await fetch(`${normalizeBaseUrl(baseUrl)}/v1/skills`, {
+export async function createSkill(baseUrl, apiKey, input, headers) {
+    if (!input.source && !input.code)
+        throw new Error("code is required when source is omitted");
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    let usedSkillHub = input.source !== undefined;
+    const skillHubPayload = input.source
+        ? {
+            name: input.name,
+            description: input.description,
+            source: input.source,
+        }
+        : {
+            name: input.name,
+            description: input.description,
+            code: input.code,
+            input_schema: input.inputSchema ?? { type: "object", properties: {} },
+        };
+    let response = await fetch(`${normalizedBaseUrl}${input.source ? "/claude-code/plugins" : "/v1/skills"}`, {
         method: "POST",
         headers: {
+            ...headers,
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json",
         },
-        body: JSON.stringify({
-            name: input.name,
-            description: input.description,
-            code: input.code,
-            input_schema: input.inputSchema ?? { type: "object", properties: {} },
-        }),
+        body: JSON.stringify(skillHubPayload),
         signal: AbortSignal.timeout(10_000),
     });
+    if (input.source && response.status === 404) {
+        usedSkillHub = false;
+        response = await fetch(`${normalizedBaseUrl}/v1/skills`, {
+            method: "POST",
+            headers: {
+                ...headers,
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                name: input.name,
+                description: input.description,
+                code: input.code,
+                input_schema: input.inputSchema ?? { type: "object", properties: {} },
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
     if (!response.ok)
         throw new Error(`LiteLLM skill create failed: HTTP ${response.status}`);
     skillsCache = undefined;
+    if (usedSkillHub) {
+        const enableResponse = await fetch(`${normalizedBaseUrl}/claude-code/plugins/${encodeURIComponent(input.name)}/enable`, {
+            method: "POST",
+            headers: { ...headers, Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!enableResponse.ok)
+            throw new Error(`LiteLLM skill enable failed: HTTP ${enableResponse.status}`);
+    }
     return response.json().catch(() => ({}));
 }
-export async function deleteSkill(baseUrl, apiKey, skillId) {
-    const response = await fetch(`${normalizeBaseUrl(baseUrl)}/v1/skills/${encodeURIComponent(skillId)}`, {
+export async function deleteSkill(baseUrl, apiKey, skillId, headers) {
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    let skillHubError;
+    const skillHubResponse = await fetch(`${normalizedBaseUrl}/claude-code/plugins/${encodeURIComponent(skillId)}`, {
         method: "DELETE",
-        headers: { Authorization: `Bearer ${apiKey}` },
+        headers: { ...headers, Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
         signal: AbortSignal.timeout(10_000),
+    }).catch((error) => {
+        skillHubError = error;
+        return undefined;
     });
+    let response = skillHubResponse;
+    if (!response || response.status === 404 || response.status >= 500) {
+        response = await fetch(`${normalizedBaseUrl}/v1/skills/${encodeURIComponent(skillId)}`, {
+            method: "DELETE",
+            headers: { ...headers, Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    if (response.status === 404 && skillHubResponse?.status !== 404) {
+        if (skillHubError instanceof Error)
+            throw skillHubError;
+        throw new Error(`LiteLLM skill delete failed: HTTP ${skillHubResponse?.status}`);
+    }
     if (!response.ok && response.status !== 404)
         throw new Error(`LiteLLM skill delete failed: HTTP ${response.status}`);
     skillsCache = undefined;
@@ -92,14 +157,22 @@ function formatSkills(skills) {
 }
 const CreateSkillParams = Type.Object({
     name: Type.String({ description: "Skill name" }),
-    description: Type.String({ description: "Skill description" }),
-    code: Type.String({ description: "Skill implementation or prompt code" }),
+    description: Type.Optional(Type.String({ description: "Skill description" })),
+    sourceJson: Type.Optional(Type.String({ description: "Optional Skill Hub source metadata JSON object" })),
+    code: Type.Optional(Type.String({ description: "Legacy Skills Gateway implementation or prompt code" })),
     inputSchemaJson: Type.Optional(Type.String({ description: "Optional JSON Schema string for skill inputs" })),
 });
 const DeleteSkillParams = Type.Object({
     skillId: Type.String({ description: "LiteLLM skill id" }),
 });
-export function createSkillToolDefinitions(baseUrl, getApiKey) {
+function parseJsonObject(value, fieldName) {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${fieldName} must be a JSON object`);
+    }
+    return parsed;
+}
+export function createSkillToolDefinitions(baseUrl, getApiKey, headers) {
     return [
         defineTool({
             name: "litellm_skill_list",
@@ -109,7 +182,7 @@ export function createSkillToolDefinitions(baseUrl, getApiKey) {
             parameters: Type.Object({}),
             async execute() {
                 const apiKey = await getApiKey();
-                const skills = await listSkills(baseUrl, apiKey);
+                const skills = await listSkills(baseUrl, apiKey, headers);
                 return { content: [{ type: "text", text: formatSkills(skills) }], details: { count: skills.length } };
             },
         }),
@@ -120,10 +193,17 @@ export function createSkillToolDefinitions(baseUrl, getApiKey) {
             parameters: CreateSkillParams,
             async execute(_toolCallId, params) {
                 const apiKey = await getApiKey();
+                const source = params.sourceJson ? parseJsonObject(params.sourceJson, "sourceJson") : undefined;
                 const inputSchema = params.inputSchemaJson
-                    ? JSON.parse(params.inputSchemaJson)
+                    ? parseJsonObject(params.inputSchemaJson, "inputSchemaJson")
                     : undefined;
-                const result = await createSkill(baseUrl, apiKey, { ...params, inputSchema });
+                const result = await createSkill(baseUrl, apiKey, {
+                    name: params.name,
+                    description: params.description,
+                    source,
+                    code: params.code,
+                    inputSchema,
+                }, headers);
                 return { content: [{ type: "text", text: "LiteLLM skill created." }], details: { result } };
             },
         }),
@@ -134,7 +214,7 @@ export function createSkillToolDefinitions(baseUrl, getApiKey) {
             parameters: DeleteSkillParams,
             async execute(_toolCallId, params) {
                 const apiKey = await getApiKey();
-                await deleteSkill(baseUrl, apiKey, params.skillId);
+                await deleteSkill(baseUrl, apiKey, params.skillId, headers);
                 return { content: [{ type: "text", text: `LiteLLM skill deleted: ${params.skillId}` }], details: {} };
             },
         }),

package/dist/types.d.ts

@@ -3,6 +3,7 @@ export type DiscoverySource = "model_info" | "models_list" | "health";
 export interface CacheFile {
     baseUrl: string;
     apiKeyFingerprint: string;
+    headersFingerprint?: string;
     fetchedAt: number;
     source: DiscoverySource;
     models: ProviderModelConfig[];
@@ -14,6 +15,7 @@ export interface DiscoveryResult {
 export interface DiscoveryOptions {
     timeoutMs?: number;
     signal?: AbortSignal;
+    headers?: Record<string, string>;
 }
 export interface ModelInfoEntry {
     model_name?: string;
@@ -75,6 +77,14 @@ export interface LiteLLMSkill {
     name: string;
     description?: string;
     enabled?: boolean;
+    source?: Record<string, unknown>;
+    version?: string;
+    keywords?: string[];
+    domain?: string;
+    namespace?: string;
+    category?: string;
+    author?: string;
+    homepage?: string;
     input_schema?: Record<string, unknown>;
     code?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -40,7 +40,7 @@
     "image": "https://raw.githubusercontent.com/balcsida/pi-provider-litellm/refs/heads/main/assets/pi_litellm_gallery.png"
   },
   "scripts": {
-    "clean": "shx rm -rf dist",
+    "clean": "rm -rf dist",
     "build": "tsgo -p tsconfig.build.json",
     "dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
     "typecheck": "tsgo --noEmit",
@@ -64,14 +64,12 @@
     "protobufjs": "8.2.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.79.1",
-    "@earendil-works/pi-coding-agent": "^0.79.1",
+    "@earendil-works/pi-ai": "^0.80.2",
+    "@earendil-works/pi-coding-agent": "^0.80.2",
     "@biomejs/biome": "^2.4.15",
-    "@types/node": "^25.9.1",
-    "@typescript/native-preview": "7.0.0-dev.20260610.1",
-    "shx": "^0.4.0",
+    "@types/node": "^26.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.3",
     "vitest": "^4.1.7"
   }
 }