@genesislcap/ai-assistant 15.52.0 → 15.53.0-GENC-1662.1

package/dist/ai-assistant.api.json

@@ -3174,6 +3174,51 @@
               ],
               "name": "canCompact"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@genesislcap/ai-assistant!AiDriver#canResumeRestoredFlow:member(1)",
+              "docComment": "/**\n * Whether a restore should resume the flow `agentName` owns (GENC-1662): the agent is configured here and has not opted out with `resumeOnRestore: false`. Pure — no activation. Lets the restore pick its divider wording before it hands the transcript over.\n *\n * Optional: a driver without it never resumes.\n *\n * @beta\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "canResumeRestoredFlow?(agentName: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Beta",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "agentName",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "name": "canResumeRestoredFlow"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@genesislcap/ai-assistant!AiDriver#compact:member(1)",
@@ -4174,6 +4219,70 @@
               ],
               "name": "restoreCondensePolicies"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@genesislcap/ai-assistant!AiDriver#resumeRestoredFlow:member(1)",
+              "docComment": "/**\n * Bring a restored session's flow back to life (GENC-1662). Activates the locked agent — the flow owner or the user's pin — so its `init({ restored })` runs now rather than on the next message, then, when `transientPrimer` is given and the agent has not opted out, runs one turn from the restored history with that primer, exactly like a continuation.\n *\n * Returns the turn's result when one ran, `undefined` otherwise (nothing locked, the locked agent is not configured, or no primer). Never throws for those cases.\n *\n * @beta\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "resumeRestoredFlow?(transientPrimer?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Promise",
+                  "canonicalReference": "!Promise:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatDriverResult",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatDriverResult:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 4,
+                "endIndex": 8
+              },
+              "releaseTag": "Beta",
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "transientPrimer",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 3
+                  },
+                  "isOptional": true
+                }
+              ],
+              "name": "resumeRestoredFlow"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@genesislcap/ai-assistant!AiDriver#sendMessage:member(1)",
@@ -18324,6 +18433,54 @@
               "isAbstract": false,
               "name": "canCompact"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#canResumeRestoredFlow:member(1)",
+              "docComment": "/**\n * Whether a restore should resume the flow `agentName` owns (GENC-1662): the agent is configured here and has not opted out with `resumeOnRestore: false`. Pure — no activation. Lets the restore pick its divider wording before it hands the transcript over.\n *\n * Optional: a driver without it never resumes.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "canResumeRestoredFlow(agentName: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "agentName",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "canResumeRestoredFlow"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#compact:member(1)",
@@ -19383,6 +19540,73 @@
               "isAbstract": false,
               "name": "restoreCondensePolicies"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#resumeRestoredFlow:member(1)",
+              "docComment": "/**\n * Bring a restored session's flow back to life (GENC-1662). Activates the locked agent — the flow owner or the user's pin — so its `init({ restored })` runs now rather than on the next message, then, when `transientPrimer` is given and the agent has not opted out, runs one turn from the restored history with that primer, exactly like a continuation.\n *\n * Returns the turn's result when one ran, `undefined` otherwise (nothing locked, the locked agent is not configured, or no primer). Never throws for those cases.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "resumeRestoredFlow(transientPrimer?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Promise",
+                  "canonicalReference": "!Promise:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatDriverResult",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatDriverResult:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 4,
+                "endIndex": 8
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "transientPrimer",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 3
+                  },
+                  "isOptional": true
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "resumeRestoredFlow"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#sendMessage:member(1)",
@@ -22990,6 +23214,33 @@
                 "endIndex": 6
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@genesislcap/ai-assistant!StatefulAgentInit#resumeOnRestore:member",
+              "docComment": "/**\n * Whether a restored session this agent owns continues on its own after a reload — see `AgentConfig.resumeOnRestore`, which this is passed straight through to. Defaults to `true`.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "resumeOnRestore?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Beta",
+              "name": "resumeOnRestore",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@genesislcap/ai-assistant!StatefulAgentInit#serialize:member",

package/dist/ai-assistant.d.ts

@@ -803,6 +803,28 @@ export declare interface AiDriver extends EventTarget {
      * shipped drivers implement it and a host no longer has to feature-detect before restoring.
      */
     primeRestoredAgentState(snapshots: Record<string, unknown>): void;
+    /**
+     * Whether a restore should resume the flow `agentName` owns (GENC-1662): the agent is configured
+     * here and has not opted out with `resumeOnRestore: false`. Pure — no activation. Lets the restore
+     * pick its divider wording before it hands the transcript over.
+     *
+     * Optional: a driver without it never resumes.
+     *
+     * @beta
+     */
+    canResumeRestoredFlow?(agentName: string): boolean;
+    /**
+     * Bring a restored session's flow back to life (GENC-1662). Activates the locked agent — the
+     * flow owner or the user's pin — so its `init({ restored })` runs now rather than on the next
+     * message, then, when `transientPrimer` is given and the agent has not opted out, runs one turn
+     * from the restored history with that primer, exactly like a continuation.
+     *
+     * Returns the turn's result when one ran, `undefined` otherwise (nothing locked, the locked agent
+     * is not configured, or no primer). Never throws for those cases.
+     *
+     * @beta
+     */
+    resumeRestoredFlow?(transientPrimer?: ChatMessage[]): Promise<ChatDriverResult | undefined>;
     /**
      * Return the full, unredacted conversation history.
      */
@@ -1434,6 +1456,24 @@ declare interface BaseAgentConfig {
      * @beta
      */
     notResumableMessage?: string;
+    /**
+     * Whether a restored session that this agent owns continues on its own after a page reload
+     * (GENC-1662). Defaults to `true`; set `false` to keep the old behaviour of waiting for the user.
+     *
+     * Applies when the reload interrupted a turn: the restore trims an unanswered tool call, a pending
+     * interaction or a half-streamed reply off the transcript, because a live widget is a promise inside
+     * a running tool handler and cannot be persisted. With this on, the restore re-activates the agent
+     * and runs one turn from the restored history, with a transient note naming the call that never
+     * completed. That turn is a fresh model decision — it usually re-asks the same question, but may
+     * word it differently or pick another valid action.
+     *
+     * The agent is re-activated on restore either way, so a stateful agent's `init({ restored })` runs
+     * straight after the reload rather than on the next message. Never consulted for a session restored
+     * as interrupted ({@link BaseAgentConfig.resumable} returned `false`).
+     *
+     * @beta
+     */
+    resumeOnRestore?: boolean;
     /**
      * Tokens this agent wants kept free for one of its turns (GENC-1567).
      * Overrides `chatConfig.context.reserveTokens` while this agent is active;
@@ -4945,6 +4985,13 @@ export declare class FoundationAiAssistant extends GenesisElement {
      * persistence is (now) on.
      */
     private initPersistenceForNewStore;
+    /**
+     * Bring a restored flow back to life (GENC-1662). Always re-activates the flow owner, so a
+     * stateful agent's `init({ restored })` — and anything the host hangs off it, like a progress
+     * stepper — runs straight after the reload instead of on the next message. When the reload cut a
+     * turn short, also runs one turn from the restored history, shown as busy exactly as a send is.
+     */
+    private resumeRestoredFlow;
     triggerFileInput(): void;
     handleFileSelect(e: Event): void;
     removeAttachment(attachment: ChatAttachment): void;
@@ -4991,6 +5038,11 @@ export declare class FoundationAiAssistant extends GenesisElement {
      */
     private _pendingSendPrompt?;
     private send;
+    /**
+     * The post-turn settle shared by `send()` and a resumed restore turn: back to idle through
+     * the session ref captured at turn start, then the cleanup the state setter would have done.
+     */
+    private settleAfterTurn;
     onChatHeaderMouseDown(e: MouseEvent): void;
     handleInteractionCompleted(e: Event): void;
     /**
@@ -5493,6 +5545,17 @@ export declare class OrchestratingDriver extends EventTarget implements AiDriver
     continueFromHistory(transientPrimer?: ChatMessage[]): Promise<ChatDriverResult>;
     /** {@inheritDoc AiDriver.primeRestoredAgentState} */
     primeRestoredAgentState(snapshots: Record<string, unknown>): void;
+    /** {@inheritDoc AiDriver.canResumeRestoredFlow} */
+    canResumeRestoredFlow(agentName: string): boolean;
+    /**
+     * {@inheritDoc AiDriver.resumeRestoredFlow}
+     *
+     * Installs the locked agent directly rather than through `handleTurn`: there is no user message
+     * to classify, and a restored lock already says which agent owns the flow. `continueFromHistory`
+     * on its own would not do — it neither routes nor installs, so it would run on whatever agent
+     * happened to be installed (none, straight after a reload).
+     */
+    resumeRestoredFlow(transientPrimer?: ChatMessage[]): Promise<ChatDriverResult | undefined>;
     /**
      * {@inheritDoc AiDriver.getContextReserve}
      *
@@ -6400,6 +6463,11 @@ export declare interface StatefulAgentInit<S> {
      * `false`. Falls back to a built-in default when omitted.
      */
     notResumableMessage?: string;
+    /**
+     * Whether a restored session this agent owns continues on its own after a reload — see
+     * `AgentConfig.resumeOnRestore`, which this is passed straight through to. Defaults to `true`.
+     */
+    resumeOnRestore?: boolean;
 }
 
 /**

package/dist/chat-driver.cjs

@@ -4114,6 +4114,8 @@ var META_EVENT_IMPORTANCE = {
   "session.switched": "low",
   "session.switch-deferred": "low",
   "persistence.restored": "normal",
+  // Whether a restored flow will be re-activated and resumed (GENC-1662), and how much the trim cut.
+  "persistence.resume-planned": "normal",
   "persistence.suppressed": "normal",
   "persistence.not-resumable": "normal",
   "driver.wired": "low",
@@ -8705,6 +8707,29 @@ var OrchestratingDriver = class extends EventTarget {
   primeRestoredAgentState(snapshots) {
     this.agentSession.primeRestoredStates(snapshots);
   }
+  /** {@inheritDoc AiDriver.canResumeRestoredFlow} */
+  canResumeRestoredFlow(agentName) {
+    const agent = this.agents.find((a) => a.name === agentName);
+    return !!agent && agent.resumeOnRestore !== false;
+  }
+  /**
+   * {@inheritDoc AiDriver.resumeRestoredFlow}
+   *
+   * Installs the locked agent directly rather than through `handleTurn`: there is no user message
+   * to classify, and a restored lock already says which agent owns the flow. `continueFromHistory`
+   * on its own would not do — it neither routes nor installs, so it would run on whatever agent
+   * happened to be installed (none, straight after a reload).
+   */
+  async resumeRestoredFlow(transientPrimer) {
+    const agent = this.resolvePinnedAgent();
+    if (!agent) return void 0;
+    this.cancelled = false;
+    await this.installAgent(agent);
+    if (!transientPrimer?.length || agent.resumeOnRestore === false || this.cancelled) {
+      return void 0;
+    }
+    return this.chatDriver.continueFromHistory(transientPrimer);
+  }
   /**
    * {@inheritDoc AiDriver.getContextReserve}
    *
@@ -9179,6 +9204,7 @@ function defineStatefulAgent(opts) {
     onUnresolvedTool: wrappedOnUnresolvedTool,
     resumable: wrappedResumable,
     notResumableMessage: opts.notResumableMessage,
+    resumeOnRestore: opts.resumeOnRestore,
     contextReserve: opts.contextReserve,
     onActivate: async (ctx) => {
       state = await opts.init(ctx);