mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/mcp/child-tree.mjs

@@ -35,52 +35,124 @@ function transportPid(transport) {
   return (typeof transport?.pid === 'number' ? transport.pid : null) ?? transport?._process?.pid ?? null;
 }
 
+/** Deadline of one process-table enumeration subprocess. A healthy CIM query
+ *  takes ~1-3 s but exceeds 8 s under heavy load, and a timed-out strict read
+ *  leaves the finished command's workspace held, so the deadline only cuts
+ *  off a query that is genuinely stuck. A query that has not answered by then
+ *  is killed and its snapshot rejected (strict) or empty (best-effort). A
+ *  termination watch schedules its next pass only after the previous read
+ *  settled, so enumerators never pile up whatever this value is. */
+export const ENUMERATION_DEADLINE_MS = 20_000;
+
 // Spawn a helper command and resolve its stdout (empty string on any error).
-function run(cmd, args) {
-  return new Promise((resolve) => {
+// `timeoutMs` > 0: past the deadline the helper is killed (Node reaps it on
+// exit) and the call settles at once instead of waiting for it.
+function run(cmd, args, { strict = false, timeoutMs = 0 } = {}) {
+  return new Promise((resolve, reject) => {
     let out = '';
     let cp;
+    let timer = null;
+    let settled = false;
+    const settle = (finish) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      finish();
+    };
     try {
       cp = spawn(cmd, args, { windowsHide: true });
-    } catch {
+    } catch (error) {
+      if (strict) {
+        reject(error);
+        return;
+      }
       resolve('');
       return;
     }
     cp.stdout?.on('data', (d) => {
       out += String(d);
     });
-    cp.on('error', () => resolve(out));
-    cp.on('close', () => resolve(out));
+    cp.on('error', (error) => settle(() => (strict ? reject(error) : resolve(out))));
+    cp.on('close', (code) =>
+      settle(() => (strict && code !== 0 ? reject(new Error(`Process enumeration failed (${code}).`)) : resolve(out)))
+    );
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => {
+        try {
+          cp.kill('SIGKILL');
+        } catch {
+          /* already gone */
+        }
+        cp.stdout?.destroy?.();
+        cp.stderr?.destroy?.();
+        settle(() =>
+          strict ? reject(new Error(`Process enumeration timed out after ${timeoutMs} ms.`)) : resolve('')
+        );
+      }, timeoutMs);
+      timer.unref?.();
+    }
   });
 }
 
 // Snapshot the whole process table once: parent map + a per-pid identity
 // token (Windows CreationDate, POSIX lstart) so a later kill can prove a pid
 // number was not recycled onto a different process before signalling it.
-async function enumerate() {
+// POSIX rows also carry the process group id (Windows has none).
+async function enumerate({ strict = false } = {}) {
   const childrenOf = new Map();
   const tokenOf = new Map();
   const nameOf = new Map();
+  const pgidOf = new Map();
   const out = isWin
-    ? await run('powershell.exe', [
-        '-NoProfile',
-        '-NonInteractive',
-        '-Command',
-        `Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.Name) $($_.CreationDate.ToString('o'))" }`,
-      ])
-    : await run('ps', ['-A', '-o', 'pid=,ppid=,comm=,lstart=']);
+    ? await run(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          `${strict ? "$ErrorActionPreference = 'Stop'; " : ''}Get-CimInstance Win32_Process | ForEach-Object { $created = if ($_.CreationDate) { $_.CreationDate.ToString('o') } else { '' }; "$($_.ProcessId) $($_.ParentProcessId) $($_.Name) $created" }`,
+        ],
+        { strict, timeoutMs: ENUMERATION_DEADLINE_MS }
+      )
+    : await run('ps', ['-A', '-o', 'pid=,ppid=,pgid=,comm=,lstart='], {
+        strict,
+        timeoutMs: ENUMERATION_DEADLINE_MS,
+      });
+  const row = isWin ? /^(\d+)\s+(\d+)\s+()(\S+)(?:\s+(.+))?$/ : /^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)(?:\s+(.+))?$/;
   for (const line of out.split(/\r?\n/)) {
-    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)(?:\s+(.+))?$/);
+    const m = line.trim().match(row);
     if (!m) continue;
     const pid = Number(m[1]);
     const ppid = Number(m[2]);
-    const token = (m[4] || '').trim() || null;
+    const token = (m[5] || '').trim() || null;
     if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
     childrenOf.get(ppid).push(pid);
     tokenOf.set(pid, token);
-    nameOf.set(pid, m[3]);
+    nameOf.set(pid, m[4]);
+    if (m[3]) pgidOf.set(pid, Number(m[3]));
+  }
+  if (strict && !nameOf.has(process.pid)) throw new Error('The process snapshot could not be verified.');
+  return { childrenOf, tokenOf, nameOf, pgidOf };
+}
+
+/** One strict process-table snapshot: parent links, identity tokens, image
+ *  names and (POSIX) process groups. Rejects instead of returning a partial
+ *  table, so callers can tell "nothing found" from "could not look".
+ *
+ *  `shared: true` (pre-kill captures) joins a read already in flight, so many
+ *  jobs promoted together do not each spawn an enumerator; a capture taken
+ *  while its root runs is valid whenever that read began. An observation after
+ *  a kill never shares: a read that began before the kill would report the
+ *  killed tree alive and defer the confirmation by a whole re-check. */
+let tableInFlight = null;
+export function readProcessTable({ shared = false } = {}) {
+  if (!shared) return enumerate({ strict: true });
+  if (!tableInFlight) {
+    tableInFlight = enumerate({ strict: true }).finally(() => {
+      tableInFlight = null;
+    });
   }
-  return { childrenOf, tokenOf, nameOf };
+  return tableInFlight;
 }
 
 // Walk every descendant pid of rootPid (excludes rootPid).
@@ -106,12 +178,18 @@ async function collectDescendants(rootPid) {
   return descendantsOf(childrenOf, rootPid);
 }
 
-/** Descendant pids WITH their image names, from one batched process-table
- *  read. Shared with the shell runner's post-exit descendant observation so
- *  both use a single enumeration implementation. */
-export async function collectDescendantProcesses(rootPid) {
-  const { childrenOf, nameOf } = await enumerate().catch(() => ({ childrenOf: new Map(), nameOf: new Map() }));
-  return descendantsOf(childrenOf, rootPid).map((pid) => ({ pid, name: nameOf.get(pid) || '' }));
+/** Descendant pids WITH their image names and identity tokens (creation
+ *  time), from one batched process-table read. */
+export async function collectDescendantProcesses(rootPid, { strict = false } = {}) {
+  const snapshot = enumerate({ strict });
+  const { childrenOf, nameOf, tokenOf } = strict
+    ? await snapshot
+    : await snapshot.catch(() => ({ childrenOf: new Map(), nameOf: new Map(), tokenOf: new Map() }));
+  return descendantsOf(childrenOf, rootPid).map((pid) => ({
+    pid,
+    name: nameOf.get(pid) || '',
+    token: tokenOf.get(pid) ?? null,
+  }));
 }
 
 /** Force-kill whole process trees by pid. Windows batches one taskkill /T /F

package/src/runtime/agent/orchestrator/providers/account-pool.mjs

@@ -165,6 +165,8 @@ function boundAccountSend(providerName, row, messages, options) {
     };
   }
   if (options.sessionId) {
+    // An explicit empty executor (model-proxy host) must stay empty.
+    opts.toolExecutionSessionId = options.toolExecutionSessionId ?? options.sessionId;
     opts.sessionId = accountScopedSessionId(providerName, row.id, options.sessionId);
     // The spend still belongs to the visible session (usage-accounting.mjs).
     opts.usageSessionId = options.usageSessionId || options.sessionId;

package/src/runtime/agent/orchestrator/providers/anthropic-api-key-fetch.mjs

@@ -0,0 +1,36 @@
+// Custom `fetch` for the Anthropic SDK client (API-key path): gzips
+// /v1/messages bodies on the libuv threadpool, but ONLY when the effective
+// request origin is exactly https://api.anthropic.com. The decision is made on
+// the final request URL, so a custom baseURL, ANTHROPIC_BASE_URL, proxy or
+// gateway never gets a compressed body. Policy shared with the OAuth path.
+import { sendGzipCompressed } from './lib/request-compression.mjs';
+
+const OFFICIAL_ORIGIN = 'https://api.anthropic.com';
+
+function officialMessagesUrl(input) {
+  try {
+    const url = new URL(typeof input === 'string' || input instanceof URL ? input : input.url);
+    return url.origin === OFFICIAL_ORIGIN && url.pathname === '/v1/messages';
+  } catch {
+    return false;
+  }
+}
+
+function bodyBytes(body) {
+  if (typeof body === 'string') return Buffer.from(body);
+  if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  return null;
+}
+
+export function createAnthropicApiKeyFetch({ baseFetch = (...args) => globalThis.fetch(...args), compress } = {}) {
+  return async (input, init) => {
+    const raw = init?.method?.toUpperCase() === 'POST' && officialMessagesUrl(input) ? bodyBytes(init.body) : null;
+    if (!raw) return baseFetch(input, init);
+    return sendGzipCompressed({
+      raw,
+      headers: init.headers,
+      compress,
+      send: (body, headers) => baseFetch(input, { ...init, headers, body: body === raw ? init.body : body }),
+    });
+  };
+}

package/src/runtime/agent/orchestrator/providers/anthropic-api-request.mjs

@@ -16,10 +16,12 @@ import { fastModeAvailable } from './anthropic-fast-mode.mjs';
 import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic-effort.mjs';
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 import {
+  anthropicThinkingActive,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   resolveAnthropicCacheTtls as resolveCacheTtls,
   resolveAnthropicMessageCacheSlots,
+  sharedCachePrefixBoundary,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
 import {
@@ -54,17 +56,21 @@ export async function buildAnthropicApiRequest({
   opts,
   fastModeLatched,
   modelInfo = null,
+  // The Claude id a gateway slug stands for (OpenRouter `anthropic/claude-opus-4.8`
+  // → `claude-opus-4.8`): the output cap and the thinking/effort shape are read
+  // from it, while the wire still names `useModel`.
+  capabilityModel = useModel,
+  // A gateway-supplied output limit for the model; wins over the Anthropic catalog.
+  modelMaxOutputTokens = opts?.modelMaxOutputTokens ?? null,
 }) {
   // A user-defined provider's reasoning comes from its own model row only:
   // the global by-model-id capability index and the Claude-id ladders are
   // first-party knowledge and must not leak onto (or from) a custom endpoint.
   const isCustom = isCustomProviderName(name);
-  const maxTokens = resolveMaxTokens(useModel);
-  const effortProjection = projectEffortConfiguration(messages, name, useModel, {
-    ...config,
-    ...opts,
-    disableBetaHeaders: config?.disableBetaHeaders,
-  });
+  const maxTokens = resolveMaxTokens(capabilityModel, { modelMaxOutputTokens });
+  const effortOptions = { ...config, ...opts, disableBetaHeaders: config?.disableBetaHeaders };
+  const gatewayEffort = typeof config?.messagesEffort === 'function' ? config.messagesEffort(opts) : null;
+  const effortProjection = projectEffortConfiguration(messages, name, useModel, effortOptions);
   const ttls = resolveCacheTtls(opts);
 
   const systemMsgs = messages.filter((m) => m.role === 'system');
@@ -73,20 +79,29 @@ export async function buildAnthropicApiRequest({
   // (cacheTier:'tier3') at ttls.tier3 — each its own system content block.
   const systemBlocks = buildSystemBlocks(systemMsgs, ttls.system, ttls.tier3);
 
-  // Message-tail cache budget (4-BP layout + ANTHROPIC_MSG_SLOTS) is
-  // shared with anthropic-oauth — see resolveAnthropicMessageCacheSlots.
-  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls);
   // Tools are resolved BEFORE the messages: the lowering needs the final
   // tool list to drop tool_reference blocks whose tool no longer ships
   // in this request (otherwise the API rejects the whole turn).
-  const requestTools = requestAnthropicTools(tools, chatMsgs, opts);
+  const requestTools = requestAnthropicTools(tools, chatMsgs, opts, name);
+  // Message-tail cache budget (4-BP layout + ANTHROPIC_MSG_SLOTS) is
+  // shared with anthropic-oauth — see resolveAnthropicMessageCacheSlots.
+  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls, { tools: requestTools });
   // Build → sanitize (once, inside toAnthropicMessages) → mark. Markers
   // are applied to the FINAL sanitized array by invariant, so block
   // drops / inserts / reorders performed by the sanitizer can never move
   // or delete a marked block. NEVER sanitize again after this.
+  const lowerHistory = (history, projection) =>
+    lowerAnthropicEffortHistory(
+      history.filter((m) => m.role !== 'system'),
+      (segment) => toAnthropicMessages(segment, requestTools, name),
+      projection
+    );
   const anthropicMessages = applyAnthropicCacheMarkers(
-    lowerAnthropicEffortHistory(chatMsgs, (segment) => toAnthropicMessages(segment, requestTools), effortProjection),
-    messageCacheSlots
+    lowerHistory(chatMsgs, effortProjection),
+    messageCacheSlots,
+    sharedCachePrefixBoundary(messages, opts, (prefix) =>
+      lowerHistory(prefix, projectEffortConfiguration(prefix, name, useModel, effortOptions))
+    )
   );
 
   const params = {
@@ -108,10 +123,9 @@ export async function buildAnthropicApiRequest({
   // tool_choice only when tools are actually present (Anthropic rejects
   // tool_choice without tools). 'none' rides the hard-cap final turn to
   // forbid tool USE while keeping the tools prefix stable for cache reuse.
-  if (params.tools) {
-    const toolChoice = toAnthropicToolChoice(opts.toolChoice);
-    if (toolChoice) params.tool_choice = toolChoice;
-  }
+  // The key is reserved here (wire key order) and resolved once thinking is
+  // known: forced any/tool is invalid while thinking is enabled.
+  if (params.tools) params.tool_choice = undefined;
   const hasDeferredTools = Array.isArray(params.tools) && params.tools.some((tool) => tool?.defer_loading === true);
   // Known tool names for the shared parseSSEStream leaked-tool-call guard
   // (same guard fixes both Anthropic providers). Recovered leaked calls
@@ -129,16 +143,30 @@ export async function buildAnthropicApiRequest({
     });
     if (fields.thinking) params.thinking = fields.thinking;
     if (fields.output_config) params.output_config = { ...(params.output_config || {}), ...fields.output_config };
-  } else {
+  } else if (gatewayEffort !== 'none') {
+    // A gateway's own reasoning control (`messagesEffort`) replaces the turn
+    // effort; 'none' sends no thinking at all.
+    const turnOpts = effortProjection ? { ...opts, effort: effortProjection.initialEffort } : opts;
     applyAnthropicEffortToBody(params, {
-      model: useModel,
-      opts: effortProjection ? { ...opts, effort: effortProjection.initialEffort } : opts,
+      model: capabilityModel,
+      opts: gatewayEffort ? { ...turnOpts, effort: gatewayEffort } : turnOpts,
       maxTokens,
       clampThinkingBudgetTokens,
       logTag: name,
       progressUpdates: config?.disableBetaHeaders !== true,
     });
   }
+  if (params.tools) {
+    const toolChoice = toAnthropicToolChoice(opts.toolChoice, {
+      thinking: anthropicThinkingActive(params),
+      disableParallelToolUse: opts.disableParallelToolUse === true,
+      // A gateway that cannot honour disable_parallel_tool_use declares so.
+      supportsDisableParallelToolUse: config?.supportsDisableParallelToolUse !== false,
+      onThinkingConflict: opts.toolChoiceThinkingConflict,
+    });
+    if (toolChoice) params.tool_choice = toolChoice;
+    else delete params.tool_choice;
+  }
   // Fast mode → speed: "fast" on models Anthropic marks as speed-capable.
   // Suppressed while the fast capacity pool is cooling down.
   let fastLatched = fastModeLatched;
@@ -169,7 +197,7 @@ export async function buildAnthropicApiRequest({
         fastMode: fastLatched,
         toolSearch: hasDeferredTools,
         // Custom: the beta follows the resolver's output, not the model id.
-        effort: isCustom ? Boolean(params.output_config?.effort) : shouldIncludeEffortBeta(useModel, opts),
+        effort: isCustom ? Boolean(params.output_config?.effort) : shouldIncludeEffortBeta(capabilityModel, opts),
         serverFallback: params.fallbacks === 'default',
         thinkingDisplayUpdates: params.thinking?.display === 'updates',
       }),

package/src/runtime/agent/orchestrator/providers/anthropic-error-contract.mjs

@@ -25,9 +25,11 @@ const STATUS_ERROR_TYPE = new Map([
   [401, 'authentication_error'],
   [403, 'permission_error'],
   [404, 'not_found_error'],
+  [409, 'conflict_error'],
   [413, REQUEST_TOO_LARGE],
   [429, 'rate_limit_error'],
   [500, 'api_error'],
+  [504, 'timeout_error'],
   [529, 'overloaded_error'],
 ]);
 
@@ -43,7 +45,7 @@ function lowered(value) {
 
 /** The lowercased error type named by an Anthropic error body (JSON text or parsed object). */
 export function anthropicErrorTypeFromBody(body) {
-  if (body && typeof body === 'object') return lowered((body.error && body.error.type) || body.type);
+  if (body && typeof body === 'object') return lowered(body.error?.type || body.type);
   const match = BODY_TYPE_RE.exec(String(body || ''));
   return match ? lowered(match[1]) : '';
 }

package/src/runtime/agent/orchestrator/providers/anthropic-max-tokens.mjs

@@ -4,10 +4,10 @@
 //
 // Resolution order:
 //   1. MIXDOG_ANTHROPIC_MAX_OUTPUT_TOKENS env override, if set to a positive
-//      int, wins outright (returned as the safety cap itself).
+//      int, wins, capped by the known model maximum when there is one.
 //   2. Catalog outputTokens for the model id (trusted over hardcoded
 //      heuristics when present — the API reports real per-model limits),
-//      clamped to [MAX_TOKENS_FLOOR, safetyCap].
+//      clamped to safetyCap (never raised: a declared limit is a ceiling).
 //   3. The shared model catalog's outputTokens for the model (cached roster /
 //      LiteLLM / models.dev), same clamp.
 //   4. The pre-catalog family limits for a model no catalog describes, else
@@ -62,21 +62,28 @@ function sharedCatalogOutputTokens(model) {
 // catalogLookup(model) -> number|null. Providers supply their own strategy
 // for sourcing the catalog array (in-memory mirror + disk fallback for OAuth,
 // plain disk read for the API-key twin — see anthropic.mjs).
-export function resolveAnthropicMaxTokens(model, { catalogLookup } = {}) {
-  const envOverride = envAnthropicMaxOutputOverride();
-  if (envOverride != null) return envOverride;
-  const safetyCap = DEFAULT_SAFETY_CAP;
-  let catalogValue = null;
-  if (typeof catalogLookup === 'function') {
-    try {
-      catalogValue = catalogLookup(model);
-    } catch {
-      catalogValue = null;
+//
+// `modelMaxOutputTokens` (number|null): a gateway-supplied model limit. When
+// positive it takes precedence over every catalog lookup. A declared model
+// maximum is a ceiling: it is never raised to the floor, and the env override
+// is capped by it.
+export function resolveAnthropicMaxTokens(model, { catalogLookup, modelMaxOutputTokens = null } = {}) {
+  const isLimit = (value) => Number.isFinite(value) && value > 0;
+  let declared = Number(modelMaxOutputTokens);
+  if (!isLimit(declared)) {
+    declared = null;
+    if (typeof catalogLookup === 'function') {
+      try {
+        declared = catalogLookup(model);
+      } catch {
+        declared = null;
+      }
     }
+    if (!isLimit(declared)) declared = sharedCatalogOutputTokens(model);
   }
-  if (!(Number.isFinite(catalogValue) && catalogValue > 0)) catalogValue = sharedCatalogOutputTokens(model);
-  if (Number.isFinite(catalogValue) && catalogValue > 0) {
-    return Math.max(MAX_TOKENS_FLOOR, Math.min(catalogValue, safetyCap));
-  }
-  return Math.min(fallbackAnthropicMaxTokens(model), safetyCap);
+  declared = isLimit(declared) ? Math.floor(declared) : null;
+  const envOverride = envAnthropicMaxOutputOverride();
+  if (envOverride != null) return declared == null ? envOverride : Math.min(envOverride, declared);
+  if (declared != null) return Math.min(declared, DEFAULT_SAFETY_CAP);
+  return Math.min(fallbackAnthropicMaxTokens(model), DEFAULT_SAFETY_CAP);
 }

package/src/runtime/agent/orchestrator/providers/anthropic-messages.mjs

@@ -28,9 +28,8 @@ export function loadAnthropic() {
 
 // 4-BP cache policy aligned with anthropic-oauth — system + tier3 +
 // messages-tail. Tool schemas sit before system and are covered by the system
-// breakpoint, so they do not spend a separate cache_control slot. 1h TTL
-// requires the extended-cache-ttl beta header, which we set on the client via
-// defaultHeaders below.
+// breakpoint, so they do not spend a separate cache_control slot. The 1h TTL
+// is requested with cache_control ttl:"1h"; no beta header is needed.
 
 // BP3 (tier3) rides its own `system` role block (the 3rd system block, tagged
 // cacheTier:'tier3'). buildSystemBlocks applies the tier3 1h cache_control to
@@ -131,8 +130,8 @@ function _catalogOutputTokensFromSharedCache(model) {
   }
 }
 
-export function resolveMaxTokens(model) {
-  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokensFromSharedCache });
+export function resolveMaxTokens(model, { modelMaxOutputTokens = null } = {}) {
+  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokensFromSharedCache, modelMaxOutputTokens });
 }
 
 // Test-only escape hatch for the provider contract scripts
@@ -144,11 +143,12 @@ export const _test = {
   sanitizeInputSchema: (schema, toolName) => sanitizeAnthropicInputSchema(schema, toolName, 'anthropic'),
 };
 
-function deferredAnthropicTools(activeTools, messages, opts) {
-  return sharedDeferredAnthropicTools(activeTools, messages, opts, 'anthropic');
+function deferredAnthropicTools(activeTools, messages, opts, provider = 'anthropic') {
+  return sharedDeferredAnthropicTools(activeTools, messages, opts, provider);
 }
-export function requestAnthropicTools(tools, messages, opts) {
-  return sharedRequestAnthropicTools(tools, messages, opts, 'anthropic');
+// `provider`: the engine's name (a gateway Messages engine runs under its gateway's).
+export function requestAnthropicTools(tools, messages, opts, provider = 'anthropic') {
+  return sharedRequestAnthropicTools(tools, messages, opts, provider);
 }
 // Test-only: expose the lowering so the steering-provenance test can assert
 // the API-key provider keeps steering-tagged user turns distinct (mirrors

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-client-version.mjs

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.300';
+export const DEFAULT_CLI_VERSION = '2.1.302';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-request/gzip-post.mjs

@@ -2,55 +2,37 @@
 // /v1/messages returns 200 for Content-Encoding: gzip, 400 for zstd). Large turn
 // bodies (system prompt + history, typically 50-100KB+) compress ~5-10x,
 // trimming upload time off every call's header wait. Env kill-switch
-// (MIXDOG_ANTHROPIC_REQ_GZIP=0) plus a process-wide latch flipped on the first
-// 400 seen on a compressed request; small bodies skip compression since below
-// ~8KB the CPU + header cost outweighs the upload saving.
-import { promisify } from 'node:util';
-import { gzip } from 'node:zlib';
+// (MIXDOG_ANTHROPIC_REQ_GZIP=0); the gzip policy (8KB floor, fail-open,
+// 400/415 plain resend + latch-on-success) lives in lib/request-compression.mjs.
 import { getLlmDispatcher } from '../../../../shared/llm/http-agent.mjs';
 import { claudeCliUserAgent } from '../anthropic-oauth-client-version.mjs';
 import { ANTHROPIC_VERSION } from '../lib/anthropic-models.mjs';
+import { sendGzipCompressed } from '../lib/request-compression.mjs';
 
 const API_URL = 'https://api.anthropic.com/v1/messages';
 export { ANTHROPIC_VERSION };
 
-const ANTHROPIC_REQ_GZIP_MIN_BYTES = 8 * 1024;
-let gzipLatchedOff = false;
-const gzipDisabled = () => gzipLatchedOff || process.env.MIXDOG_ANTHROPIC_REQ_GZIP === '0';
-// Compress on the libuv threadpool so large turn bodies never block the main thread.
-const gzipAsync = promisify(gzip);
-
-export async function postMessages({ accessToken, requestBody, betaHeaders, signal }) {
-  const rawBody = Buffer.from(JSON.stringify(requestBody));
-  const useGzip = !gzipDisabled() && rawBody.length >= ANTHROPIC_REQ_GZIP_MIN_BYTES;
-  const sendAttempt = async (gz) =>
-    fetch(API_URL, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-version': ANTHROPIC_VERSION,
-        'anthropic-beta': betaHeaders,
-        'anthropic-dangerous-direct-browser-access': 'true',
-        'user-agent': claudeCliUserAgent(),
-        'x-app': 'cli',
-        'Content-Type': 'application/json',
-        ...(gz ? { 'Content-Encoding': 'gzip' } : {}),
-      },
-      body: gz ? await gzipAsync(rawBody) : rawBody,
-      signal,
-      dispatcher: getLlmDispatcher(),
-    });
-  let response = await sendAttempt(useGzip);
-  if (useGzip && response.status === 400) {
-    // Latch OFF process-wide and retry this attempt uncompressed, so a
-    // server-side behavior change can never wedge the session.
-    gzipLatchedOff = true;
-    try {
-      await response.arrayBuffer();
-    } catch {
-      /* drain best-effort */
-    }
-    response = await sendAttempt(false);
-  }
-  return response;
+export async function postMessages({ accessToken, requestBody, betaHeaders, signal, compress }) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    'anthropic-version': ANTHROPIC_VERSION,
+    'anthropic-beta': betaHeaders,
+    'anthropic-dangerous-direct-browser-access': 'true',
+    'user-agent': claudeCliUserAgent(),
+    'x-app': 'cli',
+    'Content-Type': 'application/json',
+  };
+  return sendGzipCompressed({
+    raw: Buffer.from(JSON.stringify(requestBody)),
+    headers,
+    compress,
+    send: (body, sendHeaders) =>
+      fetch(API_URL, {
+        method: 'POST',
+        headers: sendHeaders,
+        body,
+        signal,
+        dispatcher: getLlmDispatcher(),
+      }),
+  });
 }