@bitkyc08/opencodex 2.45.0 → 2.46.0-preview.20260907

package/src/providers/quota.ts

@@ -1552,6 +1552,59 @@ type AccountQuotaCacheEntry = {
   identity?: string;
   isCurrent?: () => boolean;
 };
+/** Expired measurements become unknown; missing reset evidence never implies a fresh allowance. */
+function normalizeAnthropicQuota(quota: ProviderQuota | null | undefined, now: number): ProviderQuota | null {
+  if (!quota) return null;
+  const validReset = (resetAt: unknown): resetAt is number => typeof resetAt === "number"
+    && Number.isFinite(resetAt) && resetAt > 0 && Number.isFinite(new Date(resetAt).getTime());
+  let result = quota;
+  for (const [percent, reset] of [
+    ["fiveHourPercent", "fiveHourResetAt"],
+    ["weeklyPercent", "weeklyResetAt"],
+    ["monthlyPercent", "monthlyResetAt"],
+  ] as const) {
+    const resetAt = quota[reset];
+    if (resetAt === undefined) continue;
+    const valid = validReset(resetAt);
+    if (valid && resetAt > now) continue;
+    if (result === quota) result = { ...quota };
+    if (valid) delete result[percent];
+    delete result[reset];
+  }
+  // Persisted rows validate only the outer quota object, so custom data may be malformed.
+  if (quota.customWindows !== undefined) {
+    const windows = Array.isArray(quota.customWindows) ? quota.customWindows : [];
+    const retained: ProviderQuotaWindow[] = [];
+    let changed = !Array.isArray(quota.customWindows);
+    for (const window of windows) {
+      if (!window || typeof window !== "object" || typeof window.label !== "string" || !window.label.trim()
+        || typeof window.percent !== "number" || !Number.isFinite(window.percent)
+        || window.percent < 0 || window.percent > 100) {
+        changed = true;
+        continue;
+      }
+      if (validReset(window.resetAt) && window.resetAt <= now) {
+        changed = true;
+        continue;
+      }
+      if (window.resetAt !== undefined && !validReset(window.resetAt)) {
+        const normalized = { ...window };
+        delete normalized.resetAt;
+        retained.push(normalized);
+        changed = true;
+      } else {
+        retained.push(window);
+      }
+    }
+    if (changed) {
+      if (result === quota) result = { ...quota };
+      if (retained.length) result.customWindows = retained;
+      else delete result.customWindows;
+    }
+  }
+  return hasQuotaRows(result) ? result : null;
+}
+
 const accountQuotaCache = new Map<string, AccountQuotaCacheEntry>();
 let explicitAccountEpoch = 0;
 
@@ -1568,14 +1621,23 @@ function hydrateAccountQuotaCache(): void {
   if (diskHydrated) return;
   diskHydrated = true;
   for (const [key, quota] of readPersistedAccountQuotas()) {
-    if (!accountQuotaCache.has(key)) accountQuotaCache.set(key, { ts: quota.updatedAt, quota });
+    // Disk stores observation time, not the Anthropic usage probe's clock.
+    if (!accountQuotaCache.has(key)) {
+      const anthropic = key.startsWith("anthropic\u0000");
+      accountQuotaCache.set(key, {
+        ts: anthropic ? 0 : quota.updatedAt,
+        quota: anthropic ? normalizeAnthropicQuota(quota, Date.now()) : quota,
+      });
+    }
   }
 }
 
 function persistAccountQuotaCache(): void {
   schedulePersistAccountQuotas(function* () {
+    const now = Date.now();
     for (const [key, entry] of accountQuotaCache) {
-      if (entry.quota) yield [key, entry.quota] as [string, ProviderQuota];
+      const quota = key.startsWith("anthropic\u0000") ? normalizeAnthropicQuota(entry.quota, now) : entry.quota;
+      if (quota) yield [key, quota] as [string, ProviderQuota];
     }
   });
 }
@@ -1625,7 +1687,7 @@ function accountCacheKey(provider: string, accountId: string): string {
 export function getCachedProviderAccountQuota(provider: string, accountId: string): ProviderQuota | null {
   const entry = accountQuotaCache.get(accountCacheKey(provider, accountId));
   if (entry?.isCurrent && !entry.isCurrent()) return null;
-  return entry?.quota ?? null;
+  return provider === "anthropic" ? normalizeAnthropicQuota(entry?.quota, Date.now()) : entry?.quota ?? null;
 }
 
 /** Test-only: seed or clear the per-account quota cache without probing upstream. */
@@ -1642,6 +1704,68 @@ export function setCachedProviderAccountQuotaForTests(
   accountQuotaCache.set(key, { ts: Date.now(), quota });
 }
 
+/** Unified headers report utilization fractions and epoch-second reset times. */
+function anthropicHeaderResetAt(value: string | null): number | undefined {
+  const seconds = toFiniteNumber(value);
+  if (seconds === undefined || seconds <= 0) return undefined;
+  const timestamp = seconds * 1000;
+  return Number.isFinite(new Date(timestamp).getTime()) ? timestamp : undefined;
+}
+
+export function parseAnthropicRateLimitHeaders(headers: Headers): ProviderQuota | null {
+  const fiveHourPercent = normalizeUtilizationFraction(headers.get("anthropic-ratelimit-unified-5h-utilization"));
+  const weeklyPercent = normalizeUtilizationFraction(headers.get("anthropic-ratelimit-unified-7d-utilization"));
+  if (fiveHourPercent === undefined && weeklyPercent === undefined) return null;
+  const fiveHourResetAt = anthropicHeaderResetAt(headers.get("anthropic-ratelimit-unified-5h-reset"));
+  const weeklyResetAt = anthropicHeaderResetAt(headers.get("anthropic-ratelimit-unified-7d-reset"));
+  return {
+    ...(fiveHourPercent !== undefined ? { fiveHourPercent } : {}),
+    ...(fiveHourPercent !== undefined && fiveHourResetAt !== undefined ? { fiveHourResetAt } : {}),
+    ...(weeklyPercent !== undefined ? { weeklyPercent } : {}),
+    ...(weeklyPercent !== undefined && weeklyResetAt !== undefined ? { weeklyResetAt } : {}),
+    updatedAt: Date.now(),
+  };
+}
+
+/** Reject unknown scales; round fraction conversion for persisted/displayed percentages. */
+function normalizeUtilizationFraction(value: string | null): number | undefined {
+  const numeric = toFiniteNumber(value);
+  if (numeric === undefined || numeric < 0 || numeric > 1) return undefined;
+  return Math.round(numeric * 10_000) / 100;
+}
+
+/**
+ * Merge serving-account observations without advancing the usage probe's clock or
+ * erasing model-specific windows. The caller owns credential attribution; this guard
+ * prevents a retired account key from being revived by an older config generation.
+ */
+export function recordAnthropicAccountQuotaFromHeaders(
+  accountId: string,
+  headers: Headers,
+  writerGeneration: number,
+): void {
+  if (!accountId) return;
+  const observed = parseAnthropicRateLimitHeaders(headers);
+  if (!observed) return;
+  const key = accountCacheKey("anthropic", accountId);
+  if (!mayCommitAccountQuotaKey(key, writerGeneration)) return;
+  // Hydrate before writing, for the same reason `recordPassiveAccountQuota` does: this write
+  // arrives unprompted from the request path, and `persistAccountQuotaCache` serializes the
+  // whole map. Landing before any reader has hydrated would persist this single row and erase
+  // every other provider's saved row.
+  hydrateAccountQuotaCache();
+  const previous = accountQuotaCache.get(key);
+  accountQuotaCache.set(key, {
+    ...previous,
+    // Headers do not prove that the last usage probe succeeded.
+    ts: previous?.ts ?? 0,
+    quota: normalizeAnthropicQuota({
+      ...normalizeAnthropicQuota(previous?.quota, observed.updatedAt), ...observed,
+    }, observed.updatedAt),
+  });
+  persistAccountQuotaCache();
+}
+
 /**
  * Providers whose per-account quota is OBSERVED in-band, never probed.
  *
@@ -1714,7 +1838,11 @@ export function readPassiveProviderAccountQuotas(provider: string): ProviderAcco
 export function sweepExpiredProviderAccountQuotaRows(now = Date.now()): number {
   let removed = 0;
   for (const [key, entry] of accountQuotaCache) {
-    if (entry.ts + ACCOUNT_QUOTA_TTL_MS > now) continue;
+    // Anthropic observations extend retention, never the usage probe's eligibility clock.
+    const retainedAt = key.startsWith("anthropic\u0000")
+      ? Math.max(entry.ts, entry.quota?.updatedAt ?? 0)
+      : entry.ts;
+    if (retainedAt + ACCOUNT_QUOTA_TTL_MS > now) continue;
     accountQuotaCache.delete(key);
     removed += 1;
   }
@@ -1907,10 +2035,13 @@ async function fetchAccountQuota(
 ): Promise<AccountQuotaCacheEntry> {
   if (!supportsPerAccountQuota(provider)) return { ts: Date.now(), quota: null, unavailable: true };
   if (explicitAccountReader(provider)) return fetchExplicitAccountQuota(provider, accountId, forceRefresh, providerConfig);
+  if (provider === "anthropic") hydrateAccountQuotaCache();
   const key = accountCacheKey(provider, accountId);
   const writerGeneration = captureConfigGeneration();
   const cached = accountQuotaCache.get(key);
-  if (!forceRefresh && cached && Date.now() - cached.ts < ACCOUNT_QUOTA_TTL_MS) return cached;
+  if (!forceRefresh && cached && Date.now() - cached.ts < ACCOUNT_QUOTA_TTL_MS) {
+    return provider === "anthropic" ? { ...cached, quota: normalizeAnthropicQuota(cached.quota, Date.now()) } : cached;
+  }
   const joinable = accountQuotaInflight.get(key);
   if (joinable) return joinable;
 
@@ -1947,7 +2078,9 @@ async function fetchAccountQuota(
         // negative-cache instead of re-probing on every GUI poll.
         const entry: AccountQuotaCacheEntry = {
           ts: Date.now(),
-          quota: cached?.quota ?? null,
+          // Settle once for all joiners against observations committed during the probe.
+          quota: provider === "anthropic"
+            ? normalizeAnthropicQuota(accountQuotaCache.get(key)?.quota, Date.now()) : cached?.quota ?? null,
           unavailable: true,
         };
         if (mayCommitAccountQuotaKey(key, writerGeneration)) {
@@ -1957,7 +2090,9 @@ async function fetchAccountQuota(
         }
         return entry;
       }
-      const entry: AccountQuotaCacheEntry = { ts: Date.now(), quota };
+      const entry: AccountQuotaCacheEntry = {
+        ts: Date.now(), quota: provider === "anthropic" ? normalizeAnthropicQuota(quota, Date.now()) : quota,
+      };
       if (mayCommitAccountQuotaKey(key, writerGeneration)) {
         accountQuotaCache.set(key, entry);
         // Exhaustion state rides the SAME commit guard as the quota row: a probe from a
@@ -1969,7 +2104,8 @@ async function fetchAccountQuota(
     } catch {
       const entry: AccountQuotaCacheEntry = {
         ts: Date.now(),
-        quota: cached?.quota ?? null,
+        quota: provider === "anthropic"
+          ? normalizeAnthropicQuota(accountQuotaCache.get(key)?.quota, Date.now()) : cached?.quota ?? null,
         unavailable: true,
       };
       if (mayCommitAccountQuotaKey(key, writerGeneration)) {
@@ -2001,7 +2137,7 @@ export async function fetchProviderAccountQuotas(
     const entry = await fetchAccountQuota(provider, account.id, forceRefresh, providerConfig);
     const result: ProviderAccountQuota = {
       accountId: account.id,
-      quota: entry.quota,
+      quota: provider === "anthropic" ? normalizeAnthropicQuota(entry.quota, Date.now()) : entry.quota,
       ...(entry.unavailable ? { unavailable: true as const } : {}),
     };
     if (!explicitAccountReader(provider)) return result;

package/src/providers/registry.ts

@@ -2544,6 +2544,37 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     // yields an empty picker at runtime.
     note: "Domestic BigModel Coding Plan endpoint (open.bigmodel.cn)",
   },
+  // Narrowed carry of #3641: the official Codex example declares a local static catalog,
+  // not an HTTP /models contract. Keep Responses separate from the Chat endpoint above.
+  // Source: https://docs.bigmodel.cn/cn/coding-plan/tool/codex.md (checked 2026-09-07).
+  {
+    id: "zhipu-bigmodel-responses",
+    label: "Zhipu AI — BigModel Coding Plan (Responses)",
+    baseUrl: "https://open.bigmodel.cn/api/v1",
+    adapter: "openai-responses",
+    authKind: "key",
+    dashboardUrl: "https://bigmodel.cn/console/usercenter/apikeys",
+    defaultModel: "glm-5.3",
+    models: ["glm-5.3", "glm-5-turbo"],
+    liveModels: false,
+    // The local Codex catalog does not establish an authenticated HTTP /models contract.
+    apiKeyValidation: "unknown",
+    jawcodeBundle: "zai",
+    // A pre-existing same-named custom provider must retain its destination and key boundary.
+    preserveCustomDestination: true,
+    modelContextWindows: { "glm-5.3": 1_048_576, "glm-5-turbo": 204_800 },
+    modelInputModalities: { "glm-5.3": ["text"], "glm-5-turbo": ["text"] },
+    modelReasoningEfforts: {
+      "glm-5.3": ZAI_GLM_53_REASONING_EFFORTS,
+      // Explicitly empty: Turbo must not inherit the generic selectable effort ladder.
+      "glm-5-turbo": [],
+    },
+    modelDefaultReasoningEfforts: { "glm-5.3": "max", "glm-5-turbo": "max" },
+    modelSupportsReasoningSummaries: { "glm-5.3": true, "glm-5-turbo": true },
+    // Responses replay uses this provider-level flag, not the Chat-path model list.
+    preserveResponsesReasoningContent: true,
+    note: "Domestic BigModel Coding Plan Responses endpoint; static model roster",
+  },
   { id: "nanogpt", label: "NanoGPT", baseUrl: "https://nano-gpt.com/api/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://nano-gpt.com/api" },
   { id: "synthetic", label: "Synthetic", baseUrl: "https://api.synthetic.new/openai/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://synthetic.new" },
   // SiliconFlow publishes an OpenAI-compatible chat endpoint and a dynamic model catalog. Do not

package/src/responses/parser.ts

@@ -126,6 +126,12 @@ export function parseRequest(
     }
     return holder;
   };
+  const preservePendingReplay = () => {
+    const replay = pendingReasoning.filter(entry => entry.envelopeSigned || entry.part.redacted?.length);
+    if (replay.length > 0) {
+      ensureAssistantPlaceholder(messages, data.model, now).content.push(...replay.map(entry => entry.part));
+    }
+  };
   // Tool specs surfaced by a prior tool_search (deferred tools, e.g. subagents). Codex does not
   // re-list these in `tools`, but chat models can only call listed tools — so we re-inject them.
   const loadedToolSpecs: unknown[] = [];
@@ -148,6 +154,12 @@ export function parseRequest(
       const effectiveType = (item as { type?: string }).type ?? ("role" in item ? "message" : undefined);
       const itemRole = (item as { role?: string }).role;
       const externalTaskInput = effectiveType === "function_call_output" ? externalTaskInputContent(item) : undefined;
+      // A signed/opaque assistant-only turn still owns its replay blocks, even
+      // without a following assistant text or tool call to drain the pending list.
+      if (effectiveType === "agent_message" || externalTaskInput !== undefined
+        || (effectiveType === "message" && ["user", "developer", "system"].includes(itemRole ?? ""))) {
+        preservePendingReplay();
+      }
       // Raw protocol items do not map one-to-one onto context messages. Capture the boundary while
       // both representations are available so later metadata can stay before conversation in both.
       if (
@@ -269,7 +281,7 @@ export function parseRequest(
         const envelope = typeof reasoning.encrypted_content === "string"
           ? decodeReasoningEnvelope(reasoning.encrypted_content)
           : null;
-        const thinkingText = envelope?.txt || text;
+        const thinkingText = envelope?.txt ?? text;
 
         // Kiro reasoning round-trip: a krc-only item carries nothing renderable — it is provider
         // state for the assistant turn that ALREADY closed, because Kiro emits its
@@ -285,7 +297,7 @@ export function parseRequest(
 
         // Native/non-ocxr1 encrypted-only reasoning is opaque here. Do not create a detached
         // assistant turn or invent replayable plaintext/signatures from the encrypted payload.
-        if (thinkingText.length > 0) {
+        if (thinkingText.length > 0 || envelope?.sig || envelope?.red?.length) {
           const part: OcxThinkingContent = {
             type: "thinking",
             thinking: thinkingText,
@@ -296,7 +308,7 @@ export function parseRequest(
           const envelopeSigned = typeof envelope?.sig === "string";
           const previous = pendingReasoning[pendingReasoning.length - 1];
 
-          if (!envelopeSigned && previous && !previous.envelopeSigned) {
+          if (!envelopeSigned && !part.redacted && previous && !previous.envelopeSigned && !previous.part.redacted) {
             previous.part = {
               ...part,
               thinking: `${previous.part.thinking}\n${part.thinking}`,
@@ -466,6 +478,7 @@ export function parseRequest(
       }
     }
   }
+  preservePendingReplay();
   if (data.previous_response_id && continuationConversationMessageIndex === undefined) {
     continuationConversationMessageIndex = messages.length;
   }

package/src/responses/reasoning-envelope.ts

@@ -50,10 +50,11 @@ export function decodeReasoningEnvelope(encryptedContent: string): ReasoningEnve
       if (red.length > 0) envelope.red = red;
     }
     const txt = (parsed as { txt?: unknown }).txt;
-    if (typeof txt === "string" && txt.length > 0) envelope.txt = txt;
+    const hasTxt = typeof txt === "string";
+    if (hasTxt) envelope.txt = txt;
     const krc = (parsed as { krc?: unknown }).krc;
     if (typeof krc === "string" && krc.length > 0) envelope.krc = krc;
-    return envelope.sig || envelope.red || envelope.txt || envelope.krc ? envelope : null;
+    return envelope.sig || envelope.red || hasTxt || envelope.krc ? envelope : null;
   } catch {
     return null;
   }

package/src/server/grok-responses-control-frame.ts

@@ -0,0 +1,43 @@
+import { sseDataPayload, type SseBlockRewrite } from "./sse-payload-rewrite";
+
+const GROK_CONTROL_FRAME_TYPES: Record<string, true> = {
+  "codex.rate_limits": true,
+  "codex.response.metadata": true,
+};
+
+/**
+ * Hide Codex-only control frames from Grok's strict Responses decoder.
+ *
+ * The inspection branch still sees these frames before this client-facing
+ * rewrite, so quota accounting and response metadata remain available to the
+ * proxy while Grok receives only its declared Responses event variants.
+ */
+export function createGrokResponsesControlFrameBlockRewrite(): SseBlockRewrite {
+  return (block) => {
+    let eventName = "";
+    // SSE overwrites the event type on every event field, including empty resets.
+    // Like sseDataPayload, remove only one optional ASCII space after the colon.
+    for (const line of block.split(/\r?\n/)) {
+      if (line === "event") eventName = "";
+      else if (line.startsWith("event:")) {
+        const value = line.slice("event:".length);
+        eventName = value.startsWith(" ") ? value.slice(1) : value;
+      }
+    }
+    if (GROK_CONTROL_FRAME_TYPES[eventName] === true) return [];
+
+    const payload = sseDataPayload(block);
+    if (payload === null || payload === "[DONE]") return [block];
+
+    let event: unknown;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      return [block];
+    }
+    if (!event || typeof event !== "object" || Array.isArray(event) || !("type" in event)) return [block];
+    return typeof event.type === "string" && GROK_CONTROL_FRAME_TYPES[event.type] === true
+      ? []
+      : [block];
+  };
+}

package/src/server/management/config-routes.ts

@@ -161,7 +161,7 @@ interface ClientIntegrationSyncOutcome {
 }
 
 /**
- * Re-inject native clients that are switched ON and file integrations whose
+ * Re-inject native clients that are switched ON and every file integration whose
  * OpenCodex ownership record is the operator's durable opt-in.
  *
  * Only Codex used to run here, so a catalog change reached Codex and nothing else: a Grok
@@ -169,6 +169,10 @@ interface ClientIntegrationSyncOutcome {
  * next `ocx start`. The startup path already gates each client on its own toggle
  * (`src/cli/index.ts`), and this is that same fan-out for the on-demand command.
  *
+ * File integrations use the catalog-refresh coordinator so owned blocks are
+ * updated without claiming unowned files. Aside remains on its multi-profile
+ * server-owned path inside that coordinator.
+ *
  * A client that is OFF or never connected is omitted from the result rather than reported as skipped — the
  * caller has to be able to tell "not touched" from "tried and failed". A client that fails
  * does not fail the sync: Codex is the one that matters for routing, and a broken Grok file
@@ -233,7 +237,7 @@ export async function syncEnabledClientIntegrations(
     },
     config,
     port,
-  }, ["mcode", "pi", "aside"]));
+  }, ["mcode", "pi", "aside", "raycast"]));
 
   return out;
 }

package/src/server/management/integration-routes.ts

@@ -22,6 +22,7 @@ import {
   isIntegrationClientId,
   type IntegrationClientId,
 } from "../../integrations/registry";
+import { detectRaycast, type RaycastInstall } from "../../integrations/raycast-detect";
 import { readIntegrationState } from "../../integrations/state";
 import { createIntegrationStateStore, type IntegrationStateStore } from "../../integrations/store";
 import {
@@ -58,6 +59,13 @@ type RestoreResult = Awaited<ReturnType<typeof restoreIntegrationCoordinated>>;
 
 export type IntegrationStateEnvelope = {
   clientId: IntegrationClientId;
+  /**
+   * Raycast only, and only on the single-client read. Custom Providers is a
+   * Pro feature, so a file that is `current` can still be one Raycast ignores;
+   * this is the fact that lets status and the GUI say so. It is not part of
+   * the shared `IntegrationStatus`, which describes the file, not the app.
+   */
+  raycast?: RaycastInstall;
 } & IntegrationStateRecord;
 
 export interface IntegrationStateListEnvelope {
@@ -141,6 +149,17 @@ export function setIntegrationPathTestHooks(hooks: { env?: NodeJS.ProcessEnv; ho
   integrationPathTestHooks = hooks;
 }
 
+/**
+ * Raycast detection override for tests. The real detector spawns `defaults` and
+ * reads the developer's own subscription state, which is exactly the kind of
+ * host fact a route test must not depend on.
+ */
+let raycastDetectTestHook: (() => RaycastInstall) | null = null;
+
+export function setRaycastDetectTestHook(hook: (() => RaycastInstall) | null): void {
+  raycastDetectTestHook = hook;
+}
+
 /** The `env`/`home` overrides, spread into every registry-resolving call. */
 function pathOverrides(): { env?: NodeJS.ProcessEnv; home?: string } {
   return {
@@ -177,7 +196,10 @@ export function setIntegrationMutationFlightTestHooks(
   setIntegrationMutationFlightTestHook(hooks?.run ?? null);
   // Path overrides are part of the same isolation contract: clearing flights
   // while leaving a temp home bound would let the next suite write real files.
-  if (hooks === null) integrationPathTestHooks = null;
+  if (hooks === null) {
+    integrationPathTestHooks = null;
+    raycastDetectTestHook = null;
+  }
 }
 
 /**
@@ -633,7 +655,12 @@ export async function handleIntegrationRoutes(ctx: ManagementContext): Promise<R
     try {
       const input = await buildIntegrationWriteInput(requestedClient, ctx, integrationStore());
       const state = readIntegrationState(input);
-      return jsonResponse(state satisfies IntegrationStateEnvelope, 200, req, ctx.config);
+      // Detection runs only for the client that needs it: `defaults` is a
+      // process spawn, and no other client's read should pay for it.
+      const envelope: IntegrationStateEnvelope = requestedClient === "raycast"
+        ? { ...state, raycast: (raycastDetectTestHook ?? detectRaycast)() }
+        : state;
+      return jsonResponse(envelope, 200, req, ctx.config);
     } catch (error) {
       return internalErrorResponse(error, ctx);
     }

package/src/server/management/model-routes.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
+import { shouldInjectApiAuthHeader } from "../../codex/loopback-target";
 
 /**
  * Codex parses a catalog entry's `input_modalities` as a closed enum, and one out-of-enum
@@ -480,6 +481,13 @@ export async function handleModelRoutes(ctx: ManagementContext): Promise<Respons
       if (!(error instanceof ClientPathError)) throw error;
       return jsonResponse({ error: error.message }, 400, req, config);
     }
+    if (requested === "raycast" && shouldInjectApiAuthHeader(config)) {
+      return jsonResponse({
+        error: "Raycast export requires an unauthenticated loopback destination; this listener requires an admission header Raycast cannot supply.",
+        reason: "non_loopback",
+      }, 400, req, config);
+    }
+    const baseUrl = opencodeProxyBaseUrl(Number(url.port) || config.port, config.hostname, config);
     let models: ExportModel[];
     try {
       // The ONE loader every export surface uses. It carries the visibility
@@ -499,7 +507,7 @@ export async function handleModelRoutes(ctx: ManagementContext): Promise<Respons
       );
     }
     const built = buildClientConfigText(requested, {
-      baseUrl: opencodeProxyBaseUrl(Number(url.port) || config.port, config.hostname),
+      baseUrl,
       models,
       config,
     });

package/src/server/request-decompress.ts

@@ -27,14 +27,39 @@ export class UnsupportedContentEncodingError extends Error {
   }
 }
 
+export type BodySizeMeasurement =
+  | "declared_wire"
+  | "observed_wire_lower_bound"
+  | "decoded_exact"
+  | "decoded_lower_bound";
+
 export class DecompressedBodyTooLargeError extends Error {
-  constructor(readonly bytes: number, limit: number = MAX_DECOMPRESSED_BODY_BYTES) {
-    super(`Decompressed request body exceeds ${limit} bytes`);
+  readonly measurement: BodySizeMeasurement | null;
+
+  constructor(
+    readonly bytes: number,
+    readonly limit: number = MAX_DECOMPRESSED_BODY_BYTES,
+    measurement: BodySizeMeasurement | null = null,
+  ) {
+    // Legacy callers supply no provenance. Only fixed categories and finite
+    // numbers may reach the public message, including calls from untyped code.
+    const category = measurement === "declared_wire" || measurement === "observed_wire_lower_bound"
+      || measurement === "decoded_exact" || measurement === "decoded_lower_bound"
+      ? measurement : null;
+    const suffix = category !== null && Number.isFinite(bytes) && bytes >= 0
+      && Number.isFinite(limit) && limit >= 0
+      ? ` [measurement=${category}; bytes=${bytes}]` : "";
+    super(`Decompressed request body exceeds ${Number.isFinite(limit) ? limit : "unknown"} bytes${suffix}`);
+    this.measurement = category;
   }
 }
 
-function assertBodySizeWithinLimit(body: Uint8Array, maxBytes: number): Uint8Array {
-  if (body.byteLength > maxBytes) throw new DecompressedBodyTooLargeError(body.byteLength, maxBytes);
+function assertBodySizeWithinLimit(
+  body: Uint8Array,
+  maxBytes: number,
+  measurement: BodySizeMeasurement = "decoded_exact",
+): Uint8Array {
+  if (body.byteLength > maxBytes) throw new DecompressedBodyTooLargeError(body.byteLength, maxBytes, measurement);
   return body;
 }
 
@@ -112,7 +137,7 @@ async function readRequestBodyBytesCapped(
       if (!value || value.byteLength === 0) continue;
 
       if (value.byteLength > maxBytes - retainedBytes) {
-        const error = new DecompressedBodyTooLargeError(retainedBytes + value.byteLength, maxBytes);
+        const error = new DecompressedBodyTooLargeError(retainedBytes + value.byteLength, maxBytes, "observed_wire_lower_bound");
         cancel(error);
         throw error;
       }
@@ -173,7 +198,8 @@ export function decodeRequestBody(
     else throw new UnsupportedContentEncodingError(encoding);
   } catch (err) {
     if ((err as NodeJS.ErrnoException | null)?.code === "ERR_BUFFER_TOO_LARGE") {
-      throw new DecompressedBodyTooLargeError(maxBytes + 1, maxBytes);
+      // Inflation stopped at the cap; the full decoded size was never measured.
+      throw new DecompressedBodyTooLargeError(maxBytes + 1, maxBytes, "decoded_lower_bound");
     }
     throw err;
   }
@@ -198,7 +224,7 @@ export async function readBoundedJsonRequestBody(
   // Reject an honest oversized declaration before reading. Missing, malformed,
   // and dishonest declarations remain bounded by the streaming reader below.
   if (declaredLength !== null && declaredLength > maxBytes) {
-    const error = new DecompressedBodyTooLargeError(declaredLength, maxBytes);
+    const error = new DecompressedBodyTooLargeError(declaredLength, maxBytes, "declared_wire");
     cancelStreamWithoutWaiting(req.body, error);
     throw error;
   }
@@ -211,7 +237,7 @@ export async function readBoundedJsonRequestBody(
   } finally {
     releaseReservation?.();
   }
-  assertBodySizeWithinLimit(raw, maxBytes);
+  assertBodySizeWithinLimit(raw, maxBytes, "observed_wire_lower_bound");
   const releaseRaw = budget?.observeAcceptedRequestCopy(raw.byteLength);
   let releaseDecoded: (() => void) | undefined;
   let releaseText: (() => void) | undefined;