@pellux/goodvibes-transport-realtime 0.18.3 → 0.30.1

package/README.md

@@ -1,24 +1,20 @@
 # @pellux/goodvibes-transport-realtime
 
-Realtime event-domain connectors for GoodVibes SSE and WebSocket integrations.
+Internal workspace package backing `@pellux/goodvibes-sdk/transport-realtime`.
 
-Install:
+Consumers should install `@pellux/goodvibes-sdk` and import this surface from the umbrella package.
 
-```bash
-npm install @pellux/goodvibes-transport-realtime
-```
-
-Example:
+Consumer import:
 
 ```ts
 import {
   createEventSourceConnector,
   createRemoteRuntimeEvents,
-} from '@pellux/goodvibes-transport-realtime';
+} from '@pellux/goodvibes-sdk/transport-realtime';
 
 const events = createRemoteRuntimeEvents(
   createEventSourceConnector('https://goodvibes.example.com', 'token', fetch),
 );
 ```
 
-Use this package when you want runtime-event subscriptions without pulling in the full umbrella SDK.
+Use this surface when you want runtime-event subscriptions without pulling in the full umbrella SDK.

package/dist/domain-events.d.ts

@@ -13,6 +13,35 @@ export interface SerializedEventEnvelope<TEvent extends EventLike = EventLike> {
 }
 export type DomainEventConnector<TDomain extends string, TEvent extends EventLike = EventLike> = (domain: TDomain, onEnvelope: (envelope: SerializedEventEnvelope<TEvent>) => void) => void | Promise<() => void>;
 export type DomainEvents<TDomain extends string, TEvent extends EventLike = EventLike> = RuntimeEventFeeds<TDomain, TEvent>;
-export declare function createRemoteDomainEvents<TDomain extends string, TEvent extends EventLike = EventLike>(domains: readonly TDomain[], connect: DomainEventConnector<TDomain, TEvent>): DomainEvents<TDomain, TEvent>;
+export interface RemoteDomainEventsOptions<TDomain extends string = string> {
+    readonly onConnectionError?: (error: Error, domain: TDomain) => void;
+}
+export declare function createRemoteDomainEvents<TDomain extends string, TEvent extends EventLike = EventLike>(domains: readonly TDomain[], connect: DomainEventConnector<TDomain, TEvent>, options?: RemoteDomainEventsOptions<TDomain>): DomainEvents<TDomain, TEvent>;
+/**
+ * Returns a filtered view of the given domain events object where every
+ * callback only fires for events whose envelope `sessionId` equals the
+ * supplied value.
+ *
+ * All domain feeds and the `domain()` accessor are pre-filtered. The
+ * `domains` list is preserved unchanged.
+ *
+ * Unsubscribe handles returned by the filtered feeds propagate correctly
+ * to the underlying connection.
+ *
+ * @example
+ * const events = sdk.realtime.viaSse();
+ * // Without forSession — manual filter:
+ * events.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   if (e.sessionId !== mySessionId) return;
+ *   process.stdout.write(e.payload.content);
+ * });
+ *
+ * // With forSession — no filter needed:
+ * const sessionEvents = forSession(events, mySessionId);
+ * sessionEvents.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   process.stdout.write(e.payload.content);
+ * });
+ */
+export declare function forSession<TDomain extends string, TEvent extends EventLike = EventLike>(events: DomainEvents<TDomain, TEvent>, sessionId: string): DomainEvents<TDomain, TEvent>;
 export {};
 //# sourceMappingURL=domain-events.d.ts.map

package/dist/domain-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"domain-events.d.ts","sourceRoot":"","sources":["../src/domain-events.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAE1H,KAAK,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,WAAW,uBAAuB,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,CAC9B,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,CACF,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,CAAC,MAAM,CAAC,KAAK,IAAI,KAC5D,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;AAEhC,MAAM,MAAM,YAAY,CACtB,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AAmIvC,wBAAgB,wBAAwB,CACtC,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,EAEpC,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,OAAO,EAAE,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,GAC7C,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAK/B"}
+{"version":3,"file":"domain-events.d.ts","sourceRoot":"","sources":["../src/domain-events.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,kCAAkC,CAAC;AAE1C,KAAK,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,WAAW,uBAAuB,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,CAC9B,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,CACF,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,CAAC,MAAM,CAAC,KAAK,IAAI,KAC5D,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;AAEhC,MAAM,MAAM,YAAY,CACtB,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,IAClC,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AAEvC,MAAM,WAAW,yBAAyB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM;IACxE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACtE;AAyID,wBAAgB,wBAAwB,CACtC,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,EAEpC,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,OAAO,EAAE,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,EAC9C,OAAO,GAAE,yBAAyB,CAAC,OAAO,CAAM,GAC/C,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAK/B;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CACxB,OAAO,SAAS,MAAM,EACtB,MAAM,SAAS,SAAS,GAAG,SAAS,EAEpC,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EACrC,SAAS,EAAE,MAAM,GAChB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAY/B"}

package/dist/domain-events.js

@@ -1,4 +1,4 @@
-import { createRuntimeEventFeeds } from '@pellux/goodvibes-transport-core';
+import { createRuntimeEventFeeds, isAbortError, transportErrorFromUnknown, } from '@pellux/goodvibes-transport-core';
 function addListener(map, type, listener) {
     const listeners = map.get(type) ?? new Set();
     listeners.add(listener);
@@ -20,11 +20,14 @@ function hasAnyListener(map) {
     }
     return false;
 }
-function isExpectedDisconnectError(error) {
-    return (error instanceof DOMException && error.name === 'AbortError') || (typeof error === 'object'
-        && error !== null
-        && 'name' in error
-        && error.name === 'AbortError');
+const isExpectedDisconnectError = isAbortError;
+function normalizeConnectionError(error, domain) {
+    return error instanceof Error
+        ? error
+        : transportErrorFromUnknown(error, `Remote domain event connection for "${domain}" failed`);
+}
+function reportUnexpectedConnectionError(error, domain, options) {
+    options.onConnectionError?.(normalizeConnectionError(error, domain), domain);
 }
 function toEventEnvelope(envelope) {
     return {
@@ -40,7 +43,7 @@ function toEventEnvelope(envelope) {
         payload: envelope.payload,
     };
 }
-function createRemoteDomainEventFeed(domain, connect) {
+function createRemoteDomainEventFeed(domain, connect, options) {
     const payloadListeners = new Map();
     const envelopeListeners = new Map();
     let disconnect = null;
@@ -73,7 +76,7 @@ function createRemoteDomainEventFeed(domain, connect) {
             disconnect = cleanup;
         }).catch((error) => {
             if (!isExpectedDisconnectError(error)) {
-                throw error;
+                reportUnexpectedConnectionError(error, domain, options);
             }
         }).finally(() => {
             connectPromise = null;
@@ -111,6 +114,69 @@ function createRemoteDomainEventFeed(domain, connect) {
         },
     };
 }
-export function createRemoteDomainEvents(domains, connect) {
-    return createRuntimeEventFeeds(domains, (domain) => createRemoteDomainEventFeed(domain, connect));
+export function createRemoteDomainEvents(domains, connect, options = {}) {
+    return createRuntimeEventFeeds(domains, (domain) => createRemoteDomainEventFeed(domain, connect, options));
+}
+/**
+ * Wraps an existing {@link RuntimeEventFeed} and returns a filtered feed whose
+ * callbacks only fire for envelopes whose `sessionId` matches the given value.
+ *
+ * Unsubscribe handles returned by `on` / `onEnvelope` on the filtered feed
+ * correctly remove the underlying listener from the original feed.
+ */
+function createFilteredFeed(feed, sessionId) {
+    return {
+        on(type, listener) {
+            return feed.onEnvelope(type, (envelope) => {
+                if (envelope.sessionId !== sessionId)
+                    return;
+                listener(envelope.payload);
+            });
+        },
+        onEnvelope(type, listener) {
+            return feed.onEnvelope(type, (envelope) => {
+                if (envelope.sessionId !== sessionId)
+                    return;
+                listener(envelope);
+            });
+        },
+    };
+}
+/**
+ * Returns a filtered view of the given domain events object where every
+ * callback only fires for events whose envelope `sessionId` equals the
+ * supplied value.
+ *
+ * All domain feeds and the `domain()` accessor are pre-filtered. The
+ * `domains` list is preserved unchanged.
+ *
+ * Unsubscribe handles returned by the filtered feeds propagate correctly
+ * to the underlying connection.
+ *
+ * @example
+ * const events = sdk.realtime.viaSse();
+ * // Without forSession — manual filter:
+ * events.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   if (e.sessionId !== mySessionId) return;
+ *   process.stdout.write(e.payload.content);
+ * });
+ *
+ * // With forSession — no filter needed:
+ * const sessionEvents = forSession(events, mySessionId);
+ * sessionEvents.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   process.stdout.write(e.payload.content);
+ * });
+ */
+export function forSession(events, sessionId) {
+    const filteredFeeds = {};
+    for (const domain of events.domains) {
+        filteredFeeds[domain] = createFilteredFeed(events[domain], sessionId);
+    }
+    return Object.freeze({
+        ...filteredFeeds,
+        domains: events.domains,
+        domain(d) {
+            return filteredFeeds[d];
+        },
+    });
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export type { DomainEventConnector, DomainEvents, SerializedEventEnvelope, } from './domain-events.js';
-export { createRemoteDomainEvents } from './domain-events.js';
-export type { RemoteRuntimeEvents, SerializedRuntimeEnvelope } from './runtime-events.js';
-export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, } from './runtime-events.js';
+export type { DomainEventConnector, DomainEvents, RemoteDomainEventsOptions, SerializedEventEnvelope, } from './domain-events.js';
+export { createRemoteDomainEvents, forSession } from './domain-events.js';
+export type { RemoteRuntimeEvents, RemoteRuntimeEventsOptions, SerializedRuntimeEnvelope } from './runtime-events.js';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, DEFAULT_WS_MAX_ATTEMPTS, forSessionRuntime, } from './runtime-events.js';
 export type { RuntimeEventConnectorOptions } from './runtime-events.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,YAAY,EACZ,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,YAAY,EACZ,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC1E,YAAY,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACtH,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { createRemoteDomainEvents } from './domain-events.js';
-export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, } from './runtime-events.js';
+export { createRemoteDomainEvents, forSession } from './domain-events.js';
+export { buildEventSourceUrl, buildWebSocketUrl, createEventSourceConnector, createRemoteRuntimeEvents, createWebSocketConnector, DEFAULT_WS_MAX_ATTEMPTS, forSessionRuntime, } from './runtime-events.js';

package/dist/runtime-events.d.ts

@@ -1,20 +1,67 @@
 import { type RuntimeEventDomain } from '@pellux/goodvibes-contracts';
+import { GoodVibesSdkError } from '@pellux/goodvibes-errors';
 import { type AuthTokenResolver, type StreamReconnectPolicy } from '@pellux/goodvibes-transport-http';
+import { type TransportObserver } from '@pellux/goodvibes-transport-core';
 import { type DomainEventConnector, type DomainEvents, type SerializedEventEnvelope } from './domain-events.js';
 type RuntimeEventRecord = {
     readonly type: string;
 };
 export type SerializedRuntimeEnvelope<TEvent extends RuntimeEventRecord = RuntimeEventRecord> = SerializedEventEnvelope<TEvent>;
 export type RemoteRuntimeEvents<TEvent extends RuntimeEventRecord = RuntimeEventRecord> = DomainEvents<RuntimeEventDomain, TEvent>;
+export interface RemoteRuntimeEventsOptions {
+    readonly onError?: (error: Error, domain: RuntimeEventDomain) => void;
+    readonly observer?: TransportObserver;
+}
+/**
+ * Returns a filtered view of a {@link RemoteRuntimeEvents} object where every
+ * callback only fires for events whose envelope `sessionId` equals the given
+ * session identifier.
+ *
+ * This is a convenience wrapper around {@link forSession} scoped to the
+ * canonical runtime-event domains. Use it instead of manually checking
+ * `e.sessionId` in every callback.
+ *
+ * @example
+ * const events = sdk.realtime.viaSse();
+ * const session = await sdk.operator.sessions.create({ title: 'demo' });
+ * const sessionId = session.session.id;
+ *
+ * // Before forSession — repeated manual guard:
+ * events.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   if (e.sessionId !== sessionId) return;
+ *   process.stdout.write(e.payload.content);
+ * });
+ *
+ * // After forSession — clean, session-scoped subscription:
+ * const sessionEvents = forSessionRuntime(events, sessionId);
+ * sessionEvents.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   process.stdout.write(e.payload.content);
+ * });
+ */
+export { forSession as forSessionRuntime } from './domain-events.js';
 export interface RuntimeEventConnectorOptions {
     readonly reconnect?: StreamReconnectPolicy;
     readonly onError?: (error: unknown) => void;
+    readonly observer?: TransportObserver;
+    /**
+     * Called once the WebSocket connector is set up, providing an `emitLocal`
+     * function the caller can use to send messages over this connection.
+     * Primarily for tests and local harnesses that need to inject outbound frames.
+     */
+    readonly onEmitter?: (emitLocal: (data: string) => void) => void;
 }
 type AuthTokenSource = string | null | undefined | AuthTokenResolver;
-export declare function createRemoteRuntimeEvents<TEvent extends RuntimeEventRecord = RuntimeEventRecord>(connect: DomainEventConnector<RuntimeEventDomain, TEvent>): RemoteRuntimeEvents<TEvent>;
+/** Default max reconnect attempts for WebSocket connections (finite to prevent infinite auth loops). */
+export declare const DEFAULT_WS_MAX_ATTEMPTS = 10;
+export declare class WebSocketTransportError extends GoodVibesSdkError {
+    constructor(message: string, options?: {
+        readonly cause?: unknown;
+        readonly hint?: string;
+    });
+}
+export declare function createRemoteRuntimeEvents<TEvent extends RuntimeEventRecord = RuntimeEventRecord>(connect: DomainEventConnector<RuntimeEventDomain, TEvent>, options?: RemoteRuntimeEventsOptions): RemoteRuntimeEvents<TEvent>;
 export declare function buildEventSourceUrl(baseUrl: string, domain: RuntimeEventDomain): string;
 export declare function buildWebSocketUrl(baseUrl: string, domains: readonly RuntimeEventDomain[]): string;
-export declare function createEventSourceConnector(baseUrl: string, token: AuthTokenSource, fetchImpl: typeof fetch, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>;
-export declare function createWebSocketConnector(baseUrl: string, token: AuthTokenSource, WebSocketImpl: typeof WebSocket, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, RuntimeEventRecord>;
-export {};
+export declare function createEventSourceConnector<TEvent extends RuntimeEventRecord = RuntimeEventRecord>(baseUrl: string, token: AuthTokenSource, fetchImpl: typeof fetch, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, TEvent>;
+export declare function createWebSocketConnector<TEvent extends RuntimeEventRecord = RuntimeEventRecord>(baseUrl: string, token: AuthTokenSource, WebSocketImpl: typeof WebSocket, options?: RuntimeEventConnectorOptions): DomainEventConnector<RuntimeEventDomain, TEvent>;
 //# sourceMappingURL=runtime-events.d.ts.map

package/dist/runtime-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-events.d.ts","sourceRoot":"","sources":["../src/runtime-events.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC7F,OAAO,EAAoB,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAA6D,MAAM,kCAAkC,CAAC;AAEnL,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B,KAAK,kBAAkB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,MAAM,yBAAyB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,IAC1F,uBAAuB,CAAC,MAAM,CAAC,CAAC;AAElC,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,IACpF,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;AAE3C,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,KAAK,eAAe,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB,CAAC;AASrE,wBAAgB,yBAAyB,CAAC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,EAC9F,OAAO,EAAE,oBAAoB,CAAC,kBAAkB,EAAE,MAAM,CAAC,GACxD,mBAAmB,CAAC,MAAM,CAAC,CAK7B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAIR;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,CAQR;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,OAAO,KAAK,EACvB,OAAO,GAAE,4BAAiC,GACzC,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAiB9D;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,OAAO,SAAS,EAC/B,OAAO,GAAE,4BAAiC,GACzC,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAuF9D"}
+{"version":3,"file":"runtime-events.d.ts","sourceRoot":"","sources":["../src/runtime-events.ts"],"names":[],"mappings":"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"}

package/dist/runtime-events.js

@@ -1,16 +1,67 @@
-// Synced from goodvibes-tui/src/runtime/transports/runtime-events-client.ts
 import { RUNTIME_EVENT_DOMAINS } from '@pellux/goodvibes-contracts';
-import { resolveAuthToken, openRawServerSentEventStream as openServerSentEventStream } from '@pellux/goodvibes-transport-http';
+import { ConfigurationError, GoodVibesSdkError } from '@pellux/goodvibes-errors';
+import { normalizeAuthToken, openRawServerSentEventStream as openServerSentEventStream, normalizeStreamReconnectPolicy, getStreamReconnectDelay, } from '@pellux/goodvibes-transport-http';
 import { buildUrl, normalizeBaseUrl } from '@pellux/goodvibes-transport-http';
+import { describeUnknownTransportError, injectTraceparentAsync, invokeTransportObserver, transportErrorFromUnknown, } from '@pellux/goodvibes-transport-core';
 import { createRemoteDomainEvents, } from './domain-events.js';
-async function resolveAuthTokenSource(source) {
-    if (typeof source === 'function') {
-        return await resolveAuthToken(null, source);
+/**
+ * Returns a filtered view of a {@link RemoteRuntimeEvents} object where every
+ * callback only fires for events whose envelope `sessionId` equals the given
+ * session identifier.
+ *
+ * This is a convenience wrapper around {@link forSession} scoped to the
+ * canonical runtime-event domains. Use it instead of manually checking
+ * `e.sessionId` in every callback.
+ *
+ * @example
+ * const events = sdk.realtime.viaSse();
+ * const session = await sdk.operator.sessions.create({ title: 'demo' });
+ * const sessionId = session.session.id;
+ *
+ * // Before forSession — repeated manual guard:
+ * events.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   if (e.sessionId !== sessionId) return;
+ *   process.stdout.write(e.payload.content);
+ * });
+ *
+ * // After forSession — clean, session-scoped subscription:
+ * const sessionEvents = forSessionRuntime(events, sessionId);
+ * sessionEvents.turn.onEnvelope('STREAM_DELTA', (e) => {
+ *   process.stdout.write(e.payload.content);
+ * });
+ */
+export { forSession as forSessionRuntime } from './domain-events.js';
+/** Default max reconnect attempts for WebSocket connections (finite to prevent infinite auth loops). */
+export const DEFAULT_WS_MAX_ATTEMPTS = 10;
+/** Maximum number of messages that may be queued in the outbound queue before the oldest entry is dropped. */
+const MAX_OUTBOUND_QUEUE = 1024;
+function getSocketOpenState(WebSocketImpl) {
+    return typeof WebSocketImpl.OPEN === 'number' ? WebSocketImpl.OPEN : 1;
+}
+function isSocketOpen(socket, WebSocketImpl) {
+    return socket.readyState === getSocketOpenState(WebSocketImpl);
+}
+export class WebSocketTransportError extends GoodVibesSdkError {
+    constructor(message, options = {}) {
+        super(message, {
+            code: 'WEBSOCKET_TRANSPORT_ERROR',
+            category: 'network',
+            source: 'transport',
+            recoverable: true,
+            hint: options.hint,
+            cause: options.cause,
+        });
+        this.name = 'WebSocketTransportError';
     }
-    return source ?? null;
 }
-export function createRemoteRuntimeEvents(connect) {
-    return createRemoteDomainEvents(RUNTIME_EVENT_DOMAINS, connect);
+export function createRemoteRuntimeEvents(connect, options = {}) {
+    const domainOptions = {
+        onConnectionError: (error, domain) => {
+            invokeTransportObserver(() => options.observer?.onError?.(error));
+            options.onError?.(error, domain);
+        },
+    };
+    return createRemoteDomainEvents(RUNTIME_EVENT_DOMAINS, connect, domainOptions);
 }
 export function buildEventSourceUrl(baseUrl, domain) {
     const url = new URL(buildUrl(baseUrl, '/api/control-plane/events'));
@@ -18,43 +69,144 @@ export function buildEventSourceUrl(baseUrl, domain) {
     return url.toString();
 }
 export function buildWebSocketUrl(baseUrl, domains) {
-    const base = normalizeBaseUrl(baseUrl);
-    const url = new URL('/api/control-plane/ws', base.replace(/^http(s?):\/\//, 'ws$1://'));
+    const url = new URL('/api/control-plane/ws', normalizeBaseUrl(baseUrl));
+    if (url.protocol === 'http:') {
+        url.protocol = 'ws:';
+    }
+    else if (url.protocol === 'https:') {
+        url.protocol = 'wss:';
+    }
+    else if (url.protocol !== 'ws:' && url.protocol !== 'wss:') {
+        throw new ConfigurationError(`Unsupported WebSocket base URL protocol: ${url.protocol}`, {
+            source: 'transport',
+            hint: 'Runtime event WebSocket clients require http, https, ws, or wss base URLs.',
+        });
+    }
+    assertWebSocketAuthTransportIsSafe(url);
     url.searchParams.set('clientKind', 'web');
     if (domains.length > 0) {
         url.searchParams.set('domains', domains.join(','));
     }
     return url.toString();
 }
+function assertWebSocketAuthTransportIsSafe(url) {
+    if (url.protocol !== 'ws:')
+        return;
+    const host = url.hostname.toLowerCase();
+    const isLoopback = host === 'localhost'
+        || host === '127.0.0.1'
+        || host === '::1'
+        || host.startsWith('127.');
+    if (!isLoopback) {
+        throw new ConfigurationError('Refusing to send GoodVibes WebSocket authentication over insecure ws:// transport. Use https:// or wss://.', {
+            source: 'transport',
+            hint: 'Use https:// or wss:// for non-loopback WebSocket runtime event connections.',
+        });
+    }
+}
 export function createEventSourceConnector(baseUrl, token, fetchImpl, options = {}) {
-    const handleError = options.onError ?? (options.reconnect?.enabled ? (() => { }) : undefined);
+    const { observer } = options;
+    const handleError = options.onError;
     return async (domain, onEnvelope) => {
         const url = buildEventSourceUrl(baseUrl, domain);
-        return await openServerSentEventStream(fetchImpl, url, {
-            onEvent: (eventName, payload) => {
-                if (eventName !== domain)
-                    return;
-                if (!payload || typeof payload !== 'object')
-                    return;
-                onEnvelope(payload);
-            },
-            onError: handleError,
-        }, {
-            reconnect: options.reconnect,
-            getAuthToken: typeof token === 'function' ? token : undefined,
-            authToken: typeof token === 'function' ? null : token,
-        });
+        const getAuthToken = normalizeAuthToken(token ?? undefined);
+        // Inject W3C traceparent if OTel is active (async probe for SSE cold-start).
+        const sseHeaders = {};
+        await injectTraceparentAsync(sseHeaders);
+        // Notify observer of outbound SSE connection attempt.
+        invokeTransportObserver(() => observer?.onTransportActivity?.({ direction: 'send', url, kind: 'sse' }));
+        try {
+            return await openServerSentEventStream(fetchImpl, url, {
+                onEvent: (eventName, payload) => {
+                    if (eventName !== domain)
+                        return;
+                    if (!payload || typeof payload !== 'object')
+                        return;
+                    const envelope = payload;
+                    onEnvelope(envelope);
+                    // Notify observer of inbound event.
+                    invokeTransportObserver(() => {
+                        observer?.onTransportActivity?.({ direction: 'recv', url, kind: 'sse' });
+                        if (envelope.payload) {
+                            observer?.onEvent?.(envelope.payload);
+                        }
+                    });
+                },
+                onError: (err) => {
+                    const streamError = transportErrorFromUnknown(err, 'SSE runtime event stream error');
+                    invokeTransportObserver(() => observer?.onError?.(streamError));
+                    handleError?.(streamError);
+                },
+            }, {
+                reconnect: options.reconnect,
+                getAuthToken,
+                headers: Object.keys(sseHeaders).length > 0 ? sseHeaders : undefined,
+            });
+        }
+        catch (error) {
+            const connectionError = transportErrorFromUnknown(error, 'SSE runtime event connection failed');
+            invokeTransportObserver(() => observer?.onError?.(connectionError));
+            handleError?.(connectionError);
+            throw connectionError;
+        }
     };
 }
 export function createWebSocketConnector(baseUrl, token, WebSocketImpl, options = {}) {
+    const { observer } = options;
     return async (domain, onEnvelope) => {
         const url = buildWebSocketUrl(baseUrl, [domain]);
         const reconnect = options.reconnect;
         const enabled = reconnect?.enabled ?? false;
+        // Normalize reconnect policy, defaulting maxAttempts to a finite value to prevent
+        // infinite auth-failure loops. Callers can opt-in to a higher limit explicitly.
+        const reconnectPolicy = normalizeStreamReconnectPolicy({
+            ...reconnect,
+            maxAttempts: reconnect?.maxAttempts ?? DEFAULT_WS_MAX_ATTEMPTS,
+        });
         let stopped = false;
         let reconnectAttempt = 0;
+        let hasReceivedMessage = false;
         let socket = null;
         let reconnectTimer = null;
+        // Bounded outbound message queue — max MAX_OUTBOUND_QUEUE entries, drop-oldest policy.
+        // Messages pushed while the socket is not yet open or is reconnecting are buffered here
+        // and flushed on the next successful open event.
+        const outboundQueue = [];
+        let droppedOutboundCount = 0;
+        let queueOverflowNotified = false;
+        /**
+         * Enqueue a message for delivery over this WebSocket connection.
+         *
+         * If the socket is currently open the message is sent immediately.
+         * If the socket is not yet open (or is reconnecting), the message is
+         * buffered and will be flushed once the connection is re-established.
+         *
+         * When the buffer is full (> MAX_OUTBOUND_QUEUE), the oldest pending
+         * message is silently dropped and a counter is incremented. Callers that
+         * need back-pressure should check `socket?.readyState` before calling.
+         *
+         * @param data - Serialised message string to send.
+         */
+        const emitLocal = (data) => {
+            if (socket && isSocketOpen(socket, WebSocketImpl)) {
+                socket.send(data);
+                return;
+            }
+            if (outboundQueue.length >= MAX_OUTBOUND_QUEUE) {
+                // Drop oldest message to make room (drop-oldest policy).
+                outboundQueue.shift();
+                droppedOutboundCount += 1;
+                if (!queueOverflowNotified) {
+                    queueOverflowNotified = true;
+                    options.onError?.(new WebSocketTransportError(`WebSocket outbound queue full (limit ${MAX_OUTBOUND_QUEUE}). Dropping oldest messages until the socket reconnects.`, {
+                        hint: 'Wait for the runtime event WebSocket to reconnect before sending more local frames.',
+                    }));
+                }
+            }
+            outboundQueue.push(data);
+        };
+        // Notify caller of the emitter handle for tests and local frame injection.
+        options.onEmitter?.(emitLocal);
         const closeSocket = () => {
             if (!socket)
                 return;
@@ -69,47 +221,109 @@ export function createWebSocketConnector(baseUrl, token, WebSocketImpl, options
             if (!enabled || stopped)
                 return;
             const nextAttempt = reconnectAttempt + 1;
-            const maxAttempts = reconnect?.maxAttempts ?? Number.POSITIVE_INFINITY;
-            if (nextAttempt >= maxAttempts)
+            if (nextAttempt > reconnectPolicy.maxAttempts)
                 return;
             reconnectAttempt = nextAttempt;
-            const baseDelayMs = reconnect?.baseDelayMs ?? 500;
-            const maxDelayMs = reconnect?.maxDelayMs ?? 5_000;
-            const backoffFactor = reconnect?.backoffFactor ?? 2;
-            const delayMs = Math.min(maxDelayMs, Math.floor(baseDelayMs * (backoffFactor ** Math.max(0, nextAttempt - 1))));
+            // Use shared backoff helper so WS and SSE are on identical schedule.
+            const delayMs = getStreamReconnectDelay(nextAttempt, reconnectPolicy);
             reconnectTimer = setTimeout(() => {
                 reconnectTimer = null;
-                void connect();
+                void connect().catch((error) => {
+                    const connectionError = transportErrorFromUnknown(error, 'WebSocket runtime event reconnect failed');
+                    invokeTransportObserver(() => observer?.onError?.(connectionError));
+                    options.onError?.(connectionError);
+                    scheduleReconnect();
+                });
             }, delayMs);
+            reconnectTimer.unref?.();
         };
-        const onOpen = async () => {
-            reconnectAttempt = 0;
-            const authToken = await resolveAuthTokenSource(token);
-            if (!authToken || !socket)
-                return;
-            socket.send(JSON.stringify({
-                type: 'auth',
-                token: authToken,
-                domains: [domain],
-            }));
+        const flushOutboundQueue = (ws) => {
+            while (outboundQueue.length > 0) {
+                const data = outboundQueue.shift();
+                if (data === undefined)
+                    break;
+                ws.send(data);
+            }
+        };
+        const onOpen = async (event) => {
+            const candidateSocket = event.currentTarget;
+            const openedSocket = candidateSocket && typeof candidateSocket.send === 'function'
+                ? candidateSocket
+                : socket;
+            try {
+                const authToken = (await normalizeAuthToken(token ?? undefined)()) ?? null;
+                if (!authToken || !openedSocket || stopped || socket !== openedSocket)
+                    return;
+                // Notify observer of outbound WS connection.
+                invokeTransportObserver(() => observer?.onTransportActivity?.({ direction: 'send', url, kind: 'ws' }));
+                // Send auth frame first, then drain any messages buffered during resolution.
+                // Inject traceparent into the auth frame for W3C Trace Context propagation over WebSocket.
+                const wsTraceHeaders = {};
+                await injectTraceparentAsync(wsTraceHeaders);
+                if (stopped || socket !== openedSocket)
+                    return;
+                openedSocket.send(JSON.stringify({
+                    type: 'auth',
+                    token: authToken,
+                    domains: [domain],
+                    ...(wsTraceHeaders['traceparent'] ? { traceparent: wsTraceHeaders['traceparent'] } : {}),
+                    ...(wsTraceHeaders['tracestate'] ? { tracestate: wsTraceHeaders['tracestate'] } : {}),
+                }));
+                flushOutboundQueue(openedSocket);
+            }
+            catch (error) {
+                const sendError = transportErrorFromUnknown(error, 'WebSocket send failed');
+                invokeTransportObserver(() => observer?.onError?.(sendError));
+                options.onError?.(sendError);
+                closeSocket();
+                scheduleReconnect();
+            }
         };
         const onMessage = (event) => {
             try {
                 const frame = JSON.parse(event.data);
+                if (!hasReceivedMessage) {
+                    hasReceivedMessage = true;
+                    reconnectAttempt = 0;
+                }
+                queueOverflowNotified = false;
                 if (frame.type === 'event' && frame.event === domain && frame.payload && typeof frame.payload === 'object') {
-                    onEnvelope(frame.payload);
+                    const wsPayload = frame.payload;
+                    onEnvelope(wsPayload);
+                    // Notify observer of inbound WS event.
+                    invokeTransportObserver(() => {
+                        observer?.onTransportActivity?.({ direction: 'recv', url, kind: 'ws' });
+                        if (wsPayload.payload) {
+                            observer?.onEvent?.(wsPayload.payload);
+                        }
+                    });
                 }
             }
-            catch {
-                // Ignore malformed frames.
+            catch (error) {
+                const malformed = new GoodVibesSdkError(`Malformed WebSocket runtime event frame: ${transportErrorFromUnknown(error, 'parse error').message}`, {
+                    category: 'protocol',
+                    source: 'transport',
+                    recoverable: true,
+                    cause: error,
+                });
+                invokeTransportObserver(() => observer?.onError?.(malformed));
+                options.onError?.(malformed);
             }
         };
-        const onClose = () => {
+        const onClose = (event) => {
+            hasReceivedMessage = false;
+            if (!stopped && event.code !== 1000 && event.code !== 1005) {
+                const closeError = webSocketCloseError(event);
+                invokeTransportObserver(() => observer?.onError?.(closeError));
+                options.onError?.(closeError);
+            }
             closeSocket();
             scheduleReconnect();
         };
         const onError = (event) => {
-            options.onError?.(event);
+            const streamError = webSocketEventError(event);
+            invokeTransportObserver(() => observer?.onError?.(streamError));
+            options.onError?.(streamError);
         };
         const connect = async () => {
             if (stopped)
@@ -122,7 +336,15 @@ export function createWebSocketConnector(baseUrl, token, WebSocketImpl, options
             nextSocket.addEventListener('close', onClose);
             nextSocket.addEventListener('error', onError);
         };
-        await connect();
+        try {
+            await connect();
+        }
+        catch (error) {
+            const connectionError = transportErrorFromUnknown(error, 'WebSocket runtime event connection failed');
+            invokeTransportObserver(() => observer?.onError?.(connectionError));
+            options.onError?.(connectionError);
+            throw connectionError;
+        }
         return () => {
             stopped = true;
             if (reconnectTimer) {
@@ -132,3 +354,28 @@ export function createWebSocketConnector(baseUrl, token, WebSocketImpl, options
         };
     };
 }
+function webSocketCloseError(event) {
+    const reason = typeof event.reason === 'string' ? event.reason.trim() : '';
+    const code = typeof event.code === 'number' ? event.code : 1005;
+    const wasClean = typeof event.wasClean === 'boolean' ? event.wasClean : false;
+    const detail = [
+        `code=${code}`,
+        reason ? `reason=${reason}` : undefined,
+        `wasClean=${wasClean}`,
+    ].filter(Boolean).join(' ');
+    return new WebSocketTransportError(`WebSocket runtime event stream closed unexpectedly: ${detail}`, {
+        cause: event,
+    });
+}
+function webSocketEventError(event) {
+    const candidate = event;
+    if (candidate.error) {
+        return transportErrorFromUnknown(candidate.error, 'WebSocket runtime event stream error');
+    }
+    const eventMessage = typeof candidate.message === 'string' && candidate.message.trim().length > 0
+        ? candidate.message.trim()
+        : undefined;
+    return new WebSocketTransportError(eventMessage
+        ? `WebSocket runtime event stream error: ${eventMessage}`
+        : `WebSocket runtime event stream error: ${describeUnknownTransportError(event)}`, { cause: event });
+}

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@pellux/goodvibes-transport-realtime",
-  "version": "0.18.3",
+  "version": "0.30.1",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "description": "Realtime event-domain connectors for GoodVibes SSE and WebSocket integrations.",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +13,14 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./domain-events": {
+      "types": "./dist/domain-events.d.ts",
+      "import": "./dist/domain-events.js"
+    },
+    "./runtime-events": {
+      "types": "./dist/runtime-events.d.ts",
+      "import": "./dist/runtime-events.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -32,12 +43,13 @@
     "websocket",
     "events"
   ],
+  "dependencies": {
+    "@pellux/goodvibes-contracts": "0.30.1",
+    "@pellux/goodvibes-errors": "0.30.1",
+    "@pellux/goodvibes-transport-core": "0.30.1",
+    "@pellux/goodvibes-transport-http": "0.30.1"
+  },
   "publishConfig": {
     "access": "public"
-  },
-  "dependencies": {
-    "@pellux/goodvibes-contracts": "0.18.3",
-    "@pellux/goodvibes-transport-core": "0.18.3",
-    "@pellux/goodvibes-transport-http": "0.18.3"
   }
 }