@agentick/client - npm Package Compare versions

+7

-2

package.json

		{
		"name": "@agentick/client",
		"version": "0.0.1",
		"version": "0.1.9",
		"description": "Client SDK for Agentick - multiplexed sessions over SSE",
		@@ -30,3 +30,3 @@ "keywords": [
		"dependencies": {
		"@agentick/shared": "0.0.1"
		"@agentick/shared": "0.1.9"
		},
		@@ -36,2 +36,7 @@ "devDependencies": {
		},
		"repository": {
		"type": "git",
		"url": "git+https://github.com/agenticklabs/agentick.git",
		"directory": "packages/client"
		},
		"scripts": {
		@@ -38,0 +43,0 @@ "build": "tsc -p tsconfig.build.json",

-213

dist/transports/http.d.ts

		/**
		* HTTP/SSE Transport - Default transport implementation
		*
		* - Server → Client: Server-Sent Events (SSE)
		* - Client → Server: HTTP POST
		*
		* @module @tentickle/client/transports/http
		*/
		import type { Transport, ClientConfig, ConnectionState, ConnectionMetadata, ChannelEvent } from "../types.js";
		/**
		* Custom fetch function signature.
		* Allows replacing the default fetch with axios, ky, or a custom wrapper.
		*/
		export type FetchFn = typeof fetch;
		/**
		* EventSource constructor signature.
		* Allows replacing the default EventSource (e.g., for polyfills or custom implementations).
		*/
		export interface EventSourceConstructor {
		new (url: string \| URL, init?: {
		withCredentials?: boolean;
		}): EventSource;
		}
		/**
		* HTTP transport configuration.
		*/
		export interface HTTPTransportConfig extends ClientConfig {
		/**
		* Custom headers to include in all requests.
		* These are merged with defaults (Content-Type: application/json).
		* User-provided headers take precedence over defaults.
		*
		* Use this for custom auth schemes, API keys, or any other headers.
		*
		* @example
		* ```typescript
		* // Basic auth
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { Authorization: 'Basic ' + btoa('user:pass') },
		* });
		*
		* // API key
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { 'X-API-Key': 'my-api-key' },
		* });
		* ```
		*/
		headers?: Record<string, string>;
		/**
		* Send cookies with requests and SSE (EventSource withCredentials).
		* Defaults to false.
		*/
		withCredentials?: boolean;
		/**
		* Include auth token in SSE query params (EventSource lacks headers).
		* Defaults to false to avoid token leakage in logs.
		*/
		authTokenInQuery?: boolean;
		/**
		* Custom fetch implementation.
		* Use this to inject axios, ky, or a fetch wrapper with custom credentials/interceptors.
		*
		* @example
		* ```typescript
		* import ky from 'ky';
		*
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* fetch: ky as unknown as FetchFn,
		* });
		* ```
		*/
		fetch?: FetchFn;
		/**
		* Custom EventSource constructor.
		* Use this for polyfills (e.g., eventsource package in Node.js) or custom implementations.
		*
		* @example
		* ```typescript
		* import EventSource from 'eventsource';
		*
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* EventSource: EventSource,
		* });
		* ```
		*/
		EventSource?: EventSourceConstructor;
		}
		/**
		* HTTP/SSE Transport implementation.
		*
		* This is the default transport for Tentickle clients.
		* Uses SSE for server-to-client streaming and HTTP POST for client-to-server messages.
		*
		* Supports custom fetch and EventSource implementations for:
		* - Server-side (Node.js) usage with polyfills
		* - Custom HTTP clients (axios, ky, got)
		* - Credentials/interceptors
		* - Testing with mocks
		*/
		export declare class HTTPTransport implements Transport {
		readonly name = "http";
		private _state;
		private sessionId?;
		private metadata?;
		private eventSource?;
		private reconnectAttempts;
		private reconnectTimer?;
		private receiveHandlers;
		private stateHandlers;
		private readonly baseUrl;
		private readonly eventsPath;
		private readonly timeout;
		private readonly reconnectDelay;
		private readonly maxReconnectAttempts;
		private readonly withCredentials;
		private readonly authTokenInQuery;
		/** Token for SSE query param auth (EventSource doesn't support headers) */
		private readonly token?;
		/** Custom headers to merge with defaults for fetch requests */
		private readonly customHeaders;
		/** Custom fetch implementation (defaults to global fetch) */
		private readonly fetchFn;
		/** Custom EventSource constructor (defaults to global EventSource) */
		private readonly EventSourceCtor;
		constructor(config: HTTPTransportConfig);
		get state(): ConnectionState;
		private setState;
		/**
		* Connect to the SSE stream.
		*/
		connect(sessionId: string, metadata?: ConnectionMetadata): Promise<void>;
		private connectSSE;
		private handleReconnect;
		private closeEventSource;
		/**
		* Disconnect from the server.
		*/
		disconnect(): Promise<void>;
		/**
		* Send event via HTTP POST.
		*/
		send(event: ChannelEvent): Promise<void>;
		/**
		* Register receive handler.
		*/
		onReceive(handler: (event: ChannelEvent) => void): () => void;
		/**
		* Register state change handler.
		*/
		onStateChange(handler: (state: ConnectionState) => void): () => void;
		private notifyReceive;
		}
		/**
		* Create HTTP/SSE transport.
		*
		* @example
		* ```typescript
		* // Default usage
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* });
		*
		* // With custom headers (API key, Basic auth, etc.)
		* const transportWithApiKey = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { 'X-API-Key': 'my-api-key' },
		* });
		*
		* const transportWithBasicAuth = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { Authorization: 'Basic ' + btoa('user:pass') },
		* });
		*
		* // With Bearer token (convenience - same as headers: { Authorization: 'Bearer ...' })
		* const transportWithToken = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* token: 'my-jwt-token',
		* });
		*
		* // With custom fetch (e.g., for credentials)
		* const transportWithCredentials = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* fetch: (url, init) => fetch(url, { ...init, credentials: 'include' }),
		* });
		*
		* // With cookie-based auth for SSE + POST
		* const transportWithCookies = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* withCredentials: true,
		* });
		*
		* // If you must pass auth token to SSE via query params
		* const transportWithQueryToken = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* token: 'my-jwt-token',
		* authTokenInQuery: true,
		* });
		*
		* // Node.js with polyfills
		* import EventSource from 'eventsource';
		*
		* const nodeTransport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* EventSource,
		* });
		* ```
		*/
		export declare function createHTTPTransport(config: HTTPTransportConfig): Transport;
		//# sourceMappingURL=http.d.ts.map

-1

dist/transports/http.d.ts.map

{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"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"}

-309

dist/transports/http.js

		/**
		* HTTP/SSE Transport - Default transport implementation
		*
		* - Server → Client: Server-Sent Events (SSE)
		* - Client → Server: HTTP POST
		*
		* @module @tentickle/client/transports/http
		*/
		/**
		* HTTP/SSE Transport implementation.
		*
		* This is the default transport for Tentickle clients.
		* Uses SSE for server-to-client streaming and HTTP POST for client-to-server messages.
		*
		* Supports custom fetch and EventSource implementations for:
		* - Server-side (Node.js) usage with polyfills
		* - Custom HTTP clients (axios, ky, got)
		* - Credentials/interceptors
		* - Testing with mocks
		*/
		export class HTTPTransport {
		name = "http";
		_state = "disconnected";
		sessionId;
		metadata;
		eventSource;
		reconnectAttempts = 0;
		reconnectTimer;
		receiveHandlers = new Set();
		stateHandlers = new Set();
		baseUrl;
		eventsPath;
		timeout;
		reconnectDelay;
		maxReconnectAttempts;
		withCredentials;
		authTokenInQuery;
		/** Token for SSE query param auth (EventSource doesn't support headers) */
		token;
		/** Custom headers to merge with defaults for fetch requests */
		customHeaders;
		/** Custom fetch implementation (defaults to global fetch) */
		fetchFn;
		/** Custom EventSource constructor (defaults to global EventSource) */
		EventSourceCtor;
		constructor(config) {
		this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
		this.eventsPath = config.paths?.events ?? "/events";
		this.timeout = config.timeout ?? 30000;
		this.reconnectDelay = config.reconnectDelay ?? 1000;
		this.maxReconnectAttempts = config.maxReconnectAttempts ?? 10;
		this.withCredentials = config.withCredentials ?? false;
		this.authTokenInQuery = config.authTokenInQuery ?? false;
		// Token is used for SSE query param (EventSource doesn't support custom headers)
		this.token = config.token;
		// Build custom headers for fetch requests - token adds Bearer auth if no custom Authorization
		this.customHeaders = { ...config.headers };
		if (config.token && !this.customHeaders["Authorization"]) {
		this.customHeaders["Authorization"] = `Bearer ${config.token}`;
		}
		// Use custom implementations or fall back to globals
		this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
		this.EventSourceCtor = config.EventSource ?? globalThis.EventSource;
		}
		get state() {
		return this._state;
		}
		setState(state) {
		if (this._state === state)
		return;
		this._state = state;
		for (const handler of this.stateHandlers) {
		try {
		handler(state);
		}
		catch (error) {
		console.error("Error in state handler:", error);
		}
		}
		}
		/**
		* Connect to the SSE stream.
		*/
		async connect(sessionId, metadata) {
		if (this._state === "connected") {
		throw new Error("Already connected");
		}
		this.sessionId = sessionId;
		this.metadata = metadata;
		this.reconnectAttempts = 0;
		this.setState("connecting");
		try {
		await this.connectSSE();
		this.setState("connected");
		}
		catch (error) {
		this.setState("error");
		throw error;
		}
		}
		async connectSSE() {
		if (!this.sessionId) {
		throw new Error("Session ID required");
		}
		// Close existing connection
		this.closeEventSource();
		// Build SSE URL with query params
		const url = new URL(`${this.baseUrl}${this.eventsPath}`);
		url.searchParams.set("sessionId", this.sessionId);
		if (this.metadata?.userId) {
		url.searchParams.set("userId", String(this.metadata.userId));
		}
		if (this.token && this.authTokenInQuery) {
		url.searchParams.set("token", this.token);
		}
		return new Promise((resolve, reject) => {
		try {
		this.eventSource = new this.EventSourceCtor(url.toString(), {
		withCredentials: this.withCredentials,
		});
		const onOpen = () => {
		this.reconnectAttempts = 0;
		resolve();
		};
		const onMessage = (event) => {
		try {
		const channelEvent = JSON.parse(event.data);
		this.notifyReceive(channelEvent);
		}
		catch (error) {
		console.error("Failed to parse SSE event:", error);
		}
		};
		const onError = () => {
		if (this._state === "connecting") {
		this.closeEventSource();
		reject(new Error("SSE connection failed"));
		}
		else {
		this.handleReconnect();
		}
		};
		this.eventSource.addEventListener("open", onOpen);
		this.eventSource.addEventListener("message", onMessage);
		this.eventSource.addEventListener("error", onError);
		}
		catch (error) {
		reject(error);
		}
		});
		}
		handleReconnect() {
		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
		console.error("Max reconnection attempts reached");
		this.setState("error");
		return;
		}
		this.reconnectAttempts++;
		const delay = this.reconnectDelay * Math.min(this.reconnectAttempts, 5); // Cap backoff
		this.reconnectTimer = setTimeout(() => {
		if (this.sessionId && this._state !== "disconnected") {
		this.connectSSE()
		.then(() => this.setState("connected"))
		.catch((error) => {
		console.error("Reconnection failed:", error);
		});
		}
		}, delay);
		}
		closeEventSource() {
		if (this.eventSource) {
		this.eventSource.close();
		this.eventSource = undefined;
		}
		}
		/**
		* Disconnect from the server.
		*/
		async disconnect() {
		if (this.reconnectTimer) {
		clearTimeout(this.reconnectTimer);
		this.reconnectTimer = undefined;
		}
		this.closeEventSource();
		this.sessionId = undefined;
		this.metadata = undefined;
		this.reconnectAttempts = 0;
		this.setState("disconnected");
		}
		/**
		* Send event via HTTP POST.
		*/
		async send(event) {
		if (!this.sessionId) {
		throw new Error("Not connected");
		}
		// Merge default headers with custom headers (custom takes precedence)
		const headers = {
		"Content-Type": "application/json",
		...this.customHeaders,
		};
		const response = await this.fetchFn(`${this.baseUrl}${this.eventsPath}`, {
		method: "POST",
		headers,
		credentials: this.withCredentials ? "include" : "same-origin",
		body: JSON.stringify({
		...event,
		metadata: {
		...event.metadata,
		sessionId: this.sessionId,
		userId: this.metadata?.userId,
		timestamp: Date.now(),
		},
		}),
		signal: AbortSignal.timeout(this.timeout),
		});
		if (!response.ok) {
		const text = await response.text();
		throw new Error(`Failed to send event: ${response.status} ${text}`);
		}
		}
		/**
		* Register receive handler.
		*/
		onReceive(handler) {
		this.receiveHandlers.add(handler);
		return () => {
		this.receiveHandlers.delete(handler);
		};
		}
		/**
		* Register state change handler.
		*/
		onStateChange(handler) {
		this.stateHandlers.add(handler);
		return () => {
		this.stateHandlers.delete(handler);
		};
		}
		notifyReceive(event) {
		for (const handler of this.receiveHandlers) {
		try {
		handler(event);
		}
		catch (error) {
		console.error("Error in receive handler:", error);
		}
		}
		}
		}
		/**
		* Create HTTP/SSE transport.
		*
		* @example
		* ```typescript
		* // Default usage
		* const transport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* });
		*
		* // With custom headers (API key, Basic auth, etc.)
		* const transportWithApiKey = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { 'X-API-Key': 'my-api-key' },
		* });
		*
		* const transportWithBasicAuth = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* headers: { Authorization: 'Basic ' + btoa('user:pass') },
		* });
		*
		* // With Bearer token (convenience - same as headers: { Authorization: 'Bearer ...' })
		* const transportWithToken = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* token: 'my-jwt-token',
		* });
		*
		* // With custom fetch (e.g., for credentials)
		* const transportWithCredentials = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* fetch: (url, init) => fetch(url, { ...init, credentials: 'include' }),
		* });
		*
		* // With cookie-based auth for SSE + POST
		* const transportWithCookies = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* withCredentials: true,
		* });
		*
		* // If you must pass auth token to SSE via query params
		* const transportWithQueryToken = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* token: 'my-jwt-token',
		* authTokenInQuery: true,
		* });
		*
		* // Node.js with polyfills
		* import EventSource from 'eventsource';
		*
		* const nodeTransport = createHTTPTransport({
		* baseUrl: 'https://api.example.com',
		* EventSource,
		* });
		* ```
		*/
		export function createHTTPTransport(config) {
		return new HTTPTransport(config);
		}
		//# sourceMappingURL=http.js.map

-1

dist/transports/http.js.map

-16

dist/transports/index.d.ts

		/**
		* Transport implementations for @tentickle/client
		*
		* Default: HTTP/SSE transport
		* Alternative: WebSocket transport
		*
		* Both transports support custom implementations for:
		* - Server-side (Node.js) usage with polyfills
		* - Custom HTTP clients (axios, ky, got)
		* - Testing with mocks
		*
		* @module @tentickle/client/transports
		*/
		export { HTTPTransport, createHTTPTransport, type HTTPTransportConfig, type FetchFn, type EventSourceConstructor, } from "./http.js";
		export { WebSocketTransport, createWebSocketTransport, type WebSocketConfig, type WebSocketConstructor, } from "./websocket.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/transports/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,sBAAsB,GAC5B,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GAC1B,MAAM,gBAAgB,CAAC"}

-18

dist/transports/index.js

		/**
		* Transport implementations for @tentickle/client
		*
		* Default: HTTP/SSE transport
		* Alternative: WebSocket transport
		*
		* Both transports support custom implementations for:
		* - Server-side (Node.js) usage with polyfills
		* - Custom HTTP clients (axios, ky, got)
		* - Testing with mocks
		*
		* @module @tentickle/client/transports
		*/
		// Default HTTP/SSE transport
		export { HTTPTransport, createHTTPTransport, } from "./http.js";
		// Alternative WebSocket transport
		export { WebSocketTransport, createWebSocketTransport, } from "./websocket.js";
		//# sourceMappingURL=index.js.map

-1

dist/transports/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/transports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,6BAA6B;AAC7B,OAAO,EACL,aAAa,EACb,mBAAmB,GAIpB,MAAM,WAAW,CAAC;AAEnB,kCAAkC;AAClC,OAAO,EACL,kBAAkB,EAClB,wBAAwB,GAGzB,MAAM,gBAAgB,CAAC"}

-114

dist/transports/websocket.d.ts

		/**
		* WebSocket Transport - Alternative transport implementation
		*
		* Bidirectional communication over WebSocket.
		* Use when you need lower latency or when SSE is not available.
		*
		* @module @tentickle/client/transports/websocket
		*/
		import type { Transport, ClientConfig, ConnectionState, ConnectionMetadata, ChannelEvent } from "../types.js";
		/**
		* WebSocket constructor signature.
		* Allows replacing the default WebSocket (e.g., with 'ws' package in Node.js).
		*/
		export interface WebSocketConstructor {
		new (url: string \| URL, protocols?: string \| string[]): WebSocket;
		}
		/**
		* WebSocket transport configuration.
		*/
		export interface WebSocketConfig extends ClientConfig {
		/** WebSocket URL (ws:// or wss://) - overrides baseUrl */
		wsUrl?: string;
		/** WebSocket protocols */
		protocols?: string[];
		/**
		* Custom WebSocket constructor.
		* Use this for Node.js (ws package) or custom implementations.
		*
		* @example
		* ```typescript
		* import WebSocket from 'ws';
		*
		* const transport = createWebSocketTransport({
		* baseUrl: 'wss://api.example.com',
		* WebSocket: WebSocket as unknown as WebSocketConstructor,
		* });
		* ```
		*/
		WebSocket?: WebSocketConstructor;
		}
		/**
		* WebSocket Transport implementation.
		*
		* Use this when:
		* - You need bidirectional real-time communication
		* - SSE is blocked or unavailable
		* - You want lower latency
		*/
		export declare class WebSocketTransport implements Transport {
		readonly name = "websocket";
		private _state;
		private sessionId?;
		private metadata?;
		private ws?;
		private reconnectAttempts;
		private reconnectTimer?;
		private receiveHandlers;
		private stateHandlers;
		private readonly wsUrl;
		private readonly protocols?;
		private readonly token?;
		private readonly reconnectDelay;
		private readonly maxReconnectAttempts;
		/** Custom WebSocket constructor (defaults to global WebSocket) */
		private readonly WebSocketCtor;
		constructor(config: WebSocketConfig);
		get state(): ConnectionState;
		private setState;
		/**
		* Connect to WebSocket server.
		*/
		connect(sessionId: string, metadata?: ConnectionMetadata): Promise<void>;
		private connectWebSocket;
		private handleReconnect;
		private closeWebSocket;
		/**
		* Disconnect from server.
		*/
		disconnect(): Promise<void>;
		/**
		* Send event via WebSocket.
		*/
		send(event: ChannelEvent): Promise<void>;
		/**
		* Register receive handler.
		*/
		onReceive(handler: (event: ChannelEvent) => void): () => void;
		/**
		* Register state change handler.
		*/
		onStateChange(handler: (state: ConnectionState) => void): () => void;
		private notifyReceive;
		}
		/**
		* Create WebSocket transport.
		*
		* @example
		* ```typescript
		* // Browser usage
		* const transport = createWebSocketTransport({
		* baseUrl: 'wss://api.example.com',
		* });
		*
		* // Node.js with ws package
		* import WebSocket from 'ws';
		*
		* const nodeTransport = createWebSocketTransport({
		* baseUrl: 'wss://api.example.com',
		* WebSocket: WebSocket as unknown as WebSocketConstructor,
		* });
		* ```
		*/
		export declare function createWebSocketTransport(config: WebSocketConfig): Transport;
		//# sourceMappingURL=websocket.d.ts.map

-1

dist/transports/websocket.d.ts.map

{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/transports/websocket.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,YAAY,EACb,MAAM,aAAa,CAAC;AAMrB;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;CACnE;AAED;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,oBAAoB,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,SAAS;IAClD,QAAQ,CAAC,IAAI,eAAe;IAE5B,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAC,CAAqB;IACtC,OAAO,CAAC,EAAE,CAAC,CAAY;IACvB,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,cAAc,CAAC,CAAgC;IACvD,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,aAAa,CAA+C;IAEpE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAW;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAE9C,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuB;gBAEzC,MAAM,EAAE,eAAe;IAiBnC,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED,OAAO,CAAC,QAAQ;IAYhB;;OAEG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;YAmBhE,gBAAgB;IAuD9B,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;OAEG;IACG,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9C;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI;IAO7D;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,MAAM,IAAI;IAOpE,OAAO,CAAC,aAAa;CAStB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAE3E"}

-239

dist/transports/websocket.js

		/**
		* WebSocket Transport - Alternative transport implementation
		*
		* Bidirectional communication over WebSocket.
		* Use when you need lower latency or when SSE is not available.
		*
		* @module @tentickle/client/transports/websocket
		*/
		/**
		* WebSocket Transport implementation.
		*
		* Use this when:
		* - You need bidirectional real-time communication
		* - SSE is blocked or unavailable
		* - You want lower latency
		*/
		export class WebSocketTransport {
		name = "websocket";
		_state = "disconnected";
		sessionId;
		metadata;
		ws;
		reconnectAttempts = 0;
		reconnectTimer;
		receiveHandlers = new Set();
		stateHandlers = new Set();
		wsUrl;
		protocols;
		token;
		reconnectDelay;
		maxReconnectAttempts;
		/** Custom WebSocket constructor (defaults to global WebSocket) */
		WebSocketCtor;
		constructor(config) {
		// Convert HTTP URL to WebSocket URL if needed
		const baseUrl = config.wsUrl ?? config.baseUrl;
		this.wsUrl = baseUrl
		.replace(/^http:/, "ws:")
		.replace(/^https:/, "wss:")
		.replace(/\/$/, "");
		this.protocols = config.protocols;
		this.token = config.token;
		this.reconnectDelay = config.reconnectDelay ?? 1000;
		this.maxReconnectAttempts = config.maxReconnectAttempts ?? 10;
		// Use custom implementation or fall back to global
		this.WebSocketCtor = config.WebSocket ?? globalThis.WebSocket;
		}
		get state() {
		return this._state;
		}
		setState(state) {
		if (this._state === state)
		return;
		this._state = state;
		for (const handler of this.stateHandlers) {
		try {
		handler(state);
		}
		catch (error) {
		console.error("Error in state handler:", error);
		}
		}
		}
		/**
		* Connect to WebSocket server.
		*/
		async connect(sessionId, metadata) {
		if (this._state === "connected") {
		throw new Error("Already connected");
		}
		this.sessionId = sessionId;
		this.metadata = metadata;
		this.reconnectAttempts = 0;
		this.setState("connecting");
		try {
		await this.connectWebSocket();
		this.setState("connected");
		}
		catch (error) {
		this.setState("error");
		throw error;
		}
		}
		async connectWebSocket() {
		if (!this.sessionId) {
		throw new Error("Session ID required");
		}
		// Close existing connection
		this.closeWebSocket();
		// Build WebSocket URL with query params
		const url = new URL(this.wsUrl);
		url.searchParams.set("sessionId", this.sessionId);
		if (this.metadata?.userId) {
		url.searchParams.set("userId", String(this.metadata.userId));
		}
		if (this.token) {
		url.searchParams.set("token", this.token);
		}
		return new Promise((resolve, reject) => {
		try {
		this.ws = new this.WebSocketCtor(url.toString(), this.protocols);
		this.ws.onopen = () => {
		this.reconnectAttempts = 0;
		resolve();
		};
		this.ws.onmessage = (event) => {
		try {
		const channelEvent = JSON.parse(event.data);
		this.notifyReceive(channelEvent);
		}
		catch (error) {
		console.error("Failed to parse WebSocket message:", error);
		}
		};
		this.ws.onerror = () => {
		if (this._state === "connecting") {
		reject(new Error("WebSocket connection failed"));
		}
		};
		this.ws.onclose = () => {
		if (this._state === "disconnected") {
		// Intentional disconnect
		return;
		}
		this.handleReconnect();
		};
		}
		catch (error) {
		reject(error);
		}
		});
		}
		handleReconnect() {
		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
		console.error("Max reconnection attempts reached");
		this.setState("error");
		return;
		}
		this.reconnectAttempts++;
		const delay = this.reconnectDelay * Math.min(this.reconnectAttempts, 5);
		this.reconnectTimer = setTimeout(() => {
		if (this.sessionId && this._state !== "disconnected") {
		this.connectWebSocket()
		.then(() => this.setState("connected"))
		.catch((error) => {
		console.error("Reconnection failed:", error);
		});
		}
		}, delay);
		}
		closeWebSocket() {
		if (this.ws) {
		this.ws.close();
		this.ws = undefined;
		}
		}
		/**
		* Disconnect from server.
		*/
		async disconnect() {
		if (this.reconnectTimer) {
		clearTimeout(this.reconnectTimer);
		this.reconnectTimer = undefined;
		}
		this.setState("disconnected"); // Set before close to prevent reconnect
		this.closeWebSocket();
		this.sessionId = undefined;
		this.metadata = undefined;
		this.reconnectAttempts = 0;
		}
		/**
		* Send event via WebSocket.
		*/
		async send(event) {
		if (!this.ws \|\| this._state !== "connected") {
		throw new Error("Not connected");
		}
		this.ws.send(JSON.stringify({
		...event,
		metadata: {
		...event.metadata,
		sessionId: this.sessionId,
		userId: this.metadata?.userId,
		timestamp: Date.now(),
		},
		}));
		}
		/**
		* Register receive handler.
		*/
		onReceive(handler) {
		this.receiveHandlers.add(handler);
		return () => {
		this.receiveHandlers.delete(handler);
		};
		}
		/**
		* Register state change handler.
		*/
		onStateChange(handler) {
		this.stateHandlers.add(handler);
		return () => {
		this.stateHandlers.delete(handler);
		};
		}
		notifyReceive(event) {
		for (const handler of this.receiveHandlers) {
		try {
		handler(event);
		}
		catch (error) {
		console.error("Error in receive handler:", error);
		}
		}
		}
		}
		/**
		* Create WebSocket transport.
		*
		* @example
		* ```typescript
		* // Browser usage
		* const transport = createWebSocketTransport({
		* baseUrl: 'wss://api.example.com',
		* });
		*
		* // Node.js with ws package
		* import WebSocket from 'ws';
		*
		* const nodeTransport = createWebSocketTransport({
		* baseUrl: 'wss://api.example.com',
		* WebSocket: WebSocket as unknown as WebSocketConstructor,
		* });
		* ```
		*/
		export function createWebSocketTransport(config) {
		return new WebSocketTransport(config);
		}
		//# sourceMappingURL=websocket.js.map

-1

dist/transports/websocket.js.map

@agentick/client - npm Package Compare versions

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes