@genesislcap/ai-assistant 15.5.0 → 15.6.0

package/dist/ai-assistant.api.json

@@ -5662,6 +5662,33 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@genesislcap/ai-assistant!ChatDriverConfig#condenseBatchCalls:member",
+              "docComment": "/**\n * Collapse `condenseWhen` payloads in batches of this many model-calls rather than as soon as each trigger fires. A positive integer; decimals are floored and anything below `1` becomes `1`. Default `1` — collapse immediately, the historical behaviour.\n *\n * Condensation rewrites history in place, so collapsing continuously breaks the provider's prompt cache on nearly every call of a re-read loop. Raising this trades up to that many calls' worth of extra context for one cache break per batch.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "condenseBatchCalls?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Beta",
+              "name": "condenseBatchCalls",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@genesislcap/ai-assistant!ChatDriverConfig#maxFoldOperations:member",

package/dist/ai-assistant.d.ts

@@ -1377,6 +1377,8 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
     private unsubscribeRegistry?;
     /** Hard cap on tool-loop iterations. */
     private readonly maxToolIterations;
+    /** Model-calls per condensation batch; `1` collapses as soon as a trigger fires. */
+    private readonly condenseBatchCalls;
     /** Session identity used to file meta events onto the shared debug-log timeline. */
     private readonly sessionKey;
     /** Injected activity bus; defaults to a no-op off-browser (Node/tests/headless). */
@@ -1713,6 +1715,16 @@ export declare interface ChatDriverConfig {
     maxToolIterations?: number;
     /** Hard cap on fold operations. Default `5`. */
     maxFoldOperations?: number;
+    /**
+     * Collapse `condenseWhen` payloads in batches of this many model-calls rather than as
+     * soon as each trigger fires. A positive integer; decimals are floored and anything
+     * below `1` becomes `1`. Default `1` — collapse immediately, the historical behaviour.
+     *
+     * Condensation rewrites history in place, so collapsing continuously breaks the
+     * provider's prompt cache on nearly every call of a re-read loop. Raising this trades
+     * up to that many calls' worth of extra context for one cache break per batch.
+     */
+    condenseBatchCalls?: number;
     /** Ring-buffer size for per-turn snapshots. Default `400`. */
     maxTurnSnapshots?: number;
     /** Session identity used to file meta events onto the shared debug-log timeline. */

package/dist/chat-driver.cjs

@@ -2843,6 +2843,9 @@ function estimateTokensSaved(origLen, stubLen) {
 function applyCondensation(history, policies, ctx, onCondensed) {
   if (policies.size === 0) return history;
   const triggersOf = (entry) => Array.isArray(entry.policy.on) ? entry.policy.on : [entry.policy.on];
+  const batchCalls = Math.max(1, Math.floor(ctx.batchCalls ?? 1));
+  const asOf = batchCalls === 1 ? ctx.modelCall : Math.floor(ctx.modelCall / batchCalls) * batchCalls;
+  const withinBatch = (entry) => batchCalls === 1 || entry.iteration <= asOf;
   const latestByKey = /* @__PURE__ */ new Map();
   const nameById = /* @__PURE__ */ new Map();
   for (const msg of history) {
@@ -2850,7 +2853,7 @@ function applyCondensation(history, policies, ctx, onCondensed) {
     for (const tc of msg.toolCalls) {
       nameById.set(tc.id, tc.name);
       const entry = policies.get(tc.id);
-      if (!entry) continue;
+      if (!entry || !withinBatch(entry)) continue;
       for (const t of triggersOf(entry)) {
         if (t.kind === "superseded") latestByKey.set(t.by, tc.id);
       }
@@ -2862,7 +2865,7 @@ function applyCondensation(history, policies, ctx, onCondensed) {
       // past the last allowed view: turns:1 → seen once, then gone. Monotonic
       // clock, so this holds across turn boundaries too.
       case "age":
-        return ctx.modelCall - entry.iteration > trig.turns;
+        return asOf - entry.iteration > trig.turns;
       case "turnEnd":
         return ctx.turn > entry.turn;
       case "agentEnd":
@@ -2876,7 +2879,7 @@ function applyCondensation(history, policies, ctx, onCondensed) {
         return latestByKey.get(trig.by) !== toolCallId;
     }
   };
-  const firstFired = (toolCallId, entry) => triggersOf(entry).find((t) => triggerFires(toolCallId, entry, t));
+  const firstFired = (toolCallId, entry) => withinBatch(entry) ? triggersOf(entry).find((t) => triggerFires(toolCallId, entry, t)) : void 0;
   return history.map((msg) => {
     if (msg.toolCalls?.length) {
       let changed = false;
@@ -3257,11 +3260,13 @@ var ChatDriver = class _ChatDriver extends EventTarget {
       primerHistory,
       maxToolIterations = DEFAULT_MAX_TOOL_ITERATIONS,
       maxFoldOperations = DEFAULT_MAX_FOLD_OPERATIONS,
+      condenseBatchCalls = 1,
       maxTurnSnapshots = DEFAULT_MAX_TURN_SNAPSHOTS,
       sessionKey = "",
       activityBus = NOOP_ACTIVITY_BUS
     } = config;
     this.maxToolIterations = maxToolIterations;
+    this.condenseBatchCalls = condenseBatchCalls;
     this.sessionKey = sessionKey;
     this.activityBus = activityBus;
     if (typeof toolHandlers === "function") {
@@ -4500,7 +4505,8 @@ Output format (strict):
           activationEnded: (activation) => activation < this.currentActivation,
           // A call's phase has ended once the app declared a later phase epoch
           // current via `endPhase()`.
-          phaseEnded: (phaseEpoch) => phaseEpoch < this.currentPhaseEpoch
+          phaseEnded: (phaseEpoch) => phaseEpoch < this.currentPhaseEpoch,
+          batchCalls: this.condenseBatchCalls
         },
         (detail) => recordMetaEvent(this.sessionKey, "context.condensed", detail)
       );