@agentuity/frontend 1.0.48 → 2.0.0-beta.0

package/src/client/eventstream.ts

@@ -1,52 +0,0 @@
-import type { EventHandler, EventStreamClient } from './types';
-
-/**
- * Create an EventSource (SSE) client wrapper with event-based API.
- *
- * Note: Native EventSource has limited authentication support.
- * - withCredentials: true will send cookies and HTTP auth headers
- * - For custom Authorization headers, consider using @microsoft/fetch-event-source
- */
-export function createEventStreamClient(
-	url: string,
-	options?: { withCredentials?: boolean }
-): EventStreamClient {
-	const eventSource = new EventSource(url, {
-		withCredentials: options?.withCredentials ?? false,
-	});
-	const handlers: {
-		message: Set<EventHandler<MessageEvent>>;
-		open: Set<EventHandler<Event>>;
-		error: Set<EventHandler<Event>>;
-	} = {
-		message: new Set(),
-		open: new Set(),
-		error: new Set(),
-	};
-
-	// Set up native EventSource event listeners
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	eventSource.onmessage = (event: any) => {
-		handlers.message.forEach((handler) => handler(event));
-	};
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	eventSource.onopen = (event: any) => {
-		handlers.open.forEach((handler) => handler(event));
-	};
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	eventSource.onerror = (event: any) => {
-		handlers.error.forEach((handler) => handler(event));
-	};
-
-	return {
-		on: ((event: 'message' | 'open' | 'error', handler: EventHandler) => {
-			handlers[event].add(handler);
-		}) as EventStreamClient['on'],
-
-		close() {
-			eventSource.close();
-		},
-	};
-}

package/src/client/index.ts

@@ -1,267 +0,0 @@
-import type { Client, ClientOptions } from './types';
-import { createWebSocketClient } from './websocket';
-import { createEventStreamClient } from './eventstream';
-import { createStreamClient } from './stream';
-
-/**
- * Default base URL (empty = relative URLs).
- */
-const defaultBaseUrl = '';
-
-/**
- * Resolve baseUrl - if it's a function, call it; otherwise return the string.
- */
-function resolveBaseUrl(baseUrl: string | (() => string)): string {
-	return typeof baseUrl === 'function' ? baseUrl() : baseUrl;
-}
-
-/**
- * Resolve headers - if it's a function, call it; otherwise return the object.
- */
-function resolveHeaders(
-	headers: Record<string, string> | (() => Record<string, string>)
-): Record<string, string> {
-	return typeof headers === 'function' ? headers() : headers;
-}
-
-/**
- * Escape special regex characters in a string.
- */
-function escapeRegExp(str: string): string {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Substitute path parameters in a URL path template.
- * E.g., '/api/users/:id' with { id: '123' } becomes '/api/users/123'
- */
-function substitutePathParams(pathTemplate: string, pathParams?: Record<string, string>): string {
-	if (!pathParams) return pathTemplate;
-
-	let result = pathTemplate;
-	for (const [key, value] of Object.entries(pathParams)) {
-		const escapedKey = escapeRegExp(key);
-		result = result.replace(new RegExp(`:${escapedKey}\\??`, 'g'), encodeURIComponent(value));
-		result = result.replace(new RegExp(`\\*${escapedKey}`, 'g'), encodeURIComponent(value));
-	}
-	return result;
-}
-
-/**
- * Build URL with query params.
- */
-function buildUrlWithQuery(baseUrl: string, path: string, query?: Record<string, string>): string {
-	const url = `${baseUrl}${path}`;
-	if (!query || Object.keys(query).length === 0) return url;
-
-	const params = new URLSearchParams(query);
-	return `${url}?${params.toString()}`;
-}
-
-/**
- * Create a type-safe API client from a RouteRegistry.
- *
- * Uses a Proxy to build up the path as you navigate the object,
- * then executes the request when you call a terminal method (.post(), .get(), .websocket(), etc.).
- *
- * @example
- * ```typescript
- * import { createClient } from '@agentuity/frontend';
- * import type { RPCRouteRegistry } from './generated/routes';
- *
- * const client = createClient<RPCRouteRegistry>();
- *
- * // Type-safe API call
- * const result = await client.hello.post({ name: 'World' });
- *
- * // WebSocket
- * const ws = client.chat.websocket();
- * ws.on('message', (msg) => console.log(msg));
- *
- * // Server-Sent Events
- * const es = client.events.eventstream();
- * es.on('message', (event) => console.log(event.data));
- *
- * // Streaming response
- * const stream = await client.data.stream({ query: 'foo' });
- * stream.on('chunk', (chunk) => console.log(chunk));
- * ```
- */
-export function createClient<R>(options: ClientOptions = {}, metadata?: unknown): Client<R> {
-	const { baseUrl = defaultBaseUrl, headers, contentType = 'application/json', signal } = options;
-
-	// Default headers to empty object if not provided
-	const defaultHeaders = headers || {};
-
-	const handler: ProxyHandler<{ __path: string[]; __type?: string }> = {
-		get(target, prop: string) {
-			const currentPath = target.__path;
-			const newPath = [...currentPath, prop];
-
-			// Check if this is a terminal method
-			const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
-			const streamMethods = ['websocket', 'eventstream', 'stream'];
-			const isHttpMethod = httpMethods.includes(prop);
-			const isStreamMethod = streamMethods.includes(prop);
-			const isTerminalMethod = isHttpMethod || isStreamMethod;
-
-			// Terminal: method at the end (minimum 1 path segment required)
-			// Examples: client.hello.post(), client.echo.websocket(), client.events.eventstream()
-			if (isTerminalMethod && currentPath.length >= 1) {
-				const method = prop;
-				const pathSegments = currentPath;
-
-				// Look up route metadata
-				let routeType = 'api';
-				let routePath: string | undefined;
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				let metaNode: any = metadata;
-
-				if (isStreamMethod) {
-					// Stream methods directly specify the route type
-					if (method === 'websocket') routeType = 'websocket';
-					else if (method === 'eventstream') routeType = 'sse';
-					else if (method === 'stream') routeType = 'stream';
-				}
-
-				if (metadata) {
-					for (const segment of pathSegments) {
-						if (metaNode && typeof metaNode === 'object') {
-							metaNode = metaNode[segment];
-						}
-					}
-					if (metaNode && typeof metaNode === 'object' && metaNode[method]) {
-						if (metaNode[method].type) {
-							routeType = metaNode[method].type;
-						}
-						if (metaNode[method].path) {
-							routePath = metaNode[method].path;
-						}
-					}
-				}
-
-				// Fallback URL path if no metadata
-				const fallbackPath = '/api/' + pathSegments.join('/');
-
-				return (...args: unknown[]) => {
-					const resolvedBaseUrl = resolveBaseUrl(baseUrl);
-					const resolvedHeaders = resolveHeaders(defaultHeaders);
-
-					// Get path param names from metadata if available
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					const pathParamNames: string[] | undefined = (metaNode as any)?.[method]?.pathParams;
-					const hasPathParams = pathParamNames && pathParamNames.length > 0;
-
-					let pathParams: Record<string, string> | undefined;
-					let input: unknown;
-					let query: Record<string, string> | undefined;
-
-					if (hasPathParams) {
-						// Route has path params - positional arguments API
-						// Args are: param1, param2, ..., [options?]
-						// Example: client.user.get('123', 12) or client.user.get('123', 12, { query: {...} })
-						pathParams = {};
-
-						for (let i = 0; i < pathParamNames.length; i++) {
-							const paramName = pathParamNames[i];
-							if (paramName === undefined) continue;
-							const arg = args[i];
-							if (arg === undefined || arg === null) {
-								throw new Error(
-									`Missing required path parameter '${paramName}' at position ${i + 1}. ` +
-										`Expected ${pathParamNames.length} path parameter(s): ${pathParamNames.join(', ')}`
-								);
-							}
-							pathParams[paramName] = String(arg);
-						}
-
-						// Check if there's an options object after the path params
-						const optionsArg = args[pathParamNames.length];
-						if (optionsArg && typeof optionsArg === 'object') {
-							// eslint-disable-next-line @typescript-eslint/no-explicit-any
-							const opts = optionsArg as any;
-							input = opts.input;
-							query = opts.query;
-						}
-					} else {
-						// No path params - use existing behavior
-						const options = args[0];
-						// eslint-disable-next-line @typescript-eslint/no-explicit-any
-						const opts = options as any;
-						const isOptionsObject =
-							opts && typeof opts === 'object' && ('input' in opts || 'query' in opts);
-
-						input = isOptionsObject ? opts.input : options;
-						query = isOptionsObject ? opts.query : undefined;
-					}
-
-					// Substitute path params in the route path
-					const basePath = routePath || fallbackPath;
-					const urlPath = substitutePathParams(basePath, pathParams);
-
-					// WebSocket endpoint
-					if (routeType === 'websocket') {
-						const wsBaseUrl = resolvedBaseUrl.replace(/^http/, 'ws');
-						const wsUrl = buildUrlWithQuery(wsBaseUrl, urlPath, query);
-						const ws = createWebSocketClient(wsUrl);
-						if (input) {
-							ws.on('open', () => ws.send(input));
-						}
-						return ws;
-					}
-
-					// SSE endpoint
-					if (routeType === 'sse') {
-						const sseUrl = buildUrlWithQuery(resolvedBaseUrl, urlPath, query);
-						return createEventStreamClient(sseUrl, {
-							withCredentials: Object.keys(resolvedHeaders).length > 0,
-						});
-					}
-
-					// Stream endpoint
-					if (routeType === 'stream') {
-						const streamUrl = buildUrlWithQuery(resolvedBaseUrl, urlPath, query);
-						return fetch(streamUrl, {
-							method: method.toUpperCase(),
-							headers: { 'Content-Type': contentType, ...resolvedHeaders },
-							body: input ? JSON.stringify(input) : undefined,
-							signal,
-						}).then((res) => {
-							if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-							return createStreamClient(res);
-						});
-					}
-
-					// Regular API endpoint
-					const apiUrl = buildUrlWithQuery(resolvedBaseUrl, urlPath, query);
-					return fetch(apiUrl, {
-						method: method.toUpperCase(),
-						headers: { 'Content-Type': contentType, ...resolvedHeaders },
-						body: method.toUpperCase() !== 'GET' && input ? JSON.stringify(input) : undefined,
-						signal,
-					}).then(async (res) => {
-						if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-						if (res.status === 204) return undefined;
-						return res.json();
-					});
-				};
-			}
-
-			// Otherwise, return a new proxy with extended path
-			return new Proxy({ __path: newPath }, handler);
-		},
-	};
-
-	return new Proxy({ __path: [] }, handler) as unknown as Client<R>;
-}
-
-// Re-export types
-export type {
-	ClientOptions,
-	Client,
-	RouteEndpoint,
-	WebSocketClient,
-	EventStreamClient,
-	StreamClient,
-	EventHandler,
-} from './types';

package/src/client/stream.ts

@@ -1,61 +0,0 @@
-import type { EventHandler, StreamClient } from './types';
-
-/**
- * Create a streaming response reader with event-based API.
- */
-export function createStreamClient(response: Response): StreamClient {
-	const handlers: {
-		chunk: Set<EventHandler<Uint8Array>>;
-		close: Set<EventHandler<void>>;
-		error: Set<EventHandler<Error>>;
-	} = {
-		chunk: new Set(),
-		close: new Set(),
-		error: new Set(),
-	};
-
-	const reader = response.body?.getReader();
-	let cancelled = false;
-
-	// Start reading the stream
-	const readStream = async () => {
-		if (!reader) {
-			const error = new Error('Response body is not readable');
-			handlers.error.forEach((handler) => handler(error));
-			return;
-		}
-
-		try {
-			while (!cancelled) {
-				const { done, value } = await reader.read();
-
-				if (done) {
-					handlers.close.forEach((handler) => handler());
-					break;
-				}
-
-				if (value) {
-					handlers.chunk.forEach((handler) => handler(value));
-				}
-			}
-		} catch (error) {
-			const err = error instanceof Error ? error : new Error(String(error));
-			handlers.error.forEach((handler) => handler(err));
-		}
-	};
-
-	// Start reading immediately
-	readStream();
-
-	return {
-		on: ((event: 'chunk' | 'close' | 'error', handler: EventHandler) => {
-			handlers[event].add(handler as EventHandler<Uint8Array | void | Error>);
-		}) as StreamClient['on'],
-
-		async cancel() {
-			cancelled = true;
-			await reader?.cancel();
-			handlers.close.forEach((handler) => handler());
-		},
-	};
-}

package/src/client/types.ts

@@ -1,237 +0,0 @@
-/**
- * Type-safe API client types for RPC-style invocations.
- */
-
-/**
- * Options for creating a client.
- */
-export interface ClientOptions {
-	/**
-	 * Base URL for API requests (e.g., "https://p1234567890.agenuity.run").
-	 * Defaults to empty string (relative URLs).
-	 * Can be a string or a function that returns a string for lazy resolution.
-	 */
-	baseUrl?: string | (() => string);
-
-	/**
-	 * Default headers to include in all requests.
-	 * Can be a static object or a function that returns headers for dynamic resolution (e.g., auth tokens).
-	 */
-	headers?: Record<string, string> | (() => Record<string, string>);
-
-	/**
-	 * Content-Type header for request bodies.
-	 * @default "application/json"
-	 */
-	contentType?: string;
-
-	/**
-	 * AbortSignal for request cancellation.
-	 */
-	signal?: AbortSignal;
-}
-
-/**
- * Event handler for streaming responses.
- */
-export type EventHandler<T = unknown> = (data: T) => void;
-
-/**
- * WebSocket wrapper with event-based API.
- */
-export interface WebSocketClient {
-	/**
-	 * Register an event handler.
-	 */
-	on: {
-		(event: 'message', handler: EventHandler<unknown>): void;
-		(event: 'open', handler: EventHandler<Event>): void;
-		(event: 'close', handler: EventHandler<CloseEvent>): void;
-		(event: 'error', handler: EventHandler<Event>): void;
-	};
-
-	/**
-	 * Send data through the WebSocket.
-	 */
-	send(data: unknown): void;
-
-	/**
-	 * Close the WebSocket connection.
-	 */
-	close(code?: number, reason?: string): void;
-}
-
-/**
- * Server-Sent Events (SSE) client with event-based API.
- */
-export interface EventStreamClient {
-	/**
-	 * Register an event handler.
-	 */
-	on: {
-		(event: 'message', handler: EventHandler<MessageEvent>): void;
-		(event: 'open', handler: EventHandler<Event>): void;
-		(event: 'error', handler: EventHandler<Event>): void;
-	};
-
-	/**
-	 * Close the EventSource connection.
-	 */
-	close(): void;
-}
-
-/**
- * Streaming response reader with event-based API.
- */
-export interface StreamClient {
-	/**
-	 * Register an event handler.
-	 */
-	on: {
-		(event: 'chunk', handler: EventHandler<Uint8Array>): void;
-		(event: 'close', handler: EventHandler<void>): void;
-		(event: 'error', handler: EventHandler<Error>): void;
-	};
-
-	/**
-	 * Cancel the stream.
-	 */
-	cancel(): Promise<void>;
-}
-
-/**
- * Options object for endpoints without path params (optional query support).
- */
-export interface EndpointOptionsWithQuery<Input = unknown, Query = Record<string, string>> {
-	input?: Input;
-	query?: Query;
-}
-
-/**
- * Additional options that can be passed after positional path params.
- */
-export interface EndpointExtraOptions<Input = unknown, Query = Record<string, string>> {
-	input?: Input;
-	query?: Query;
-}
-
-/**
- * Convert a path params object to a tuple of its value types.
- * Used for positional argument typing.
- * Note: For proper ordering, we rely on the generated PathParamsTuple type.
- */
-export type PathParamsToTuple<P> = P extends readonly [infer First, ...infer Rest]
-	? [First, ...PathParamsToTuple<Rest>]
-	: P extends readonly []
-		? []
-		: string[];
-
-/**
- * API endpoint - callable function for regular HTTP calls.
- * - Without path params: accepts input directly OR options object with query
- * - With path params: accepts positional arguments followed by optional options object
- *
- * @example
- * // No path params
- * client.hello.post({ name: 'World' })
- *
- * // Single path param
- * client.users.userId.get('123')
- *
- * // Multiple path params
- * client.orgs.orgId.members.memberId.get('org-1', 'user-2')
- *
- * // With additional options
- * client.users.userId.get('123', { query: { include: 'posts' } })
- */
-export type APIEndpoint<
-	Input = unknown,
-	Output = unknown,
-	PathParams = never,
-	PathParamsTuple extends unknown[] = string[],
-> = [PathParams] extends [never]
-	? (inputOrOptions?: Input | EndpointOptionsWithQuery<Input>) => Promise<Output>
-	: (...args: [...PathParamsTuple, options?: EndpointExtraOptions<Input>]) => Promise<Output>;
-
-/**
- * WebSocket endpoint - callable function that returns WebSocket client.
- */
-export type WebSocketEndpoint<
-	Input = unknown,
-	_Output = unknown,
-	PathParams = never,
-	PathParamsTuple extends unknown[] = string[],
-> = [PathParams] extends [never]
-	? (inputOrOptions?: Input | EndpointOptionsWithQuery<Input>) => WebSocketClient
-	: (...args: [...PathParamsTuple, options?: EndpointExtraOptions<Input>]) => WebSocketClient;
-
-/**
- * Server-Sent Events endpoint - callable function that returns EventStream client.
- */
-export type SSEEndpoint<
-	Input = unknown,
-	_Output = unknown,
-	PathParams = never,
-	PathParamsTuple extends unknown[] = string[],
-> = [PathParams] extends [never]
-	? (inputOrOptions?: Input | EndpointOptionsWithQuery<Input>) => EventStreamClient
-	: (...args: [...PathParamsTuple, options?: EndpointExtraOptions<Input>]) => EventStreamClient;
-
-/**
- * Streaming endpoint - callable function that returns Stream client.
- */
-export type StreamEndpoint<
-	Input = unknown,
-	_Output = unknown,
-	PathParams = never,
-	PathParamsTuple extends unknown[] = string[],
-> = [PathParams] extends [never]
-	? (inputOrOptions?: Input | EndpointOptionsWithQuery<Input>) => StreamClient
-	: (...args: [...PathParamsTuple, options?: EndpointExtraOptions<Input>]) => StreamClient;
-
-/**
- * Route endpoint - discriminated union based on route type.
- */
-export type RouteEndpoint<
-	Input = unknown,
-	Output = unknown,
-	Type extends string = 'api',
-	PathParams = never,
-	PathParamsTuple extends unknown[] = [],
-> = Type extends 'websocket'
-	? WebSocketEndpoint<Input, Output, PathParams, PathParamsTuple>
-	: Type extends 'sse'
-		? SSEEndpoint<Input, Output, PathParams, PathParamsTuple>
-		: Type extends 'stream'
-			? StreamEndpoint<Input, Output, PathParams, PathParamsTuple>
-			: APIEndpoint<Input, Output, PathParams, PathParamsTuple>;
-
-/**
- * Recursively build the client proxy type from a RouteRegistry.
- */
-export type Client<R> = {
-	[K in keyof R]: R[K] extends {
-		input: infer I;
-		output: infer O;
-		type: infer T;
-		params: infer P;
-		paramsTuple: infer PT;
-	}
-		? PT extends unknown[]
-			? RouteEndpoint<I, O, T extends string ? T : 'api', P, PT>
-			: RouteEndpoint<I, O, T extends string ? T : 'api', P>
-		: R[K] extends {
-					input: infer I;
-					output: infer O;
-					type: infer T;
-					params: infer P;
-				}
-			? RouteEndpoint<I, O, T extends string ? T : 'api', P>
-			: R[K] extends { input: infer I; output: infer O; type: infer T }
-				? RouteEndpoint<I, O, T extends string ? T : 'api'>
-				: R[K] extends { input: infer I; output: infer O }
-					? RouteEndpoint<I, O, 'api'>
-					: R[K] extends object
-						? Client<R[K]>
-						: never;
-};

package/src/client/websocket.ts

@@ -1,61 +0,0 @@
-import type { EventHandler, WebSocketClient } from './types';
-
-/**
- * Create a WebSocket client wrapper with event-based API.
- */
-export function createWebSocketClient(url: string, protocols?: string | string[]): WebSocketClient {
-	const ws = new WebSocket(url, protocols);
-	const handlers: {
-		message: Set<EventHandler<unknown>>;
-		open: Set<EventHandler<Event>>;
-		close: Set<EventHandler<CloseEvent>>;
-		error: Set<EventHandler<Event>>;
-	} = {
-		message: new Set(),
-		open: new Set(),
-		close: new Set(),
-		error: new Set(),
-	};
-
-	// Set up native WebSocket event listeners
-	ws.addEventListener('message', (event: MessageEvent) => {
-		let data: unknown = event.data;
-		// Try to parse JSON if data is a string
-		if (typeof event.data === 'string') {
-			try {
-				data = JSON.parse(event.data);
-			} catch {
-				// Keep as string if not valid JSON
-				data = event.data;
-			}
-		}
-		handlers.message.forEach((handler) => handler(data));
-	});
-
-	ws.addEventListener('open', (event: Event) => {
-		handlers.open.forEach((handler) => handler(event));
-	});
-
-	ws.addEventListener('close', (event: CloseEvent) => {
-		handlers.close.forEach((handler) => handler(event));
-	});
-
-	ws.addEventListener('error', (event: Event) => {
-		handlers.error.forEach((handler) => handler(event));
-	});
-
-	return {
-		on: ((event: 'message' | 'open' | 'close' | 'error', handler: EventHandler) => {
-			handlers[event].add(handler as EventHandler<unknown | Event | CloseEvent>);
-		}) as WebSocketClient['on'],
-
-		send(data: unknown) {
-			const payload = typeof data === 'string' ? data : JSON.stringify(data);
-			ws.send(payload);
-		},
-
-		close(code?: number, reason?: string) {
-			ws.close(code, reason);
-		},
-	};
-}