@genesislcap/ai-assistant 15.58.1 → 15.59.0

package/dist/dts/types/interaction-interceptor.d.ts

@@ -0,0 +1,109 @@
+import type { InteractionContext } from './interaction-context';
+/**
+ * The handle an interceptor uses to move a pending interaction between the person and itself
+ * (GENC-1660): to the person when it hands back or is paused, back to itself when resumed.
+ *
+ * Every interceptor is offered one, but only the claimant's works: on any other interceptor's
+ * handle, and after the interaction ends, its members do nothing and return `false`. A claim is
+ * granted only once `onInteractionOpened` has returned `'claim'` (it may yet be refused), so the
+ * claimant's own handle does nothing until then either: act on it afterwards. Views read the
+ * result as `ctx.heldBy`; they never change it.
+ *
+ * @beta
+ */
+export interface InteractionHold {
+    /**
+     * Give the interaction to the person (`'user'`) or back to the claimant (`'claimant'`). Notifies
+     * the context's subscribers and records `interaction.held`. Returns whether it applied.
+     */
+    set(holder: 'user' | 'claimant'): boolean;
+    /**
+     * Say what the claimant decided, before it settles the interaction, so the tool that asked is
+     * told honestly (GENC-1660). When the interaction then resolves while the claimant holds it, the
+     * driver adds a {@link DelegatedDecision} built from this to that tool's result, so the working
+     * agent learns the choice was made on the user's behalf and what the user was shown about it.
+     *
+     * Optional to call: without it the record carries only the framing. Later calls replace earlier
+     * ones. Returns `false`, recording nothing, unless this interceptor holds the interaction.
+     */
+    recordDecision(decision: {
+        choice?: string;
+        shownToUser?: string;
+    }): boolean;
+    /**
+     * Settle the interaction AS the claimant (GENC-1660). The only route that stamps the claimant as
+     * `answeredBy`: an answer through the host's `resolveInteraction` — a click — is the person's,
+     * whoever held the interaction at the time, so attribution never depends on a view honouring
+     * `heldBy`. Returns `false`, settling nothing, unless this interceptor holds it right now.
+     */
+    resolve(result: unknown): boolean;
+}
+/**
+ * What the working agent is told about an interaction an interceptor answered (GENC-1660): added
+ * to the result of the tool call that requested it, as `decidedOnUsersBehalf` on an object result
+ * or as a line appended to a text one.
+ *
+ * Built only from what the platform already holds — the claimant's framing, and the choice and
+ * narration it recorded — so the text the person saw and the text the agent is told about are the
+ * same string. It never names the claimant, so the agent has nothing to repeat about one.
+ *
+ * @beta
+ */
+export interface DelegatedDecision {
+    /** The claimant's {@link InteractionInterceptor.decisionFraming}, e.g. "Decided on the user's behalf". */
+    readonly framing: string;
+    /** What was chosen, as recorded by the claimant. */
+    readonly choice?: string;
+    /** What the person was shown about it, verbatim, as the assistant's own words. */
+    readonly shownToUser?: string;
+}
+/**
+ * A new interaction, as offered to each installed interceptor (GENC-1660).
+ *
+ * Offered once, at the root driver, after its context exists and before its message is appended,
+ * so the first render of its widget already knows who holds it.
+ *
+ * @beta
+ */
+export interface InteractionOpened {
+    readonly interactionId: string;
+    readonly componentName: string;
+    /** The `data` the widget was requested with. */
+    readonly data: unknown;
+    /**
+     * The agents that asked for it, outermost first: the root's active agent, then each sub-agent
+     * the request travelled up through — e.g. `['bootstrap', 'brief-critic']`. The last entry is the
+     * agent whose tool handler called `requestInteraction`.
+     */
+    readonly ownerPath: readonly string[];
+    /** Set from `InteractionRequestOptions.userOnly`: nobody may claim it. */
+    readonly userOnly: boolean;
+    /** The interaction's live context, the same object its widget is handed. */
+    readonly ctx: InteractionContext;
+    /** See {@link InteractionHold}. Works only for the interceptor whose claim was granted. */
+    readonly hold: InteractionHold;
+}
+/**
+ * Something that is told about every interaction a driver opens, and may answer it instead of the
+ * person (GENC-1660). Installed with `AiDriver.addInteractionInterceptor`, typically by a driver
+ * decorator such as an autopilot or a test harness.
+ *
+ * Interceptors are asked outermost first. The first to claim an interaction holds it; the rest
+ * observe — they see the same context but their `hold` does nothing. Nobody can claim a `userOnly`
+ * interaction. A throwing interceptor is logged and treated as abstaining.
+ *
+ * @beta
+ */
+export interface InteractionInterceptor {
+    /** The holder id this interceptor's claims are recorded under, e.g. `'autopilot'`. Not `'user'`. */
+    readonly id: string;
+    /**
+     * How a {@link DelegatedDecision} it settled opens, as the working agent reads it. Must not name
+     * the interceptor. Defaults to "Decided on the user's behalf"; an autopilot grounded in a brief
+     * would say "Decided on the user's behalf, from their brief".
+     */
+    readonly decisionFraming?: string;
+    /** Return `'claim'` to hold the interaction, or nothing to leave it with the person. */
+    onInteractionOpened(opened: InteractionOpened): 'claim' | undefined | void;
+}
+//# sourceMappingURL=interaction-interceptor.d.ts.map

package/dist/dts/types/interaction-interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-interceptor.d.ts","sourceRoot":"","sources":["../../../src/types/interaction-interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAC1C;;;;;;;;OAQG;IACH,cAAc,CAAC,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;IAC7E;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,0GAA0G;IAC1G,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACjC,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACrC,oGAAoG;IACpG,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,wFAAwF;IACxF,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;CAC5E"}

package/dist/dts/utils/delegated-message.d.ts

@@ -0,0 +1,52 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+/**
+ * A message written or sent on the user's behalf by a driver decorator (GENC-1660). See
+ * `ChatMessage.delegate`.
+ *
+ * @beta
+ */
+export type DelegatedMessage = ChatMessage & {
+    delegate: string;
+};
+/**
+ * Whether `message` was written or sent on the user's behalf. A delegated message renders as the
+ * assistant, whatever its role.
+ *
+ * @beta
+ */
+export declare const isDelegated: (message: ChatMessage) => message is DelegatedMessage;
+/**
+ * How a delegated `user` message is framed for the model when its sender gives no phrase. Names no
+ * decorator, so the model has none to repeat.
+ *
+ * @beta
+ */
+export declare const DEFAULT_DELEGATE_FRAMING = "Sent on the user's behalf.";
+/**
+ * Options for `AiDriver.sendMessage` (GENC-1660).
+ *
+ * @beta
+ */
+export interface SendMessageOptions {
+    /**
+     * Send the message on the user's behalf, as this decorator (e.g. `'autopilot'`). The platform
+     * stamps it on the stored message as `delegate`, so it renders as the assistant and the model
+     * reads it framed.
+     */
+    delegate?: string;
+    /**
+     * The phrase the model reads in front of a delegated message. Defaults to
+     * {@link DEFAULT_DELEGATE_FRAMING}. Ignored unless `delegate` is set.
+     */
+    delegateFraming?: string;
+}
+/**
+ * A delegated `user` message's content as the model reads it: its framing in brackets, then the
+ * text. The one place this string is built, so the first model call (which takes the message as
+ * its input) and every later call (which reads it from history) send the same bytes and the cache
+ * prefix holds.
+ *
+ * @internal
+ */
+export declare function frameDelegatedContent(content: string, framing: string | undefined): string;
+//# sourceMappingURL=delegated-message.d.ts.map

package/dist/dts/utils/delegated-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegated-message.d.ts","sourceRoot":"","sources":["../../../src/utils/delegated-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,WAAW,KAAG,OAAO,IAAI,gBAC1C,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAE1F"}

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

@@ -1 +1 @@
-{"version":3,"file":"history-transform.d.ts","sourceRoot":"","sources":["../../../src/utils/history-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAEL,KAAK,oBAAoB,EAI1B,MAAM,kBAAkB,CAAC;AAoC1B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAsBjG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAG3F;AAID;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CASvF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,eAAe,GAAE,MAAkC,EACnD,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,IAAI,CAkBf;AAED,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,0CAA0C;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,GAAG,IAAI,CAc7B;AAkCD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,GAAG;IAC/E,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAkBA;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,EAAE,CAanF;AAED,oEAAoE;AACpE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAG7D"}
+{"version":3,"file":"history-transform.d.ts","sourceRoot":"","sources":["../../../src/utils/history-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAEL,KAAK,oBAAoB,EAI1B,MAAM,kBAAkB,CAAC;AAqC1B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAsBjG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAG3F;AAID;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CASvF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,eAAe,GAAE,MAAkC,EACnD,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,IAAI,CAkBf;AAED,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,0CAA0C;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,GAAG,IAAI,CAc7B;AAqCD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,GAAG;IAC/E,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAkBA;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,EAAE,CAkBnF;AAED,oEAAoE;AACpE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAG7D"}

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

@@ -150,6 +150,8 @@ export class AgentSession {
                 transition.flowOwnerChangedTo = agent.name;
             }
             this.active = agent;
+            if (switched)
+                this.reportTransition(transition);
             return transition;
         });
     }
@@ -174,9 +176,24 @@ export class AgentSession {
                 this.flowOwner = null;
                 transition.flowOwnerChangedTo = null;
             }
+            this.reportTransition(transition);
             return transition;
         });
     }
+    /**
+     * Hand a transition to the owner. A throwing listener is logged rather than propagated, for the
+     * same reason a throwing hook is: the transition has already happened, and failing the caller
+     * would leave it believing it had not.
+     */
+    reportTransition(transition) {
+        var _a, _b;
+        try {
+            (_b = (_a = this.deps).onTransition) === null || _b === void 0 ? void 0 : _b.call(_a, transition);
+        }
+        catch (e) {
+            logger.warn(`${WARN_PREFIX}: onTransition threw:`, e);
+        }
+    }
     /**
      * Fire `onDeactivate` on the active agent and abort pending lifecycle work, for session
      * teardown, so machines release resources cleanly. The session is not reusable afterwards: the

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

@@ -1 +1,21 @@
-export {};
+/**
+ * The event types in {@link AiDriverEventMap}, as a runtime list. Built from a record keyed by the
+ * map, so adding an event to the map without adding it here is a compile error.
+ *
+ * @beta
+ */
+export const AI_DRIVER_EVENT_TYPES = Object.keys({
+    'history-updated': true,
+    'sub-agent-history-updated': true,
+    'sub-agent-start': true,
+    'sub-agent-stop': true,
+    'interaction-start': true,
+    'interaction-stop': true,
+    'provider-changed': true,
+    'external-cost-recorded': true,
+    'agent-changed': true,
+    'agent-released': true,
+    'flow-owner-changed': true,
+    'orchestrating-start': true,
+    'orchestrating-stop': true,
+});

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

@@ -0,0 +1,211 @@
+import { AI_DRIVER_EVENT_TYPES, } from './ai-driver';
+/**
+ * The base of every driver decorator (GENC-1660): an {@link AiDriver} that wraps another and
+ * passes every member, and every event in {@link AiDriverEventMap}, through to it.
+ *
+ * A decorator extends this and overrides only what it changes, so decorators stack in any order
+ * and a member or event added to `AiDriver` reaches the host through every layer by default.
+ * `OrchestratingDriver` is one; it used to forward by hand, and twice a member it did not forward
+ * silently did nothing for every multi-agent host (`recordExternalCost`, then
+ * `getHistoryForPersistence`).
+ *
+ * Abstract with no abstract members, so it cannot be constructed on its own: a decorator that
+ * changes nothing is not one.
+ *
+ * Optional `AiDriver` members are implemented here unconditionally, as a forward that falls back
+ * to the "not supported" answer when the inner driver lacks them. A host that feature-detects with
+ * `?.` therefore always finds them, and gets the same answer it would from the inner driver.
+ *
+ * @beta
+ */
+export class BaseDriverDecorator extends EventTarget {
+    constructor(inner) {
+        super();
+        this.inner = inner;
+        /** Undoes this layer's hold on its inner driver; see {@link BaseDriverDecorator.detach}. */
+        this.detachers = [];
+        // Re-dispatch, not re-target: an event belongs to one target, so each layer raises its own
+        // copy with the same detail, as the orchestrator always did.
+        for (const type of AI_DRIVER_EVENT_TYPES) {
+            const forward = (e) => {
+                this.dispatchEvent(new CustomEvent(type, { detail: e.detail }));
+            };
+            inner.addEventListener(type, forward);
+            this.onDetach(() => inner.removeEventListener(type, forward));
+        }
+    }
+    /**
+     * Let go of the inner driver WITHOUT disposing it: stop forwarding its events, and undo whatever
+     * a subclass registered through {@link BaseDriverDecorator.onDetach} (its interceptors, its
+     * capabilities, its own listeners). For dropping or replacing a decorator while the driver it
+     * wrapped lives on — otherwise the old layer keeps re-dispatching every event and is never
+     * collected. Idempotent. `dispose()` detaches too.
+     */
+    detach() {
+        for (const undo of this.detachers.splice(0)) {
+            try {
+                undo();
+            }
+            catch (_a) {
+                // One failed undo must not keep the rest attached.
+            }
+        }
+    }
+    /** Register something {@link BaseDriverDecorator.detach} must undo. */
+    onDetach(undo) {
+        this.detachers.push(undo);
+    }
+    sendMessage(input, attachments, options) {
+        return this.inner.sendMessage(input, attachments, options);
+    }
+    continueFromHistory(transientPrimer, options) {
+        return this.inner.continueFromHistory(transientPrimer, options);
+    }
+    resolveInteraction(interactionId, result) {
+        this.inner.resolveInteraction(interactionId, result);
+    }
+    recordExternalCost(interactionId, costUsd) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).recordExternalCost) === null || _b === void 0 ? void 0 : _b.call(_a, interactionId, costUsd)) !== null && _c !== void 0 ? _c : false;
+    }
+    getInteractionContext(interactionId) {
+        var _a, _b;
+        return (_b = (_a = this.inner).getInteractionContext) === null || _b === void 0 ? void 0 : _b.call(_a, interactionId);
+    }
+    loadHistory(messages) {
+        this.inner.loadHistory(messages);
+    }
+    primeRestoredAgentState(snapshots) {
+        this.inner.primeRestoredAgentState(snapshots);
+    }
+    canRestoreFlowOwner(agentName) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).canRestoreFlowOwner) === null || _b === void 0 ? void 0 : _b.call(_a, agentName)) !== null && _c !== void 0 ? _c : false;
+    }
+    canResumeRestoredFlow(agentName) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).canResumeRestoredFlow) === null || _b === void 0 ? void 0 : _b.call(_a, agentName)) !== null && _c !== void 0 ? _c : false;
+    }
+    resumeRestoredFlow(resumeNote, agent) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).resumeRestoredFlow) === null || _b === void 0 ? void 0 : _b.call(_a, resumeNote, agent)) !== null && _c !== void 0 ? _c : Promise.resolve(undefined);
+    }
+    getRawHistory() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getRawHistory) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+    }
+    getHistoryForPersistence() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getHistoryForPersistence) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [...this.getRawHistory()];
+    }
+    getCondensePoliciesForPersistence(messages) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getCondensePoliciesForPersistence) === null || _b === void 0 ? void 0 : _b.call(_a, messages)) !== null && _c !== void 0 ? _c : [];
+    }
+    restoreCondensePolicies(entries) {
+        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 });
+    }
+    getActiveAgent() {
+        return this.inner.getActiveAgent();
+    }
+    setPinnedAgent(name) {
+        this.inner.setPinnedAgent(name);
+    }
+    setFlowOwner(name) {
+        this.inner.setFlowOwner(name);
+    }
+    getFlowOwner() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getFlowOwner) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null;
+    }
+    /**
+     * Forwarded, so an interceptor installed on any layer lands on the driver that opens the
+     * interactions. A decorator that answers interactions installs its own on `this.inner`.
+     */
+    addInteractionInterceptor(interceptor) {
+        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);
+    }
+    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.')));
+    }
+    provideHandlerCapability(name, factory) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).provideHandlerCapability) === null || _b === void 0 ? void 0 : _b.call(_a, name, factory)) !== null && _c !== void 0 ? _c : (() => undefined);
+    }
+    getContextReserve() {
+        var _a, _b;
+        return (_b = (_a = this.inner).getContextReserve) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    getPreambleTokens() {
+        var _a, _b;
+        return (_b = (_a = this.inner).getPreambleTokens) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    setContextGuard(policy) {
+        var _a, _b;
+        (_b = (_a = this.inner).setContextGuard) === null || _b === void 0 ? void 0 : _b.call(_a, policy);
+    }
+    compact(options) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).compact) === null || _b === void 0 ? void 0 : _b.call(_a, options)) !== null && _c !== void 0 ? _c : Promise.resolve(null);
+    }
+    getCompactionPlan(options) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getCompactionPlan) === null || _b === void 0 ? void 0 : _b.call(_a, options)) !== null && _c !== void 0 ? _c : null;
+    }
+    canCompact(options) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).canCompact) === null || _b === void 0 ? void 0 : _b.call(_a, options)) !== null && _c !== void 0 ? _c : false;
+    }
+    isBusy() {
+        return this.inner.isBusy();
+    }
+    getSuggestions(history, prompt, count, allAgentInfo) {
+        return this.inner.getSuggestions(history, prompt, count, allAgentInfo);
+    }
+    getTurnSnapshots() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getTurnSnapshots) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+    }
+    /**
+     * The inner driver's entries. Diagnostics compose down the stack: a decorator with entries of
+     * its own overrides this and appends them to `super.getExternalDiagnostics()`.
+     */
+    getExternalDiagnostics() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.inner).getExternalDiagnostics) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
+    }
+    getActiveProviderName() {
+        return this.inner.getActiveProviderName();
+    }
+    dispose() {
+        var _a, _b;
+        const disposed = (_b = (_a = this.inner).dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.detach();
+        return disposed;
+    }
+    cancel() {
+        var _a, _b;
+        (_b = (_a = this.inner).cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Every driver in the stack, outermost first: `driver`, then each inner driver down to the one
+     * that is not a decorator.
+     *
+     * For diagnostics and labelling only: behaviour must go through `AiDriver` members, which every
+     * layer forwards, never through a concrete class found here.
+     *
+     * @internal
+     */
+    static layers(driver) {
+        const layers = [driver];
+        let current = driver;
+        while (current instanceof BaseDriverDecorator) {
+            current = current.inner;
+            layers.push(current);
+        }
+        return layers;
+    }
+}

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

@@ -1 +1,2 @@
-export {};
+export { AI_DRIVER_EVENT_TYPES } from './ai-driver';
+export { BaseDriverDecorator } from './base-driver-decorator';