pi-provider-litellm 2.2.1 → 3.0.0

package/dist/litellm.d.ts

@@ -1 +0,0 @@
-export declare function getSessionIdFromFile(sessionFile?: string): string | undefined;

package/dist/litellm.js

@@ -1,10 +0,0 @@
-import { basename } from "node:path";
-export function getSessionIdFromFile(sessionFile) {
-    if (!sessionFile)
-        return undefined;
-    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);
-    return uuidMatch?.[1] ?? filename;
-}

package/dist/mcp-tools.d.ts

@@ -1,5 +0,0 @@
-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, allowInsecureHttp?: boolean): Promise<LiteLLMMcpTool[]>;
-export declare function executeMcpTool(baseUrl: string, apiKey: string, serverId: string, toolName: string, args: Record<string, unknown>, headers?: Record<string, string>, allowInsecureHttp?: boolean): Promise<string>;
-export declare function createMcpToolDefinitions(getAuth: (ctx?: ExtensionContext) => Promise<LiteLLMRuntimeAuth>, onProgress?: (message: string) => void, signal?: AbortSignal): Promise<ToolDefinition[]>;

package/dist/mcp-tools.js

@@ -1,181 +0,0 @@
-import { Type } from "@earendil-works/pi-ai";
-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 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;
-}
-function normalizeMcpTool(value) {
-    const raw = asRecord(value);
-    if (!raw)
-        return undefined;
-    const name = stringValue(raw.name);
-    const serverName = stringValue(raw.mcp_info?.server_name) ??
-        stringValue(raw.server_name) ??
-        stringValue(raw.mcp_info?.server_id) ??
-        stringValue(raw.server_id);
-    if (!name || !serverName)
-        return undefined;
-    const inputSchema = asRecord(raw.inputSchema) ?? asRecord(raw.input_schema) ?? { type: "object", properties: {} };
-    return {
-        name,
-        server_name: serverName,
-        server_id: stringValue(raw.mcp_info?.server_id) ?? stringValue(raw.server_id) ?? serverName,
-        description: stringValue(raw.description) ?? name,
-        input_schema: inputSchema,
-    };
-}
-export async function discoverMcpTools(baseUrl, apiKey, headers, onProgress, parentSignal, allowInsecureHttp = false) {
-    onProgress?.("Discovering MCP tools from server...");
-    try {
-        onProgress?.("Querying MCP tools/list endpoint...");
-        const response = await fetch(`${normalizeBaseUrl(baseUrl, allowInsecureHttp)}/mcp-rest/tools/list`, {
-            headers: {
-                ...headers,
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            signal: parentSignal
-                ? AbortSignal.any([parentSignal, AbortSignal.timeout(LIST_TIMEOUT_MS)])
-                : AbortSignal.timeout(LIST_TIMEOUT_MS),
-        });
-        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 : [];
-        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 (error) {
-        onProgress?.("MCP tools discovery encountered an error");
-        throw error;
-    }
-}
-export async function executeMcpTool(baseUrl, apiKey, serverId, toolName, args, headers, allowInsecureHttp = false) {
-    for (let attempt = 0; attempt <= MCP_RETRY_ATTEMPTS; attempt++) {
-        const result = await executeMcpToolOnce(baseUrl, apiKey, serverId, toolName, args, headers, allowInsecureHttp);
-        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, allowInsecureHttp = false) {
-    try {
-        let response;
-        try {
-            response = await fetch(`${normalizeBaseUrl(baseUrl, allowInsecureHttp)}/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: AbortSignal.timeout(CALL_TIMEOUT_MS),
-            });
-        }
-        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 { text: formatMcpToolError(toolName, serverId, error), retryable: false };
-    }
-}
-function sanitizeName(name) {
-    const sanitized = name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "_")
-        .replace(/^_+|_+$/g, "");
-    return sanitized || "tool";
-}
-function buildParameters(inputSchema) {
-    const properties = inputSchema.properties;
-    if (!properties || typeof properties !== "object") {
-        return Type.Object({
-            args: Type.Record(Type.String(), Type.Unknown(), { description: "Tool arguments as key-value pairs" }),
-        });
-    }
-    return Type.Unsafe(inputSchema);
-}
-export async function createMcpToolDefinitions(getAuth, onProgress, signal) {
-    const discoveryAuth = await getAuth();
-    const tools = await discoverMcpTools(discoveryAuth.baseUrl, discoveryAuth.apiKey, discoveryAuth.headers, onProgress, signal, discoveryAuth.allowInsecureHttp);
-    return tools.map((mcpTool) => {
-        const safeServer = sanitizeName(mcpTool.server_name);
-        const safeTool = sanitizeName(mcpTool.name);
-        const parameters = buildParameters(mcpTool.input_schema);
-        return defineTool({
-            name: `mcp_${safeServer}_${safeTool}`,
-            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, _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(auth.baseUrl, auth.apiKey, mcpTool.server_id ?? mcpTool.server_name, mcpTool.name, args, auth.headers, auth.allowInsecureHttp);
-                return {
-                    content: [{ type: "text", text }],
-                    details: { server: mcpTool.server_name, serverId: mcpTool.server_id, tool: mcpTool.name },
-                };
-            },
-        });
-    });
-}

package/dist/provider.d.ts

@@ -1,16 +0,0 @@
-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;
-    /** 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>[];
-    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

@@ -1,40 +0,0 @@
-import { createProvider } from "@earendil-works/pi-ai";
-import { openAICompletionsApi, openAIResponsesApi } from "@earendil-works/pi-ai/compat";
-import { enrichCachedModel } from "./discover.js";
-export function toNativeModels(provider, baseUrl, models) {
-    return models.map((model) => ({
-        ...model,
-        provider,
-        api: model.api ?? "openai-completions",
-        baseUrl,
-    }));
-}
-export function createLiteLLMProvider(options) {
-    const provider = createProvider({
-        id: options.id,
-        name: options.name,
-        baseUrl: options.baseUrl,
-        auth: options.auth,
-        models: options.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(),
-        },
-    });
-    const refreshModels = provider.refreshModels;
-    if (!refreshModels)
-        return provider;
-    return {
-        ...provider,
-        refreshModels: (context) => refreshModels({
-            ...context,
-            stored: context.stored && { ...context.stored, models: context.stored.models.map(enrichCachedModel) },
-        }),
-    };
-}

package/dist/skills.d.ts

@@ -1,14 +0,0 @@
-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>, allowInsecureHttp?: boolean): Promise<LiteLLMSkill[]>;
-export declare function createSkill(baseUrl: string, apiKey: string, input: {
-    name: string;
-    description?: string;
-    source?: Record<string, unknown>;
-    code?: string;
-    inputSchema?: Record<string, unknown>;
-}, headers?: Record<string, string>, allowInsecureHttp?: boolean): Promise<unknown>;
-export declare function deleteSkill(baseUrl: string, apiKey: string, skillId: string, headers?: Record<string, string>, allowInsecureHttp?: boolean): Promise<void>;
-export declare function createSkillsPromptSection(skills: LiteLLMSkill[]): string | undefined;
-export declare function createSkillToolDefinitions(getAuth: (ctx?: ExtensionContext) => Promise<LiteLLMRuntimeAuth>): ToolDefinition[];
-export declare function resetSkillsCache(): void;

package/dist/skills.js

@@ -1,225 +0,0 @@
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { normalizeBaseUrl } from "./discover.js";
-const SKILLS_CACHE_TTL_MS = 60_000;
-let skillsCache;
-function getSkillsFromBody(body) {
-    if (Array.isArray(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))
-            return record.skills;
-    }
-    return [];
-}
-export async function listSkills(baseUrl, apiKey, headers, allowInsecureHttp = false) {
-    const normalizedBaseUrl = normalizeBaseUrl(baseUrl, allowInsecureHttp);
-    if (skillsCache &&
-        skillsCache.baseUrl === normalizedBaseUrl &&
-        skillsCache.apiKey === apiKey &&
-        Date.now() - skillsCache.fetchedAt < SKILLS_CACHE_TTL_MS) {
-        return skillsCache.skills;
-    }
-    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 [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, headers, allowInsecureHttp = false) {
-    if (!input.source && !input.code)
-        throw new Error("code is required when source is omitted");
-    const normalizedBaseUrl = normalizeBaseUrl(baseUrl, allowInsecureHttp);
-    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(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, headers, allowInsecureHttp = false) {
-    const normalizedBaseUrl = normalizeBaseUrl(baseUrl, allowInsecureHttp);
-    let skillHubError;
-    const skillHubResponse = await fetch(`${normalizedBaseUrl}/claude-code/plugins/${encodeURIComponent(skillId)}`, {
-        method: "DELETE",
-        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;
-}
-function escapeXml(value) {
-    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-}
-export function createSkillsPromptSection(skills) {
-    const enabled = skills.filter((skill) => skill.enabled !== false && skill.name);
-    if (enabled.length === 0)
-        return undefined;
-    const body = enabled
-        .map((skill) => {
-        const description = skill.description?.trim() || "No description provided.";
-        return `<skill name="${escapeXml(skill.name)}">\n${escapeXml(description)}\n</skill>`;
-    })
-        .join("\n");
-    return `LiteLLM Skills Gateway provided these active skills. Use them as additional guidance when relevant.\n<litellm_skills>\n${body}\n</litellm_skills>`;
-}
-function formatSkills(skills) {
-    if (skills.length === 0)
-        return "No LiteLLM skills are registered.";
-    return skills
-        .map((skill) => `- ${skill.name}${skill.enabled === false ? " (disabled)" : ""}: ${skill.description ?? ""}`)
-        .join("\n");
-}
-const CreateSkillParams = Type.Object({
-    name: Type.String({ description: "Skill name" }),
-    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" }),
-});
-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(getAuth) {
-    return [
-        defineTool({
-            name: "litellm_skill_list",
-            label: "LiteLLM Skills",
-            description: "List skills registered on the LiteLLM proxy Skills Gateway.",
-            promptSnippet: "List LiteLLM Skills Gateway skills",
-            parameters: Type.Object({}),
-            async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-                const auth = await getAuth(ctx);
-                const skills = await listSkills(auth.baseUrl, auth.apiKey, auth.headers, auth.allowInsecureHttp);
-                return { content: [{ type: "text", text: formatSkills(skills) }], details: { count: skills.length } };
-            },
-        }),
-        defineTool({
-            name: "litellm_skill_create",
-            label: "Create LiteLLM Skill",
-            description: "Create a skill on the LiteLLM proxy Skills Gateway.",
-            parameters: CreateSkillParams,
-            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(auth.baseUrl, auth.apiKey, {
-                    name: params.name,
-                    description: params.description,
-                    source,
-                    code: params.code,
-                    inputSchema,
-                }, auth.headers, auth.allowInsecureHttp);
-                return { content: [{ type: "text", text: "LiteLLM skill created." }], details: { result } };
-            },
-        }),
-        defineTool({
-            name: "litellm_skill_delete",
-            label: "Delete LiteLLM Skill",
-            description: "Delete a skill from the LiteLLM proxy Skills Gateway.",
-            parameters: DeleteSkillParams,
-            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-                const auth = await getAuth(ctx);
-                await deleteSkill(auth.baseUrl, auth.apiKey, params.skillId, auth.headers, auth.allowInsecureHttp);
-                return { content: [{ type: "text", text: `LiteLLM skill deleted: ${params.skillId}` }], details: {} };
-            },
-        }),
-    ];
-}
-export function resetSkillsCache() {
-    skillsCache = undefined;
-}

package/dist/types.d.ts

@@ -1,100 +0,0 @@
-import type { Model } from "@earendil-works/pi-ai";
-export type DiscoverySource = "model_info" | "models_list" | "health";
-export type LiteLLMApi = "openai-completions" | "openai-responses";
-export type LiteLLMRuntimeAuth = {
-    baseUrl: string;
-    apiKey: string;
-    headers?: Record<string, string>;
-    allowInsecureHttp?: boolean;
-};
-export type DiscoveredModel = Omit<Model<"openai-completions">, "provider" | "api" | "baseUrl"> & {
-    api?: LiteLLMApi;
-};
-export interface DiscoveryResult {
-    models: DiscoveredModel[];
-    source: DiscoverySource;
-}
-export interface DiscoveryOptions {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-    headers?: Record<string, string>;
-    allowInsecureHttp?: boolean;
-}
-export interface ModelInfoEntry {
-    model_name?: string;
-    model_info?: {
-        mode?: string | null;
-        input_cost_per_token?: number;
-        output_cost_per_token?: number;
-        cache_read_input_token_cost?: number;
-        cache_creation_input_token_cost?: number;
-        max_input_tokens?: number;
-        max_output_tokens?: number;
-        supports_reasoning?: boolean;
-        supports_none_reasoning_effort?: boolean;
-        supports_minimal_reasoning_effort?: boolean;
-        supports_low_reasoning_effort?: boolean;
-        supports_medium_reasoning_effort?: boolean;
-        supports_high_reasoning_effort?: boolean;
-        supports_xhigh_reasoning_effort?: boolean;
-        supports_max_reasoning_effort?: boolean;
-        supports_vision?: boolean;
-    };
-}
-export interface ModelInfoResponse {
-    data?: ModelInfoEntry[];
-}
-export interface HealthModelEntry {
-    model?: string;
-    model_id?: string;
-    api_base?: string;
-}
-export interface HealthResponse {
-    healthy_endpoints?: HealthModelEntry[];
-}
-export interface ModelsListEntry {
-    id?: string;
-    owned_by?: string;
-}
-export interface ModelsListResponse {
-    data?: ModelsListEntry[];
-}
-export type AuthFileEntry = {
-    type: "oauth";
-    access: string;
-    refresh: string;
-    expires: number;
-    baseUrl?: string;
-} | {
-    type: "api_key";
-    key: string;
-};
-export interface ResolvedCredentials {
-    baseUrl?: string;
-    apiKey?: string;
-    apiKeyFingerprint?: string;
-    apiKeyConfig?: string;
-}
-export interface LiteLLMMcpTool {
-    name: string;
-    server_name: string;
-    server_id?: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-}
-export interface LiteLLMSkill {
-    id?: string;
-    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/dist/types.js

@@ -1 +0,0 @@
-export {};