@pwguler/pi-pengepul-provider 0.2.0 → 0.2.2

package/extensions/models.ts

@@ -9,8 +9,9 @@
  *
  * The relay advertises id/owned_by and, since pengepul 0.6.0, optional
  * per-model metadata: `context_window`, `max_output_tokens`,
- * `input_modalities`, and `pricing`. That is the first-party truth for what
- * this relay actually serves, so it wins. The rollout is partial (some ids
+ * `input_modalities`, `pricing`, and `reasoning`. That is the first-party
+ * truth for what this relay actually serves, so it wins. The rollout is
+ * partial (some ids
  * still come back with ids only), so two fallbacks remain: pi's builtin
  * catalog - pengepul forwards the same ids upstream, so pi's numbers are the
  * next best source - and then family heuristics. The catalog lookup is
@@ -32,8 +33,8 @@ export const DEFAULT_MODELS_TIMEOUT_MS = 10_000
 const DEFAULT_CONTEXT_WINDOW = 200_000
 const DEFAULT_MAX_TOKENS = 64_000
 const ZERO_COST: ModelCostRates = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
-/** v2 cached pre-multi-catalog lookups (commandcode ids missed reasoning); reject it. */
-const MODEL_CACHE_VERSION = 4
+/** v5 cached entries predate the relay-uniform off/minimal overlay (foreign catalog maps offered levels the relay 400s); reject it. */
+const MODEL_CACHE_VERSION = 6
 
 export type ModelInput = ("text" | "image")[]
 
@@ -74,7 +75,7 @@ export interface PengepulModel {
   cost: ModelCostRates
   contextWindow: number
   maxTokens: number
-  /** Level-to-wire mapping inherited from the catalog; undefined = pi's default. */
+  /** Level-to-wire mapping (inherited, relay-unsafe levels nulled); undefined = pi's default. */
   thinkingLevelMap?: Record<string, string | null>
 }
 
@@ -91,20 +92,45 @@ export function bareId(id: string): string {
   return slash === -1 ? id : id.slice(slash + 1)
 }
 
+/** `openrouter/openai/gpt-5.4:batch` -> `gpt-5.4:batch`: the model name without every routing prefix. */
+export function modelName(id: string): string {
+  const slash = id.lastIndexOf("/")
+  return slash === -1 ? id : id.slice(slash + 1)
+}
+
 /**
  * Fallback for models pi's catalog does not know. Family-shaped but
- * conservative; the builtin lookup wins whenever it has the id. The final
- * branch treats unknown ids as non-reasoning, so an unrecognized id never
- * gets reasoning params the upstream may reject.
+ * conservative; the builtin lookup wins whenever it has the id. The relay
+ * prefixes ids with routing namespaces (`openrouter/openai/gpt-5.4:batch`),
+ * so the family is read from the final segment. The final branch treats
+ * unknown ids as non-reasoning, so an unrecognized id never gets reasoning
+ * params the upstream may reject.
  */
 function heuristicMeta(id: string): BuiltinModelMeta {
-  const lower = bareId(id).toLowerCase()
-  if (lower.startsWith("claude-")) {
+  const name = modelName(id).toLowerCase()
+  if (name.startsWith("claude-")) {
     return { reasoning: true, contextWindow: 200_000, maxTokens: 64_000, input: ["text"], cost: ZERO_COST }
   }
-  if (lower.startsWith("gpt-") || lower.startsWith("codex-") || /^o[1-9]/.test(lower)) {
+  if (
+    name.startsWith("codex-") ||
+    /^gpt-[5-9]/.test(name) ||
+    name.startsWith("gpt-oss") ||
+    /^o[1-9]/.test(name)
+  ) {
     return { reasoning: true, contextWindow: 272_000, maxTokens: 64_000, input: ["text"], cost: ZERO_COST }
   }
+  // Families that name their reasoning: DeepSeek's R1 line and ids that spell
+  // it out (`sonar-reasoning-pro`). The relay's own numbers win when it sends
+  // them; these are placeholders for the ids it describes with nothing else.
+  if (name.startsWith("deepseek-r1") || name.includes("reasoning")) {
+    return {
+      reasoning: true,
+      contextWindow: DEFAULT_CONTEXT_WINDOW,
+      maxTokens: DEFAULT_MAX_TOKENS,
+      input: ["text"],
+      cost: ZERO_COST,
+    }
+  }
   return {
     reasoning: false,
     contextWindow: DEFAULT_CONTEXT_WINDOW,
@@ -117,6 +143,8 @@ function heuristicMeta(id: string): BuiltinModelMeta {
 /**
  * Metadata pengepul itself advertises for a model (pengepul >= 0.6.0).
  * Every field is optional: the rollout is partial and older relays send none.
+ * `reasoning` is the relay's first-party say on whether the upstream accepts
+ * reasoning params; absent or non-boolean falls back to the catalog.
  * Returns undefined when the entry carries no usable metadata at all.
  */
 export function metaFromRelayEntry(
@@ -126,16 +154,19 @@ export function metaFromRelayEntry(
   const maxTokens = optionalPositiveNumber(entry["max_output_tokens"])
   const input = optionalInputModalities(entry["input_modalities"])
   const cost = optionalPricing(entry["pricing"])
+  const reasoning = optionalBoolean(entry["reasoning"])
 
   if (
     contextWindow === undefined &&
     maxTokens === undefined &&
     input === undefined &&
-    cost === undefined
+    cost === undefined &&
+    reasoning === undefined
   ) {
     return undefined
   }
   return {
+    ...(reasoning !== undefined ? { reasoning } : {}),
     ...(contextWindow !== undefined ? { contextWindow } : {}),
     ...(maxTokens !== undefined ? { maxTokens } : {}),
     ...(input !== undefined ? { input } : {}),
@@ -147,6 +178,10 @@ function optionalPositiveNumber(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined
 }
 
+function optionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined
+}
+
 function optionalInputModalities(value: unknown): ModelInput | undefined {
   if (!Array.isArray(value)) return undefined
   const input = value.filter(
@@ -206,6 +241,21 @@ function toPengepulModel(
   // capable, even when pi's catalog does not know its exact id yet.
   const reasoning = meta.reasoning || ownedBy === "anthropic"
 
+  // The relay enforces reasoning_effort low|medium|high|xhigh|max at its
+  // request layer, uniformly across families: `minimal` 400s and its thinking
+  // toggle never actually disables thinking. That holds no matter where the
+  // reasoning knowledge came from, so every openai-completions reasoning model
+  // gets the relay's shape: inherited strings case-folded to the enum (pi's
+  // catalogs spell Google efforts `HIGH` and Qwen's `default`), values that
+  // match under no casing hidden, and off/minimal always null. Overlay, never
+  // replace: inherited nulls keep their levels hidden. The Messages dialect
+  // needs none of this: it folds `minimal` into `low` and already nulls `off`
+  // via forceAdaptiveThinking.
+  const thinkingLevelMap = relaySafeLevelMap(
+    meta.thinkingLevelMap,
+    reasoning && dialect === "openai-completions",
+  )
+
   return {
     id,
     name: displayName(id),
@@ -215,10 +265,41 @@ function toPengepulModel(
     cost: { ...meta.cost },
     contextWindow: meta.contextWindow,
     maxTokens: meta.maxTokens,
-    ...(meta.thinkingLevelMap ? { thinkingLevelMap: { ...meta.thinkingLevelMap } } : {}),
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
   }
 }
 
+/** The efforts the relay accepts; anything else is rejected at its request layer. */
+const RELAY_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"])
+
+/**
+ * Shape an inherited level map for the relay's wire. With `enforce` (an
+ * openai-completions reasoning model) the relay's enum is the only vocabulary
+ * that reaches it: inherited strings are case-folded to the enum or hidden,
+ * and off/minimal are always hidden. Without it the map passes through.
+ */
+function relaySafeLevelMap(
+  inherited: Record<string, string | null> | undefined,
+  enforce: boolean,
+): Record<string, string | null> | undefined {
+  if (!enforce) return inherited ? { ...inherited } : undefined
+
+  const map: Record<string, string | null> = {}
+  for (const [level, mapped] of Object.entries(inherited ?? {})) {
+    map[level] = typeof mapped === "string" ? relayEffort(mapped) : mapped
+  }
+  map["off"] = null
+  map["minimal"] = null
+  return map
+}
+
+/** The relay's effort enum, case-folded; null keeps the level out of the picker. */
+function relayEffort(value: string): string | null {
+  if (RELAY_EFFORTS.has(value)) return value
+  const lower = value.toLowerCase()
+  return RELAY_EFFORTS.has(lower) ? lower : null
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
@@ -269,7 +350,12 @@ export function toProviderModelConfigs(
   contextWindow: number
   maxTokens: number
   thinkingLevelMap?: Record<string, string | null>
-  compat?: { forceAdaptiveThinking?: boolean; supportsLongCacheRetention?: boolean }
+  compat?: {
+    forceAdaptiveThinking?: boolean
+    supportsLongCacheRetention?: boolean
+    sendSessionAffinityHeaders?: boolean
+    sessionAffinityFormat?: "openai" | "openai-nosession" | "openrouter"
+  }
 }> {
   return models.map((model) => {
     const adaptive = model.dialect === "anthropic-messages" && model.reasoning
@@ -301,14 +387,44 @@ export function toProviderModelConfigs(
       // unsupported so pi omits the thinking param entirely (server default
       // = adaptive), and forceAdaptiveThinking routes an explicit level to
       // {type:"adaptive"} + effort instead of budget_tokens.
-      ...(adaptive || longCacheRetention
-        ? {
-            compat: {
-              ...(adaptive ? { forceAdaptiveThinking: true as const } : {}),
-              ...(longCacheRetention ? { supportsLongCacheRetention: true as const } : {}),
-            },
-          }
-        : {}),
+      // Both dialects pin both fields, and that is why `compat` is
+      // unconditional. The relay's prompt-cache affinity key resolves in this
+      // order: `x-claude-code-session-id`, `x-session-id`, the body's
+      // `prompt_cache_key`, then a hash of the cacheable request prefix
+      // (app.rs `conversation_key`). pi emits `x-session-id` only for the
+      // `openrouter` affinity format, and only when the send flag is set;
+      // the auto-detected defaults are wrong here in both cases
+      // (openai-completions picks `openai`: session_id + x-client-request-id +
+      // x-session-affinity; anthropic-messages picks nothing). The header is
+      // the cheaper and more explicit of the two signals and it outranks the
+      // body field, so pinning it keeps a session's account stable by the
+      // relay's first rule rather than its third. Losing the pin costs a
+      // session that migrates between pooled accounts its whole prefix: the
+      // upstream cache is per account.
+      //
+      // Measured, not assumed — `test/affinity-wire.test.ts` dumps both bodies:
+      // openai-completions carries `prompt_cache_key: <sessionId>` (and
+      // `prompt_cache_retention: "24h"`) under PI_CACHE_RETENTION=long, so the
+      // body field alone would name the conversation; anthropic-messages
+      // carries no `prompt_cache_key` at all, and pi-ai hardcodes
+      // `x-session-affinity` there, which this relay does not read. Messages
+      // traffic therefore rests entirely on the relay's prefix fallback until
+      // a pi release honours `sessionAffinityFormat` on that dialect.
+      //
+      // The two dialects do not land at the same time. openai-completions
+      // honors `sessionAffinityFormat` in every released pi. anthropic-messages
+      // only reads it from the unreleased change on pi main (commit
+      // bbb61e34a); through pi-ai 0.85.1 that client hardcodes the header name
+      // `x-session-affinity`, which this relay does not read, so the Claude
+      // pin below is inert until pi ships it. Pin now rather than later: the
+      // cost of an ignored header is zero, and the cost of forgetting is
+      // silently re-billed Claude prefixes.
+      compat: {
+        ...(adaptive ? { forceAdaptiveThinking: true as const } : {}),
+        ...(longCacheRetention ? { supportsLongCacheRetention: true as const } : {}),
+        sendSessionAffinityHeaders: true as const,
+        sessionAffinityFormat: "openrouter" as const,
+      },
     }
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pwguler/pi-pengepul-provider",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "description": "pi custom provider for pengepul, a local relay that pools your Claude/Codex subscriptions. Connects pi to http://127.0.0.1:8317 over the native Anthropic Messages and OpenAI Chat Completions wires.",
   "license": "MIT",