@genesislcap/ai-assistant 15.24.2 → 15.26.0

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

@@ -0,0 +1,184 @@
+import { __awaiter } from "tslib";
+import { logger } from '../../utils/logger';
+import { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
+/** Read `ToolFold` metadata off a handler, or `undefined` if it is not a fold facade. */
+const foldOf = (handler) => handler
+    ? handler[TOOL_FOLD_SYMBOL]
+    : undefined;
+/**
+ * Tool folds: grouping tools behind a facade so the model sees a small surface, and swapping the
+ * surface as it opens and closes them.
+ *
+ * Owns the fold stack and the no-progress counter. Everything else it needs is the driver's tool
+ * surface, reached through {@link FoldDeps}.
+ */
+export class FoldController {
+    constructor(deps) {
+        this.deps = deps;
+        this.stack = [];
+        /**
+         * Consecutive fold opens/closes with no tool call between them. A model that only opens and
+         * closes is making no progress, and the loop breaks out past a ceiling.
+         */
+        this.consecutiveOps = 0;
+    }
+    /** Drop all fold state. Called on an agent swap — each agent starts outside every fold. */
+    reset() {
+        this.stack = [];
+        this.consecutiveOps = 0;
+    }
+    /** Names of the currently open folds, outermost first. */
+    activeNames() {
+        return this.stack.map((f) => f.foldName);
+    }
+    get depth() {
+        return this.stack.length;
+    }
+    /** The innermost open fold's name, or `undefined` when none is open. */
+    get topName() {
+        var _a;
+        return (_a = this.stack[this.stack.length - 1]) === null || _a === void 0 ? void 0 : _a.foldName;
+    }
+    /** Count one fold operation and return the new consecutive total. */
+    noteOp() {
+        this.consecutiveOps += 1;
+        return this.consecutiveOps;
+    }
+    /** Real work happened, so the no-progress streak restarts. */
+    clearOps() {
+        this.consecutiveOps = 0;
+    }
+    /** Fold metadata for a tool name, or `undefined` if it is not a fold facade. */
+    foldFor(toolName) {
+        return foldOf(this.deps.getHandlers()[toolName]);
+    }
+    /**
+     * Which fold to **open** to reach `toolName`, or `null` if no registered fold contains it.
+     *
+     * Returns the outermost *registered* ancestor, not the innermost fold holding the tool — the one
+     * consumer uses the answer to tell the model what to call next, and a nested fold cannot be
+     * opened before its parent. The recursion therefore only descends through closed folds: once a
+     * fold is open its children are top-level in the live handler map and match directly.
+     */
+    findContaining(toolName, handlers) {
+        const source = handlers !== null && handlers !== void 0 ? handlers : this.deps.getHandlers();
+        for (const handler of Object.values(source)) {
+            const fold = foldOf(handler);
+            if (!fold)
+                continue;
+            if (fold.handlers[toolName])
+                return fold.name;
+            if (this.findContaining(toolName, fold.handlers))
+                return fold.name;
+        }
+        return null;
+    }
+    /**
+     * If an open fold is hiding a previously-available tool, the fold to close to start getting it
+     * back, else `null`.
+     *
+     * Only exclusive folds hide tools — they replace the tool set on open rather than extending it —
+     * so a base tool that was visible beforehand sits in a frame's `previousHandlers` but not in the
+     * live map. Only the top fold's `close_` tool is active, so that is always the actionable step:
+     * closing repeatedly walks back to a tool further down the stack.
+     */
+    hidingTool(toolName) {
+        if (this.stack.length === 0)
+            return null;
+        const hidden = this.stack.some((f) => f.previousHandlers[toolName]);
+        return hidden ? this.topName : null;
+    }
+    /** Open a fold: push a frame, swap the tool set, and return the response for the model. */
+    open(foldName, fold, args, activeToolCallId) {
+        // Shortcut dispatch: the model passed inner tool args directly, e.g.
+        // trading_tools({ search_trades: { side: "BUY" } })
+        for (const key of Object.keys(args)) {
+            const innerHandler = fold.handlers[key];
+            if (innerHandler) {
+                logger.debug(`ChatDriver: fold shortcut dispatch "${foldName}" → "${key}"`);
+                // Open first, so the tool set is correct for subsequent calls.
+                this.pushFrame(foldName);
+                this.applyToolSet(fold, foldName);
+                this.clearOps(); // shortcut dispatch counts as real work
+                const innerArgs = typeof args[key] === 'object' && args[key] !== null
+                    ? args[key]
+                    : {};
+                return innerHandler(innerArgs, this.deps.handlerContext(activeToolCallId)).then((r) => typeof r === 'string' ? r : JSON.stringify(r));
+            }
+        }
+        this.pushFrame(foldName);
+        this.applyToolSet(fold, foldName);
+        const closeToolName = `close_${foldName}`;
+        const innerToolNames = fold.tools.map((t) => t.name);
+        let message = `Fold opened: ${foldName}. Tools now available: ${[...innerToolNames, closeToolName].join(', ')}.`;
+        if (fold.usageNotes)
+            message += ` Notes: ${fold.usageNotes}`;
+        message += ` Call ${closeToolName} when done to return to the previous tools.`;
+        return Promise.resolve(message);
+    }
+    /** Close the top fold: pop the frame, restore the tool set it captured. */
+    close() {
+        const frame = this.stack.pop();
+        if (!frame)
+            return 'No fold is currently open.';
+        this.deps.setDefinitions(frame.previousDefinitions);
+        this.deps.setHandlers(frame.previousHandlers);
+        const toolNames = frame.previousDefinitions.map((t) => t.name);
+        return `Fold closed: ${frame.foldName}. Tools now available: ${toolNames.join(', ')}.`;
+    }
+    /** The fold-awareness suffix appended to the system prompt on each LLM call. */
+    systemPromptSuffix() {
+        const activeFolds = Object.values(this.deps.getHandlers())
+            .map(foldOf)
+            .filter((f) => !!f);
+        if (activeFolds.length === 0 && this.stack.length === 0)
+            return '';
+        const parts = [
+            '\n\n--- Tool Folds ---',
+            'Some tools are grouped into folds. You may see tool calls in the conversation history for tools that are not currently available — they are inside a fold. To access them, invoke the fold tool first.',
+        ];
+        if (this.topName) {
+            parts.push(`You are currently inside the "${this.topName}" fold. Call close_${this.topName} when you are done with these tools.`);
+        }
+        for (const fold of activeFolds)
+            parts.push(`• ${fold.name}: ${fold.description}`);
+        return parts.join('\n');
+    }
+    pushFrame(foldName) {
+        this.stack.push({
+            foldName,
+            previousDefinitions: [...this.deps.getDefinitions()],
+            previousHandlers: Object.assign({}, this.deps.getHandlers()),
+        });
+    }
+    /**
+     * Install the fold's inner tool set, replacing it (exclusive) or extending it (non-exclusive),
+     * and inject the close tool. Does not touch the stack.
+     */
+    applyToolSet(fold, foldName) {
+        const closeToolName = `close_${foldName}`;
+        const newDefs = [];
+        const newHandlers = {};
+        if (!fold.exclusive) {
+            // Keep the existing tools, minus the facade just opened.
+            for (const def of this.deps.getDefinitions()) {
+                if (def.name !== foldName)
+                    newDefs.push(def);
+            }
+            for (const [name, handler] of Object.entries(this.deps.getHandlers())) {
+                if (name !== foldName)
+                    newHandlers[name] = handler;
+            }
+        }
+        newDefs.push(...fold.tools);
+        Object.assign(newHandlers, fold.handlers);
+        newDefs.push({
+            name: closeToolName,
+            description: `Close the ${foldName} fold and return to the previous set of tools.`,
+            parameters: { type: 'object', properties: {} },
+        });
+        newHandlers[closeToolName] = () => __awaiter(this, void 0, void 0, function* () { return this.close(); });
+        this.deps.setDefinitions(newDefs);
+        this.deps.setHandlers(newHandlers);
+    }
+}

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

@@ -82,3 +82,17 @@ export const TURN_FAILURE_EXITS = {
     // `TurnFailureReason` and cost the literal types that let `turn-failures.test.ts` pin the
     // two deliberate divergences at compile time instead of at runtime.
 };
+/**
+ * Build the `done` loop result, carrying the typed failure reason when the turn bailed (PTC-0).
+ *
+ * The discriminant stays `'done'` either way, so consumers matching on `reason === 'done'` are
+ * unchanged. Both payloads are omitted rather than set to `undefined`, which keeps a happy-path
+ * result byte-identical to `{ reason: 'done' }` for a consumer that structurally compares it.
+ *
+ * @beta
+ */
+export function turnDone(failureReason, budget, providerRefused) {
+    if (!failureReason)
+        return { reason: 'done' };
+    return Object.assign(Object.assign({ reason: 'done', failureReason }, (budget ? { budget } : {})), (providerRefused ? { providerRefused } : {}));
+}

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

@@ -149,16 +149,33 @@ function buildFallbackSystemPrompt(fallback, specialists) {
  * @beta
  */
 export class OrchestratingDriver extends EventTarget {
+    /**
+     * The stateful-agent contract (§7.1): active agent, user pin, flow lock, restored state, and
+     * the `onActivate` / `onDeactivate` hooks.
+     *
+     * **The inner driver's session, not one of our own.** One session is the invariant: two would
+     * let the outer and inner driver disagree about which agent is active, and the inner one would
+     * never be activated at all, because this driver installs a *decorated* config through
+     * `applyAgent` rather than going via `ChatDriver.activateAgent`. This driver keeps the routing
+     * decisions; the session owns the lifecycle.
+     */
+    get agentSession() {
+        return this.chatDriver.agentSession;
+    }
+    /**
+     * The active agent, or `undefined` before the first activation and after a release.
+     *
+     * Kept as an accessor over `agentSession` rather than removed: it is a public member of an
+     * exported class, so nothing in this package reading it is not the same as nothing reading it.
+     */
+    get activeAgent() {
+        return this.agentSession.getActive();
+    }
     constructor(providerRegistry, agents, options = {}) {
         var _a, _b, _c, _d;
         super();
         this.providerRegistry = providerRegistry;
         this.agents = agents;
-        /**
-         * Aborted on driver disposal. Threaded into `AgentLifecycleContext.signal`
-         * so long-running `onActivate` work can bail if the session disconnects.
-         */
-        this.lifecycleAbortController = new AbortController();
         /**
          * Set by `cancel()` for the duration of a `sendMessage` run. Breaks the
          * handoff loop so we don't classify or start another agent turn after the
@@ -176,28 +193,6 @@ export class OrchestratingDriver extends EventTarget {
          * made it vanish. Reset at the top of each `runOrchestratedTurn`.
          */
         this.userMessageAppended = false;
-        /**
-         * Sticky user pick from the picker (or the host's `setAgent` API). Only
-         * changes on explicit user action. Survives flow completion: when a stateful
-         * agent releases, the user-pin stays put and routing falls back to it on
-         * the next turn.
-         */
-        this.pinnedAgentName = null;
-        /**
-         * Transient flow lock — set when a stateful agent's `onActivate` fires,
-         * cleared by `releaseActiveAgent`. While non-null, routing precedence goes
-         * to this agent and the picker is locked. Independent of
-         * `pinnedAgentName` so completing a flow doesn't wipe the user's sticky
-         * choice.
-         */
-        this.flowOwnerAgentName = null;
-        /**
-         * Per-agent restored state for a rehydrated session, keyed by agent name.
-         * Primed by the host on restore; each entry is passed to that agent's
-         * `onActivate` as `ctx.restored` on its next activation, then deleted so a
-         * later re-activation starts fresh.
-         */
-        this.restoredAgentStates = {};
         this.sessionKey = (_a = options.sessionKey) !== null && _a !== void 0 ? _a : '';
         this.maxHandoffs = (_b = options.maxHandoffs) !== null && _b !== void 0 ? _b : DEFAULT_MAX_HANDOFFS;
         this.classifierHistoryLength =
@@ -224,6 +219,8 @@ export class OrchestratingDriver extends EventTarget {
             sessionKey: this.sessionKey,
             activityBus: options.activityBus,
             budgetExhaustedMessage: options.budgetExhaustedMessage,
+            // This driver releases after the turn so it can fire the host-facing events; see the option.
+            deferAgentRelease: true,
         });
         // Proxy events from the shared driver
         this.chatDriver.addEventListener('history-updated', (e) => {
@@ -282,7 +279,7 @@ export class OrchestratingDriver extends EventTarget {
      * return to automatic routing.
      */
     setPinnedAgent(name) {
-        this.pinnedAgentName = name;
+        this.agentSession.setPinned(name);
     }
     /**
      * Set the flow-owner lock — used to restore state from Redux on driver
@@ -291,7 +288,7 @@ export class OrchestratingDriver extends EventTarget {
      * for.
      */
     setFlowOwner(name) {
-        this.flowOwnerAgentName = name;
+        this.agentSession.setFlowOwner(name);
     }
     loadHistory(messages) {
         this.chatDriver.loadHistory(messages);
@@ -535,7 +532,7 @@ export class OrchestratingDriver extends EventTarget {
     }
     /** {@inheritDoc AiDriver.primeRestoredAgentState} */
     primeRestoredAgentState(snapshots) {
-        this.restoredAgentStates = Object.assign({}, snapshots);
+        this.agentSession.primeRestoredStates(snapshots);
     }
     /**
      * {@inheritDoc AiDriver.getContextReserve}
@@ -593,69 +590,16 @@ export class OrchestratingDriver extends EventTarget {
     }
     /** {@inheritDoc AiDriver.getActiveAgent} */
     getActiveAgent() {
-        return this.activeAgent;
+        return this.agentSession.getActive();
     }
     applyAgent(agent) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const previousAgent = this.activeAgent;
-            const isSwitch = !previousAgent || previousAgent.name !== agent.name;
-            // Record the agent transition on the debug-log timeline. A `null` `from`
-            // marks the initial activation; a named `from` is a handoff between agents.
-            if (isSwitch) {
-                recordMetaEvent(this.sessionKey, 'agent.handoff', {
-                    from: (_a = previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name) !== null && _a !== void 0 ? _a : null,
-                    to: agent.name,
-                    // GENC-1351: was a restored snapshot waiting for this agent at activation?
-                    restored: this.restoredAgentStates[agent.name] !== undefined,
-                });
-            }
-            // Fire lifecycle hooks around the swap — outgoing first, then incoming.
-            // Both are awaited so a heavy `onActivate` (e.g. machine restore) completes
-            // before the agent's first turn runs.
-            if (isSwitch && (previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.onDeactivate)) {
-                try {
-                    yield previousAgent.onDeactivate({
-                        agentName: previousAgent.name,
-                        sessionKey: this.sessionKey,
-                        signal: this.lifecycleAbortController.signal,
-                    });
-                }
-                catch (e) {
-                    logger.warn(`OrchestratingDriver: onDeactivate("${previousAgent.name}") threw:`, e);
-                }
-            }
-            if (isSwitch && agent.onActivate) {
-                // On a session restore, hand this agent its persisted state exactly once
-                // (consumed here) so a stateful machine resumes at the right step; a later
-                // re-activation of the same agent then starts fresh.
-                const restored = this.restoredAgentStates[agent.name];
-                if (restored !== undefined)
-                    delete this.restoredAgentStates[agent.name];
-                try {
-                    yield agent.onActivate({
-                        agentName: agent.name,
-                        sessionKey: this.sessionKey,
-                        previousAgentName: previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name,
-                        signal: this.lifecycleAbortController.signal,
-                        restored,
-                    });
-                }
-                catch (e) {
-                    logger.warn(`OrchestratingDriver: onActivate("${agent.name}") threw:`, e);
-                }
-            }
-            const hasLifecycleHooks = !!(agent.onActivate || agent.onDeactivate);
-            // Stateful agents auto-lock the flow on activation. The lock guarantees
-            // the machine survives subsequent turns (the classifier would otherwise be
-            // free to route away mid-flow, tearing the machine down). Release happens
-            // when the agent calls `releaseAgent` from a terminal-state tool handler
-            // — see the post-sendMessage check below. We write `flowOwnerAgentName`
-            // rather than `pinnedAgentName` so completing a flow doesn't wipe the
-            // user's sticky picker choice.
-            if (isSwitch && hasLifecycleHooks && this.flowOwnerAgentName !== agent.name) {
-                this.flowOwnerAgentName = agent.name;
-                this.dispatchEvent(new CustomEvent('flow-owner-changed', { detail: agent.name }));
+            // The transition — handoff record, lifecycle hooks, restored state, flow lock — belongs to
+            // the session. What is left below is this driver's own job: what the agent may route to, and
+            // what the transcript says happened.
+            const { previousAgent, flowOwnerChangedTo } = yield this.agentSession.activate(agent);
+            if (flowOwnerChangedTo !== undefined) {
+                this.dispatchEvent(new CustomEvent('flow-owner-changed', { detail: flowOwnerChangedTo }));
             }
             // Terminal agents do not get the cross-agent handoff tool. Four cases:
             //   • fallback     — already a leaf; handoff would loop
@@ -667,9 +611,9 @@ export class OrchestratingDriver extends EventTarget {
             //                    classifier mid-machine. Capture the tool loop until the
             //                    user (or the agent itself, via `releaseAgent`) releases.
             const isTerminal = isFallback(agent) ||
-                this.pinnedAgentName !== null ||
-                this.flowOwnerAgentName !== null ||
-                hasLifecycleHooks;
+                this.agentSession.getPinned() !== null ||
+                this.agentSession.getFlowOwner() !== null ||
+                !!(agent.onActivate || agent.onDeactivate);
             let agentToApply = agent;
             if (!isTerminal) {
                 const declaredTools = agent.toolDefinitions;
@@ -691,7 +635,6 @@ export class OrchestratingDriver extends EventTarget {
             }
             this.chatDriver.setProviderHistoryTransform((h) => transformHistoryForAgent(h, agent.name));
             this.chatDriver.applyAgent(agentToApply);
-            this.activeAgent = agent;
             this.dispatchEvent(new CustomEvent('orchestrating-stop'));
             this.dispatchEvent(new CustomEvent('agent-changed', { detail: agent }));
         });
@@ -709,27 +652,13 @@ export class OrchestratingDriver extends EventTarget {
      */
     releaseActiveAgent() {
         return __awaiter(this, void 0, void 0, function* () {
-            const agent = this.activeAgent;
-            if (!agent)
+            const released = yield this.agentSession.release();
+            if (!released)
                 return;
-            if (agent.onDeactivate) {
-                try {
-                    yield agent.onDeactivate({
-                        agentName: agent.name,
-                        sessionKey: this.sessionKey,
-                        signal: this.lifecycleAbortController.signal,
-                    });
-                }
-                catch (e) {
-                    logger.warn(`OrchestratingDriver: release onDeactivate("${agent.name}") threw:`, e);
-                }
+            if (released.flowOwnerChangedTo !== undefined) {
+                this.dispatchEvent(new CustomEvent('flow-owner-changed', { detail: released.flowOwnerChangedTo }));
             }
-            this.activeAgent = undefined;
-            if (this.flowOwnerAgentName !== null) {
-                this.flowOwnerAgentName = null;
-                this.dispatchEvent(new CustomEvent('flow-owner-changed', { detail: null }));
-            }
-            this.dispatchEvent(new CustomEvent('agent-released', { detail: agent }));
+            this.dispatchEvent(new CustomEvent('agent-released', { detail: released.previousAgent }));
             this.dispatchEvent(new CustomEvent('agent-changed', { detail: undefined }));
         });
     }
@@ -749,23 +678,12 @@ export class OrchestratingDriver extends EventTarget {
      */
     dispose() {
         return __awaiter(this, void 0, void 0, function* () {
-            const previousAgent = this.activeAgent;
-            if (previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.onDeactivate) {
-                try {
-                    yield previousAgent.onDeactivate({
-                        agentName: previousAgent.name,
-                        sessionKey: this.sessionKey,
-                        signal: this.lifecycleAbortController.signal,
-                    });
-                }
-                catch (e) {
-                    logger.warn(`OrchestratingDriver: dispose onDeactivate("${previousAgent.name}") threw:`, e);
-                }
-            }
-            this.lifecycleAbortController.abort();
+            // Hooks first, then teardown — the order this method has always had, so an `onDeactivate`
+            // still runs against a live inner driver. The session lives on that driver, so disposing it
+            // below repeats this call and finds nothing left to do.
+            yield this.agentSession.dispose();
             // Tear down the inner driver too, so any in-flight provider request aborts.
-            this.chatDriver.dispose();
-            this.activeAgent = undefined;
+            yield this.chatDriver.dispose();
         });
     }
     /**
@@ -995,8 +913,7 @@ export class OrchestratingDriver extends EventTarget {
      * — protects against stale state after an agents-array reassignment.
      */
     resolvePinnedAgent() {
-        var _a;
-        const name = (_a = this.flowOwnerAgentName) !== null && _a !== void 0 ? _a : this.pinnedAgentName;
+        const name = this.agentSession.getLockedName();
         if (name === null)
             return undefined;
         const match = this.agents.find((a) => a.name === name);

package/dist/esm/index.js

@@ -2,6 +2,7 @@ export * from './main/main';
 export * from './main/main.types';
 export * from './main/main.template';
 export * from './components/agent-picker';
+export * from './components/agent-session';
 export * from './components/ai-driver';
 export * from './components/chat-driver';
 export * from './components/orchestrating-driver';

package/dist/esm/main/main.js

@@ -52,6 +52,7 @@ import { lastUserMessageIndex } from '../state/persistence/session-snapshot';
 import { getSessionStore, hasSessionStore, deleteSessionStore, } from '../state/session-store';
 import { pinColourAt } from '../styles/ai-colours';
 import { ChatSuggestions } from '../suggestions/chat-suggestions';
+import { agentsKey } from '../utils/agents-key';
 import { resolveExclusiveLoadingStyle } from '../utils/animation-exclusivity';
 import { deleteBankedBaseline } from '../utils/banked-usage-baselines';
 import { estimateContextTokens, isContextMeasurable, } from '../utils/context-tokens';
@@ -555,7 +556,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     applyDeferredAgentsSwap() {
         if (!this.driver)
             return;
-        if (this.getAgentsKey(this.agents) === this._driverAgentsKey)
+        if (agentsKey(this.agents) === this._driverAgentsKey)
             return;
         this.agentsChanged();
     }
@@ -1153,8 +1154,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     /**
      * Aggregated USD cost across every chat turn in this session.
      *
-     * Read-only (unlike previously): it is a projection of `sessionUsage`, and a
-     * host assigning it would have set a figure the next transcript change overwrites.
+     * Read-only: a projection of `sessionUsage`, so an assigned figure would be overwritten by
+     * the next transcript change.
      */
     get sessionCostUsd() {
         return this.sessionUsage.costUsd;
@@ -1414,14 +1415,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.settings.costHistorySlotted = value;
     }
     /**
-     * This element's driver as an orchestrator, or `undefined` when the session is
-     * running a bare `ChatDriver`.
-     *
-     * The five call sites that used to test the type themselves now read this
-     * (§11.2 constraint 3 of `docs/code-health.md`): the agent pin, the flow-owner
-     * lock, the wire-up in `wireDriver`, and the two `driverKind` diagnostics. The
-     * type test itself lives in `asOrchestrator`, shared with the session
-     * persister.
+     * This element's driver as an orchestrator, or `undefined` when the session is running a bare
+     * `ChatDriver`. The only place in this element that narrows the type; the test itself lives in
+     * `asOrchestrator`, shared with the session persister.
      */
     get orchestrator() {
         return asOrchestrator(this.driver);
@@ -1544,7 +1540,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // This prevents spurious driver teardowns when the collapse-mode element
         // connects and its parent re-assigns the same agents array, which would
         // destroy pending interactions in the existing driver.
-        const newKey = this.getAgentsKey(this.agents);
+        const newKey = agentsKey(this.agents);
         if (newKey === this._driverAgentsKey)
             return;
         // GENC-1388: a sibling component sharing this session key (e.g. the popped-out
@@ -1597,26 +1593,6 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             driverKind: this.orchestrator ? 'orchestrating' : 'chat',
         });
     }
-    /** Returns a stable fingerprint for an agents array based on agent names and tool handler keys. */
-    getAgentsKey(agents) {
-        if (!(agents === null || agents === void 0 ? void 0 : agents.length))
-            return '';
-        return agents
-            .map((a) => {
-            var _a;
-            // Function-form handlers are resolved per turn — their full key set
-            // isn't knowable at fingerprint time. A constant marker still
-            // distinguishes static-vs-dynamic shape changes; finer-grained
-            // detection isn't load-bearing here.
-            const toolNames = typeof a.toolHandlers === 'function'
-                ? '<fn>'
-                : Object.keys((_a = a.toolHandlers) !== null && _a !== void 0 ? _a : {})
-                    .sort()
-                    .join('+');
-            return `${a.name}[${toolNames}]`;
-        })
-            .join(',');
-    }
     /**
      * Pure factory — creates a ChatDriver or OrchestratingDriver based on the
      * current agent configuration. Does not wire event listeners or register in
@@ -1927,7 +1903,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * `clearSession`.
      */
     rebuildDriver(key) {
-        this._driverAgentsKey = this.getAgentsKey(this.agents);
+        this._driverAgentsKey = agentsKey(this.agents);
         this.driver = getOrCreateDriver(key, this._driverAgentsKey, () => this.createDriver());
         this.wireDriver();
     }
@@ -1967,7 +1943,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             }
         }
         const driverExisted = !!getDriver(key);
-        this._driverAgentsKey = this.getAgentsKey(this.agents);
+        this._driverAgentsKey = agentsKey(this.agents);
         this.driver = getOrCreateDriver(key, this._driverAgentsKey, () => this.createDriver());
         this.wireDriver();
         // Auto-restore only for a freshly created store (the page-reload case); an
@@ -2345,10 +2321,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.finalizeCostSession();
         }
     }
-    /**
-     * Runs side effects that were previously in `messagesChanged()`.
-     * Called from the `messages` setter after dispatching to the store.
-     */
+    /** Transcript side effects, called from the `messages` setter after it dispatches to the store. */
     handleMessagesUpdate() {
         var _a, _b;
         // Reset the loading timer when an assistant message arrives mid-loop so each