@memberjunction/ai-agents 6.2.0-edge.3 → 6.2.0-edge.4

package/dist/realtime/client-only-channel-server.js

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview A generic server half for channels that run entirely in the browser.
+ *
+ * `MJ: AI Agent Channels.ServerPluginClass` is `NOT NULL`: every channel in the registry names a server plugin, even a
+ * channel whose verbs, state and surface all live in the client. Without this class each such channel (an Open App's
+ * form channel, a game, a component host) would hand-write the same empty plugin. A client-only channel instead
+ * points its registry row at this one:
+ *
+ * ```json
+ * { "fields": { "Name": "YourChannel", "ServerPluginClass": "ClientOnlyChannelServer", "ClientPluginClass": "YourChannel", ... } }
+ * ```
+ *
+ * The plugin takes its channel name from the registry row it was resolved for (see {@link ClientOnlyChannelServer.BindChannelName}),
+ * so one registered class serves any number of channels and `RealtimeChannelServerHost` never reports a name mismatch.
+ *
+ * ## What it does
+ *
+ * - Completes the registry pairing, so the channel is discoverable, scoped and killable like every other.
+ * - Contributes **no server tools** (`GetServerToolDefinitions()` is `[]`): every verb executes in the browser.
+ * - Does **not interpret or rewrite** a state-of-record save (`OnChannelStateSave` returns `null`, which the host reads as
+ *   "keep what the client sent").
+ *
+ * ## What it does not do
+ *
+ * - **It does not decide scope.** Whether the channel is in a session at all is resolved by the channel-scoping cascade
+ *   (`channels.include` / `exclude` / the registry's `IsActive` kill switch) BEFORE the host creates any plugin, so there is
+ *   nothing left for a plugin to validate.
+ * - **It does not stop a save.** The host treats a plugin's `null` (and any thrown error) as "persist the original", so a
+ *   server plugin cannot refuse state. Whether anything is persisted is decided by the CLIENT: a channel with no state of
+ *   record (`SerializeState()` returns `null`, so it never requests a save) persists nothing. A channel that does request
+ *   saves, such as an `AngularComponentChannel`, has its state stored on the session's channel row as submitted; if that state
+ *   must not be stored, validate or redact it in a server plugin of your own (return a replacement) or do not save it.
+ * - **It does not authorize anything.** If the channel's verbs call server operations, those operations are the security
+ *   boundary (they run on the session's own principal); a client-only channel adds no door of its own.
+ *
+ * Use a dedicated server plugin instead when the channel needs server tools, a server-side state normalizer, or
+ * session-lifecycle work.
+ *
+ * @module @memberjunction/ai-agents
+ * @author MemberJunction.com
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseRealtimeChannelServer } from '@memberjunction/ai';
+import { RegisterClass } from '@memberjunction/global';
+/** The `ServerPluginClass` key a client-only channel's registry row uses. */
+export const CLIENT_ONLY_CHANNEL_SERVER_KEY = 'ClientOnlyChannelServer';
+/**
+ * Generic server half for a channel that runs entirely in the browser. One instance per realtime session (created by
+ * `RealtimeChannelServerHost` from the channel registry; never construct directly).
+ *
+ * Subclass it only to pin a fixed {@link ChannelName} under a key of your own (as the built-in Interactive Component and
+ * Identity Verification channels do, so their existing registry keys keep resolving); an Open App should simply use the
+ * registered `ClientOnlyChannelServer` key.
+ */
+let ClientOnlyChannelServer = class ClientOnlyChannelServer extends BaseRealtimeChannelServer {
+    constructor() {
+        super(...arguments);
+        this.boundChannelName = null;
+    }
+    /**
+     * The channel this instance serves: the registry row's `Name`, once the host has bound it; `''` before that. A subclass
+     * that pins a fixed name overrides it.
+     */
+    get ChannelName() {
+        return this.boundChannelName ?? '';
+    }
+    /**
+     * Tells the plugin which registry row it was resolved for. Called by `RealtimeChannelServerHost` right after it creates
+     * the instance, so a single registered class can serve any client-only channel.
+     *
+     * @param channelName The registry row's `Name`.
+     */
+    BindChannelName(channelName) {
+        this.boundChannelName = channelName;
+    }
+    /** No server-executed tools: every verb runs in the browser. */
+    GetServerToolDefinitions() {
+        return [];
+    }
+    /**
+     * Does not interpret or rewrite a state save. `null` means "persist what the client submitted" (the host cannot refuse a
+     * save through a plugin; see the file comment).
+     *
+     * @returns `null`.
+     */
+    async OnChannelStateSave() {
+        return null;
+    }
+};
+ClientOnlyChannelServer = __decorate([
+    RegisterClass(BaseRealtimeChannelServer, CLIENT_ONLY_CHANNEL_SERVER_KEY)
+], ClientOnlyChannelServer);
+export { ClientOnlyChannelServer };
+/**
+ * Tree-shaking prevention for {@link ClientOnlyChannelServer}'s `@RegisterClass` registration. Called from a static code
+ * path in the server host (and, for the Interactive Component and Identity Verification plugins, from their own load
+ * functions) so the registration always executes.
+ */
+export function LoadClientOnlyChannelServer() {
+    // no-op: the import + call create a static reference bundlers cannot eliminate
+}
+//# sourceMappingURL=client-only-channel-server.js.map

package/dist/realtime/client-only-channel-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-only-channel-server.js","sourceRoot":"","sources":["../../src/realtime/client-only-channel-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;;;;;;;AAEH,OAAO,EAAE,yBAAyB,EAA0B,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,8BAA8B,GAAG,yBAAyB,CAAC;AAExE;;;;;;;GAOG;AAEI,IAAM,uBAAuB,GAA7B,MAAM,uBAAwB,SAAQ,yBAAyB;IAA/D;;QACK,qBAAgB,GAAkB,IAAI,CAAC;IAkCnD,CAAC;IAhCG;;;OAGG;IACH,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,WAAmB;QACtC,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC;IACxC,CAAC;IAED,gEAAgE;IAChD,wBAAwB;QACpC,OAAO,EAAE,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACa,KAAK,CAAC,kBAAkB;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ,CAAA;AAnCY,uBAAuB;IADnC,aAAa,CAAC,yBAAyB,EAAE,8BAA8B,CAAC;GAC5D,uBAAuB,CAmCnC;;AAED;;;;GAIG;AACH,MAAM,UAAU,2BAA2B;IACvC,+EAA+E;AACnF,CAAC"}

package/dist/realtime/identity-verification-channel-server.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Server-side channel plugin for the **Identity Verification** channel — the generic,
+ * opt-in channel through which a realtime agent helps a person (often an anonymous widget guest) prove
+ * they control an email address without leaving the call.
+ *
+ * Paired with the browser's `IdentityVerificationChannel` client plugin through the seeded
+ * `MJ: AI Agent Channels` row (`Name: 'IdentityVerification'`,
+ * `ServerPluginClass: 'IdentityVerificationChannelServer'`, `ClientPluginClass: 'IdentityVerificationChannel'`).
+ *
+ * **Why the server half is intentionally thin, and validates nothing beyond scope.** The channel's verbs
+ * are executed in the browser, which then calls the verification operations
+ * (`RequestRealtimeSessionVerification`, `SubmitRealtimeSessionVerificationCode`) on the session's own
+ * principal. Those operations — not this plugin — are the security boundary: domain policy, rate limits,
+ * code hashing, expiry and deadline extension all live in the verification service, and the server never
+ * trusts anything the client says about verification state. A server tool here would only be a second,
+ * weaker door to the same room, and a state of record would put an email address (PII) onto the session's
+ * channel row for no benefit — the session's verification state is already stored, hashed where it must
+ * be, on the session itself. So the plugin completes the registry pairing (so the channel is discoverable
+ * and scoped like every other) and contributes no server tools and no persisted state.
+ *
+ * "Scope" is the only thing that applies server-side: whether the channel is in a session at all is decided
+ * by the channel-scoping cascade (`channels.config.IdentityVerification`, opt-in by default) and the
+ * registry's kill switch, both resolved before this plugin is ever created.
+ *
+ * @module @memberjunction/ai-agents
+ * @author MemberJunction.com
+ */
+import { ClientOnlyChannelServer } from './client-only-channel-server.js';
+/** The stable channel name, matching the seeded `MJ: AI Agent Channels` row. */
+export declare const IDENTITY_VERIFICATION_CHANNEL_NAME = "IdentityVerification";
+/**
+ * Server half of the Identity Verification channel. One instance per realtime session (created by
+ * `RealtimeChannelServerHost` from the channel registry; never construct directly).
+ *
+ * A {@link ClientOnlyChannelServer} that pins the channel's name under its own, already-seeded registry key
+ * (`IdentityVerificationChannelServer`), so the existing row keeps resolving. It contributes no server tools and does not
+ * rewrite saves. The channel's state is a name and an email in a form: the client plugin has no state of record (it never
+ * requests a save), so no email address reaches the channel row. A server plugin cannot refuse a save, so that guarantee
+ * rests on the client plugin continuing not to request one.
+ */
+export declare class IdentityVerificationChannelServer extends ClientOnlyChannelServer {
+    /** Matches the seeded `MJ: AI Agent Channels` row's `Name`. */
+    get ChannelName(): string;
+}
+/**
+ * Tree-shaking prevention for {@link IdentityVerificationChannelServer}'s `@RegisterClass` registration.
+ * Called from a static code path in the server host so the registration always executes.
+ */
+export declare function LoadIdentityVerificationChannelServer(): void;
+//# sourceMappingURL=identity-verification-channel-server.d.ts.map

package/dist/realtime/identity-verification-channel-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-verification-channel-server.d.ts","sourceRoot":"","sources":["../../src/realtime/identity-verification-channel-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAAE,uBAAuB,EAA+B,MAAM,8BAA8B,CAAC;AAEpG,gFAAgF;AAChF,eAAO,MAAM,kCAAkC,yBAAyB,CAAC;AAEzE;;;;;;;;;GASG;AACH,qBACa,iCAAkC,SAAQ,uBAAuB;IAC1E,+DAA+D;IAC/D,IAAoB,WAAW,IAAI,MAAM,CAExC;CACJ;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D"}

package/dist/realtime/identity-verification-channel-server.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Server-side channel plugin for the **Identity Verification** channel — the generic,
+ * opt-in channel through which a realtime agent helps a person (often an anonymous widget guest) prove
+ * they control an email address without leaving the call.
+ *
+ * Paired with the browser's `IdentityVerificationChannel` client plugin through the seeded
+ * `MJ: AI Agent Channels` row (`Name: 'IdentityVerification'`,
+ * `ServerPluginClass: 'IdentityVerificationChannelServer'`, `ClientPluginClass: 'IdentityVerificationChannel'`).
+ *
+ * **Why the server half is intentionally thin, and validates nothing beyond scope.** The channel's verbs
+ * are executed in the browser, which then calls the verification operations
+ * (`RequestRealtimeSessionVerification`, `SubmitRealtimeSessionVerificationCode`) on the session's own
+ * principal. Those operations — not this plugin — are the security boundary: domain policy, rate limits,
+ * code hashing, expiry and deadline extension all live in the verification service, and the server never
+ * trusts anything the client says about verification state. A server tool here would only be a second,
+ * weaker door to the same room, and a state of record would put an email address (PII) onto the session's
+ * channel row for no benefit — the session's verification state is already stored, hashed where it must
+ * be, on the session itself. So the plugin completes the registry pairing (so the channel is discoverable
+ * and scoped like every other) and contributes no server tools and no persisted state.
+ *
+ * "Scope" is the only thing that applies server-side: whether the channel is in a session at all is decided
+ * by the channel-scoping cascade (`channels.config.IdentityVerification`, opt-in by default) and the
+ * registry's kill switch, both resolved before this plugin is ever created.
+ *
+ * @module @memberjunction/ai-agents
+ * @author MemberJunction.com
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseRealtimeChannelServer } from '@memberjunction/ai';
+import { RegisterClass } from '@memberjunction/global';
+import { ClientOnlyChannelServer, LoadClientOnlyChannelServer } from './client-only-channel-server.js';
+/** The stable channel name, matching the seeded `MJ: AI Agent Channels` row. */
+export const IDENTITY_VERIFICATION_CHANNEL_NAME = 'IdentityVerification';
+/**
+ * Server half of the Identity Verification channel. One instance per realtime session (created by
+ * `RealtimeChannelServerHost` from the channel registry; never construct directly).
+ *
+ * A {@link ClientOnlyChannelServer} that pins the channel's name under its own, already-seeded registry key
+ * (`IdentityVerificationChannelServer`), so the existing row keeps resolving. It contributes no server tools and does not
+ * rewrite saves. The channel's state is a name and an email in a form: the client plugin has no state of record (it never
+ * requests a save), so no email address reaches the channel row. A server plugin cannot refuse a save, so that guarantee
+ * rests on the client plugin continuing not to request one.
+ */
+let IdentityVerificationChannelServer = class IdentityVerificationChannelServer extends ClientOnlyChannelServer {
+    /** Matches the seeded `MJ: AI Agent Channels` row's `Name`. */
+    get ChannelName() {
+        return IDENTITY_VERIFICATION_CHANNEL_NAME;
+    }
+};
+IdentityVerificationChannelServer = __decorate([
+    RegisterClass(BaseRealtimeChannelServer, 'IdentityVerificationChannelServer')
+], IdentityVerificationChannelServer);
+export { IdentityVerificationChannelServer };
+/**
+ * Tree-shaking prevention for {@link IdentityVerificationChannelServer}'s `@RegisterClass` registration.
+ * Called from a static code path in the server host so the registration always executes.
+ */
+export function LoadIdentityVerificationChannelServer() {
+    LoadClientOnlyChannelServer();
+}
+//# sourceMappingURL=identity-verification-channel-server.js.map

package/dist/realtime/identity-verification-channel-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-verification-channel-server.js","sourceRoot":"","sources":["../../src/realtime/identity-verification-channel-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;;;;;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAEpG,gFAAgF;AAChF,MAAM,CAAC,MAAM,kCAAkC,GAAG,sBAAsB,CAAC;AAEzE;;;;;;;;;GASG;AAEI,IAAM,iCAAiC,GAAvC,MAAM,iCAAkC,SAAQ,uBAAuB;IAC1E,+DAA+D;IAC/D,IAAoB,WAAW;QAC3B,OAAO,kCAAkC,CAAC;IAC9C,CAAC;CACJ,CAAA;AALY,iCAAiC;IAD7C,aAAa,CAAC,yBAAyB,EAAE,mCAAmC,CAAC;GACjE,iCAAiC,CAK7C;;AAED;;;GAGG;AACH,MAAM,UAAU,qCAAqC;IACjD,2BAA2B,EAAE,CAAC;AAClC,CAAC"}

package/dist/realtime/interactive-component-channel-server.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Server-side channel plugin for the **Interactive Component** channel, the one that shows the user
+ * any component artifact next to the call and lets the agent operate it.
+ *
+ * Paired with the browser's `RealtimeInteractiveComponentChannel` client plugin through the
+ * `MJ: AI Agent Channels` row `Name: 'InteractiveComponent'`
+ * (`ServerPluginClass: 'InteractiveComponentChannelServer'`, `ClientPluginClass: 'RealtimeInteractiveComponentChannel'`).
+ *
+ * **Why the server half is intentionally thin.** The channel's work happens where the component runs, in the
+ * browser: the client plugin loads the artifact through the signed-in user's own session, renders it, derives the
+ * agent's actions from the component's spec and drives it. Its contract is not known until a component is open,
+ * so there is nothing to declare to the model as a native server tool; every action reaches the browser through
+ * the stable `ContextTool` proxy. The server half exists to complete the channel registry pairing (so the channel
+ * is discoverable and loadable like every other) and to say, explicitly, that it holds nothing: no server tools and
+ * no state of record. Open components are live-only and are not restored when a session resumes.
+ *
+ * @module @memberjunction/ai-agents
+ */
+import { ClientOnlyChannelServer } from './client-only-channel-server.js';
+/** The stable channel name, matching the `MJ: AI Agent Channels` row. */
+export declare const INTERACTIVE_COMPONENT_CHANNEL_NAME = "InteractiveComponent";
+/**
+ * Server half of the Interactive Component channel. One instance per realtime session (created by
+ * `RealtimeChannelServerHost` from the channel registry; never construct directly).
+ *
+ * A {@link ClientOnlyChannelServer} that pins the channel's name under its own, already-seeded registry key
+ * (`InteractiveComponentChannelServer`), so the existing row keeps resolving. It contributes no server tools and does not
+ * rewrite saves; the client plugin is live-only (`SerializeState()` returns `null`), so nothing is ever persisted.
+ */
+export declare class InteractiveComponentChannelServer extends ClientOnlyChannelServer {
+    /** Matches the `MJ: AI Agent Channels` row's `Name`. */
+    get ChannelName(): string;
+}
+/**
+ * Tree-shaking prevention for {@link InteractiveComponentChannelServer}'s `@RegisterClass` registration. Called from a
+ * static code path in the server host so the registration always executes.
+ */
+export declare function LoadInteractiveComponentChannelServer(): void;
+//# sourceMappingURL=interactive-component-channel-server.d.ts.map

package/dist/realtime/interactive-component-channel-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-component-channel-server.d.ts","sourceRoot":"","sources":["../../src/realtime/interactive-component-channel-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAAE,uBAAuB,EAA+B,MAAM,8BAA8B,CAAC;AAEpG,yEAAyE;AACzE,eAAO,MAAM,kCAAkC,yBAAyB,CAAC;AAEzE;;;;;;;GAOG;AACH,qBACa,iCAAkC,SAAQ,uBAAuB;IAC1E,wDAAwD;IACxD,IAAoB,WAAW,IAAI,MAAM,CAExC;CACJ;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D"}

package/dist/realtime/interactive-component-channel-server.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Server-side channel plugin for the **Interactive Component** channel, the one that shows the user
+ * any component artifact next to the call and lets the agent operate it.
+ *
+ * Paired with the browser's `RealtimeInteractiveComponentChannel` client plugin through the
+ * `MJ: AI Agent Channels` row `Name: 'InteractiveComponent'`
+ * (`ServerPluginClass: 'InteractiveComponentChannelServer'`, `ClientPluginClass: 'RealtimeInteractiveComponentChannel'`).
+ *
+ * **Why the server half is intentionally thin.** The channel's work happens where the component runs, in the
+ * browser: the client plugin loads the artifact through the signed-in user's own session, renders it, derives the
+ * agent's actions from the component's spec and drives it. Its contract is not known until a component is open,
+ * so there is nothing to declare to the model as a native server tool; every action reaches the browser through
+ * the stable `ContextTool` proxy. The server half exists to complete the channel registry pairing (so the channel
+ * is discoverable and loadable like every other) and to say, explicitly, that it holds nothing: no server tools and
+ * no state of record. Open components are live-only and are not restored when a session resumes.
+ *
+ * @module @memberjunction/ai-agents
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseRealtimeChannelServer } from '@memberjunction/ai';
+import { RegisterClass } from '@memberjunction/global';
+import { ClientOnlyChannelServer, LoadClientOnlyChannelServer } from './client-only-channel-server.js';
+/** The stable channel name, matching the `MJ: AI Agent Channels` row. */
+export const INTERACTIVE_COMPONENT_CHANNEL_NAME = 'InteractiveComponent';
+/**
+ * Server half of the Interactive Component channel. One instance per realtime session (created by
+ * `RealtimeChannelServerHost` from the channel registry; never construct directly).
+ *
+ * A {@link ClientOnlyChannelServer} that pins the channel's name under its own, already-seeded registry key
+ * (`InteractiveComponentChannelServer`), so the existing row keeps resolving. It contributes no server tools and does not
+ * rewrite saves; the client plugin is live-only (`SerializeState()` returns `null`), so nothing is ever persisted.
+ */
+let InteractiveComponentChannelServer = class InteractiveComponentChannelServer extends ClientOnlyChannelServer {
+    /** Matches the `MJ: AI Agent Channels` row's `Name`. */
+    get ChannelName() {
+        return INTERACTIVE_COMPONENT_CHANNEL_NAME;
+    }
+};
+InteractiveComponentChannelServer = __decorate([
+    RegisterClass(BaseRealtimeChannelServer, 'InteractiveComponentChannelServer')
+], InteractiveComponentChannelServer);
+export { InteractiveComponentChannelServer };
+/**
+ * Tree-shaking prevention for {@link InteractiveComponentChannelServer}'s `@RegisterClass` registration. Called from a
+ * static code path in the server host so the registration always executes.
+ */
+export function LoadInteractiveComponentChannelServer() {
+    LoadClientOnlyChannelServer();
+}
+//# sourceMappingURL=interactive-component-channel-server.js.map

package/dist/realtime/interactive-component-channel-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-component-channel-server.js","sourceRoot":"","sources":["../../src/realtime/interactive-component-channel-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;;;;;;;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAEpG,yEAAyE;AACzE,MAAM,CAAC,MAAM,kCAAkC,GAAG,sBAAsB,CAAC;AAEzE;;;;;;;GAOG;AAEI,IAAM,iCAAiC,GAAvC,MAAM,iCAAkC,SAAQ,uBAAuB;IAC1E,wDAAwD;IACxD,IAAoB,WAAW;QAC3B,OAAO,kCAAkC,CAAC;IAC9C,CAAC;CACJ,CAAA;AALY,iCAAiC;IAD7C,aAAa,CAAC,yBAAyB,EAAE,mCAAmC,CAAC;GACjE,iCAAiC,CAK7C;;AAED;;;GAGG;AACH,MAAM,UAAU,qCAAqC;IACjD,2BAA2B,EAAE,CAAC;AAClC,CAAC"}

package/dist/realtime/realtime-avatar-resolution.d.ts

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Which live avatar, if any, a realtime session asks for, and the voice that goes with it.
+ *
+ * A persona is a voice and a face: its Audio binding on a vendor is a voice, its Video binding an avatar. A session asks
+ * for an avatar when the voiced agent's video setting is on (`realtime.video.enabled`), the model's Video/Output row
+ * doesn't turn video off (`IsSupported` false: reason `endpoint`), and a face resolves:
+ * 1. `realtime.video.avatarId`, accepted only when it names an Active Video binding the model supports on the vendor;
+ * 2. else the voiced (target) agent's personas, default first, the first with a face;
+ * 3. else the co-agent's personas, the same way;
+ * 4. else none. The model's own first persona is never used: an agent with no persona gets no face.
+ *
+ * A call's avatar pick (the runtime override's `realtime.video.avatarId`) can't turn the video setting on: with the
+ * setting off the session asks for none, and says why (reason `video-off`), since the pick asked for one.
+ *
+ * Where the session runs can rule the avatar out before any of that: nobody sees an avatar on a phone call (reason
+ * `phone`), or in an app that shows no agent video (reason `host`: the app said so at mint), so such a session asks for
+ * none ({@link WithoutUnseenAvatar}) and keeps only the persona's voice.
+ *
+ * Whether the session can render the avatar is otherwise the driver's call (its endpoint profile); this only decides
+ * which one to ask for. Once the driver has minted the session, {@link ResolveRealtimeAvatarStatus} merges the two into
+ * the status the call gets, so a call that shows no avatar can say why. A server-side session gets its status from
+ * {@link ResolveBridgedAvatarStatus}, so a meeting can say why too, including when the prep asked its driver for none
+ * and when its driver renders no avatar and ignored the request.
+ *
+ * @module @memberjunction/ai-agents
+ */
+import type { RealtimeAvatarSettings, RealtimeAvatarStatus, RealtimeAvatarUnavailableReason } from '@memberjunction/ai';
+import type { ResolvedAgentPersona, ResolvedModelPersona } from '@memberjunction/ai-engine-base';
+import type { RealtimeCoAgentConfig } from './realtime-coagent-config.js';
+import type { RealtimeVideoOutputRow } from './realtime-video-output-gate.js';
+/** The persona lookups the resolution needs: `AIEngine` provides them; tests pass a fake. */
+export interface RealtimeAvatarPersonaSource {
+    GetModelPersonas(modelId: string, modalityName?: string, vendorId?: string): ResolvedModelPersona[];
+    GetAgentPersonas(agentId: string): ResolvedAgentPersona[];
+}
+/** What the session needs to know to resolve its avatar. */
+export interface RealtimeAvatarResolutionInput {
+    /** The session's effective realtime configuration. */
+    EffectiveConfig: RealtimeCoAgentConfig | null | undefined;
+    /** The voiced (target) agent, when there is one. */
+    TargetAgentID?: string | null;
+    /** The co-agent voicing it. */
+    CoAgentID: string;
+    /** The resolved realtime model. */
+    ModelID: string;
+    /** The AI vendor serving it. Bindings on other vendors don't count. */
+    VendorID?: string | null;
+    /**
+     * The model's Video/Output row (`ReadRealtimeVideoOutputRow`). `'unsupported'` turns video off: no avatar, reason
+     * `endpoint`. `'supported'`, `'unstated'` or absent leave it to the driver's endpoint profile at the mint.
+     */
+    VideoOutputRow?: RealtimeVideoOutputRow;
+    /**
+     * Whether the call picked an avatar (its runtime override names `realtime.video.avatarId`). With the agent's video
+     * setting off, the pick is dropped with reason `video-off`; absent or `false`, the session asks for nothing then.
+     */
+    AvatarPicked?: boolean;
+}
+/**
+ * Why nobody would see an avatar in a session, whatever its model renders: `'phone'`, a phone call; `'host'`, an app that
+ * shows no agent video. Such a session asks the model for none.
+ */
+export type RealtimeAvatarUnseenReason = Extract<RealtimeAvatarUnavailableReason, 'phone' | 'host'>;
+/** Which avatar to ask for, and its persona's voice; or why there is none. */
+export interface RealtimeAvatarResolution {
+    /**
+     * The avatar to ask for. Absent when the video setting is off, the model's row turns video off, no face resolves, or
+     * nobody in the session would see it.
+     */
+    Avatar?: RealtimeAvatarSettings;
+    /**
+     * The avatar persona's voice on the same vendor, when it has one. Kept when nobody would see the avatar, so the agent
+     * sounds the same on a phone call, or in an app without agent video, as in a call that shows its face.
+     */
+    Voice?: string;
+    /**
+     * Why there is no avatar although the video setting is on or the call picked one: nobody in the session would see it
+     * (`phone`, `host`), the call picked one and the agent's video setting is off (`video-off`), the model's Video/Output
+     * row turns video off (`endpoint`), the requested avatar is not a face the model has on the vendor (`unknown-avatar`),
+     * or no persona has one (`no-binding`).
+     */
+    Reason?: RealtimeAvatarUnseenReason | Extract<RealtimeAvatarUnavailableReason, 'video-off' | 'endpoint' | 'unknown-avatar' | 'no-binding'>;
+}
+/** What says, before any model is asked, whether anyone in a session could see an avatar. */
+export interface RealtimeAvatarViewers {
+    /** `true` when the session is a phone call: the caller hears the agent and sees no video. */
+    PhoneCall?: boolean;
+    /**
+     * `false` when the app showing the call shows no agent video (none of its channels shows it). Absent or `true`: it
+     * may show it.
+     */
+    ShowsAgentVideo?: boolean;
+}
+/**
+ * Why nobody would see an avatar in a session, whatever its model renders, or `undefined` when someone could. A phone
+ * call says `phone` whatever app relays it.
+ *
+ * @param viewers What the session says about who is on the other end.
+ */
+export declare function ResolveAvatarUnseenReason(viewers: RealtimeAvatarViewers): RealtimeAvatarUnseenReason | undefined;
+/** What says whether a session could show an avatar at all: who is on the other end, and where the session runs. */
+export interface RealtimeAvatarSessionShape extends RealtimeAvatarViewers {
+    /** `true` for a server-side (bridged or agent-run) session; absent for a browser session. */
+    ServerSide?: boolean;
+    /** `'room'` when the session's host publishes the avatar into a room. */
+    AvatarDelivery?: 'room';
+}
+/**
+ * Whether a session could show an avatar at all: a browser session whose app may show agent video, or a server-side
+ * one whose host publishes the avatar into a room. A phone call or an app without agent video
+ * ({@link ResolveAvatarUnseenReason}), or a server-side session whose host can't publish video, can't.
+ *
+ * @param session What the session says about its viewers and where it runs.
+ */
+export declare function RealtimeSessionCanShowAvatar(session: RealtimeAvatarSessionShape): boolean;
+/**
+ * A resolution without its avatar request when nobody in the session would see the avatar
+ * ({@link ResolveAvatarUnseenReason}), so the driver is never asked to render video that nobody sees. The reason replaces
+ * any other, since no model or face could change it; the persona's voice stays. A resolution that asked for nothing
+ * (the video setting is off) stays as it is, so the call gets no notice.
+ *
+ * @param resolution The session's avatar resolution.
+ * @param viewers What the session says about who is on the other end.
+ */
+export declare function WithoutUnseenAvatar(resolution: RealtimeAvatarResolution, viewers: RealtimeAvatarViewers): RealtimeAvatarResolution;
+/** What a server-side (bridged) session's avatar status is made from, once its driver has opened it. */
+export interface RealtimeBridgedAvatarStatusInput {
+    /** The session's avatar resolution (`RealtimeSessionParamsPrep.AvatarResolution`); absent when the prep made none. */
+    Resolution: RealtimeAvatarResolution | undefined;
+    /**
+     * Whether the session's host publishes the avatar into a room (`PrepareClientSessionInput.AvatarDelivery` `'room'`).
+     * Without it nothing on the server shows an avatar.
+     */
+    RoomDelivery: boolean;
+    /**
+     * Whether the session's model shows avatars (`RealtimeModelShowsAvatar`: its Video/Output row and its driver's
+     * endpoint). Asked only in a session whose host publishes the avatar, when the driver had nothing to report: the prep
+     * asked it for no avatar for a reason other than who would see it, or asked it for one and it reported nothing.
+     */
+    ModelShowsAvatar: () => boolean;
+    /** What the driver reported when it opened the session (`IRealtimeSession.AvatarStatus`). */
+    DriverStatus: RealtimeAvatarStatus | undefined;
+}
+/**
+ * The avatar status a server-side (bridged) session reports, which its host shows (the LiveKit room puts it on the
+ * agent's bot as `mj.agentAvatar`). A status the driver reported about the avatar it was asked for stands: the driver
+ * decided. A session whose prep asked for none because the video setting is off keeps the driver's status (none).
+ * Otherwise the driver had nothing to report, because the prep asked it for no avatar for a reason, or because it renders
+ * no avatar and ignored the request, so the status says why, asked for and not granted:
+ * 1. `phone` (or `host`): nobody would see the avatar, whatever renders it; or `video-off`: the agent's video setting
+ *    dropped the call's pick;
+ * 2. `bridged` when the host publishes no avatar into a room, which is what a driver asked there says (the LiveKit room
+ *    then names its own reason, such as `decoder-missing`);
+ * 3. `endpoint` when the model shows no avatar, as a browser call says ({@link ResolveRealtimeAvatarStatus});
+ * 4. else the prep's reason: `endpoint` (the model's Video/Output row), `unknown-avatar` or `no-binding`. A driver that
+ *    was asked for the avatar on a model that shows avatars and reported nothing gives no reason, so there is no status.
+ *
+ * @param input The resolution, whether the host publishes the avatar, the model's capability and the driver's status.
+ * @returns The status for the session; `undefined` when the session asked for no avatar, or its driver reported nothing
+ *   about one on a model that shows avatars.
+ */
+export declare function ResolveBridgedAvatarStatus(input: RealtimeBridgedAvatarStatusInput): RealtimeAvatarStatus | undefined;
+/**
+ * Resolves the avatar a session asks for (see the file header for the order).
+ *
+ * @param input The session's configuration, agents, model and vendor.
+ * @param personas The persona lookups (`AIEngine.Instance`).
+ */
+export declare function ResolveRealtimeAvatar(input: RealtimeAvatarResolutionInput, personas: RealtimeAvatarPersonaSource): RealtimeAvatarResolution;
+/** What a session's avatar status is made from, once the driver has minted it. */
+export interface RealtimeAvatarStatusInput {
+    /** The session's avatar resolution: an avatar, a reason there is none, or neither when the agent asked for none. */
+    Resolution: RealtimeAvatarResolution;
+    /**
+     * Whether the resolved model shows avatars (`RealtimeModelShowsAvatar`): its Video/Output row allows video or it has
+     * none, and its driver renders avatars on its endpoint (`BaseRealtimeModel.SupportsAvatarOutput`).
+     */
+    ModelSupportsAvatarOutput: boolean;
+    /** The driver's decision at mint (`ClientRealtimeSessionConfig.AvatarStatus`), when it reported one. */
+    DriverStatus?: RealtimeAvatarStatus;
+}
+/**
+ * The status a call gets about the avatar its agent asked for. Nothing when the agent asked for none (its video
+ * setting is off, and the call picked none). Otherwise audio only when nobody in the session would see it
+ * ({@link RealtimeAvatarUnseenReason}) or the agent's video setting dropped the call's pick (`video-off`), whatever the
+ * model renders; then `endpoint` when the model shows no avatar (its Video/Output row turns video off, or it
+ * renders none on its endpoint), whatever driver serves it; then the resolution's reason (`unknown-avatar`,
+ * `no-binding`); else the driver's own decision (granted, or `custom-disabled` and the like).
+ *
+ * @param input The resolution, the model's capability and the driver's decision.
+ * @returns The status for the call, or `undefined` when the session asked for no avatar or the driver reported none.
+ */
+export declare function ResolveRealtimeAvatarStatus(input: RealtimeAvatarStatusInput): RealtimeAvatarStatus | undefined;
+//# sourceMappingURL=realtime-avatar-resolution.d.ts.map

package/dist/realtime/realtime-avatar-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime-avatar-resolution.d.ts","sourceRoot":"","sources":["../../src/realtime/realtime-avatar-resolution.ts"],"names":[],"mappings":"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"}