chainlesschain 0.166.115 → 0.166.117

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

@@ -15,6 +15,7 @@ import { captureEvolutionReleaseTrain } from "./evolution-release-train.js";
 import {
   snapshotAgentModelRequest,
   buildAgentModelRequest,
+  projectAgentOpaqueTransportBlock,
 } from "./agent-model-projection.js";
 import {
   snapshotSkillDecisionRequest,
@@ -28,8 +29,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 =
@@ -294,8 +294,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,
@@ -537,12 +536,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 +587,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;

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;