pullfrog 0.1.90 → 0.1.91

package/dist/index.js

@@ -83904,7 +83904,7 @@ var require_Element = __commonJS({
     var FilteredElementList = require_FilteredElementList();
     var DOMException2 = require_DOMException();
     var DOMTokenList = require_DOMTokenList();
-    var select = require_select();
+    var select2 = require_select();
     var ContainerNode = require_ContainerNode();
     var ChildNode = require_ChildNode();
     var NonDocumentTypeChildNode = require_NonDocumentTypeChildNode();
@@ -84665,7 +84665,7 @@ var require_Element = __commonJS({
         this.className = v;
       } },
       matches: { value: function(selector) {
-        return select.matches(this, selector);
+        return select2.matches(this, selector);
       } },
       closest: { value: function(selector) {
         var el = this;
@@ -84678,10 +84678,10 @@ var require_Element = __commonJS({
         return null;
       } },
       querySelector: { value: function(selector) {
-        return select(selector, this)[0];
+        return select2(selector, this)[0];
       } },
       querySelectorAll: { value: function(selector) {
-        var nodes = select(selector, this);
+        var nodes = select2(selector, this);
         return nodes.item ? nodes : new NodeList(nodes);
       } }
     });
@@ -85209,7 +85209,7 @@ var require_DocumentFragment = __commonJS({
     var NodeList = require_NodeList();
     var ContainerNode = require_ContainerNode();
     var Element = require_Element();
-    var select = require_select();
+    var select2 = require_select();
     var utils = require_utils8();
     function DocumentFragment(doc) {
       ContainerNode.call(this);
@@ -85238,7 +85238,7 @@ var require_DocumentFragment = __commonJS({
         context.isHTML = true;
         context.getElementsByTagName = Element.prototype.getElementsByTagName;
         context.nextElement = Object.getOwnPropertyDescriptor(Element.prototype, "firstElementChild").get;
-        var nodes = select(selector, context);
+        var nodes = select2(selector, context);
         return nodes.item ? nodes : new NodeList(nodes);
       } },
       // Utility methods
@@ -88353,7 +88353,7 @@ var require_Document = __commonJS({
     var NodeIterator = require_NodeIterator();
     var NodeFilter = require_NodeFilter();
     var URL2 = require_URL();
-    var select = require_select();
+    var select2 = require_select();
     var events = require_events3();
     var xml = require_xmlnames();
     var html = require_htmlelts();
@@ -88914,10 +88914,10 @@ var require_Document = __commonJS({
         return this._templateDocCache;
       } },
       querySelector: { value: function(selector) {
-        return select(selector, this)[0];
+        return select2(selector, this)[0];
       } },
       querySelectorAll: { value: function(selector) {
-        var nodes = select(selector, this);
+        var nodes = select2(selector, this);
         return nodes.item ? nodes : new NodeList(nodes);
       } }
     });
@@ -105082,10 +105082,12 @@ async function preflightClaudeSubscription(params) {
   if (res.status !== 401 && res.status !== 403 && res.status !== 429)
     return { usable: true, status: res.status };
   const body = await res.text().catch(() => "");
+  const reset = Number(res.headers.get("anthropic-ratelimit-unified-reset"));
   return {
     usable: false,
     status: res.status,
-    reason: `${res.status}: ${extractApiErrorMessage(body)}`
+    reason: `${res.status}: ${extractApiErrorMessage(body)}`,
+    resetAt: res.status === 429 && reset > 0 ? new Date(reset * 1e3) : void 0
   };
 }
 function extractApiErrorMessage(body) {
@@ -105729,7 +105731,7 @@ var import_semver = __toESM(require_semver2(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.90",
+  version: "0.1.91",
   cliContractVersion: "1",
   type: "module",
   bin: {
@@ -108001,6 +108003,17 @@ function parseXaiAuthBody(raw2) {
 var CODEX_AUTH_ENV = "CODEX_AUTH_JSON";
 var XAI_AUTH_ENV = "GROK_AUTH_JSON";
 var installedSubscriptionPaths = /* @__PURE__ */ new Map();
+function clearInstalledSubscription(name) {
+  const path4 = installedSubscriptionPaths.get(name);
+  if (!path4 || !existsSync4(path4)) return;
+  const value2 = JSON.parse(readFileSync2(path4, "utf8"));
+  if (!value2 || typeof value2 !== "object") return;
+  if (name === "CODEX_AUTH_JSON" && "openai" in value2) delete value2.openai;
+  if (name === "GROK_AUTH_JSON" && "xai" in value2) delete value2.xai;
+  writeFileSync4(path4, `${JSON.stringify(value2)}
+`, { mode: 384 });
+  installedSubscriptionPaths.delete(name);
+}
 var PULLFROG_DATA_DIR = "/var/lib/pullfrog";
 function isRejectedChain(body) {
   if (!body.refresh_rejected_at) return false;
@@ -116693,6 +116706,9 @@ function captureAuthorizedModels(cliPath) {
   }
   log.debug(`\xBB opencode authorized: ${authorized.size} models`);
 }
+function authorizeModel(model) {
+  getAuthorizedModels().add(model);
+}
 function getAuthorizedModels() {
   if (!authorized) {
     throw new Error("getAuthorizedModels called before captureAuthorizedModels");
@@ -130812,8 +130828,8 @@ function liftWireOnlyMaterial(message, kind) {
   };
 }
 function codecResultValidator(codec2, method) {
-  const probe = codec2.validateResult(method, void 0);
-  if (!probe.ok && probe.reason === "not-in-era") return void 0;
+  const probe2 = codec2.validateResult(method, void 0);
+  if (!probe2.ok && probe2.reason === "not-in-era") return void 0;
   return { "~standard": {
     version: 1,
     vendor: "mcp-wire-codec",
@@ -145189,8 +145205,8 @@ function liftWireOnlyMaterial2(message, kind) {
   };
 }
 function codecResultValidator2(codec2, method) {
-  const probe = codec2.validateResult(method, void 0);
-  if (!probe.ok && probe.reason === "not-in-era") return void 0;
+  const probe2 = codec2.validateResult(method, void 0);
+  if (!probe2.ok && probe2.reason === "not-in-era") return void 0;
   return { "~standard": {
     version: 1,
     vendor: "mcp-wire-codec",
@@ -188369,10 +188385,10 @@ function CommitChangesTool(ctx) {
         }
         const requested = new Set(params.files);
         const known = new Set(changes.map((c) => c.path));
-        const unknown4 = [...requested].filter((p) => !known.has(p));
-        if (unknown4.length > 0) {
+        const unknown5 = [...requested].filter((p) => !known.has(p));
+        if (unknown5.length > 0) {
           throw new Error(
-            `no detected change at: ${unknown4.join(", ")} \u2014 run git status to list changed paths.`
+            `no detected change at: ${unknown5.join(", ")} \u2014 run git status to list changed paths.`
           );
         }
         changes = changes.filter((c) => requested.has(c.path));
@@ -188765,15 +188781,6 @@ function PushTagsTool(ctx) {
 // utils/buildPullfrogFooter.ts
 var PULLFROG_DIVIDER = "<!-- PULLFROG_DIVIDER_DO_NOT_REMOVE_PLZ -->";
 var FROG_LOGO = `<a href="https://pullfrog.com"><picture><source media="(prefers-color-scheme: dark)" srcset="https://pullfrog.com/logos/frog-white-full-18px.png"><img src="https://pullfrog.com/logos/frog-green-full-18px.png" width="9px" height="9px" style="vertical-align: middle; " alt="Pullfrog"></picture></a>`;
-function providerDisplayName(slug2) {
-  try {
-    const key = getModelProvider(slug2);
-    const meta3 = providers[key];
-    return meta3?.displayName ?? key;
-  } catch {
-    return slug2;
-  }
-}
 function formatModelLabel(params) {
   const alias = resolveDisplayAlias(params.model) ?? // reverse-lookup: when the caller passes an effective model (proxy or
   // resolved target like "openrouter/anthropic/claude-opus-4.7") instead of
@@ -188788,9 +188795,6 @@ function formatModelLabel(params) {
     return `${ossBase} (${configured} not used \u2014 pick one of the [funded models](https://docs.pullfrog.com/models#pullfrog-for-oss) or add a [provider key](https://docs.pullfrog.com/keys) to run your own)`;
   }
   const base = alias?.isFree ? `\`${displayName}\` (free)` : `\`${displayName}\``;
-  if (params.fallbackFrom) {
-    return `${base} (credentials for ${providerDisplayName(params.fallbackFrom)} were rejected by the provider)`;
-  }
   if (params.clamped?.reason === "trial") {
     return `${base} (model usage covered by Pullfrog)`;
   }
@@ -188831,7 +188835,6 @@ function buildPullfrogFooter(params) {
     parts.push(
       `Using ${formatModelLabel({
         model: params.model,
-        fallbackFrom: params.fallbackFrom,
         clamped: params.clamped,
         unselectedProxyDefault: params.unselectedProxyDefault,
         oss: params.oss
@@ -189031,7 +189034,6 @@ function buildCommentFooter(ctx, customParts) {
     } : void 0,
     customParts,
     model: ctx.toolState.model,
-    fallbackFrom: ctx.toolState.modelFallback?.from,
     clamped: ctx.toolState.modelClamped,
     unselectedProxyDefault: ctx.toolState.unselectedProxyDefault,
     oss: ctx.oss,
@@ -190021,7 +190023,6 @@ async function createAndSubmitWithFooter(ctx, params, opts) {
       workflowRun: ctx.runId ? { owner: ctx.repo.owner, repo: ctx.repo.name, runId: ctx.runId, jobId: ctx.jobId } : void 0,
       customParts,
       model: ctx.toolState.model,
-      fallbackFrom: ctx.toolState.modelFallback?.from,
       clamped: ctx.toolState.modelClamped,
       unselectedProxyDefault: ctx.toolState.unselectedProxyDefault,
       oss: ctx.oss,
@@ -192397,7 +192398,6 @@ function buildPrBodyWithFooter(ctx, body) {
     triggeredBy: true,
     workflowRun: ctx.runId ? { owner: ctx.repo.owner, repo: ctx.repo.name, runId: ctx.runId, jobId: ctx.jobId } : void 0,
     model: ctx.toolState.model,
-    fallbackFrom: ctx.toolState.modelFallback?.from,
     clamped: ctx.toolState.modelClamped,
     unselectedProxyDefault: ctx.toolState.unselectedProxyDefault,
     oss: ctx.oss,
@@ -194546,17 +194546,17 @@ async function verifyCredential(params) {
   const value2 = params.value.trim();
   if (value2.length === 0) return "dead";
   if (params.envVar === "CLAUDE_CODE_OAUTH_TOKEN") return verifyClaudeSubscription(value2);
-  const probe = PROBES[params.envVar];
-  if (!probe) return "unknown";
-  const request2 = probe.request(value2);
+  const probe2 = PROBES[params.envVar];
+  if (!probe2) return "unknown";
+  const request2 = probe2.request(value2);
   try {
     const response = await fetch(request2.url, {
       headers: request2.headers,
       signal: AbortSignal.timeout(5e3)
     });
     if (response.ok) return "alive";
-    if (probe.deadWhen) {
-      return probe.deadWhen(response.status, await response.text()) ? "dead" : "unknown";
+    if (probe2.deadWhen) {
+      return probe2.deadWhen(response.status, await response.text()) ? "dead" : "unknown";
     }
     return response.status === 401 ? "dead" : "unknown";
   } catch {
@@ -194587,14 +194587,6 @@ async function checkOne(params) {
   const verdict = await verifyCredential({ envVar: params.envVar, value: value2 });
   return verdict === "dead" ? { severity: "dead", reason: void 0 } : null;
 }
-function pickReplacement(params) {
-  const candidates = modelAliases.filter(
-    (alias) => !alias.hidden && !alias.fallback && params.authorized.has(alias.resolve) && // a model with no known env vars is routable through credentials we can't
-    // see (Codex auth lands as an on-disk auth.json), so it stays a candidate.
-    !envVarsFor(alias.resolve).some((envVar) => params.deadVars.has(envVar))
-  );
-  return (candidates.find((alias) => alias.preferred) ?? candidates[0])?.resolve;
-}
 async function checkConfiguredCredentials(params) {
   if (!params.model) return { kind: "ok" };
   const present = envVarsFor(params.model).filter(hasEnvVar4);
@@ -194620,12 +194612,396 @@ async function checkConfiguredCredentials(params) {
   failed.forEach(drop);
   const first = failed[0];
   if (!first) return { kind: "ok" };
-  const outcome = { credential: first.envVar, reason: first.failure.reason };
-  const replacement = pickReplacement({
-    authorized: params.authorized,
-    deadVars: new Set(failed.map((entry) => entry.envVar))
+  return { kind: "dead", credential: first.envVar, reason: first.failure.reason };
+}
+
+// utils/normalizeEnv.ts
+function hasControlCharacter(value2) {
+  return [...value2].some((ch) => {
+    const code = ch.charCodeAt(0);
+    return code < 32 || code === 127;
   });
-  return replacement ? { kind: "fellBack", ...outcome, replacement } : { kind: "dead", ...outcome };
+}
+function sanitizeSecret(key, value2) {
+  const trimmed = value2.trim();
+  if (trimmed.length === 0) {
+    log.warning(
+      `\xBB ${key} is whitespace-only \u2014 leaving env var unchanged. check your secret value.`
+    );
+    return null;
+  }
+  if (key.endsWith("_API_KEY") && hasControlCharacter(trimmed)) {
+    log.warning(
+      `\xBB ${key} contains a line break or control character and cannot be sent as an HTTP header \u2014 leaving env var unchanged. re-save the secret as a single line.`
+    );
+    return null;
+  }
+  if (trimmed !== value2) {
+    log.warning(
+      `\xBB stripped whitespace from ${key} (whitespace in secret values breaks GitHub Actions log masking)`
+    );
+  }
+  maskSecret(trimmed);
+  return trimmed;
+}
+function normalizeEnv() {
+  const upperKeys = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(process.env)) {
+    const upper2 = key.toUpperCase();
+    const existing = upperKeys.get(upper2) || [];
+    existing.push(key);
+    upperKeys.set(upper2, existing);
+  }
+  for (const [upperKey, keys] of upperKeys) {
+    if (keys.length === 1) {
+      const key = keys[0];
+      if (key !== upperKey) {
+        process.env[upperKey] = process.env[key];
+        delete process.env[key];
+      }
+      continue;
+    }
+    const values = keys.map((k2) => process.env[k2]);
+    const uniqueValues = new Set(values);
+    if (uniqueValues.size > 1) {
+      log.warning(
+        `env var conflict: ${keys.join(", ")} have different values. using uppercase ${upperKey}.`
+      );
+    }
+    const preferredKey = keys.find((k2) => k2 === upperKey) || keys[0];
+    const preferredValue = process.env[preferredKey];
+    for (const key of keys) {
+      delete process.env[key];
+    }
+    process.env[upperKey] = preferredValue;
+  }
+  for (const key of Object.keys(process.env)) {
+    if (!isSensitiveEnvName(key)) continue;
+    const value2 = process.env[key];
+    if (typeof value2 !== "string" || value2.length === 0) continue;
+    const sanitized = sanitizeSecret(key, value2);
+    if (sanitized !== null) process.env[key] = sanitized;
+  }
+}
+
+// utils/subscriptionCredentials.ts
+var subscriptionNameSchema = external_exports.enum([
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CODEX_AUTH_JSON",
+  "GROK_AUTH_JSON"
+]);
+var subscriptionSchema = external_exports.object({
+  id: external_exports.string(),
+  credentialId: external_exports.string(),
+  name: subscriptionNameSchema,
+  label: external_exports.string(),
+  owner: external_exports.string(),
+  inherited: external_exports.boolean(),
+  shared: external_exports.boolean(),
+  registeredAt: external_exports.string(),
+  /** the provider's last verdict on the current value; null = usable or never checked. */
+  status: external_exports.enum(["rejected", "exhausted"]).nullish(),
+  resetAt: external_exports.string().nullish()
+});
+var subscriptionListSchema = external_exports.object({
+  subscriptions: external_exports.array(subscriptionSchema),
+  writable: external_exports.boolean()
+});
+var subscriptionInputSchema = external_exports.object({
+  name: subscriptionNameSchema,
+  value: external_exports.string().trim().min(1).refine((value2) => Buffer.byteLength(value2, "utf8") <= 49152),
+  replaceId: external_exports.string().optional()
+});
+var credentialCandidateSchema = external_exports.object({
+  id: external_exports.string(),
+  name: external_exports.string(),
+  source: external_exports.enum(["repo", "account", "personal"])
+});
+var credentialAccessSchema = external_exports.object({
+  token: external_exports.string(),
+  candidates: external_exports.array(credentialCandidateSchema)
+});
+var selectedCredentialSchema = external_exports.object({
+  name: external_exports.string(),
+  value: external_exports.string(),
+  receipt: external_exports.string()
+});
+
+// utils/subscriptionProbe.ts
+var identitySchema = external_exports.object({
+  email: external_exports.string().email().optional(),
+  sub: external_exports.string().optional(),
+  user_id: external_exports.string().optional(),
+  account_id: external_exports.string().optional(),
+  email_verified: external_exports.boolean().optional()
+});
+var codexWindowSchema = external_exports.object({ used_percent: external_exports.number().optional(), reset_at: external_exports.number().optional() }).nullish();
+var codexUsageSchema = external_exports.object({
+  rate_limit: external_exports.object({
+    allowed: external_exports.boolean(),
+    limit_reached: external_exports.boolean(),
+    primary_window: codexWindowSchema,
+    secondary_window: codexWindowSchema
+  }).optional()
+});
+var unknown4 = { status: "unknown" };
+async function readSubscriptionEndpoint(input) {
+  const headers = new Headers({ authorization: `Bearer ${input.token}` });
+  if (input.accountId) headers.set("ChatGPT-Account-Id", input.accountId);
+  if (input.grokBilling) headers.set("x-xai-token-auth", "xai-grok-cli");
+  return fetch(input.url, {
+    headers,
+    redirect: "error",
+    signal: AbortSignal.timeout(1e4)
+  }).catch(() => null);
+}
+async function probeSubscription(input) {
+  if (input.name === "CLAUDE_CODE_OAUTH_TOKEN") {
+    const result = await preflightClaudeSubscription({ token: input.value, model: input.model });
+    if (result.usable)
+      return result.status !== void 0 && result.status < 300 ? { status: "usable" } : unknown4;
+    return result.status === 429 ? { status: "exhausted", detail: result.reason, resetAt: result.resetAt } : { status: "rejected", detail: result.reason };
+  }
+  const codex2 = input.name === "CODEX_AUTH_JSON" ? parseCodexAuthBody(input.value) : null;
+  const grok = input.name === "GROK_AUTH_JSON" ? parseXaiAuthBody(input.value) : null;
+  const auth2 = codex2 ?? grok;
+  if (!auth2) return { status: "rejected", detail: "the stored credential is malformed" };
+  if (auth2.refresh_rejected_at)
+    return { status: "rejected", detail: `refresh rejected at ${auth2.refresh_rejected_at}` };
+  if (grok && input.model)
+    return probeInference({
+      name: "XAI_API_KEY",
+      value: grok.tokens.access_token,
+      model: input.model
+    });
+  const response = await readSubscriptionEndpoint({
+    url: codex2 ? "https://chatgpt.com/backend-api/wham/usage" : "https://cli-chat-proxy.grok.com/v1/billing?format=credits",
+    token: auth2.tokens.access_token,
+    accountId: codex2?.tokens.account_id,
+    grokBilling: !!grok
+  });
+  if (response?.status === 401) return { status: "rejected", detail: "rejected with 401" };
+  if (!response?.ok) return unknown4;
+  const body = await response.json().catch(() => null);
+  if (!codex2) return unknown4;
+  const parsed2 = codexUsageSchema.safeParse(body);
+  const limit = parsed2.success ? parsed2.data.rate_limit : void 0;
+  if (!limit) return unknown4;
+  if (limit.allowed && !limit.limit_reached) return { status: "usable" };
+  const windows = [limit.primary_window, limit.secondary_window];
+  const full = windows.filter((window2) => (window2?.used_percent ?? 0) >= 100);
+  const resets = (full.length ? full : windows).flatMap(
+    (window2) => window2?.reset_at ? [window2.reset_at] : []
+  );
+  return {
+    status: "exhausted",
+    detail: "the ChatGPT plan's usage limit is reached",
+    resetAt: resets.length ? new Date(Math.max(...resets) * 1e3) : void 0
+  };
+}
+async function probeInference(input) {
+  const anthropic = input.name === "ANTHROPIC_API_KEY";
+  const openai = input.name === "OPENAI_API_KEY";
+  if (!anthropic && !openai && input.name !== "XAI_API_KEY") {
+    const result = await verifyCredential({ envVar: input.name, value: input.value });
+    return result === "dead" ? { status: "rejected", detail: "rejected by its provider" } : result === "alive" ? { status: "usable" } : unknown4;
+  }
+  const headers = new Headers({ "content-type": "application/json" });
+  if (anthropic) {
+    headers.set("x-api-key", input.value);
+    headers.set("anthropic-version", "2023-06-01");
+  } else headers.set("authorization", `Bearer ${input.value}`);
+  const response = await fetch(
+    anthropic ? "https://api.anthropic.com/v1/messages" : openai ? "https://api.openai.com/v1/responses" : "https://api.x.ai/v1/chat/completions",
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(
+        openai ? { model: input.model, input: "Reply OK.", max_output_tokens: 16, store: false } : {
+          model: input.model,
+          messages: [{ role: "user", content: "Reply OK." }],
+          max_tokens: 1
+        }
+      ),
+      redirect: "error",
+      signal: AbortSignal.timeout(1e4)
+    }
+  ).catch(() => null);
+  if (response?.status === 400 && input.name === "XAI_API_KEY") {
+    const error49 = external_exports.object({ error: external_exports.string() }).safeParse(await response.json().catch(() => null));
+    return error49.success && error49.data.error.startsWith("Incorrect API key provided.") ? { status: "rejected", detail: "rejected with 400: incorrect API key" } : unknown4;
+  }
+  if (response?.status === 429 && openai) {
+    const error49 = external_exports.object({ error: external_exports.object({ code: external_exports.string() }) }).safeParse(await response.json().catch(() => null));
+    return error49.success && error49.data.error.code === "insufficient_quota" ? { status: "exhausted", detail: "refused with 429: insufficient quota", resetAt: void 0 } : unknown4;
+  }
+  await response?.body?.cancel();
+  if (!response) return unknown4;
+  if (response.ok) return { status: "usable" };
+  if (response.status === 401 || response.status === 403)
+    return { status: "rejected", detail: `rejected with ${response.status}` };
+  if (response.status === 402)
+    return { status: "exhausted", detail: "refused with 402", resetAt: void 0 };
+  return unknown4;
+}
+
+// utils/credentialPool.ts
+var receipts = {};
+var workflowCredentials = {};
+function saveReceipts() {
+  for (const receipt of Object.values(receipts)) maskSecret(receipt);
+  saveSecretState("credential_receipts", JSON.stringify(receipts));
+}
+var select = op(
+  async (input) => {
+    const response = await apiFetch({
+      path: "/api/runtime/credentials",
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${input.access.token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ id: input.candidate.id }),
+      signal: AbortSignal.timeout(35e3)
+    });
+    if (response.status === 404) return null;
+    if (!response.ok)
+      throw new Error("could not load a configured credential; no fallback was charged", {
+        cause: response.status
+      });
+    return selectedCredentialSchema.parse(await response.json());
+  },
+  {
+    retries: [250, 1e3],
+    bail: (error49) => error49 instanceof Error && typeof error49.cause === "number" && error49.cause >= 400 && error49.cause < 500
+  }
+);
+function subscriptionForModel(model) {
+  if (!model.includes("/")) return null;
+  const provider2 = getModelProvider(model);
+  return provider2 === "anthropic" ? "CLAUDE_CODE_OAUTH_TOKEN" : provider2 === "openai" ? "CODEX_AUTH_JSON" : provider2 === "xai" ? "GROK_AUTH_JSON" : null;
+}
+async function initializeCredentialPool(input) {
+  const access = input.ctx.credentialAccess;
+  if (!access) return;
+  const model = discoveryModel(input.slug);
+  maskSecret(access.token);
+  const names = /* @__PURE__ */ new Set([
+    ...access.candidates.map((candidate) => candidate.name),
+    ...subscriptionNameSchema.options,
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "XAI_API_KEY"
+  ]);
+  for (const name of names) {
+    const value2 = process.env[name];
+    if (value2 && !input.injected.includes(name)) workflowCredentials[name] = value2;
+  }
+  for (const name of subscriptionNameSchema.options) {
+    if (model && subscriptionForModel(model) !== name) continue;
+    if (workflowCredentials[name]) continue;
+    const candidate = access.candidates.find((item) => item.name === name);
+    if (!candidate) continue;
+    const selected = await select({ access, candidate }).catch(() => {
+      log.warning(`\xBB could not load ${name} for model discovery; selection will retry if needed`);
+      return null;
+    });
+    if (!selected) continue;
+    const value2 = sanitizeSecret(name, selected.value);
+    if (!value2) continue;
+    process.env[name] = value2;
+    receipts[name] = selected.receipt;
+  }
+  saveReceipts();
+}
+function discoveryModel(slug2) {
+  const value2 = process.env.PULLFROG_MODEL?.trim() || slug2?.trim();
+  if (!value2) return void 0;
+  return resolveCliModel(value2) ?? (value2.includes("/") ? value2 : void 0);
+}
+function resolvePoolModel(input) {
+  const agent2 = resolveAgent({
+    model: void 0,
+    proxyModel: void 0,
+    codexAgent: input.codexAgent
+  });
+  if (agent2.name === "opencode") return autoSelectModel();
+  const provider2 = agent2.name === "claude" ? "anthropic" : "openai";
+  return modelAliases.find(
+    (alias) => alias.provider === provider2 && alias.preferred && !alias.hidden && !alias.fallback && !alias.routing
+  )?.resolve;
+}
+async function selectConfiguredCredential(input) {
+  const access = input.ctx.credentialAccess;
+  const model = input.model;
+  if (!access || !model?.includes("/") || getProviderGatewayUrl(model)) return false;
+  const subscription = subscriptionForModel(model);
+  const names = getModelEnvVars(model).filter((name) => name !== subscription);
+  if (subscription) names.unshift(subscription);
+  const candidates = access.candidates.filter((candidate) => names.includes(candidate.name));
+  if (!candidates.length) return false;
+  const refused = [];
+  for (const name of names.filter((item) => workflowCredentials[item])) {
+    const value2 = workflowCredentials[name];
+    const verdict = await probe({ name, value: value2, model });
+    if (usable(verdict)) {
+      activate({ names, name, value: value2, receipt: void 0, model });
+      return true;
+    }
+    refused.push(`${name} from the workflow: ${verdict.detail}`);
+    log.info(`\xBB ${name} from the workflow unavailable; trying the next credential`);
+  }
+  for (const candidate of candidates) {
+    const selected = await select({ access, candidate });
+    if (!selected) continue;
+    const verdict = await probe({ ...selected, model });
+    await reportVerdict({ receipt: selected.receipt, verdict });
+    if (usable(verdict)) {
+      activate({ names, ...selected, model });
+      log.info(`\xBB selected ${candidate.name} from ${candidate.source} scope`);
+      return true;
+    }
+    refused.push(`${candidate.name} from ${candidate.source} scope: ${verdict.detail}`);
+    log.info(
+      `\xBB ${candidate.name} from ${candidate.source} scope unavailable; trying the next credential`
+    );
+  }
+  throw new Error(
+    `all configured credentials for ${model} were rejected or exhausted (${refused.join("; ")}); no other model or provider was selected`
+  );
+}
+async function probe(input) {
+  const subscription = subscriptionNameSchema.safeParse(input.name);
+  const model = stripProviderPrefix(input.model);
+  return subscription.success ? probeSubscription({ name: subscription.data, value: input.value, model }) : probeInference({ ...input, model });
+}
+function usable(verdict) {
+  return verdict.status !== "rejected" && verdict.status !== "exhausted";
+}
+async function reportVerdict(input) {
+  if (input.verdict.status === "unknown") return;
+  await apiFetch({
+    path: "/api/runtime/credentials/status",
+    method: "POST",
+    headers: { authorization: `Bearer ${input.receipt}`, "content-type": "application/json" },
+    body: JSON.stringify(input.verdict),
+    signal: AbortSignal.timeout(5e3)
+  }).catch(() => log.debug("\xBB could not record a credential verdict"));
+}
+function activate(input) {
+  for (const name of input.names) {
+    delete process.env[name];
+    delete receipts[name];
+    if (name === "CODEX_AUTH_JSON" || name === "GROK_AUTH_JSON") clearInstalledSubscription(name);
+  }
+  const value2 = sanitizeSecret(input.name, input.value);
+  if (!value2) throw new Error("configured credential was empty");
+  process.env[input.name] = value2;
+  if (input.receipt) receipts[input.name] = input.receipt;
+  installCodexAuth();
+  installXaiAuth();
+  saveReceipts();
+  authorizeModel(input.model);
 }
 
 // utils/gitAuthServer.ts
@@ -195331,75 +195707,6 @@ function buildModelAccessError(input) {
   return [headline, "", why, "", cta].join("\n");
 }
 
-// utils/normalizeEnv.ts
-function hasControlCharacter(value2) {
-  return [...value2].some((ch) => {
-    const code = ch.charCodeAt(0);
-    return code < 32 || code === 127;
-  });
-}
-function sanitizeSecret(key, value2) {
-  const trimmed = value2.trim();
-  if (trimmed.length === 0) {
-    log.warning(
-      `\xBB ${key} is whitespace-only \u2014 leaving env var unchanged. check your secret value.`
-    );
-    return null;
-  }
-  if (key.endsWith("_API_KEY") && hasControlCharacter(trimmed)) {
-    log.warning(
-      `\xBB ${key} contains a line break or control character and cannot be sent as an HTTP header \u2014 leaving env var unchanged. re-save the secret as a single line.`
-    );
-    return null;
-  }
-  if (trimmed !== value2) {
-    log.warning(
-      `\xBB stripped whitespace from ${key} (whitespace in secret values breaks GitHub Actions log masking)`
-    );
-  }
-  maskSecret(trimmed);
-  return trimmed;
-}
-function normalizeEnv() {
-  const upperKeys = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(process.env)) {
-    const upper2 = key.toUpperCase();
-    const existing = upperKeys.get(upper2) || [];
-    existing.push(key);
-    upperKeys.set(upper2, existing);
-  }
-  for (const [upperKey, keys] of upperKeys) {
-    if (keys.length === 1) {
-      const key = keys[0];
-      if (key !== upperKey) {
-        process.env[upperKey] = process.env[key];
-        delete process.env[key];
-      }
-      continue;
-    }
-    const values = keys.map((k2) => process.env[k2]);
-    const uniqueValues = new Set(values);
-    if (uniqueValues.size > 1) {
-      log.warning(
-        `env var conflict: ${keys.join(", ")} have different values. using uppercase ${upperKey}.`
-      );
-    }
-    const preferredKey = keys.find((k2) => k2 === upperKey) || keys[0];
-    const preferredValue = process.env[preferredKey];
-    for (const key of keys) {
-      delete process.env[key];
-    }
-    process.env[upperKey] = preferredValue;
-  }
-  for (const key of Object.keys(process.env)) {
-    if (!isSensitiveEnvName(key)) continue;
-    const value2 = process.env[key];
-    if (typeof value2 !== "string" || value2.length === 0) continue;
-    const sanitized = sanitizeSecret(key, value2);
-    if (sanitized !== null) process.env[key] = sanitized;
-  }
-}
-
 // utils/overrides.ts
 var DENIED_OVERRIDE_NAMES = /* @__PURE__ */ new Set([
   "GITHUB_TOKEN",
@@ -195970,7 +196277,6 @@ ${ctx.error}` : ctx.error;
     workflowRun: runId ? { owner: repoContext.owner, repo: repoContext.name, runId } : void 0,
     customParts,
     model: ctx.toolState.model,
-    fallbackFrom: ctx.toolState.modelFallback?.from,
     clamped: ctx.toolState.modelClamped,
     unselectedProxyDefault: ctx.toolState.unselectedProxyDefault,
     oss: ctx.toolState.oss,
@@ -196354,7 +196660,8 @@ async function fetchRunContext(params) {
   const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const headers = {
-      Authorization: `Bearer ${params.token}`
+      Authorization: `Bearer ${params.token}`,
+      "X-Pullfrog-Credential-Pools": "1"
     };
     if (params.oidcToken) {
       headers["X-GitHub-OIDC-Token"] = params.oidcToken;
@@ -197651,16 +197958,20 @@ async function main() {
     const preIntrospectionDirty = repoDir ? await dirtyTrackedPaths({ cwd: repoDir }) : null;
     const opencodeCliPath = await agents.opencode.install();
     captureBaselineModels(opencodeCliPath);
+    const injected = [];
     if (runContext.dbSecrets) {
       for (const [key, value2] of Object.entries(runContext.dbSecrets)) {
         if (!process.env[key]) {
           const sanitized = sanitizeSecret(key, value2);
-          if (sanitized !== null) process.env[key] = sanitized;
+          if (sanitized === null) continue;
+          process.env[key] = sanitized;
+          injected.push(key);
         }
       }
       const count = Object.keys(runContext.dbSecrets).length;
       if (count > 0) log.info(`\xBB ${count} db secret(s) loaded`);
     }
+    await initializeCredentialPool({ ctx: runContext, slug: payload.model, injected });
     installCodexAuth();
     installXaiAuth();
     captureAuthorizedModels(opencodeCliPath);
@@ -197734,13 +198045,23 @@ async function main() {
         }
         const gitAuthServer = __using(_stack2, await startGitAuthServer(tmpdir3), true);
         setGitAuthServer(gitAuthServer);
+        let resolvedModel = resolveModel({ slug: payload.model });
+        if (!resolvedModel && !payload.proxyModel && runContext.credentialAccess?.candidates.length) {
+          resolvedModel = resolvePoolModel({
+            codexAgent: runContext.repoSettings.codexAgent || payload.codexArm === true
+          });
+        }
+        let poolSelected = !payload.proxyModel && await selectConfiguredCredential({
+          ctx: runContext,
+          model: resolvedModel
+        });
         const access = decideModelAccess({
           modelExplicit: payload.modelExplicit ?? false,
           model: payload.model,
           oss: runContext.oss,
           proxyActive: !!payload.proxyModel,
           subsidyTarget: runContext.proxyModel,
-          resolvedModel: resolveModel({ slug: payload.model }),
+          resolvedModel,
           authorized: getAuthorizedModels()
         });
         if (access.kind === "error") {
@@ -197754,15 +198075,19 @@ async function main() {
           );
         }
         if (access.kind === "proxy") payload.proxyModel = access.target;
-        if (access.kind === "byok") payload.proxyModel = void 0;
+        if (access.kind === "byok") {
+          payload.proxyModel = void 0;
+          if (!poolSelected)
+            poolSelected = await selectConfiguredCredential({
+              ctx: runContext,
+              model: resolvedModel
+            });
+        }
         if (runContext.oss && payload.proxyModel) {
           payload.effort = ossEffortFloor({ payload });
         }
-        const configuredModel = payload.proxyModel ? void 0 : resolveModel({ slug: payload.model });
-        const credentials = payload.proxyModel ? { kind: "ok" } : await checkConfiguredCredentials({
-          model: configuredModel,
-          authorized: getAuthorizedModels()
-        });
+        if (payload.proxyModel) resolvedModel = void 0;
+        const credentials = payload.proxyModel || poolSelected ? { kind: "ok" } : await checkConfiguredCredentials({ model: resolvedModel });
         if (credentials.kind === "dead") {
           throw new Error(
             buildRejectedCredentialError({
@@ -197774,13 +198099,6 @@ async function main() {
             })
           );
         }
-        if (credentials.kind === "fellBack" && configuredModel) {
-          log.warning(
-            `\xBB ${credentials.credential} was rejected by its provider \u2014 running ${credentials.replacement} instead of ${configuredModel}`
-          );
-          toolState.modelFallback = { from: configuredModel };
-        }
-        const resolvedModel = credentials.kind === "fellBack" ? credentials.replacement : configuredModel;
         vertexCredentials = materializeVertexCredentials({ model: resolvedModel });
         let agent2 = resolveAgent({
           model: resolvedModel,
@@ -198090,12 +198408,12 @@ ${instructions.user}` : null,
         if (payload.timeout === TIMEOUT_DISABLED) {
           result = await Promise.race([agentPromise, activityTimeout.promise]);
         } else {
-          const usable = resolveTimeoutMs(payload.timeout);
-          if (payload.timeout && usable === null) {
+          const usable2 = resolveTimeoutMs(payload.timeout);
+          if (payload.timeout && usable2 === null) {
             log.warning(`invalid timeout "${payload.timeout}" (use --notimeout to disable), using 1h`);
           }
-          const timeoutMs = usable ?? 36e5;
-          const actualTimeout = usable !== null ? payload.timeout : "1h";
+          const timeoutMs = usable2 ?? 36e5;
+          const actualTimeout = usable2 !== null ? payload.timeout : "1h";
           let timeoutId;
           const timeoutPromise = new Promise((_4, reject) => {
             timeoutId = setTimeout(() => {