@pwguler/pi-pengepul-provider 0.5.1 → 0.5.3

package/README.md

@@ -141,6 +141,11 @@ box:
 }
 ```
 
+`env` is read off the credential by this provider, not by pi core: a provider
+that brings its own `resolve()` has to hand the values back, and pengepul does.
+Re-add them after `/login pengepul` — pi replaces the whole credential on login,
+so a key rotation drops the block and, with it, the tier.
+
 Idle warming covers gaps up to 30 minutes, pi's own safety limit, and pi only
 triggers it when the expected saving clears a threshold of its own — a small
 prompt is left to expire rather than refreshed. The long tier is what carries a

package/extensions/credential.ts

@@ -10,7 +10,7 @@
  * override, then the credential, then the loopback default pengepul binds to.
  */
 
-import { API_KEY_ENV } from "./config.ts"
+import { API_KEY_ENV, RELAY_BASE_ENV } from "./config.ts"
 import { normalizeRootBaseUrl } from "./dialect.ts"
 import { DEFAULT_RELAY_BASE } from "./models.ts"
 
@@ -20,6 +20,8 @@ export interface PengepulCredential {
   type?: unknown
   key?: unknown
   baseUrl?: unknown
+  /** Provider-scoped environment values pi stores alongside the key. */
+  env?: unknown
 }
 
 function nonEmptyString(value: unknown): string | undefined {
@@ -28,9 +30,18 @@ function nonEmptyString(value: unknown): string | undefined {
   return trimmed === "" ? undefined : trimmed
 }
 
-/** The relay base stored on the credential, when the user set one. */
+/**
+ * The relay base stored on the credential, when the user set one.
+ *
+ * `baseUrl` is where the stored credential keeps it. The credential pi hands
+ * the network phase of a refresh is not the stored one: pi rebuilds it from
+ * `resolve()` as `{ type, key, env }`, so the base only survives as the
+ * `PENGEPUL_BASE_URL` entry `resolve()` writes into `env`. Missing that
+ * fallback sends the catalog fetch to loopback - which on any machine but the
+ * relay's is some other listener, or nothing.
+ */
 export function credentialRelayBase(credential: PengepulCredential | undefined): string | undefined {
-  return nonEmptyString(credential?.baseUrl)
+  return nonEmptyString(credential?.baseUrl) ?? credentialEnv(credential)?.[RELAY_BASE_ENV]
 }
 
 /** The API key stored on the credential, when the user set one. */
@@ -38,6 +49,32 @@ export function credentialApiKey(credential: PengepulCredential | undefined): st
   return nonEmptyString(credential?.key)
 }
 
+/**
+ * The provider-scoped environment the credential carries, when it holds any.
+ *
+ * pi core fills an `AuthResult.env` from here only for providers that bring no
+ * `resolve()` of their own; this provider brings one, so the values have to be
+ * passed through or they never reach a request. They are how a user sets
+ * `PI_CACHE_RETENTION=long` for the relay without exporting it in every shell
+ * that starts pi, and losing them is silent: the cache quietly falls back to
+ * the five-minute tier and re-bills whole prefixes.
+ *
+ * Non-string values are dropped rather than stringified — an env var is a
+ * string, and a nested object here is a typo, not a value.
+ */
+export function credentialEnv(
+  credential: PengepulCredential | undefined,
+): Record<string, string> | undefined {
+  const raw = credential?.env
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return undefined
+
+  const env: Record<string, string> = {}
+  for (const [name, value] of Object.entries(raw)) {
+    if (typeof value === "string") env[name] = value
+  }
+  return Object.keys(env).length > 0 ? env : undefined
+}
+
 export interface RelayBaseSources {
   /** The `PENGEPUL_BASE_URL` environment value. */
   environment?: string | undefined

package/extensions/provider.ts

@@ -30,6 +30,7 @@ import { anthropicMessagesApi, lazyStream, openAICompletionsApi } from "@earendi
 import { API_KEY_ENV, RELAY_BASE_ENV } from "./config.ts"
 import {
   credentialApiKey,
+  credentialEnv,
   credentialRelayBase,
   resolveApiKey,
   resolveRelayBase,
@@ -211,9 +212,30 @@ export function createPengepulProvider(options: PengepulProviderOptions): Provid
         resolve: async (input): Promise<AuthResult | undefined> => {
           const resolved = resolveKey(input.credential)
           if (!resolved) return undefined
+          const credential = input.credential as PengepulCredential | undefined
+          const relayBase = credentialRelayBase(credential)
+          const credentialVars = credentialEnv(credential)
+          const env =
+            credentialVars || relayBase
+              ? { ...credentialVars, ...(relayBase ? { [RELAY_BASE_ENV]: relayBase } : {}) }
+              : undefined
           // No `baseUrl` here on purpose: pi would apply it to every model and
-          // collapse the two dialect base URLs into one.
-          return { auth: { apiKey: resolved.key }, source: resolved.source }
+          // collapse the two dialect base URLs into one. The relay base rides
+          // in `env` instead, because the network phase of a refresh gets a
+          // credential pi rebuilds from this result, and `env` is the only
+          // field of ours that survives the rebuild.
+          //
+          // The credential's own `env` is here because pi only reads it off the credential itself
+          // when the provider brings no `resolve()` of its own — this one does,
+          // so a value like PI_CACHE_RETENTION=long is dropped unless it is
+          // handed back. Dropping it is silent and costs money: the cache falls
+          // back to the five-minute tier and re-bills the prefix on every
+          // return.
+          return {
+            auth: { apiKey: resolved.key },
+            ...(env ? { env } : {}),
+            source: resolved.source,
+          }
         },
       },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pwguler/pi-pengepul-provider",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "type": "module",
   "description": "pi custom provider for pengepul, a relay that pools your Claude/Codex subscriptions. Key and relay base live in auth.json; both native wires (Anthropic Messages, OpenAI Chat Completions) come from one catalog.",
   "license": "MIT",