codex-copilot-dx 0.6.1 → 0.6.3

package/src/pm-studio-status.mjs

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  AUTH_PROFILE_CLAUDE,
+  readAuthProfileCredentials,
+} from "./auth-profile.mjs";
+import { PM_STUDIO_RECIPES } from "./pm-studio-asar.mjs";
+import {
+  createPmStudioSetupOperations,
+  DEFAULT_PM_STUDIO_APP_PATH,
+  inspectPmStudioApp,
+  PM_STUDIO_CLAUDE_AUTH_COMMAND,
+} from "./pm-studio-setup.mjs";
+import { checkRunningAdapter } from "./running-adapter.mjs";
+import { status } from "./status.mjs";
+
+const PM_RELAY_HOST = "127.0.0.1";
+const PM_RELAY_PORT = 2026;
+
+function selectRecipe(metadata, recipes) {
+  return recipes.find((recipe) => recipe.version === String(metadata.version)
+    && recipe.build === String(metadata.build)
+    && recipe.bundleIdentifier === String(metadata.bundleIdentifier));
+}
+
+function safeMessage(error) {
+  return String(error?.message || "inspection failed").replace(/\s+/g, " ").trim();
+}
+
+function inspectClaudeProfile(home, readCredentials) {
+  try {
+    const credentials = readCredentials(AUTH_PROFILE_CLAUDE, { home });
+    return {
+      configured: credentials.configured === true,
+      valid: credentials.valid === true,
+      reason: credentials.reason || "",
+      login: credentials.identity?.login || "",
+    };
+  } catch (error) {
+    return { configured: true, valid: false, reason: safeMessage(error), login: "" };
+  }
+}
+
+export async function inspectPmStudioStatus({
+  appPath = DEFAULT_PM_STUDIO_APP_PATH,
+  home = os.homedir(),
+  recipes = PM_STUDIO_RECIPES,
+  operationOverrides = {},
+  existsSync = fs.existsSync,
+  inspectApp = inspectPmStudioApp,
+  readClaudeCredentials = readAuthProfileCredentials,
+  checkRunningAdapterFn = checkRunningAdapter,
+} = {}) {
+  const operations = createPmStudioSetupOperations(operationOverrides);
+  let app;
+  if (!existsSync(appPath)) {
+    app = { state: "not_installed", metadata: null, issues: [] };
+  } else {
+    try {
+      const metadata = operations.readBundleMetadata({
+        appPath,
+        infoPlistPath: path.join(appPath, "Contents/Info.plist"),
+        processRunner: operations.processRunner,
+      });
+      const normalized = {
+        version: String(metadata.version),
+        build: String(metadata.build),
+        bundleIdentifier: String(metadata.bundleIdentifier),
+      };
+      const recipe = selectRecipe(normalized, recipes);
+      app = recipe
+        ? { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id }
+        : { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+    } catch (error) {
+      app = { state: "error", metadata: null, issues: [safeMessage(error)], recipe: "" };
+    }
+  }
+
+  const claude = inspectClaudeProfile(home, readClaudeCredentials);
+  let adapter;
+  try {
+    adapter = await checkRunningAdapterFn({ host: PM_RELAY_HOST, port: PM_RELAY_PORT });
+  } catch (error) {
+    adapter = { ok: false, error };
+  }
+  const operational = app.state === "patched" && claude.valid && adapter?.ok === true;
+  return { ok: operational, appPath, app, claude, adapter };
+}
+
+function appStatusLine(result, commandName) {
+  const { app } = result;
+  const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
+  if (app.state === "patched") return status("ok", `PM Studio ${version} is patched and verified`);
+  if (app.state === "clean") return status("warn", `PM Studio ${version} is supported but not patched; run ${commandName} pms setup`);
+  if (app.state === "unsupported") return status("err", `PM Studio ${version} has no exact patch recipe; no files will be changed`);
+  if (app.state === "drift") return status("err", `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}`);
+  if (app.state === "not_installed") return status("warn", `PM Studio is not installed at ${result.appPath}`);
+  return status("err", `PM Studio could not be inspected: ${app.issues.join("; ")}`);
+}
+
+export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
+  const lines = [
+    `${commandName} pms status`,
+    appStatusLine(result, commandName),
+  ];
+  if (result.claude.valid) {
+    const account = result.claude.login ? ` for ${result.claude.login}` : "";
+    lines.push(status("ok", `Isolated Claude profile is valid${account}`));
+  } else {
+    const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
+    lines.push(status("err", `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}`));
+  }
+  if (result.adapter?.ok) {
+    lines.push(status("ok", `PM relay is available at ${result.adapter.baseUrl}`));
+  } else if (result.adapter?.incompatible) {
+    lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
+  } else {
+    lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
+  }
+  lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+  return lines.join("\n");
+}
+
+export async function runPmStudioStatus(options = {}) {
+  const result = await inspectPmStudioStatus(options);
+  const output = formatPmStudioStatus(result, options);
+  (options.log || console.log)(output);
+  return { ...result, output };
+}

package/src/profile-model-runtime.mjs

@@ -33,6 +33,7 @@ export function createProfileModelRuntime({
   codexClient,
   claudeClient = codexClient,
   claudeMode = "inherited",
+  codexCredentialFingerprint = "",
   claudeCredentialFingerprint = "",
   home,
   env = process.env,
@@ -93,7 +94,7 @@ export function createProfileModelRuntime({
   function loadCached({ client, profile, registry, ownsClaudeModels }) {
     const credentialFingerprint = profile === "claude"
       ? String(claudeCredentialFingerprint || "").trim()
-      : "";
+      : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return false;
     const cached = loadModelCache({ home, profile, credentialFingerprint });
     if (!cached) return false;
@@ -133,7 +134,7 @@ export function createProfileModelRuntime({
   function persist(models, profile) {
     const credentialFingerprint = profile === "claude"
       ? String(claudeCredentialFingerprint || "").trim()
-      : "";
+      : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return;
     try {
       saveModelCache(models, { home, profile, credentialFingerprint });

package/src/profile-routing.mjs

@@ -0,0 +1,74 @@
+function catalogData(catalog) {
+  if (Array.isArray(catalog)) return catalog;
+  return Array.isArray(catalog?.data) ? catalog.data : [];
+}
+
+function isClaudeCatalogEntry(model) {
+  const id = String(model?.id || "").trim();
+  const vendor = String(model?.vendor || "").trim().toLowerCase();
+  return Boolean(id) && (vendor === "anthropic" || id.toLowerCase().startsWith("claude-"));
+}
+
+function isAllowedClaudeModel(model) {
+  return isClaudeCatalogEntry(model)
+    && String(model?.vendor || "").trim().toLowerCase() === "anthropic"
+    && model?.model_picker_enabled !== false
+    && Array.isArray(model?.supported_endpoints)
+    && model.supported_endpoints.includes("/chat/completions");
+}
+
+export function profileRouting({ claudeMode = "inherited", claudeConfigured = false } = {}) {
+  const isolated = claudeMode === "isolated" || claudeConfigured === true;
+  return Object.freeze({ responses: "codex", messages: isolated ? "claude" : "codex" });
+}
+
+export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {}) {
+  if (typeof getCatalog !== "function") throw new Error("getCatalog is required");
+  if (typeof isClaudeEnabled !== "function") throw new Error("isClaudeEnabled is required");
+
+  const unset = Symbol("unset");
+  let cachedCatalog = unset;
+  let cachedEnabled = false;
+  let cachedAllowed = new Map();
+  let cachedKnown = new Set();
+  let rebuilds = 0;
+
+  function availability() {
+    const catalog = getCatalog();
+    const enabled = isClaudeEnabled() === true;
+    if (catalog === cachedCatalog && enabled === cachedEnabled) {
+      return { allowed: cachedAllowed, known: cachedKnown };
+    }
+
+    const allowed = new Map();
+    const known = new Set();
+    for (const model of catalogData(catalog)) {
+      const id = String(model?.id || "").trim();
+      if (!id || !isClaudeCatalogEntry(model)) continue;
+      known.add(id);
+      if (enabled && isAllowedClaudeModel(model) && !allowed.has(id)) allowed.set(id, model);
+    }
+    cachedCatalog = catalog;
+    cachedEnabled = enabled;
+    cachedAllowed = allowed;
+    cachedKnown = known;
+    rebuilds += 1;
+    return { allowed, known };
+  }
+
+  return Object.freeze({
+    classify(modelId) {
+      const id = String(modelId || "").trim();
+      const { allowed, known } = availability();
+      if (allowed.has(id)) return "claude";
+      if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
+      return "enterprise";
+    },
+    allowedModels() {
+      return [...availability().allowed.values()];
+    },
+    diagnostics() {
+      return { rebuilds, allowed: cachedAllowed.size, known: cachedKnown.size };
+    },
+  });
+}

package/src/profile-runtime.mjs

@@ -1,5 +1,6 @@
 import {
   AUTH_PROFILE_CLAUDE,
+  AUTH_PROFILE_CODEX,
   authProfilePaths,
   profileReauthMessage,
   readAuthProfileCredentials,
@@ -45,6 +46,16 @@ export function createProfileRuntime({
   };
   const credentials = readCredentials();
   const claudeProfile = safeProfileStatus(credentials);
+  let codexCredentialFingerprint = "";
+  try {
+    const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
+    if (codexCredentials.valid) {
+      codexCredentialFingerprint = githubTokenFingerprint(codexCredentials.token);
+    }
+  } catch {
+    // The Codex client remains authoritative if its optional metadata cannot
+    // be inspected; only credential-bound cache reuse is disabled.
+  }
 
   if (!credentials.configured) {
     return Object.freeze({
@@ -52,6 +63,7 @@ export function createProfileRuntime({
       claudeClient: codexClient,
       claudeMode: "inherited",
       claudeProfile,
+      codexCredentialFingerprint,
       claudeCredentialFingerprint: "",
     });
   }
@@ -73,6 +85,7 @@ export function createProfileRuntime({
     claudeClient,
     claudeMode: "isolated",
     claudeProfile,
+    codexCredentialFingerprint,
     claudeCredentialFingerprint: credentials.valid
       ? githubTokenFingerprint(credentials.token)
       : "",

package/src/response-history.mjs

@@ -174,6 +174,10 @@ export function responseHistoryStats() {
   return { entries: histories.size, bytes: totalBytes, evicted: evictedIds.size };
 }
 
+export function responseHistoryRootId(responseId) {
+  return histories.get(responseId)?.rootId || null;
+}
+
 export function materializeResponseHistory(responseId) {
   const chain = [];
   const seen = new Set();

package/src/responses-bridge.mjs

@@ -149,24 +149,29 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   try {
     const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
     try {
-      resp = await chatCompletionsFn(upstreamReq, { signal: options.signal, bodyText });
+      options.onUpstreamStart?.();
+      resp = await chatCompletionsFn(upstreamReq, {
+        signal: options.signal,
+        bodyText,
+        onUpstreamStart: options.onUpstreamStart,
+      });
     } finally {
       options.releaseRequest?.();
     }
   } catch (e) {
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
     await onError(statusCode, e.message);
-    return;
+    return false;
   }
   if (!resp.ok) {
     await onError(resp.status, await resp.text(), undefined, resp);
-    return;
+    return false;
   }
   try {
     await requireUpstreamEventStream(resp);
   } catch (error) {
     await onError(error.statusCode, error.message, error);
-    return;
+    return false;
   }
   options.onUpstreamResponse?.(resp);
   options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
@@ -279,7 +284,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     })) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();
-      if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
+      if (data === "[DONE]") { await emitCompleted(); onDone(); return true; }
       let parsed;
       try {
         parsed = JSON.parse(data);
@@ -331,8 +336,9 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   } catch (e) {
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : (e?.statusCode || 502);
     await onError(statusCode, e?.message || "upstream stream error", e);
-    return;
+    return false;
   }
   const error = incompleteUpstreamStream("[DONE]");
   await onError(error.statusCode, error.message, error);
+  return false;
 }

package/src/responses-byte-budget.mjs

@@ -159,12 +159,14 @@ function recordBytesAfterDrop(record, state, partIndex) {
   return state.baseBytes + remainingElementBytes + remainingCount - 1;
 }
 
-function selectImageDrops(refs, bodyBytes, targetBytes) {
+function selectImageDrops(refs, bodyBytes, targetBytes, maxHistoricalImages = Number.POSITIVE_INFINITY) {
   const candidates = orderedHistoricalImageCandidates(refs);
   const selected = new Set();
   const byRecord = new Map();
   let projectedBytes = bodyBytes;
+  let historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
   for (const index of candidates) {
+    if (projectedBytes <= targetBytes && historicalImages <= maxHistoricalImages) break;
     const ref = refs[index];
     let state = byRecord.get(ref.record);
     if (!state) {
@@ -173,7 +175,7 @@ function selectImageDrops(refs, bodyBytes, targetBytes) {
     }
     const afterBytes = recordBytesAfterDrop(ref.record, state, ref.partIndex);
     const savings = state.currentBytes - afterBytes;
-    if (savings <= 0) continue;
+    if (savings <= 0 && historicalImages <= maxHistoricalImages) continue;
     state.currentBytes = afterBytes;
     if (ref.record.kind !== "top-level") {
       state.remainingCount -= 1;
@@ -181,9 +183,9 @@ function selectImageDrops(refs, bodyBytes, targetBytes) {
     }
     selected.add(index);
     projectedBytes -= savings;
-    if (projectedBytes <= targetBytes) break;
+    historicalImages -= 1;
   }
-  return selected;
+  return { selected, historicalImages, projectedBytes };
 }
 
 function applyImageDrops(records, refs, selected) {
@@ -253,7 +255,7 @@ export function trimResponsesHistoryToByteBudget(reqBody, {
   while (bodyBytes > limit) {
     const { records, refs } = collectResponseImages(inputItems, currentInputStart);
     if (!refs.length) break;
-    const selected = selectImageDrops(refs, bodyBytes, limit);
+    const { selected } = selectImageDrops(refs, bodyBytes, limit);
     if (!selected.size) break;
     applyImageDrops(records, refs, selected);
     imagesOmitted += selected.size;
@@ -278,6 +280,62 @@ export function trimResponsesHistoryToByteBudget(reqBody, {
   };
 }
 
+export function responsesHistoricalImageStats(inputItems, currentInputStart = 0) {
+  const items = Array.isArray(inputItems) ? inputItems : [];
+  const { refs } = collectResponseImages(items, currentInputStart);
+  const historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
+  return {
+    totalImages: refs.length,
+    historicalImages,
+    currentImages: refs.length - historicalImages,
+  };
+}
+
+export function trimResponsesHistoricalImages(reqBody, {
+  currentInputStart = 0,
+  maxHistoricalImages = Number.POSITIVE_INFINITY,
+  targetBytes = Number.POSITIVE_INFINITY,
+  initialBodyText,
+  initialBodyBytes,
+} = {}) {
+  let bodyText = initialBodyText ?? JSON.stringify(reqBody);
+  let bodyBytes = initialBodyBytes ?? Buffer.byteLength(bodyText);
+  const byteLimit = Number.isFinite(targetBytes) && targetBytes > 0
+    ? Math.floor(targetBytes)
+    : Number.POSITIVE_INFINITY;
+  const imageLimit = Number.isFinite(maxHistoricalImages) && maxHistoricalImages >= 0
+    ? Math.floor(maxHistoricalImages)
+    : Number.POSITIVE_INFINITY;
+  const inputItems = Array.isArray(reqBody?.input) ? reqBody.input : [];
+  let imagesOmitted = 0;
+
+  while (true) {
+    const { records, refs } = collectResponseImages(inputItems, currentInputStart);
+    const historicalImages = refs.reduce((count, ref) => count + (ref.historical ? 1 : 0), 0);
+    if (bodyBytes <= byteLimit && historicalImages <= imageLimit) break;
+    if (!historicalImages) break;
+    const { selected } = selectImageDrops(refs, bodyBytes, byteLimit, imageLimit);
+    if (!selected.size) break;
+    applyImageDrops(records, refs, selected);
+    imagesOmitted += selected.size;
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+  }
+
+  const stats = responsesHistoricalImageStats(inputItems, currentInputStart);
+  return {
+    bodyText,
+    bodyBytes,
+    targetBytes: byteLimit,
+    maxHistoricalImages: imageLimit,
+    historicalImages: stats.historicalImages,
+    currentImages: stats.currentImages,
+    imagesOmitted,
+    overBudget: bodyBytes > byteLimit,
+    overImageBudget: stats.historicalImages > imageLimit,
+    adapted: imagesOmitted > 0,
+  };
+}
+
 export function enforceResponsesPayloadByteBudget(reqBody, payload) {
   let finalized = payload;
   if (payload?.overBudget) {

package/src/responses-handler.mjs

@@ -79,6 +79,7 @@ export function createResponsesHandler(options) {
     autoReviewModelResolver,
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
+    imagePressure,
     openAIModelEnv,
     responsesPayloadOptions,
     responsesFn,
@@ -90,14 +91,42 @@ export function createResponsesHandler(options) {
   return async function handleResponses(req, res) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
+    let prepared = null;
+    let imagePressureResult = null;
+    let parsed = null;
+    const startUpstreamTimeout = () => abort.setTimeout(
+      parsed?.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
+      parsed?.stream ? "stream_handshake_timeout" : "upstream_timeout",
+    );
+    const applyAdaptiveTimeout = (error) => {
+      if (!["responses_prepare_timeout", "stream_handshake_timeout", "upstream_timeout"].includes(abort.reason)) {
+        return error;
+      }
+      const activated = imagePressure?.markTimeout?.(prepared?.historyRootId, {
+        eligible: imagePressureResult?.pressureEligible === true,
+      });
+      if (!activated) return error;
+      const message = "Responses timed out while processing a large visual history. Retry the request; ccdx will keep fewer earlier images automatically. Restart is not required.";
+      error.statusCode = 504;
+      error.jsonBody = {
+        error: {
+          message,
+          type: "timeout_error",
+          code: "ccdx_visual_history_timeout",
+          retryable: true,
+        },
+      };
+      return error;
+    };
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      const parsed = await readJsonBody(req);
-      abort.setTimeout(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
-      );
-      const prepared = prepareResponsesRequest(parsed, { mutate: true });
+      parsed = await readJsonBody(req);
+      abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
+      prepared = prepareResponsesRequest(parsed, { mutate: true });
+      imagePressureResult = imagePressure?.apply?.(prepared) || null;
+      if (imagePressureResult?.adapted) {
+        console.warn(status("warn", `responses visual history mode=${imagePressureResult.mode} historical_images=${imagePressureResult.initialHistoricalImages}->${imagePressureResult.historicalImages} omitted=${imagePressureResult.imagesOmitted} bytes=${imagePressureResult.initialBodyBytes}->${imagePressureResult.bodyBytes}`));
+      }
       prepared.surface = "responses";
       const model = parsed.model || "unknown";
       const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
@@ -110,12 +139,14 @@ export function createResponsesHandler(options) {
         || (usesCustomTools && cachedModelSupportsResponses(upstreamModel, getCachedModelEndpointsFn));
       if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
       if (useNativeResponses) {
-        await proxyCopilotResponses(prepared, req, res, responsesFn, {
+        const result = await proxyCopilotResponses(prepared, req, res, responsesFn, {
           signal: abort.signal,
           abort,
+          onUpstreamStart: startUpstreamTimeout,
           releaseRequest,
           streamIdleTimeoutMs,
         });
+        if (result?.successful) imagePressure?.markSuccess?.(prepared.historyRootId);
       } else {
         const chatPayload = await prepareResponsesChatPayload(prepared, {
           payloadOptions: responsesPayloadOptions,
@@ -125,7 +156,7 @@ export function createResponsesHandler(options) {
         const { chatReq, bodyText } = chatPayload;
         if (parsed.stream) {
           let streamResponseHeaders = null;
-          await forwardToChat(chatReq, async (event, data) => {
+          const successful = await forwardToChat(chatReq, async (event, data) => {
             if (!res.headersSent) res.writeHead(200, {
               ...streamResponseHeaders,
               "Cache-Control": "no-cache",
@@ -142,7 +173,7 @@ export function createResponsesHandler(options) {
                 sendUpstreamError(res, upstreamResponse, errMsg);
                 return;
               }
-              const responseError = error || Object.assign(new Error(errMsg), { statusCode });
+              const responseError = applyAdaptiveTimeout(error || Object.assign(new Error(errMsg), { statusCode }));
               sendJsonError(res, responseError, statusCode || 500);
               return;
             }
@@ -150,6 +181,7 @@ export function createResponsesHandler(options) {
           }, {
             signal: abort.signal,
             abort,
+            onUpstreamStart: startUpstreamTimeout,
             streamIdleTimeoutMs,
             chatCompletionsFn,
             releaseRequest,
@@ -160,9 +192,15 @@ export function createResponsesHandler(options) {
               });
             },
           });
+          if (successful) imagePressure?.markSuccess?.(prepared.historyRootId);
         } else {
           try {
-            const upstream = await chatCompletionsFn(chatReq, { signal: abort.signal, bodyText });
+            startUpstreamTimeout();
+            const upstream = await chatCompletionsFn(chatReq, {
+              signal: abort.signal,
+              bodyText,
+              onUpstreamStart: startUpstreamTimeout,
+            });
             releaseRequest();
             const data = await upstream.text();
             if (!upstream.ok) {
@@ -171,20 +209,23 @@ export function createResponsesHandler(options) {
             }
             const response = chatToResponses(JSON.parse(data), model);
             rememberResponseHistory(prepared, response);
+            imagePressure?.markSuccess?.(prepared.historyRootId);
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
             res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
               contentType: "application/json",
             }));
             res.end(JSON.stringify(response));
           } catch (error) {
-            logRequestFailure("Responses", error, abort);
-            sendJsonError(res, error, 502);
+            const responseError = applyAdaptiveTimeout(error);
+            logRequestFailure("Responses", responseError, abort);
+            sendJsonError(res, responseError, 502);
           }
         }
       }
     } catch (error) {
-      logRequestFailure("Responses", error, abort);
-      sendJsonError(res, error, 502);
+      const responseError = applyAdaptiveTimeout(error);
+      logRequestFailure("Responses", responseError, abort);
+      sendJsonError(res, responseError, 502);
     } finally {
       releaseRequest();
       abort.cleanup();
@@ -196,6 +237,7 @@ export function createResponsesCompactHandler(options) {
   const {
     acquireRequest,
     autoReviewModelResolver,
+    imagePressure,
     openAIModelEnv,
     responsesCompactFn,
     upstreamTimeoutMs,
@@ -207,7 +249,7 @@ export function createResponsesCompactHandler(options) {
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       const parsed = await readJsonBody(req);
-      abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+      abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
       const prepared = prepareResponsesCompactionRequest(
         prepareResponsesRequest(parsed, { mutate: true }),
       );
@@ -217,11 +259,13 @@ export function createResponsesCompactHandler(options) {
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
-      await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
+      const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         signal: abort.signal,
         abort,
+        onUpstreamStart: () => abort.setTimeout(upstreamTimeoutMs, "upstream_timeout"),
         releaseRequest,
       });
+      if (result?.compacted) imagePressure?.clear?.(prepared.historyRootId);
     } catch (error) {
       logRequestFailure("Responses compact", error, abort);
       sendJsonError(res, error, 502);