chainlesschain 0.166.115 → 0.166.118

package/src/lib/context-memory-kernel/provider-context.js

@@ -11,6 +11,11 @@ import {
   memoryRecordsToContextItems,
   messagesToContextItems,
 } from "./message-adapter.js";
+import {
+  adjustContextImageTokenEstimates,
+  captureContextImageTransport,
+  restoreContextImageTransport,
+} from "./context-image-transport.js";
 
 export const SEMANTIC_CANDIDATE_REQUEST_SCHEMA =
   "chainlesschain.context-memory-semantic-candidate-request/v1";
@@ -217,12 +222,17 @@ export async function prepareCanonicalProviderContext(
     ),
     ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
   });
-  const messageItems = messagesToContextItems(messages, {
-    sessionId,
-    allowedSinks: [sink],
-    trustCurrentSystemPolicy: true,
-    trustedSystemIndexes: options.contextMemoryTrustedSystemIndexes,
-  });
+  const imageTransport = captureContextImageTransport(messages);
+  const messageItems = adjustContextImageTokenEstimates(
+    messagesToContextItems(imageTransport.messages, {
+      sessionId,
+      allowedSinks: [sink],
+      trustCurrentSystemPolicy: true,
+      trustedSystemIndexes: options.contextMemoryTrustedSystemIndexes,
+      allowExternalization: false,
+    }),
+    imageTransport.captures,
+  );
   const memoryItems = memoryRecordsToContextItems(
     recall.results.map((entry) => entry.record),
     { insertionSequence: Math.max(0, messages.length - 1) },
@@ -290,9 +300,14 @@ export async function prepareCanonicalProviderContext(
     sessionHead,
     memoryRevision: recall.memoryRevision,
   });
+  const selectedMessages = contextItemsToMessages(
+    plan.selected.filter((item) => item.kind !== "tool-schema"),
+    { sessionId },
+  );
   return {
-    messages: contextItemsToMessages(
-      plan.selected.filter((item) => item.kind !== "tool-schema"),
+    messages: restoreContextImageTransport(
+      selectedMessages,
+      imageTransport.captures,
     ),
     selectedToolNames: toolItems
       .filter((item) => plan.selectedItemIds.includes(item.itemId))

package/src/lib/evolution/agent-evolution-ingress.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { types } from "node:util";
 import evolutionRun from "@chainlesschain/session-core/evolution-run";
+import { storageFailureCauseSuffix } from "../storage-failure-cause-codes.js";
 
 import { EvolutionEvidenceArtifactAdapter } from "./evolution-evidence-artifact-adapter.js";
 import {
@@ -8,13 +9,21 @@ import {
   EVOLUTION_SKILL_DECISION_PROJECTION_RULESET_DIGEST,
   EVOLUTION_PROJECTION_RULESET_DIGEST,
 } from "./evolution-evidence-projector.js";
-import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
+import {
+  EvolutionRunLedgerAdapter,
+  captureEvolutionRunAppendNext,
+} from "./evolution-run-ledger-adapter.js";
+import {
+  evidenceStorageLayoutForRun,
+  validateEvidenceStorageLayout,
+} from "./evolution-evidence-storage-layout.js";
 import { captureEvolutionRunWikiMaintenanceProducer } from "./evolution-run-wiki-maintenance-source.js";
 import { WIKI_MAINTENANCE_TRIGGER_KIND } from "./wiki-maintenance-trigger-ledger-adapter.js";
 import { captureEvolutionReleaseTrain } from "./evolution-release-train.js";
 import {
   snapshotAgentModelRequest,
   buildAgentModelRequest,
+  projectAgentOpaqueTransportBlock,
 } from "./agent-model-projection.js";
 import {
   snapshotSkillDecisionRequest,
@@ -28,8 +37,7 @@ export const AGENT_EVOLUTION_INGRESS_SCHEMA =
 export const AGENT_EVOLUTION_INGRESS_FAILED_CODE =
   "CC_AGENT_EVOLUTION_INGRESS_FAILED";
 
-const RESPONSE_CACHE_RECORD_SCHEMA =
-  "chainlesschain.model-response-cache/v2";
+const RESPONSE_CACHE_RECORD_SCHEMA = "chainlesschain.model-response-cache/v2";
 const LEGACY_RESPONSE_CACHE_RECORD_SCHEMA =
   "chainlesschain.model-response-cache/v1";
 const RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA =
@@ -152,6 +160,7 @@ function ingressFailure(cause) {
     `Agent evolution ingress failed: ${cause?.message || String(cause)}`,
     { cause },
   );
+  error.message += storageFailureCauseSuffix(cause);
   error.code = AGENT_EVOLUTION_INGRESS_FAILED_CODE;
   return error;
 }
@@ -165,6 +174,7 @@ function guardIngress(operation) {
 export function createAgentEvolutionIngress({
   evidenceAdapter,
   runAdapter,
+  evidenceStorageLayout = "legacy",
   sourceEnvelopeAuthority,
   openCacheSourceRun = null,
   wikiMaintenanceProducer = null,
@@ -173,6 +183,7 @@ export function createAgentEvolutionIngress({
   now = () => new Date(),
   idGenerator = () => crypto.randomUUID(),
 } = {}) {
+  validateEvidenceStorageLayout(evidenceStorageLayout);
   if (!(evidenceAdapter instanceof EvolutionEvidenceArtifactAdapter)) {
     throw new TypeError("an EvolutionEvidenceArtifactAdapter is required");
   }
@@ -245,10 +256,24 @@ export function createAgentEvolutionIngress({
     return timestamp(iso, "ingress timestamp");
   };
 
+  const assertLoadedLayout = (loaded) => {
+    if (
+      evidenceStorageLayoutForRun(loaded.events, evidenceStorageLayout) !==
+      evidenceStorageLayout
+    )
+      throw new Error("Authenticated Run Evidence storage layout changed");
+  };
+
   const appendStarted = () => {
     const loaded = runAdapter.load();
+    assertLoadedLayout(loaded);
     if (loaded.events.length > 0) return loaded.projection;
     const occurredAt = currentTimestamp();
+    const data = {
+      occurredAt,
+      runtime: "agent",
+      ...(evidenceStorageLayout === "legacy" ? {} : { evidenceStorageLayout }),
+    };
     return runAdapter.appendEvent({
       schema: EVOLUTION_RUN_EVENT_SCHEMA,
       tenantId: descriptor.tenantId,
@@ -257,10 +282,10 @@ export function createAgentEvolutionIngress({
       sequence: 1,
       type: EVENT_TYPES.RUN_STARTED,
       subjectId: descriptor.runId,
-      payloadDigest: digest({ occurredAt, runtime: "agent" }),
+      payloadDigest: digest(data),
       artifactRef: null,
       keyRef: null,
-      data: { occurredAt, runtime: "agent" },
+      data,
     }).projection;
   };
 
@@ -294,8 +319,7 @@ export function createAgentEvolutionIngress({
         const payload = cacheRecord
           ? {
               schema: RESPONSE_CACHE_RECORD_SCHEMA,
-              identifierBindingSchema:
-                RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA,
+              identifierBindingSchema: RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA,
               requestKeyBinding: cacheIdentifierBinding(
                 "request key",
                 evidence.requestKey,
@@ -348,13 +372,14 @@ export function createAgentEvolutionIngress({
             "Agent evidence persistence returned an unbound result",
           );
         }
-        const current = runAdapter.load();
-        const appended = runAdapter.appendEvent({
+        const appendNext = captureEvolutionRunAppendNext(runAdapter);
+        // Custom ports keep their established load-before-append phase.
+        const current = appendNext === null ? runAdapter.load() : null;
+        const event = {
           schema: EVOLUTION_RUN_EVENT_SCHEMA,
           tenantId: descriptor.tenantId,
           runId: descriptor.runId,
           eventId,
-          sequence: current.events.length + 1,
           type: EVENT_TYPES.RAW_EVENT_REFERENCED,
           subjectId: persisted.evidenceId,
           payloadDigest: persisted.manifest.digest,
@@ -372,7 +397,14 @@ export function createAgentEvolutionIngress({
                   candidateSetDigest: skillDecisionRequest.candidateSetDigest,
                 }),
           },
-        });
+        };
+        const appended =
+          appendNext !== null
+            ? appendNext(event)
+            : runAdapter.appendEvent({
+                ...event,
+                sequence: current.events.length + 1,
+              });
         if (kind === "model-input") {
           lastModelResponse = null;
           modelAdmissionPending = true;
@@ -537,12 +569,11 @@ export function createAgentEvolutionIngress({
             throw new Error(
               "Cache response projection is not safe or request-bound",
             );
-          const responseEvent = loaded.events.find(
-            (item) =>
-              legacyRecord
-                ? item.eventId === record.sourceEventId
-                : cacheIdentifierBinding("source event ID", item.eventId) ===
-                  record.sourceEventIdBinding,
+          const responseEvent = loaded.events.find((item) =>
+            legacyRecord
+              ? item.eventId === record.sourceEventId
+              : cacheIdentifierBinding("source event ID", item.eventId) ===
+                record.sourceEventIdBinding,
           );
           if (
             responseEvent?.data?.evidenceKind !== "response-completed" ||
@@ -589,8 +620,60 @@ export function createAgentEvolutionIngress({
       }
       return ingest("model-input", snapshot, {}, snapshot);
     },
-    ingestUserPrompt: async (input, options) =>
-      ingest("user-prompt", { input: cloneEvidence(input) }, options),
+    ingestUserPrompt: async (input, options) => {
+      const snapshot = cloneEvidence(input);
+      try {
+        if (
+          Array.isArray(snapshot?.messages) &&
+          typeof snapshot.source === "string"
+        ) {
+          const captured = snapshotAgentModelRequest({
+            messages: snapshot.messages,
+            tools: [],
+          });
+          // User-prompt is a small event, not a second image transport. Bind
+          // each image to its complete original block; model-input admission
+          // separately retains the original image in encrypted Raw evidence.
+          snapshot.messages = captured.messages.map(
+            (message, messageIndex) => ({
+              ...message,
+              ...(Array.isArray(message.content)
+                ? {
+                    content: message.content.map((block, blockIndex) =>
+                      block.type === "image_url"
+                        ? projectAgentOpaqueTransportBlock(
+                            block,
+                            `messages.${messageIndex}.content.${blockIndex}`,
+                          )
+                        : block,
+                    ),
+                  }
+                : {}),
+            }),
+          );
+        } else if (Array.isArray(snapshot?.content)) {
+          const captured = snapshotAgentModelRequest({
+            messages: [{ role: "user", content: snapshot.content }],
+            tools: [],
+          });
+          // REPL callers pass the current user content directly, without a
+          // source label or a messages wrapper. Apply the same image binding.
+          snapshot.content = captured.messages[0].content.map(
+            (block, blockIndex) =>
+              block.type === "image_url"
+                ? projectAgentOpaqueTransportBlock(
+                    block,
+                    `messages.0.content.${blockIndex}`,
+                  )
+                : block,
+          );
+        }
+      } catch (error) {
+        admissionFailure ??= ingressFailure(error);
+        throw admissionFailure;
+      }
+      return ingest("user-prompt", { input: snapshot }, options);
+    },
     ingestAgentEvent: async (event, options) => {
       if (admissionFailure !== null) throw admissionFailure;
       let type;
@@ -627,6 +710,7 @@ export function createAgentEvolutionIngress({
         serialize(async () => {
           if (admissionFailure !== null) throw admissionFailure;
           const loaded = runAdapter.load();
+          assertLoadedLayout(loaded);
           let projection;
           if (loaded.projection?.status === "completed") {
             projection = loaded.projection;

package/src/lib/evolution/agent-evolution-runtime-composition.js

@@ -14,6 +14,11 @@ import {
   EvolutionEvidenceReader,
 } from "./evolution-evidence-projector.js";
 import { EvolutionArtifactPorts } from "./evolution-artifact-ports.js";
+import {
+  createTypedEvidenceArtifactPorts,
+  evidenceStorageLayoutForRun,
+  validateEvidenceStorageLayout,
+} from "./evolution-evidence-storage-layout.js";
 import {
   captureEvolutionLedgerFileBackend,
   createEvolutionLedgerFileBackend,
@@ -172,16 +177,14 @@ function layout(stateRootDir, tenantId, runId, initialize = true, fsImpl = fs) {
   const result = Object.freeze({
     rootDir,
     artifactDir: path.join(scope, "artifacts"),
+    evidenceArtifactDir: path.join(scope, "evidence-artifacts"),
     rawDir: path.join(scope, "raw"),
     ledgerRootDir: path.join(scope, "ledger-events"),
     ledgerAuthorityRootDir: path.join(scope, "ledger-authority"),
     witnessFilePath: path.join(scope, "witness", "checkpoint.json"),
   });
   if (initialize) {
-    ensureDirectoryTreeDurable(
-      fsImpl,
-      path.dirname(result.witnessFilePath),
-    );
+    ensureDirectoryTreeDurable(fsImpl, path.dirname(result.witnessFilePath));
   }
   return result;
 }
@@ -224,6 +227,7 @@ export function createAgentEvolutionRuntimeComposition({
   stateRootDir,
   authorities: authorityInput,
   evidenceTtlMs,
+  evidenceStorageLayout = "legacy",
   witnessId: witnessIdInput,
   clock: clockInput = Date.now,
   evidenceIdGenerator,
@@ -240,6 +244,7 @@ export function createAgentEvolutionRuntimeComposition({
   witnessMaximumBytes,
   ledgerV2: ledgerV2Input = null,
 } = {}) {
+  validateEvidenceStorageLayout(evidenceStorageLayout);
   const ledgerV2 =
     ledgerV2Input === null
       ? null
@@ -445,14 +450,6 @@ export function createAgentEvolutionRuntimeComposition({
     attestationVerifier: ports.attestationVerifier,
     now: () => new Date(clock()),
   });
-  const evidenceAdapter = new EvolutionEvidenceArtifactAdapter({
-    tenantId,
-    audience,
-    projector,
-    bundleVerifier,
-    artifactPorts,
-    ...(evidenceTtlMs === undefined ? {} : { ttlMs: evidenceTtlMs }),
-  });
   const ledgerArtifactResolver =
     artifactPorts.createEvolutionLedgerArtifactResolver({
       purpose: "evolution-ledger",
@@ -516,6 +513,46 @@ export function createAgentEvolutionRuntimeComposition({
     ledgerArtifactResolver,
     now: clock,
   });
+  const createEvidenceAdapter = (run, runStorage, mainPorts, emptyLayout) => {
+    const loaded = run.load();
+    const selectedLayout = evidenceStorageLayoutForRun(
+      loaded.events,
+      emptyLayout,
+    );
+    return {
+      selectedLayout,
+      adapter: new EvolutionEvidenceArtifactAdapter({
+        tenantId,
+        audience,
+        projector,
+        bundleVerifier,
+        ...(selectedLayout === "legacy"
+          ? { artifactPorts: mainPorts }
+          : {
+              typedArtifactPorts: createTypedEvidenceArtifactPorts({
+                rootDir: runStorage.evidenceArtifactDir,
+                tenantId,
+                audience,
+                artifactAuthority: {
+                  envelopeSigner: ports.artifactEnvelopeSigner,
+                  envelopeVerifier: ports.artifactEnvelopeVerifier,
+                  currentAuthorityResolver:
+                    ports.artifactCurrentAuthorityResolver,
+                },
+                now: clock,
+                existingRun: loaded.events.length > 0,
+              }),
+            }),
+        ...(evidenceTtlMs === undefined ? {} : { ttlMs: evidenceTtlMs }),
+      }),
+    };
+  };
+  const { adapter: evidenceAdapter, selectedLayout } = createEvidenceAdapter(
+    runAdapter,
+    storage,
+    artifactPorts,
+    evidenceStorageLayout,
+  );
   let wikiMaintenance = null;
   let wikiMaintainer = null;
   if (wikiConfiguration !== null) {
@@ -707,6 +744,7 @@ export function createAgentEvolutionRuntimeComposition({
   const evolutionIngress = createAgentEvolutionIngress({
     evidenceAdapter,
     runAdapter,
+    evidenceStorageLayout: selectedLayout,
     openCacheSourceRun: (input) => {
       const sourceRunId = identifier(input, "cache source runId");
       const sourceStorage = layout(
@@ -758,22 +796,22 @@ export function createAgentEvolutionRuntimeComposition({
         ...(lockTimeoutMs === undefined ? {} : { lockTimeoutMs }),
         ...(witnessMaximumBytes === undefined ? {} : { witnessMaximumBytes }),
       });
+      const sourceRunAdapter = new EvolutionRunLedgerAdapter({
+        descriptor: { ...runAdapter.descriptor, runId: sourceRunId },
+        artifactPorts: sourcePorts,
+        ledger: sourceBackend.ledger,
+        ledgerArtifactResolver: sourceResolver,
+        now: clock,
+      });
+      const sourceEvidence = createEvidenceAdapter(
+        sourceRunAdapter,
+        sourceStorage,
+        sourcePorts,
+        "legacy",
+      );
       return {
-        runAdapter: new EvolutionRunLedgerAdapter({
-          descriptor: { ...runAdapter.descriptor, runId: sourceRunId },
-          artifactPorts: sourcePorts,
-          ledger: sourceBackend.ledger,
-          ledgerArtifactResolver: sourceResolver,
-          now: clock,
-        }),
-        evidenceAdapter: new EvolutionEvidenceArtifactAdapter({
-          tenantId,
-          audience,
-          projector,
-          bundleVerifier,
-          artifactPorts: sourcePorts,
-          ...(evidenceTtlMs === undefined ? {} : { ttlMs: evidenceTtlMs }),
-        }),
+        runAdapter: sourceRunAdapter,
+        evidenceAdapter: sourceEvidence.adapter,
       };
     },
     sourceEnvelopeAuthority: ports.sourceEnvelope,

package/src/lib/evolution/agent-model-projection.js

@@ -1,9 +1,26 @@
 import { createHash } from "node:crypto";
 import { types } from "node:util";
 import { isAgentToolArgumentsPath } from "./evidence-json-text.js";
+import {
+  MAX_INPUT_IMAGES,
+  MAX_INPUT_IMAGE_BYTES,
+} from "../image-file-boundary.js";
 
-const MAX_NODES = 32_768;
-const MAX_BYTES = 1024 * 1024;
+export const AGENT_MODEL_REQUEST_LIMITS = Object.freeze({
+  maxNodes: 32_768,
+  maxBytes: 1024 * 1024,
+  maxDepth: 24,
+});
+export const AGENT_MODEL_IMAGE_LIMITS = Object.freeze({
+  maxImageBytes: MAX_INPUT_IMAGE_BYTES,
+  maxMessageImageBytes: MAX_INPUT_IMAGE_BYTES,
+  maxMessageImages: MAX_INPUT_IMAGES,
+  maxRequestImageBytes: 40 * 1024 * 1024,
+  // Includes bounded base64 expansion, the text allocation and URL headers.
+  maxCanonicalRequestBytes: 56 * 1024 * 1024,
+});
+const MAX_NODES = AGENT_MODEL_REQUEST_LIMITS.maxNodes;
+const MAX_BYTES = AGENT_MODEL_REQUEST_LIMITS.maxBytes;
 const MESSAGE_KEYS = new Set([
   "role",
   "content",
@@ -59,6 +76,32 @@ function blockDigest(value) {
     .digest("hex")}`;
 }
 
+function imageDataUrlBudget(url) {
+  if (
+    typeof url !== "string" ||
+    url.length > Math.ceil(AGENT_MODEL_IMAGE_LIMITS.maxImageBytes / 3) * 4 + 128
+  )
+    throw new TypeError(
+      `Agent image exceeds its ${AGENT_MODEL_IMAGE_LIMITS.maxImageBytes / 1024 / 1024} MiB image byte budget`,
+    );
+  const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/u.exec(url);
+  if (!match || !IMAGE_MEDIA_TYPES.has(match[1]) || match[2].length % 4 !== 0)
+    throw new TypeError(
+      "Agent image block requires a supported base64 data URL",
+    );
+  const decodedBytes =
+    (match[2].length / 4) * 3 -
+    (match[2].endsWith("==") ? 2 : match[2].endsWith("=") ? 1 : 0);
+  if (decodedBytes > AGENT_MODEL_IMAGE_LIMITS.maxImageBytes)
+    throw new TypeError(
+      `Agent image exceeds its ${AGENT_MODEL_IMAGE_LIMITS.maxImageBytes / 1024 / 1024} MiB image byte budget`,
+    );
+  const decoded = Buffer.from(match[2], "base64");
+  if (!decoded.length || decoded.toString("base64") !== match[2])
+    throw new TypeError("Agent image block contains non-canonical base64");
+  return { decodedBytes, encodedBytes: match[2].length };
+}
+
 function imageBlock(value) {
   if (!exactKeys(value, new Set(["type", "image_url"]))) return null;
   const imageKeys = new Set(
@@ -74,18 +117,7 @@ function imageBlock(value) {
   ) {
     throw new TypeError("Agent image block has an unsupported protocol shape");
   }
-  const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/u.exec(
-    value.image_url.url,
-  );
-  if (!match || !IMAGE_MEDIA_TYPES.has(match[1]) || match[2].length % 4 !== 0) {
-    throw new TypeError(
-      "Agent image block requires a supported base64 data URL",
-    );
-  }
-  const decoded = Buffer.from(match[2], "base64");
-  if (!decoded.length || decoded.toString("base64") !== match[2]) {
-    throw new TypeError("Agent image block contains non-canonical base64");
-  }
+  imageDataUrlBudget(value.image_url.url);
   return value;
 }
 
@@ -319,18 +351,54 @@ export function snapshotAgentModelRequest(
 ) {
   let nodes = 0;
   let bytes = 0;
+  let imageBytes = 0;
+  let encodedImageBytes = 0;
+  const messageImageBudgets = new Map();
   const seen = new Set();
   const visit = (entry, depth, path = "") => {
-    if (++nodes > MAX_NODES || depth > 24) {
+    if (++nodes > MAX_NODES || depth > AGENT_MODEL_REQUEST_LIMITS.maxDepth) {
       throw new TypeError("Agent model request exceeds the input budget");
     }
     if (typeof entry === "string") {
-      if (entry.length > 8192 && !textPath(path, allowStructuredArgumentText)) {
+      const imageUrl = /^messages\.\d+\.content\.\d+\.image_url\.url$/u.test(
+        path,
+      );
+      let imageBudget = null;
+      if (imageUrl) {
+        imageBudget = imageDataUrlBudget(entry);
+        const messageIndex = path.split(".")[1];
+        const messageBudget = messageImageBudgets.get(messageIndex) ?? {
+          bytes: 0,
+          count: 0,
+        };
+        messageBudget.bytes += imageBudget.decodedBytes;
+        messageBudget.count++;
+        messageImageBudgets.set(messageIndex, messageBudget);
+        if (
+          messageBudget.bytes > AGENT_MODEL_IMAGE_LIMITS.maxMessageImageBytes ||
+          messageBudget.count > AGENT_MODEL_IMAGE_LIMITS.maxMessageImages
+        )
+          throw new TypeError(
+            `Agent images exceed the per-message image budget (${AGENT_MODEL_IMAGE_LIMITS.maxMessageImages} images / ${AGENT_MODEL_IMAGE_LIMITS.maxMessageImageBytes / 1024 / 1024} MiB)`,
+          );
+        imageBytes += imageBudget.decodedBytes;
+        encodedImageBytes += imageBudget.encodedBytes;
+        if (imageBytes > AGENT_MODEL_IMAGE_LIMITS.maxRequestImageBytes)
+          throw new TypeError(
+            `Agent images exceed the ${AGENT_MODEL_IMAGE_LIMITS.maxRequestImageBytes / 1024 / 1024} MiB request image byte budget`,
+          );
+      }
+      if (
+        entry.length > 8192 &&
+        !imageUrl &&
+        !textPath(path, allowStructuredArgumentText)
+      ) {
         throw new TypeError(
           "Agent model protocol metadata exceeds the text budget",
         );
       }
-      bytes += Buffer.byteLength(entry, "utf8");
+      bytes +=
+        Buffer.byteLength(entry, "utf8") - (imageBudget?.encodedBytes ?? 0);
       if (bytes > MAX_BYTES)
         throw new TypeError("Agent model request is too large");
       return entry;
@@ -405,7 +473,11 @@ export function snapshotAgentModelRequest(
   );
   // Include escaping, punctuation and numeric values in the transport/storage
   // budget, not just string values. Whole fields are never split or truncated.
-  if (Buffer.byteLength(JSON.stringify(request), "utf8") > MAX_BYTES) {
+  const canonicalBytes = Buffer.byteLength(JSON.stringify(request), "utf8");
+  if (
+    canonicalBytes - encodedImageBytes > MAX_BYTES ||
+    canonicalBytes > AGENT_MODEL_IMAGE_LIMITS.maxCanonicalRequestBytes
+  ) {
     throw new TypeError("Agent model request is too large");
   }
   return request;