@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/mcp-client/http-client.ts

@@ -0,0 +1,194 @@
+/**
+ * Minimal MCP client for Streamable HTTP transport.
+ *
+ * Performs the initialize handshake, tracks MCP session IDs, parses JSON/SSE
+ * responses, discovers tools, and forwards tool calls. The client itself is
+ * transport-only: callers provide any auth headers and it never imports DB code.
+ */
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface McpToolCallResult {
+  content: Array<{ type: string; text?: string }>;
+  isError?: boolean;
+}
+
+export type McpJsonRpcError = {
+  code?: number;
+  message?: string;
+  data?: unknown;
+};
+
+export type McpToolCallEnvelope =
+  | { ok: true; result: McpToolCallResult }
+  | { ok: false; error: McpJsonRpcError | string };
+
+function jsonRpcErrorMessage(error: McpJsonRpcError | string): string {
+  if (typeof error === "string") return error;
+  return error.message ?? JSON.stringify(error);
+}
+
+type McpHttpClientOptions = {
+  protocolVersion?: string;
+  clientInfo?: { name: string; version: string };
+  timeoutMs?: number;
+  omitEmptyAuthHeaders?: boolean;
+};
+
+export class McpHttpClient {
+  private sessionId: string | null = null;
+  private nextId = 1;
+  /** Additional headers merged into every request (e.g. for installed MCP servers) */
+  public customHeaders: Record<string, string> = {};
+  /**
+   * When true, baseUrl is used as-is for requests (external MCP servers).
+   * When false (default), /mcp is appended (swarm convention).
+   */
+  public useRawUrl = false;
+
+  constructor(
+    private baseUrl: string,
+    private apiKey: string,
+    private agentId: string,
+    private taskId?: string,
+    private options: McpHttpClientOptions = {},
+  ) {}
+
+  private async send(body: unknown): Promise<{ data: unknown; headers: Headers }> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+    };
+    if (this.apiKey || !this.options.omitEmptyAuthHeaders) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (this.agentId || !this.options.omitEmptyAuthHeaders) {
+      headers["X-Agent-ID"] = this.agentId;
+    }
+    Object.assign(headers, this.customHeaders);
+    if (this.taskId) {
+      headers["X-Source-Task-Id"] = this.taskId;
+    }
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+
+    const controller = this.options.timeoutMs ? new AbortController() : null;
+    const timeout = controller
+      ? setTimeout(() => controller.abort(), this.options.timeoutMs)
+      : null;
+    const url = this.useRawUrl ? this.baseUrl : `${this.baseUrl}/mcp`;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller?.signal,
+      });
+
+      if (!res.ok) {
+        throw new Error(`MCP request failed: ${res.status} ${res.statusText}`);
+      }
+
+      // Capture session ID from response.
+      const sid = res.headers.get("mcp-session-id");
+      if (sid) this.sessionId = sid;
+
+      // Handle SSE responses (extract JSON from event stream).
+      const contentType = res.headers.get("content-type") || "";
+      if (contentType.includes("text/event-stream")) {
+        const text = await res.text();
+        const dataLines = text
+          .split("\n")
+          .filter((line) => line.startsWith("data: "))
+          .map((line) => line.slice(6));
+        const lastData = dataLines[dataLines.length - 1];
+        return { data: lastData ? JSON.parse(lastData) : null, headers: res.headers };
+      }
+
+      const text = await res.text();
+      const data = text.trim() ? JSON.parse(text) : null;
+      return { data, headers: res.headers };
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new Error(`MCP request timed out after ${this.options.timeoutMs}ms`);
+      }
+      throw err;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+
+  /** Perform MCP initialize + initialized handshake */
+  async initialize(): Promise<void> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "initialize",
+      params: {
+        protocolVersion: this.options.protocolVersion ?? "2025-03-26",
+        capabilities: {},
+        clientInfo: this.options.clientInfo ?? {
+          name: "agent-swarm-pi-mono",
+          version: "1.0.0",
+        },
+      },
+    });
+
+    if (!data || typeof data !== "object" || !("result" in (data as Record<string, unknown>))) {
+      throw new Error(`MCP initialize failed: ${JSON.stringify(data)}`);
+    }
+
+    // Send initialized notification (no response expected for notifications).
+    await this.send({
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+  }
+
+  /** Discover all available MCP tools */
+  async listTools(): Promise<McpTool[]> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "tools/list",
+      params: {},
+    });
+
+    const result = data as { result?: { tools?: McpTool[] }; error?: McpJsonRpcError | string };
+    if (result?.error) {
+      throw new Error(`MCP tools/list failed: ${jsonRpcErrorMessage(result.error)}`);
+    }
+    return result?.result?.tools ?? [];
+  }
+
+  /** Call an MCP tool and preserve either the JSON-RPC result or error shape. */
+  async callToolRaw(name: string, args: Record<string, unknown>): Promise<McpToolCallEnvelope> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "tools/call",
+      params: { name, arguments: args },
+    });
+
+    const response = data as {
+      result?: McpToolCallResult;
+      error?: McpJsonRpcError | string;
+    };
+    if (response?.error) return { ok: false, error: response.error };
+    return {
+      ok: true,
+      result: response?.result ?? { content: [{ type: "text", text: "No result" }] },
+    };
+  }
+
+  /** Call an MCP tool */
+  async callTool(name: string, args: Record<string, unknown>): Promise<McpToolCallResult> {
+    const envelope = await this.callToolRaw(name, args);
+    return envelope.ok ? envelope.result : { content: [{ type: "text", text: "No result" }] };
+  }
+}

package/src/oauth/app-validation.ts

@@ -0,0 +1,16 @@
+import { assertUrlSafe, publicEndpointSsrfOptions } from "./mcp-wrapper";
+
+export const RESERVED_OAUTH_PROVIDERS = new Set(["linear", "jira"]);
+
+export function assertOAuthProviderIsNotReserved(provider: string): void {
+  if (!RESERVED_OAUTH_PROVIDERS.has(provider.toLowerCase())) return;
+  throw new Error(
+    `OAuth provider "${provider}" is reserved for dedicated tracker OAuth flows. Use the Linear/Jira tracker integration flow instead.`,
+  );
+}
+
+export function assertOAuthAppUrlsSafe(input: { authorizeUrl: string; tokenUrl: string }): void {
+  const options = publicEndpointSsrfOptions();
+  assertUrlSafe(input.authorizeUrl, options);
+  assertUrlSafe(input.tokenUrl, options);
+}

package/src/oauth/ensure-token.ts

@@ -5,35 +5,70 @@ import {
   isTokenExpiringSoon,
   releaseOAuthRefreshLock,
 } from "../be/db-queries/oauth";
-import type { OAuthTokens } from "../tracker/types";
+import type { OAuthApp, OAuthTokens } from "../tracker/types";
 import { type OAuthProviderConfig, refreshAccessToken } from "./wrapper";
 
-const refreshLocks = new Map<string, Promise<void>>();
-const REFRESH_LOCK_TTL_MS = 2 * 60 * 1000;
-const REFRESH_LOCK_WAIT_MS = 30 * 1000;
-const REFRESH_LOCK_POLL_MS = 250;
+function parseMetadata(metadataJson: string | null | undefined): Record<string, unknown> {
+  try {
+    const parsed = JSON.parse(metadataJson || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function stringRecord(value: unknown): Record<string, string> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, String(item)]));
+}
 
 /**
- * Build an OAuthProviderConfig from the oauth_apps table for any provider.
+ * Map an oauth_apps row to a provider config. Single source of truth for the
+ * token-endpoint behavior knobs stored in metadata (extraParams,
+ * tokenAuthStyle, tokenBodyFormat) — used by ensure-token and re-exported by
+ * be/oauth-credential-bindings (which can't be imported from here without a
+ * cycle).
  */
-function getOAuthConfig(provider: string): OAuthProviderConfig | null {
-  const app = getOAuthApp(provider);
-  if (!app) return null;
+export function oauthAppRowToProviderConfig(app: OAuthApp): OAuthProviderConfig {
+  const metadata = parseMetadata(app.metadata);
+  const extraParams =
+    stringRecord(metadata.extraParams) ??
+    (typeof metadata.actor === "string" ? { actor: metadata.actor } : undefined);
 
-  const metadata = JSON.parse(app.metadata || "{}");
   return {
-    provider,
+    provider: app.provider,
     clientId: app.clientId,
     clientSecret: app.clientSecret,
     authorizeUrl: app.authorizeUrl,
     tokenUrl: app.tokenUrl,
     redirectUri: app.redirectUri,
-    scopes: app.scopes.split(","),
-    extraParams: metadata.extraParams ?? (metadata.actor ? { actor: metadata.actor } : undefined),
-    requiresRefreshTokenRotation: provider === "jira",
+    scopes: app.scopes
+      .split(",")
+      .map((scope) => scope.trim())
+      .filter(Boolean),
+    extraParams,
+    // Standard OAuth wants space-separated scopes; the wrapper's comma
+    // default exists only for Linear, which has its own dedicated flow.
+    scopeSeparator: " ",
+    ...(metadata.tokenAuthStyle === "basic" ? { tokenAuthStyle: "basic" as const } : {}),
+    ...(metadata.tokenBodyFormat === "json" ? { tokenBodyFormat: "json" as const } : {}),
+    requiresRefreshTokenRotation: app.provider === "jira",
   };
 }
 
+const refreshLocks = new Map<string, Promise<void>>();
+const REFRESH_LOCK_TTL_MS = 2 * 60 * 1000;
+const REFRESH_LOCK_WAIT_MS = 30 * 1000;
+const REFRESH_LOCK_POLL_MS = 250;
+
+/**
+ * Build an OAuthProviderConfig from the oauth_apps table for any provider.
+ */
+function getOAuthConfig(provider: string): OAuthProviderConfig | null {
+  const app = getOAuthApp(provider);
+  return app ? oauthAppRowToProviderConfig(app) : null;
+}
+
 async function withProviderRefreshLock<T>(provider: string, fn: () => Promise<T>): Promise<T> {
   const previous = refreshLocks.get(provider) ?? Promise.resolve();
   let release!: () => void;
@@ -94,6 +129,26 @@ export async function ensureToken(provider: string, bufferMs?: number): Promise<
   }
 }
 
+/**
+ * Buffer large enough that any stored expiry counts as "expiring soon",
+ * turning {@link ensureTokenOrThrow} into an unconditional refresh.
+ */
+const FORCE_REFRESH_BUFFER_MS = 1000 * 60 * 60 * 24 * 365 * 100; // ~100 years
+
+/**
+ * Force a refresh of the stored token regardless of remaining lifetime,
+ * going through the exact same in-process queue + DB refresh-lock path as
+ * {@link ensureTokenOrThrow}. Used by the manual refresh endpoint and the
+ * background refresh sweep's keep-alive path.
+ *
+ * Like {@link ensureTokenOrThrow}, stays silent (no throw) when the provider
+ * has no app config or no stored refresh token — callers that need those to
+ * be errors must pre-check.
+ */
+export async function forceRefreshTokenOrThrow(provider: string): Promise<void> {
+  await ensureTokenOrThrow(provider, FORCE_REFRESH_BUFFER_MS);
+}
+
 /**
  * Strict variant of {@link ensureToken}: throws on refresh failure of a
  * configured provider so callers (keepalive, alerting) can react.

package/src/oauth/mcp-wrapper.ts

@@ -96,6 +96,21 @@ export function assertUrlSafe(rawUrl: string, opts: SsrfGuardOptions = {}): URL
   return parsed;
 }
 
+export function publicEndpointSsrfOptions(): SsrfGuardOptions {
+  // Fail closed: NODE_ENV is typically UNSET in the production image (Bun
+  // does not default it), so only an explicit development/test environment —
+  // or the explicit override flag — may fetch private/insecure endpoints.
+  // Local dev entrypoints (`bun run dev:http` / `start:http`) set
+  // NODE_ENV=development.
+  const env = process.env.NODE_ENV;
+  const dev =
+    env === "development" || env === "test" || process.env.ALLOW_PRIVATE_NETWORK_URLS === "true";
+  return {
+    allowPrivateHosts: dev,
+    allowInsecure: dev,
+  };
+}
+
 function defaultSsrfOptions(): SsrfGuardOptions {
   return {
     allowPrivateHosts: process.env.MCP_OAUTH_ALLOW_PRIVATE_HOSTS === "true",

package/src/oauth/wrapper.ts

@@ -29,6 +29,20 @@ export interface OAuthProviderConfig {
    * pre-existing consumer of this wrapper.
    */
   scopeSeparator?: string;
+  /**
+   * How client credentials are sent to the token endpoint.
+   *
+   * - `"body"` (default): `client_id` + `client_secret` as body parameters.
+   * - `"basic"`: HTTP Basic `Authorization` header (RFC 6749 §2.3.1) —
+   *   required by providers like Notion that reject body credentials.
+   */
+  tokenAuthStyle?: "body" | "basic";
+  /**
+   * Token request body encoding. `"form"` (default) sends
+   * `application/x-www-form-urlencoded`; `"json"` sends a JSON body
+   * (Notion requires JSON).
+   */
+  tokenBodyFormat?: "form" | "json";
 }
 
 interface PendingState {
@@ -97,6 +111,30 @@ export async function buildAuthorizationUrl(
  * Validates the state against our pending map, calls the token endpoint,
  * and persists tokens via storeOAuthTokens().
  */
+/**
+ * Build headers + body for a token-endpoint request, honoring the provider's
+ * client-auth style (body params vs HTTP Basic) and body encoding (form vs JSON).
+ */
+function tokenRequestInit(
+  config: OAuthProviderConfig,
+  params: Record<string, string>,
+): { headers: Record<string, string>; body: string } {
+  const useBasic = config.tokenAuthStyle === "basic";
+  const bodyParams = useBasic
+    ? params
+    : { ...params, client_id: config.clientId, client_secret: config.clientSecret };
+  const headers: Record<string, string> = {};
+  if (useBasic) {
+    headers.Authorization = `Basic ${Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64")}`;
+  }
+  if (config.tokenBodyFormat === "json") {
+    headers["Content-Type"] = "application/json";
+    return { headers, body: JSON.stringify(bodyParams) };
+  }
+  headers["Content-Type"] = "application/x-www-form-urlencoded";
+  return { headers, body: new URLSearchParams(bodyParams).toString() };
+}
+
 export async function exchangeCode(
   config: OAuthProviderConfig,
   code: string,
@@ -111,19 +149,14 @@ export async function exchangeCode(
   const { codeVerifier } = pending;
 
   // Build token request manually — Linear doesn't use standard OAuth discovery
-  const body = new URLSearchParams({
-    grant_type: "authorization_code",
-    client_id: config.clientId,
-    client_secret: config.clientSecret,
-    redirect_uri: config.redirectUri,
-    code,
-    code_verifier: codeVerifier,
-  });
-
   const response = await fetch(config.tokenUrl, {
     method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
+    ...tokenRequestInit(config, {
+      grant_type: "authorization_code",
+      redirect_uri: config.redirectUri,
+      code,
+      code_verifier: codeVerifier,
+    }),
   });
 
   if (!response.ok) {
@@ -167,17 +200,12 @@ export async function refreshAccessToken(
   config: OAuthProviderConfig,
   refreshToken: string,
 ): Promise<{ accessToken: string; refreshToken?: string; expiresIn?: number; scope?: string }> {
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    client_id: config.clientId,
-    client_secret: config.clientSecret,
-    refresh_token: refreshToken,
-  });
-
   const response = await fetch(config.tokenUrl, {
     method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
+    ...tokenRequestInit(config, {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+    }),
   });
 
   if (!response.ok) {

package/src/prompts/session-templates.ts

@@ -420,9 +420,9 @@ The 5 script tools (\`script-search\`, \`script-run\`, \`script-upsert\`, \`scri
 - \`agentId\` IS propagated to scripts via the \`X-Agent-ID\` header.
 - \`taskId\` is NOT propagated to scripts — there is no ambient task context. Pass \`taskId\` explicitly via \`args\` if the script needs to call \`ctx.swarm.task_storeProgress\`.
 - Use \`script-query-types\` to inspect the live \`swarm-sdk.d.ts\` before authoring a complex script.
-- Typed API connections: a lead-registered \`script_connections\` entry exposes a typed \`ctx.api.<slug>.<method>(...)\` client in scripts.
-- \`ctx.api\` clients auto-inject the configured credential at egress, so scripts calling an allow-listed external API should prefer \`ctx.api\` over hand-written \`[REDACTED:<KEY>]\` Authorization headers.
-- Registration is lead-only; workers should document the connection spec and hand it to the lead to register.
+- Script connections: lead-registered \`script_connections\` entries expose typed clients in scripts — \`ctx.api.<slug>.<operationId>(...)\` (OpenAPI), \`ctx.api.<slug>.graphql(query, vars)\` (GraphQL), and \`ctx.mcp.<slug>.<toolName>(args)\` (MCP, proxied server-side). Introspect with \`Object.keys(ctx.api ?? {})\` / \`Object.keys(ctx.mcp ?? {})\`.
+- Connection credentials (config secrets or OAuth tokens with auto-refresh) are injected at egress, so scripts calling an external API should prefer a connection over hand-written \`fetch\` + \`[REDACTED:<KEY>]\` headers — and never paste raw secrets.
+- Registration is lead-only (\`script-connections\` + \`credential-bindings\` tools); workers should hand the lead the spec to register: slug, baseUrl or spec URL, allowedHosts, and auth (config key vs OAuth provider).
 `,
   variables: [],
   category: "system",

package/src/providers/codex-models.ts

@@ -1,6 +1,6 @@
 /**
- * Codex API-addressable models, verified from https://developers.openai.com/codex/models
- * and https://developers.openai.com/api/docs/deprecations as of 2026-05-28.
+ * Codex API-addressable models, verified from https://developers.openai.com/api/docs/models
+ * and https://developers.openai.com/api/docs/deprecations as of 2026-07-10.
  *
  * NOTE: `gpt-5.3-codex-spark` is intentionally excluded. It is a ChatGPT Pro
  * research preview and is NOT API-addressable via the Codex SDK at launch.
@@ -10,6 +10,7 @@
  * adapter so the onboarding UI and model selector can import it without
  * pulling in the SDK.
  */
+import modelsDevCache from "../be/modelsdev-cache.json";
 
 /**
  * List of Codex models we know about (drives the onboarding model selector,
@@ -18,17 +19,20 @@
  * SDK, so new OpenAI models work without a code change.
  */
 export const CODEX_MODELS = [
-  "gpt-5.5", // newest frontier coding/professional-work model, 1.05M context
-  "gpt-5.4", // default — mainline reasoning model w/ frontier coding
+  "gpt-5.6-sol", // frontier GPT-5.6 tier for complex reasoning/coding
+  "gpt-5.6-terra", // balanced GPT-5.6 tier
+  "gpt-5.6-luna", // fast/cheap GPT-5.6 tier for high-volume workloads
+  "gpt-5.5", // previous frontier coding/professional-work model
+  "gpt-5.4", // previous mainline reasoning model w/ frontier coding
   "gpt-5.4-mini", // faster/cheaper
-  "gpt-5.3-codex", // coding-specialized, 1M context
+  "gpt-5.3-codex", // coding-specialized legacy model
   "gpt-5.2-codex", // legacy — scheduled for retirement, see openai deprecations page
 ] as const;
 
 export type CodexModel = (typeof CODEX_MODELS)[number];
 
 /** The baseline default when neither MODEL_OVERRIDE nor task.model is set. */
-export const CODEX_DEFAULT_MODEL: CodexModel = "gpt-5.4";
+export const CODEX_DEFAULT_MODEL: CodexModel = "gpt-5.6-terra";
 
 /**
  * Map claude-style shortnames (that flow through MODEL_OVERRIDE / task.model)
@@ -36,10 +40,10 @@ export const CODEX_DEFAULT_MODEL: CodexModel = "gpt-5.4";
  * a task authored for Claude works unchanged when pointed at a Codex worker.
  */
 const CLAUDE_SHORTNAMES: Record<string, CodexModel> = {
-  fable: "gpt-5.5",
-  opus: "gpt-5.4",
-  sonnet: "gpt-5.4",
-  haiku: "gpt-5.4-mini",
+  fable: "gpt-5.6-sol",
+  opus: "gpt-5.6-sol",
+  sonnet: "gpt-5.6-terra",
+  haiku: "gpt-5.6-luna",
 };
 
 /**
@@ -56,22 +60,51 @@ export function resolveCodexModel(modelStr: string | undefined): string {
   return CLAUDE_SHORTNAMES[normalized] ?? normalized;
 }
 
-/**
- * Per-model approximate context window (tokens). The Codex SDK does not
- * expose these at runtime, so we maintain a static map derived from
- * https://developers.openai.com/codex/models. The values are used by the
- * `context_usage` percent calculation inside `CodexSession`.
- *
- * Update this map whenever a model's context window changes.
- */
-export const CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = {
+interface ModelsDevOpenAiModel {
+  limit?: {
+    context?: number;
+  };
+  cost?: {
+    input?: number;
+    cache_read?: number;
+    output?: number;
+  };
+}
+
+const MODELSDEV_OPENAI_MODELS =
+  (
+    modelsDevCache as {
+      openai?: {
+        models?: Record<string, ModelsDevOpenAiModel>;
+      };
+    }
+  ).openai?.models ?? {};
+
+const FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = {
+  "gpt-5.6-sol": 1_050_000,
+  "gpt-5.6-terra": 1_050_000,
+  "gpt-5.6-luna": 1_050_000,
   "gpt-5.5": 1_050_000,
-  "gpt-5.4": 200_000,
-  "gpt-5.4-mini": 200_000,
-  "gpt-5.3-codex": 1_000_000, // 1M context per plan Key Discoveries
+  "gpt-5.4": 1_050_000,
+  "gpt-5.4-mini": 400_000,
+  "gpt-5.3-codex": 400_000,
   "gpt-5.2-codex": 200_000,
 };
 
+/**
+ * Per-model approximate context window (tokens). The Codex SDK does not
+ * expose these at runtime, so we read the vendored models.dev cache used by
+ * the pricing seeder and fall back only for legacy/incomplete cache entries.
+ * The values are used by the `context_usage` percent calculation inside
+ * `CodexSession`.
+ */
+export const CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = Object.fromEntries(
+  CODEX_MODELS.map((model) => [
+    model,
+    MODELSDEV_OPENAI_MODELS[model]?.limit?.context ?? FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS[model],
+  ]),
+) as Record<CodexModel, number>;
+
 /**
  * Return the context window in tokens for a given Codex model. Unknown models
  * (passthrough strings) get the 200k default — keeps `context_usage` finite
@@ -82,15 +115,14 @@ export function getCodexContextWindow(model: string): number {
 }
 
 /**
- * Per-model pricing in USD per million tokens, sourced from
- * https://developers.openai.com/api/docs/pricing on 2026-05-28 (Standard tier,
- * short-context column — long-context multipliers and Batch / Flex / Priority
- * tiers exist but the Codex SDK does not expose which tier was used so we
- * default to the headline rate).
+ * Per-model pricing in USD per million tokens, sourced from the vendored
+ * models.dev cache (`src/be/modelsdev-cache.json`). The fallback below mirrors
+ * that snapshot for known models and covers legacy models that models.dev no
+ * longer lists.
  *
  * The Codex SDK does NOT report dollar cost in `Usage`, so this map is what
- * powers `totalCostUsd` on the `result` event. Update whenever OpenAI changes
- * the pricing page or adds new models.
+ * powers `totalCostUsd` on the `result` event. Refresh models.dev whenever
+ * OpenAI changes pricing or adds new models.
  *
  * `gpt-5.2-codex` is not on the current pricing page (legacy / retired); it
  * inherits the `gpt-5.3-codex` rate as a best-effort fallback so old tasks
@@ -105,7 +137,22 @@ export interface CodexModelPricing {
   outputPerMillion: number;
 }
 
-export const CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = {
+const FALLBACK_CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = {
+  "gpt-5.6-sol": {
+    inputPerMillion: 5.0,
+    cachedInputPerMillion: 0.5,
+    outputPerMillion: 30.0,
+  },
+  "gpt-5.6-terra": {
+    inputPerMillion: 2.5,
+    cachedInputPerMillion: 0.25,
+    outputPerMillion: 15.0,
+  },
+  "gpt-5.6-luna": {
+    inputPerMillion: 1.0,
+    cachedInputPerMillion: 0.1,
+    outputPerMillion: 6.0,
+  },
   "gpt-5.5": {
     inputPerMillion: 5.0,
     cachedInputPerMillion: 0.5,
@@ -134,6 +181,29 @@ export const CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = {
   },
 };
 
+function getModelsDevCodexPricing(model: CodexModel): CodexModelPricing | undefined {
+  const cost = MODELSDEV_OPENAI_MODELS[model]?.cost;
+  if (
+    typeof cost?.input !== "number" ||
+    typeof cost.cache_read !== "number" ||
+    typeof cost.output !== "number"
+  ) {
+    return undefined;
+  }
+  return {
+    inputPerMillion: cost.input,
+    cachedInputPerMillion: cost.cache_read,
+    outputPerMillion: cost.output,
+  };
+}
+
+export const CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = Object.fromEntries(
+  CODEX_MODELS.map((model) => [
+    model,
+    getModelsDevCodexPricing(model) ?? FALLBACK_CODEX_MODEL_PRICING[model],
+  ]),
+) as Record<CodexModel, CodexModelPricing>;
+
 /**
  * Phase 6 — one-warning-per-process tracking so unknown models log once
  * instead of spamming the worker log on every turn.