@genesislcap/ai-assistant 15.14.2 → 15.15.0

package/src/utils/condense-history.test.ts

@@ -497,8 +497,6 @@ suite('multi-trigger first-wins: the earliest-listed firing trigger is the reaso
   );
 });
 
-suite.run();
-
 // ── batched collapse (GENC-1476) ───────────────────────────────────────────
 // Condensation rewrites history in place, so collapsing the instant a trigger fires
 // breaks the prompt cache on nearly every call of a re-read loop. Batching holds the
@@ -662,3 +660,87 @@ batch('a mixed policy batches superseded but still honours agentEnd immediately'
 });
 
 batch.run();
+
+// ---------------------------------------------------------------------------
+// image-bearing tool results (GENC-1508)
+//
+// A render tool returns a few words of text plus ~15KB of base64. Sizing the payload
+// on `content` alone leaves it permanently under the floor, so the image rides every
+// later turn — the exact bytes condensation exists to shed. And a stub that leaves the
+// attachments in place claims a collapse that did not happen.
+// ---------------------------------------------------------------------------
+
+/** A tool result shaped like a mockup render: short text, one large image. */
+const imageToolMsg = (toolCallId: string, dataLen: number): ChatMessage => ({
+  role: 'tool',
+  content: 'rendered',
+  toolResult: {
+    toolCallId,
+    content: 'rendered',
+    attachments: [
+      { kind: 'image', name: 'mockup.png', mimeType: 'image/png', data: 'a'.repeat(dataLen) },
+    ],
+  },
+});
+
+suite('image bytes count toward the condense floor, so a short-text render condenses', () => {
+  const history: ChatMessage[] = [
+    asstCall('m1', 'render_mockup', { html: '<p/>' }),
+    imageToolMsg('m1', CONDENSE_MIN_CHARS + 500),
+    asstCall('m2', 'render_mockup', { html: '<p/>' }),
+    imageToolMsg('m2', CONDENSE_MIN_CHARS + 500),
+  ];
+  const policies = new Map<string, RegisteredCondensePolicy>([
+    ['m1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+    ['m2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+  ]);
+  const { on } = sink();
+  const out = applyCondensation(history, policies, ctx(), on);
+  assert.ok(
+    out[1].toolResult!.content.startsWith('['),
+    'the superseded render is collapsed to a stub — sizing on content alone would skip it',
+  );
+});
+
+suite('a condensed image result drops its attachments, not just its text', () => {
+  const history: ChatMessage[] = [
+    asstCall('m1', 'render_mockup', { html: '<p/>' }),
+    imageToolMsg('m1', CONDENSE_MIN_CHARS + 500),
+    asstCall('m2', 'render_mockup', { html: '<p/>' }),
+    imageToolMsg('m2', CONDENSE_MIN_CHARS + 500),
+  ];
+  const policies = new Map<string, RegisteredCondensePolicy>([
+    ['m1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+    ['m2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+  ]);
+  const { on } = sink();
+  const out = applyCondensation(history, policies, ctx(), on);
+  assert.is(
+    out[1].toolResult!.attachments,
+    undefined,
+    'leaving the image attached would shed none of the bytes the stub claims were elided',
+  );
+  assert.equal(
+    out[3].toolResult!.attachments?.length,
+    1,
+    'the surviving latest render keeps its image',
+  );
+});
+
+suite('a short text-only result is still below the floor with no attachments', () => {
+  const history: ChatMessage[] = [
+    asstCall('s1', 'render_mockup', {}),
+    toolMsg('s1', 'rendered'),
+    asstCall('s2', 'render_mockup', {}),
+    toolMsg('s2', 'rendered'),
+  ];
+  const policies = new Map<string, RegisteredCondensePolicy>([
+    ['s1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+    ['s2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
+  ]);
+  const { on } = sink();
+  const out = applyCondensation(history, policies, ctx(), on);
+  assert.is(out[1].toolResult!.content, 'rendered', 'the floor still protects small payloads');
+});
+
+suite.run();

package/src/utils/condense-history.ts

@@ -169,11 +169,19 @@ function condenseStub(
   trigger: CondenseTrigger,
   origLen: number,
   restorable: boolean,
+  /**
+   * Images elided alongside the text. Reported separately because the model reads this stub as
+   * fact: folding base64 bytes into the char count would tell it a 15KB render was "~15447
+   * chars" of prose. One variable cannot be both the size FLOOR (bytes, correctly) and a
+   * model-facing description (characters).
+   */
+  imageCount = 0,
 ): string {
   const what = target === 'args' ? 'args' : 'result';
   const key = trigger.kind === 'superseded' ? ` ${trigger.by}` : '';
   const restore = restorable ? '; re-call to restore' : '';
-  return `[${tool}${key} — ${what} elided, ~${origLen} chars (${triggerReason(trigger)})${restore}]`;
+  const images = imageCount > 0 ? ` + ${imageCount} image${imageCount === 1 ? '' : 's'}` : '';
+  return `[${tool}${key} — ${what} elided, ~${origLen} chars${images} (${triggerReason(trigger)})${restore}]`;
 }
 
 /** Stable label for the `context.condensed` meta-event's `trigger` field. */
@@ -392,7 +400,18 @@ export function applyCondensation(
       const entry = policies.get(msg.toolResult.toolCallId);
       // Defensive `?? 0` for restored/malformed history — `content` is typed
       // `string`, but a 0-length payload is simply below the floor and skipped.
-      const origLen = msg.toolResult.content?.length ?? 0;
+      //
+      // Attachment bytes COUNT toward the floor (GENC-1508). An image-bearing result is
+      // typically a few words of text — "rendered the mockup" — plus ~15KB of base64, so
+      // sizing on `content` alone leaves it permanently under CONDENSE_MIN_CHARS and the
+      // image rides every subsequent turn. That is the exact payload condensation exists
+      // to shed, so it must be what is measured.
+      const textLen = msg.toolResult.content?.length ?? 0;
+      const images = msg.toolResult.attachments ?? [];
+      // Bytes gate the FLOOR (an image result is a few words of text plus ~15KB of base64, so
+      // sizing on text alone would never condense it); `textLen` and the image count are what
+      // the model is told. See condenseStub.
+      const origLen = textLen + images.reduce((n, att) => n + (att.data?.length ?? 0), 0);
       const fired = entry?.policy.response
         ? firstFired(msg.toolResult.toolCallId, entry)
         : undefined;
@@ -402,7 +421,7 @@ export function applyCondensation(
         // Kept non-empty — Anthropic rejects empty tool_result content.
         const content =
           result === 'drop' || result === 'pointer'
-            ? condenseStub('response', tool, fired, origLen, result === 'pointer')
+            ? condenseStub('response', tool, fired, textLen, result === 'pointer', images.length)
             : result.replaceWith;
         if (!entry.reportedResponse) {
           entry.reportedResponse = true;
@@ -416,7 +435,11 @@ export function applyCondensation(
             tokensSaved: estimateTokensSaved(origLen, content.length),
           });
         }
-        return { ...msg, toolResult: { ...msg.toolResult, content } };
+        // `attachments` is dropped, not spread through: the stub says the payload was
+        // elided, and leaving the images attached would make that a lie AND shed none of
+        // the bytes the condensation was performed to shed.
+        const { attachments: _elided, ...restOfResult } = msg.toolResult;
+        return { ...msg, toolResult: { ...restOfResult, content } };
       }
     }
 

package/src/utils/history-transform.test.ts

@@ -7,6 +7,7 @@ import {
   COMPACT_MIN_MESSAGES_TO_COMPACT,
   findCompactionCut,
   normalizeForProvider,
+  transformHistoryForAgent,
 } from './history-transform';
 
 const asMsg = (o: Record<string, unknown>): ChatMessage => o as unknown as ChatMessage;
@@ -194,4 +195,34 @@ Suite('compactionDividerLabel pluralizes and falls back to 0', () => {
   );
 });
 
+// ── masking another agent's tool payload (GENC-1508) ─────────────────────────
+
+Suite('transformHistoryForAgent drops tool-result IMAGES, not just the text', () => {
+  const history: ChatMessage[] = [
+    asMsg({
+      role: 'tool',
+      content: '',
+      agentName: 'other-agent',
+      toolResult: {
+        toolCallId: 'r1',
+        content: 'rendered the mockup',
+        attachments: [
+          { kind: 'image', name: 'mockup.png', mimeType: 'image/png', data: 'a'.repeat(2000) },
+        ],
+      },
+    }),
+  ];
+  const out = transformHistoryForAgent(history, 'this-agent');
+  assert.ok(
+    out[0].toolResult!.content.includes('omitted'),
+    'the text is stubbed, as it always was',
+  );
+  assert.is(
+    out[0].toolResult!.attachments,
+    undefined,
+    "masking exists to keep another agent's payload out of context — an image IS the payload, " +
+      'and stubbing the prose while shipping the render defeats the mask where it matters most',
+  );
+});
+
 Suite.run();

package/src/utils/history-transform.ts

@@ -10,9 +10,15 @@ function maskToolPayload(msg: ChatMessage): ChatMessage {
     return { ...msg, toolCalls: msg.toolCalls.map((tc) => ({ ...tc, args: {} })) };
   }
   if (msg.toolResult) {
+    // `attachments` is dropped, not spread through. Masking exists to keep another agent's
+    // payload out of this one's context, and an image is the largest payload there is — spreading
+    // it would stub the prose while still shipping the render, defeating the mask for exactly the
+    // case it matters most. `applyHistoryCap` masks everything past the cap for sub-agent context,
+    // so without this every older image rides every sub-agent turn under an "omitted" label.
+    const { attachments: _masked, ...restOfResult } = msg.toolResult;
     return {
       ...msg,
-      toolResult: { ...msg.toolResult, content: "[other agent's tool result omitted]" },
+      toolResult: { ...restOfResult, content: "[other agent's tool result omitted]" },
     };
   }
   return msg;