@namzu/cli 37.0.0 → 37.0.2

package/dist/chunks/{chunk-5J3T7DNL.js → chunk-FLUVTAXY.js}

@@ -3655,6 +3655,14 @@ function readOutputOverflow(err) {
   return void 0;
 }
 __name(readOutputOverflow, "readOutputOverflow");
+function isUndiciTermination(err) {
+  for (const link6 of causeChain(err)) {
+    if (link6 instanceof TypeError && link6.message === "terminated")
+      return true;
+  }
+  return false;
+}
+__name(isUndiciTermination, "isUndiciTermination");
 var NETWORK_ERRNOS = /* @__PURE__ */ new Set([
   "ECONNRESET",
   "ECONNREFUSED",
@@ -3693,13 +3701,23 @@ function codeFromStatus(status) {
   return "unknown";
 }
 __name(codeFromStatus, "codeFromStatus");
-function codeFromMessage(message) {
+function overflowWordingAllowed(status) {
+  return status === void 0 || status === 400 || status === 413;
+}
+__name(overflowWordingAllowed, "overflowWordingAllowed");
+var CONTEXT_WINDOW_OVERFLOW = /(?:exceed\w*|too (?:long|large|big)|larger than|longer than|over the|beyond|maximum|overflow\w*)\b[^.]{0,60}context window|context window[^.]{0,60}\b(?:exceed\w*|too (?:long|large|big)|larger than|longer than|over the|beyond|maximum|overflow\w*)/i;
+function codeFromMessage(message, status) {
   const m = message.toLowerCase();
   if (m.includes("context length") || m.includes("context_length") || m.includes("maximum context") || m.includes("too many tokens") || m.includes("prompt is too long") || // Real wordings that missed every phrase above and so classified as
   // a plain invalid request — which is not retryable, and which the
   // overflow rescue tests for by exact equality. The turn died holding
   // the remedy.
-  m.includes("too long for") || m.includes("maximum length") || m.includes("exceeds the maximum") || m.includes("input is too large") || m.includes("too large for")) {
+  m.includes("too long for") || // The reference terminal's own wordings (its `context window` and
+  // `input length and max_tokens exceed context limit` matchers).
+  // Only where the status cannot say otherwise: a 429, 5xx or 401 that
+  // mentions the window is still a rate limit, a server fault or an auth
+  // failure, and must keep its retry and fallback behaviour.
+  overflowWordingAllowed(status) && (CONTEXT_WINDOW_OVERFLOW.test(message) || m.includes("exceed context limit")) || m.includes("maximum length") || m.includes("exceeds the maximum") || m.includes("input is too large") || m.includes("too large for")) {
     return "context_length_exceeded";
   }
   if (m.includes("rate limit") || m.includes("rate_limit") || m.includes("too many requests")) {
@@ -3788,7 +3806,7 @@ function classifyProviderError(err, providerId, now = Date.now()) {
   const errno = readErrnoCode(err);
   const retryAfterMs = readRetryAfterMs(err, now);
   const messages = chainMessages(err);
-  const fromMessage = messages.map(codeFromMessage).find((code) => code !== void 0);
+  const fromMessage = messages.map((m) => codeFromMessage(m, status)).find((code) => code !== void 0);
   const declared = declaredRetryable(err);
   const structural = codeFromStructure(err);
   if (structural !== void 0) {
@@ -3802,7 +3820,7 @@ function classifyProviderError(err, providerId, now = Date.now()) {
       cause: err
     });
   }
-  if (messages.some((m) => codeFromMessage(m) === "context_length_exceeded")) {
+  if (messages.some((m) => codeFromMessage(m, status) === "context_length_exceeded")) {
     return new ProviderError({
       code: "context_length_exceeded",
       message,
@@ -3843,7 +3861,7 @@ function classifyProviderError(err, providerId, now = Date.now()) {
       });
     }
   }
-  if (err instanceof TypeError && /fetch|network/i.test(message)) {
+  if (err instanceof TypeError && /fetch|network/i.test(message) || isUndiciTermination(err)) {
     return new ProviderError({
       code: "network",
       message,
@@ -14209,6 +14227,483 @@ var PromptContributionRegistry = class {
 };
 var SKILLS_CONTRIBUTION_ID = "namzu.skills";
 
+// ../sdk/dist/provider/errors.js
+var PROVIDER_ERROR_KINDS = [
+  "throttle",
+  "network",
+  "auth",
+  "context_overflow",
+  "bad_request",
+  "server"
+];
+var ProviderRequestError = class extends Error {
+  static {
+    __name(this, "ProviderRequestError");
+  }
+  kind;
+  providerId;
+  providerCode;
+  status;
+  retryAfterMs;
+  /**
+   * What the provider said was wrong, truncated and redacted.
+   *
+   * `ProviderRequestErrorInit` has declared this field all along and the
+   * constructor never read it, so every caller that set it was writing to
+   * nothing. That is not a cosmetic gap: a provider rejecting a request
+   * usually names the exact offending field, and losing that sentence turns
+   * a one-line diagnosis into hypothesis elimination against a live API. It
+   * did — a tool schema in the wrong JSON Schema dialect cost a day of
+   * production downtime while the wire had been saying
+   * `tools.0.custom.input_schema: … must match JSON Schema draft 2020-12`
+   * the whole time.
+   *
+   * See {@link vendorDetail} for what is kept and what is scrubbed.
+   */
+  detail;
+  /** The provider's `x-should-retry` verdict, when it sent one; see {@link ProviderRequestErrorInit.shouldRetry}. */
+  shouldRetry;
+  constructor(init) {
+    super(buildProviderErrorMessage(init));
+    this.name = "ProviderRequestError";
+    this.kind = init.kind;
+    this.providerId = init.providerId;
+    const exactProviderCode = safeProviderCode(init.providerCode);
+    if (exactProviderCode !== void 0)
+      this.providerCode = exactProviderCode;
+    if (init.status !== void 0)
+      this.status = init.status;
+    if (init.retryAfterMs !== void 0)
+      this.retryAfterMs = init.retryAfterMs;
+    if (init.detail !== void 0)
+      this.detail = init.detail;
+    if (init.shouldRetry !== void 0)
+      this.shouldRetry = init.shouldRetry;
+  }
+};
+var DETAIL_MAX = 400;
+var PROVIDER_CODE = /^[A-Za-z][A-Za-z0-9._-]{0,79}$/;
+function safeProviderCode(value) {
+  if (typeof value !== "string" || !PROVIDER_CODE.test(value))
+    return void 0;
+  return redactSecrets(value) === value ? value : void 0;
+}
+__name(safeProviderCode, "safeProviderCode");
+function providerCode(value) {
+  let decoded = value;
+  if (typeof decoded === "string") {
+    try {
+      decoded = JSON.parse(decoded);
+    } catch {
+      return void 0;
+    }
+  }
+  if (typeof decoded !== "object" || decoded === null)
+    return void 0;
+  const record3 = decoded;
+  const nested = typeof record3.error === "object" && record3.error !== null ? record3.error.code : void 0;
+  return safeProviderCode(record3.code ?? nested);
+}
+__name(providerCode, "providerCode");
+function vendorDetail(body) {
+  if (body === void 0 || body === null)
+    return void 0;
+  let text9;
+  if (typeof body === "string") {
+    try {
+      text9 = pickMessage(JSON.parse(body)) ?? body;
+    } catch {
+      text9 = body;
+    }
+  } else {
+    text9 = pickMessage(body) ?? "";
+  }
+  const cleaned = redactSecrets(text9.trim());
+  if (cleaned.length === 0)
+    return void 0;
+  return cleaned.length > DETAIL_MAX ? `${cleaned.slice(0, DETAIL_MAX)}\u2026` : cleaned;
+}
+__name(vendorDetail, "vendorDetail");
+function redactSecrets(text9) {
+  let out = text9;
+  for (const [label5, pattern] of LOG_SECRET_PATTERNS) {
+    out = out.replace(pattern, `[REDACTED:${label5}]`);
+  }
+  return out;
+}
+__name(redactSecrets, "redactSecrets");
+function pickMessage(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value !== "object" || value === null)
+    return void 0;
+  const node = value;
+  const nested = node.error;
+  if (typeof nested === "string")
+    return nested;
+  if (typeof nested === "object" && nested !== null) {
+    const message = nested.message;
+    if (typeof message === "string")
+      return message;
+  }
+  if (typeof node.message === "string")
+    return node.message;
+  return void 0;
+}
+__name(pickMessage, "pickMessage");
+function isProviderRequestError(err) {
+  const exactProviderCode = err?.providerCode;
+  return err instanceof Error && err.name === "ProviderRequestError" && typeof err.providerId === "string" && PROVIDER_ERROR_KINDS.includes(err.kind) && (exactProviderCode === void 0 || safeProviderCode(exactProviderCode) === exactProviderCode);
+}
+__name(isProviderRequestError, "isProviderRequestError");
+function isCallerAbortError(error, signal) {
+  if (!signal?.aborted)
+    return false;
+  if (error === signal.reason)
+    return true;
+  if (!(error instanceof Error))
+    return false;
+  return error.name === "AbortError" || error.name === "APIUserAbortError";
+}
+__name(isCallerAbortError, "isCallerAbortError");
+var KIND_SENTENCE = {
+  throttle: "rate limited by the provider",
+  network: "could not reach the provider",
+  auth: "the provider rejected the request credentials",
+  context_overflow: "the request exceeded the model context window",
+  bad_request: "the provider rejected the request as invalid",
+  server: "the provider failed to complete the request"
+};
+function buildProviderErrorMessage(init) {
+  const status = init.status !== void 0 ? ` (HTTP ${init.status})` : "";
+  const detail = init.detail ? `: ${init.detail}` : "";
+  return `${init.providerId}${status} \u2014 ${KIND_SENTENCE[init.kind]}${detail}`;
+}
+__name(buildProviderErrorMessage, "buildProviderErrorMessage");
+var OVERFLOW_BODY_PATTERNS = [
+  /prompt is too long/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /maximum context length/i,
+  /too long for requested model/i,
+  /input is too long/i,
+  /(?:input|prompt|context).{0,80}exceeds the maximum/i,
+  /reduce the (?:input|prompt|context) length/i,
+  // Ollama phrases it the other way round — "input length exceeds context
+  // length" — so a pattern anchored on "exceeded" misses it entirely.
+  /exceeds?\s+(?:the\s+)?(?:model'?s?\s+)?context\s+(?:length|window|size)/i,
+  /context\s+(?:length|window|size)\s+exceed/i,
+  // The reference terminal's own list matches the bare phrase "context
+  // window". Here it must sit next to a verb that says the request did not
+  // fit ("larger than the model context window of N tokens"), so a 400 that
+  // only names the window ("does not support this parameter with the 1M
+  // context window beta") stays an invalid request. The same pattern lives in
+  // `types/provider/errors.ts` (`codeFromMessage`), which also gates it on the
+  // status; keep them equal.
+  /(?:exceed\w*|too (?:long|large|big)|larger than|longer than|over the|beyond|maximum|overflow\w*)\b[^.]{0,60}context window|context window[^.]{0,60}\b(?:exceed\w*|too (?:long|large|big)|larger than|longer than|over the|beyond|maximum|overflow\w*)/i,
+  // "input length and `max_tokens` exceed context limit: A + B > C". The
+  // prompt may fit and only the requested output not; the loop tries a smaller
+  // `max_tokens` first (readOutputOverflow) and falls back to shedding history
+  // when there is no room for a useful reply, which needs this to classify.
+  /input length and `?max_tokens`? exceed context limit/i
+];
+function bodySaysContextOverflow(body) {
+  if (!body)
+    return false;
+  return OVERFLOW_BODY_PATTERNS.some((re2) => re2.test(body));
+}
+__name(bodySaysContextOverflow, "bodySaysContextOverflow");
+function parseShouldRetry(value) {
+  return value?.trim().toLowerCase() === "false" ? false : void 0;
+}
+__name(parseShouldRetry, "parseShouldRetry");
+function parseRetryAfterMs(headerValue2, now = Date.now()) {
+  if (!headerValue2)
+    return void 0;
+  const trimmed = headerValue2.trim();
+  if (trimmed === "")
+    return void 0;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (!Number.isFinite(seconds) || seconds < 0)
+      return void 0;
+    return Math.round(seconds * 1e3);
+  }
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at))
+    return void 0;
+  const delta = at - now;
+  return delta > 0 ? delta : void 0;
+}
+__name(parseRetryAfterMs, "parseRetryAfterMs");
+function classifyProviderHttpStatus(status, body) {
+  if (status === 401 || status === 403)
+    return "auth";
+  if (status === 429)
+    return "throttle";
+  if (status === 408 || status === 425)
+    return "network";
+  if (status >= 500)
+    return "server";
+  if (status === 413) {
+    return bodySaysContextOverflow(body) ? "context_overflow" : "bad_request";
+  }
+  if (status >= 400) {
+    return bodySaysContextOverflow(body) ? "context_overflow" : "bad_request";
+  }
+  return "server";
+}
+__name(classifyProviderHttpStatus, "classifyProviderHttpStatus");
+var VENDOR_TYPE_KINDS = [
+  [/overloaded_error|api_error|service_unavailable/i, "server"],
+  [/rate_limit_error|rate_limit_exceeded/i, "throttle"],
+  [/authentication_error|permission_error|invalid_api_key|unauthorized/i, "auth"],
+  [/timeout_error|connection_error/i, "network"]
+];
+function vendorTypeKind(message) {
+  for (const [re2, kind] of VENDOR_TYPE_KINDS) {
+    if (re2.test(message))
+      return kind;
+  }
+  return void 0;
+}
+__name(vendorTypeKind, "vendorTypeKind");
+function vendorErrorStatus(err) {
+  if (typeof err !== "object" || err === null)
+    return void 0;
+  const e = err;
+  for (const candidate of [e.status, e.statusCode, e.status_code, e.$metadata?.httpStatusCode]) {
+    if (typeof candidate === "number" && Number.isFinite(candidate))
+      return candidate;
+  }
+  return void 0;
+}
+__name(vendorErrorStatus, "vendorErrorStatus");
+function vendorRetryAfter(err) {
+  if (typeof err !== "object" || err === null)
+    return void 0;
+  const headers = err.headers ?? err.$response?.headers;
+  if (!headers)
+    return void 0;
+  if (typeof headers.get === "function") {
+    return headers.get("retry-after") ?? void 0;
+  }
+  const record3 = headers;
+  for (const key5 of ["retry-after", "Retry-After", "retryAfter"]) {
+    const value = record3[key5];
+    if (typeof value === "string")
+      return value;
+  }
+  return void 0;
+}
+__name(vendorRetryAfter, "vendorRetryAfter");
+var REQUEST_ID_HEADERS = ["x-request-id", "request-id", "x-goog-request-id"];
+function vendorHeader(err, names) {
+  if (typeof err !== "object" || err === null)
+    return void 0;
+  const headers = err.headers ?? err.$response?.headers;
+  if (!headers)
+    return void 0;
+  for (const name2 of names) {
+    if (typeof headers.get === "function") {
+      const value2 = headers.get(name2);
+      if (value2)
+        return value2;
+      continue;
+    }
+    const value = headers[name2];
+    if (typeof value === "string" && value)
+      return value;
+  }
+  return void 0;
+}
+__name(vendorHeader, "vendorHeader");
+var FIELD_VALUE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+function fieldValue(value) {
+  return typeof value === "string" && FIELD_VALUE.test(value) && redactSecrets(value) === value ? value : void 0;
+}
+__name(fieldValue, "fieldValue");
+function structuredVendorDetail(input) {
+  const message = vendorDetail(input.message?.replace(/^\d{3}\s+/, ""));
+  const type = fieldValue(input.type);
+  const code = fieldValue(input.code);
+  const param = fieldValue(input.param);
+  const requestId = fieldValue(input.requestId);
+  if (!type && !code && !param && !requestId)
+    return message;
+  if (!message)
+    return void 0;
+  return JSON.stringify({
+    error: {
+      message,
+      ...type ? { type } : {},
+      ...code ? { code } : {},
+      ...param ? { param } : {}
+    },
+    ...requestId ? { request_id: requestId } : {}
+  });
+}
+__name(structuredVendorDetail, "structuredVendorDetail");
+function providerVendorError(input) {
+  const { error } = input;
+  const status = vendorErrorStatus(error);
+  const exactProviderCode = providerCode(error);
+  const name2 = error instanceof Error ? error.name : "";
+  const message = error instanceof Error ? error.message : "";
+  let kind;
+  if (/ThrottlingException|TooManyRequests|ServiceQuotaExceeded/i.test(name2)) {
+    kind = "throttle";
+  } else if (/AccessDenied|Unauthorized|Forbidden|Authentication/i.test(name2)) {
+    kind = "auth";
+  } else if (/ValidationException/i.test(name2)) {
+    kind = bodySaysContextOverflow(message) ? "context_overflow" : "bad_request";
+  } else if (/ServiceUnavailable|InternalServer|ModelTimeout|ModelStreamError|ModelError|ModelNotReady/i.test(name2)) {
+    kind = "server";
+  } else if (status !== void 0) {
+    kind = classifyProviderHttpStatus(status, message);
+  } else if (exactProviderCode === "invalid_image") {
+    kind = "bad_request";
+  } else if (bodySaysContextOverflow(message)) {
+    kind = "context_overflow";
+  } else {
+    kind = vendorTypeKind(message) ?? "network";
+  }
+  const retryAfterMs = parseRetryAfterMs(input.retryAfter ?? vendorRetryAfter(error), input.now ?? Date.now());
+  const shouldRetry = parseShouldRetry(vendorHeader(error, ["x-should-retry"]));
+  const fields2 = error;
+  const detail = carriesBody(message) ? vendorDetail(message) : structuredVendorDetail({
+    message,
+    type: fields2?.type,
+    code: exactProviderCode,
+    param: fields2?.param,
+    requestId: fields2?.requestID ?? vendorHeader(error, REQUEST_ID_HEADERS)
+  });
+  return new ProviderRequestError({
+    kind,
+    providerId: input.providerId,
+    ...exactProviderCode !== void 0 ? { providerCode: exactProviderCode } : {},
+    ...status !== void 0 ? { status } : {},
+    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
+    ...detail !== void 0 ? { detail } : {},
+    ...shouldRetry !== void 0 ? { shouldRetry } : {}
+  });
+}
+__name(providerVendorError, "providerVendorError");
+function carriesBody(message) {
+  const rest = message.replace(/^\d{3}\s+/, "").trim();
+  if (!rest.startsWith("{"))
+    return false;
+  try {
+    const parsed = JSON.parse(rest);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+__name(carriesBody, "carriesBody");
+function parsedBody(body) {
+  let decoded = body;
+  if (typeof decoded === "string") {
+    try {
+      decoded = JSON.parse(decoded);
+    } catch {
+      return void 0;
+    }
+  }
+  return typeof decoded === "object" && decoded !== null && !Array.isArray(decoded) ? decoded : void 0;
+}
+__name(parsedBody, "parsedBody");
+function bodyErrorFields(body) {
+  const inner = body && typeof body.error === "object" && body.error !== null ? body.error : void 0;
+  if (!inner)
+    return {};
+  return {
+    type: inner.type ?? (typeof inner.status === "string" ? inner.status : void 0),
+    code: typeof inner.code === "string" ? inner.code : void 0,
+    param: inner.param
+  };
+}
+__name(bodyErrorFields, "bodyErrorFields");
+function providerHttpError(input) {
+  const kind = classifyProviderHttpStatus(input.status, input.body);
+  const retryAfterMs = parseRetryAfterMs(input.retryAfter, input.now ?? Date.now());
+  const body = parsedBody(input.body);
+  const bodyError = bodyErrorFields(body);
+  const detail = body ? structuredVendorDetail({
+    message: vendorDetail(input.body),
+    type: bodyError.type,
+    code: bodyError.code,
+    param: bodyError.param,
+    requestId: input.requestId
+  }) : vendorDetail(input.body);
+  const exactProviderCode = providerCode(input.body);
+  const shouldRetry = parseShouldRetry(input.shouldRetry);
+  return new ProviderRequestError({
+    kind,
+    providerId: input.providerId,
+    ...exactProviderCode !== void 0 ? { providerCode: exactProviderCode } : {},
+    status: input.status,
+    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
+    ...detail !== void 0 ? { detail } : {},
+    ...shouldRetry !== void 0 ? { shouldRetry } : {}
+  });
+}
+__name(providerHttpError, "providerHttpError");
+
+// ../sdk/dist/provider/capabilities.js
+var PERMISSIVE_PROVIDER_CAPABILITIES = {
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsFunctionCalling: true,
+  supportsVision: true,
+  supportsDocuments: true,
+  supportsToolResultImages: true,
+  supportsToolResultDocuments: true
+};
+function resolveProviderCapabilities(provider) {
+  const declared = provider.capabilities;
+  return {
+    supportsTools: declared?.supportsTools ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsTools,
+    supportsStreaming: declared?.supportsStreaming ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsStreaming,
+    supportsFunctionCalling: declared?.supportsFunctionCalling ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsFunctionCalling,
+    supportsVision: declared?.supportsVision ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsVision,
+    supportsDocuments: declared?.supportsDocuments ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsDocuments,
+    supportsToolResultImages: declared?.supportsToolResultImages ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsToolResultImages,
+    supportsToolResultDocuments: declared?.supportsToolResultDocuments ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsToolResultDocuments,
+    maxOutputTokens: declared?.maxOutputTokens
+  };
+}
+__name(resolveProviderCapabilities, "resolveProviderCapabilities");
+function modelReadsImages(provider, model) {
+  if (provider.capabilities?.supportsVision === false)
+    return false;
+  if (model === void 0 || model === "")
+    return true;
+  return provider.supportsImageInputFor?.(model) ?? true;
+}
+__name(modelReadsImages, "modelReadsImages");
+function assertNativeStructuredOutputSupported(provider, params) {
+  if (params.responseFormat?.type === "json_schema" && provider.capabilities?.supportsNativeStructuredOutput !== true) {
+    throw new ProviderRequestError({
+      kind: "bad_request",
+      providerId: provider.id,
+      providerCode: "native_structured_output_unsupported",
+      detail: "Native JSON Schema output requires a provider that declares supportsNativeStructuredOutput: true."
+    });
+  }
+}
+__name(assertNativeStructuredOutputSupported, "assertNativeStructuredOutputSupported");
+function assertHostedWebSearchSupported(provider, params) {
+  if (params.webSearch && (provider.capabilities?.supportsHostedWebSearch !== true || provider.supportsHostedWebSearchFor && !provider.supportsHostedWebSearchFor(params.model ?? "", params.webSearch.mode))) {
+    throw new ProviderRequestError({
+      kind: "bad_request",
+      providerId: provider.id,
+      providerCode: "hosted_web_search_unsupported",
+      detail: "This provider does not support hosted web search. Disable web.search or select a supported provider."
+    });
+  }
+}
+__name(assertHostedWebSearchSupported, "assertHostedWebSearchSupported");
+
 // ../sdk/dist/registry/tool/execute.js
 var TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
 function assertToolName(name2) {
@@ -26311,462 +26806,6 @@ async function readEverRecordedMessages(log) {
 }
 __name(readEverRecordedMessages, "readEverRecordedMessages");
 
-// ../sdk/dist/provider/errors.js
-var PROVIDER_ERROR_KINDS = [
-  "throttle",
-  "network",
-  "auth",
-  "context_overflow",
-  "bad_request",
-  "server"
-];
-var ProviderRequestError = class extends Error {
-  static {
-    __name(this, "ProviderRequestError");
-  }
-  kind;
-  providerId;
-  providerCode;
-  status;
-  retryAfterMs;
-  /**
-   * What the provider said was wrong, truncated and redacted.
-   *
-   * `ProviderRequestErrorInit` has declared this field all along and the
-   * constructor never read it, so every caller that set it was writing to
-   * nothing. That is not a cosmetic gap: a provider rejecting a request
-   * usually names the exact offending field, and losing that sentence turns
-   * a one-line diagnosis into hypothesis elimination against a live API. It
-   * did — a tool schema in the wrong JSON Schema dialect cost a day of
-   * production downtime while the wire had been saying
-   * `tools.0.custom.input_schema: … must match JSON Schema draft 2020-12`
-   * the whole time.
-   *
-   * See {@link vendorDetail} for what is kept and what is scrubbed.
-   */
-  detail;
-  /** The provider's `x-should-retry` verdict, when it sent one; see {@link ProviderRequestErrorInit.shouldRetry}. */
-  shouldRetry;
-  constructor(init) {
-    super(buildProviderErrorMessage(init));
-    this.name = "ProviderRequestError";
-    this.kind = init.kind;
-    this.providerId = init.providerId;
-    const exactProviderCode = safeProviderCode(init.providerCode);
-    if (exactProviderCode !== void 0)
-      this.providerCode = exactProviderCode;
-    if (init.status !== void 0)
-      this.status = init.status;
-    if (init.retryAfterMs !== void 0)
-      this.retryAfterMs = init.retryAfterMs;
-    if (init.detail !== void 0)
-      this.detail = init.detail;
-    if (init.shouldRetry !== void 0)
-      this.shouldRetry = init.shouldRetry;
-  }
-};
-var DETAIL_MAX = 400;
-var PROVIDER_CODE = /^[A-Za-z][A-Za-z0-9._-]{0,79}$/;
-function safeProviderCode(value) {
-  if (typeof value !== "string" || !PROVIDER_CODE.test(value))
-    return void 0;
-  return redactSecrets(value) === value ? value : void 0;
-}
-__name(safeProviderCode, "safeProviderCode");
-function providerCode(value) {
-  let decoded = value;
-  if (typeof decoded === "string") {
-    try {
-      decoded = JSON.parse(decoded);
-    } catch {
-      return void 0;
-    }
-  }
-  if (typeof decoded !== "object" || decoded === null)
-    return void 0;
-  const record3 = decoded;
-  const nested = typeof record3.error === "object" && record3.error !== null ? record3.error.code : void 0;
-  return safeProviderCode(record3.code ?? nested);
-}
-__name(providerCode, "providerCode");
-function vendorDetail(body) {
-  if (body === void 0 || body === null)
-    return void 0;
-  let text9;
-  if (typeof body === "string") {
-    try {
-      text9 = pickMessage(JSON.parse(body)) ?? body;
-    } catch {
-      text9 = body;
-    }
-  } else {
-    text9 = pickMessage(body) ?? "";
-  }
-  const cleaned = redactSecrets(text9.trim());
-  if (cleaned.length === 0)
-    return void 0;
-  return cleaned.length > DETAIL_MAX ? `${cleaned.slice(0, DETAIL_MAX)}\u2026` : cleaned;
-}
-__name(vendorDetail, "vendorDetail");
-function redactSecrets(text9) {
-  let out = text9;
-  for (const [label5, pattern] of LOG_SECRET_PATTERNS) {
-    out = out.replace(pattern, `[REDACTED:${label5}]`);
-  }
-  return out;
-}
-__name(redactSecrets, "redactSecrets");
-function pickMessage(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value !== "object" || value === null)
-    return void 0;
-  const node = value;
-  const nested = node.error;
-  if (typeof nested === "string")
-    return nested;
-  if (typeof nested === "object" && nested !== null) {
-    const message = nested.message;
-    if (typeof message === "string")
-      return message;
-  }
-  if (typeof node.message === "string")
-    return node.message;
-  return void 0;
-}
-__name(pickMessage, "pickMessage");
-function isProviderRequestError(err) {
-  const exactProviderCode = err?.providerCode;
-  return err instanceof Error && err.name === "ProviderRequestError" && typeof err.providerId === "string" && PROVIDER_ERROR_KINDS.includes(err.kind) && (exactProviderCode === void 0 || safeProviderCode(exactProviderCode) === exactProviderCode);
-}
-__name(isProviderRequestError, "isProviderRequestError");
-function isCallerAbortError(error, signal) {
-  if (!signal?.aborted)
-    return false;
-  if (error === signal.reason)
-    return true;
-  if (!(error instanceof Error))
-    return false;
-  return error.name === "AbortError" || error.name === "APIUserAbortError";
-}
-__name(isCallerAbortError, "isCallerAbortError");
-var KIND_SENTENCE = {
-  throttle: "rate limited by the provider",
-  network: "could not reach the provider",
-  auth: "the provider rejected the request credentials",
-  context_overflow: "the request exceeded the model context window",
-  bad_request: "the provider rejected the request as invalid",
-  server: "the provider failed to complete the request"
-};
-function buildProviderErrorMessage(init) {
-  const status = init.status !== void 0 ? ` (HTTP ${init.status})` : "";
-  const detail = init.detail ? `: ${init.detail}` : "";
-  return `${init.providerId}${status} \u2014 ${KIND_SENTENCE[init.kind]}${detail}`;
-}
-__name(buildProviderErrorMessage, "buildProviderErrorMessage");
-var OVERFLOW_BODY_PATTERNS = [
-  /prompt is too long/i,
-  /context[_ ]length[_ ]exceeded/i,
-  /maximum context length/i,
-  /too long for requested model/i,
-  /input is too long/i,
-  /(?:input|prompt|context).{0,80}exceeds the maximum/i,
-  /reduce the (?:input|prompt|context) length/i,
-  // Ollama phrases it the other way round — "input length exceeds context
-  // length" — so a pattern anchored on "exceeded" misses it entirely.
-  /exceeds?\s+(?:the\s+)?(?:model'?s?\s+)?context\s+(?:length|window|size)/i,
-  /context\s+(?:length|window|size)\s+exceed/i
-];
-function bodySaysContextOverflow(body) {
-  if (!body)
-    return false;
-  return OVERFLOW_BODY_PATTERNS.some((re2) => re2.test(body));
-}
-__name(bodySaysContextOverflow, "bodySaysContextOverflow");
-function parseShouldRetry(value) {
-  return value?.trim().toLowerCase() === "false" ? false : void 0;
-}
-__name(parseShouldRetry, "parseShouldRetry");
-function parseRetryAfterMs(headerValue2, now = Date.now()) {
-  if (!headerValue2)
-    return void 0;
-  const trimmed = headerValue2.trim();
-  if (trimmed === "")
-    return void 0;
-  if (/^\d+(\.\d+)?$/.test(trimmed)) {
-    const seconds = Number(trimmed);
-    if (!Number.isFinite(seconds) || seconds < 0)
-      return void 0;
-    return Math.round(seconds * 1e3);
-  }
-  const at = Date.parse(trimmed);
-  if (Number.isNaN(at))
-    return void 0;
-  const delta = at - now;
-  return delta > 0 ? delta : void 0;
-}
-__name(parseRetryAfterMs, "parseRetryAfterMs");
-function classifyProviderHttpStatus(status, body) {
-  if (status === 401 || status === 403)
-    return "auth";
-  if (status === 429)
-    return "throttle";
-  if (status === 408 || status === 425)
-    return "network";
-  if (status >= 500)
-    return "server";
-  if (status === 413) {
-    return bodySaysContextOverflow(body) ? "context_overflow" : "bad_request";
-  }
-  if (status >= 400) {
-    return bodySaysContextOverflow(body) ? "context_overflow" : "bad_request";
-  }
-  return "server";
-}
-__name(classifyProviderHttpStatus, "classifyProviderHttpStatus");
-var VENDOR_TYPE_KINDS = [
-  [/overloaded_error|api_error|service_unavailable/i, "server"],
-  [/rate_limit_error|rate_limit_exceeded/i, "throttle"],
-  [/authentication_error|permission_error|invalid_api_key|unauthorized/i, "auth"],
-  [/timeout_error|connection_error/i, "network"]
-];
-function vendorTypeKind(message) {
-  for (const [re2, kind] of VENDOR_TYPE_KINDS) {
-    if (re2.test(message))
-      return kind;
-  }
-  return void 0;
-}
-__name(vendorTypeKind, "vendorTypeKind");
-function vendorErrorStatus(err) {
-  if (typeof err !== "object" || err === null)
-    return void 0;
-  const e = err;
-  for (const candidate of [e.status, e.statusCode, e.status_code, e.$metadata?.httpStatusCode]) {
-    if (typeof candidate === "number" && Number.isFinite(candidate))
-      return candidate;
-  }
-  return void 0;
-}
-__name(vendorErrorStatus, "vendorErrorStatus");
-function vendorRetryAfter(err) {
-  if (typeof err !== "object" || err === null)
-    return void 0;
-  const headers = err.headers ?? err.$response?.headers;
-  if (!headers)
-    return void 0;
-  if (typeof headers.get === "function") {
-    return headers.get("retry-after") ?? void 0;
-  }
-  const record3 = headers;
-  for (const key5 of ["retry-after", "Retry-After", "retryAfter"]) {
-    const value = record3[key5];
-    if (typeof value === "string")
-      return value;
-  }
-  return void 0;
-}
-__name(vendorRetryAfter, "vendorRetryAfter");
-var REQUEST_ID_HEADERS = ["x-request-id", "request-id", "x-goog-request-id"];
-function vendorHeader(err, names) {
-  if (typeof err !== "object" || err === null)
-    return void 0;
-  const headers = err.headers ?? err.$response?.headers;
-  if (!headers)
-    return void 0;
-  for (const name2 of names) {
-    if (typeof headers.get === "function") {
-      const value2 = headers.get(name2);
-      if (value2)
-        return value2;
-      continue;
-    }
-    const value = headers[name2];
-    if (typeof value === "string" && value)
-      return value;
-  }
-  return void 0;
-}
-__name(vendorHeader, "vendorHeader");
-var FIELD_VALUE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
-function fieldValue(value) {
-  return typeof value === "string" && FIELD_VALUE.test(value) && redactSecrets(value) === value ? value : void 0;
-}
-__name(fieldValue, "fieldValue");
-function structuredVendorDetail(input) {
-  const message = vendorDetail(input.message?.replace(/^\d{3}\s+/, ""));
-  const type = fieldValue(input.type);
-  const code = fieldValue(input.code);
-  const param = fieldValue(input.param);
-  const requestId = fieldValue(input.requestId);
-  if (!type && !code && !param && !requestId)
-    return message;
-  if (!message)
-    return void 0;
-  return JSON.stringify({
-    error: {
-      message,
-      ...type ? { type } : {},
-      ...code ? { code } : {},
-      ...param ? { param } : {}
-    },
-    ...requestId ? { request_id: requestId } : {}
-  });
-}
-__name(structuredVendorDetail, "structuredVendorDetail");
-function providerVendorError(input) {
-  const { error } = input;
-  const status = vendorErrorStatus(error);
-  const exactProviderCode = providerCode(error);
-  const name2 = error instanceof Error ? error.name : "";
-  const message = error instanceof Error ? error.message : "";
-  let kind;
-  if (/ThrottlingException|TooManyRequests|ServiceQuotaExceeded/i.test(name2)) {
-    kind = "throttle";
-  } else if (/AccessDenied|Unauthorized|Forbidden|Authentication/i.test(name2)) {
-    kind = "auth";
-  } else if (/ValidationException/i.test(name2)) {
-    kind = bodySaysContextOverflow(message) ? "context_overflow" : "bad_request";
-  } else if (/ServiceUnavailable|InternalServer|ModelTimeout|ModelStreamError|ModelError|ModelNotReady/i.test(name2)) {
-    kind = "server";
-  } else if (status !== void 0) {
-    kind = classifyProviderHttpStatus(status, message);
-  } else if (exactProviderCode === "invalid_image") {
-    kind = "bad_request";
-  } else if (bodySaysContextOverflow(message)) {
-    kind = "context_overflow";
-  } else {
-    kind = vendorTypeKind(message) ?? "network";
-  }
-  const retryAfterMs = parseRetryAfterMs(input.retryAfter ?? vendorRetryAfter(error), input.now ?? Date.now());
-  const shouldRetry = parseShouldRetry(vendorHeader(error, ["x-should-retry"]));
-  const fields2 = error;
-  const detail = carriesBody(message) ? vendorDetail(message) : structuredVendorDetail({
-    message,
-    type: fields2?.type,
-    code: exactProviderCode,
-    param: fields2?.param,
-    requestId: fields2?.requestID ?? vendorHeader(error, REQUEST_ID_HEADERS)
-  });
-  return new ProviderRequestError({
-    kind,
-    providerId: input.providerId,
-    ...exactProviderCode !== void 0 ? { providerCode: exactProviderCode } : {},
-    ...status !== void 0 ? { status } : {},
-    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
-    ...detail !== void 0 ? { detail } : {},
-    ...shouldRetry !== void 0 ? { shouldRetry } : {}
-  });
-}
-__name(providerVendorError, "providerVendorError");
-function carriesBody(message) {
-  const rest = message.replace(/^\d{3}\s+/, "").trim();
-  if (!rest.startsWith("{"))
-    return false;
-  try {
-    const parsed = JSON.parse(rest);
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
-  } catch {
-    return false;
-  }
-}
-__name(carriesBody, "carriesBody");
-function parsedBody(body) {
-  let decoded = body;
-  if (typeof decoded === "string") {
-    try {
-      decoded = JSON.parse(decoded);
-    } catch {
-      return void 0;
-    }
-  }
-  return typeof decoded === "object" && decoded !== null && !Array.isArray(decoded) ? decoded : void 0;
-}
-__name(parsedBody, "parsedBody");
-function bodyErrorFields(body) {
-  const inner = body && typeof body.error === "object" && body.error !== null ? body.error : void 0;
-  if (!inner)
-    return {};
-  return {
-    type: inner.type ?? (typeof inner.status === "string" ? inner.status : void 0),
-    code: typeof inner.code === "string" ? inner.code : void 0,
-    param: inner.param
-  };
-}
-__name(bodyErrorFields, "bodyErrorFields");
-function providerHttpError(input) {
-  const kind = classifyProviderHttpStatus(input.status, input.body);
-  const retryAfterMs = parseRetryAfterMs(input.retryAfter, input.now ?? Date.now());
-  const body = parsedBody(input.body);
-  const bodyError = bodyErrorFields(body);
-  const detail = body ? structuredVendorDetail({
-    message: vendorDetail(input.body),
-    type: bodyError.type,
-    code: bodyError.code,
-    param: bodyError.param,
-    requestId: input.requestId
-  }) : vendorDetail(input.body);
-  const exactProviderCode = providerCode(input.body);
-  const shouldRetry = parseShouldRetry(input.shouldRetry);
-  return new ProviderRequestError({
-    kind,
-    providerId: input.providerId,
-    ...exactProviderCode !== void 0 ? { providerCode: exactProviderCode } : {},
-    status: input.status,
-    ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
-    ...detail !== void 0 ? { detail } : {},
-    ...shouldRetry !== void 0 ? { shouldRetry } : {}
-  });
-}
-__name(providerHttpError, "providerHttpError");
-
-// ../sdk/dist/provider/capabilities.js
-var PERMISSIVE_PROVIDER_CAPABILITIES = {
-  supportsTools: true,
-  supportsStreaming: true,
-  supportsFunctionCalling: true,
-  supportsVision: true,
-  supportsDocuments: true,
-  supportsToolResultImages: true,
-  supportsToolResultDocuments: true
-};
-function resolveProviderCapabilities(provider) {
-  const declared = provider.capabilities;
-  return {
-    supportsTools: declared?.supportsTools ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsTools,
-    supportsStreaming: declared?.supportsStreaming ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsStreaming,
-    supportsFunctionCalling: declared?.supportsFunctionCalling ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsFunctionCalling,
-    supportsVision: declared?.supportsVision ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsVision,
-    supportsDocuments: declared?.supportsDocuments ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsDocuments,
-    supportsToolResultImages: declared?.supportsToolResultImages ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsToolResultImages,
-    supportsToolResultDocuments: declared?.supportsToolResultDocuments ?? PERMISSIVE_PROVIDER_CAPABILITIES.supportsToolResultDocuments,
-    maxOutputTokens: declared?.maxOutputTokens
-  };
-}
-__name(resolveProviderCapabilities, "resolveProviderCapabilities");
-function assertNativeStructuredOutputSupported(provider, params) {
-  if (params.responseFormat?.type === "json_schema" && provider.capabilities?.supportsNativeStructuredOutput !== true) {
-    throw new ProviderRequestError({
-      kind: "bad_request",
-      providerId: provider.id,
-      providerCode: "native_structured_output_unsupported",
-      detail: "Native JSON Schema output requires a provider that declares supportsNativeStructuredOutput: true."
-    });
-  }
-}
-__name(assertNativeStructuredOutputSupported, "assertNativeStructuredOutputSupported");
-function assertHostedWebSearchSupported(provider, params) {
-  if (params.webSearch && (provider.capabilities?.supportsHostedWebSearch !== true || provider.supportsHostedWebSearchFor && !provider.supportsHostedWebSearchFor(params.model ?? "", params.webSearch.mode))) {
-    throw new ProviderRequestError({
-      kind: "bad_request",
-      providerId: provider.id,
-      providerCode: "hosted_web_search_unsupported",
-      detail: "This provider does not support hosted web search. Disable web.search or select a supported provider."
-    });
-  }
-}
-__name(assertHostedWebSearchSupported, "assertHostedWebSearchSupported");
-
 // ../sdk/dist/provider/idle-timeout.js
 var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 5 * 6e4;
 var MAX_TIMER_DELAY_MS = 2147483647;
@@ -26874,6 +26913,9 @@ function withStreamIdleTimeout(provider, options) {
     ...provider.supportsHostedWebSearchFor ? {
       supportsHostedWebSearchFor: /* @__PURE__ */ __name((model, mode) => provider.supportsHostedWebSearchFor?.(model, mode) ?? false, "supportsHostedWebSearchFor")
     } : {},
+    ...provider.supportsImageInputFor ? {
+      supportsImageInputFor: /* @__PURE__ */ __name((model) => provider.supportsImageInputFor?.(model) ?? true, "supportsImageInputFor")
+    } : {},
     ...provider.reasoningEffortLevelsFor ? {
       reasoningEffortLevelsFor: /* @__PURE__ */ __name((model, thinking) => provider.reasoningEffortLevelsFor?.(model, thinking), "reasoningEffortLevelsFor")
     } : {},
@@ -28450,6 +28492,69 @@ function withDefined(key5, value) {
 }
 __name(withDefined, "withDefined");
 
+// ../sdk/dist/runtime/query/deferred-sandbox.js
+var SandboxAcquisitionStopped = class extends Error {
+  static {
+    __name(this, "SandboxAcquisitionStopped");
+  }
+  acquisition;
+  constructor(acquisition) {
+    super(acquisition.kind === "timed_out" ? acquisition.error.message : "Sandbox acquisition was cancelled before it finished");
+    this.name = "SandboxAcquisitionStopped";
+    this.acquisition = acquisition;
+  }
+};
+function createDeferredSandbox(options) {
+  const controller = new AbortController();
+  const relay = /* @__PURE__ */ __name(() => controller.abort(options.turnSignal.reason), "relay");
+  if (options.turnSignal.aborted)
+    relay();
+  else
+    options.turnSignal.addEventListener("abort", relay, { once: true });
+  let outcome;
+  const start = /* @__PURE__ */ __name(() => {
+    outcome ??= (async () => {
+      try {
+        const acquired = await options.acquire(controller.signal);
+        if (acquired.kind === "created")
+          await options.publish(acquired.sandbox);
+        return acquired;
+      } catch (error) {
+        return { kind: "failed", error };
+      }
+    })();
+    return outcome;
+  }, "start");
+  const rethrow = /* @__PURE__ */ __name((settled) => {
+    if (settled.kind === "created")
+      return;
+    if (settled.kind === "failed")
+      throw settled.error;
+    throw new SandboxAcquisitionStopped(settled);
+  }, "rethrow");
+  return {
+    start: /* @__PURE__ */ __name(() => {
+      void start();
+    }, "start"),
+    ensure: /* @__PURE__ */ __name(async () => rethrow(await start()), "ensure"),
+    settle: /* @__PURE__ */ __name(async () => {
+      if (outcome === void 0)
+        return;
+      const settled = await outcome;
+      if (options.turnSignal.aborted)
+        return;
+      rethrow(settled);
+    }, "settle"),
+    cancel: /* @__PURE__ */ __name(async () => {
+      options.turnSignal.removeEventListener("abort", relay);
+      controller.abort();
+      if (outcome !== void 0)
+        await outcome;
+    }, "cancel")
+  };
+}
+__name(createDeferredSandbox, "createDeferredSandbox");
+
 // ../sdk/dist/store/memory/digest.js
 import { createHash as createHash9 } from "node:crypto";
 var KNOWLEDGE_TAG_PREFIX = "knowledge:";
@@ -29722,13 +29827,23 @@ var rejectedUserImageMarker = /* @__PURE__ */ __name(() => "[image omitted from
 var rejectedToolImageMarker = /* @__PURE__ */ __name(() => `[image omitted from this model request because the provider rejected this image. ${toolRecovery} Correct the image source before presenting it again.]`, "rejectedToolImageMarker");
 var invalidUserImageMarker = /* @__PURE__ */ __name(() => "[image omitted from this model request because its encoded bytes are not a complete supported raster matching the declared media type; attach a corrected image in a new message if it is still needed.]", "invalidUserImageMarker");
 var invalidToolImageMarker = /* @__PURE__ */ __name(() => `[image omitted from this model request because the producing tool returned encoded bytes that are not a complete supported raster matching the declared media type. ${toolRecovery} Correct the image source before presenting it again.]`, "invalidToolImageMarker");
+function describeEncodedSize(base64Length) {
+  const bytes = Math.floor(base64Length * 3 / 4);
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+__name(describeEncodedSize, "describeEncodedSize");
+var textOnlyImageMarker = /* @__PURE__ */ __name((mediaType, base64Length) => `[image omitted: the current model cannot read images${mediaType ? ` (${mediaType}, ${describeEncodedSize(base64Length)})` : ""}]`, "textOnlyImageMarker");
 function assertInlineAttachment(attachment) {
   if (attachment.type === "stored") {
     throw new TypeError("Cannot budget an unresolved stored attachment; resolve attachment bytes before building a model request");
   }
 }
 __name(assertInlineAttachment, "assertInlineAttachment");
-function collectRichOccurrences(messages) {
+function collectRichOccurrences(messages, imagesReadable) {
   const occurrences = [];
   for (const [messageIndex, message] of messages.entries()) {
     if (message.role === "user") {
@@ -29740,7 +29855,8 @@ function collectRichOccurrences(messages) {
           source: "user",
           kind: attachment.type === "document" ? "document" : "image",
           bytes: attachment.data.length,
-          reason: attachment.type !== "document" && attachment.modelOmission?.reason === "invalid-image" ? "invalid-image" : attachment.type !== "document" && attachment.modelOmission?.reason === "provider-rejected" ? "provider-rejected" : "budget"
+          mediaType: attachment.mediaType,
+          reason: attachment.type !== "document" && !imagesReadable ? "model-text-only" : attachment.type !== "document" && attachment.modelOmission?.reason === "invalid-image" ? "invalid-image" : attachment.type !== "document" && attachment.modelOmission?.reason === "provider-rejected" ? "provider-rejected" : "budget"
         });
       }
       continue;
@@ -29756,7 +29872,8 @@ function collectRichOccurrences(messages) {
         source: "tool",
         kind: block.type,
         bytes: block.data.length,
-        reason: block.type === "image" && block.modelOmission?.reason === "invalid-image" ? "invalid-image" : block.type === "image" && block.modelOmission?.reason === "provider-rejected" ? "provider-rejected" : "budget"
+        mediaType: block.mediaType,
+        reason: block.type === "image" && !imagesReadable ? "model-text-only" : block.type === "image" && block.modelOmission?.reason === "invalid-image" ? "invalid-image" : block.type === "image" && block.modelOmission?.reason === "provider-rejected" ? "provider-rejected" : "budget"
       });
     }
   }
@@ -29773,12 +29890,12 @@ ${joined3}` : joined3;
 }
 __name(appendTextMarkers, "appendTextMarkers");
 function appendMarkers(content, occurrences) {
-  const markers = occurrences.map((occurrence) => occurrence.reason === "provider-rejected" ? rejectedUserImageMarker() : occurrence.reason === "invalid-image" ? invalidUserImageMarker() : userMarker(occurrence.kind));
+  const markers = occurrences.map((occurrence) => occurrence.reason === "model-text-only" ? textOnlyImageMarker(occurrence.mediaType, occurrence.bytes) : occurrence.reason === "provider-rejected" ? rejectedUserImageMarker() : occurrence.reason === "invalid-image" ? invalidUserImageMarker() : userMarker(occurrence.kind));
   return appendTextMarkers(content, markers);
 }
 __name(appendMarkers, "appendMarkers");
-function projectRequestRichContent(messages, maxBytes) {
-  const occurrences = collectRichOccurrences(messages);
+function projectRequestRichContent(messages, maxBytes, options = {}) {
+  const occurrences = collectRichOccurrences(messages, options.imagesReadable ?? true);
   if (occurrences.length === 0)
     return messages;
   const omitted = /* @__PURE__ */ new Map();
@@ -29791,9 +29908,8 @@ function projectRequestRichContent(messages, maxBytes) {
     byItem.set(occurrence.itemIndex, occurrence);
   }, "omit");
   for (const occurrence of occurrences) {
-    if (occurrence.reason === "provider-rejected" || occurrence.reason === "invalid-image") {
+    if (occurrence.reason !== "budget")
       omit(occurrence);
-    }
   }
   let total = occurrences.reduce((sum, occurrence) => sum + (occurrence.reason === "budget" ? occurrence.bytes : 0), 0);
   if (maxBytes > 0 && total > maxBytes) {
@@ -29827,7 +29943,7 @@ function projectRequestRichContent(messages, maxBytes) {
         const occurrence = byItem.get(itemIndex);
         return occurrence?.source === "tool" ? {
           type: "text",
-          text: occurrence.reason === "provider-rejected" ? rejectedToolImageMarker() : occurrence.reason === "invalid-image" ? invalidToolImageMarker() : toolMarker(occurrence.kind)
+          text: occurrence.reason === "model-text-only" ? textOnlyImageMarker(occurrence.mediaType, occurrence.bytes) : occurrence.reason === "provider-rejected" ? rejectedToolImageMarker() : occurrence.reason === "invalid-image" ? invalidToolImageMarker() : toolMarker(occurrence.kind)
         } : block;
       });
       return { ...message, content };
@@ -29836,6 +29952,23 @@ function projectRequestRichContent(messages, maxBytes) {
   });
 }
 __name(projectRequestRichContent, "projectRequestRichContent");
+function requestHasImages(messages) {
+  for (const message of messages) {
+    if (message.role === "user") {
+      for (const attachment of message.attachments ?? []) {
+        if (attachment.type !== "stored" && attachment.type !== "document")
+          return true;
+      }
+      continue;
+    }
+    if (message.role !== "tool" || !Array.isArray(message.content))
+      continue;
+    if (message.content.some((block) => block.type === "image"))
+      return true;
+  }
+  return false;
+}
+__name(requestHasImages, "requestHasImages");
 function sameImage(image, identity) {
   return image.data === identity.data && image.mediaType === identity.mediaType;
 }
@@ -30870,6 +31003,19 @@ function* conversationExcerpt(messages) {
   }
 }
 __name(conversationExcerpt, "conversationExcerpt");
+var MAX_VERIFIER_HEAD_TRUNCATIONS = 3;
+var EXCERPT_TRUNCATED_PLACEHOLDER = "[earlier conversation truncated for compaction retry]";
+function truncateExcerptHead(excerpt2) {
+  const body = excerpt2.startsWith(EXCERPT_TRUNCATED_PLACEHOLDER) ? excerpt2.slice(EXCERPT_TRUNCATED_PLACEHOLDER.length).trimStart() : excerpt2;
+  let kept = body.slice(Math.floor(body.length / 2));
+  const first = kept.charCodeAt(0);
+  if (first >= 56320 && first <= 57343)
+    kept = kept.slice(1);
+  return `${EXCERPT_TRUNCATED_PLACEHOLDER}
+
+${kept}`;
+}
+__name(truncateExcerptHead, "truncateExcerptHead");
 function truncateMessages(messages, budget) {
   if (budget <= 0)
     return "";
@@ -30927,29 +31073,46 @@ async function buildVerifiedSummaryWithProvider(manager, olderMessages, provider
   if (!conversationExcerpt2.trim()) {
     return serialized;
   }
-  const verificationMessages = [
-    {
-      role: "system",
-      content: withInstructions(VERIFICATION_PROMPT, instructions)
-    },
-    {
-      role: "user",
-      content: `## Structured State
+  let excerpt2 = conversationExcerpt2;
+  let truncations = 0;
+  let response;
+  for (; ; ) {
+    const verificationMessages = [
+      {
+        role: "system",
+        content: withInstructions(VERIFICATION_PROMPT, instructions)
+      },
+      {
+        role: "user",
+        content: `## Structured State
 
 ${serialized}
 
 ## Conversation Excerpt
 
-${conversationExcerpt2}`
+${excerpt2}`
+      }
+    ];
+    try {
+      response = await collectChatCompletion(provider.chatStream({
+        model: model ?? "",
+        messages: verificationMessages,
+        maxTokens: config.llmVerificationMaxTokens,
+        temperature: 0,
+        ...signal ? { signal } : {}
+      }));
+      break;
+    } catch (error) {
+      if (signal?.aborted)
+        throw error;
+      if (classifyProviderError(error).code !== "context_length_exceeded")
+        throw error;
+      if (truncations >= MAX_VERIFIER_HEAD_TRUNCATIONS)
+        return serialized;
+      truncations++;
+      excerpt2 = truncateExcerptHead(excerpt2);
     }
-  ];
-  const response = await collectChatCompletion(provider.chatStream({
-    model: model ?? "",
-    messages: verificationMessages,
-    maxTokens: config.llmVerificationMaxTokens,
-    temperature: 0,
-    ...signal ? { signal } : {}
-  }));
+  }
   onUsage?.(response.usage);
   const responseText = response.message.content?.trim() ?? "";
   if (responseText === "COMPLETE" || responseText.length === 0) {
@@ -31172,8 +31335,7 @@ __name(resolveTaskModel, "resolveTaskModel");
 var COMPACTION_FAILURE_LIMIT = 3;
 var COMPACTION_REFILL_ITERATIONS = 3;
 var COMPACTION_REFILL_LIMIT = 3;
-var COMPACTION_REFILL_MESSAGE = "The context filled up again right after being compacted, three times in a row. A file or tool output is probably too big for the window: read it in smaller parts, or start fresh with /clear.";
-var COMPACTION_FAILURE_MESSAGE = "Automatic compaction stopped after three failed attempts. Run /compact yourself, or start fresh with /clear.";
+var COMPACTION_REFILL_MESSAGE = "The context filled up again right after being compacted, three times in a row. A file being read or a tool output is probably too large for the context window. Try reading it in smaller parts.";
 var CompactionBreaker = class {
   static {
     __name(this, "CompactionBreaker");
@@ -31428,11 +31590,46 @@ function measureContext(ctx) {
   return { tokens: estimateTokens(ctx), source: "estimate" };
 }
 __name(measureContext, "measureContext");
-async function relieveOverflow(ctx) {
+var OVERFLOW_RELIEF_LIMIT = 2;
+var DEEPER_PASS_MIN_GROUPS = 3;
+function roundGroups(messages) {
+  let groups = 0;
+  for (const message of messages)
+    if (message.role === "assistant")
+      groups++;
+  return groups;
+}
+__name(roundGroups, "roundGroups");
+function deepenConfig(config, messages) {
+  let lastAssistant = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "assistant") {
+      lastAssistant = i;
+      break;
+    }
+  }
+  const deeper = { ...config, keepRecentToolResults: 0 };
+  if (lastAssistant < 0 || roundGroups(messages) < DEEPER_PASS_MIN_GROUPS)
+    return deeper;
+  const newest = messages.slice(lastAssistant);
+  if (config.keepRecentTokens !== void 0) {
+    return {
+      ...deeper,
+      keepRecentTokens: Math.max(1, Math.min(config.keepRecentTokens, estimateMessagesTokens(newest)))
+    };
+  }
+  return {
+    ...deeper,
+    keepRecentMessages: Math.max(1, Math.min(config.keepRecentMessages, newest.length))
+  };
+}
+__name(deepenConfig, "deepenConfig");
+async function relieveOverflow(ctx, options = {}) {
+  clearCompactionErrorNote(ctx);
   const before = ctx.recorder.messages.length;
   const beforeChars = totalChars(ctx.recorder.messages);
   const beforeTokens = estimateMessagesTokens(ctx.recorder.messages);
-  await runCompactionCheck(ctx, { force: true });
+  await runCompactionCheck(ctx, { force: true, ...options.deeper ? { deeper: true } : {} });
   const shed = beforeChars - totalChars(ctx.recorder.messages);
   const tokensShed = beforeTokens - estimateMessagesTokens(ctx.recorder.messages);
   const meaningful = Math.max(MIN_RELIEF_TOKENS, beforeTokens * MIN_RELIEF_FRACTION);
@@ -31456,6 +31653,23 @@ async function relieveOverflow(ctx) {
   return true;
 }
 __name(relieveOverflow, "relieveOverflow");
+var compactionErrors = /* @__PURE__ */ new WeakMap();
+var MAX_COMPACTION_CAUSE_CHARS = 300;
+var AUTOMATIC_COMPACTION_FAILED = " \xB7 automatic compaction failed: ";
+function noteCompactionError(ctx, error) {
+  const text9 = error instanceof Error ? error.message : String(error);
+  if (text9.length > 0)
+    compactionErrors.set(ctx.recorder, text9.slice(0, MAX_COMPACTION_CAUSE_CHARS));
+}
+__name(noteCompactionError, "noteCompactionError");
+function compactionErrorNote(ctx) {
+  return compactionErrors.get(ctx.recorder);
+}
+__name(compactionErrorNote, "compactionErrorNote");
+function clearCompactionErrorNote(ctx) {
+  compactionErrors.delete(ctx.recorder);
+}
+__name(clearCompactionErrorNote, "clearCompactionErrorNote");
 function totalChars(messages) {
   let total = 0;
   for (const msg of messages)
@@ -31525,6 +31739,7 @@ async function applyReducer(ctx, reducer, reduction, measurement) {
       "namzu.runtime.reason": reduction.reason,
       "exception.message": message
     });
+    noteCompactionError(ctx, error);
     await declined(ctx, "reducer_threw", before, message);
     return;
   }
@@ -31622,11 +31837,12 @@ async function runCompactionCheck(ctx, options) {
 }
 __name(runCompactionCheck, "runCompactionCheck");
 async function runCompactionCheckInner(ctx, pass, options) {
-  const config = ctx.compactionConfig;
-  if (!config)
+  const configured = ctx.compactionConfig;
+  if (!configured)
     return;
-  if (config.strategy === "disabled")
+  if (configured.strategy === "disabled")
     return;
+  const config = options?.deeper ? deepenConfig(configured, ctx.recorder.messages) : configured;
   const measured2 = measureContext(ctx);
   const estimatedTokens = measured2.tokens;
   const window2 = activeContextWindow(ctx);
@@ -31649,8 +31865,7 @@ async function runCompactionCheckInner(ctx, pass, options) {
         turnId: ctx.recorder.turnId,
         iteration: ctx.recorder.currentIteration,
         cause: "breaker_open",
-        messages: ctx.recorder.messages.length,
-        error: COMPACTION_FAILURE_MESSAGE
+        messages: ctx.recorder.messages.length
       });
     }
     return;
@@ -31803,24 +32018,35 @@ async function runCompactionCheckInner(ctx, pass, options) {
   let compactedContent;
   if (config.llmVerification && manager.slotCount() < config.richStateThreshold) {
     const compactionModel = resolveTaskModel("compaction", ctx.taskRouter, ctx.turnConfig.model);
-    compactedContent = await buildVerifiedSummaryWithBoundedProvider(
-      manager,
-      olderMessages,
-      ctx.provider,
-      config,
-      (usage2) => ctx.recorder.accumulateUsage(usage2, {
-        providerId: ctx.recorder.servingProviderId,
-        model: compactionModel
-      }),
-      // The one model call a turn makes that the user never asked for. It
-      // reads a transcript and writes a summary, which is the cheapest
-      // thing a small model does well, and it fires on exactly the long
-      // runs where the primary model is most expensive. `taskRouter` had
-      // been accepted, validated and threaded through four types since it
-      // was added, and nothing ever consulted it.
-      compactionModel,
-      ctx.abortController.signal
-    );
+    try {
+      compactedContent = await buildVerifiedSummaryWithBoundedProvider(
+        manager,
+        olderMessages,
+        ctx.provider,
+        config,
+        (usage2) => ctx.recorder.accumulateUsage(usage2, {
+          providerId: ctx.recorder.servingProviderId,
+          model: compactionModel
+        }),
+        // The one model call a turn makes that the user never asked for. It
+        // reads a transcript and writes a summary, which is the cheapest
+        // thing a small model does well, and it fires on exactly the long
+        // runs where the primary model is most expensive. `taskRouter` had
+        // been accepted, validated and threaded through four types since it
+        // was added, and nothing ever consulted it.
+        compactionModel,
+        ctx.abortController.signal
+      );
+    } catch (error) {
+      if (ctx.abortController.signal.aborted)
+        throw error;
+      noteCompactionError(ctx, error);
+      ctx.log.warn("The compaction summary call failed \u2014 using the extracted state alone", {
+        [NAMZU.TURN_ID]: ctx.recorder.turnId,
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
+      compactedContent = serializeState(manager.getState());
+    }
   } else {
     compactedContent = serializeState(manager.getState());
   }
@@ -33276,6 +33502,45 @@ async function* runToolReview(ctx, response, iterationNum) {
 }
 __name(runToolReview, "runToolReview");
 
+// ../sdk/dist/provider/image-input-refusal.js
+var IMAGE_INPUT_REFUSAL_PATTERNS = [
+  // Zen: "Beam supports text input only. This conversation contains an image."
+  /\btext\s+inputs?\s+only\b/i,
+  /\bonly\s+(?:supports?|accepts?)\s+text\s+inputs?\b/i,
+  /\bonly\s+text\s+inputs?\s+(?:is|are)\s+(?:supported|accepted|allowed)\b/i,
+  // "This model is text-only", "a text-only model"
+  /\btext[- ]only\s+model\b/i,
+  /\bmodel\b[^.;]{0,40}\bis\s+(?:a\s+)?text[- ]only\b/i,
+  // Local model servers: "<model> does not support images", "Model does not
+  // support images. Please use a model that does." Also "doesn't support vision",
+  // "does not support image input", "does not support multimodal inputs".
+  /\b(?:does\s?n[o'’]t|do\s+not|cannot|can[’']t)\s+(?:support|accept)\s+(?:images|vision)\b(?![/\w-])/i,
+  /\b(?:does\s?n[o'’]t|do\s+not|cannot|can[’']t)\s+(?:support|accept|process|handle)\s+(?:image|vision|multimodal|visual)\s+inputs?\b/i,
+  // A local inference server: "image input is not supported - hint: ... mmproj". The
+  // sentence must end there or name the model: "image input is not supported
+  // on streaming" is a restriction of the endpoint, not of the model.
+  /\b(?:image|vision|multimodal)\s+inputs?\s+(?:is|are)\s+(?:not\s+supported|unsupported)(?:\s+(?:by|for)\s+(?:this|the)\s+model)?\s*(?:$|[.;:,!)\-])/i,
+  /\bimages\s+(?:is|are)\s+not\s+supported(?:\s+(?:by|for)\s+(?:this|the)\s+model)?\s*(?:$|[.;:,!)\-])/i,
+  // A serving engine: "<model> is not a multimodal model"
+  /\bis\s+not\s+a\s+(?:multimodal|vision)\s+model\b/i,
+  // A chat-completions API: "Invalid content type. image_url is only supported by certain models."
+  /\bimage_url\b.{0,40}\bonly\s+supported\s+by\s+certain\s+models\b/i,
+  // A chat-completions server that only knows text parts: "unknown variant `image_url`, expected `text`"
+  /\bunknown\s+variant\s+\W?image_url\W?,?\s+expected\s+\W?text\b/i
+];
+function isImageInputRefusalMessage(text9) {
+  if (!text9)
+    return false;
+  return IMAGE_INPUT_REFUSAL_PATTERNS.some((pattern) => pattern.test(text9));
+}
+__name(isImageInputRefusalMessage, "isImageInputRefusalMessage");
+function isImageInputRefusal(error) {
+  if (!isProviderRequestError(error) || error.kind !== "bad_request")
+    return false;
+  return isImageInputRefusalMessage(error.detail ?? error.message);
+}
+__name(isImageInputRefusal, "isImageInputRefusal");
+
 // ../sdk/dist/runtime/query/iteration/provider-rejected-image.js
 var IMAGE_REJECTION_PATTERNS = [
   /\binvalid[_ -]?image\b/i,
@@ -33292,6 +33557,10 @@ function classifyProviderRejectedImageError(error) {
   return IMAGE_REJECTION_PATTERNS.some((pattern) => pattern.test(detail)) ? "heuristic" : null;
 }
 __name(classifyProviderRejectedImageError, "classifyProviderRejectedImageError");
+function isProviderRejectedImageError(error) {
+  return classifyProviderRejectedImageError(error) !== null;
+}
+__name(isProviderRejectedImageError, "isProviderRejectedImageError");
 function isAcceptedChunk(chunk) {
   if (chunk.retry !== void 0 || chunk.fallback !== void 0 || chunk.error !== void 0) {
     return false;
@@ -33304,17 +33573,20 @@ function throwIfAborted(signal) {
     throw signal.reason;
 }
 __name(throwIfAborted, "throwIfAborted");
-async function* streamWithProviderRejectedImageRecovery(provider, params, onAccepted, onRequest) {
+async function* streamWithProviderRejectedImageRecovery(provider, params, onAccepted, onRequest, textOnly, repair) {
+  const session = repair?.session();
+  const send = /* @__PURE__ */ __name((request) => repair ? repair.stream(provider, request, session) : provider.chatStream(request), "send");
   const candidate = findSingleRequestImage(params.messages);
   onRequest?.(params.messages);
-  if (candidate === null) {
-    yield* provider.chatStream(params);
+  if (candidate === null && !requestHasImages(params.messages)) {
+    yield* send(params);
     return;
   }
   let produced = false;
   let confidence = null;
+  let refused = null;
   try {
-    for await (const chunk of provider.chatStream(params)) {
+    for await (const chunk of send(params)) {
       if (isAcceptedChunk(chunk))
         produced = true;
       yield chunk;
@@ -33322,11 +33594,41 @@ async function* streamWithProviderRejectedImageRecovery(provider, params, onAcce
     return;
   } catch (error) {
     throwIfAborted(params.signal);
+    if (produced)
+      throw error;
     confidence = classifyProviderRejectedImageError(error);
-    if (produced || confidence === null)
+    if (confidence === null && isImageInputRefusal(error)) {
+      const served = textOnly?.servedBy?.();
+      refused = {
+        providerId: served?.providerId ?? provider.id,
+        model: served?.model ?? params.model
+      };
+    } else if (confidence === null || candidate === null) {
       throw error;
+    }
   }
   throwIfAborted(params.signal);
+  if (refused !== null) {
+    const messages = projectRequestRichContent(params.messages, 0, { imagesReadable: false });
+    onRequest?.(messages);
+    let accepted2 = false;
+    let reportedError = false;
+    for await (const chunk of send({ ...params, messages })) {
+      if (chunk.error !== void 0)
+        reportedError = true;
+      if (!accepted2 && isAcceptedChunk(chunk)) {
+        throwIfAborted(params.signal);
+        await textOnly?.onAccepted(refused);
+        accepted2 = true;
+      }
+      yield chunk;
+    }
+    if (!accepted2 && !reportedError)
+      await textOnly?.onAccepted(refused);
+    return;
+  }
+  if (candidate === null)
+    return;
   const retryParams = {
     ...params,
     messages: projectRequestWithoutImage(params.messages, candidate)
@@ -33334,7 +33636,7 @@ async function* streamWithProviderRejectedImageRecovery(provider, params, onAcce
   let accepted = false;
   let retryReportedError = false;
   onRequest?.(retryParams.messages);
-  for await (const chunk of provider.chatStream(retryParams)) {
+  for await (const chunk of send(retryParams)) {
     if (chunk.error !== void 0)
       retryReportedError = true;
     if (!accepted && isAcceptedChunk(chunk)) {
@@ -33353,6 +33655,552 @@ async function* streamWithProviderRejectedImageRecovery(provider, params, onAcce
 }
 __name(streamWithProviderRejectedImageRecovery, "streamWithProviderRejectedImageRecovery");
 
+// ../sdk/dist/runtime/query/iteration/request-repair.js
+import { createHash as createHash14 } from "node:crypto";
+var MAX_REPAIRS_PER_REQUEST = 5;
+var MAX_STRIPS_PER_INDEX = 3;
+var GENERIC_MEDIA_LIMITS = [510, 255, 127];
+var PARAMETER_CODES = /* @__PURE__ */ new Set([
+  "unsupported_parameter",
+  "unsupported_value",
+  "unknown_parameter"
+]);
+var REASONING_CODES = /* @__PURE__ */ new Set([
+  "invalid_encrypted_content",
+  "invalid_reasoning",
+  "invalid_signature"
+]);
+var TOOL_PAIRING = /\btool_use\b.{0,120}\btool_result\b|\btool_result\b.{0,120}\btool_use\b|unexpected\s+`?tool_use_id`?|tool_use\s+ids?\s+must\s+be\s+unique|\btool_call_id\b|role\s+'tool'\s+must\s+be\s+a\s+response|'tool_calls'\s+must\s+be\s+followed|Expected\s+toolResult\s+blocks|function\s+call\s+turn\s+comes\s+immediately|number\s+of\s+function\s+response\s+parts/i;
+var REASONING = /\bthought[_ ]?signature\b|`?signature`?\s+in\s+`?(?:thinking|redacted_thinking)|\b(?:thinking|redacted_thinking)\s+blocks?\b.{0,160}\b(?:cannot|can['’]t|must|invalid|modified|expected)|\bexpected\s+`?(?:thinking|redacted_thinking)`?|\bencrypted[_ ]content\b|\breasoning\s+item\b|\bitem\s+'rs_[^']*'|\bof\s+type\s+'reasoning'/i;
+var TOOL_SCHEMA_PATH = /\b(?:tools?|functions?)[.[]\s*\d+|input_schema|\.properties\b|json\s+schema/i;
+var REFUSAL = "(?:unsupported|not\\s+supported|does\\s?n[o']t\\s+support|do\\s+not\\s+support|unrecognized|unknown\\s+(?:request\\s+)?(?:parameter|argument|field)|not\\s+allowed|deprecated|only\\s+the\\s+default)";
+var PARAMETER_NAMES = {
+  effort: "(?:reasoning[_. -]?effort|effort)",
+  thinking: "thinking",
+  temperature: "temperature",
+  topP: "top[_ ]?p",
+  responseFormat: "(?:response_format|output_config(?:\\.format)?|json_schema|json_object|structured\\s+output)"
+};
+var PARAMETER_PATTERNS = Object.fromEntries(Object.entries(PARAMETER_NAMES).map(([name2, token]) => [
+  name2,
+  {
+    named: new RegExp(`\\b${token}\\b`, "i"),
+    refused: new RegExp(`${REFUSAL}.{0,80}\\b${token}\\b|\\b${token}\\b.{0,80}${REFUSAL}`, "i")
+  }
+]));
+var BOTH_SAMPLING = /temperature.{0,60}top[_ ]?p.{0,80}(?:cannot|can['’]t|may\s+not|should\s+not).{0,20}(?:both|together)/i;
+var IMAGE_FAULT = /\b(?:images?|pictures?|photos?)\b.{0,100}\b(?:too\s+(?:large|big)|exceeds?|larger\s+than|maximum\s+(?:size|dimensions?)|dimensions?|(?:could|can)\s?not\s+be\s+(?:processed|decoded|loaded|read|fetched|downloaded)|failed\s+to\s+(?:process|decode|load|read|download)|unsupported|not\s+supported|corrupt\w*|malformed|truncated|invalid)\b|\b(?:(?:could|can)\s?not|failed\s+to|unable\s+to)\s+(?:process|decode|load|read|download|fetch)\b.{0,60}\b(?:images?|pictures?)\b|\bunsupported\s+(?:image|media)\b|\binvalid\s+image\b/i;
+var DOCUMENT_FAULT = /\bdocument_block\b|\b(?:documents?|pdfs?)\b.{0,80}\b(?:too\s+(?:large|big)|exceeds?\s+(?:the\s+)?(?:maximum|size|page)|page\s+limit|password|corrupt\w*|(?:could|can)\s?not\s+be\s+(?:processed|read|decoded)|failed\s+to\s+(?:process|read|decode))\b|\bpassword[- ]protected\s+pdf\b|\bpdf\b.{0,40}\bpages?\b.{0,20}\b(?:limit|maximum|exceeds?)\b/i;
+var GENERIC_MEDIA = /\bunprocessable\b.{0,100}\b(?:images?|media|documents?)\b|\b(?:images?|media|documents?)\b.{0,100}\bunprocessable\b|\btoo\s+many\s+(?:images?|documents?|media|attachments?)\b|\bmedia_budget\b|\bimage_block\b/i;
+var NAMES_MEDIA = /\b(?:images?|pictures?|photos?|documents?|pdfs?|media|attachments?)\b/i;
+function wireIndexes(text9) {
+  const both = /\bmessages?[.[]\s*(\d+)\s*\]?[.[]\s*content[.[]\s*(\d+)/i.exec(text9);
+  if (both?.[1] !== void 0 && both[2] !== void 0) {
+    return { messageIndex: Number(both[1]), contentIndex: Number(both[2]) };
+  }
+  const only = /\bmessages?[.[]\s*(\d+)\b/i.exec(text9);
+  return only?.[1] !== void 0 ? { messageIndex: Number(only[1]) } : {};
+}
+__name(wireIndexes, "wireIndexes");
+function rejectedParameters(text9, code, params) {
+  if (TOOL_SCHEMA_PATH.test(text9))
+    return [];
+  const structured = code !== void 0 && PARAMETER_CODES.has(code);
+  const set3 = {
+    effort: params.effort !== void 0,
+    thinking: params.thinking !== void 0,
+    temperature: params.temperature !== void 0,
+    topP: params.topP !== void 0,
+    responseFormat: params.responseFormat !== void 0
+  };
+  const found = [];
+  for (const name2 of Object.keys(set3)) {
+    if (!set3[name2])
+      continue;
+    const pattern = PARAMETER_PATTERNS[name2];
+    if (structured ? pattern.named.test(text9) : pattern.refused.test(text9))
+      found.push(name2);
+  }
+  if (found.length === 0 && set3.topP && BOTH_SAMPLING.test(text9))
+    found.push("topP");
+  return found;
+}
+__name(rejectedParameters, "rejectedParameters");
+function requestHasMedia(params) {
+  return listMedia(params.messages).length > 0;
+}
+__name(requestHasMedia, "requestHasMedia");
+function classifyRequestRejection(error, params) {
+  if (!isProviderRequestError(error) || error.kind !== "bad_request")
+    return null;
+  if (error.status !== void 0 && error.status !== 400 && error.status !== 413 && error.status !== 422) {
+    return null;
+  }
+  const text9 = error.detail ?? error.message;
+  const code = error.providerCode;
+  if (code !== void 0 && REASONING_CODES.has(code))
+    return { kind: "reasoning" };
+  if (REASONING.test(text9))
+    return { kind: "reasoning" };
+  if (TOOL_PAIRING.test(text9))
+    return { kind: "tool-pairing" };
+  const parameters = rejectedParameters(text9, code, params);
+  if (parameters.length > 0)
+    return { kind: "parameter", parameters };
+  if (TOOL_SCHEMA_PATH.test(text9))
+    return null;
+  if (code === "invalid_image")
+    return { kind: "media", generic: false, ...wireIndexes(text9) };
+  if (GENERIC_MEDIA.test(text9))
+    return { kind: "media", generic: true };
+  if ((error.status === 413 || error.status === 422) && NAMES_MEDIA.test(text9)) {
+    return requestHasMedia(params) ? { kind: "media", generic: true } : null;
+  }
+  if (IMAGE_FAULT.test(text9) || DOCUMENT_FAULT.test(text9)) {
+    return { kind: "media", generic: false, ...wireIndexes(text9) };
+  }
+  return null;
+}
+__name(classifyRequestRejection, "classifyRequestRejection");
+function isAccepted(chunk) {
+  if (chunk.retry !== void 0 || chunk.fallback !== void 0 || chunk.error !== void 0) {
+    return false;
+  }
+  return Boolean(chunk.delta.content || chunk.delta.toolCalls?.length || chunk.delta.toolCallEnd || chunk.delta.reasoning || chunk.delta.citation || chunk.finishReason !== void 0 || chunk.usage !== void 0 || chunk.replayState !== void 0 || chunk.textParts !== void 0);
+}
+__name(isAccepted, "isAccepted");
+var mediaFingerprint = /* @__PURE__ */ __name((data, mediaType) => createHash14("sha256").update(mediaType).update("\0").update(data).digest("hex"), "mediaFingerprint");
+var FAULT_NOTE = "the provider could not process it. The file may be unsupported or corrupt; do not retry reading it. If you need to inspect it, use a shell command instead.";
+var LIMIT_NOTE = "this conversation holds more files than the provider accepts at once, so the oldest are left out of the request. They are still in the conversation.";
+var removedNote = /* @__PURE__ */ __name((kind, limit) => `[${kind} removed: ${limit ? LIMIT_NOTE : FAULT_NOTE}]`, "removedNote");
+function listMedia(messages) {
+  const slots = [];
+  for (const [messageIndex, message] of messages.entries()) {
+    if (message.role === "user") {
+      for (const [itemIndex, attachment] of (message.attachments ?? []).entries()) {
+        if (attachment.type === "stored")
+          continue;
+        slots.push({
+          messageIndex,
+          itemIndex,
+          source: "user",
+          kind: attachment.type === "document" ? "document" : "image",
+          fingerprint: mediaFingerprint(attachment.data, attachment.mediaType)
+        });
+      }
+    } else if (message.role === "tool" && Array.isArray(message.content)) {
+      for (const [itemIndex, block] of message.content.entries()) {
+        if (block.type !== "image" && block.type !== "document")
+          continue;
+        slots.push({
+          messageIndex,
+          itemIndex,
+          source: "tool",
+          kind: block.type,
+          fingerprint: mediaFingerprint(block.data, block.mediaType)
+        });
+      }
+    }
+  }
+  return slots;
+}
+__name(listMedia, "listMedia");
+function removeMedia(messages, slots, limit) {
+  if (slots.length === 0)
+    return messages;
+  const byMessage = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const items = byMessage.get(slot.messageIndex) ?? /* @__PURE__ */ new Map();
+    items.set(slot.itemIndex, slot);
+    byMessage.set(slot.messageIndex, items);
+  }
+  return messages.map((message, messageIndex) => {
+    const items = byMessage.get(messageIndex);
+    if (!items)
+      return message;
+    if (message.role === "user") {
+      const attachments = message.attachments ?? [];
+      const kept = attachments.filter((_a2, i) => !items.has(i));
+      const notes = [...items.values()].sort((a, b) => a.itemIndex - b.itemIndex).map((slot) => removedNote(slot.kind, limit)).join("\n\n");
+      const { attachments: _drop, ...rest } = message;
+      return {
+        ...rest,
+        content: message.content.length > 0 ? `${message.content}
+
+${notes}` : notes,
+        ...kept.length > 0 ? { attachments: kept } : {}
+      };
+    }
+    if (message.role === "tool" && Array.isArray(message.content)) {
+      const content = message.content.map((block, i) => {
+        const slot = items.get(i);
+        return slot ? { type: "text", text: removedNote(slot.kind, limit) } : block;
+      });
+      return { ...message, content };
+    }
+    return message;
+  });
+}
+__name(removeMedia, "removeMedia");
+function stripReasoning(messages) {
+  let changed = false;
+  const out = messages.map((message) => {
+    if (message.role !== "assistant")
+      return message;
+    const assistant = message;
+    const hasState = assistant.source !== void 0 && assistant.source.replayState !== void 0;
+    if (assistant.reasoning === void 0 && !hasState)
+      return message;
+    changed = true;
+    const { reasoning: _reasoning, source, ...rest } = assistant;
+    if (source === void 0)
+      return rest;
+    const { replayState: _state, ...route } = source;
+    return { ...rest, source: route };
+  });
+  return changed ? out : messages;
+}
+__name(stripReasoning, "stripReasoning");
+function mediaAtWireIndex(messages, slots, family, wireIndex, contentIndex) {
+  if (family !== "anthropic" && family !== "openai")
+    return void 0;
+  const entries2 = [];
+  let inToolRun = false;
+  for (const [index, message2] of messages.entries()) {
+    if (family === "anthropic") {
+      if (message2.role === "system")
+        continue;
+      if (message2.role === "tool") {
+        if (!inToolRun)
+          entries2.push([]);
+        inToolRun = true;
+        entries2[entries2.length - 1]?.push(index);
+        continue;
+      }
+      inToolRun = false;
+    }
+    entries2.push([index]);
+  }
+  const entry = entries2[wireIndex];
+  if (entry === void 0)
+    return void 0;
+  const mine = slots.filter((slot) => entry.includes(slot.messageIndex));
+  if (mine.length === 0)
+    return void 0;
+  if (contentIndex === void 0)
+    return mine;
+  const first = entry[0];
+  const message = first === void 0 ? void 0 : messages[first];
+  if (message?.role === "user" && !(family === "openai" && mine.some((s) => s.source === "tool"))) {
+    const itemIndex = contentIndex - (message.content.length > 0 ? 1 : 0);
+    const hit = mine.filter((slot) => slot.itemIndex === itemIndex);
+    return hit.length > 0 ? hit : mine;
+  }
+  if (family === "anthropic" && message?.role === "tool") {
+    const owner = entry[contentIndex];
+    const hit = owner === void 0 ? [] : mine.filter((slot) => slot.messageIndex === owner);
+    return hit.length > 0 ? hit : mine;
+  }
+  return mine;
+}
+__name(mediaAtWireIndex, "mediaAtWireIndex");
+var emptyLearned = /* @__PURE__ */ __name(() => ({
+  latched: /* @__PURE__ */ new Map(),
+  reasoningOff: /* @__PURE__ */ new Set(),
+  rejectedMedia: /* @__PURE__ */ new Set(),
+  mediaLimit: void 0
+}), "emptyLearned");
+var RequestRepair = class {
+  static {
+    __name(this, "RequestRepair");
+  }
+  hooks;
+  learned = emptyLearned();
+  constructor(hooks = {}) {
+    this.hooks = hooks;
+  }
+  /** A fresh budget for one original request. */
+  session() {
+    return {
+      spent: /* @__PURE__ */ new Set(),
+      stripsByIndex: /* @__PURE__ */ new Map(),
+      pending: emptyLearned(),
+      repairs: 0,
+      removal: void 0
+    };
+  }
+  served(provider, params) {
+    const member = this.hooks.servedBy?.();
+    return {
+      providerId: member?.providerId ?? params.providerRoute?.providerId ?? provider.id,
+      model: member?.model ?? params.providerRoute?.model ?? params.model
+    };
+  }
+  routeKey(provider, params) {
+    const { providerId, model } = this.served(provider, params);
+    return `${providerId}|${model}`;
+  }
+  /** Everything already confirmed, then the tool pairing the provider requires. */
+  prepare(provider, params) {
+    const key5 = this.routeKey(provider, params);
+    let next = params;
+    const latched = this.learned.latched.get(key5);
+    if (latched)
+      next = withoutParameters(next, latched);
+    let messages = next.messages;
+    if (this.learned.reasoningOff.has(key5))
+      messages = stripReasoning(messages);
+    messages = this.applyMediaMemory(messages);
+    messages = this.pair(messages);
+    return messages === next.messages ? next : { ...next, messages };
+  }
+  applyMediaMemory(messages) {
+    const { rejectedMedia, mediaLimit } = this.learned;
+    if (rejectedMedia.size === 0 && mediaLimit === void 0)
+      return messages;
+    const slots = listMedia(messages);
+    const faulty = slots.filter((slot) => rejectedMedia.has(slot.fingerprint));
+    let out = removeMedia(messages, faulty, false);
+    if (mediaLimit !== void 0) {
+      const rest = listMedia(out);
+      if (rest.length > mediaLimit) {
+        out = removeMedia(out, rest.slice(0, rest.length - mediaLimit), true);
+      }
+    }
+    return out;
+  }
+  /** The shared tool-history repair, on the outgoing copy. Duplicate call ids fail closed there, so the request goes out as it is. */
+  pair(messages) {
+    try {
+      const repaired = repairToolMessageHistory(messages);
+      if (!toolHistoryRepairChanged(repaired.report))
+        return messages;
+      this.hooks.debug?.(`Repaired tool pairing before sending: ${JSON.stringify(repaired.report)}`);
+      return repaired.messages;
+    } catch (error) {
+      this.hooks.debug?.(`Tool pairing could not be repaired before sending: ${error instanceof Error ? error.message : String(error)}`);
+      return messages;
+    }
+  }
+  /** What a resend that was accepted has proved. */
+  commit(session) {
+    const { pending: pending2 } = session;
+    for (const [key5, names] of pending2.latched) {
+      const set3 = this.learned.latched.get(key5) ?? /* @__PURE__ */ new Set();
+      for (const name2 of names)
+        set3.add(name2);
+      this.learned.latched.set(key5, set3);
+    }
+    for (const key5 of pending2.reasoningOff)
+      this.learned.reasoningOff.add(key5);
+    for (const fingerprint of pending2.rejectedMedia)
+      this.learned.rejectedMedia.add(fingerprint);
+    if (pending2.mediaLimit !== void 0) {
+      this.learned.mediaLimit = Math.min(this.learned.mediaLimit ?? pending2.mediaLimit, pending2.mediaLimit);
+    }
+    session.pending = emptyLearned();
+  }
+  /** The request to send after `rejection`, or null when nothing more can be tried. */
+  next(provider, params, rejection, session) {
+    const { spent, pending: pending2 } = session;
+    const key5 = this.routeKey(provider, params);
+    switch (rejection.kind) {
+      case "tool-pairing": {
+        if (spent.has("tool-pairing"))
+          return null;
+        spent.add("tool-pairing");
+        const repaired = repairOnce(params.messages);
+        if (repaired === null)
+          return null;
+        this.hooks.debug?.(`Retrying after a tool-history rejection (${key5})`);
+        return { ...params, messages: repaired };
+      }
+      case "reasoning": {
+        if (spent.has("reasoning"))
+          return null;
+        spent.add("reasoning");
+        const messages = stripReasoning(params.messages);
+        if (messages === params.messages)
+          return null;
+        pending2.reasoningOff.add(key5);
+        let next = { ...params, messages };
+        if (params.thinking !== void 0 && params.thinking.type !== "disabled") {
+          next = withoutParameters(next, /* @__PURE__ */ new Set(["thinking"]));
+          const names = pending2.latched.get(key5) ?? /* @__PURE__ */ new Set();
+          names.add("thinking");
+          pending2.latched.set(key5, names);
+        }
+        this.hooks.debug?.(`Retrying without reasoning blocks (${key5})`);
+        return next;
+      }
+      case "parameter": {
+        const fresh = rejection.parameters.filter((name2) => !spent.has(`param:${name2}`));
+        if (fresh.length === 0)
+          return null;
+        for (const name2 of fresh)
+          spent.add(`param:${name2}`);
+        const names = pending2.latched.get(key5) ?? /* @__PURE__ */ new Set();
+        for (const name2 of fresh)
+          names.add(name2);
+        pending2.latched.set(key5, names);
+        this.hooks.debug?.(`Retrying without parameters the model refused (${key5}): ${fresh.join(", ")}`);
+        return withoutParameters(params, new Set(fresh));
+      }
+      case "media":
+        return this.nextWithoutMedia(provider, params, rejection, session);
+    }
+  }
+  nextWithoutMedia(provider, params, rejection, session) {
+    const { spent, stripsByIndex, pending: pending2 } = session;
+    const slots = listMedia(params.messages);
+    if (slots.length === 0)
+      return null;
+    let victims = [];
+    let limited = false;
+    if (!rejection.generic) {
+      if (rejection.messageIndex !== void 0) {
+        const used = stripsByIndex.get(rejection.messageIndex) ?? 0;
+        if (used < MAX_STRIPS_PER_INDEX) {
+          stripsByIndex.set(rejection.messageIndex, used + 1);
+          victims = mediaAtWireIndex(params.messages, slots, this.served(provider, params).providerId, rejection.messageIndex, rejection.contentIndex) ?? [];
+        }
+      }
+      if (victims.length === 0) {
+        const newest = slots[slots.length - 1];
+        if (newest === void 0)
+          return null;
+        const count7 = (stripsByIndex.get(-1) ?? 0) + 1;
+        if (count7 > MAX_STRIPS_PER_INDEX)
+          return null;
+        stripsByIndex.set(-1, count7);
+        victims = slots.filter((slot) => slot.messageIndex === newest.messageIndex);
+      }
+    } else {
+      const limit = GENERIC_MEDIA_LIMITS.find((candidate) => candidate < slots.length) ?? Math.floor(slots.length / 2);
+      spent.add(`limit:${limit}`);
+      pending2.mediaLimit = Math.min(pending2.mediaLimit ?? limit, limit);
+      victims = slots.slice(0, slots.length - limit);
+      limited = true;
+    }
+    if (!limited)
+      for (const slot of victims)
+        pending2.rejectedMedia.add(slot.fingerprint);
+    this.hooks.debug?.(`Retrying without ${victims.length} media the provider rejected`);
+    let lastUser = -1;
+    for (const [index, message] of params.messages.entries()) {
+      if (message.role === "user")
+        lastUser = index;
+    }
+    const kinds = new Set(victims.map((slot) => slot.kind));
+    const removal = {
+      count: victims.length,
+      kind: kinds.size === 1 ? [...kinds][0] : "media",
+      current: victims.some((slot) => slot.source === "user" && slot.messageIndex === lastUser),
+      limit: limited
+    };
+    const before = session.removal;
+    session.removal = before ? {
+      count: before.count + removal.count,
+      kind: before.kind === removal.kind ? before.kind : "media",
+      current: before.current || removal.current,
+      limit: before.limit && removal.limit
+    } : removal;
+    return { ...params, messages: removeMedia(params.messages, victims, limited) };
+  }
+  /**
+   * Send `params`, repairing and resending a request the provider rejects as
+   * invalid until it is accepted or nothing more can be changed. The original
+   * rejection is thrown when nothing applies, and what the guesses taught is
+   * forgotten unless a resend was accepted.
+   */
+  async *stream(provider, params, session = this.session()) {
+    let current = this.prepare(provider, params);
+    let firstError;
+    for (; ; ) {
+      let produced = false;
+      let reported = false;
+      try {
+        for await (const chunk of provider.chatStream(current)) {
+          if (isAccepted(chunk)) {
+            produced = true;
+            this.commit(session);
+            if (session.removal !== void 0 && !reported) {
+              reported = true;
+              const removal = session.removal;
+              session.removal = void 0;
+              await this.hooks.onMediaRemoved?.(removal);
+            }
+          }
+          yield chunk;
+        }
+        this.commit(session);
+        if (session.removal !== void 0 && !reported) {
+          const removal = session.removal;
+          session.removal = void 0;
+          await this.hooks.onMediaRemoved?.(removal);
+        }
+        return;
+      } catch (error) {
+        if (current.signal?.aborted)
+          throw current.signal.reason;
+        if (produced)
+          throw error;
+        firstError ??= error;
+        const forget = /* @__PURE__ */ __name(() => {
+          session.pending = emptyLearned();
+          session.removal = void 0;
+          throw firstError;
+        }, "forget");
+        if (session.repairs >= MAX_REPAIRS_PER_REQUEST)
+          return forget();
+        if (isHandledElsewhere(error, current))
+          return forget();
+        const rejection = classifyRequestRejection(error, current);
+        if (rejection === null)
+          return forget();
+        const step = this.next(provider, current, rejection, session);
+        if (step === null)
+          return forget();
+        session.repairs++;
+        current = step;
+      }
+    }
+  }
+};
+function repairOnce(messages) {
+  try {
+    const repaired = repairToolMessageHistory(messages);
+    return toolHistoryRepairChanged(repaired.report) ? repaired.messages : null;
+  } catch {
+    return null;
+  }
+}
+__name(repairOnce, "repairOnce");
+function withoutParameters(params, names) {
+  if (names.size === 0)
+    return params;
+  const next = { ...params };
+  if (names.has("effort"))
+    next.effort = void 0;
+  if (names.has("thinking"))
+    next.thinking = void 0;
+  if (names.has("temperature"))
+    next.temperature = void 0;
+  if (names.has("topP"))
+    next.topP = void 0;
+  if (names.has("responseFormat"))
+    next.responseFormat = void 0;
+  return next;
+}
+__name(withoutParameters, "withoutParameters");
+function isHandledElsewhere(error, params) {
+  if (isProviderRejectedImageError(error) && findSingleRequestImage(params.messages) !== null) {
+    return true;
+  }
+  return isImageInputRefusal(error);
+}
+__name(isHandledElsewhere, "isHandledElsewhere");
+
 // ../sdk/dist/turn/preparation-context-error.js
 var PreparationContextError = class extends Error {
   static {
@@ -33857,7 +34705,7 @@ async function* streamProviderTurn(provider, params, emitEvent, drainPending, tu
   } : void 0;
   if (!imageRecovery)
     observeRequest?.(streamParams.messages);
-  const stream = imageRecovery ? streamWithProviderRejectedImageRecovery(provider, streamParams, imageRecovery.onAccepted, observeRequest) : provider.chatStream(streamParams);
+  const stream = imageRecovery ? streamWithProviderRejectedImageRecovery(provider, streamParams, imageRecovery.onAccepted, observeRequest, imageRecovery.textOnly, imageRecovery.repair) : provider.chatStream(streamParams);
   const it = stream[Symbol.asyncIterator]();
   const signal = params.signal;
   let onAbort;
@@ -34370,6 +35218,10 @@ var DEFAULT_ANSWER_REVIEW_LIMIT = 3;
 var OUTPUT_CAP_MARGIN_TOKENS = 1e3;
 var MIN_OUTPUT_CAP_TOKENS = 3e3;
 var CLOSING_RESPONSE_GUIDANCE = "Give a concise response using only what the available evidence supports. Attribute unverified statements to their source instead of presenting them as observed facts. If evidence is missing or conflicting, state what cannot be established. Do not claim unfinished work is complete. Do not request any more tool calls.";
+function textOnlyKey(providerId, model) {
+  return `${providerId}\0${model}`;
+}
+__name(textOnlyKey, "textOnlyKey");
 var IterationOrchestrator = class {
   static {
     __name(this, "IterationOrchestrator");
@@ -34405,6 +35257,67 @@ var IterationOrchestrator = class {
   }
   /** Rich tool blocks already reported; durable history is scanned every turn. */
   warnedRichToolResults = /* @__PURE__ */ new Set();
+  /** What this run has learned about requests its provider rejects as invalid, and how to repair them. */
+  requestRepair = new RequestRepair({
+    debug: /* @__PURE__ */ __name((message) => this.ctx.log.debug(message), "debug"),
+    onMediaRemoved: /* @__PURE__ */ __name((removal) => this.noteMediaRemoved(removal), "onMediaRemoved"),
+    servedBy: /* @__PURE__ */ __name(() => this.ctx.servingMember?.(), "servedBy")
+  });
+  /**
+   * Provider and model pairs that refused a request for holding an image; they
+   * get none for the rest of the run. Keyed by both: one model id can be served
+   * by two members of a fallback chain, and only the one that refused is known.
+   */
+  textOnlyModels = /* @__PURE__ */ new Set();
+  /**
+   * The member a request for `model` goes to first. A fallback chain keeps
+   * serving from the member it last moved to, so that member, not the head,
+   * is the one whose reading of images counts.
+   */
+  servingModel(model) {
+    const serving = this.ctx.servingMember?.();
+    return {
+      providerId: serving?.providerId ?? this.ctx.provider.id,
+      model: serving?.model ?? model
+    };
+  }
+  /** Whether a request for `model` may carry images: the driver's catalogue and this run's own evidence agree. */
+  modelReadsImages(model) {
+    const serving = this.servingModel(model);
+    return !this.textOnlyModels.has(textOnlyKey(serving.providerId, serving.model)) && modelReadsImages(this.ctx.provider, model);
+  }
+  /** What a request for `model` does when its model turns out to read text only. */
+  textOnlyRecovery(model) {
+    return {
+      servedBy: /* @__PURE__ */ __name(() => this.servingModel(model), "servedBy"),
+      onAccepted: /* @__PURE__ */ __name((refused) => this.noteTextOnlyModel(refused), "onAccepted")
+    };
+  }
+  /**
+   * A provider refused a request for holding an image its model cannot read, and
+   * the retry without images was accepted. Stop sending images to it, and say so
+   * once, so the host can remember the model beyond this run.
+   */
+  async noteTextOnlyModel(refused) {
+    const key5 = textOnlyKey(refused.providerId, refused.model ?? "");
+    if (this.textOnlyModels.has(key5))
+      return;
+    this.textOnlyModels.add(key5);
+    const { providerId, model } = refused;
+    this.ctx.log.warn("Capability mismatch: the model cannot read images", {
+      [GENAI.SYSTEM]: providerId,
+      [GENAI.REQUEST_MODEL]: model ?? ""
+    });
+    await this.ctx.emitEvent?.({
+      type: "capability_warning",
+      turnId: this.ctx.recorder.turnId,
+      capability: "vision",
+      contentSource: "history",
+      providerId,
+      ...model !== void 0 ? { model } : {},
+      message: `Model '${model ?? "unknown"}' on provider '${providerId}' refused a request that held an image, so images are left out of its requests. They stay in the conversation and are sent again to a model that reads them.`
+    });
+  }
   /**
    * The previous iteration held a `stopWhen` decision open for a worker.
    *
@@ -34618,7 +35531,7 @@ var IterationOrchestrator = class {
     this.resumedToolResults = [];
     await this.recordToolStructuredFailure(resumedToolResults, recorder.currentIteration);
     await this.ctx.checkpointMgr.markLoopStart?.(recorder);
-    let overflowRelieved = false;
+    let overflowReliefs = 0;
     let outputCapOverride;
     try {
       if (this.stopForStructuredRetryExhaustion())
@@ -34785,7 +35698,7 @@ var IterationOrchestrator = class {
             requestHistory.push(stepContextMessage(contextText));
           if (step.context)
             requestHistory.push(stepContextMessage(step.context));
-          const messages = projectRequestRichContent(this.projectObservations(requestHistory), this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES);
+          const messages = projectRequestRichContent(this.projectObservations(requestHistory), this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES, { imagesReadable: this.modelReadsImages(stepModel) });
           appendWorkContext(shaping, messages, iterationNum, step);
           if (closingDirective)
             messages.push(closingDirective);
@@ -34891,7 +35804,9 @@ var IterationOrchestrator = class {
             // also races it). Inert when never aborted.
             signal: this.ctx.abortController.signal
           }, this.ctx.emitEvent, this.ctx.drainPending, recorder.turnId, iterationNum, forceFinalize, this.ctx.log, iterSpan, stepMessageId, {
-            onAccepted: /* @__PURE__ */ __name((identity) => this.acceptProviderRejectedImage(identity), "onAccepted")
+            onAccepted: /* @__PURE__ */ __name((identity) => this.acceptProviderRejectedImage(identity), "onAccepted"),
+            textOnly: this.textOnlyRecovery(stepModel),
+            repair: this.requestRepair
           }, Boolean(this.ctx.reviewAnswer || this.ctx.structuredOutput?.review || this.ctx.advisoryCtx), recorder.sessionId);
           stepResponse = response;
           const reviewRequest = {
@@ -34917,7 +35832,8 @@ var IterationOrchestrator = class {
             providerId: servedBy.providerId,
             model: servedBy.model
           });
-          overflowRelieved = false;
+          overflowReliefs = 0;
+          clearCompactionErrorNote(this.ctx);
           outputCapOverride = void 0;
           if (response.finishReason !== "length")
             this.outputContinuations = 0;
@@ -35399,6 +36315,7 @@ ${feedback}`, "hook-feedback"));
           yield* this.ctx.drainPending();
         } catch (err) {
           const cancelled = this.ctx.abortController.signal.aborted;
+          const sandboxStopped = err instanceof SandboxAcquisitionStopped;
           if (this.steps.at(-1)?.stepNumber === iterationNum) {
             this.ctx.log.warn("Iteration failed after its step was already recorded", {
               [NAMZU.TURN_ID]: recorder.turnId,
@@ -35422,7 +36339,7 @@ ${feedback}`, "hook-feedback"));
               startedAt: stepStartedAt,
               usageBefore,
               costBefore,
-              unfinished: cancelled ? { finishReason: "cancelled" } : {
+              unfinished: cancelled || sandboxStopped ? { finishReason: "cancelled" } : {
                 finishReason: "error",
                 failure: describeStepFailure(err, this.ctx.provider.id)
               }
@@ -35451,19 +36368,43 @@ ${feedback}`, "hook-feedback"));
               continue;
             }
           }
-          if (!overflowRelieved && !(err instanceof AnswerReviewFailure) && classifyProviderError(err, this.ctx.provider.id).code === "context_length_exceeded") {
-            overflowRelieved = true;
-            const shed = await relieveOverflow(this.ctx);
+          if (!(err instanceof AnswerReviewFailure) && classifyProviderError(err, this.ctx.provider.id).code === "context_length_exceeded") {
+            if (overflowReliefs === 0 && await stopOnRefill(this.ctx)) {
+              if (iterationActivity) {
+                this.ctx.activityStore.fail(iterationActivity.id, toErrorMessage(err));
+              }
+              if (this.stopForCompactionBreaker())
+                break;
+            }
+            let shed = false;
+            while (!shed && overflowReliefs < OVERFLOW_RELIEF_LIMIT) {
+              overflowReliefs++;
+              shed = await relieveOverflow(this.ctx, { deeper: overflowReliefs > 1 });
+            }
             if (shed) {
+              compactionBreaker(this.ctx)?.recordCompaction(iterationNum);
               this.ctx.log.info("Retrying the turn after relieving a context overflow", {
                 [NAMZU.TURN_ID]: recorder.turnId,
-                [NAMZU.ITERATION]: iterationNum
+                [NAMZU.ITERATION]: iterationNum,
+                "namzu.runtime.relief_rung": overflowReliefs
               });
               if (iterationActivity) {
                 this.ctx.activityStore.complete(iterationActivity.id);
               }
               continue;
             }
+            const cause = compactionErrorNote(this.ctx);
+            if (cause !== void 0 && err instanceof Error) {
+              try {
+                err.message = `${err.message}${AUTOMATIC_COMPACTION_FAILED}${cause}`;
+              } catch {
+              }
+            }
+          }
+          if (sandboxStopped) {
+            if (iterationActivity)
+              this.ctx.activityStore.complete(iterationActivity.id);
+            throw err;
           }
           if (iterationActivity) {
             this.ctx.activityStore.fail(iterationActivity.id, toErrorMessage(err));
@@ -35948,6 +36889,25 @@ ${feedback}`, "hook-feedback"));
       return false;
     return this.ctx.taskGateway.listTasks().some((t) => t.state !== "completed" && t.state !== "failed" && t.state !== "canceled");
   }
+  /** Media the provider could not process was left out of a request that then went through. */
+  async noteMediaRemoved(removal) {
+    this.ctx.log.warn("Media the provider rejected was left out of the request", {
+      [GENAI.SYSTEM]: this.ctx.provider.id,
+      "namzu.request.media_removed": removal.count
+    });
+    const noun = removal.count === 1 ? "a file" : `${removal.count} files`;
+    const it = removal.count === 1 ? "it" : "they";
+    await this.ctx.emitEvent?.({
+      type: "capability_warning",
+      turnId: this.ctx.recorder.turnId,
+      capability: removal.kind === "document" ? "documents" : "vision",
+      // The person's own latest attachment is named as such; a count limit is
+      // not a fault in any file.
+      contentSource: removal.current ? "media-removed-current" : removal.limit ? "media-limit" : "media-removed",
+      providerId: this.ctx.provider.id,
+      message: removal.limit ? `The conversation holds more files than the provider accepts at once, so ${noun} (the oldest) ${removal.count === 1 ? "was" : "were"} left out of the request. The conversation still holds ${it}.` : `The provider could not process ${noun}${removal.current ? " attached to your latest message" : " in this conversation"}, so ${it} ${removal.count === 1 ? "was" : "were"} left out of the request. The conversation still holds ${it}.`
+    });
+  }
   async acceptProviderRejectedImage(identity) {
     const repaired = markProviderRejectedImage(this.ctx.recorder.messages, identity);
     if (repaired.count === 0) {
@@ -35983,7 +36943,7 @@ ${feedback}`, "hook-feedback"));
         ...workingMemory.history,
         ...workingMemory.context ? [workingMemory.context] : []
       ];
-      const finalMessages = projectRequestRichContent(this.projectObservations(finalHistory), this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES);
+      const finalMessages = projectRequestRichContent(this.projectObservations(finalHistory), this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES, { imagesReadable: this.modelReadsImages(model) });
       appendWorkContext(this.stepShaping(), finalMessages, this.steps.length + 1, { model });
       finalMessages.push(createRuntimeContextMessage(`[SYSTEM] Turn is ending due to ${reason2}. ${CLOSING_RESPONSE_GUIDANCE}`, "limit-finalization"));
       await this.reportUnsupportedToolResults(finalMessages);
@@ -36017,7 +36977,7 @@ ${feedback}`, "hook-feedback"));
         // stream to completion.
         signal: this.ctx.abortController.signal
       };
-      const response = await collectChatCompletion(streamWithProviderRejectedImageRecovery(this.ctx.provider, finalParams, (identity) => this.acceptProviderRejectedImage(identity)));
+      const response = await collectChatCompletion(streamWithProviderRejectedImageRecovery(this.ctx.provider, finalParams, (identity) => this.acceptProviderRejectedImage(identity), void 0, this.textOnlyRecovery(model), this.requestRepair));
       const servingMember = this.ctx.servingMember?.() ?? requestedMember;
       const servedBy = {
         providerId: servingMember.providerId,
@@ -36277,6 +37237,16 @@ function withProviderFallback(members, options = {}) {
     // always present on a multi-member wrapper: `undefined` is its honest
     // answer when any member cannot enumerate its selected model.
     supportsHostedWebSearchFor: /* @__PURE__ */ __name((model, mode) => members.every((member) => member.provider.capabilities?.supportsHostedWebSearch === true && (member.provider.supportsHostedWebSearchFor?.(member.model ?? model, mode) ?? true)), "supportsHostedWebSearchFor"),
+    // Answered for the member the next request goes to first, the one the
+    // cursor rests on (it never rewinds). Unlike the head's other
+    // declarations this costs nothing to keep current, and the head's answer
+    // would strip images from a vision member serving behind a text-only head.
+    // A request that falls over mid-call to a member that cannot read images is
+    // refused there, and the runtime sends it again without them.
+    supportsImageInputFor: /* @__PURE__ */ __name((model) => {
+      const serving = members[cursor] ?? first;
+      return serving.provider.supportsImageInputFor?.(serving.model ?? model) ?? true;
+    }, "supportsImageInputFor"),
     reasoningEffortLevelsFor: /* @__PURE__ */ __name((model, thinking) => commonReasoningEffortLevels(members, model, thinking), "reasoningEffortLevelsFor"),
     // Present on the chain wrapper for the same reason the menu method is:
     // `undefined` is the honest answer when a member cannot answer, defaults
@@ -36334,6 +37304,11 @@ var DEFAULT_PROVIDER_RETRY = {
   maxDelayMs: 16e3,
   maxRetryAfterMs: 6e4
 };
+function isReasoningOnly(chunk) {
+  const d = chunk.delta;
+  return d.reasoning !== void 0 && !d.content && !d.toolCalls?.length && d.toolCallEnd === void 0 && d.hostedTool === void 0 && d.citation === void 0 && d.textPart === void 0 && chunk.textParts === void 0 && chunk.finishReason === void 0;
+}
+__name(isReasoningOnly, "isReasoningOnly");
 function withProviderRetry(provider, options = {}) {
   const config = {
     ...DEFAULT_PROVIDER_RETRY,
@@ -36348,12 +37323,17 @@ function withProviderRetry(provider, options = {}) {
   async function* chatStream(params) {
     for (let attempt = 0; ; attempt++) {
       let produced = false;
+      let reasoned = false;
       let acted = false;
       try {
         for await (const chunk of provider.chatStream(params)) {
           const isErrorOnly = chunk.error !== void 0 && !chunk.delta.content && !chunk.delta.toolCalls?.length;
-          if (!isErrorOnly)
-            produced = true;
+          if (!isErrorOnly) {
+            if (isReasoningOnly(chunk))
+              reasoned = true;
+            else
+              produced = true;
+          }
           if (chunk.delta.toolCalls?.length || chunk.delta.toolCallEnd || chunk.delta.hostedTool) {
             acted = true;
           }
@@ -36370,7 +37350,7 @@ function withProviderRetry(provider, options = {}) {
           throw err;
         const classified = classifyProviderError(err, provider.id);
         const exhausted = attempt >= config.maxRetries;
-        const restartable = produced && config.retryMidStream === true && !acted;
+        const restartable = produced && config.retryMidStream === true && !acted || !produced && reasoned;
         if (produced && !restartable || !classified.retryable || exhausted) {
           log?.warn("Provider call failed", {
             [GENAI.SYSTEM]: provider.id,
@@ -36449,6 +37429,9 @@ function withProviderRetry(provider, options = {}) {
     ...provider.supportsHostedWebSearchFor ? {
       supportsHostedWebSearchFor: /* @__PURE__ */ __name((model, mode) => provider.supportsHostedWebSearchFor?.(model, mode) ?? false, "supportsHostedWebSearchFor")
     } : {},
+    ...provider.supportsImageInputFor ? {
+      supportsImageInputFor: /* @__PURE__ */ __name((model) => provider.supportsImageInputFor?.(model) ?? true, "supportsImageInputFor")
+    } : {},
     ...provider.reasoningEffortLevelsFor ? {
       reasoningEffortLevelsFor: /* @__PURE__ */ __name((model, thinking) => provider.reasoningEffortLevelsFor?.(model, thinking), "reasoningEffortLevelsFor")
     } : {},
@@ -37452,7 +38435,7 @@ import { lstat as lstat3 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 
 // ../sdk/dist/store/evidence/index-page.js
-import { createHash as createHash14, createHmac, timingSafeEqual } from "node:crypto";
+import { createHash as createHash15, createHmac, timingSafeEqual } from "node:crypto";
 
 // ../sdk/dist/store/evidence/compaction-provenance.js
 function record(value) {
@@ -37567,7 +38550,7 @@ var positionSchema = external_exports.object({
   textIndex: integer.default(0)
 });
 function evidenceSeal(sessionStart, sourceKey) {
-  const key5 = createHash14("sha256").update("namzu-session-evidence-v1\n").update(sessionStart).digest();
+  const key5 = createHash15("sha256").update("namzu-session-evidence-v1\n").update(sessionStart).digest();
   const mac = /* @__PURE__ */ __name((value) => createHmac("sha256", key5).update(`${sourceKey}
 ${value}`).digest(), "mac");
   return {
@@ -41554,7 +42537,7 @@ function lastUnansweredBatch(messages) {
 __name(lastUnansweredBatch, "lastUnansweredBatch");
 
 // ../sdk/dist/runtime/query/executor.js
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { join as join16 } from "node:path";
 
 // ../sdk/dist/authorization/program.js
@@ -44188,6 +45171,7 @@ var ToolExecutor = class {
   /** Set per turn by the orchestrator; see {@link setStepAllowedTools}. */
   stepAllowedTools;
   fileReadTracker;
+  sandboxGate;
   /** A ledger is rebuilt from history at most once; a second pass would re-append its chains. */
   fileObservationsSeeded = false;
   constructor(config, activityStore, emitEvent, log, probes = probe) {
@@ -44207,6 +45191,22 @@ var ToolExecutor = class {
   }
   setSandbox(sandbox) {
     this.config = { ...this.config, sandbox };
+    this.sandboxGate = void 0;
+  }
+  /**
+   * Hold tool admission until a sandbox that is still being acquired exists.
+   * The gate rejects when none will, and the turn settles that rejection. It
+   * is cleared by {@link setSandbox}, so a turn pays the check once.
+   */
+  setSandboxGate(gate) {
+    this.sandboxGate = gate;
+  }
+  async awaitSandbox() {
+    await this.sandboxGate?.();
+  }
+  /** True once the turn has a sandbox, or is certain to get one before a tool runs. */
+  get sandboxed() {
+    return this.config.sandbox !== void 0 || this.sandboxGate !== void 0;
   }
   /** Classify only the exact successful result executed by this executor. */
   recordedObservationKey(call2, message) {
@@ -44214,7 +45214,7 @@ var ToolExecutor = class {
     return recorded !== void 0 && message.toolCallId === call2.id && !message.isError && typeof message.content === "string" && this.config.tools.get(recorded.toolName) === recorded.definition && recorded.fingerprint === this.observationFingerprint(call2, message.content) ? recorded.inputFingerprint : void 0;
   }
   observationFingerprint(call2, content) {
-    return createHash15("sha256").update(JSON.stringify([call2.function.name, call2.function.arguments, content])).digest("hex");
+    return createHash16("sha256").update(JSON.stringify([call2.function.name, call2.function.arguments, content])).digest("hex");
   }
   recordExecutedObservation(call2, toolName, definition, input, content) {
     if (typeof content !== "string" || this.config.tools.get(toolName) !== definition)
@@ -44226,7 +45226,7 @@ var ToolExecutor = class {
         toolName,
         definition,
         fingerprint: this.observationFingerprint(call2, content),
-        inputFingerprint: createHash15("sha256").update(JSON.stringify([toolName, input])).digest("hex")
+        inputFingerprint: createHash16("sha256").update(JSON.stringify([toolName, input])).digest("hex")
       });
     } catch {
     }
@@ -44264,7 +45264,7 @@ var ToolExecutor = class {
   }
   /** Request-only evidence from the same ledger used by mutation admission. No filesystem I/O. */
   describeFileEvidence(messages) {
-    return describeVisibleFileEvidence(messages, this.fileReadTracker, this.config.workingDirectory, this.config.sandbox !== void 0);
+    return describeVisibleFileEvidence(messages, this.fileReadTracker, this.config.workingDirectory, this.sandboxed);
   }
   /**
    * Span that this executor's tool spans should hang off — the current
@@ -44423,7 +45423,7 @@ var ToolExecutor = class {
   commandDialect(toolName) {
     const tool = this.config.tools.get(toolName);
     return tool?.commandDialect?.({
-      sandboxed: this.config.sandbox !== void 0
+      sandboxed: this.sandboxed
     }) ?? "sh";
   }
   /**
@@ -44443,6 +45443,8 @@ var ToolExecutor = class {
    */
   async prepareBatchForReview(response, hostModifiedCallIds) {
     assertUniqueToolCallIds(response.message.toolCalls ?? []);
+    if ((response.message.toolCalls ?? []).length > 0)
+      await this.awaitSandbox();
     const calls = /* @__PURE__ */ new Map();
     const escalations = /* @__PURE__ */ new Map();
     for (const toolCall of response.message.toolCalls ?? []) {
@@ -44474,7 +45476,7 @@ var ToolExecutor = class {
     if (!tool || call2.input === null || typeof call2.input !== "object")
       return void 0;
     const input = call2.input;
-    const sandboxed = this.config.sandbox !== void 0;
+    const sandboxed = this.sandboxed;
     let outsidePaths;
     if (this.config.outsideRootAccess === "review" && !sandboxed && tool.pathArgument !== void 0) {
       const value = input[tool.pathArgument];
@@ -44612,6 +45614,8 @@ var ToolExecutor = class {
       return { messages: [], results: [], observations: [] };
     }
     assertUniqueToolCallIds(toolCalls);
+    if (toolCalls.length > 0)
+      await this.awaitSandbox();
     this.batchMode = this.resolvePermissionMode();
     try {
       const owned = preparedBatch;
@@ -46635,6 +47639,9 @@ async function* query(params) {
         [GENAI.SYSTEM]: params.provider.id
       });
       let sandbox;
+      let deferredSandbox;
+      let applyAcquisitionStop = /* @__PURE__ */ __name(() => {
+      }, "applyAcquisitionStop");
       let pendingResume = null;
       let pendingResumeAssistantId;
       let answeredParkId;
@@ -46878,6 +47885,14 @@ ${segments.dynamic}` : segments.static;
           applyLifecycleHookResults("turn_start", hookResults);
           yield* eventTranslator.drainPending();
         }
+        const acquireMode = turnConfig.sandbox?.acquire ?? "eager";
+        if (acquireMode !== "eager" && acquireMode !== "concurrent" && acquireMode !== "on-first-use") {
+          throw new NamzuError({
+            code: "invalid_config",
+            message: `sandbox.acquire must be 'eager', 'concurrent' or 'on-first-use'; received ${String(acquireMode)}`,
+            details: { acquire: String(acquireMode) }
+          });
+        }
         if (params.sandboxProvider) {
           const rootAtCwd = turnConfig.sandbox?.workspace === "working-directory";
           if (rootAtCwd && params.workingDirectory === void 0) {
@@ -46897,8 +47912,9 @@ ${segments.dynamic}` : segments.static;
               }
             });
           }
-          const acquisition = await acquireSandbox({
-            provider: params.sandboxProvider,
+          const sandboxProvider = params.sandboxProvider;
+          const startAcquisition = /* @__PURE__ */ __name((signal) => acquireSandbox({
+            provider: sandboxProvider,
             config: {
               ...rootAtCwd ? { workingDirectory: ctx.cwd } : {},
               ...rootAtCwd && params.additionalDirectories?.length ? { additionalDirectories: params.additionalDirectories } : {},
@@ -46906,7 +47922,7 @@ ${segments.dynamic}` : segments.static;
               memoryLimitMb: turnConfig.sandbox?.memoryLimitMb,
               maxProcesses: turnConfig.sandbox?.maxProcesses
             },
-            signal: ctx.abortController.signal,
+            signal,
             timeoutMs: guard.remainingUntilTimeoutMs(),
             teardownTimeoutMs: sandboxTeardownTimeoutMs,
             onLateTeardown: /* @__PURE__ */ __name((result) => {
@@ -46921,12 +47937,29 @@ ${segments.dynamic}` : segments.static;
                 ...errorAttributes(result.error)
               });
             }, "onLateTeardown")
-          });
-          if (acquisition.kind !== "created") {
+          }), "startAcquisition");
+          const publishSandbox = /* @__PURE__ */ __name(async (acquired) => {
+            sandbox = acquired;
+            toolExecutor.setSandbox(acquired);
+            await eventTranslator.emitEvent({
+              type: "sandbox_created",
+              turnId: ctx.turnId,
+              sandboxId: acquired.id,
+              environment: acquired.environment
+            });
+          }, "publishSandbox");
+          const logSandboxCreated = /* @__PURE__ */ __name((acquired) => {
+            ctx.log.info("Sandbox created for run", {
+              "namzu.sandbox.id": acquired.id,
+              "namzu.execution.environment": acquired.environment,
+              "namzu.runtime.root_dir": acquired.rootDir
+            });
+          }, "logSandboxCreated");
+          applyAcquisitionStop = /* @__PURE__ */ __name((acquisition) => {
             if (acquisition.createPending) {
               ctx.log.warn("Sandbox creation was unsettled when the turn stopped; any returned handle will be released, but a remote allocation hidden behind a lost response requires provider-side reconciliation or a fleet reaper", {
                 [NAMZU.TURN_ID]: ctx.turnId,
-                "namzu.sandbox.provider_id": params.sandboxProvider.id
+                "namzu.sandbox.provider_id": sandboxProvider.id
               });
             }
             if (acquisition.kind === "cancelled") {
@@ -46935,28 +47968,36 @@ ${segments.dynamic}` : segments.static;
               ctx.recorder.setStopReason("timeout");
               ctx.log.warn("Sandbox creation exhausted the turn timeout", {
                 [NAMZU.TURN_ID]: ctx.turnId,
-                "namzu.sandbox.provider_id": params.sandboxProvider.id,
+                "namzu.sandbox.provider_id": sandboxProvider.id,
                 ...errorAttributes(acquisition.error)
               });
             }
-            yield* resultAssembler.completeTurn(rootSpan);
-            settled = true;
-            return await resultAssembler.finalize();
+          }, "applyAcquisitionStop");
+          if (acquireMode === "eager") {
+            const acquisition = await startAcquisition(ctx.abortController.signal);
+            if (acquisition.kind !== "created") {
+              applyAcquisitionStop(acquisition);
+              yield* resultAssembler.completeTurn(rootSpan);
+              settled = true;
+              return await resultAssembler.finalize();
+            }
+            await publishSandbox(acquisition.sandbox);
+            yield* eventTranslator.drainPending();
+            logSandboxCreated(acquisition.sandbox);
+          } else {
+            const deferred2 = createDeferredSandbox({
+              turnSignal: ctx.abortController.signal,
+              acquire: startAcquisition,
+              publish: /* @__PURE__ */ __name(async (acquired) => {
+                await publishSandbox(acquired);
+                logSandboxCreated(acquired);
+              }, "publish")
+            });
+            deferredSandbox = deferred2;
+            toolExecutor.setSandboxGate(() => deferred2.ensure());
+            if (acquireMode === "concurrent")
+              deferred2.start();
           }
-          sandbox = acquisition.sandbox;
-          toolExecutor.setSandbox(sandbox);
-          await eventTranslator.emitEvent({
-            type: "sandbox_created",
-            turnId: ctx.turnId,
-            sandboxId: sandbox.id,
-            environment: sandbox.environment
-          });
-          yield* eventTranslator.drainPending();
-          ctx.log.info("Sandbox created for run", {
-            "namzu.sandbox.id": sandbox.id,
-            "namzu.execution.environment": sandbox.environment,
-            "namzu.runtime.root_dir": sandbox.rootDir
-          });
         }
         const inputVerdict = await runInputGuardrails(params.inputGuardrails, {
           sessionId: ctx.sessionId,
@@ -47014,6 +48055,10 @@ ${segments.dynamic}` : segments.static;
           });
         }
         yield* iterationOrchestrator.runLoop();
+        if (deferredSandbox) {
+          await deferredSandbox.settle();
+          yield* eventTranslator.drainPending();
+        }
         yield* finalizeTurn({
           ctx,
           params,
@@ -47025,6 +48070,13 @@ ${segments.dynamic}` : segments.static;
           rootSpan
         });
       } catch (err) {
+        if (err instanceof SandboxAcquisitionStopped) {
+          applyAcquisitionStop(err.acquisition);
+          yield* eventTranslator.drainPending();
+          yield* resultAssembler.completeTurn(rootSpan);
+          settled = true;
+          return await resultAssembler.finalize();
+        }
         if (isTurnInProgressError(err) && !ctx.recorder.isActive)
           throw err;
         ctx.recorder.setSteps(iterationOrchestrator.getSteps());
@@ -47032,6 +48084,7 @@ ${segments.dynamic}` : segments.static;
         yield* eventTranslator.drainPending();
         yield* resultAssembler.handleError(err, rootSpan);
       } finally {
+        await deferredSandbox?.cancel();
         yield* releaseTurnResources({
           ctx,
           eventTranslator,
@@ -50106,7 +51159,7 @@ var LocalExecutionContext = class extends BaseExecutionContext {
 };
 
 // ../sdk/dist/turn/workspace-fingerprint.js
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 import { lstat as lstat4, readFile as readFile11, readlink } from "node:fs/promises";
 import { join as join20 } from "node:path";
 var NODE_FS = { lstat: lstat4, readlink, readFile: readFile11 };
@@ -50122,7 +51175,7 @@ async function untrackedEntry(cwd, rel, fs) {
     if (!stats.isFile())
       return `? ${rel}`;
     const body = await fs.readFile(abs);
-    return `F ${rel}\0${createHash16("sha256").update(body).digest("hex")}`;
+    return `F ${rel}\0${createHash17("sha256").update(body).digest("hex")}`;
   } catch {
     return null;
   }
@@ -50167,7 +51220,7 @@ async function fingerprintWorkspace(options) {
       return null;
     parts.push(entry);
   }
-  const hash2 = createHash16("sha256");
+  const hash2 = createHash17("sha256");
   for (const part2 of parts)
     hash2.update(`${Buffer.byteLength(part2, "utf8")}:${part2}`);
   return hash2.digest("hex");
@@ -50314,7 +51367,7 @@ Check the execution problem and any partial effects before retrying. Do not clai
 __name(createCommandGate, "createCommandGate");
 
 // ../sdk/dist/turn/json-claim-verifier.js
-import { createHash as createHash17, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash18, randomUUID as randomUUID3 } from "node:crypto";
 import { performance as performance2 } from "node:perf_hooks";
 function scalar(value) {
   return value === null || typeof value === "boolean" || typeof value === "string" && value.length <= 2e3 || typeof value === "number" && Number.isSafeInteger(value);
@@ -50447,7 +51500,7 @@ function createJsonClaimVerifier(options) {
             requestId: request.requestId,
             observedAt: observation.observedAt,
             bytes: bytes.byteLength,
-            sha256: createHash17("sha256").update(bytes).digest("hex")
+            sha256: createHash18("sha256").update(bytes).digest("hex")
           });
         }
         ensureActive();
@@ -51363,7 +52416,7 @@ var DiskTaskStore = class {
 };
 
 // ../sdk/dist/store/memory/markdown.js
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 import { lstat as lstat6, mkdir as mkdir13, readFile as readFile14, readdir as readdir8, realpath as realpath5, rename as rename6, unlink as unlink11 } from "node:fs/promises";
 import { dirname as dirname14, join as join24, resolve as resolve10 } from "node:path";
 
@@ -51664,7 +52717,7 @@ async function acquireMemoryOperationLock(path2, timeoutMs) {
 __name(acquireMemoryOperationLock, "acquireMemoryOperationLock");
 
 // ../sdk/dist/store/memory/revision.js
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 var MemoryRevisionUnavailableError = class extends Error {
   static {
     __name(this, "MemoryRevisionUnavailableError");
@@ -51770,7 +52823,7 @@ function canonicalRecord(record3) {
 }
 __name(canonicalRecord, "canonicalRecord");
 function memoryRevision(record3) {
-  return `m2:${createHash18("sha256").update(canonicalRecord(record3)).digest("hex")}`;
+  return `m2:${createHash19("sha256").update(canonicalRecord(record3)).digest("hex")}`;
 }
 __name(memoryRevision, "memoryRevision");
 var MemoryRevisionConflictError = class extends NamzuError {
@@ -51819,7 +52872,7 @@ function invalidFile(file, reason2, cause) {
 }
 __name(invalidFile, "invalidFile");
 function derivedMemoryId(name2) {
-  const hex2 = createHash19("sha256").update(`namzu-memory-name:${name2}`).digest("hex");
+  const hex2 = createHash20("sha256").update(`namzu-memory-name:${name2}`).digest("hex");
   const variant = (Number.parseInt(hex2[16] ?? "0", 16) & 3 | 8).toString(16);
   return `${hex2.slice(0, 8)}-${hex2.slice(8, 12)}-8${hex2.slice(13, 16)}-${variant}${hex2.slice(17, 20)}-${hex2.slice(20, 32)}`;
 }
@@ -57295,7 +58348,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.0.0";
+var VERSION2 = "52.1.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -58621,7 +59674,7 @@ var MCPClient = class {
 };
 
 // ../sdk/dist/connector/mcp/policy.js
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 function applyToolPolicy(tools, policy) {
   return applyNamePolicy(tools, policy);
 }
@@ -58661,7 +59714,7 @@ function toolsHash(tools) {
     // fingerprint built to catch exactly that rug-pull saw nothing.
     annotations: stableStringify2(tool.annotations)
   }));
-  return createHash20("sha256").update(JSON.stringify(canonical2)).digest("hex");
+  return createHash21("sha256").update(JSON.stringify(canonical2)).digest("hex");
 }
 __name(toolsHash, "toolsHash");
 function diffTools(before, after) {
@@ -58947,7 +60000,7 @@ function mcpPromptToToolDefinition(prompt, client, serverName) {
 __name(mcpPromptToToolDefinition, "mcpPromptToToolDefinition");
 
 // ../sdk/dist/connector/mcp/mcp-toolset.js
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 
 // ../sdk/dist/connector/mcp/reconnect.js
 var DEFAULTS = {
@@ -59074,7 +60127,7 @@ function mcpToolsetName(serverName, ...segments) {
   const full = ["mcp", serverName, ...segments].join("__");
   if (full.length <= MCP_TOOLSET_NAME_MAX_LENGTH)
     return full;
-  const hash2 = createHash21("sha256").update(full).digest("hex").slice(0, 8);
+  const hash2 = createHash22("sha256").update(full).digest("hex").slice(0, 8);
   const suffix = `_${hash2}`;
   return `${full.slice(0, MCP_TOOLSET_NAME_MAX_LENGTH - suffix.length)}${suffix}`;
 }
@@ -60469,7 +61522,7 @@ var CODING_AGENT_HYPERMODE_DOCTRINE = `### Hypermode
 This session has hypermode on: treat delegation through \`Agent\` as the default for substantive work, not the exception. Before doing multi-step work yourself, ask whether an independent piece of it \u2014 a lookup, a draft, a check \u2014 could run as its own delegation, and prefer delegating it when the answer is yes. This changes only how eagerly you reach for \`Agent\` on work you would otherwise do inline; it does not mount a roster or start any delegation by itself. Agents in the same phase are launched in the same response, each with \`run_in_background: true\` when you mean to wait for them together; a phase is never started one agent at a time.`;
 
 // ../sdk/dist/manager/resident/learning.js
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 var label = external_exports.string().trim().min(1).max(256);
 var name = external_exports.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/);
 var digest3 = external_exports.string().regex(/^[a-f0-9]{64}$/);
@@ -60622,7 +61675,7 @@ function reviseResidentProfile(current, input) {
 __name(reviseResidentProfile, "reviseResidentProfile");
 function hashResidentSkill(input) {
   const candidate = candidateSchema.parse(input);
-  return createHash22("sha256").update(JSON.stringify([
+  return createHash23("sha256").update(JSON.stringify([
     candidate.name,
     candidate.description,
     candidate.body,
@@ -60662,13 +61715,13 @@ function promoteResidentSkill(current, input, evaluation, inputEvidence) {
     verification: {
       baselineHash,
       candidateHash: hash2,
-      evidenceDigest: createHash22("sha256").update(JSON.stringify({ ...evaluation, protection })).digest("hex"),
+      evidenceDigest: createHash23("sha256").update(JSON.stringify({ ...evaluation, protection })).digest("hex"),
       verificationTasks: review.verification.tasks.length,
       confirmationTasks: review.confirmation?.tasks.length ?? 0,
       protection: {
         verificationTasks: protection.verification.length,
         confirmationTasks: protection.confirmation.length,
-        planDigest: createHash22("sha256").update(JSON.stringify(protection)).digest("hex")
+        planDigest: createHash23("sha256").update(JSON.stringify(protection)).digest("hex")
       }
     }
   };
@@ -61365,7 +62418,7 @@ function cancelResponseBody(response, reason2) {
 __name(cancelResponseBody, "cancelResponseBody");
 
 // ../sdk/dist/manager/resident/store.js
-import { createHash as createHash23, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash24, randomUUID as randomUUID6 } from "node:crypto";
 var text5 = external_exports.string().trim().min(1).max(8e3);
 var time = external_exports.number().int().nonnegative().safe();
 var MAX_WAKE_EVIDENCE_CHARS = 16e3;
@@ -61412,7 +62465,7 @@ var residentStateSchema = external_exports.object({
 });
 function residentKeySegment(key5) {
   const encoded = revisionFileSegment(key5);
-  return encoded.length <= 255 ? encoded : `~sha256-${createHash23("sha256").update(encoded).digest("hex")}`;
+  return encoded.length <= 255 ? encoded : `~sha256-${createHash24("sha256").update(encoded).digest("hex")}`;
 }
 __name(residentKeySegment, "residentKeySegment");
 var ResidentConflictError = class extends Error {
@@ -62793,7 +63846,7 @@ var PAL_WORK_GUIDANCE = [
 ].join("\n\n");
 
 // ../sdk/dist/pals/reference-images.js
-import { createHash as createHash24, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash25, randomUUID as randomUUID8 } from "node:crypto";
 import { posix } from "node:path";
 var MAX_IMAGES = 8;
 var MAX_IMAGE_BYTES = 3 * 1024 * 1024;
@@ -62837,7 +63890,7 @@ function preparePalReferenceImages(attachments) {
       attachmentIndex: index + 1,
       mediaType: attachment.mediaType,
       data: attachment.data,
-      sha256: createHash24("sha256").update(bytes).digest("hex"),
+      sha256: createHash25("sha256").update(bytes).digest("hex"),
       bytes: bytes.length
     }));
   }
@@ -63018,7 +64071,7 @@ __name(createPalReferenceImageTool, "createPalReferenceImageTool");
 import { isDeepStrictEqual as isDeepStrictEqual5 } from "node:util";
 
 // ../sdk/dist/pals/communication/schema.js
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 var id2 = external_exports.string().uuid();
 var sessionId3 = external_exports.custom((s) => isEntityId(s, "session"));
 var turnId4 = external_exports.custom((s) => isEntityId(s, "turn"));
@@ -63113,7 +64166,7 @@ function freezeCommunicationValue(value) {
 }
 __name(freezeCommunicationValue, "freezeCommunicationValue");
 function hash(value) {
-  return createHash25("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash26("sha256").update(JSON.stringify(value)).digest("hex");
 }
 __name(hash, "hash");
 function addressTuple(value) {
@@ -63772,7 +64825,7 @@ __name(createPalOperatorMessagingTools, "createPalOperatorMessagingTools");
 import { posix as posix2, win32 as win322 } from "node:path";
 
 // ../sdk/dist/runtime/harness-session/journal.js
-import { createHash as createHash26, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash27, randomUUID as randomUUID9 } from "node:crypto";
 var HarnessSessionError = class extends Error {
   static {
     __name(this, "HarnessSessionError");
@@ -63792,7 +64845,7 @@ function harnessDigest(value) {
       return v;
     return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)).map(([k, entry]) => [k, canonical2(entry)]));
   }, "canonical");
-  return createHash26("sha256").update(JSON.stringify(canonical2(value))).digest("hex");
+  return createHash27("sha256").update(JSON.stringify(canonical2(value))).digest("hex");
 }
 __name(harnessDigest, "harnessDigest");
 var HarnessJournal = class {
@@ -65648,11 +66701,11 @@ var WorkflowScriptError = class extends Error {
 };
 
 // ../sdk/dist/execution/workflow/journal.js
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 import { appendFile, mkdir as mkdir15, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join28 } from "node:path";
 function sha2563(text9) {
-  return createHash27("sha256").update(text9).digest("hex");
+  return createHash28("sha256").update(text9).digest("hex");
 }
 __name(sha2563, "sha256");
 function preview(text9, max = 500) {
@@ -76742,7 +77795,7 @@ var ResidentHost = class {
 };
 
 // ../sdk/dist/manager/resident/learning-cycle.js
-import { createHash as createHash28, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash29, randomUUID as randomUUID12 } from "node:crypto";
 var receiptSchema3 = external_exports.object({
   /** The session and turn of the execution this usage belongs to; one receipt per turn. */
   sessionId: external_exports.string().uuid(),
@@ -76911,7 +77964,7 @@ async function runResidentLearningCycle(options) {
       });
       await append("exploration", {
         observations: exploration,
-        digest: createHash28("sha256").update(JSON.stringify(exploration)).digest("hex")
+        digest: createHash29("sha256").update(JSON.stringify(exploration)).digest("hex")
       }, "explore");
       const problem2 = resourceProblem(true);
       if (problem2)
@@ -76953,7 +78006,7 @@ async function runResidentLearningCycle(options) {
       await append("evaluation", {
         baselineRevision,
         candidateRevision,
-        digest: createHash28("sha256").update(JSON.stringify(batch)).digest("hex"),
+        digest: createHash29("sha256").update(JSON.stringify(batch)).digest("hex"),
         baselineTrajectories: batch.baseline.map((t) => t.trajectoryId),
         candidateTrajectories: batch.candidate.map((t) => t.trajectoryId)
       }, name2);
@@ -77248,7 +78301,7 @@ function createResidentToolEvidenceSource(options) {
 __name(createResidentToolEvidenceSource, "createResidentToolEvidenceSource");
 
 // ../sdk/dist/manager/resident/learning-store.js
-import { createHash as createHash29, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash30, randomUUID as randomUUID13 } from "node:crypto";
 import { closeSync as closeSync2, existsSync as existsSync5, fsyncSync as fsyncSync2, linkSync as linkSync2, lstatSync as lstatSync4, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname19, join as join35, resolve as resolve21 } from "node:path";
@@ -77277,7 +78330,7 @@ var learningObservationSchema = learningTargetSchema.extend({
 
 // ../sdk/dist/manager/resident/learning-store.js
 var uuid3 = external_exports.string().uuid().transform((id3) => id3.toLowerCase());
-var digest6 = /* @__PURE__ */ __name((text9) => createHash29("sha256").update(text9).digest("hex"), "digest");
+var digest6 = /* @__PURE__ */ __name((text9) => createHash30("sha256").update(text9).digest("hex"), "digest");
 var MAX_EVENT_BYTES = 256 * 1024;
 var MAX_ARTIFACT_BYTES = 8 * 1024 * 1024;
 var MAX_EVENTS = 4096;
@@ -77952,7 +79005,7 @@ function parsePeerAddress(address2) {
 __name(parsePeerAddress, "parsePeerAddress");
 
 // ../sdk/dist/peers/record.js
-import { createHash as createHash30 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 
 // ../sdk/dist/peers/protocol.js
 var PEER_PROTOCOL_VERSION = "namzu-peer/1";
@@ -78071,7 +79124,7 @@ var PeerRecordSchema = external_exports.object({
 }).strict();
 var PEER_REF_HEX_LENGTH = 6;
 function derivePeerRef(sessionId5) {
-  return createHash30("sha256").update(sessionId5, "utf8").digest("hex").slice(0, PEER_REF_HEX_LENGTH);
+  return createHash31("sha256").update(sessionId5, "utf8").digest("hex").slice(0, PEER_REF_HEX_LENGTH);
 }
 __name(derivePeerRef, "derivePeerRef");
 
@@ -80088,10 +81141,10 @@ var DiskPalMessagePolicy = class {
 };
 
 // ../sdk/dist/pals/activity/source.js
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 
 // ../sdk/dist/pals/activity/projection.js
-import { createHash as createHash31 } from "node:crypto";
+import { createHash as createHash32 } from "node:crypto";
 var activityId2 = external_exports.custom((value) => isEntityId(value, "activity"));
 var checkpointId3 = external_exports.custom((value) => isEntityId(value, "checkpoint"));
 var toolUseId2 = external_exports.string().min(1).max(512).regex(/^[A-Za-z0-9_.:-]+$/);
@@ -80150,7 +81203,7 @@ function projectPalActivity(entry, scopeHash) {
       return null;
   }
   return Object.freeze({
-    id: createHash31("sha256").update(JSON.stringify(["pal-activity/1", scopeHash, pointer2])).digest("hex"),
+    id: createHash32("sha256").update(JSON.stringify(["pal-activity/1", scopeHash, pointer2])).digest("hex"),
     type: record3.type,
     sessionId: record3.sessionId,
     ..."turnId" in record3 ? { turnId: record3.turnId } : {},
@@ -80244,7 +81297,7 @@ function createPalActivitySource(options) {
       if (definition.id !== scope.palId || definition.revision !== scope.profileRevision)
         throw new PalActivityIntegrityError();
       const workspace = definition.workspace;
-      const scopeHash = createHash32("sha256").update(JSON.stringify([
+      const scopeHash = createHash33("sha256").update(JSON.stringify([
         "pal-activity/1",
         scope.tenantId,
         scope.projectId,
@@ -81091,7 +82144,7 @@ async function publishPalActivityOnce(options, id3, input) {
 __name(publishPalActivityOnce, "publishPalActivityOnce");
 
 // ../sdk/dist/pals/activity/causality.js
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 import { isDeepStrictEqual as isDeepStrictEqual12 } from "node:util";
 var requestMarkerSchema = external_exports.object({
   type: external_exports.literal("request_envelope"),
@@ -81170,7 +82223,7 @@ function createPalActivityCausalityResolver(options) {
     const root = entries2[0]?.record;
     if (root?.type !== "session_started" || root.parent || root.forkedFrom || root.tenantId !== scope.tenantId || root.projectId !== scope.projectId || root.cwd !== workspace || root.origin?.protocol !== "desktop" || root.origin.externalSessionId !== JSON.stringify(["namzu-pal", scope.palId, scope.profileRevision, scope.sessionId]))
       unavailable3();
-    const scopeHash = createHash33("sha256").update(JSON.stringify([
+    const scopeHash = createHash34("sha256").update(JSON.stringify([
       "pal-activity/1",
       scope.tenantId,
       scope.projectId,
@@ -81236,7 +82289,7 @@ function createPalActivityCausalityResolver(options) {
 __name(createPalActivityCausalityResolver, "createPalActivityCausalityResolver");
 
 // ../sdk/dist/tools/builtins/skill.js
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 var inputSchema6 = external_exports.object({
   name: external_exports.string().min(1).optional().describe("The skill to load, exactly as listed in the available-skills manifest. Omit it to list model-invocable skills."),
   cursor: external_exports.string().max(160).optional().describe("Opaque continuation cursor returned by an earlier call in the same mode.")
@@ -81246,7 +82299,7 @@ var LIST_CURSOR_PATTERN = /^v1\.list\.(0|[1-9][0-9]*)\.([01])\.([A-Za-z0-9_-]{43
 var MAX_SKILLS_PER_PAGE = 20;
 var OVERSIZED_CATALOG_WARNING = "Some skills were omitted because their metadata is too large for this response budget.";
 function snapshotDigest(snapshot) {
-  return createHash34("sha256").update(JSON.stringify({
+  return createHash35("sha256").update(JSON.stringify({
     version: 1,
     name: snapshot.name,
     body: snapshot.body,
@@ -81290,7 +82343,7 @@ function activeOutputCap(maxChars) {
 }
 __name(activeOutputCap, "activeOutputCap");
 function listDigest(skills, maxChars) {
-  return createHash34("sha256").update(JSON.stringify({ version: 1, kind: "list", maxChars: maxChars ?? null, skills })).digest("base64url");
+  return createHash35("sha256").update(JSON.stringify({ version: 1, kind: "list", maxChars: maxChars ?? null, skills })).digest("base64url");
 }
 __name(listDigest, "listDigest");
 function serializeListPage(page) {
@@ -81899,7 +82952,7 @@ var webGuidanceContribution = {
 };
 
 // ../sdk/dist/tools/builtins/view-image.js
-import { createHash as createHash35 } from "node:crypto";
+import { createHash as createHash36 } from "node:crypto";
 import { open as open12 } from "node:fs/promises";
 import { inflateSync } from "node:zlib";
 
@@ -82430,7 +83483,7 @@ ${validation === "container" ? "The complete container and dimensions were valid
           width: image.width,
           height: image.height,
           sourceBytes: artifact.bytes.length,
-          sha256: createHash35("sha256").update(artifact.bytes).digest("hex"),
+          sha256: createHash36("sha256").update(artifact.bytes).digest("hex"),
           validation
         }
       };
@@ -82595,10 +83648,14 @@ var DEFAULT_MAX_BATCH_ACTIONS = 20;
 var DEFAULT_MAX_WAIT_MS = 1e4;
 var MAX_LISTED_WINDOWS = 50;
 var MAX_UI_SNAPSHOT_CHARS = 14e3;
-function computerUseUnavailableReason(provider) {
-  if (resolveProviderCapabilities(provider).supportsToolResultImages)
-    return void 0;
-  return `The ${provider.id} provider cannot return images in tool results, so the model would never see a screenshot. Use a provider that can (for example Anthropic, Codex or Google) for computer use.`;
+function computerUseUnavailableReason(provider, model) {
+  if (!resolveProviderCapabilities(provider).supportsToolResultImages) {
+    return `The ${provider.id} provider cannot return images in tool results, so the model would never see a screenshot. Use a provider that can (for example Anthropic, Codex or Google) for computer use.`;
+  }
+  if (model !== void 0 && !modelReadsImages(provider, model)) {
+    return `The model ${model} cannot read images, so it would never see a screenshot. Use a model that reads images for computer use.`;
+  }
+  return void 0;
 }
 __name(computerUseUnavailableReason, "computerUseUnavailableReason");
 var pointSchema = external_exports.object({
@@ -88617,6 +89674,7 @@ export {
   InMemorySessionLog,
   PromptContributionRegistry,
   resolveProviderCapabilities,
+  modelReadsImages,
   SearchToolsTool,
   isTerminalTaskStatus,
   selectTaskContext,
@@ -88649,6 +89707,7 @@ export {
   isReviewExempt,
   batchNeedsReview,
   createReviewHandler,
+  isImageInputRefusalMessage,
   withProviderFallback,
   buildProbeContext,
   probe,
@@ -88825,4 +89884,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-5J3T7DNL.js.map
+//# sourceMappingURL=chunk-FLUVTAXY.js.map