@genesislcap/ai-assistant 15.84.3 → 15.85.0-FUI-2666.2

package/dist/dts/utils/condense-history.d.ts

@@ -90,9 +90,11 @@ export interface CondenseContext {
     activationEnded: (activation: number) => boolean;
     /**
      * Whether a later phase epoch is current than the one a call was made in — the
-     * `phaseEnd` clock. True once `endPhase()` has been called since the call.
+     * `phaseEnd` clock. True once `endPhase()` has been called since the call. `activation` is the
+     * call's, for a caller waiting in a hand-off, whose phase another agent's `endPhase()` does not
+     * end (GENC-1737).
      */
-    phaseEnded: (phaseEpoch: number) => boolean;
+    phaseEnded: (phaseEpoch: number, activation: number) => boolean;
     /**
      * Collapse in batches of this many model-calls instead of continuously. A positive
      * integer; decimals are floored and anything below `1` becomes `1`. Omit (or `1`) to
@@ -184,7 +186,12 @@ export declare function toolCallIdsIn(history: readonly ChatMessage[]): Set<stri
  *
  * Pure, no writes to the registry — safe on a save path that runs on every autosave.
  */
-export declare function snapshotCondensePolicies(policies: ReadonlyMap<string, RegisteredCondensePolicy>, clocks: CondenseClocks, history: readonly ChatMessage[]): PersistedCondensePolicy[];
+export declare function snapshotCondensePolicies(policies: ReadonlyMap<string, RegisteredCondensePolicy>, clocks: CondenseClocks, history: readonly ChatMessage[], 
+/**
+ * Activations suspended in a hand-off (GENC-1737), each with the phase epoch it was suspended
+ * at: still live, so written as unended, and their phases counted only up to the suspension.
+ */
+suspended?: ReadonlyMap<number, number>): PersistedCondensePolicy[];
 /**
  * Validate one persisted entry read back from storage. Returns `undefined` for anything that is not
  * a well-formed {@link PersistedCondensePolicy} — the blob came off a disk or a network, and a

package/dist/dts/utils/condense-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condense-history.d.ts","sourceRoot":"","sources":["../../../src/utils/condense-history.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"condense-history.d.ts","sourceRoot":"","sources":["../../../src/utils/condense-history.ts"],"names":[],"mappings":"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"}

package/dist/esm/components/agent-session/agent-session.js

@@ -8,8 +8,8 @@ const WARN_PREFIX = 'AgentSession';
  * and the `onActivate` / `onDeactivate` lifecycle around a swap. Either driver can own one.
  *
  * Knows nothing about routing, tool surfaces or transcripts — whether an agent is terminal, the
- * continuation tool, the handoff marker in history all stay with the orchestrator, which is the
- * only thing with agents to route between.
+ * hand-off stack, the divider in history all stay with the orchestrator, which is the only thing
+ * with agents to route between.
  *
  * @beta
  */
@@ -41,6 +41,17 @@ export class AgentSession {
         this.restoredStates = {};
         /** The tail of the activation queue — see {@link AgentSession.activate}. */
         this.activation = Promise.resolve();
+        /**
+         * Callers waiting in a hand-off (GENC-1737), oldest first: still live, so never deactivated by
+         * the hand-off, and resumed without `onActivate`. Empty after a reload, when a caller has no live
+         * state and is activated again from its saved state instead.
+         */
+        this.suspended = [];
+        /**
+         * The `data` of the hand-off that activated each agent (GENC-1737), for its tool handlers: kept
+         * while it is active or waits as a caller, and dropped when its activation ends.
+         */
+        this.handOffData = new Map();
     }
     /** The active agent, or `undefined` before the first activation and after a release. */
     getActive() {
@@ -83,6 +94,91 @@ export class AgentSession {
     hasRestoredState(agentName) {
         return this.restoredStates[agentName] !== undefined;
     }
+    /** The `data` of the hand-off that activated `agentName`, if one did and carried any. */
+    getHandOffData(agentName) {
+        return this.handOffData.get(agentName);
+    }
+    /** Record the `data` a hand-off activated `agentName` with, or restore it; `undefined` drops it. */
+    setHandOffData(agentName, data) {
+        if (data === undefined)
+            this.handOffData.delete(agentName);
+        else
+            this.handOffData.set(agentName, data);
+    }
+    /**
+     * Drop the flow lock and leave the active agent active (GENC-1737): a plain agent holding it with
+     * no hand-off behind it is done once its turn ends.
+     */
+    dropFlowLock() {
+        if (this.flowOwner === null)
+            return;
+        this.flowOwner = null;
+        this.reportTransition({
+            previousAgent: this.active,
+            switched: false,
+            flowOwnerChangedTo: null,
+        });
+    }
+    /** The callers waiting in a hand-off whose state is live, oldest first. */
+    getSuspended() {
+        return this.suspended;
+    }
+    /**
+     * Make `target` active for a hand-off (GENC-1737), holding the flow lock whatever kind of agent
+     * it is, since a waiting caller depends on it. With `suspendCaller` the active agent waits:
+     * it is not deactivated and keeps its state. Without it the active agent is deactivated as on
+     * any swap: a one-way hand-off from a target, whose waiting caller then waits for the new
+     * target. Queued with {@link AgentSession.activate}.
+     */
+    handOff(target, options) {
+        const run = this.activation.then(() => this.activateNow(target, { lock: true, suspendPrevious: options.suspendCaller }));
+        this.activation = run.catch(() => undefined);
+        return run;
+    }
+    /**
+     * Make a waiting caller active again when its hand-off ends (GENC-1737). One whose state is live
+     * resumes without `onActivate`, since it was never deactivated; after a reload it is activated
+     * from its saved state like any other agent. `lock` keeps the flow lock on it: it held it before,
+     * or another caller is still waiting further down.
+     */
+    resume(caller, lock) {
+        const run = this.activation.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const index = this.suspended.findIndex((a) => a.name === caller.name);
+            if (index === -1)
+                return this.activateNow(caller, { lock });
+            // The live instance, whose closures hold the state it waited with.
+            const [live] = this.suspended.splice(index, 1);
+            const transition = { previousAgent: this.active, switched: true };
+            recordMetaEvent(this.deps.sessionKey(), 'agent.handoff', {
+                from: (_b = (_a = this.active) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null,
+                to: live.name,
+                restored: false,
+            });
+            this.active = live;
+            if (lock && this.flowOwner !== caller.name) {
+                this.flowOwner = caller.name;
+                transition.flowOwnerChangedTo = caller.name;
+            }
+            this.reportTransition(transition);
+            return transition;
+        }));
+        this.activation = run.catch(() => undefined);
+        return run;
+    }
+    /**
+     * Deactivate the callers left waiting by hand-offs that ended without a hand-back, newest first,
+     * when no teardown follows to do it (GENC-1737).
+     */
+    endSuspended() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const caller of this.suspended.splice(0).reverse()) {
+                this.handOffData.delete(caller.name);
+                // oxlint-disable-next-line no-await-in-loop -- one machine at a time, as a swap does
+                yield this.fireDeactivate(caller, 'release');
+            }
+        });
+    }
     /**
      * Make `agent` active, firing the lifecycle hooks around the swap: outgoing `onDeactivate`
      * first, then incoming `onActivate`. Both are awaited so heavy activation work (a machine
@@ -104,8 +200,12 @@ export class AgentSession {
         this.activation = run.catch(() => undefined);
         return run;
     }
-    activateNow(agent) {
-        return __awaiter(this, void 0, void 0, function* () {
+    /**
+     * `lock` takes the flow lock whatever kind of agent it is, and `suspendPrevious` leaves the
+     * outgoing agent waiting instead of deactivating it, as a hand-off does (GENC-1737).
+     */
+    activateNow(agent_1) {
+        return __awaiter(this, arguments, void 0, function* (agent, { lock = false, suspendPrevious = false } = {}) {
             var _a;
             const previousAgent = this.active;
             const switched = !previousAgent || previousAgent.name !== agent.name;
@@ -119,8 +219,15 @@ export class AgentSession {
                     restored: this.hasRestoredState(agent.name),
                 });
             }
-            if (switched && previousAgent)
-                yield this.fireDeactivate(previousAgent, 'switch');
+            if (switched && previousAgent) {
+                if (suspendPrevious) {
+                    this.suspended.push(previousAgent);
+                }
+                else {
+                    this.handOffData.delete(previousAgent.name);
+                    yield this.fireDeactivate(previousAgent, 'switch');
+                }
+            }
             if (switched && agent.onActivate) {
                 // 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 starts fresh.
@@ -146,10 +253,16 @@ export class AgentSession {
             // tool handler. The FLOW lock is written rather than the user pin, so completing a flow does
             // not wipe the user's sticky picker choice.
             const hasLifecycleHooks = !!(agent.onActivate || agent.onDeactivate);
-            if (switched && hasLifecycleHooks && this.flowOwner !== agent.name) {
+            if (switched && (hasLifecycleHooks || lock) && this.flowOwner !== agent.name) {
                 this.flowOwner = agent.name;
                 transition.flowOwnerChangedTo = agent.name;
             }
+            else if (switched && !suspendPrevious && this.flowOwner === (previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name)) {
+                // A deactivated owner's flow is over, so its lock goes with it rather than calling it back,
+                // with a fresh machine, on the next message: a one-way hand-off to a plain agent (GENC-1737).
+                this.flowOwner = null;
+                transition.flowOwnerChangedTo = null;
+            }
             this.active = agent;
             if (switched)
                 this.reportTransition(transition);
@@ -170,6 +283,7 @@ export class AgentSession {
             const agent = this.active;
             if (!agent)
                 return undefined;
+            this.handOffData.delete(agent.name);
             yield this.fireDeactivate(agent, 'release');
             this.active = undefined;
             const transition = { previousAgent: agent, switched: true };
@@ -212,6 +326,13 @@ export class AgentSession {
             const agent = this.active;
             if (agent)
                 yield this.fireDeactivate(agent, 'dispose');
+            // Callers waiting in a hand-off are live too, newest first.
+            for (const caller of [...this.suspended].reverse()) {
+                // oxlint-disable-next-line no-await-in-loop -- one machine at a time, as a swap does
+                yield this.fireDeactivate(caller, 'dispose');
+            }
+            this.suspended = [];
+            this.handOffData.clear();
             this.lifecycleAbortController.abort();
             this.active = undefined;
         });

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

@@ -18,6 +18,9 @@ export const AI_DRIVER_EVENT_TYPES = Object.keys({
     'agent-changed': true,
     'agent-released': true,
     'flow-owner-changed': true,
+    'handoff-started': true,
+    'handoff-returned': true,
+    'handoff-unwound': true,
     'orchestrating-start': true,
     'orchestrating-stop': true,
 });

package/dist/esm/components/ai-driver/base-driver-decorator.js

@@ -106,6 +106,30 @@ export class BaseDriverDecorator extends EventTarget {
         var _a, _b, _c;
         return ((_c = (_b = (_a = this.inner).restoreCondensePolicies) === null || _b === void 0 ? void 0 : _b.call(_a, entries)) !== null && _c !== void 0 ? _c : { restored: 0, awaitingReactivation: 0 });
     }
+    getHandOffStack() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getHandOffStack) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+    }
+    restoreHandOffStack(saved, savedStates, interrupted) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).restoreHandOffStack) === null || _b === void 0 ? void 0 : _b.call(_a, saved, savedStates, interrupted)) !== null && _c !== void 0 ? _c : {};
+    }
+    unwindHandOffs(kind) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).unwindHandOffs) === null || _b === void 0 ? void 0 : _b.call(_a, kind)) !== null && _c !== void 0 ? _c : Promise.resolve();
+    }
+    serializeWaitingCallers() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).serializeWaitingCallers) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : {};
+    }
+    getHandOffData() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getHandOffData) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : {};
+    }
+    restoreHandOffData(saved, interrupted) {
+        var _a, _b;
+        (_b = (_a = this.inner).restoreHandOffData) === null || _b === void 0 ? void 0 : _b.call(_a, saved, interrupted);
+    }
     getActiveAgent() {
         return this.inner.getActiveAgent();
     }

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

@@ -62,11 +62,3 @@ export const HARVESTED_SUBAGENT_EVENTS = new Set([
     'tool.failed',
     'tool.unresolved',
 ]);
-/**
- * Name reserved for the cross-agent handoff tool — injected by OrchestratingDriver.
- *
- * @beta
- */
-export const REQUEST_CONTINUATION_TOOL = 'request_continuation';
-/** Paired in history for each `request_continuation` so tool_calls stay balanced for the provider. */
-export const HANDOFF_TOOL_RESULT_PLACEHOLDER = 'Handoff to another specialist — routing continues on the next turn.';