@genesislcap/ai-assistant 15.61.0 → 15.62.0

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

@@ -3,12 +3,12 @@ import { AIServiceError, BudgetExhaustedError } from '@genesislcap/foundation-ai
 import { validateStaticAgentProviders } from '../../config/validate-providers';
 import { recordMetaEvent } from '../../state/debug-event-log';
 import { reachesProvider } from '../../utils/context-tokens';
-import { DEFAULT_DELEGATE_FRAMING, frameDelegatedContent, } from '../../utils/delegated-message';
+import { delegatedFields, frameDelegatedContent, } from '../../utils/delegated-message';
 import { transformHistoryForAgent } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { messageUsage } from '../../utils/sum-usage';
 import { BaseDriverDecorator } from '../ai-driver/base-driver-decorator';
-import { ChatDriver, REQUEST_CONTINUATION_TOOL } from '../chat-driver/chat-driver';
+import { ChatDriver, REQUEST_CONTINUATION_TOOL, } from '../chat-driver/chat-driver';
 const DEFAULT_MAX_HANDOFFS = 3;
 const DEFAULT_CLASSIFIER_HISTORY_LENGTH = 4;
 const DEFAULT_CLASSIFIER_RETRIES = 2;
@@ -262,14 +262,9 @@ export class OrchestratingDriver extends BaseDriverDecorator {
     }
     sendMessage(input, attachments, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Who it is from travels with every copy of the message this method makes (GENC-1660).
-            const delegated = (options === null || options === void 0 ? void 0 : options.delegate)
-                ? {
-                    delegate: options.delegate,
-                    delegateFraming: (_a = options.delegateFraming) !== null && _a !== void 0 ? _a : DEFAULT_DELEGATE_FRAMING,
-                }
-                : {};
+            // Who it is from, and what writing it cost, travel with every copy of the message this method
+            // makes (GENC-1660).
+            const delegated = delegatedFields(options);
             try {
                 return yield this.runOrchestratedTurn(input, attachments, options, delegated);
             }
@@ -490,7 +485,29 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             yield this.installAgent(agent);
             if (!resumeNote || agent.resumeOnRestore === false || this.cancelled)
                 return undefined;
-            return this.chatDriver.continueFromHistory(undefined, { tailNote: resumeNote });
+            const result = yield this.chatDriver.continueFromHistory(undefined, { tailNote: resumeNote });
+            yield this.releaseIfRequested();
+            return result;
+        });
+    }
+    /**
+     * A continuation outside a routed turn — a decorator carrying the agent on, say — can finish the
+     * flow as surely as a turn can, so a release it requests is acted on here too. Before
+     * (GENC-1660), only `sendMessage` checked, and a flow finished by a continuation stayed locked.
+     */
+    continueFromHistory(transientPrimer, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.chatDriver.continueFromHistory(transientPrimer, options);
+            yield this.releaseIfRequested();
+            return result;
+        });
+    }
+    /** Release the flow if the turn that just ended asked to, and an agent is still active to release. */
+    releaseIfRequested() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.chatDriver.getAgentReleaseRequested() && this.agentSession.getActive()) {
+                yield this.releaseActiveAgent();
+            }
         });
     }
     /**

package/dist/esm/config/define-stateful-agent.js

@@ -246,27 +246,12 @@ export function defineStatefulAgent(opts) {
             });
         })
         : undefined;
-    const base = {
-        name: opts.name,
-        displayName: wrappedDisplayName,
-        primerHistory: opts.primerHistory,
-        subAgents: opts.subAgents,
-        manualSelection: opts.manualSelection,
-        chatInputDuringExecution: opts.chatInputDuringExecution,
-        toolDefinitions: wrappedTools,
-        toolHandlers: wrappedHandlers,
-        provider: wrappedProvider,
-        temperature: wrappedTemperature,
-        toolChoice: wrappedToolChoice,
-        cachePolicy: wrappedCachePolicy,
-        thinkingPolicy: wrappedThinkingPolicy,
-        tailContext: wrappedTailContext,
-        onUnresolvedTool: wrappedOnUnresolvedTool,
-        resumable: wrappedResumable,
-        notResumableMessage: opts.notResumableMessage,
-        resumeOnRestore: opts.resumeOnRestore,
-        contextReserve: opts.contextReserve,
-        onActivate: (ctx) => __awaiter(this, void 0, void 0, function* () {
+    const base = Object.assign(Object.assign({ name: opts.name, displayName: wrappedDisplayName, primerHistory: opts.primerHistory, subAgents: opts.subAgents, manualSelection: opts.manualSelection, chatInputDuringExecution: opts.chatInputDuringExecution, toolDefinitions: wrappedTools, toolHandlers: wrappedHandlers, provider: wrappedProvider, temperature: wrappedTemperature, toolChoice: wrappedToolChoice, cachePolicy: wrappedCachePolicy, thinkingPolicy: wrappedThinkingPolicy, tailContext: wrappedTailContext, onUnresolvedTool: wrappedOnUnresolvedTool, resumable: wrappedResumable, notResumableMessage: opts.notResumableMessage, resumeOnRestore: opts.resumeOnRestore, contextReserve: opts.contextReserve }, (opts.autopilot && {
+        autopilot: {
+            config: opts.autopilot,
+            state: () => state,
+        },
+    })), { onActivate: (ctx) => __awaiter(this, void 0, void 0, function* () {
             state = yield opts.init(ctx);
             // Sample once with the init state to fail loud on fold misuse at the
             // agent-switch boundary instead of waiting for the first tool call.
@@ -277,8 +262,7 @@ export function defineStatefulAgent(opts) {
                 const sampled = yield opts.toolHandlers(state);
                 assertNoFolds(sampled);
             }
-        }),
-        onDeactivate: (ctx) => __awaiter(this, void 0, void 0, function* () {
+        }), onDeactivate: (ctx) => __awaiter(this, void 0, void 0, function* () {
             if (state !== undefined && opts.dispose) {
                 yield opts.dispose(Object.assign(Object.assign({}, ctx), { state }));
             }
@@ -286,15 +270,14 @@ export function defineStatefulAgent(opts) {
             // cannot interleave the read-then-write of `state`.
             // eslint-disable-next-line require-atomic-updates
             state = undefined;
-        }),
-        systemPrompt: opts.systemPrompt
+        }), systemPrompt: opts.systemPrompt
             ? (ctx) => __awaiter(this, void 0, void 0, function* () {
                 if (!state) {
                     throw new Error(`Stateful agent "${opts.name}" systemPrompt called before init`);
                 }
                 return opts.systemPrompt(Object.assign(Object.assign({}, ctx), { state }));
             })
-            : undefined,
+            : undefined, 
         // Called per LLM call by ChatDriver, and once at debug-log export time.
         // Returns `undefined` before activation (state hasn't been built yet) and
         // after deactivation (state was disposed) — the snapshotter is best-effort
@@ -305,14 +288,36 @@ export function defineStatefulAgent(opts) {
             return opts.getDebugSnapshot
                 ? opts.getDebugSnapshot(state)
                 : defaultStatefulDebugSnapshot(state);
-        },
+        }, 
         // Lossless restore image for session persistence (see `serialize` on the
         // config). Returns undefined before activation / after disposal.
         serialize: () => {
             if (state === undefined)
                 return undefined;
             return opts.serialize ? opts.serialize(state) : defaultStatefulSerialize(state);
-        },
-    };
+        } });
     return Object.assign(Object.assign({}, base), { description: opts.description, excludeFromClassifier: opts.excludeFromClassifier });
 }
+/**
+ * Define an autopilot for a stateful agent whose state is `S` (GENC-1660). An identity function
+ * that exists for its type: the resolvers get `S`, and the result goes on `defineStatefulAgent`'s
+ * `autopilot` option.
+ *
+ * @example
+ * ```ts
+ * defineStatefulAgent<BootstrapState>({
+ *   name: 'bootstrap',
+ *   …,
+ *   autopilot: defineAutopilot<BootstrapState>({
+ *     availableWhen: ({ state }) => briefApproved(state.machine),
+ *     widgetPolicy: { 'planning-question': 'allowed' },
+ *     systemPrompt: ({ state }) => `${AUTOPILOT_BASE}\n<brief>${frozenBrief(state)}</brief>`,
+ *   }),
+ * });
+ * ```
+ *
+ * @beta
+ */
+export function defineAutopilot(config) {
+    return config;
+}

package/dist/esm/index.js

@@ -3,6 +3,7 @@ export * from './main/main.types';
 export * from './main/main.template';
 export * from './components/agent-picker';
 export * from './components/agent-session';
+export * from './autopilot';
 export * from './components/ai-driver';
 export * from './components/chat-driver';
 export * from './components/orchestrating-driver';
@@ -19,6 +20,8 @@ export * from './provider/assistant-app-settings';
 export * from './utils/tool-fold';
 export { DEFAULT_DELEGATE_FRAMING, isDelegated, } from './utils/delegated-message';
 export { assistantSettingsSectionTitleStyles } from './styles/settings-section';
+export { runSteps } from './state/run-steps';
+export { getInteractionRegistration, registerInteraction, } from './state/interaction-registry';
 // MARKDOWN_EXPORTPARTS travels with the component: a host rendering `<ai-chat-markdown>` in its
 // own shadow root has to forward its parts, and hand-copying the list is how it drifts.
 export { AiChatMarkdown, MARKDOWN_EXPORTPARTS } from './components/chat-markdown/chat-markdown';