@desplega.ai/agent-swarm 2.7.4 → 2.7.5

package/src/providers/codex-oauth/subscription.ts

@@ -0,0 +1,67 @@
+/**
+ * ChatGPT subscription credential for a pi session that runs an
+ * `openai-codex/<id>` model (see `@desplega/model-catalog`'s
+ * `chatgpt-subscription.ts`).
+ *
+ * The runner picks a `codex_oauth_<n>` pool slot exactly as it does for codex
+ * (`resolveCodexOAuthCredentialInfo`, same rate-limit bookkeeping) and passes
+ * it as `codexSlot`. This revalidates that slot through the locked
+ * `getValidCodexOAuth`, the sole path that ever exchanges a pool refresh
+ * token, and returns the credential with the refresh token BLANKED. The
+ * harness gets an access token it can use but never a refresh token it could
+ * rotate outside `/api/oauth/refresh-locks`: OpenAI revokes the whole token
+ * family on replay, which would kill the slot for every worker. Same contract
+ * as `credentialsToAuthJson(..., { includeRefreshToken: false })` for codex.
+ *
+ * Accepted cost: a session that outlives the access token errors instead of
+ * refreshing. `getValidCodexOAuth` hands out tokens with at least 12 h left.
+ */
+
+import { chatgptSubscriptionModelId } from "@desplega/model-catalog";
+import { isCodexRejectedAccessError } from "../../utils/codex-auth-failure";
+import { registerVolatileSecret } from "../../utils/secret-scrubber";
+import type { ProviderSessionConfig } from "../types";
+import { buildPoolRevalidationFailureReason, getValidCodexOAuth } from "./storage.js";
+import type { CodexOAuthCredentials } from "./types.js";
+
+export async function loadChatgptSubscriptionCredential(
+  config: Pick<ProviderSessionConfig, "apiUrl" | "apiKey" | "codexSlot" | "model">,
+  deps: { getValid?: typeof getValidCodexOAuth } = {},
+): Promise<CodexOAuthCredentials> {
+  const slot = config.codexSlot;
+  if (slot === undefined || !config.apiUrl || !config.apiKey) {
+    throw new Error(
+      `[auth-error] Model "${config.model}" runs on the ChatGPT subscription pool, but no codex_oauth pool slot is configured. Run codex-login to add one, or pick a model with its own API key.`,
+    );
+  }
+  const getValid = deps.getValid ?? getValidCodexOAuth;
+  let creds: CodexOAuthCredentials | null;
+  try {
+    creds = await getValid(config.apiUrl, config.apiKey, slot);
+  } catch (err) {
+    throw new Error(buildPoolRevalidationFailureReason(err, slot));
+  }
+  if (!creds) {
+    throw new Error(
+      `[auth-error] Codex pool slot ${slot} revalidation failed: no credentials found in config store — the slot may have just been quarantined; re-run codex-login for this slot if this persists.`,
+    );
+  }
+  registerVolatileSecret(creds.access, "CODEX_OAUTH_ACCESS_TOKEN");
+  return { ...creds, refresh: "" };
+}
+
+/**
+ * The `[auth-error]` failure reason for a subscription session whose access
+ * the ChatGPT backend rejected mid-run (a login revoked while its access
+ * token is unexpired), else undefined. The runner counts it toward the
+ * slot's auth-failure bench, as it does codex's turn-level 401.
+ */
+export function chatgptSubscriptionAuthFailure(
+  raw: string,
+  config: Pick<ProviderSessionConfig, "codexSlot" | "model">,
+): string | undefined {
+  const slot = config.codexSlot;
+  if (slot === undefined || !chatgptSubscriptionModelId(config.model)) return undefined;
+  if (!isCodexRejectedAccessError(raw)) return undefined;
+  return `[auth-error] Codex pool slot ${slot} authentication failed — re-run agent-swarm codex-login --slot ${slot}. Original error: ${raw}`;
+}

package/src/providers/fx-adapter.ts

@@ -0,0 +1,211 @@
+// Bun has no rename, chmod or mkdir API; file reads and writes use Bun.file/Bun.write.
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getKnownContextWindowSize } from "../utils/context-window";
+import { FX_ROUTE_KEY_VARS, type ResolvedFxRoute, requireFxRoute } from "../utils/fx-models";
+import { getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import { registerVolatileSecret } from "../utils/secret-scrubber";
+import { ACPAdapter } from "./acp-adapter";
+import { fxSessionExists, fxTargetProfile } from "./acp-targets";
+import type {
+  CredStatus,
+  ProviderAdapter,
+  ProviderSession,
+  ProviderSessionConfig,
+  ProviderTraits,
+} from "./types";
+
+/**
+ * The fx release the worker image installs (`ARG FX_VERSION` in
+ * Dockerfile.worker; bump the two together). Every ACP shape this adapter
+ * relies on was measured against it.
+ */
+export const FX_PINNED_VERSION = "0.0.15";
+
+/** OpenAI's Chat Completions prefix; fx appends `/chat/completions`. */
+export const FX_OPENAI_BASE_URL = "https://api.openai.com/v1";
+
+/**
+ * fx (Vercel Labs' terminal coding agent) on the swarm's ACP client: `fx acp`
+ * is an ACP server, so spawn, swarm MCP, permissions, event translation and
+ * cost come from {@link ACPAdapter} with {@link fxTargetProfile}. This adapter
+ * resolves the model route, checks its key and seeds `~/.fx/settings.json`.
+ *
+ * Routes (`src/utils/fx-models.ts`): `openrouter/<vendor>/<id>` on
+ * OPENROUTER_API_KEY, `vercel/<vendor>/<id>` on AI_GATEWAY_API_KEY, a bare
+ * OpenAI id on OPENAI_API_KEY.
+ */
+export function checkFxCredentials(env: Record<string, string | undefined>): CredStatus {
+  return FX_ROUTE_KEY_VARS.some((name) => env[name]?.trim())
+    ? { ready: true, missing: [], satisfiedBy: "env" }
+    : {
+        ready: false,
+        missing: [...FX_ROUTE_KEY_VARS],
+        hint: "Set OPENROUTER_API_KEY (openrouter/<vendor>/<id>), OPENAI_API_KEY (bare OpenAI ids) or AI_GATEWAY_API_KEY (vercel/<vendor>/<id>) for fx.",
+      };
+}
+
+type JsonObject = Record<string, unknown>;
+
+function isJsonObject(value: unknown): value is JsonObject {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/** An fx custom connection: OpenAI Chat Completions with a bearer key read from `keyVar`. */
+function connection(baseUrl: string, keyVar: string): JsonObject {
+  return {
+    protocol: "openai-chat-completions",
+    base_url: baseUrl,
+    auth: { type: "bearer", env: keyVar },
+  };
+}
+
+export interface FxSettingsInput {
+  /** The home dir whose `.fx/settings.json` fx reads (fx has no config-dir override). */
+  home: string;
+  route: ResolvedFxRoute;
+  /** The model's context window, registered so fx reports usage and compacts on time. */
+  contextWindow?: number;
+  openRouterBaseUrl: string;
+}
+
+/**
+ * `~/.fx/settings.json` with the swarm-owned keys merged in:
+ * - `providers.openrouter` and `providers.openai`: custom connections that
+ *   name the key's env var (never its value). Fields the swarm does not own
+ *   (`model_metadata`, `tool_choice_mode`, ...) are kept.
+ * - `model_metadata[<id>].context_window` for the session's model on its
+ *   connection, when the catalog knows it and the file has no entry: without
+ *   a window fx sends no `usage_update` and cannot time compaction.
+ * - `auto_upgrade: false` (the image pins fx) and `session_titles: false`
+ *   (a title is an extra, unmetered model call).
+ * Every other key is preserved. Pure.
+ */
+export function mergeFxSettings(
+  current: JsonObject,
+  input: Omit<FxSettingsInput, "home">,
+): JsonObject {
+  const next: JsonObject = structuredClone(current);
+  const providers: JsonObject = isJsonObject(next.providers) ? next.providers : {};
+  const owned: Record<string, JsonObject> = {
+    openrouter: connection(input.openRouterBaseUrl, "OPENROUTER_API_KEY"),
+    openai: connection(FX_OPENAI_BASE_URL, "OPENAI_API_KEY"),
+  };
+  for (const [name, fields] of Object.entries(owned)) {
+    const existing = isJsonObject(providers[name]) ? providers[name] : {};
+    providers[name] = { ...existing, ...fields };
+  }
+  const { fxProvider, fxModel } = input.route;
+  const target = fxProvider === "gateway" ? undefined : (providers[fxProvider] as JsonObject);
+  if (target && input.contextWindow && input.contextWindow > 0) {
+    const metadata = isJsonObject(target.model_metadata) ? target.model_metadata : {};
+    if (!isJsonObject(metadata[fxModel])) {
+      metadata[fxModel] = { context_window: input.contextWindow };
+    }
+    target.model_metadata = metadata;
+  }
+  next.providers = providers;
+  next.auto_upgrade = false;
+  next.session_titles = false;
+  return next;
+}
+
+/**
+ * Merge the swarm's keys into `<home>/.fx/settings.json` ({@link mergeFxSettings}).
+ * Idempotent: an unchanged file is not rewritten. Atomic: the new content goes
+ * to a temp file in the same dir, then replaces the old one with a rename, so
+ * a concurrent fx never reads half a file. A file that is not a JSON object is
+ * an error, not something to overwrite.
+ */
+export async function ensureFxSettings(input: FxSettingsInput): Promise<{
+  path: string;
+  changed: boolean;
+}> {
+  const path = join(input.home, ".fx", "settings.json");
+  const file = Bun.file(path);
+  let current: JsonObject = {};
+  if (await file.exists()) {
+    const text = await file.text();
+    if (text.trim()) {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        throw new Error(`${path} is not valid JSON; fix or remove it before running fx`);
+      }
+      if (!isJsonObject(parsed)) {
+        throw new Error(`${path} is not a JSON object; fix or remove it before running fx`);
+      }
+      current = parsed;
+    }
+  }
+  const next = mergeFxSettings(current, input);
+  if (JSON.stringify(next) === JSON.stringify(current)) return { path, changed: false };
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const tmp = `${path}.swarm-${process.pid}-${randomUUID()}.tmp`;
+  try {
+    await Bun.write(tmp, `${JSON.stringify(next, null, 2)}\n`);
+    await chmod(tmp, 0o600);
+    await rename(tmp, path);
+  } catch (error) {
+    await rm(tmp, { force: true });
+    throw error;
+  }
+  return { path, changed: true };
+}
+
+export interface FxAdapterOptions {
+  /** The home dir fx runs under. Defaults to the session's `HOME`. Tests inject a temp dir. */
+  home?: string;
+}
+
+export class FxAdapter implements ProviderAdapter {
+  readonly name = "fx";
+
+  readonly traits: ProviderTraits = {
+    hasMcp: true,
+    // fx defers swarm tools behind its own `capability_search`; the prompt
+    // uses the fx-specific discovery line, not the generic tool-search one.
+    hasToolSearch: false,
+    // `~/.claude/skills` is a native fx skill root (verified: a planted skill loaded).
+    nativeSkillDiscovery: true,
+    hasLocalEnvironment: true,
+    steerModes: ["steer"],
+  };
+
+  private readonly acp = new ACPAdapter({ providerName: "fx", target: fxTargetProfile });
+
+  constructor(private readonly options: FxAdapterOptions = {}) {}
+
+  async createSession(sessionConfig: ProviderSessionConfig): Promise<ProviderSession> {
+    const route = requireFxRoute(sessionConfig.model);
+    const env = { ...process.env, ...sessionConfig.env };
+    const apiKey = env[route.keyVar]?.trim();
+    if (!apiKey) throw new Error(`fx requires ${route.keyVar} for ${route.model}`);
+    registerVolatileSecret(apiKey, route.keyVar);
+    const home = this.options.home ?? env.HOME;
+    if (!home) throw new Error("fx requires HOME: it keeps its settings and sessions in ~/.fx");
+
+    await ensureFxSettings({
+      home,
+      route,
+      contextWindow:
+        route.fxProvider === "gateway" ? undefined : getKnownContextWindowSize(route.model),
+      openRouterBaseUrl: getOpenRouterBaseUrl(env),
+    });
+    return this.acp.createSession({
+      ...sessionConfig,
+      model: route.model,
+      env: { ...sessionConfig.env, [route.keyVar]: apiKey, HOME: home },
+    });
+  }
+
+  async canResume(sessionId: string): Promise<boolean> {
+    return fxSessionExists(sessionId, this.options.home ?? process.env.HOME);
+  }
+
+  formatCommand(commandName: string): string {
+    return `/${commandName}`;
+  }
+}

package/src/providers/index.ts

@@ -63,13 +63,17 @@ export async function createProviderAdapter(provider: string): Promise<ProviderA
       const { GrokAdapter } = await import("./grok-adapter");
       return new GrokAdapter();
     }
+    case "fx": {
+      const { FxAdapter } = await import("./fx-adapter");
+      return new FxAdapter();
+    }
     case "acp": {
       const { ACPAdapter } = await import("./acp-adapter");
       return new ACPAdapter();
     }
     default:
       throw new Error(
-        `Unknown HARNESS_PROVIDER: "${provider}". Supported: claude, pi, codex, devin, claude-managed, opencode, acp, dsh, cursor, amp, grok`,
+        `Unknown HARNESS_PROVIDER: "${provider}". Supported: claude, pi, codex, devin, claude-managed, opencode, acp, dsh, cursor, amp, grok, fx`,
       );
   }
 }

package/src/providers/mcp-loopback-proxy.ts

@@ -0,0 +1,94 @@
+import { scrubSecrets } from "../utils/secret-scrubber";
+
+/**
+ * A 127.0.0.1 forwarder in front of a plain-HTTP MCP endpoint.
+ *
+ * Some ACP targets (fx) accept an MCP server URL only when it is HTTPS or an
+ * explicit loopback HTTP endpoint, and reject `http://api:3013/mcp` with
+ * `-32602`. The forwarder listens on an ephemeral loopback port and streams
+ * every request and response (SSE included) to `upstream`, so the target sees
+ * `http://127.0.0.1:<port>/…`. Worker-side HTTP only: no DB access.
+ *
+ * Header values are never logged; error text goes through `scrubSecrets`.
+ */
+export interface McpLoopbackProxy {
+  /** `http://127.0.0.1:<port>`, no trailing slash. Append the upstream-relative path. */
+  readonly url: string;
+  stop(): Promise<void>;
+}
+
+/** Hop-by-hop headers a proxy must not forward, plus `host` (the upstream's own). */
+const DROPPED_REQUEST_HEADERS = [
+  "host",
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "upgrade",
+];
+
+/** Hosts fx treats as explicit loopback (fx 0.0.15: `127.0.0.2` is rejected). */
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+
+/** True when `url` is plain `http://` to a host that is not an explicit loopback name. */
+export function needsLoopbackProxy(url: string): boolean {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  return parsed.protocol === "http:" && !LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase());
+}
+
+/**
+ * Start a forwarder to `upstream` (a base URL; its path is kept as a prefix).
+ * A request for `/mcp?x=1` goes to `<upstream>/mcp?x=1`.
+ */
+export async function startMcpLoopbackProxy(upstream: string): Promise<McpLoopbackProxy> {
+  const base = new URL(upstream);
+  const prefix = base.pathname.replace(/\/+$/, "");
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    // SSE responses stay open with no traffic between events.
+    idleTimeout: 0,
+    async fetch(req) {
+      const incoming = new URL(req.url);
+      const target = new URL(base);
+      target.pathname = `${prefix}${incoming.pathname}`;
+      target.search = incoming.search;
+      const headers = new Headers(req.headers);
+      for (const name of DROPPED_REQUEST_HEADERS) headers.delete(name);
+      try {
+        const hasBody = req.method !== "GET" && req.method !== "HEAD";
+        return await fetch(target, {
+          method: req.method,
+          headers,
+          body: hasBody ? req.body : undefined,
+          redirect: "manual",
+          signal: req.signal,
+          // Pass bytes through untouched: decompressing here would leave a
+          // stale content-encoding header on the forwarded response.
+          decompress: false,
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return new Response(
+          JSON.stringify({
+            error: scrubSecrets(`MCP loopback proxy: upstream failed: ${message}`),
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } },
+        );
+      }
+    },
+  });
+  let stopped: Promise<void> | null = null;
+  return {
+    url: `http://127.0.0.1:${server.port}`,
+    stop() {
+      stopped ??= server.stop(true);
+      return stopped;
+    },
+  };
+}

package/src/providers/pi-mono-adapter.ts

@@ -18,6 +18,8 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+  CHATGPT_SUBSCRIPTION_PROVIDER,
+  chatgptSubscriptionModelId,
   ignoredBaseUrlVar,
   type OpenAICompatibleProvider,
   openAICompatibleKeyVars,
@@ -29,6 +31,7 @@ import {
   providerKeyFromEnv,
   providerKeyVars,
 } from "@desplega/model-catalog";
+import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import {
   getBuiltinModel as getModel,
   getBuiltinModels as getModels,
@@ -71,6 +74,12 @@ import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
 import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
 import { snapshotCatalogRows } from "../utils/runtime-model-catalog";
 import { registerEnvSecrets, scrubObject, scrubSecrets } from "../utils/secret-scrubber";
+import { hasCodexOAuthPoolSlots } from "./codex-oauth/env-keys.js";
+import {
+  chatgptSubscriptionAuthFailure,
+  loadChatgptSubscriptionCredential,
+} from "./codex-oauth/subscription.js";
+import type { CodexOAuthCredentials } from "./codex-oauth/types.js";
 import { readPkgVersion } from "./harness-version";
 import { createSwarmHooksExtension } from "./pi-mono-extension";
 import { McpHttpClient, type McpTool } from "./pi-mono-mcp-client";
@@ -328,6 +337,17 @@ export async function checkPiMonoCredentials(
     }
   }
 
+  // A ChatGPT subscription model runs on the codex_oauth pool only: the
+  // session gets a per-task in-memory credential, never auth.json or a key.
+  if (chatgptSubscriptionModelId(env.MODEL_OVERRIDE)) {
+    if (hasCodexOAuthPoolSlots(env)) return { ready: true, missing: [], satisfiedBy: "env" };
+    return {
+      ready: false,
+      missing: ["CODEX_OAUTH"],
+      hint: `MODEL_OVERRIDE=${env.MODEL_OVERRIDE} runs on the ChatGPT subscription pool; add a codex_oauth slot (codex-login) or pick a model with its own API key.`,
+    };
+  }
+
   const homeDir = opts.homeDir ?? env.HOME ?? "/root";
   const fsProbe = opts.fs?.existsSync ?? existsSync;
   const authFile = `${homeDir}/.pi/agent/auth.json`;
@@ -351,11 +371,13 @@ export async function checkPiMonoCredentials(
   // Permissive case: any one supported key works. A registry provider key
   // (NaN, Helmcode) only serves `<id>/*` models, but it is still a usable pi
   // credential (the task's explicit model is checked above once it is set).
+  // The codex_oauth pool likewise serves only `openai-codex/*` models.
   if (
     env.ANTHROPIC_API_KEY ||
     env.OPENROUTER_API_KEY ||
     env.OPENAI_API_KEY ||
-    openAICompatibleKeyVars().some((k) => env[k])
+    openAICompatibleKeyVars().some((k) => env[k]) ||
+    hasCodexOAuthPoolSlots(env)
   ) {
     return { ready: true, missing: [], satisfiedBy: "env" };
   }
@@ -518,12 +540,16 @@ const PI_RUNTIME_API_KEYS: readonly (readonly [envKey: string, provider: string]
 export async function createPiRuntimeAuth(
   env: Record<string, string | undefined> = process.env,
   modelsPath?: string,
+  subscription?: CodexOAuthCredentials,
 ): Promise<ModelRuntime> {
   // A per-session models.json (`writeSessionModelsJson`) still shares the
   // agent dir's catalog cache, which only holds built-in provider catalogs.
-  const modelRuntime = await ModelRuntime.create(
-    modelsPath ? { modelsPath, modelsStorePath: join(getAgentDir(), "models-store.json") } : {},
-  );
+  const modelRuntime = await ModelRuntime.create({
+    ...(modelsPath
+      ? { modelsPath, modelsStorePath: join(getAgentDir(), "models-store.json") }
+      : {}),
+    ...(subscription ? { credentials: await subscriptionCredentialStore(subscription) } : {}),
+  });
   for (const [envKey, provider] of PI_RUNTIME_API_KEYS) {
     const apiKey = env[envKey];
     if (apiKey) {
@@ -534,6 +560,28 @@ export async function createPiRuntimeAuth(
   return modelRuntime;
 }
 
+/**
+ * A ChatGPT subscription session's credential store: in memory, per session,
+ * holding only the pool slot's `openai-codex` OAuth entry with the refresh
+ * token blanked (`loadChatgptSubscriptionCredential`). It replaces
+ * `~/.pi/agent/auth.json` for this session, so nothing reaches disk and
+ * concurrent sessions on different slots never share an entry. A refresh pi
+ * attempts fails on the empty token and stays in memory.
+ */
+async function subscriptionCredentialStore(
+  creds: CodexOAuthCredentials,
+): Promise<InMemoryCredentialStore> {
+  const store = new InMemoryCredentialStore();
+  await store.modify(CHATGPT_SUBSCRIPTION_PROVIDER, async () => ({
+    type: "oauth",
+    access: creds.access,
+    refresh: "",
+    expires: creds.expires,
+    accountId: creds.accountId,
+  }));
+  return store;
+}
+
 /**
  * Legacy sidecar marker. Earlier versions wrote the OpenRouter gateway into
  * the shared `<agentDir>/models.json` and recorded here the `baseUrl` they
@@ -783,6 +831,9 @@ function resolveModelInner(
 ) {
   if (!modelStr) return undefined;
 
+  const subscriptionId = chatgptSubscriptionModelId(modelStr);
+  if (subscriptionId) return resolveSubscriptionModel(subscriptionId, modelRuntime);
+
   const lower = modelStr.toLowerCase();
   const isAnthropicShortname =
     lower === "opus" || lower === "sonnet" || lower === "haiku" || lower === "fable";
@@ -847,6 +898,24 @@ function resolveModelInner(
   return undefined;
 }
 
+/**
+ * `openai-codex/<id>`: pi-ai's ChatGPT backend provider. Its builtin list
+ * trails the OpenAI catalog ids the picker offers (the codex harness list), so
+ * an id it does not ship reuses a shipped model's transport settings under the
+ * requested id. The ChatGPT backend rejects an id the subscription does not
+ * serve, which fails the task with the upstream error.
+ */
+function resolveSubscriptionModel(
+  modelId: string,
+  modelRuntime: Pick<ModelRuntime, "getModel"> | undefined,
+) {
+  const provider = CHATGPT_SUBSCRIPTION_PROVIDER as "openai-codex";
+  const known = getModel(provider, modelId as never) ?? modelRuntime?.getModel(provider, modelId);
+  if (known) return known;
+  const template = getModels(provider)[0];
+  return template ? { ...template, id: modelId, name: modelId } : undefined;
+}
+
 /** Manage AGENTS.md symlink for pi-mono CLAUDE.md compatibility */
 function createAgentsMdSymlink(cwd: string): boolean {
   const claudeMd = join(cwd, "CLAUDE.md");
@@ -1301,6 +1370,14 @@ export class PiMonoSession implements ProviderSession {
     }
   }
 
+  /** An AWS SDK failure, or a rejected ChatGPT subscription login. */
+  private classifyFailure(raw: string): { message: string; category: string } | undefined {
+    const aws = classifyAwsSdkError(raw);
+    if (aws) return aws;
+    const auth = chatgptSubscriptionAuthFailure(raw, this.config);
+    return auth ? { message: auth, category: "authentication_failed" } : undefined;
+  }
+
   private async runSession(): Promise<ProviderResult> {
     try {
       // Pi expands a leading `/skill:name` itself, with no tool call to observe.
@@ -1333,7 +1410,7 @@ export class PiMonoSession implements ProviderSession {
       // exactly like sibling adapters. AWS errors get a categorized, actionable
       // message; anything else surfaces its raw error text.
       if (this.terminalError) {
-        const classification = classifyAwsSdkError(this.terminalError);
+        const classification = this.classifyFailure(this.terminalError);
         const message = scrubSecrets(classification?.message ?? this.terminalError);
         const category = classification?.category;
         this.emit({ type: "error", message, category });
@@ -1385,13 +1462,14 @@ export class PiMonoSession implements ProviderSession {
       // Defense-in-depth: AWS SDK failures surface as structured events (handled
       // above in runSession), not thrown exceptions, so this catch is for genuine
       // unexpected throws (MCP / transport / etc). Still classify in case an AWS
-      // signature ever reaches here, so the red box fires like sibling adapters.
-      const awsCatchError = classifyAwsSdkError(errorMessage);
-      if (awsCatchError) {
+      // signature or a rejected subscription login ever reaches here, so the
+      // red box fires like sibling adapters.
+      const classifiedError = this.classifyFailure(errorMessage);
+      if (classifiedError) {
         this.emit({
           type: "error",
-          message: awsCatchError.message,
-          category: awsCatchError.category,
+          message: classifiedError.message,
+          category: classifiedError.category,
         });
       }
       this.emit({ type: "raw_stderr", content: `[pi-mono] Error: ${errorMessage}\n` });
@@ -1402,8 +1480,8 @@ export class PiMonoSession implements ProviderSession {
         sessionId: this._sessionId,
         cost,
         isError: true,
-        errorCategory: awsCatchError?.category,
-        failureReason: scrubSecrets(awsCatchError?.message ?? errorMessage),
+        errorCategory: classifiedError?.category,
+        failureReason: scrubSecrets(classifiedError?.message ?? errorMessage),
         appliedReasoningEffort: this.appliedReasoningEffort,
       };
     } finally {
@@ -1992,7 +2070,14 @@ export class PiMonoAdapter implements ProviderAdapter {
     const { createdSymlink, customTools, deferTools, piMcpServers } = setup;
     // The runtime is created before resolving so custom providers, which only
     // exist in its composed store, can resolve.
-    const modelRuntime = await createPiRuntimeAuth(sessionEnv, sessionModels.modelsPath);
+    const subscription = chatgptSubscriptionModelId(config.model)
+      ? await loadChatgptSubscriptionCredential(config)
+      : undefined;
+    const modelRuntime = await createPiRuntimeAuth(
+      sessionEnv,
+      sessionModels.modelsPath,
+      subscription,
+    );
     const resolvedModel = resolveModel(config.model, sessionEnv, modelRuntime);
     // models.json overrides (e.g. the OpenRouter gateway baseUrl) only apply
     // to models resolved through the runtime's composed store; the builtin

package/src/providers/pricing-sources.md

@@ -78,6 +78,14 @@ rate by hand should also update this file.
     what xAI billed (`_meta.usage.costUsdTicks`), which wins over these rows
     as for amp. OpenRouter models also project under `provider='grok'` for
     `openrouter/<id>` models, which report no USD.
+  - fx (`provider='fx'`) reports tokens and no USD, so every fx row is
+    priced from the table (`costSource: "pricing-table"`). The lookup strips
+    the routing prefix (`src/be/pricing-normalize.ts`): an
+    `openrouter/<vendor>/<id>` model prices at OpenRouter's `<vendor>/<id>`
+    rate, a `vercel/<vendor>/<id>` model at the AI Gateway `<vendor>/<id>`
+    rate, a bare id at OpenAI's rate. fx reports no cache split, so every
+    input token prices at the uncached rate, and its counts exclude
+    sub-agent and helper-model calls: the figure is an estimate.
   - OpenAI, Anthropic, Google and xAI models (bare vendor ids) → rows under
     `provider='cursor'`. Cursor bills the vendor's API rates and reports the
     vendor's own id. The adapter subtracts cache reads and writes from SDK