@genesislcap/ai-assistant 15.86.1 → 15.87.0

package/dist/esm/autopilot/autopilot-session.js

@@ -100,6 +100,32 @@ export function parseFields(fields) {
         return { ok: false };
     }
 }
+/**
+ * A function reading a number as the action it stands for in the list last shown (`numbering`, as
+ * {@link renderActions} returns it): `'2'` is `numbering[1]`; anything that is not a whole number,
+ * or is out of range, stands for nothing. Shared by `widget_act` and the headless driver, so "2"
+ * means the same option to both.
+ */
+export const byNumberOf = (numbering) => (value) => /^\d+$/.test(value.trim()) ? numbering[Number(value.trim()) - 1] : undefined;
+/**
+ * The arguments `widget_act` hands to `invoke` for `listed`, from what was asked. An action taking
+ * one free-text argument gets `text`, as `reply` does; a form gets its `fields`, parsed leniently
+ * ({@link parseFields}; not ok when they do not parse); anything else its options (a number mapped
+ * to its name by `byNumber`) and text, as given. Pure, and shared with the headless driver, so
+ * both build the same call from the same words.
+ */
+export function invokeArgsFor(listed, given, byNumber) {
+    if ((listed === null || listed === void 0 ? void 0 : listed.args) === 'text')
+        return { ok: true, args: { text: given.text } };
+    if (given.fields !== undefined && given.fields !== null && given.fields !== '') {
+        const parsed = parseFields(given.fields);
+        return parsed.ok ? { ok: true, args: parsed.value } : { ok: false };
+    }
+    return {
+        ok: true,
+        args: Object.assign(Object.assign({}, (given.options ? { options: given.options.map((o) => { var _a; return (_a = byNumber(o)) !== null && _a !== void 0 ? _a : o; }) } : {})), (given.text !== undefined ? { text: given.text } : {})),
+    };
+}
 /**
  * How to send `fields` for `action`, as a correctly escaped example: the whole `widget_act` call,
  * with `fields` a JSON object inside a string, built from the action's schema where it has one.
@@ -567,7 +593,7 @@ export class AutopilotSession {
                 }
                 const opened = current.opened;
                 // A number names an option in the list last sent; a name is a platform-owned action.
-                const byNumber = (value) => /^\d+$/.test(value.trim()) ? current.numbering[Number(value.trim()) - 1] : undefined;
+                const byNumber = byNumberOf(current.numbering);
                 const name = (_b = byNumber(String(action !== null && action !== void 0 ? action : ''))) !== null && _b !== void 0 ? _b : String(action !== null && action !== void 0 ? action : '').trim();
                 const listed = (_c = opened.ctx.surface) === null || _c === void 0 ? void 0 : _c.actions().find((a) => a.name === name);
                 // Past the refinement limit, a refining action is withdrawn: not listed, and refused here.
@@ -575,22 +601,11 @@ export class AutopilotSession {
                     const what = name === 'reply' ? 'a written answer' : `"${name}"`;
                     return `Not done: ${what} is not available for this one any more; choose another action or hand it back.\n${relist()}`;
                 }
-                // An action taking one free-text argument gets `text`, as `reply` does; a form gets its
-                // `fields`, parsed leniently; anything else its options and text, as given.
-                let invokeArgs;
-                if ((listed === null || listed === void 0 ? void 0 : listed.args) === 'text') {
-                    invokeArgs = { text };
-                }
-                else if (fields !== undefined && fields !== null && fields !== '') {
-                    const parsed = parseFields(fields);
-                    if (!parsed.ok) {
-                        return `Not done: fields is not valid JSON. ${fieldsExample(name, listed === null || listed === void 0 ? void 0 : listed.argsSchema)}\n${relist()}`;
-                    }
-                    invokeArgs = parsed.value;
-                }
-                else {
-                    invokeArgs = Object.assign(Object.assign({}, (options ? { options: options.map((o) => { var _a; return (_a = byNumber(o)) !== null && _a !== void 0 ? _a : o; }) } : {})), (text !== undefined ? { text } : {}));
+                const built = invokeArgsFor(listed, { options, text, fields }, byNumber);
+                if (!built.ok) {
+                    return `Not done: fields is not valid JSON. ${fieldsExample(name, listed === null || listed === void 0 ? void 0 : listed.argsSchema)}\n${relist()}`;
                 }
+                const invokeArgs = built.args;
                 const result = yield opened.hold.invoke(name, invokeArgs, { note });
                 if (!result.ok) {
                     return `Not done: ${result.message}\n${relist()}`;

package/dist/esm/chat-driver-node.js

@@ -23,6 +23,11 @@ export * from './channel/ai-activity-bus';
 export * from './config/config';
 export * from './config/define-stateful-agent';
 export * from './config/fallback-agents';
+// The headless session: a way for a host with no browser to run a whole assistant journey as the
+// person. DOM-free like everything above: plain classes over the driver, `decision-message` (text
+// only) and `autopilot-session`'s pure argument helpers; the autopilot's FAST hand-back view is
+// not in its closure, and `AutopilotHost` is imported for its type alone.
+export * from './headless';
 // Provider-construction surface, re-exported from `@genesislcap/foundation-ai` so a headless
 // consumer builds its registry from the SAME bundled foundation-ai instance the driver uses. That
 // shared identity matters: `ChatDriver`'s malformed/truncated handling does `instanceof` on the
@@ -113,3 +118,6 @@ export { buildTimelineEntries } from './state/persistence/build-timeline-entries
 // and cost figures are as old as that. Pass a fresh snapshot of your own through this before
 // `assembleDebugLog`, or state in your own output that the totals are historical.
 export { assembleDebugLog, withFreshMetaSnapshot } from './state/persistence/diagnostics';
+// The two derivations of a debug log the browser's element uses (and the headless session), so a
+// host assembling its own log does not write a second one. DOM-free.
+export { buildDiagnosticEntries, lifetimeDebugLog } from './state/persistence/debug-log-assembly';

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

@@ -176,6 +176,18 @@ export class BaseDriverDecorator extends EventTarget {
         var _a, _b, _c;
         return (_c = (_b = (_a = this.inner).addInteractionInterceptor) === null || _b === void 0 ? void 0 : _b.call(_a, interceptor)) !== null && _c !== void 0 ? _c : (() => undefined);
     }
+    /**
+     * Forwarded: the interaction belongs to the driver that opened it. An inner driver that cannot
+     * run actions answers as if the interaction had ended.
+     */
+    invokeAsUser(interactionId, action, args) {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = this.inner).invokeAsUser) === null || _b === void 0 ? void 0 : _b.call(_a, interactionId, action, args)) !== null && _c !== void 0 ? _c : Promise.resolve({
+            ok: false,
+            error: 'not-held',
+            message: 'This interaction has already ended.',
+        }));
+    }
     presentInteraction(componentName, data, options) {
         var _a, _b, _c;
         return ((_c = (_b = (_a = this.inner).presentInteraction) === null || _b === void 0 ? void 0 : _b.call(_a, componentName, data, options)) !== null && _c !== void 0 ? _c : Promise.reject(new Error('presentInteraction: the inner driver cannot show interactions.')));

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

@@ -1852,6 +1852,14 @@ export class ChatDriver extends EventTarget {
     addInteractionInterceptor(interceptor) {
         return this.interactions.addInterceptor(interceptor);
     }
+    /**
+     * {@inheritDoc AiDriver.invokeAsUser}
+     *
+     * @beta
+     */
+    invokeAsUser(interactionId, action, args) {
+        return this.interactions.invokeAsUser(interactionId, action, args);
+    }
     /**
      * {@inheritDoc AiDriver.presentInteraction}
      *

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

@@ -774,6 +774,72 @@ export class InteractionController {
         (_f = this.contexts.get(interactionId)) === null || _f === void 0 ? void 0 : _f.dispose();
         this.contexts.delete(interactionId);
     }
+    /**
+     * See `ChatDriver.invokeAsUser`: `hold.invoke`'s sibling for the person (GENC-1660).
+     *
+     * Runs the action the way the widget's own button does, and records nothing against a claimant:
+     * no `settledBy`, no `decision`. So `whoAnswered` credits a settle to the person
+     * (`answeredBy: 'user'`), exactly as a click would be. Refused unless the person holds the
+     * interaction: a claimant that does is not pushed aside, the person takes it back first. An
+     * editing action leaves no edit record either — those mark what a claimant changed on the
+     * person's behalf, and this is the person's own change.
+     */
+    invokeAsUser(interactionId, action, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const pending = this.pending.get(interactionId);
+            const handle = this.contexts.get(interactionId);
+            if (!pending || !handle) {
+                return { ok: false, error: 'not-held', message: 'This interaction has already ended.' };
+            }
+            if (handle.context.heldBy !== 'user') {
+                return {
+                    ok: false,
+                    error: 'not-held',
+                    message: 'Another agent holds this interaction, so it was not acted on. The person has to take it back first, for example by pausing the autopilot.',
+                };
+            }
+            const { surface } = handle;
+            if (!surface) {
+                return { ok: false, error: 'no-surface', message: 'Nothing has been exposed here yet.' };
+            }
+            // One action at a time, as for a claimant: a second run would start while the first is still
+            // in flight. Refused, with nothing run.
+            if (pending.running) {
+                return Object.assign(Object.assign({ ok: false }, BUSY), { actions: surface.actions() });
+            }
+            const prepared = surface.prepare(action, args);
+            if ('error' in prepared) {
+                return Object.assign(Object.assign({ ok: false }, prepared), { actions: surface.actions() });
+            }
+            const token = {};
+            pending.running = { token, finishes: prepared.finishes, note: undefined };
+            let output;
+            try {
+                const ran = prepared.run();
+                output = isThenable(ran) ? yield ran : ran;
+            }
+            catch (e) {
+                logger.warn(`InteractionController: action "${action}" threw:`, e);
+                return { ok: false, error: 'threw', message: e instanceof Error ? e.message : String(e) };
+            }
+            finally {
+                if (((_a = pending.running) === null || _a === void 0 ? void 0 : _a.token) === token)
+                    pending.running = undefined;
+            }
+            // Settled, whichever way it got there: the answer is the person's regardless, so unlike a
+            // claimant's run there is no run token to tell this run's settle from another's. One held back
+            // until its message is appended (`early`) is settled too, as soon as it is.
+            const finished = !this.pending.has(interactionId) || pending.early !== undefined;
+            recordMetaEvent(this.deps.sessionKey, 'interaction.invoked', {
+                interactionId,
+                by: 'user',
+                action,
+                finished,
+            });
+            return Object.assign({ ok: true, finished, actions: finished ? [] : surface.actions() }, (output !== undefined && !finished ? { output } : {}));
+        });
+    }
     /**
      * See `ChatDriver.recordExternalCost`.
      *

package/dist/esm/headless/describe-interaction.js

@@ -0,0 +1,55 @@
+import { renderDecision, widgetAsText } from '../autopilot/decision-message';
+/** An action, as a model reads it: only what is set, so the record stays small. */
+const describeAction = (action, n) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (n !== undefined ? { n } : {})), { name: action.name }), (action.label !== undefined ? { label: action.label } : {})), (action.description !== undefined ? { description: action.description } : {})), { enabled: action.enabled }), (action.unavailable !== undefined ? { unavailable: action.unavailable } : {})), (action.args !== undefined ? { args: action.args } : {})), (action.argsSchema !== undefined ? { argsSchema: action.argsSchema } : {})), { finishes: action.finishes }), (action.refines ? { refines: true } : {})));
+/**
+ * What the person is being asked, as a compact JSON-serialisable record a model can read and
+ * answer (GENC-1660): the same text the autopilot is sent for the decision (`renderDecision`,
+ * so there is one rendering of a decision, not two), and its actions as data, numbered as that text
+ * numbers them, so "1" means the same option here and there.
+ *
+ * With no surface — a widget with no controller, or one that has not exposed anything yet — there
+ * is nothing to act on: `controller` is `false` (or `true` and not `ready`, while a controller that
+ * will expose a surface has not yet), `actions` is empty, and `text` is the widget as text alone.
+ *
+ * Reads the surface fresh each time, so it describes the widget as it is now.
+ *
+ * @beta
+ */
+export function describeInteraction(input) {
+    const { ctx, componentName, data } = input;
+    const base = {
+        interactionId: ctx.interactionId,
+        component: componentName,
+        heldBy: ctx.heldBy,
+    };
+    const { surface } = ctx;
+    if (!surface) {
+        const hasController = ctx.controller !== undefined;
+        return Object.assign(Object.assign({}, base), { controller: hasController, 
+            // A controller that has not exposed its surface yet will: wait for it. Without one, the
+            // widget is all there is.
+            ready: !hasController, text: widgetAsText(componentName, data), actions: [] });
+    }
+    const rendered = renderDecision({
+        interactionId: ctx.interactionId,
+        componentName,
+        data,
+        surface,
+    });
+    const actions = surface.actions().map((a) => {
+        const index = rendered.numbering.indexOf(a.name);
+        // Only a plain option is numbered, as `renderActions` does; a full-form action of the same
+        // name is called by name.
+        return describeAction(a, index >= 0 && a.description === undefined ? index + 1 : undefined);
+    });
+    let facts;
+    try {
+        const read = surface.facts();
+        if (Object.keys(read).length)
+            facts = Object.assign({}, read);
+    }
+    catch (_a) {
+        // A facts reader that throws must not hide the decision.
+    }
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, base), { controller: true, ready: surface.isReady(), text: rendered.text, actions }), (surface.views && Object.keys(surface.views).length ? { views: Object.assign({}, surface.views) } : {})), (facts ? { facts } : {}));
+}

package/dist/esm/headless/headless-debug.js

@@ -0,0 +1,62 @@
+import { ChatDriver } from '../components/chat-driver/chat-driver';
+import { buildMetaSnapshot } from '../main/meta-snapshot';
+import { DEBUG_LOG_README } from '../state/debug-event-log';
+import { buildDiagnosticEntries } from '../state/persistence/debug-log-assembly';
+import { assembleDebugLog, } from '../state/persistence/diagnostics';
+import { estimateContextTokens, isContextMeasurable } from '../utils/context-tokens';
+import { stripAgentHandlers } from '../utils/strip-agent-handlers';
+import { sumUsage, totalTokens } from '../utils/sum-usage';
+/** What `meta.host` says when the host did not name itself. */
+const DEFAULT_HOST = 'headless';
+/**
+ * The `meta-snapshot` entry for right now, gathered the way the assistant element gathers it
+ * (`buildMetaSnapshot` does the assembly; this reads what it reports): the live agent comes from
+ * the DRIVER, the transcript from its raw history, and the figures from the transcript, so what a
+ * headless host logs is what the browser would. The context window and model, which the element
+ * learns from its provider registry, are the host's to say.
+ *
+ * @beta
+ */
+export function headlessMetaSnapshot(driver, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const history = (_b = (_a = driver.getRawHistory) === null || _a === void 0 ? void 0 : _a.call(driver)) !== null && _b !== void 0 ? _b : [];
+    const usage = sumUsage(history);
+    const live = driver.getActiveAgent();
+    const context = (_c = options.context) === null || _c === void 0 ? void 0 : _c.call(options);
+    return buildMetaSnapshot({
+        agents: options.agents ? [...options.agents()] : undefined,
+        activeAgent: live ? stripAgentHandlers(live) : undefined,
+        liveActiveAgent: live,
+        activeFoldStack: driver instanceof ChatDriver ? driver.getActiveFoldNames() : undefined,
+        activeModel: context === null || context === void 0 ? void 0 : context.model,
+        contextTokens: isContextMeasurable(history) ? estimateContextTokens(history) : undefined,
+        contextLimit: context === null || context === void 0 ? void 0 : context.contextLimit,
+        sessionCostUsd: usage.costUsd,
+        sessionTokensConsumed: totalTokens(usage),
+        sessionUsage: usage,
+        debugState: (_d = options.debugState) === null || _d === void 0 ? void 0 : _d.call(options),
+        host: (_e = options.host) !== null && _e !== void 0 ? _e : DEFAULT_HOST,
+    });
+}
+/**
+ * The diagnostic entries for the session so far, from the same `buildDiagnosticEntries` the
+ * browser's element and its persister use.
+ *
+ * @beta
+ */
+export function headlessDiagnosticEntries(driver, stateKey, options = {}) {
+    return buildDiagnosticEntries({
+        driver,
+        stateKey,
+        metaSnapshot: () => headlessMetaSnapshot(driver, options),
+    });
+}
+/**
+ * The current page's debug log: what `HeadlessSession.debugLog()` returns when nothing is
+ * persisted, and the fallback when the stored stream cannot be read.
+ *
+ * @beta
+ */
+export function headlessCurrentDebugLog(driver, stateKey, options = {}) {
+    return assembleDebugLog(headlessDiagnosticEntries(driver, stateKey, options), DEBUG_LOG_README);
+}

package/dist/esm/headless/headless-persistence.js

@@ -0,0 +1,192 @@
+import { __awaiter } from "tslib";
+import { lifetimeDebugLog } from '../state/persistence/debug-log-assembly';
+import { deletePersister, getOrCreatePersister } from '../state/persistence/persister-registry';
+import { SessionPersister } from '../state/persistence/session-persister';
+import { lastUserMessageIndex } from '../state/persistence/session-snapshot';
+import { getSessionStore } from '../state/session-store';
+import { estimateContextTokens, isContextMeasurable } from '../utils/context-tokens';
+import { stripAgentHandlers } from '../utils/strip-agent-handlers';
+import { sumUsage } from '../utils/sum-usage';
+import { headlessCurrentDebugLog, headlessDiagnosticEntries, headlessMetaSnapshot, } from './headless-debug';
+/**
+ * The session persister, fed from a driver with no element to feed it. Holds what the persister
+ * reads of the session store (the transcript, the agent, the pin and the flow owner, the usage and
+ * the provider) current from the driver's events, and asks it to save on the events on which the
+ * browser's element does: a transcript change, spend recorded after the fact, a checkpoint, a
+ * hand-off. Only what the persister needs: none of the element's UI state.
+ */
+class Binding {
+    constructor(driver, options) {
+        this.driver = driver;
+        this.options = options;
+        this.ref = getSessionStore(this.options.stateKey);
+        this.teardown = [];
+        this.disposed = false;
+        const deps = {
+            stateKey: options.stateKey,
+            getPersistence: () => ({ enabled: true, provider: options.provider }),
+            getAgentNames: () => { var _a, _b; return ((_b = (_a = options.agents) === null || _a === void 0 ? void 0 : _a.call(options)) !== null && _b !== void 0 ? _b : []).map((a) => a.name); },
+            getDriver: () => driver,
+            getStore: () => this.ref,
+            getDiagnosticEntries: () => headlessDiagnosticEntries(driver, options.stateKey, options),
+        };
+        this.persister = getOrCreatePersister(options.stateKey, () => new SessionPersister(deps));
+        this.persister.rebindDeps(deps);
+        this.syncAll();
+        const on = (type, handler) => {
+            driver.addEventListener(type, handler);
+            this.teardown.push(() => driver.removeEventListener(type, handler));
+        };
+        // The element's `wireDriver` triggers, on the same events.
+        on('history-updated', () => {
+            this.syncTranscript();
+            this.persister.scheduleSave();
+            this.persister.scheduleDiagnostics();
+        });
+        on('external-cost-recorded', () => {
+            this.syncUsage();
+            this.persister.scheduleSave();
+            this.persister.scheduleDiagnostics();
+        });
+        on('checkpoint-saved', () => this.persister.scheduleSave());
+        on('agent-changed', (e) => {
+            const agent = e.detail;
+            this.ref.actions.aiAssistant.setActiveAgent(agent ? stripAgentHandlers(agent) : undefined);
+        });
+        on('pinned-changed', (e) => {
+            const name = e.detail;
+            if (this.ref.store.aiAssistant.pinnedAgentName !== name) {
+                this.ref.actions.aiAssistant.setPinnedAgentName(name);
+            }
+        });
+        on('flow-owner-changed', (e) => this.onFlowOwnerChanged(e.detail));
+        on('provider-changed', (e) => {
+            this.ref.actions.aiAssistant.setActiveProviderName(e.detail.name);
+            this.syncContext();
+        });
+        // A hand-off is part of the session, and saved — except one ended as `cleared`.
+        for (const type of ['handoff-started', 'handoff-returned', 'handoff-unwound']) {
+            on(type, (e) => {
+                var _a, _b;
+                if (((_b = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.outcome) === null || _b === void 0 ? void 0 : _b.kind) !== 'cleared') {
+                    this.persister.scheduleSave();
+                }
+            });
+        }
+    }
+    notePrompt(text) {
+        this.pendingPrompt = text;
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.disposed)
+                return;
+            this.syncAll();
+            yield this.persister.saveNow();
+            yield this.persister.flushDiagnostics();
+        });
+    }
+    debugLog() {
+        const { driver, options } = this;
+        return lifetimeDebugLog({
+            provider: options.provider,
+            stateKey: options.stateKey,
+            // Land the current delta first, so the log includes it.
+            flush: () => this.persister.flushDiagnostics(),
+            metaSnapshot: () => headlessMetaSnapshot(driver, options),
+            fallback: () => headlessCurrentDebugLog(driver, options.stateKey, options),
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const off of this.teardown.splice(0))
+            off();
+        // Timers only: the saved session stays where it is.
+        deletePersister(this.options.stateKey);
+    }
+    /**
+     * Mirror the flow owner, and the prompt that started the flow, as the element does: a
+     * non-resumable tombstone hands that prompt back on return (GENC-1351 §5.9). `flow-owner-changed`
+     * fires while a turn is being routed, BEFORE its message is in history, so the prompt the session
+     * was told of wins over the last user message in history, which would be the one before.
+     */
+    onFlowOwnerChanged(name) {
+        var _a, _b, _c, _d;
+        const { actions, store } = this.ref;
+        if (store.aiAssistant.flowOwnerAgentName !== name) {
+            actions.aiAssistant.setFlowOwnerAgentName(name);
+        }
+        if (!name) {
+            actions.aiAssistant.setFlowActivationPrompt(null);
+            return;
+        }
+        const history = (_c = (_b = (_a = this.driver).getRawHistory) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+        const prompt = this.pendingPrompt || ((_d = history[lastUserMessageIndex(history)]) === null || _d === void 0 ? void 0 : _d.content);
+        if (prompt)
+            actions.aiAssistant.setFlowActivationPrompt(prompt);
+    }
+    syncAll() {
+        var _a, _b, _c;
+        const { actions } = this.ref;
+        const live = this.driver.getActiveAgent();
+        actions.aiAssistant.setActiveAgent(live ? stripAgentHandlers(live) : undefined);
+        actions.aiAssistant.setActiveProviderName(this.driver.getActiveProviderName());
+        const owner = (_c = (_b = (_a = this.driver).getFlowOwner) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null;
+        if (owner !== this.ref.store.aiAssistant.flowOwnerAgentName)
+            this.onFlowOwnerChanged(owner);
+        this.syncTranscript();
+    }
+    /** The transcript and what is derived from it, as the element's `messages` setter does. */
+    syncTranscript() {
+        var _a, _b, _c;
+        const history = (_c = (_b = (_a = this.driver).getRawHistory) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+        const { actions } = this.ref;
+        actions.aiAssistant.setMessages([...history]);
+        // Estimated, not the last raw measurement: see the element's `handleMessagesUpdate`.
+        if (isContextMeasurable(history)) {
+            actions.aiAssistant.setContextTokens(estimateContextTokens(history));
+        }
+        this.syncUsage();
+        this.syncContext();
+    }
+    syncUsage() {
+        var _a, _b, _c;
+        const usage = sumUsage((_c = (_b = (_a = this.driver).getRawHistory) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : []);
+        this.ref.actions.aiAssistant.setSessionUsage(usage);
+    }
+    syncContext() {
+        var _a, _b;
+        const context = (_b = (_a = this.options).context) === null || _b === void 0 ? void 0 : _b.call(_a);
+        const { actions } = this.ref;
+        actions.aiAssistant.setContextLimit(context === null || context === void 0 ? void 0 : context.contextLimit);
+        actions.aiAssistant.setActiveModel(context === null || context === void 0 ? void 0 : context.model);
+    }
+}
+/**
+ * Persistence for a `HeadlessSession`: it writes exactly what the browser writes — the
+ * `sessions/<key>` snapshot and the `diag/<key>` stream — through the platform's
+ * `SessionPersister` and the host's `SessionPersistenceProvider`, and builds the lifetime debug log
+ * from the same code as the browser's Download.
+ *
+ * Exported from the package's main entry only, NOT from the Node entry (`./chat-driver`): it
+ * reaches the session store, and through it `@genesislcap/foundation-redux`, which are not
+ * Node-clean. The `persister` it makes is the registry's, so a host can restore through
+ * `getPersister(stateKey)`.
+ *
+ * @example
+ * ```ts
+ * const session = new HeadlessSession(driver, {
+ *   persistence: headlessPersistence({ provider, stateKey: 'project-1', agents: () => agents }),
+ * });
+ * ```
+ *
+ * @beta
+ */
+export function headlessPersistence(options) {
+    return {
+        stateKey: options.stateKey,
+        attach: (host) => new Binding(host.driver, options),
+    };
+}