pi-provider-litellm 3.0.1 → 3.2.0

package/src/model-groups.ts

@@ -2,7 +2,32 @@ import type { Api, Model } from "@earendil-works/pi-ai";
 import { intersectThinkingLevelMaps, THINKING_LEVEL_DEFINITIONS } from "./thinking-levels.js";
 import type { DiscoveredModel, ModelInfoEntry } from "./types.js";
 
-export const DEFAULT_CONTEXT_WINDOW = 128_000;
+const BUILTIN_CONTEXT_WINDOW = 128_000;
+
+/**
+ * Context window used when neither /model/info nor the catalog reports one.
+ * LITELLM_DEFAULT_CONTEXT_WINDOW raises it for proxies whose model map cannot
+ * populate `max_input_tokens`; an unset or unusable value keeps the 128K default.
+ */
+export function defaultContextWindow(): number {
+  // Number, not parseInt: parseInt takes a numeric prefix, so `1.5` would become a
+  // 1-token window and `922000junk` would pass as a limit instead of being rejected.
+  const parsed = Number(process.env.LITELLM_DEFAULT_CONTEXT_WINDOW ?? "");
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : BUILTIN_CONTEXT_WINDOW;
+}
+
+/**
+ * Whether a stored window is one this extension assumed rather than read. A model cached
+ * under the built-in default must still read as evidence-free once an operator configures
+ * LITELLM_DEFAULT_CONTEXT_WINDOW, or the setting would never reach cached entries.
+ * ponytail: a window stored under a setting that was later lowered is indistinguishable
+ * from measured evidence and stays until the next online discovery; persist a fallback
+ * marker on the model if that ever matters.
+ */
+export function isFallbackContextWindow(contextWindow: number): boolean {
+  return contextWindow === BUILTIN_CONTEXT_WINDOW || contextWindow === defaultContextWindow();
+}
+
 export const DEFAULT_MAX_TOKENS = 16_384;
 
 export type SemanticFamily = "claude" | "deepseek" | "gemini" | "kimi" | "openai";
@@ -52,6 +77,7 @@ export interface ReducedModelGroup {
   thinkingLevelMap?: DiscoveredModel["thinkingLevelMap"];
   vision: boolean;
   contextWindow: number;
+  contextWindowDefaulted?: boolean;
   maxTokens: number;
   cost: DiscoveredModel["cost"];
   hasCompleteCost: boolean;
@@ -181,6 +207,17 @@ function normalizeEffort(level: string): (typeof EXTENDED_LEVELS)[number] | unde
   return EXTENDED_LEVELS.find((candidate) => candidate === normalized);
 }
 
+// LiteLLM reads a declared `reasoning_effort_levels` list whole, ahead of the
+// per-level flags, because flags cannot state a set such as low/high/max: medium
+// has no opt-out. A declared list therefore answers every level for its deployment.
+function reportedLevel(entry: ModelInfoEntry, level: (typeof EXTENDED_LEVELS)[number]): boolean | undefined {
+  const declared: unknown = entry.model_info?.reasoning_effort_levels;
+  if (Array.isArray(declared)) {
+    return declared.some((effort) => typeof effort === "string" && normalizeEffort(effort) === level);
+  }
+  return wireBoolean(entry.model_info?.[LITELLM_LEVEL_FLAGS[level]]);
+}
+
 // A public effort list is complete: listed standard levels are enabled and omitted
 // ones are denied. Without a public list, standard levels stay absent so Pi keeps
 // its defaults. LiteLLM flags may add or remove levels, while xhigh/max always
@@ -200,23 +237,25 @@ function reasoningLevelMap(
       map[level] = publicSets.every((set) => set.has(level)) ? (level === "off" ? "none" : level) : null;
     }
   }
-  // A catalog level map is direct evidence even when its selectable projection
-  // is empty. Preserve its denials independently from public effort lists, whose
-  // unrecognized values intentionally have no opinion.
-  for (const catalogMap of catalogMaps) Object.assign(map, deniedLevels(catalogMap));
-
-  for (const [level, flag] of Object.entries(LITELLM_LEVEL_FLAGS) as Array<
-    [keyof typeof LITELLM_LEVEL_FLAGS, (typeof LITELLM_LEVEL_FLAGS)[keyof typeof LITELLM_LEVEL_FLAGS]]
-  >) {
-    const reported = entries.map((entry) => wireBoolean(entry.model_info?.[flag]));
+  // A catalog level map is not a complete list: a null denies, a value supplies the
+  // wire spelling, and an omitted standard level keeps Pi's default. Flattening it
+  // into a list denied every standard level a map left implicit, such as Codex
+  // `gpt-5.6-sol`, which only states `xhigh`, `max`, and `minimal`.
+  for (const catalogMap of catalogMaps) {
+    for (const [level, value] of Object.entries(catalogMap ?? {}) as [keyof typeof map, string | null][]) {
+      if (value === null || (value !== undefined && map[level] !== null)) map[level] = value;
+    }
+  }
+
+  for (const level of EXTENDED_LEVELS) {
+    const reported = entries.map((entry) => reportedLevel(entry, level));
     if (reported.some((value) => value === false)) map[level] = null;
     else if (reported.length > 0 && reported.every((value) => value === true)) {
       map[level] = level === "off" ? "none" : level;
     }
   }
   for (const level of ["xhigh", "max"] as const) {
-    const flag = LITELLM_LEVEL_FLAGS[level];
-    if (!entries.every((entry) => wireBoolean(entry.model_info?.[flag]) === true)) map[level] = null;
+    if (!entries.every((entry) => reportedLevel(entry, level) === true)) map[level] = null;
   }
   return map;
 }
@@ -241,6 +280,15 @@ function acceptedParams(entry: ModelInfoEntry): Set<string> {
   return params;
 }
 
+// LiteLLM omits supported_openai_params (or returns null) for a deployment its
+// model map does not describe, so that absence says nothing about the carrier. An
+// explicit `supports_reasoning: true` is the operator's opt-in there, as in
+// LiteLLM's own effort resolution. Present but malformed data is not an absence.
+function optsIntoEffortCarrier(entry: ModelInfoEntry): boolean {
+  const supported: unknown = entry.model_info?.supported_openai_params;
+  return (supported === undefined || supported === null) && wireBoolean(entry.model_info?.supports_reasoning) === true;
+}
+
 function intersectParams(entries: readonly ModelInfoEntry[]): string[] {
   const [first, ...rest] = entries.map(acceptedParams);
   if (!first) return [];
@@ -779,7 +827,8 @@ export function reduceModelGroup(
     (entry) => wireBoolean(entry.model_info?.supports_reasoning) === false,
   );
   const vision = visionEvidence.every((value) => value ?? false);
-  const contextWindow = min(contextWindowEvidence.map((value) => value ?? DEFAULT_CONTEXT_WINDOW));
+  const fallbackContextWindow = defaultContextWindow();
+  const contextWindow = min(contextWindowEvidence.map((value) => value ?? fallbackContextWindow));
   const maxTokens = min(maxTokensEvidence.map((value) => value ?? DEFAULT_MAX_TOKENS));
 
   const costValues = COST_FIELDS.map((field) =>
@@ -830,16 +879,17 @@ export function reduceModelGroup(
     if (tiers) cost.tiers = tiers;
   }
   const acceptedOpenAIParams = intersectParams(deployments);
-  const acceptsResponsesReasoningControl = acceptedOpenAIParams.includes("reasoning_effort");
-  const publicEfforts = catalogAuthority.map(
-    (catalog) =>
-      catalog?.effortLevels ??
-      (catalog?.thinkingLevelMap
-        ? Object.entries(catalog.thinkingLevelMap)
-            .filter(([, value]) => value !== null)
-            .map(([level]) => level)
-        : undefined),
+  // Kimi and DeepSeek generations name their own carriers, so an operator opt-in
+  // cannot substitute for the parameter evidence their contracts require.
+  const namedCarrierFamily = catalogs.some((catalog) =>
+    ["kimi", "deepseek", "conflicting"].includes(catalog?.semanticFamily ?? ""),
   );
+  const acceptsResponsesReasoningControl =
+    acceptedOpenAIParams.includes("reasoning_effort") ||
+    (!namedCarrierFamily &&
+      deployments.length > 0 &&
+      deployments.every((entry) => acceptedParams(entry).has("reasoning_effort") || optsIntoEffortCarrier(entry)));
+  const publicEfforts = catalogAuthority.map((catalog) => catalog?.effortLevels);
   const evidenceLevelMap = reasoningLevelMap(deployments, publicEfforts, [
     intersectThinkingLevelMaps(catalogAuthority.map((catalog) => catalog?.thinkingLevelMap)),
   ]);
@@ -848,10 +898,8 @@ export function reduceModelGroup(
     thinkingLevelMap = intersectThinkingLevelMaps(catalogs.map((catalog) => catalog?.messagesThinkingLevelMap));
     // Native serializer restrictions apply even when catalog pricing is withheld.
     // Router flags can also deny Pi's implicit default levels, never add a level.
-    for (const [level, flag] of Object.entries(LITELLM_LEVEL_FLAGS) as Array<
-      [keyof typeof LITELLM_LEVEL_FLAGS, (typeof LITELLM_LEVEL_FLAGS)[keyof typeof LITELLM_LEVEL_FLAGS]]
-    >) {
-      const reported = deployments.map((entry) => wireBoolean(entry.model_info?.[flag]));
+    for (const level of EXTENDED_LEVELS) {
+      const reported = deployments.map((entry) => reportedLevel(entry, level));
       if (
         reported.some((value) => value === false) ||
         ((level === "xhigh" || level === "max") &&
@@ -886,9 +934,7 @@ export function reduceModelGroup(
   const semanticMap = semanticReasoningPolicy.thinkingLevelMap;
   const hasEvidenceLevels = Object.values(evidenceLevelMap ?? {}).some((level) => level !== null);
   const semanticBinary = semanticReasoningPolicy.compat?.supportsReasoningEffort === false && !hasEvidenceLevels;
-  const explicitOffDenial = deployments.some(
-    (entry) => wireBoolean(entry.model_info?.supports_none_reasoning_effort) === false,
-  );
+  const explicitOffDenial = deployments.some((entry) => reportedLevel(entry, "off") === false);
   const reasoningPolicy = semanticMap
     ? {
         ...semanticReasoningPolicy,
@@ -911,6 +957,9 @@ export function reduceModelGroup(
     ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
     vision,
     contextWindow,
+    ...(contextWindowEvidence.includes(undefined) && contextWindow === fallbackContextWindow
+      ? { contextWindowDefaulted: true }
+      : {}),
     maxTokens,
     cost,
     hasCompleteCost,
@@ -933,11 +982,6 @@ export function catalogResolution(provider: string, model: Model<Api>): CatalogR
     provider,
     catalogModelId: model.id,
     reasoning: model.reasoning,
-    effortLevels: model.thinkingLevelMap
-      ? Object.entries(model.thinkingLevelMap)
-          .filter(([, value]) => value !== null)
-          .map(([level]) => level)
-      : undefined,
     thinkingLevelMap: model.thinkingLevelMap,
     vision: model.input.includes("image"),
     contextWindow: model.contextWindow,

package/src/public-catalog.ts

@@ -12,6 +12,9 @@ const KNOWN_PROVIDERS = new Set<string>(getProviders());
 export interface PublicCatalogRecord {
   source: "models.dev" | "pi-vendor" | "pi-adapter";
   provider: string;
+  // The Pi catalog for fields a models.dev record omits, when the record was found
+  // under another vendor's key (ChatGPT routes read OpenAI's but bill as Codex).
+  piProvider?: string;
   modelId: string;
   limits?: { context?: number; output?: number };
   cost?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
@@ -54,6 +57,8 @@ const PROVIDER_ALIASES: Readonly<Record<string, readonly string[]>> = {
   azure_ai: ["azure", "openai"],
   bedrock: ["amazon-bedrock"],
   bedrock_converse: ["amazon-bedrock"],
+  // models.dev has no ChatGPT subscription provider; its routes serve OpenAI models.
+  chatgpt: ["chatgpt", "openai"],
   deepseek: ["deepseek"],
   fireworks: ["fireworks-ai"],
   fireworks_ai: ["fireworks-ai"],
@@ -68,6 +73,7 @@ const PROVIDER_ALIASES: Readonly<Record<string, readonly string[]>> = {
 const PI_PROVIDER_ALIASES: Readonly<Record<string, readonly string[]>> = {
   "amazon-bedrock": ["amazon-bedrock"],
   azure: ["azure-openai-responses"],
+  azure_ai: ["azure-openai-responses"],
   chatgpt: ["openai-codex"],
   "fireworks-ai": ["fireworks"],
   openai: ["openai"],
@@ -199,11 +205,6 @@ function mapModelsDev(provider: string, modelId: string, model: ModelsDevModel):
 
 function toPiRecord(source: "pi-vendor" | "pi-adapter", provider: string, model: Model<Api>): PublicCatalogRecord {
   const thinkingLevelMap = model.thinkingLevelMap as Record<string, unknown> | undefined;
-  const effortLevels = thinkingLevelMap
-    ? Object.entries(thinkingLevelMap)
-        .filter(([, value]) => value !== null)
-        .map(([level]) => level)
-    : [];
   return {
     source,
     provider,
@@ -216,7 +217,6 @@ function toPiRecord(source: "pi-vendor" | "pi-adapter", provider: string, model:
       cacheWrite: model.cost.cacheWrite,
     },
     modalities: model.input.includes("image") ? ["text", "image"] : ["text"],
-    ...(effortLevels.length > 0 ? { effortLevels } : {}),
     ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
   };
 }
@@ -245,25 +245,34 @@ export async function loadPublicCatalog(options: LoadPublicCatalogOptions = {}):
     lookup(provider, id) {
       const providers = providerCandidates(provider);
       const ids = lookupIds(id);
+      const vendor = providers.find((candidate) => candidate !== "azure") ?? providers[0];
+      const adapter = provider?.trim().toLowerCase();
       for (const candidate of providers) {
         const models = catalog?.[candidate]?.models;
         for (const modelId of ids) {
           const model = models?.[modelId];
-          if (model) return mapModelsDev(candidate, modelId, model);
+          if (!model) continue;
+          const record = mapModelsDev(candidate, modelId, model);
+          if (candidate === providers[0] || !vendor) return record;
+          const fallback =
+            adapter && (PI_PROVIDER_ALIASES[adapter] ?? [adapter]).some((piProvider) => findPiModel(piProvider, ids))
+              ? adapter
+              : vendor;
+          return { ...record, piProvider: (PI_PROVIDER_ALIASES[fallback] ?? [fallback])[0] };
         }
       }
-      const vendor = providers.find((candidate) => candidate !== "azure") ?? providers[0];
-      if (vendor) {
-        for (const piProvider of PI_PROVIDER_ALIASES[vendor] ?? [vendor]) {
+      // Provider-specific limits and pricing must not be replaced by the generic
+      // vendor's entry just because both catalogs recognize the model id.
+      if (adapter && adapter !== vendor) {
+        for (const piProvider of PI_PROVIDER_ALIASES[adapter] ?? [adapter]) {
           const model = findPiModel(piProvider, ids);
-          if (model) return toPiRecord("pi-vendor", piProvider, model);
+          if (model) return toPiRecord("pi-adapter", piProvider, model);
         }
       }
-      const adapter = provider?.trim().toLowerCase();
-      if (adapter) {
-        for (const piProvider of PI_PROVIDER_ALIASES[adapter] ?? [adapter]) {
+      if (vendor) {
+        for (const piProvider of PI_PROVIDER_ALIASES[vendor] ?? [vendor]) {
           const model = findPiModel(piProvider, ids);
-          if (model) return toPiRecord("pi-adapter", piProvider, model);
+          if (model) return toPiRecord("pi-vendor", piProvider, model);
         }
       }
       return undefined;

package/src/skills.ts

@@ -42,97 +42,55 @@ export async function listSkills(
     return skillsCache.skills;
   }
 
-  const fetchSkills = async (path: string): Promise<LiteLLMSkill[]> => {
+  const fetchSkills = async (path: string): Promise<LiteLLMSkill[] | undefined> => {
     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()) : [];
+      return response.ok ? getSkillsFromBody(await response.json()) : undefined;
     } catch {
-      return [];
+      return undefined;
     }
   };
 
-  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))];
+  const skills = (await fetchSkills("/claude-code/marketplace.json")) ?? (await fetchSkills("/v1/skills")) ?? [];
   skillsCache = { baseUrl: normalizedBaseUrl, apiKey, fetchedAt: Date.now(), skills };
   return skills;
 }
 
+// Only the Skill Hub creates skills from JSON. LiteLLM's POST /v1/skills is Anthropic's multipart
+// Skills API, so a JSON code skill sent there never becomes a listable skill.
 export async function createSkill(
   baseUrl: string,
   apiKey: string,
-  input: {
-    name: string;
-    description?: string;
-    source?: Record<string, unknown>;
-    code?: string;
-    inputSchema?: Record<string, unknown>;
-  },
+  input: { name: string; description?: string; source: Record<string, unknown> },
   headers?: Record<string, string>,
   allowInsecureHttp = false,
 ): Promise<unknown> {
-  if (!input.source && !input.code) throw new Error("code is required when source is omitted");
+  if (!input.source) throw new Error("source is required: skills are created through the LiteLLM Skill Hub");
   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"}`, {
+  const response = await fetch(`${normalizedBaseUrl}/claude-code/plugins`, {
     method: "POST",
     headers: {
       ...headers,
       Authorization: `Bearer ${apiKey}`,
       "Content-Type": "application/json",
     },
-    body: JSON.stringify(skillHubPayload),
+    body: JSON.stringify({ name: input.name, description: input.description, source: input.source }),
     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}`);
-  }
+  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(() => ({}));
 }
 
@@ -196,9 +154,7 @@ function formatSkills(skills: LiteLLMSkill[]): string {
 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" })),
+  sourceJson: Type.String({ description: "Skill Hub source metadata JSON object" }),
 });
 
 const DeleteSkillParams = Type.Object({
@@ -232,24 +188,15 @@ export function createSkillToolDefinitions(
     defineTool({
       name: "litellm_skill_create",
       label: "Create LiteLLM Skill",
-      description: "Create a skill on the LiteLLM proxy Skills Gateway.",
+      description: "Create and enable a skill on the LiteLLM proxy Skill Hub from source metadata.",
       parameters: CreateSkillParams,
       async execute(_toolCallId, params: Static<typeof CreateSkillParams>, _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 source = parseJsonObject(params.sourceJson, "sourceJson");
         const result = await createSkill(
           auth.baseUrl,
           auth.apiKey,
-          {
-            name: params.name,
-            description: params.description,
-            source,
-            code: params.code,
-            inputSchema,
-          },
+          { name: params.name, description: params.description, source },
           auth.headers,
           auth.allowInsecureHttp,
         );

package/src/thinking-levels.ts

@@ -19,6 +19,10 @@ type ThinkingLevelDefinitionsAreExhaustive = AssertNever<
 
 type ThinkingLevelMap = DiscoveredModel["thinkingLevelMap"];
 
+// Pi sends an omitted standard level as its own name. An omitted `off` sends no
+// disable value and omitted `xhigh`/`max` are unsupported, so those stay distinct.
+const IMPLICIT_LEVELS = new Set<string>(["minimal", "low", "medium", "high"]);
+
 // Intersects independently authoritative maps. A level mentioned by any source
 // is denied unless every source supplies the same mapping for that level.
 export function intersectThinkingLevelMaps(maps: readonly ThinkingLevelMap[]): ThinkingLevelMap {
@@ -26,8 +30,9 @@ export function intersectThinkingLevelMaps(maps: readonly ThinkingLevelMap[]): T
 
   const intersection: NonNullable<ThinkingLevelMap> = {};
   for (const [level] of THINKING_LEVEL_DEFINITIONS) {
-    const values = maps.map((map) => map?.[level]);
-    if (values.every((value) => value === undefined)) continue;
+    const stated = maps.map((map) => map?.[level]);
+    if (stated.every((value) => value === undefined)) continue;
+    const values = stated.map((value) => (value === undefined && IMPLICIT_LEVELS.has(level) ? level : value));
     const first = values[0];
     intersection[level] = first !== undefined && values.every((value) => value === first) ? first : null;
   }

package/src/types.ts

@@ -63,6 +63,8 @@ export interface DiscoveryOptions {
   signal?: AbortSignal;
   headers?: Record<string, string>;
   allowInsecureHttp?: boolean;
+  // `false` reads only an existing cache at `modelsDevCachePath`; with no cache
+  // path, models.dev is not consulted at all.
   modelsDev?: boolean;
   modelsDevCachePath?: string;
 }
@@ -89,6 +91,7 @@ export interface ModelInfoEntry {
     max_input_tokens?: number;
     max_output_tokens?: number;
     supports_reasoning?: boolean;
+    reasoning_effort_levels?: string[];
     supports_none_reasoning_effort?: boolean;
     supports_minimal_reasoning_effort?: boolean;
     supports_low_reasoning_effort?: boolean;