@genesislcap/ai-assistant 15.19.6 → 15.20.0-alpha.3

package/dist/dts/utils/resolve-context-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-context-budget.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-context-budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,0BAA0B,EAAE,CAAC;AAEtC;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,OAAQ,CAAC;AAEjD,iEAAiE;AACjE,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,GAAG,qBAAqB,CAmDrF"}

package/dist/esm/components/chat-driver/chat-driver.js

@@ -1,11 +1,12 @@
 import { __awaiter, __rest } from "tslib";
-import { BudgetExhaustedError, DEFAULT_BUDGET_EXHAUSTED_MESSAGE, DEFAULT_PROVIDER_REFUSED_MESSAGE, ProviderRefusedError, isObservableAIProviderRegistry, MalformedFunctionCallError, ResponseTruncatedError, vendorTypeOfLabel, } from '@genesislcap/foundation-ai';
+import { BudgetExhaustedError, DEFAULT_BUDGET_EXHAUSTED_MESSAGE, DEFAULT_PROVIDER_REFUSED_MESSAGE, ContextOverflowError, DEFAULT_CONTEXT_OVERFLOW_MESSAGE, ProviderRefusedError, isObservableAIProviderRegistry, MalformedFunctionCallError, ResponseTruncatedError, vendorTypeOfLabel, } from '@genesislcap/foundation-ai';
 import { NOOP_ACTIVITY_BUS } from '../../channel/ai-activity-bus';
 import { resolveChatProvider } from '../../config/validate-providers';
 import { clearSession, getMetaEvents, mergeMetaEvents, recordMetaEvent, recordTurnError, recordTurnRetry, } from '../../state/debug-event-log';
 import { createInteractionContext, } from '../../state/interaction-context';
-import { applyCondensation } from '../../utils/condense-history';
-import { applyHistoryCap, buildCompactionSummaryPrompt, findCompactionCut, normalizeForProvider, } from '../../utils/history-transform';
+import { applyCondensation, condenseForPersistence, } from '../../utils/condense-history';
+import { estimateRequestTokens } from '../../utils/context-tokens';
+import { applyHistoryCap, buildCompactionSummaryPrompt, planCompaction, normalizeForProvider, } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { messageUsage, sumUsage } from '../../utils/sum-usage';
 import { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
@@ -115,16 +116,6 @@ const HARVESTED_SUBAGENT_EVENTS = new Set([
 export const REQUEST_CONTINUATION_TOOL = 'request_continuation';
 /** Paired in history for each `request_continuation` so tool_calls stay balanced for the provider. */
 const HANDOFF_TOOL_RESULT_PLACEHOLDER = 'Handoff to another specialist — routing continues on the next turn.';
-/**
- * Plain TS class that drives a multi-turn chat conversation, including the tool-call loop.
- * Owned by `FoundationAiAssistant` — created in `connectedCallback`, torn down in `disconnectedCallback`.
- *
- * Dispatches `'history-updated'` events on itself so the owning element can observe changes.
- *
- * @fires history-updated - Fired whenever the in-memory chat history changes (append, tool loop, interaction resolution, post-resolve external cost) with the full history snapshot. detail: `ReadonlyArray<ChatMessage>`
- *
- * @beta
- */
 export class ChatDriver extends EventTarget {
     constructor(providerRegistry, config = {}) {
         super();
@@ -755,6 +746,12 @@ export class ChatDriver extends EventTarget {
             const status = yield this.resolveStatusForProvider(resolvedName, provider);
             this.lastResolvedModel = status.model;
             this.lastResolvedProvider = status.provider;
+            // The window of the provider THIS call will go to. Read here rather than
+            // pushed down by the host, because the host cannot know it until the later
+            // `provider-changed` event — so a per-agent provider switch would otherwise
+            // have its first call guarded by the previous model's limit, refusing a valid
+            // turn on the way up and waving an oversized one through on the way down.
+            this.lastResolvedContextLimit = status.contextLimit;
             if (resolvedName !== this.lastDispatchedProviderName) {
                 this.lastDispatchedProviderName = resolvedName;
                 recordMetaEvent(this.sessionKey, 'provider.selected', {
@@ -788,7 +785,13 @@ export class ChatDriver extends EventTarget {
             try {
                 const resolved = yield ((_a = provider.getStatus) === null || _a === void 0 ? void 0 : _a.call(provider));
                 if (resolved) {
-                    status = { model: resolved.model, provider: resolved.provider };
+                    status = {
+                        model: resolved.model,
+                        provider: resolved.provider,
+                        // Carried so the mid-loop guard can measure against the window of the
+                        // provider this call actually resolved to (GENC-1567).
+                        contextLimit: resolved.contextLimit,
+                    };
                 }
             }
             catch (_b) {
@@ -962,9 +965,62 @@ export class ChatDriver extends EventTarget {
         return snapshot;
     }
     /**
-     * Optional transform applied to conversation history immediately before each LLM request.
-     * Cleared when `undefined`. Does not alter stored history.
+     * Set the mid-loop context guard. Its margin is deliberately far smaller than
+     * the reserve that blocks NEW turns: that reserve exists so an accepted turn can
+     * spend it, and a guard set at the same line would kill every turn that used
+     * the headroom it was given.
      */
+    setContextGuard(policy) {
+        this.contextGuard = policy && policy.marginTokens > 0 ? policy : undefined;
+    }
+    /**
+     * Whether issuing `requestHistory` would run the context window out.
+     *
+     * Inert unless a margin has been set AND the resolved provider reports a
+     * window — with no window there is nothing to measure against, and inventing
+     * one to refuse a request is worse than letting the provider answer.
+     *
+     * Stopping here is strictly better than letting the request go: the provider
+     * would reject an oversized prompt outright, leaving a transcript still too
+     * large to retry and no explanation the user can act on, whereas ending the
+     * turn keeps history intact so compaction is still available and the work so
+     * far is not lost.
+     */
+    contextExhausted(requestHistory, pendingInput) {
+        var _a, _b;
+        const guard = this.contextGuard;
+        if (!guard)
+            return undefined;
+        // The resolved provider's own window, falling back to the host's assumption
+        // only when the provider reports none. Without the fallback a host that knows
+        // its window but uses a provider that does not report it got a UI gate and no
+        // running-turn guard — the fallback protecting the composer and nothing else.
+        const limit = (_a = this.lastResolvedContextLimit) !== null && _a !== void 0 ? _a : guard.fallbackLimit;
+        if (limit == null || limit <= 0)
+            return undefined;
+        const threshold = Math.max(0, limit - guard.marginTokens);
+        // The first call of a turn passes the user's text and attachments SEPARATELY
+        // (`sendMessage` appended them to history, and `baseHistory` drops that last
+        // message precisely because they are supplied out of band). Measuring only
+        // `requestHistory` therefore omitted them — so a large paste or a set of
+        // images, the very payloads most likely to overrun a window, were invisible to
+        // the guard that exists to catch them.
+        const request = pendingInput && (pendingInput.content || ((_b = pendingInput.attachments) === null || _b === void 0 ? void 0 : _b.length))
+            ? [
+                ...requestHistory,
+                {
+                    role: 'user',
+                    content: pendingInput.content,
+                    attachments: pendingInput.attachments,
+                },
+            ]
+            : requestHistory;
+        const estimated = estimateRequestTokens(this.history, request);
+        if (estimated < threshold)
+            return undefined;
+        logger.error(`ChatDriver: ending the turn — the request would fill the context window (~${estimated} of ${limit})`);
+        return { estimated, threshold };
+    }
     setProviderHistoryTransform(transform) {
         this.providerHistoryTransform = transform;
     }
@@ -978,6 +1034,26 @@ export class ChatDriver extends EventTarget {
     getActiveFoldNames() {
         return this.foldStack.map((f) => f.foldName);
     }
+    /**
+     * The transcript as it should be **stored**: every tool payload the model has already stopped
+     * seeing replaced by the same stub it was sent (GENC-1566). Live history is untouched — this
+     * returns a copy.
+     *
+     * Condensation deliberately spares stored history, because the live transcript and the debug
+     * export both read it. A host writing that transcript to durable storage inherits the other
+     * half of that decision: it stores payloads the driver has already retired, on every autosave,
+     * for the life of the session. Measured on one small Create session — 58,187 chars, 7.4% of a
+     * 790 KB session object, across five payloads worth 14,434 tokens of context, written 86 times.
+     *
+     * Only already-collapsed payloads are touched, so this can never store a stub for something the
+     * model can still see, and it has no side effects (see `condenseForPersistence`, which is
+     * internal). A host that wants the unredacted transcript still calls
+     * {@link ChatDriver.getRawHistory}, and a diagnostics stream that keeps full payloads is
+     * unaffected — which is what makes the elision recoverable.
+     */
+    getHistoryForPersistence() {
+        return condenseForPersistence([...this.history], this.condensePolicies);
+    }
     getSuggestions(history, prompt, count, allAgentInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             // Suggestions are an out-of-turn UI helper, not bound to any single agent —
@@ -1085,8 +1161,19 @@ export class ChatDriver extends EventTarget {
      * turns exists behind a clean boundary. Uses the same `history` `compact()`
      * acts on, so the UI's gate can't disagree with the action (GENC-1351 follow-up).
      */
-    canCompact() {
-        return findCompactionCut(this.history) != null;
+    canCompact(options) {
+        return this.getCompactionPlan(options) != null;
+    }
+    /**
+     * {@inheritDoc AiDriver.getCompactionPlan}
+     *
+     * Runs against the driver's own `history` — the exact list `compact()` acts on
+     * — so a projection and the compaction it describes can never be computed from
+     * different transcripts (the GENC-1351 follow-up that first made `canCompact`
+     * read `history` rather than a mirrored copy).
+     */
+    getCompactionPlan(options) {
+        return planCompaction(this.history, options);
     }
     /**
      * Destructively compact older turns into a single `compacted-summary` message
@@ -1097,9 +1184,9 @@ export class ChatDriver extends EventTarget {
      * the new one. Returns the created summary message, or `null` when there is
      * nothing worth compacting or the default provider cannot summarize.
      */
-    compact() {
+    compact(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g;
             if (this.busy)
                 return null;
             const defaultProvider = this.providerRegistry.default();
@@ -1108,7 +1195,10 @@ export class ChatDriver extends EventTarget {
                 return null;
             }
             const history = this.history;
-            const cut = findCompactionCut(history);
+            // Same plan the affordance was gated on — including its worth-it floor, so a
+            // compaction that would reclaim too little is declined here as well as being
+            // greyed out in the UI.
+            const cut = (_a = planCompaction(history, options)) === null || _a === void 0 ? void 0 : _a.cut;
             if (cut == null)
                 return null;
             const toCompact = history.slice(0, cut);
@@ -1122,7 +1212,7 @@ export class ChatDriver extends EventTarget {
             const failMessage = "Sorry, I couldn't compact the conversation just now. Nothing was changed — please try again.";
             let summaryText;
             try {
-                summaryText = (_b = (_a = (yield defaultProvider.prompt(userMessage, { systemPrompt }))) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '';
+                summaryText = (_c = (_b = (yield defaultProvider.prompt(userMessage, { systemPrompt }))) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : '';
             }
             catch (e) {
                 logger.warn(`ChatDriver: compaction summary failed: ${e instanceof Error ? e.message : e}`);
@@ -1141,7 +1231,7 @@ export class ChatDriver extends EventTarget {
                     break;
                 }
             }
-            const status = yield ((_c = defaultProvider.getStatus) === null || _c === void 0 ? void 0 : _c.call(defaultProvider));
+            const status = yield ((_d = defaultProvider.getStatus) === null || _d === void 0 ? void 0 : _d.call(defaultProvider));
             const createdAt = new Date().toISOString();
             const summaryMessage = {
                 role: 'compacted-summary',
@@ -1150,10 +1240,10 @@ export class ChatDriver extends EventTarget {
                 // for the oldest messages and sits at the head of history, so this keeps it
                 // sorted to the head in any timestamp-ordered view (the debug timeline) and
                 // history time-monotonic. Its true creation time is in compaction.createdAt.
-                timestamp: (_e = (_d = toCompact[0]) === null || _d === void 0 ? void 0 : _d.timestamp) !== null && _e !== void 0 ? _e : createdAt,
+                timestamp: (_f = (_e = toCompact[0]) === null || _e === void 0 ? void 0 : _e.timestamp) !== null && _f !== void 0 ? _f : createdAt,
                 compaction: {
                     compactedCount: toCompact.length,
-                    coveredThroughTimestamp: (_f = toCompact[toCompact.length - 1]) === null || _f === void 0 ? void 0 : _f.timestamp,
+                    coveredThroughTimestamp: (_g = toCompact[toCompact.length - 1]) === null || _g === void 0 ? void 0 : _g.timestamp,
                     tokensBefore,
                     model: status === null || status === void 0 ? void 0 : status.model,
                     createdAt,
@@ -1701,6 +1791,11 @@ export class ChatDriver extends EventTarget {
             // Mark before the first turn so the child forces tool use and reports a
             // typed failure (rather than user-facing text) if it never completes.
             child.markAsSubAgent();
+            // The guard is policy, and a sub-agent runs the same tool loop against the
+            // same window. Without this every child was inert — and the
+            // `context_exhausted` sub-agent failure this feature added was unreachable by
+            // any normal path.
+            child.setContextGuard(this.contextGuard);
             // Propagate disposal: if this (parent) driver is torn down while the
             // sub-agent is mid-flight, dispose the child too so its in-flight request
             // aborts. Detached in the `finally` below once the sub-agent completes.
@@ -2085,7 +2180,7 @@ export class ChatDriver extends EventTarget {
     // oxlint-disable-next-line complexity
     runToolLoop(userInput, attachments, transientPrimer) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
             if (!this.systemPrompt) {
                 logger.warn('ChatDriver: no systemPrompt set. The assistant will have no instructions — provide a systemPrompt via agents config or the foundation-ai-assistant property.');
             }
@@ -2399,6 +2494,43 @@ export class ChatDriver extends EventTarget {
                     turnSnapshot.provider = this.lastResolvedProvider;
                 if (this.lastResolvedModel !== undefined)
                     turnSnapshot.model = this.lastResolvedModel;
+                // The context wall (GENC-1567) — checked HERE, at the last possible moment,
+                // rather than at the top of the iteration where it started life.
+                //
+                // Two things are only knowable at this point, and getting either wrong
+                // ended valid turns. `historyForCall` is what will actually be sent, after
+                // `condenseWhen` has stubbed spent tool payloads and per-agent masking has
+                // blanked another agent's — stored history deliberately keeps them in full,
+                // so measuring it refused turns whose real request was a fraction of the
+                // size. And `lastResolvedContextLimit` is the window of the provider THIS
+                // call resolved to, which on an agent switch is not the one the host knew
+                // about when it last pushed a threshold down.
+                const contextStop = this.contextExhausted(historyForCall, {
+                    content: userInputForCall,
+                    attachments: attachmentsForCall,
+                });
+                if (contextStop) {
+                    recordTurnError(this.sessionKey, 'context-exhausted', {
+                        agent: this.activeAgentName,
+                        provider: this.lastResolvedProviderName,
+                        contextTokens: contextStop.estimated,
+                        guard: contextStop.threshold,
+                        limit: this.lastResolvedContextLimit,
+                        iterations,
+                        isSubAgent: this.isSubAgent,
+                    });
+                    if (this.isSubAgent) {
+                        this.failSubAgent('context_exhausted');
+                    }
+                    else {
+                        this.appendToHistory({
+                            role: 'assistant',
+                            content: 'I had to stop here — this conversation has filled the available context. ' +
+                                'Compact it to free up room, then ask me to continue.',
+                        });
+                    }
+                    return this.turnDone('context-exhausted');
+                }
                 let response;
                 try {
                     // oxlint-disable-next-line no-await-in-loop
@@ -2484,13 +2616,46 @@ export class ChatDriver extends EventTarget {
                     // error is an untyped transport failure, gets re-issued MAX_SETUP_TRANSPORT_RETRIES times
                     // against a wall that cannot move, and then surfaces as "something went wrong on my end" —
                     // wrong twice over, since nothing went wrong on our end and trying again will not help.
+                    // The REQUEST wall (GENC-1567) — the prompt outgrew the window. Placed
+                    // beside the account walls and before the transient-retry step for the
+                    // same reason: re-issuing an oversized prompt cannot make it fit, and
+                    // without this it surfaces as "something went wrong on my end" when in
+                    // fact the user has a clear, effective remedy.
+                    //
+                    // A backstop rather than the main defence — the mid-loop guard should
+                    // normally stop the turn before a request this large is built. It is
+                    // reached when the provider reports no context window (nothing for the
+                    // guard to measure against), when the estimate ran under, or when a
+                    // single request was already too large.
+                    if (e instanceof ContextOverflowError) {
+                        logger.error('ChatDriver: the prompt exceeded the model context window', e);
+                        recordTurnError(this.sessionKey, 'context-exhausted', {
+                            agent: this.activeAgentName,
+                            provider: this.lastResolvedProviderName,
+                            vendor: (_e = vendorTypeOfLabel(e.vendorLabel)) !== null && _e !== void 0 ? _e : this.lastResolvedProvider,
+                            promptTokens: e.promptTokens,
+                            limitTokens: e.limitTokens,
+                            via: 'provider',
+                            isSubAgent: this.isSubAgent,
+                        });
+                        if (this.isSubAgent) {
+                            this.failSubAgent('context_exhausted');
+                        }
+                        else {
+                            this.appendToHistory({
+                                role: 'assistant',
+                                content: DEFAULT_CONTEXT_OVERFLOW_MESSAGE,
+                            });
+                        }
+                        return this.turnDone('context-exhausted');
+                    }
                     if (e instanceof ProviderRefusedError) {
                         if (this.isSubAgent) {
                             logger.error('ChatDriver: provider refused the request', e);
                             recordTurnError(this.sessionKey, 'provider-refused', {
                                 agent: this.activeAgentName,
                                 provider: this.lastResolvedProviderName,
-                                vendor: (_e = vendorTypeOfLabel(e.vendorLabel)) !== null && _e !== void 0 ? _e : this.lastResolvedProvider,
+                                vendor: (_f = vendorTypeOfLabel(e.vendorLabel)) !== null && _f !== void 0 ? _f : this.lastResolvedProvider,
                                 kind: e.kind,
                                 upstreamStatus: e.upstreamStatus,
                                 upstreamType: e.upstreamType,
@@ -2524,7 +2689,7 @@ export class ChatDriver extends EventTarget {
                             recordTurnError(this.sessionKey, 'budget-exhausted', {
                                 agent: this.activeAgentName,
                                 provider: this.lastResolvedProviderName,
-                                vendor: (_g = (_f = vendorTypeOfLabel(e.vendorLabel)) !== null && _f !== void 0 ? _f : vendorTypeOfLabel(e.serverVendor)) !== null && _g !== void 0 ? _g : this.lastResolvedProvider,
+                                vendor: (_h = (_g = vendorTypeOfLabel(e.vendorLabel)) !== null && _g !== void 0 ? _g : vendorTypeOfLabel(e.serverVendor)) !== null && _h !== void 0 ? _h : this.lastResolvedProvider,
                                 budgetUsd: e.budgetUsd,
                                 spentUsd: e.spentUsd,
                                 isSubAgent: true,
@@ -2622,15 +2787,15 @@ export class ChatDriver extends EventTarget {
                 // fallback chain answered on a different model than the one we asked for.
                 if (response.model !== undefined)
                     turnSnapshot.model = response.model;
-                const isThinkingStep = response.content && ((_h = response.toolCalls) === null || _h === void 0 ? void 0 : _h.length);
-                const isEmptyResponse = !((_j = response.content) === null || _j === void 0 ? void 0 : _j.trim()) && !((_k = response.toolCalls) === null || _k === void 0 ? void 0 : _k.length);
+                const isThinkingStep = response.content && ((_j = response.toolCalls) === null || _j === void 0 ? void 0 : _j.length);
+                const isEmptyResponse = !((_k = response.content) === null || _k === void 0 ? void 0 : _k.trim()) && !((_l = response.toolCalls) === null || _l === void 0 ? void 0 : _l.length);
                 // A pre-output refusal (safety-classifier decline, e.g. Fable 5 `stop_reason: 'refusal'`)
                 // comes back with empty content, so it looks like a blank response — but it is deterministic:
                 // retrying re-sends the identical request and refuses again, burning up to
                 // MAX_EMPTY_RESPONSE_RETRIES turns on the most expensive models for the same outcome, ending
                 // in the misleading "blank response" message. Treat it as a terminal, non-retried failure with
                 // its own reason and message. (GENC-1461)
-                const isRefusal = ((_l = response.responseMeta) === null || _l === void 0 ? void 0 : _l.finishReason) === 'refusal';
+                const isRefusal = ((_m = response.responseMeta) === null || _m === void 0 ? void 0 : _m.finishReason) === 'refusal';
                 if (isEmptyResponse) {
                     emptyResponseAttempts += 1;
                     if (!isRefusal && emptyResponseAttempts < MAX_EMPTY_RESPONSE_RETRIES) {
@@ -2704,7 +2869,7 @@ export class ChatDriver extends EventTarget {
                 emptyResponseAttempts = 0;
                 malformedAttempts = 0;
                 setupTransportAttempts = 0;
-                if (!((_m = response.toolCalls) === null || _m === void 0 ? void 0 : _m.length)) {
+                if (!((_o = response.toolCalls) === null || _o === void 0 ? void 0 : _o.length)) {
                     break;
                 }
                 const [toolCalls, systemCalls] = response.toolCalls.reduce((acc, tc) => {
@@ -2934,7 +3099,7 @@ export class ChatDriver extends EventTarget {
                 // The response was appended before execution — find it and annotate.
                 let tcMsgIdx = -1;
                 for (let i = this.history.length - 1; i >= 0; i -= 1) {
-                    if (this.history[i].role === 'assistant' && ((_o = this.history[i].toolCalls) === null || _o === void 0 ? void 0 : _o.length)) {
+                    if (this.history[i].role === 'assistant' && ((_p = this.history[i].toolCalls) === null || _p === void 0 ? void 0 : _p.length)) {
                         tcMsgIdx = i;
                         break;
                     }
@@ -2972,7 +3137,7 @@ export class ChatDriver extends EventTarget {
                     const unknownTools = [
                         ...new Set([
                             ...this.recentUnknownToolNames,
-                            ...((_p = response.toolCalls) !== null && _p !== void 0 ? _p : [])
+                            ...((_q = response.toolCalls) !== null && _q !== void 0 ? _q : [])
                                 .filter((tc) => unknownToolIds.has(tc.id))
                                 .map((tc) => tc.name),
                         ]),
@@ -2984,7 +3149,7 @@ export class ChatDriver extends EventTarget {
                     const staleTools = [
                         ...new Set([
                             ...this.recentStaleToolNames,
-                            ...((_q = response.toolCalls) !== null && _q !== void 0 ? _q : [])
+                            ...((_r = response.toolCalls) !== null && _r !== void 0 ? _r : [])
                                 .filter((tc) => staleToolIds.has(tc.id))
                                 .map((tc) => tc.name),
                         ]),

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -203,13 +203,37 @@ export class OrchestratingDriver extends EventTarget {
     getRawHistory() {
         return this.chatDriver.getHistory();
     }
+    /**
+     * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it
+     * is the only object that knows which payloads the model has stopped seeing (GENC-1566).
+     *
+     * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares
+     * `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back
+     * to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it
+     * wraps one — so without an explicit forward the optional call resolves to `undefined` and every
+     * host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly
+     * that way on a Create run: 10 `context.condensed` events fired, and the session still stored
+     * the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the
+     * tests passed, and the feature did nothing.
+     */
+    getHistoryForPersistence() {
+        return this.chatDriver.getHistoryForPersistence();
+    }
+    /** {@inheritDoc AiDriver.setContextGuard} */
+    setContextGuard(policy) {
+        this.chatDriver.setContextGuard(policy);
+    }
     /** {@inheritDoc AiDriver.compact} */
-    compact() {
-        return this.chatDriver.compact();
+    compact(options) {
+        return this.chatDriver.compact(options);
     }
     /** {@inheritDoc AiDriver.canCompact} */
-    canCompact() {
-        return this.chatDriver.canCompact();
+    canCompact(options) {
+        return this.chatDriver.canCompact(options);
+    }
+    /** {@inheritDoc AiDriver.getCompactionPlan} */
+    getCompactionPlan(options) {
+        return this.chatDriver.getCompactionPlan(options);
     }
     /** Delegates to the inner {@link ChatDriver} — turns are captured there. */
     getTurnSnapshots() {