@tonyclaw/agent-inspector 3.0.45 → 3.0.46

package/src/proxy/ecosystemTasks.ts

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import type {
   EcosystemExecutionPlan,
@@ -8,15 +8,31 @@ import type {
   EcosystemTaskStatus,
 } from "../lib/ecosystemContract";
 import { findEcosystemPackage, findEcosystemRecipe } from "./ecosystemRegistry";
-import { npmCommand, npmSpawnCommand } from "./platformCommands";
+import {
+  npmCommand,
+  npmSpawnCommand,
+  signalProcessTree,
+  type CommandSpec,
+} from "./platformCommands";
 
 const MAX_TASKS = 50;
 const OUTPUT_LIMIT = 40_000;
 const INSTALL_TIMEOUT_MS = 120_000;
 const HELP_TIMEOUT_MS = 30_000;
 const RECIPE_TIMEOUT_MS = 90_000;
+const SHUTDOWN_GRACE_MS = 2_000;
 
 const tasks = new Map<string, EcosystemTask>();
+type ActiveTask = {
+  child: ChildProcess;
+  closed: Promise<void>;
+  resolveClosed: () => void;
+  timeout: ReturnType<typeof setTimeout>;
+};
+
+const activeTasks = new Map<string, ActiveTask>();
+let acceptingTasks = true;
+let shutdownForceTimer: ReturnType<typeof setTimeout> | null = null;
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -152,6 +168,77 @@ function completeTask(
   task.finishedAt = nowIso();
 }
 
+function finishActiveTask(taskId: string): void {
+  const active = activeTasks.get(taskId);
+  if (active === undefined) return;
+  clearTimeout(active.timeout);
+  activeTasks.delete(taskId);
+  active.resolveClosed();
+  if (activeTasks.size === 0 && shutdownForceTimer !== null) {
+    clearTimeout(shutdownForceTimer);
+    shutdownForceTimer = null;
+  }
+}
+
+function failTaskForShutdown(task: EcosystemTask): void {
+  if (task.status !== "running" && task.status !== "queued") return;
+  const error = "Runtime shutdown terminated the ecosystem command";
+  appendTaskOutput(task, `\n${error}.\n`);
+  completeTask(task, "failed", null, error);
+}
+
+function forceActiveTaskTrees(): void {
+  for (const active of activeTasks.values()) {
+    const pid = active.child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGKILL");
+  }
+}
+
+function launchTask(task: EcosystemTask, spawnCommand: CommandSpec, timeoutMs: number): void {
+  const child = spawn(spawnCommand.command, spawnCommand.args, {
+    detached: process.platform !== "win32",
+    windowsHide: true,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let resolveClosed = (): void => {};
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+  const timeout = setTimeout(() => {
+    const pid = child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGKILL");
+    appendTaskOutput(task, `\nTimed out after ${String(timeoutMs / 1000)}s.\n`);
+  }, timeoutMs);
+  activeTasks.set(task.id, { child, closed, resolveClosed, timeout });
+
+  task.status = "running";
+  task.startedAt = nowIso();
+  appendTaskOutput(task, `$ ${task.command}\n`);
+
+  child.stdout?.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.stderr?.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.on("error", (error) => {
+    appendTaskOutput(task, `\n${error.message}\n`);
+    if (task.status !== "failed") completeTask(task, "failed", null, error.message);
+    finishActiveTask(task.id);
+  });
+  child.on("close", (code) => {
+    if (task.status !== "failed") {
+      if (code === 0) {
+        completeTask(task, "succeeded", code, null);
+      } else {
+        completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
+      }
+    }
+    finishActiveTask(task.id);
+  });
+}
+
 export function getEcosystemTask(taskId: string): EcosystemTask | null {
   return tasks.get(taskId) ?? null;
 }
@@ -164,6 +251,7 @@ export function startEcosystemTask(
   packageId: string,
   action: EcosystemTaskAction,
 ): EcosystemTask | null {
+  if (!acceptingTasks) return null;
   if (action === "recipe") return null;
   const definition =
     action === "runner-presets"
@@ -190,46 +278,13 @@ export function startEcosystemTask(
   };
   rememberTask(task);
 
-  const spawnCommand = npmSpawnCommand(args);
-  const child = spawn(spawnCommand.command, spawnCommand.args, {
-    windowsHide: true,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  const timeout = setTimeout(() => {
-    child.kill();
-    appendTaskOutput(task, `\nTimed out after ${String(packageActionTimeout(action) / 1000)}s.\n`);
-  }, packageActionTimeout(action));
-
-  task.status = "running";
-  task.startedAt = nowIso();
-  appendTaskOutput(task, `$ ${task.command}\n`);
-
-  child.stdout.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.stderr.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.on("error", (error) => {
-    clearTimeout(timeout);
-    appendTaskOutput(task, `\n${error.message}\n`);
-    completeTask(task, "failed", null, error.message);
-  });
-  child.on("close", (code) => {
-    clearTimeout(timeout);
-    if (task.status === "failed") return;
-    if (code === 0) {
-      completeTask(task, "succeeded", code, null);
-      return;
-    }
-    completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
-  });
+  launchTask(task, npmSpawnCommand(args), packageActionTimeout(action));
 
   return task;
 }
 
 export function startEcosystemRecipeTask(recipeId: string): EcosystemTask | null {
+  if (!acceptingTasks) return null;
   const recipe = findEcosystemRecipe(recipeId);
   if (recipe === null) return null;
   if (!recipe.runnable) return null;
@@ -255,41 +310,77 @@ export function startEcosystemRecipeTask(recipeId: string): EcosystemTask | null
   };
   rememberTask(task);
 
-  const spawnCommand = npmSpawnCommand(args);
-  const child = spawn(spawnCommand.command, spawnCommand.args, {
-    windowsHide: true,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  const timeout = setTimeout(() => {
-    child.kill();
-    appendTaskOutput(task, `\nTimed out after ${String(RECIPE_TIMEOUT_MS / 1000)}s.\n`);
-  }, RECIPE_TIMEOUT_MS);
+  launchTask(task, npmSpawnCommand(args), RECIPE_TIMEOUT_MS);
 
-  task.status = "running";
-  task.startedAt = nowIso();
-  appendTaskOutput(task, `$ ${task.command}\n`);
+  return task;
+}
 
-  child.stdout.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.stderr.on("data", (chunk: Buffer) => {
-    appendTaskOutput(task, chunk.toString("utf8"));
-  });
-  child.on("error", (error) => {
-    clearTimeout(timeout);
-    appendTaskOutput(task, `\n${error.message}\n`);
-    completeTask(task, "failed", null, error.message);
-  });
-  child.on("close", (code) => {
-    clearTimeout(timeout);
-    if (task.status === "failed") return;
-    if (code === 0) {
-      completeTask(task, "succeeded", code, null);
-      return;
-    }
-    completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
-  });
+/** Stop admitting commands and begin terminating every tracked child process tree. */
+export function beginEcosystemTaskShutdown(): void {
+  acceptingTasks = false;
+  for (const [taskId, active] of activeTasks) {
+    const task = tasks.get(taskId);
+    if (task !== undefined) failTaskForShutdown(task);
+    clearTimeout(active.timeout);
+    const pid = active.child.pid;
+    if (pid !== undefined) signalProcessTree(pid, "SIGTERM");
+  }
+  if (activeTasks.size > 0 && shutdownForceTimer === null) {
+    shutdownForceTimer = setTimeout(() => {
+      shutdownForceTimer = null;
+      forceActiveTaskTrees();
+    }, SHUTDOWN_GRACE_MS);
+    shutdownForceTimer.unref();
+  }
+}
+
+/** Wait until children signalled by beginEcosystemTaskShutdown have closed. */
+export async function waitForEcosystemTasksToClose(): Promise<void> {
+  await Promise.all([...activeTasks.values()].map(async (active) => await active.closed));
+}
+
+/** Immediate deadline fallback used by the runtime shutdown coordinator. */
+export function forceCloseEcosystemTasks(): void {
+  acceptingTasks = false;
+  if (shutdownForceTimer !== null) {
+    clearTimeout(shutdownForceTimer);
+    shutdownForceTimer = null;
+  }
+  for (const taskId of activeTasks.keys()) {
+    const task = tasks.get(taskId);
+    if (task !== undefined) failTaskForShutdown(task);
+  }
+  forceActiveTaskTrees();
+}
 
+export function _startEcosystemTaskForTests(
+  spawnCommand: CommandSpec,
+  timeoutMs = RECIPE_TIMEOUT_MS,
+): EcosystemTask | null {
+  if (!acceptingTasks) return null;
+  const task: EcosystemTask = {
+    id: randomUUID(),
+    packageId: "test-package",
+    npmName: "test-package",
+    recipeId: null,
+    action: "help",
+    status: "queued",
+    command: `${spawnCommand.command} ${spawnCommand.args.join(" ")}`,
+    output: "",
+    createdAt: nowIso(),
+    startedAt: null,
+    finishedAt: null,
+    exitCode: null,
+    error: null,
+  };
+  rememberTask(task);
+  launchTask(task, spawnCommand, timeoutMs);
   return task;
 }
+
+export function _resetEcosystemTasksForTests(): void {
+  forceCloseEcosystemTasks();
+  tasks.clear();
+  activeTasks.clear();
+  acceptingTasks = true;
+}

package/src/proxy/formats/registry.ts

@@ -1,12 +1,8 @@
 import type { FormatHandler } from "./handler";
 import type { ApiFormat } from "../schemas";
-import {
-  PATH_V1_CHAT_COMPLETIONS,
-  PATH_CHAT_COMPLETIONS,
-  PATH_V1_RESPONSES,
-  PATH_RESPONSES,
-  PATH_V1_MESSAGES,
-} from "../constants";
+import { API_FORMAT_PATH_ENTRIES, apiFormatForPath } from "../../lib/apiFormat";
+
+export { apiFormatForPath };
 
 /**
  * API format registry maps request paths and API formats to their FormatHandler.
@@ -63,18 +59,7 @@ export function formatForPath(path: string): FormatHandler | null {
   return formatRegistry.getByPath(path) ?? null;
 }
 
-/**
- * Resolve the API format from the request endpoint. The endpoint is
- * authoritative because Anthropic and OpenAI request bodies overlap for
- * simple message-only calls.
- */
-export function apiFormatForPath(path: string): ApiFormat {
-  return formatRegistry.getApiFormatByPath(path) ?? "unknown";
-}
-
 // Register known paths
-formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
-formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_CHAT_COMPLETIONS, "openai");
-formatRegistry.registerPath(PATH_V1_RESPONSES, "openai");
-formatRegistry.registerPath(PATH_RESPONSES, "openai");
+for (const [path, format] of API_FORMAT_PATH_ENTRIES) {
+  formatRegistry.registerPath(path, format);
+}

package/src/proxy/handler.ts

@@ -1,7 +1,7 @@
-import { createLog, finalizeLogUpdate, getNextLogId, type CapturedLog } from "./store";
+import { Buffer } from "node:buffer";
+import { createLog, getNextLogId, persistFinalizedLogUpdate, type CapturedLog } from "./store";
 import { appendLogEntry, logger } from "./logger";
 import { extractRequestMetadata } from "./schemas";
-import { registry } from "./formats";
 import { findProviderByModel } from "./providers";
 import { getClientInfo } from "./socketTracker";
 import { formatForPath } from "./formats";
@@ -25,18 +25,26 @@ import { getConfig } from "./config";
 import { safeFetch } from "../lib/safeFetch";
 
 const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
-import { stripClaudeCodeBillingHeader } from "./claudeCodeStrip";
+const EMPTY_UPSTREAM_BODY_ERROR = "Upstream response did not include a body";
+const UPSTREAM_STREAM_ERROR = "Upstream stream terminated unexpectedly";
+import { stripClaudeCodeBillingHeader } from "../lib/claudeCodeStrip";
 import { stripOpenAIOrphanToolMessages } from "./openaiOrphanToolStrip";
 import { maskApiKey } from "../lib/mask";
 import { buildFileLogEntry, type FinalizeLogJob } from "./logFinalizer";
 import { enqueueFinalizeLogJob } from "./sessionRuntime";
 import { RawStreamCapture } from "./rawStreamCapture";
-import { acquireRuntimeRequest, type RuntimeRequestLease } from "./runtimeAdmission";
+import {
+  acquireRuntimeRequest,
+  getRuntimeAdmissionState,
+  type RuntimeRequestLease,
+} from "./runtimeAdmission";
+import { resourceLimitResponse } from "../lib/resourceLimits";
 import {
   buildUpstreamUrl,
   describeApiRoute,
   getProxyApiPath,
   injectProviderAuth,
+  providerSupportsApiRoute,
   selectUpstreamBase,
   setUpstreamHost,
 } from "./upstream";
@@ -181,31 +189,81 @@ function handleNonStreamingResponse(
   });
 }
 
-function handleStreamingResponse(
+function applyRawStreamCaptureStatus(log: CapturedLog, capture: RawStreamCapture): void {
+  const status = capture.status;
+  log.captureIncomplete = status.incomplete;
+  log.droppedChunks = status.droppedChunks;
+  log.droppedBytes = status.droppedBytes;
+  log.captureIncompleteReason = status.reason;
+}
+
+function applyUpstreamStreamError(log: CapturedLog): void {
+  log.captureIncomplete = true;
+  log.captureIncompleteReason = "upstream-stream-error";
+  log.error = UPSTREAM_STREAM_ERROR;
+}
+
+async function handleStreamingResponse(
   upstreamRes: Response,
   req: Request,
   startTime: number,
   upstreamUrl: string,
   log: CapturedLog,
   collectStreamingChunks: boolean,
-): Response {
+): Promise<Response> {
   log.streaming = true;
   log.responseStatus = upstreamRes.status;
 
+  if (upstreamRes.body === null) {
+    log.elapsedMs = Date.now() - startTime;
+    log.responseStatus = STATUS_BAD_GATEWAY;
+    log.responseText = EMPTY_UPSTREAM_BODY_ERROR;
+    log.captureIncomplete = true;
+    log.droppedChunks = 0;
+    log.droppedBytes = 0;
+    log.captureIncompleteReason = "upstream-stream-error";
+    log.error = EMPTY_UPSTREAM_BODY_ERROR;
+    appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: EMPTY_UPSTREAM_BODY_ERROR });
+    await persistFinalizedLogUpdate(log);
+    return new Response("No response body", { status: STATUS_BAD_GATEWAY });
+  }
+
   const capture = new RawStreamCapture();
   const decoder = new TextDecoder();
   let finalizationScheduled = false;
   let firstChunkMs: number | null = null;
+  let pendingDecoderBytes = 0;
+  let downstreamCancelled = false;
+
+  const submitDecodedText = (text: string, flush: boolean = false): void => {
+    const observedBytes = flush
+      ? pendingDecoderBytes
+      : Math.min(pendingDecoderBytes, Buffer.byteLength(text, "utf-8"));
+    pendingDecoderBytes -= observedBytes;
+    if (text === "" && observedBytes === 0) return;
+    capture.tryAppend(text, observedBytes);
+    applyRawStreamCaptureStatus(log, capture);
+  };
 
-  const scheduleStreamingFinalization = (type: "streaming" | "stream-abort"): void => {
+  const scheduleStreamingFinalization = (
+    type: "streaming" | "stream-abort",
+    upstreamStreamFailed: boolean = false,
+  ): void => {
     if (finalizationScheduled) return;
     finalizationScheduled = true;
 
+    if (pendingDecoderBytes > 0) {
+      capture.recordDroppedObservation("pipeline-closed", pendingDecoderBytes);
+      pendingDecoderBytes = 0;
+    }
+
     const totalStreamMs = Date.now() - startTime;
     const elapsedMs = totalStreamMs;
     void capture
       .finalize()
       .then((rawStream) => {
+        applyRawStreamCaptureStatus(log, capture);
+        if (upstreamStreamFailed) applyUpstreamStreamError(log);
         switch (type) {
           case "streaming":
             scheduleLogFinalization({
@@ -218,6 +276,7 @@ function handleStreamingResponse(
               collectStreamingChunks,
               firstChunkMs,
               totalStreamMs,
+              terminalError: upstreamStreamFailed ? UPSTREAM_STREAM_ERROR : null,
             });
             return;
           case "stream-abort":
@@ -237,6 +296,10 @@ function handleStreamingResponse(
       })
       .catch((error: unknown) => {
         const message = error instanceof Error ? error.message : String(error);
+        applyRawStreamCaptureStatus(log, capture);
+        if (upstreamStreamFailed) applyUpstreamStreamError(log);
+        log.captureIncomplete = true;
+        log.captureIncompleteReason ??= "finalize-failed";
         logger.error(
           `[handler] Raw stream finalization failed for log #${String(log.id)}:`,
           message,
@@ -256,28 +319,48 @@ function handleStreamingResponse(
   };
 
   const transform = new TransformStream<Uint8Array, Uint8Array>({
-    async transform(chunk, controller) {
+    transform(chunk, controller) {
       if (firstChunkMs === null) firstChunkMs = Date.now() - startTime;
       controller.enqueue(chunk);
-      await capture.append(decoder.decode(chunk, { stream: true }));
+      pendingDecoderBytes += chunk.byteLength;
+      submitDecodedText(decoder.decode(chunk, { stream: true }));
     },
-    async flush() {
-      await capture.append(decoder.decode());
+    flush() {
+      submitDecodedText(decoder.decode(), true);
       scheduleStreamingFinalization("streaming");
     },
   });
 
-  if (upstreamRes.body === null) {
-    return new Response("No response body", { status: STATUS_BAD_GATEWAY });
-  }
-
   // pipeTo returns a promise that rejects when either side errors. Without
   // this catch, an upstream connection drop skips flush() and leaves the log
   // permanently un-finalized with a leaked temp file.
   void upstreamRes.body.pipeTo(transform.writable).catch(() => {
-    scheduleStreamingFinalization("streaming");
+    if (downstreamCancelled || req.signal?.aborted === true) {
+      scheduleStreamingFinalization("stream-abort");
+      return;
+    }
+    scheduleStreamingFinalization("streaming", true);
+  });
+  const transformedReader = transform.readable.getReader();
+  const loggedStream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const next = await transformedReader.read();
+        if (next.done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(next.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      downstreamCancelled = true;
+      scheduleStreamingFinalization("stream-abort");
+      await transformedReader.cancel(reason);
+    },
   });
-  const loggedStream = transform.readable;
 
   if (req.signal === undefined) {
     logger.warn("[handler] req.signal is undefined; abort detection disabled for this request");
@@ -361,6 +444,19 @@ async function handleAdmittedProxy(req: Request): Promise<Response> {
   // Find provider config using already-extracted model (not calling extractModelFromBody again)
   const matchedProviderConfig = model !== null ? findProviderByModel(model) : null;
   const route = describeApiRoute(parsed.apiPath);
+
+  // Model matching is necessary but not sufficient: the Provider must explicitly expose the
+  // protocol selected by the request path. This guard stays before log creation and fetch so a
+  // protocol mismatch has the same zero-side-effect contract as an unconfigured model.
+  if (
+    model === null ||
+    matchedProviderConfig === null ||
+    !providerSupportsApiRoute(route, matchedProviderConfig)
+  ) {
+    logger.warn(`[handler] Unsupported provider: model=${model}`);
+    return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
+  }
+
   const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
   const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
 
@@ -374,15 +470,7 @@ async function handleAdmittedProxy(req: Request): Promise<Response> {
   setUpstreamHost(upstreamHeaders, upstreamBase);
   injectProviderAuth(upstreamHeaders, matchedProviderConfig);
 
-  const provider = model !== null ? registry.findProvider(model) : null;
-
-  // Only proxy requests matching a registered provider
-  if (model === null || provider === null) {
-    logger.warn(`[handler] Unsupported provider: model=${model}`);
-    return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
-  }
-
-  // Pick the format handler from the request path. provider.format is only a
+  // Pick the format handler from the request path. ProviderConfig.format is only a
   // hint used as a fallback when no anthropicBaseUrl/openaiBaseUrl is set, and
   // does NOT describe what the upstream actually returns: a provider configured
   // with format="openai" may still expose an Anthropic-compatible endpoint
@@ -441,7 +529,7 @@ async function handleAdmittedProxy(req: Request): Promise<Response> {
       log.responseStatus = status;
       log.responseText = fetchResult.reason;
       appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: fetchResult.reason });
-      finalizeLogUpdate(log);
+      await persistFinalizedLogUpdate(log);
       return new Response(
         fetchResult.kind === "network-policy"
           ? "Forbidden: upstream URL is not permitted"
@@ -458,14 +546,14 @@ async function handleAdmittedProxy(req: Request): Promise<Response> {
       log.responseStatus = 499; // Client Closed Request (non-standard but descriptive)
       log.responseText = "Client aborted";
       appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
-      finalizeLogUpdate(log);
+      await persistFinalizedLogUpdate(log);
       return new Response("Client aborted", { status: 499 });
     }
     logger.error(`[handler] Proxy error: ${req.method} ${parsed.apiPath}`, String(err));
     log.responseStatus = STATUS_BAD_GATEWAY;
     log.responseText = String(err);
     appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: String(err) });
-    finalizeLogUpdate(log);
+    await persistFinalizedLogUpdate(log);
     return new Response(`Proxy error: ${err}`, { status: STATUS_BAD_GATEWAY });
   }
 
@@ -527,6 +615,18 @@ function responseWithRuntimeLease(response: Response, lease: RuntimeRequestLease
 export async function handleProxy(req: Request): Promise<Response> {
   const lease = acquireRuntimeRequest();
   if (lease === null) {
+    const admission = getRuntimeAdmissionState();
+    if (admission.acceptingRequests) {
+      return resourceLimitResponse({
+        error: `Proxy request capacity reached. At most ${String(admission.capacity)} active requests are allowed; retry after a response completes.`,
+        code: "proxy-capacity-exceeded",
+        status: 503,
+        resource: "proxy-requests",
+        limit: admission.capacity,
+        retryable: true,
+        retryAfterSeconds: 1,
+      });
+    }
     return Response.json(
       { error: "Agent Inspector is shutting down" },
       { status: 503, headers: { "cache-control": "no-store", "retry-after": "5" } },