pi-provider-litellm 2.2.1 → 3.0.0

package/dist/discover.js

@@ -1,333 +0,0 @@
-import { isIP } from "node:net";
-import { getModels, getProviders } from "@earendil-works/pi-ai/compat";
-const DEFAULT_TIMEOUT_MS = 5000;
-const DEFAULT_CONTEXT_WINDOW = 128_000;
-const DEFAULT_MAX_TOKENS = 16_384;
-const KNOWN_PROVIDER_SET = new Set(getProviders());
-export function normalizeBaseUrl(input, allowInsecureHttp = false) {
-    const url = new URL(input);
-    const hostname = url.hostname.toLowerCase();
-    const loopback = hostname === "localhost" || hostname === "[::1]" || (isIP(hostname) === 4 && hostname.startsWith("127."));
-    if (url.protocol !== "https:" && !(url.protocol === "http:" && (loopback || allowInsecureHttp))) {
-        throw new Error("LiteLLM base URL must use HTTPS except for loopback hosts");
-    }
-    return input.replace(/\/+$/, "").replace(/\/v1\/?$/i, "");
-}
-const RESPONSES_MODE_PATTERN = /^responses?$/i;
-function isResponsesMode(mode) {
-    return mode != null && RESPONSES_MODE_PATTERN.test(mode);
-}
-function isChatStyleMode(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.
-// `google/claude-sonnet-4-6`, `opus-4.7`, `sonnet-4.6`, `haiku-4.5`). Without
-// the `cacheControlFormat: "anthropic"` flag, pi never relays cache_control
-// markers through the proxy, so prompt caching silently no-ops on Claude models.
-const ANTHROPIC_MODEL_PATTERN = /(?:^|[-_/.:])(?:anthropic\/|(?:claude|opus|sonnet|haiku)(?=$|[-_/.:]))/i;
-const MOONSHOT_MODEL_PATTERN = /^(moonshotai\/|moonshot\/|kimi[-/])/i;
-const FORCED_THINKING_MODEL_PATTERN = /(?:^|[-/])thinking(?:[-/]|$)/i;
-// Deployments expose the gpt-5.5 route under varying names (`llm-gateway/gpt-5.5`,
-// bare `gpt-5.5`, dated ids like `gpt-5.5-20260504143601`); match them all so the
-// tool+reasoning workaround survives route renames.
-const GPT55_MODEL_PATTERN = /(?:^|\/)gpt-5\.5(?:$|[-.])/i;
-export function isMoonshotModel(modelId) {
-    return MOONSHOT_MODEL_PATTERN.test(modelId);
-}
-export function isGpt55Model(modelId) {
-    return GPT55_MODEL_PATTERN.test(modelId);
-}
-export function shouldSuppressReasoningContent(modelId) {
-    return isMoonshotModel(modelId) && !FORCED_THINKING_MODEL_PATTERN.test(modelId);
-}
-export function buildCompat(modelId) {
-    if (isMoonshotModel(modelId)) {
-        return {
-            supportsStore: false,
-            supportsDeveloperRole: false,
-            supportsReasoningEffort: false,
-            supportsStrictMode: false,
-            maxTokensField: "max_tokens",
-        };
-    }
-    if (ANTHROPIC_MODEL_PATTERN.test(modelId)) {
-        return { supportsStore: false, cacheControlFormat: "anthropic" };
-    }
-    return { supportsStore: false };
-}
-function toKnownProvider(provider) {
-    if (!provider)
-        return undefined;
-    const normalized = provider.toLowerCase();
-    return KNOWN_PROVIDER_SET.has(normalized) ? normalized : undefined;
-}
-function findCatalogModel(id, ownedBy) {
-    const prefixProvider = toKnownProvider(id.split("/")[0]);
-    const lookupIds = catalogLookupIds(id);
-    const candidates = [toKnownProvider(ownedBy), prefixProvider, lookupIds.length > 1 ? "anthropic" : undefined].filter((provider) => provider !== undefined);
-    for (const provider of candidates) {
-        const match = findCatalogModelInProvider(provider, lookupIds);
-        if (match)
-            return match;
-    }
-    for (const provider of getProviders()) {
-        const match = findCatalogModelInProvider(provider, lookupIds);
-        if (match)
-            return match;
-    }
-    return undefined;
-}
-export function enrichCachedModel(model) {
-    // ponytail: legacy cache lacks field provenance; add per-field cache provenance if strict preservation becomes necessary.
-    if (!model.name.endsWith(" (no metadata)") ||
-        model.reasoning ||
-        model.thinkingLevelMap !== undefined ||
-        model.input.length !== 1 ||
-        model.input[0] !== "text" ||
-        model.cost.input !== 0 ||
-        model.cost.output !== 0 ||
-        model.cost.cacheRead !== 0 ||
-        model.cost.cacheWrite !== 0 ||
-        model.cost.tiers !== undefined ||
-        model.contextWindow !== DEFAULT_CONTEXT_WINDOW ||
-        model.maxTokens !== DEFAULT_MAX_TOKENS) {
-        return model;
-    }
-    const catalogModel = findCatalogModel(model.id);
-    if (!catalogModel)
-        return model;
-    return {
-        ...model,
-        name: catalogModel.name,
-        reasoning: catalogModel.reasoning,
-        thinkingLevelMap: catalogModel.thinkingLevelMap,
-        input: catalogModel.input,
-        cost: catalogModel.cost,
-        contextWindow: catalogModel.contextWindow,
-        maxTokens: catalogModel.maxTokens,
-    };
-}
-function catalogLookupIds(id) {
-    const lookupIds = new Set([id]);
-    const unprefixed = id.includes("/") ? id.slice(id.indexOf("/") + 1) : id;
-    lookupIds.add(unprefixed);
-    const anthropicAlias = unprefixed.toLowerCase().replaceAll(".", "-");
-    const match = /^(?:claude-)?(opus|sonnet|haiku)-(\d+)-(\d+)$/.exec(anthropicAlias);
-    if (match)
-        lookupIds.add(`claude-${match[1]}-${match[2]}-${match[3]}`);
-    if (anthropicAlias === "fable-5" || anthropicAlias === "opus-5")
-        lookupIds.add(`claude-${anthropicAlias}`);
-    return [...lookupIds];
-}
-function findCatalogModelInProvider(provider, lookupIds) {
-    for (const lookupId of lookupIds) {
-        const exact = getModels(provider).find((model) => model.id === lookupId);
-        if (exact)
-            return exact;
-        const providerQualified = getModels(provider).find((model) => model.id === `${provider}/${lookupId}`);
-        if (providerQualified)
-            return providerQualified;
-    }
-    return undefined;
-}
-function mapModelInfoCost(info, fallback) {
-    return {
-        input: info.input_cost_per_token !== undefined ? info.input_cost_per_token * 1_000_000 : (fallback?.input ?? 0),
-        output: info.output_cost_per_token !== undefined ? info.output_cost_per_token * 1_000_000 : (fallback?.output ?? 0),
-        cacheRead: info.cache_read_input_token_cost !== undefined
-            ? info.cache_read_input_token_cost * 1_000_000
-            : (fallback?.cacheRead ?? 0),
-        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 } : {}),
-    };
-}
-async function fetchJson(url, apiKey, options) {
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const response = await fetch(url, {
-        headers: { ...options.headers, Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
-        signal: options.signal
-            ? AbortSignal.any([options.signal, AbortSignal.timeout(timeoutMs)])
-            : AbortSignal.timeout(timeoutMs),
-    });
-    if (!response.ok)
-        return { ok: false, status: response.status };
-    const data = (await response.json());
-    return { ok: true, data };
-}
-function mapReasoningEfforts(info) {
-    const flags = [
-        ["off", "none", info.supports_none_reasoning_effort],
-        ["minimal", "minimal", info.supports_minimal_reasoning_effort],
-        ["low", "low", info.supports_low_reasoning_effort],
-        ["medium", "medium", info.supports_medium_reasoning_effort],
-        ["high", "high", info.supports_high_reasoning_effort],
-        ["xhigh", "xhigh", info.supports_xhigh_reasoning_effort],
-        ["max", "max", info.supports_max_reasoning_effort],
-    ];
-    const map = Object.fromEntries(flags
-        .filter(([, , supported]) => supported !== undefined)
-        .map(([level, value, supported]) => [level, supported ? value : null]));
-    return Object.keys(map).length > 0 ? map : undefined;
-}
-function mapFromModelInfo(entry) {
-    const id = entry.model_name;
-    if (!id)
-        return undefined;
-    const info = entry.model_info ?? {};
-    if (!isChatStyleMode(info.mode))
-        return undefined;
-    const responsesMode = isResponsesMode(info.mode);
-    const catalogModel = findCatalogModel(id);
-    const reasoningEffortMap = mapReasoningEfforts(info);
-    const thinkingLevelMap = catalogModel?.thinkingLevelMap || reasoningEffortMap
-        ? { ...catalogModel?.thinkingLevelMap, ...reasoningEffortMap }
-        : undefined;
-    return {
-        id,
-        name: id,
-        reasoning: info.supports_reasoning ?? false,
-        ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
-        input: info.supports_vision ? ["text", "image"] : ["text"],
-        cost: mapModelInfoCost(info, catalogModel?.cost),
-        contextWindow: info.max_input_tokens ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: info.max_output_tokens ?? DEFAULT_MAX_TOKENS,
-        compat: buildCompat(id),
-        ...(responsesMode ? { api: "openai-responses" } : {}),
-    };
-}
-function mapFromHealthModelInfo(entry, fallbackId) {
-    if (entry.model_name || !fallbackId)
-        return mapFromModelInfo(entry);
-    const model = mapFromModelInfo({ ...entry, model_name: fallbackId });
-    if (model)
-        delete model.thinkingLevelMap;
-    return model;
-}
-function mapFromHealthEndpoint(entry) {
-    const id = entry.model;
-    if (!id)
-        return undefined;
-    const catalogModel = findCatalogModel(id);
-    return {
-        id,
-        name: catalogModel?.name ?? id,
-        reasoning: catalogModel?.reasoning ?? false,
-        thinkingLevelMap: catalogModel?.thinkingLevelMap,
-        input: catalogModel?.input ?? ["text"],
-        cost: catalogModel?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: catalogModel?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: catalogModel?.maxTokens ?? DEFAULT_MAX_TOKENS,
-        compat: buildCompat(id),
-    };
-}
-function mapFromModelsList(entry) {
-    const id = entry.id;
-    if (!id)
-        return undefined;
-    const catalogModel = findCatalogModel(id, entry.owned_by);
-    return {
-        id,
-        name: catalogModel?.name ?? `${id} (no metadata)`,
-        reasoning: catalogModel?.reasoning ?? false,
-        thinkingLevelMap: catalogModel?.thinkingLevelMap,
-        input: catalogModel?.input ?? ["text"],
-        cost: catalogModel?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: catalogModel?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: catalogModel?.maxTokens ?? DEFAULT_MAX_TOKENS,
-        compat: buildCompat(id),
-    };
-}
-async function discoverFromHealth(base, apiKey, options) {
-    const progress = options.silent ? undefined : options.onProgress;
-    progress?.("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);
-    progress?.(`Discovered ${endpoints.length} model endpoints, fetching details...`);
-    let completed = 0;
-    const models = await Promise.all(endpoints.map(async (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) {
-            progress?.(`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.allowInsecureHttp);
-    const progress = options.silent ? undefined : options.onProgress;
-    progress?.("Querying /model/info endpoint...");
-    const infoResult = await fetchJson(`${base}/model/info`, apiKey, options);
-    if (infoResult.ok) {
-        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 },
-            });
-        }
-        let models = [...entries.values()].map(mapFromModelInfo).filter((m) => m !== undefined);
-        // LiteLLM's /model/info does NOT expand wildcard model_name entries (e.g.
-        // "lemonade/*" backed by model: openai/* + check_provider_endpoint: true)
-        // — it returns the literal wildcard only. The discovered ids live in
-        // /v1/models instead. When /model/info contains any wildcard id, also query
-        // /v1/models and merge the expanded (non-wildcard) entries in, dropping the
-        // raw wildcard row so it doesn't surface as a phantom model choice.
-        // Ref: docs.litellm.ai/docs/proxy/model_discovery
-        if (models.some((m) => m.id.includes("*"))) {
-            progress?.("/model/info has wildcard entries, expanding via /v1/models...");
-            const listResult = await fetchJson(`${base}/v1/models`, apiKey, options);
-            if (listResult.ok) {
-                const expanded = (listResult.data.data ?? [])
-                    .map(mapFromModelsList)
-                    .filter((m) => m !== undefined && !m.id.includes("*"));
-                const seen = new Set(models.map((m) => m.id));
-                models = [...models.filter((m) => !m.id.includes("*")), ...expanded.filter((m) => !seen.has(m.id))];
-            }
-        }
-        return { source: "model_info", models: deduplicateModels(models) };
-    }
-    if (![401, 403, 404].includes(infoResult.status)) {
-        throw new Error(`/model/info returned ${infoResult.status}`);
-    }
-    progress?.("/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)) {
-            progress?.("/v1/models unavailable, falling back to /health endpoint...");
-            const models = await discoverFromHealth(base, apiKey, options);
-            if (models.length > 0)
-                return { source: "health", models: deduplicateModels(models) };
-        }
-        throw new Error(`/v1/models returned ${listResult.status}`);
-    }
-    const models = (listResult.data.data ?? [])
-        .map(mapFromModelsList)
-        .filter((m) => m !== undefined);
-    return { source: "models_list", models: deduplicateModels(models) };
-}

package/dist/gcloud-token-cli.d.ts

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

package/dist/gcloud-token-cli.js

@@ -1,8 +0,0 @@
-import { getGcloudToken } from "./gcloud-token.js";
-const token = await getGcloudToken();
-if (token) {
-    process.stdout.write(token);
-}
-else {
-    process.exitCode = 1;
-}

package/dist/gcloud-token.d.ts

@@ -1,7 +0,0 @@
-export declare const CACHE_TTL_MS: number;
-export declare const GCLOUD_TOKEN_CACHE_KEY = "gcloud-adc";
-export declare function isGcloudTokenAuthEnabled(): boolean;
-export declare function getGcloudTokenCommand(): string;
-export declare function getGcloudTokenCacheKey(): Promise<string | null>;
-export declare function getGcloudToken(): Promise<string | null>;
-export declare function resetGcloudTokenCache(): void;

package/dist/gcloud-token.js

@@ -1,133 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-export const CACHE_TTL_MS = 50 * 60 * 1000;
-export const GCLOUD_TOKEN_CACHE_KEY = "gcloud-adc";
-const ADC_FILENAME = "application_default_credentials.json";
-let cachedToken = null;
-let cachedAt = 0;
-let cachedTokenKey = null;
-function isAuthorizedUserCredentials(credentials) {
-    return (credentials.type === "authorized_user" &&
-        typeof credentials.client_id === "string" &&
-        typeof credentials.client_secret === "string" &&
-        typeof credentials.refresh_token === "string");
-}
-export function isGcloudTokenAuthEnabled() {
-    const raw = process.env.LITELLM_GCLOUD_TOKEN_AUTH;
-    return raw !== undefined && raw !== "" && raw !== "0";
-}
-function shellQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-export function getGcloudTokenCommand() {
-    const cliPath = fileURLToPath(new URL("./gcloud-token-cli.js", import.meta.url));
-    return `!${shellQuote(process.execPath)} ${shellQuote(cliPath)}`;
-}
-function getAdcPath() {
-    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    if (envPath)
-        return envPath;
-    const candidates = [join(homedir(), ".config", "gcloud", ADC_FILENAME)];
-    if (process.env.APPDATA)
-        candidates.push(join(process.env.APPDATA, "gcloud", ADC_FILENAME));
-    return candidates.find((path) => existsSync(path)) ?? null;
-}
-function getCredentialsCacheKey(credentials) {
-    if (isAuthorizedUserCredentials(credentials)) {
-        return `${GCLOUD_TOKEN_CACHE_KEY}:authorized_user:${credentials.client_id}:${credentials.refresh_token}`;
-    }
-    return null;
-}
-async function readCredentials(path) {
-    try {
-        return JSON.parse(await readFile(path, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export async function getGcloudTokenCacheKey() {
-    const adcPath = getAdcPath();
-    if (!adcPath) {
-        console.warn("LiteLLM gcloud auth: No Google ADC file found. Set GOOGLE_APPLICATION_CREDENTIALS or run `gcloud auth application-default login`.");
-        return null;
-    }
-    const credentials = await readCredentials(adcPath);
-    if (!credentials) {
-        console.warn(`LiteLLM gcloud auth: Failed to read ADC file: ${adcPath}`);
-        return null;
-    }
-    const cacheKey = getCredentialsCacheKey(credentials);
-    if (cacheKey)
-        return cacheKey;
-    if (credentials.type === "service_account") {
-        console.warn("LiteLLM gcloud auth: Service account credentials are not supported; use authorized_user ADC.");
-        return null;
-    }
-    console.warn(`LiteLLM gcloud auth: Unknown credential type: ${credentials.type ?? "missing"}`);
-    return null;
-}
-async function exchangeRefreshToken(credentials) {
-    const body = new URLSearchParams({
-        grant_type: "refresh_token",
-        client_id: credentials.client_id,
-        client_secret: credentials.client_secret,
-        refresh_token: credentials.refresh_token,
-    }).toString();
-    try {
-        const response = await fetch("https://oauth2.googleapis.com/token", {
-            method: "POST",
-            headers: { "Content-Type": "application/x-www-form-urlencoded" },
-            body,
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (!response.ok) {
-            console.warn(`LiteLLM gcloud auth: Token exchange failed (${response.status})`);
-            return null;
-        }
-        const data = (await response.json());
-        return typeof data.access_token === "string" && data.access_token ? data.access_token : null;
-    }
-    catch (error) {
-        console.warn(`LiteLLM gcloud auth: Token exchange failed: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export async function getGcloudToken() {
-    const adcPath = getAdcPath();
-    if (!adcPath) {
-        console.warn("LiteLLM gcloud auth: No Google ADC file found. Set GOOGLE_APPLICATION_CREDENTIALS or run `gcloud auth application-default login`.");
-        return null;
-    }
-    const credentials = await readCredentials(adcPath);
-    if (!credentials) {
-        console.warn(`LiteLLM gcloud auth: Failed to read ADC file: ${adcPath}`);
-        return null;
-    }
-    const cacheKey = getCredentialsCacheKey(credentials);
-    if (cacheKey && cachedToken && cachedTokenKey === cacheKey && Date.now() - cachedAt < CACHE_TTL_MS)
-        return cachedToken;
-    if (isAuthorizedUserCredentials(credentials)) {
-        const token = await exchangeRefreshToken(credentials);
-        if (token) {
-            cachedToken = token;
-            cachedTokenKey = cacheKey;
-            cachedAt = Date.now();
-        }
-        return token;
-    }
-    if (credentials.type === "service_account") {
-        console.warn("LiteLLM gcloud auth: Service account credentials are not supported; use authorized_user ADC.");
-        return null;
-    }
-    console.warn(`LiteLLM gcloud auth: Unknown credential type: ${credentials.type ?? "missing"}`);
-    return null;
-}
-export function resetGcloudTokenCache() {
-    cachedToken = null;
-    cachedTokenKey = null;
-    cachedAt = 0;
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export default function (pi: ExtensionAPI): Promise<void>;