@genesislcap/ai-assistant 15.85.0 → 15.86.0

package/dist/ai-assistant.api.json

@@ -9733,7 +9733,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!AutopilotDriver#getPersistedMode:member(1)",
-              "docComment": "/**\n * The mode to save with the session, while it is set for the current flow.\n */\n",
+              "docComment": "/**\n * The mode to save with the session, while it is set for the current flow — or kept for a hand-off's caller while its target releases, saved for that target, as the stack saves it.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -33076,7 +33076,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@genesislcap/ai-assistant!PersistedAutopilotMode:interface",
-          "docComment": "/**\n * The autopilot's mode as saved with the session (GENC-1660 §4.8): which flow it was set for, and whether it was running. Cleared when that flow ends, so a saved mode never outlives its flow.\n *\n * @beta\n */\n",
+          "docComment": "/**\n * The autopilot's mode as saved with the session (GENC-1660 §4.8): which flow it was set for, and whether it was running. Cleared when that flow ends, so a saved mode never outlives its flow. A hand-off does not end it: the mode goes with the task to the target, and back (GENC-1751).\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",

package/dist/ai-assistant.d.ts

@@ -1965,6 +1965,16 @@ export declare class AutopilotDriver extends BaseDriverDecorator implements Auto
     private turnHandBack?;
     /** A mode restored with the session, waiting for its flow to become the owner again. */
     private restored?;
+    /**
+     * The mode of a hand-off's target that has released, kept for its caller, which has not taken the
+     * lock back yet (GENC-1751): the flow has no owner in between. See `carriedTo`.
+     */
+    private handingBack?;
+    /**
+     * The mode of the flow that just ended, should a one-way hand-off with nobody waiting turn out to
+     * have ended it: that switch announces itself only after the owner has changed (GENC-1751).
+     */
+    private switchedFrom?;
     /**
      * Bumped on every pause and resume, and when its sessions end. A written answer is sent only if
      * none came between asking for it and its landing: one started before a pause is stale after it,
@@ -2005,7 +2015,10 @@ export declare class AutopilotDriver extends BaseDriverDecorator implements Auto
     pause(): void;
     resume(): void;
     stop(): void;
-    /** The mode to save with the session, while it is set for the current flow. */
+    /**
+     * The mode to save with the session, while it is set for the current flow — or kept for a
+     * hand-off's caller while its target releases, saved for that target, as the stack saves it.
+     */
     getPersistedMode(): PersistedAutopilotMode | undefined;
     /**
      * Bring back a saved mode. It applies once its flow is the owner again — at once if it already
@@ -2157,6 +2170,36 @@ export declare class AutopilotDriver extends BaseDriverDecorator implements Auto
     /** A claimed interaction settled, whoever settled it. */
     private onSettled;
     private onFlowOwnerChanged;
+    /**
+     * A one-way hand-off with nobody waiting is a plain switch, the caller deactivated, so nothing on
+     * the stack says the owner it changed to took over the same task: its event, raised once the
+     * target is active, does (GENC-1751).
+     */
+    private onHandOffStarted;
+    /** The mode set for the current flow, or kept for the caller of a hand-back under way. */
+    private current;
+    /**
+     * The mode that carries to `owner` because the owner changed for a hand-off or its hand-back, as
+     * the hand-off stack shows it at that moment (GENC-1751):
+     * - a hand-off: `owner` is the top frame's target, which has not finished. Its frame is on the
+     *   stack before the target is activated, and so is a waiting caller's passed on by a one-way
+     *   hand-off from a target;
+     * - a hand-back: the top frame's target, which the mode is set for, has finished, and `owner` is
+     *   its caller, or no one while the target releases. Its frame leaves the stack only after the
+     *   caller is active again.
+     *
+     * Clear and an agents change empty the stack before the flow ends, so the mode ends with it, as
+     * it ends with any flow. A turn routed away from the target ends the hand-offs the same way.
+     */
+    private carriedTo;
+    /** Whether `owner` is the caller the top hand-off hands back to from `target`. */
+    private handsBack;
+    /**
+     * Set `carried`'s mode for `owner`, which took the task over in a hand-off or its hand-back. A
+     * pause the person chose carries with it; the autopilot's own hand-back of an interaction does
+     * not, since that interaction settled before the hand-off could start.
+     */
+    private carry;
     private capabilityFor;
     private flowOwner;
     private bindingFor;
@@ -8100,7 +8143,8 @@ export declare class OrchestratingDriver extends BaseDriverDecorator<ChatDriver>
      *
      * A failed call ends the turn there, as a Stop does: what it asked for still happens, and the
      * next agent runs on the next message. Running it now would meet the same wall (a budget, a
-     * refused account, a full context window), or build on a reply that never came.
+     * refused account, a full context window), or build on a reply that never came. The one thing a
+     * Stop takes back is a hand-off that has not started (see `afterAgentCall`).
      */
     private carryOn;
     /**
@@ -8110,6 +8154,11 @@ export declare class OrchestratingDriver extends BaseDriverDecorator<ChatDriver>
      *
      * A plain target hands back when its call ends, released or not, as a plain agent is done once
      * it has answered. A stateful one holds the hand-off until it releases, as it holds its flow.
+     *
+     * A Stop cancels a hand-off that has not started: the user stopped the turn the caller asked for
+     * it in, often during the caller's closing call, so the target is not activated, and the call
+     * ends as if it had never asked (a plain caller's turn ends as usual below). A hand-back is not
+     * taken back: the target finished the work it was given.
      */
     private afterAgentCall;
     /** How the target of `frame` finished: with `completeHandOff`, or a release and its last reply. */
@@ -8294,7 +8343,8 @@ export declare const PERSISTED_SESSION_VERSION = 1;
 
 /**
  * The autopilot's mode as saved with the session (GENC-1660 §4.8): which flow it was set for, and
- * whether it was running. Cleared when that flow ends, so a saved mode never outlives its flow.
+ * whether it was running. Cleared when that flow ends, so a saved mode never outlives its flow. A
+ * hand-off does not end it: the mode goes with the task to the target, and back (GENC-1751).
  *
  * @beta
  */

package/dist/chat-driver.cjs

@@ -4133,6 +4133,8 @@ var META_EVENT_IMPORTANCE = {
   "autopilot.handed-back": "normal",
   "autopilot.paused": "normal",
   "autopilot.resumed": "normal",
+  // The mode went with the task across a hand-off or its hand-back, rather than ending with the flow.
+  "autopilot.carried": "normal",
   // The wrapper itself failed: the journey stops being automatic without anyone choosing that.
   "autopilot.error": "high",
   // A written answer counted against the step's limit; reaching it withdraws `reply`.
@@ -10337,7 +10339,8 @@ var OrchestratingDriver = class _OrchestratingDriver extends BaseDriverDecorator
    *
    * A failed call ends the turn there, as a Stop does: what it asked for still happens, and the
    * next agent runs on the next message. Running it now would meet the same wall (a budget, a
-   * refused account, a full context window), or build on a reply that never came.
+   * refused account, a full context window), or build on a reply that never came. The one thing a
+   * Stop takes back is a hand-off that has not started (see `afterAgentCall`).
    */
   async carryOn(result) {
     let last = result;
@@ -10355,10 +10358,18 @@ var OrchestratingDriver = class _OrchestratingDriver extends BaseDriverDecorator
    *
    * A plain target hands back when its call ends, released or not, as a plain agent is done once
    * it has answered. A stateful one holds the hand-off until it releases, as it holds its flow.
+   *
+   * A Stop cancels a hand-off that has not started: the user stopped the turn the caller asked for
+   * it in, often during the caller's closing call, so the target is not activated, and the call
+   * ends as if it had never asked (a plain caller's turn ends as usual below). A hand-back is not
+   * taken back: the target finished the work it was given.
    */
   async afterAgentCall() {
     const request = this.chatDriver.getHandOffRequest();
-    if (request) return this.startHandOff(request);
+    if (request && !this.cancelled) return this.startHandOff(request);
+    if (request) {
+      logger2.debug(`OrchestratingDriver: stopped before the hand-off to "${request.to}" started`);
+    }
     const active = this.agentSession.getActive();
     if (!active) return void 0;
     const frame = this.topFrameFor(active.name);