@memberjunction/conversations-runtime 0.0.1 → 5.42.0

package/dist/sessions/SessionsObserver.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Observability surface for AI Agent Sessions & Channels lifecycle.
+ *
+ * `SessionsObserver` is the runtime's framework-agnostic re-broadcaster of
+ * session lifecycle events that originate from PR #2787's Sessions/Channels
+ * infrastructure. It does NOT subscribe directly to any Angular service or
+ * realtime client — those concerns live behind an {@link ISessionsAdapter} the
+ * host registers at bootstrap (typically `RealtimeSessionsAdapter` in
+ * `@memberjunction/ng-conversations`, but anything implementing the contract
+ * works — a React host, a Node test harness, a server-side runner, etc.).
+ *
+ * **What you get on `SessionLifecycle$`:**
+ * - `session-started` — a new realtime session has fully started (sessionId is
+ *   non-null, the realtime client is connected). Adapter implementations are
+ *   responsible for emitting only AFTER all the prerequisites are satisfied
+ *   (e.g., the Angular `RealtimeSessionsAdapter` waits for both `Active$` AND a
+ *   non-null `agentSessionId`).
+ * - `session-channel` — a channel (voice/whiteboard/whatever) opened or closed
+ *   inside the session. The `state` union is intentionally narrow
+ *   (`'open' | 'closed'`) because no per-channel transition observable exists
+ *   today; see `ISessionsAdapter` JSDoc for the rationale.
+ * - `session-ended` — the session ended client-side. `reason` is a narrowed
+ *   union (`'explicit' | 'error' | 'unknown'`) — see `ISessionsAdapter`.
+ *
+ * **What you DON'T get:** server-side close events that fire while the user's
+ * tab is gone (janitor sweep, host shutdown). Those flow into the `MJ: AI Agent
+ * Sessions` row's `CloseReason` column but are not pushed to the client today.
+ * Admin/observability tooling polls the entity for those — out of scope for
+ * the orchestration runtime.
+ *
+ * @module @memberjunction/conversations-runtime
+ */
+import { Observable } from 'rxjs';
+import { ISessionsAdapter, SessionLifecycleEvent } from '../adapters/ISessionsAdapter.js';
+export type { SessionLifecycleEvent, SessionChannelState, SessionEndReason, } from '../adapters/ISessionsAdapter.js';
+/**
+ * Observes Sessions/Channels lifecycle from the registered adapter and
+ * re-broadcasts via `SessionLifecycle$`.
+ *
+ * **Lifecycle:** constructed once by `ConversationsRuntime` (singleton). Stays
+ * subscribed to the adapter's stream until `Dispose()` is called. Adapter swaps
+ * via `UseSessionsAdapter` unsubscribe the prior adapter cleanly.
+ *
+ * Usually accessed via `ConversationsRuntime.Instance.Sessions`.
+ */
+export declare class SessionsObserver {
+    /**
+     * Stream of session lifecycle events from whatever adapter is currently
+     * registered. Subscribers see only events that occur AFTER they subscribe —
+     * `SessionsObserver` does not replay history (use `RealtimeSessionReviewService`
+     * for past-session loading, separate concern).
+     */
+    readonly SessionLifecycle$: Observable<SessionLifecycleEvent>;
+    private readonly _lifecycle$;
+    private _adapter;
+    private _adapterSub;
+    constructor();
+    /**
+     * Register the adapter that produces session events. Replaces any prior
+     * adapter and cleanly tears down the previous subscription. Typically called
+     * once at host bootstrap (e.g., Angular's `ConversationsRuntimeBootstrap`),
+     * but multiple swaps are supported (e.g., test harnesses that switch
+     * adapters between cases).
+     */
+    UseSessionsAdapter(adapter: ISessionsAdapter): void;
+    /**
+     * Whether a non-default adapter is currently registered. Useful for
+     * diagnostics ("are sessions actually wired up on this host?") and for
+     * features that should gate themselves on real wiring.
+     */
+    get IsWired(): boolean;
+    /**
+     * The currently registered adapter. Provided for diagnostics; consumers
+     * should subscribe to `SessionLifecycle$` instead of reaching into the
+     * adapter directly.
+     */
+    get Adapter(): ISessionsAdapter;
+    /**
+     * Tear down the adapter subscription and complete the lifecycle stream.
+     * Safe to call multiple times. After Dispose, subscribers will receive a
+     * `complete` notification on `SessionLifecycle$`.
+     */
+    Dispose(): void;
+    /** Forwards adapter events into our internal Subject. */
+    private subscribeToAdapter;
+}
+//# sourceMappingURL=SessionsObserver.d.ts.map

package/dist/sessions/SessionsObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionsObserver.d.ts","sourceRoot":"","sources":["../../src/sessions/SessionsObserver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,UAAU,EAAyB,MAAM,MAAM,CAAC;AACzD,OAAO,EACH,gBAAgB,EAEhB,qBAAqB,EACxB,MAAM,8BAA8B,CAAC;AAItC,YAAY,EACR,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,GACnB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;GASG;AACH,qBAAa,gBAAgB;IACzB;;;;;OAKG;IACH,SAAgB,iBAAiB,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC;IAErE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwC;IACpE,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,WAAW,CAA6B;;IAShD;;;;;;OAMG;IACI,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAM1D;;;;OAIG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED;;;;OAIG;IACH,IAAW,OAAO,IAAI,gBAAgB,CAErC;IAED;;;;OAIG;IACI,OAAO,IAAI,IAAI;IAMtB,yDAAyD;IACzD,OAAO,CAAC,kBAAkB;CAS7B"}

package/dist/sessions/SessionsObserver.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Observability surface for AI Agent Sessions & Channels lifecycle.
+ *
+ * `SessionsObserver` is the runtime's framework-agnostic re-broadcaster of
+ * session lifecycle events that originate from PR #2787's Sessions/Channels
+ * infrastructure. It does NOT subscribe directly to any Angular service or
+ * realtime client — those concerns live behind an {@link ISessionsAdapter} the
+ * host registers at bootstrap (typically `RealtimeSessionsAdapter` in
+ * `@memberjunction/ng-conversations`, but anything implementing the contract
+ * works — a React host, a Node test harness, a server-side runner, etc.).
+ *
+ * **What you get on `SessionLifecycle$`:**
+ * - `session-started` — a new realtime session has fully started (sessionId is
+ *   non-null, the realtime client is connected). Adapter implementations are
+ *   responsible for emitting only AFTER all the prerequisites are satisfied
+ *   (e.g., the Angular `RealtimeSessionsAdapter` waits for both `Active$` AND a
+ *   non-null `agentSessionId`).
+ * - `session-channel` — a channel (voice/whiteboard/whatever) opened or closed
+ *   inside the session. The `state` union is intentionally narrow
+ *   (`'open' | 'closed'`) because no per-channel transition observable exists
+ *   today; see `ISessionsAdapter` JSDoc for the rationale.
+ * - `session-ended` — the session ended client-side. `reason` is a narrowed
+ *   union (`'explicit' | 'error' | 'unknown'`) — see `ISessionsAdapter`.
+ *
+ * **What you DON'T get:** server-side close events that fire while the user's
+ * tab is gone (janitor sweep, host shutdown). Those flow into the `MJ: AI Agent
+ * Sessions` row's `CloseReason` column but are not pushed to the client today.
+ * Admin/observability tooling polls the entity for those — out of scope for
+ * the orchestration runtime.
+ *
+ * @module @memberjunction/conversations-runtime
+ */
+import { Subject } from 'rxjs';
+import { NoOpSessionsAdapter, } from '../adapters/ISessionsAdapter.js';
+/**
+ * Observes Sessions/Channels lifecycle from the registered adapter and
+ * re-broadcasts via `SessionLifecycle$`.
+ *
+ * **Lifecycle:** constructed once by `ConversationsRuntime` (singleton). Stays
+ * subscribed to the adapter's stream until `Dispose()` is called. Adapter swaps
+ * via `UseSessionsAdapter` unsubscribe the prior adapter cleanly.
+ *
+ * Usually accessed via `ConversationsRuntime.Instance.Sessions`.
+ */
+export class SessionsObserver {
+    constructor() {
+        this._lifecycle$ = new Subject();
+        this._adapterSub = null;
+        this.SessionLifecycle$ = this._lifecycle$.asObservable();
+        // Default to no-op so consumers can subscribe immediately without an adapter.
+        this._adapter = new NoOpSessionsAdapter();
+        this.subscribeToAdapter();
+    }
+    /**
+     * Register the adapter that produces session events. Replaces any prior
+     * adapter and cleanly tears down the previous subscription. Typically called
+     * once at host bootstrap (e.g., Angular's `ConversationsRuntimeBootstrap`),
+     * but multiple swaps are supported (e.g., test harnesses that switch
+     * adapters between cases).
+     */
+    UseSessionsAdapter(adapter) {
+        this._adapterSub?.unsubscribe();
+        this._adapter = adapter;
+        this.subscribeToAdapter();
+    }
+    /**
+     * Whether a non-default adapter is currently registered. Useful for
+     * diagnostics ("are sessions actually wired up on this host?") and for
+     * features that should gate themselves on real wiring.
+     */
+    get IsWired() {
+        return !(this._adapter instanceof NoOpSessionsAdapter);
+    }
+    /**
+     * The currently registered adapter. Provided for diagnostics; consumers
+     * should subscribe to `SessionLifecycle$` instead of reaching into the
+     * adapter directly.
+     */
+    get Adapter() {
+        return this._adapter;
+    }
+    /**
+     * Tear down the adapter subscription and complete the lifecycle stream.
+     * Safe to call multiple times. After Dispose, subscribers will receive a
+     * `complete` notification on `SessionLifecycle$`.
+     */
+    Dispose() {
+        this._adapterSub?.unsubscribe();
+        this._adapterSub = null;
+        this._lifecycle$.complete();
+    }
+    /** Forwards adapter events into our internal Subject. */
+    subscribeToAdapter() {
+        this._adapterSub = this._adapter.SessionLifecycle$.subscribe({
+            next: (event) => this._lifecycle$.next(event),
+            // Don't surface adapter errors to consumers — they're host-specific.
+            // The adapter is responsible for its own resilience; we just keep
+            // our broadcast stream alive for the next adapter swap.
+            error: () => undefined,
+        });
+    }
+}
+//# sourceMappingURL=SessionsObserver.js.map

package/dist/sessions/SessionsObserver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionsObserver.js","sourceRoot":"","sources":["../../src/sessions/SessionsObserver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAc,OAAO,EAAgB,MAAM,MAAM,CAAC;AACzD,OAAO,EAEH,mBAAmB,GAEtB,MAAM,8BAA8B,CAAC;AAUtC;;;;;;;;;GASG;AACH,MAAM,OAAO,gBAAgB;IAazB;QAJiB,gBAAW,GAAG,IAAI,OAAO,EAAyB,CAAC;QAE5D,gBAAW,GAAwB,IAAI,CAAC;QAG5C,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;QACzD,8EAA8E;QAC9E,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC1C,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,OAAyB;QAC/C,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,IAAW,OAAO;QACd,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,YAAY,mBAAmB,CAAC,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACH,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACI,OAAO;QACV,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC;QAChC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAChC,CAAC;IAED,yDAAyD;IACjD,kBAAkB;QACtB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,SAAS,CAAC;YACzD,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;YAC7C,qEAAqE;YACrE,kEAAkE;YAClE,wDAAwD;YACxD,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS;SACzB,CAAC,CAAC;IACP,CAAC;CACJ"}

package/dist/streaming/ConversationStreaming.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Pure-TypeScript streaming layer for conversation progress + completion.
+ *
+ * Ported from `@memberjunction/ng-conversations/src/lib/services/conversation-streaming.service.ts`.
+ * The original was largely framework-agnostic — the `@Injectable()` decorator was the only
+ * Angular dep, and `OnDestroy` was its only Angular lifecycle hook. We strip both, replace
+ * `OnDestroy` with an explicit `Dispose()` method, and route `removeByAgentRunId` calls
+ * through the {@link IActiveTaskTracker} adapter instead of Angular DI.
+ *
+ * Maintains a single PubSub subscription to `GraphQLDataProvider.PushStatusUpdates()` and
+ * routes progress + completion events to registered per-message callbacks. Handles late-
+ * arrival replay (5-min window) so a component that mounts after an agent run finished can
+ * still see the completion.
+ *
+ * @module @memberjunction/conversations-runtime
+ */
+import { Subject } from 'rxjs';
+import { IConversationsRuntimeContext } from '../context/IConversationsRuntimeContext.js';
+/**
+ * Completion event broadcast when an agent finishes. Includes enriched result data from
+ * the server's fire-and-forget completion event.
+ */
+export interface CompletionEvent {
+    conversationDetailId: string;
+    agentRunId: string;
+    /** Whether the agent execution succeeded. */
+    success?: boolean;
+    /** Error message if the agent execution failed. */
+    errorMessage?: string;
+}
+/** Metadata structure for message progress updates. */
+export interface MessageProgressMetadata {
+    /** Progress details (from RunAIAgentResolver). */
+    progress?: {
+        hierarchicalStep?: string;
+        percentage?: number;
+        message?: string;
+        stepCount?: number;
+        agentName?: string;
+        agentType?: string;
+    };
+    /** Agent run information (from RunAIAgentResolver). */
+    agentRun?: {
+        Agent?: string;
+        ConversationDetailID?: string;
+        ID?: string;
+    };
+    /** Agent run ID (alternative to agentRun.ID). */
+    agentRunId?: string;
+}
+/** Single progress update for a message. */
+export interface MessageProgressUpdate {
+    message: string;
+    percentComplete?: number;
+    taskName?: string;
+    conversationDetailId: string;
+    metadata?: MessageProgressMetadata;
+    stepCount?: number;
+    /** Which backend resolver published this update. */
+    resolver?: 'TaskOrchestrator' | 'RunAIAgentResolver' | string;
+}
+/** Callback type for progress updates. */
+export type MessageProgressCallback = (progress: MessageProgressUpdate) => Promise<void> | void;
+/** Connection status for the streaming service. */
+export type StreamingConnectionStatus = 'connected' | 'disconnected' | 'error' | 'reconnecting';
+/**
+ * Global streaming service that manages PubSub subscriptions for all conversations.
+ *
+ * Maintains a single GraphQL subscription and routes updates to registered per-message
+ * callbacks, regardless of which conversation is currently visible. This ensures
+ * messages update correctly even when users navigate away and return.
+ *
+ * Usually accessed via `ConversationsRuntime.Instance.Streaming`.
+ */
+export declare class ConversationStreaming {
+    private readonly context;
+    private pushStatusSubscription?;
+    private readonly callbackRegistry;
+    private readonly recentCompletions;
+    private readonly connectionStatus$;
+    private initialized;
+    private reconnectionTimeout?;
+    /**
+     * Observable for components to subscribe to completion events in real-time.
+     * Emits enriched completion data once per agent finish.
+     */
+    readonly completionEvents$: Subject<CompletionEvent>;
+    /**
+     * @param context Runtime context providing live access to the registered
+     *     {@link IActiveTaskTracker}. Read on every event dispatch so adapter swaps
+     *     after construction are picked up immediately.
+     */
+    constructor(context: IConversationsRuntimeContext);
+    /**
+     * Initialize the global PubSub subscription. Idempotent — safe to call multiple
+     * times. Should be called once at app startup (e.g., the Angular widget calls
+     * this when the workspace mounts).
+     */
+    initialize(): void;
+    /** Current connection status as an observable. */
+    getConnectionStatus$(): import("rxjs").Observable<StreamingConnectionStatus>;
+    /** Current connection status value (synchronous). */
+    getConnectionStatus(): StreamingConnectionStatus;
+    /**
+     * Register a callback for a specific conversation detail (message). The callback
+     * is invoked whenever progress updates arrive for that message.
+     */
+    registerMessageCallback(conversationDetailId: string, callback: MessageProgressCallback): void;
+    /**
+     * Unregister a callback for a specific conversation detail. When `callback` is
+     * omitted, ALL callbacks for that message are removed.
+     */
+    unregisterMessageCallback(conversationDetailId: string, callback?: MessageProgressCallback): void;
+    /** Total number of registered callbacks (diagnostic). */
+    getRegisteredCallbackCount(): number;
+    /** Number of distinct messages currently being tracked (diagnostic). */
+    getTrackedMessageCount(): number;
+    /**
+     * Replay a recently completed event so a late-mounting component can pick it up.
+     * Returns `undefined` if no completion is in the 5-minute replay window.
+     */
+    getRecentCompletion(conversationDetailId: string): {
+        agentRunId: string;
+    } | undefined;
+    /** Clear a recent completion after the late-mounting component has handled it. */
+    clearRecentCompletion(conversationDetailId: string): void;
+    /**
+     * Diagnostic snapshot for a specific message — used by debugging tools to dump
+     * live in-memory state.
+     */
+    getDiagnosticSnapshot(messageId: string): {
+        hasCallbacks: boolean;
+        callbackCount: number;
+        recentCompletion: {
+            conversationDetailId: string;
+            agentRunId: string;
+            timestamp: Date;
+        } | undefined;
+        connectionStatus: StreamingConnectionStatus;
+    };
+    /**
+     * Tear down subscriptions and clear state. Call at app shutdown or in tests
+     * between cases.
+     */
+    Dispose(): void;
+    /**
+     * Route an incoming PubSub status update to the right handler based on which
+     * resolver published it.
+     */
+    private handlePushStatusUpdate;
+    /**
+     * Route a TaskOrchestrator progress update to the message-scoped callback set,
+     * keyed by `conversationDetailId`.
+     */
+    private routeTaskProgress;
+    /**
+     * Route a RunAIAgentResolver progress update. Handles both progress messages and
+     * completion messages (which include enriched result data and trigger the
+     * `completionEvents$` broadcast + active-task cleanup).
+     */
+    private routeAgentProgress;
+    /** Invoke every callback registered for `conversationDetailId`, swallowing per-callback errors. */
+    private dispatchCallbacks;
+    /** Schedule a reconnection attempt after a connection error or completion. */
+    private scheduleReconnection;
+    /** Evict completions older than the replay window to bound memory. */
+    private cleanupOldCompletions;
+}
+//# sourceMappingURL=ConversationStreaming.d.ts.map

package/dist/streaming/ConversationStreaming.d.ts.map

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