pi-provider-litellm 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-litellm",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "LiteLLM proxy provider extension for Pi",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -1125,16 +1125,25 @@ async function refreshLiteLLM(
   return { ...credentials, access, expires: tokenExpiresAt(access, EXPIRE_TOKEN_IMMEDIATELY) };
 }
 
+async function configuredBaseUrl(
+  definition: ProviderDefinition,
+  ctx: { env(name: string): Promise<string | undefined> },
+  credential?: ApiKeyCredential,
+): Promise<string | undefined> {
+  return (
+    cleanConfig(credential?.env?.[ENV_BASE_URL]) ??
+    cleanConfig(definition.baseUrl) ??
+    (definition.useDefaultEnv ? cleanConfig(await ctx.env(ENV_BASE_URL)) : undefined)
+  );
+}
+
 async function resolveApiKeyAuth(
   definition: ProviderDefinition,
   ctx: { env(name: string): Promise<string | undefined> },
   credential?: ApiKeyCredential,
   executeHelpers = true,
 ) {
-  const baseUrl =
-    cleanConfig(credential?.env?.[ENV_BASE_URL]) ??
-    cleanConfig(definition.baseUrl) ??
-    (definition.useDefaultEnv ? cleanConfig(await ctx.env(ENV_BASE_URL)) : undefined);
+  const baseUrl = await configuredBaseUrl(definition, ctx, credential);
   const stored = credential?.key
     ? resolveConfigValue(credential.key, { executeCommands: executeHelpers })?.trim()
     : undefined;
@@ -1209,6 +1218,7 @@ function createProviderAuth(
   definition: ProviderDefinition,
   clearOAuthRuntimeRoot?: () => void,
   onLogin?: () => void,
+  oauthRuntimeRoot?: () => { apiKey: string; root: string } | undefined,
 ): ProviderAuth {
   function completeLogin<T extends Credential>(credential: T): T {
     onLogin?.();
@@ -1255,6 +1265,34 @@ function createProviderAuth(
         return fallback ? { type: "api_key", source: fallback } : undefined;
       },
       resolve: async ({ ctx, credential }) => {
+        // Pi re-resolves auth through this api-key path whenever a caller passes an explicit
+        // apiKey override — compaction and summarization both hand back the key they just
+        // resolved — which bypasses the stored OAuth credential carrying the base URL. The
+        // api-key path exports its root as env so it survives that round trip, but OAuth's
+        // toAuth has no env to export, leaving an SSO session no record of its root. Read it
+        // back from auth.json, the same fallback check() and seedModels() use, and export it
+        // so the request carries the root rather than depending on in-memory state. auth.json is
+        // shared, though: another Pi process logging in replaces the stored token while this one
+        // still holds its own, so fall back to the root this process resolved for that exact
+        // token. Only when nothing configures a root at all: a base URL that is set still
+        // resolves, and still fails, on its own terms rather than silently rerouting.
+        if (credential?.key && !(await configuredBaseUrl(definition, ctx, credential))) {
+          const stored = readStoredCredential(definition.name, join(getAgentDir(), "auth.json"));
+          const remembered = oauthRuntimeRoot?.();
+          const root =
+            stored?.type === "oauth" && stored.access === credential.key
+              ? requireCredentialRoot(resolveCredentialRoot(definition, stored), definition.name)
+              : remembered?.apiKey === credential.key
+                ? remembered.root
+                : undefined;
+          if (root) {
+            return {
+              auth: { apiKey: credential.key, headers: resolveHeaders(definition), baseUrl: root },
+              env: { [ENV_BASE_URL]: root },
+              source: "OAuth",
+            };
+          }
+        }
         clearOAuthRuntimeRoot?.();
         return resolveApiKeyAuth(definition, ctx, credential);
       },
@@ -1867,6 +1905,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       definition,
       () => oauthRuntimeRoots.delete(definition.name),
       definition.name === PROVIDER_NAME ? resumeMcpDiscovery : undefined,
+      () => oauthRuntimeRoots.get(definition.name),
     );
     if (auth.oauth) {
       if (definition.name === PROVIDER_NAME) {

package/src/model-groups.ts

@@ -169,13 +169,12 @@ function explicitLimit(value: number | undefined): number | undefined {
 
 const EXTENDED_LEVELS = THINKING_LEVEL_DEFINITIONS.map(([level]) => level);
 
-const LITELLM_LEVEL_FLAGS = {
-  off: "supports_none_reasoning_effort",
-  minimal: "supports_minimal_reasoning_effort",
-  low: "supports_low_reasoning_effort",
-  xhigh: "supports_xhigh_reasoning_effort",
-  max: "supports_max_reasoning_effort",
-} as const;
+// Derived from the level table rather than restated: a second hand-written copy
+// silently dropped `supports_medium_reasoning_effort` and
+// `supports_high_reasoning_effort`, so those router flags were never read.
+const LITELLM_LEVEL_FLAGS = Object.fromEntries(THINKING_LEVEL_DEFINITIONS.map(([level, , flag]) => [level, flag])) as {
+  [Definition in (typeof THINKING_LEVEL_DEFINITIONS)[number] as Definition[0]]: Definition[2];
+};
 
 function normalizeEffort(level: string): (typeof EXTENDED_LEVELS)[number] | undefined {
   const normalized = level === "none" ? "off" : level;
@@ -273,9 +272,10 @@ export const NO_TRANSMISSIBLE_LEVELS = {
 
 // Efforts the Responses API accepts. pi-ai passes an unmapped level through
 // verbatim and reads `thinkingLevelMap.off` as the disable value, so a Chat-shaped
-// map would emit `off` or `max` as an effort. `none` is the disable spelling —
-// pi-ai's own `openai/gpt-5.5` entry maps `off` to it.
-const RESPONSES_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
+// map would emit `off` as an effort. `none` is the disable spelling — pi-ai's own
+// `openai/gpt-5.5` entry maps `off` to it, and its `openai/gpt-5.6-*` entries map
+// `max` to itself, so `max` is a real Responses effort and not a Chat-only value.
+const RESPONSES_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 // A level map is only meaningful next to the compat that serializes it, and the
 // two used to travel separately: five call sites each decided whether to copy

package/src/thinking-levels.ts

@@ -5,8 +5,8 @@ export const THINKING_LEVEL_DEFINITIONS = [
   ["off", "none", "supports_none_reasoning_effort"],
   ["minimal", "minimal", "supports_minimal_reasoning_effort"],
   ["low", "low", "supports_low_reasoning_effort"],
-  ["medium", "medium", undefined],
-  ["high", "high", undefined],
+  ["medium", "medium", "supports_medium_reasoning_effort"],
+  ["high", "high", "supports_high_reasoning_effort"],
   ["xhigh", "xhigh", "supports_xhigh_reasoning_effort"],
   ["max", "max", "supports_max_reasoning_effort"],
 ] as const;

package/src/types.ts

@@ -92,6 +92,8 @@ export interface ModelInfoEntry {
     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;