@agentuity/react 1.0.48 → 2.0.0-beta.0

package/src/client.ts

@@ -1,136 +0,0 @@
-import {
-	createClient as coreCreateClient,
-	type Client,
-	type ClientOptions,
-	type RPCRouteRegistry,
-} from '@agentuity/frontend';
-
-// Re-export RPCRouteRegistry for backwards compatibility
-// The canonical definition is in @agentuity/frontend
-export type { RPCRouteRegistry };
-
-let globalBaseUrl: string | undefined;
-let globalAuthHeader: string | null | undefined;
-
-/**
- * Set the global base URL for RPC clients.
- * This is automatically called by AgentuityProvider.
- * @internal
- */
-export function setGlobalBaseUrl(url: string): void {
-	globalBaseUrl = url;
-}
-
-/**
- * Get the global base URL for RPC clients.
- * Returns the configured base URL or falls back to window.location.origin.
- * @internal
- */
-export function getGlobalBaseUrl(): string {
-	return globalBaseUrl || (typeof window !== 'undefined' ? window.location.origin : '');
-}
-
-/**
- * Set the global auth header for RPC clients.
- * This is automatically called by AgentuityProvider when auth state changes.
- * @internal
- */
-export function setGlobalAuthHeader(authHeader: string | null): void {
-	globalAuthHeader = authHeader;
-}
-
-/**
- * Get the global auth header for RPC clients.
- * Returns the current auth header or undefined if not set.
- * @internal
- */
-export function getGlobalAuthHeader(): string | null | undefined {
-	return globalAuthHeader;
-}
-
-/**
- * Create a type-safe RPC client for React applications.
- *
- * This is a React-specific wrapper around @agentuity/core's createClient that
- * automatically uses the baseUrl and auth headers from AgentuityProvider context.
- *
- * @example
- * ```typescript
- * import { createClient } from '@agentuity/react';
- * import type { RPCRouteRegistry } from '@agentuity/react';
- *
- * const client = createClient<RPCRouteRegistry>();
- *
- * // Inside component
- * const result = await client.hello.post({ name: 'World' });
- * ```
- */
-export function createClient<R>(
-	options?: Omit<ClientOptions, 'baseUrl' | 'headers'> & {
-		baseUrl?: string | (() => string);
-		headers?: Record<string, string> | (() => Record<string, string>);
-	},
-	metadata?: unknown
-): Client<R> {
-	// Merge user headers with auth headers
-	// User-provided headers take precedence over global auth header
-	const mergedHeaders = (): Record<string, string> => {
-		const authHeader = getGlobalAuthHeader();
-		const userHeaders =
-			typeof options?.headers === 'function' ? options.headers() : options?.headers || {};
-
-		const headers: Record<string, string> = {};
-
-		// Add global auth header first (lower priority)
-		if (authHeader) {
-			headers.Authorization = authHeader;
-		}
-
-		// User headers override global auth
-		return { ...headers, ...userHeaders };
-	};
-
-	return coreCreateClient<R>(
-		{
-			...options,
-			baseUrl: (options?.baseUrl || getGlobalBaseUrl) as string | (() => string),
-			headers: mergedHeaders,
-		} as ClientOptions,
-		metadata
-	);
-}
-
-/**
- * Create a type-safe API client with optional configuration.
- *
- * This is the recommended way to create an API client in React applications.
- * It automatically includes auth headers from AgentuityProvider and allows
- * custom headers to be passed.
- *
- * The generic type parameter defaults to RPCRouteRegistry which is augmented
- * by generated code, so you don't need to specify it manually.
- *
- * @example
- * ```typescript
- * import { createAPIClient } from '@agentuity/react';
- *
- * // Types are automatically inferred from generated routes
- * const api = createAPIClient();
- * await api.hello.post({ name: 'World' });
- *
- * // With custom headers
- * const api = createAPIClient({ headers: { 'X-Custom': 'value' } });
- * await api.hello.post({ name: 'World' });
- * ```
- */
-export function createAPIClient<R = RPCRouteRegistry>(
-	options?: Omit<ClientOptions, 'baseUrl' | 'headers'> & {
-		baseUrl?: string | (() => string);
-		headers?: Record<string, string> | (() => Record<string, string>);
-	}
-): Client<R> {
-	// This function is designed to be used with generated metadata
-	// The metadata will be provided by the code generator
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return createClient<R>(options, (globalThis as any).__rpcRouteMetadata);
-}

package/src/eventstream.ts

@@ -1,188 +0,0 @@
-import type { InferOutput } from '@agentuity/core';
-import {
-	buildUrl,
-	EventStreamManager,
-	jsonEqual,
-	type SSERouteRegistry,
-} from '@agentuity/frontend';
-import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
-import { AgentuityContext } from './context';
-
-/**
- * Extract SSE route keys (e.g., '/events', '/notifications')
- */
-export type SSERouteKey = keyof SSERouteRegistry;
-
-/**
- * Extract output type for an SSE route (SSE is typically one-way server->client)
- */
-export type SSERouteOutput<TRoute extends SSERouteKey> = TRoute extends keyof SSERouteRegistry
-	? SSERouteRegistry[TRoute] extends { outputSchema: infer TSchema }
-		? TSchema extends undefined | never
-			? void
-			: InferOutput<TSchema>
-		: void
-	: void;
-
-/**
- * Options for EventStream hooks
- */
-export interface EventStreamOptions {
-	/**
-	 * Optional query parameters to append to the EventStream URL
-	 */
-	query?: URLSearchParams;
-	/**
-	 * Optional subpath to append to the EventStream path
-	 */
-	subpath?: string;
-	/**
-	 * Optional AbortSignal to cancel the EventStream connection
-	 */
-	signal?: AbortSignal;
-}
-
-/**
- * Type-safe EventStream (SSE) hook for connecting to SSE routes.
- *
- * Provides automatic type inference for route outputs based on
- * the SSERouteRegistry generated from your routes.
- *
- * @template TRoute - SSE route key from SSERouteRegistry (e.g., '/events', '/notifications')
- * @template TOutput - Optional type override for SSE event data. When provided, this type
- *   is used instead of the inferred type from the route registry. This is useful for SSE
- *   routes where outputSchema is `never` in the generated types.
- *
- * @example Simple SSE connection
- * ```typescript
- * const { isConnected, data } = useEventStream('/events');
- *
- * // data is fully typed based on route output schema!
- * ```
- *
- * @example SSE with query parameters
- * ```typescript
- * const { isConnected, data } = useEventStream('/notifications', {
- *   query: new URLSearchParams({ userId: '123' })
- * });
- * ```
- *
- * @example SSE with custom output type (when registry has outputSchema: never)
- * ```typescript
- * interface StreamMessage {
- *   type: 'token' | 'complete';
- *   content?: string;
- * }
- *
- * const { isConnected, data } = useEventStream<'/api/search', StreamMessage>('/api/search');
- *
- * // data is typed as StreamMessage | undefined
- * if (data?.type === 'token') {
- *   console.log(data.content);
- * }
- * ```
- */
-export function useEventStream<TRoute extends SSERouteKey, TOutput = SSERouteOutput<TRoute>>(
-	route: TRoute,
-	options?: EventStreamOptions
-): {
-	isConnected: boolean;
-	close: () => void;
-	data?: TOutput;
-	error: Error | null;
-	isError: boolean;
-	reset: () => void;
-	readyState: number;
-} {
-	const context = useContext(AgentuityContext);
-
-	if (!context) {
-		throw new Error('useEventStream must be used within a AgentuityProvider');
-	}
-
-	const managerRef = useRef<EventStreamManager<TOutput> | null>(null);
-
-	const [data, setData] = useState<TOutput>();
-	const [error, setError] = useState<Error | null>(null);
-	const [isError, setIsError] = useState(false);
-	const [isConnected, setIsConnected] = useState(false);
-	const [readyState, setReadyState] = useState<number>(2); // EventSource.CLOSED = 2
-
-	// Build EventStream URL
-	// Track both query object and its string representation to detect mutations.
-	// URLSearchParams can be mutated in-place without changing object identity,
-	// so we compare the string value to trigger recomputation when params change.
-	const _queryString = options?.query?.toString();
-	const esUrl = useMemo(
-		() => buildUrl(context.baseUrl!, route as string, options?.subpath, options?.query),
-		[context.baseUrl, route, options?.subpath, options?.query]
-	);
-
-	// Initialize manager and connect
-	useEffect(() => {
-		const manager = new EventStreamManager<TOutput>({
-			url: esUrl,
-			callbacks: {
-				onConnect: () => {
-					setIsConnected(true);
-					setError(null);
-					setIsError(false);
-					setReadyState(1); // EventSource.OPEN = 1
-				},
-				onDisconnect: () => {
-					setIsConnected(false);
-					setReadyState(2); // EventSource.CLOSED = 2
-				},
-				onError: (err) => {
-					setError(err);
-					setIsError(true);
-				},
-			},
-		});
-
-		// Set message handler with JSON memoization
-		manager.setMessageHandler((message) => {
-			setData((prev) => (prev !== undefined && jsonEqual(prev, message) ? prev : message));
-		});
-
-		manager.connect();
-		managerRef.current = manager;
-
-		return () => {
-			manager.dispose();
-			managerRef.current = null;
-		};
-	}, [esUrl]);
-
-	// Handle abort signal
-	useEffect(() => {
-		if (options?.signal) {
-			const listener = () => {
-				managerRef.current?.close();
-			};
-			options.signal.addEventListener('abort', listener);
-			return () => {
-				options.signal?.removeEventListener('abort', listener);
-			};
-		}
-	}, [options?.signal]);
-
-	const reset = useCallback(() => {
-		setError(null);
-		setIsError(false);
-	}, []);
-
-	const close = useCallback(() => {
-		managerRef.current?.close();
-	}, []);
-
-	return {
-		isConnected,
-		close,
-		data,
-		error,
-		isError,
-		reset,
-		readyState,
-	};
-}

package/src/types.ts

@@ -1,23 +0,0 @@
-/**
- * Route Registry Types for @agentuity/react
- *
- * These interfaces are re-exported from @agentuity/frontend and augmented by
- * generated code (src/generated/routes.ts) to provide type-safe routing for
- * useAPI, useWebsocket, useEventStream, and createAPIClient.
- *
- * @remarks
- * The generated code uses `declare module '@agentuity/frontend'` to augment
- * these interfaces. Since @agentuity/react re-exports them, the augmented
- * types are available when importing from either package.
- *
- * This design ensures that in monorepo setups with multiple node_modules,
- * TypeScript sees consistent types as long as @agentuity/frontend is properly
- * resolved (via hoisting or tsconfig paths).
- */
-
-export type {
-	RouteRegistry,
-	WebSocketRouteRegistry,
-	SSERouteRegistry,
-	RPCRouteRegistry,
-} from '@agentuity/frontend';

package/src/websocket.ts

@@ -1,241 +0,0 @@
-import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
-import type { InferInput, InferOutput } from '@agentuity/core';
-import { buildUrl, WebSocketManager, type WebSocketRouteRegistry } from '@agentuity/frontend';
-import { AgentuityContext } from './context';
-
-// WebSocket ready state constants for SSR compatibility
-// (WebSocket global may not exist during SSR)
-const WS_OPEN = 1;
-const WS_CLOSED = 3;
-
-/**
- * Extract WebSocket route keys (e.g., '/ws', '/chat')
- */
-export type WebSocketRouteKey = keyof WebSocketRouteRegistry;
-
-/**
- * Extract input type for a WebSocket route
- */
-export type WebSocketRouteInput<TRoute extends WebSocketRouteKey> =
-	TRoute extends keyof WebSocketRouteRegistry
-		? WebSocketRouteRegistry[TRoute] extends { inputSchema: infer TSchema }
-			? TSchema extends undefined | never
-				? never
-				: InferInput<TSchema>
-			: never
-		: never;
-
-/**
- * Extract output type for a WebSocket route
- */
-export type WebSocketRouteOutput<TRoute extends WebSocketRouteKey> =
-	TRoute extends keyof WebSocketRouteRegistry
-		? WebSocketRouteRegistry[TRoute] extends { outputSchema: infer TSchema }
-			? TSchema extends undefined | never
-				? void
-				: InferOutput<TSchema>
-			: void
-		: void;
-
-/**
- * Options for WebSocket hooks
- */
-export interface WebsocketOptions {
-	/**
-	 * Optional query parameters to append to the websocket URL
-	 */
-	query?: URLSearchParams;
-	/**
-	 * Optional subpath to append to the websocket path
-	 */
-	subpath?: string;
-	/**
-	 * Optional AbortSignal to cancel the websocket connection
-	 */
-	signal?: AbortSignal;
-	/**
-	 * Maximum number of messages to keep in the messages array.
-	 * When exceeded, oldest messages are removed.
-	 * @default undefined (no limit)
-	 */
-	maxMessages?: number;
-}
-
-/**
- * Type-safe WebSocket hook for connecting to WebSocket routes.
- *
- * Provides automatic type inference for route inputs and outputs based on
- * the WebSocketRouteRegistry generated from your routes.
- *
- * @template TRoute - WebSocket route key from WebSocketRouteRegistry (e.g., '/ws', '/chat')
- *
- * @example Simple WebSocket connection
- * ```typescript
- * const { isConnected, data, send } = useWebsocket('/ws');
- *
- * // Send typed data
- * send({ message: 'Hello' }); // Fully typed based on route schema!
- * ```
- *
- * @example WebSocket with query parameters
- * ```typescript
- * const { isConnected, data, send } = useWebsocket('/chat', {
- *   query: new URLSearchParams({ room: 'general' })
- * });
- * ```
- *
- * @example Access all messages (prevents message loss in rapid succession)
- * ```typescript
- * const { messages, clearMessages } = useWebsocket('/chat');
- *
- * // messages array contains ALL received messages
- * messages.forEach(msg => console.log(msg));
- *
- * // Clear messages when needed
- * clearMessages();
- * ```
- */
-export function useWebsocket<TRoute extends WebSocketRouteKey>(
-	route: TRoute,
-	options?: WebsocketOptions
-): {
-	isConnected: boolean;
-	close: () => void;
-	data?: WebSocketRouteOutput<TRoute>;
-	messages: WebSocketRouteOutput<TRoute>[];
-	clearMessages: () => void;
-	error: Error | null;
-	isError: boolean;
-	reset: () => void;
-	send: (data: WebSocketRouteInput<TRoute>) => void;
-	readyState: WebSocket['readyState'];
-} {
-	const context = useContext(AgentuityContext);
-
-	if (!context) {
-		throw new Error('useWebsocket must be used within a AgentuityProvider');
-	}
-
-	const managerRef = useRef<WebSocketManager<
-		WebSocketRouteInput<TRoute>,
-		WebSocketRouteOutput<TRoute>
-	> | null>(null);
-
-	const [data, setData] = useState<WebSocketRouteOutput<TRoute>>();
-	const [messages, setMessages] = useState<WebSocketRouteOutput<TRoute>[]>([]);
-	const [error, setError] = useState<Error | null>(null);
-	const [isError, setIsError] = useState(false);
-	const [isConnected, setIsConnected] = useState(false);
-	const [readyState, setReadyState] = useState<number>(WS_CLOSED);
-
-	// Build WebSocket URL
-	const wsUrl = useMemo(() => {
-		const base = context.baseUrl!;
-		const wsBase = base.replace(/^http(s?):/, 'ws$1:');
-
-		// Add auth token to query params if present
-		// (WebSocket doesn't support custom headers, so we pass via query string)
-		let queryParams = options?.query;
-		if (context.authHeader) {
-			const token = context.authHeader.replace(/^Bearer\s+/i, '');
-			const authQuery = new URLSearchParams({ token });
-			if (queryParams) {
-				queryParams = new URLSearchParams([...queryParams, ...authQuery]);
-			} else {
-				queryParams = authQuery;
-			}
-		}
-
-		return buildUrl(wsBase, route as string, options?.subpath, queryParams);
-	}, [context.baseUrl, context.authHeader, route, options?.subpath, options?.query]);
-
-	// Initialize manager and connect
-	useEffect(() => {
-		const manager = new WebSocketManager<
-			WebSocketRouteInput<TRoute>,
-			WebSocketRouteOutput<TRoute>
-		>({
-			url: wsUrl,
-			callbacks: {
-				onConnect: () => {
-					setIsConnected(true);
-					setError(null);
-					setIsError(false);
-					setReadyState(WS_OPEN);
-				},
-				onDisconnect: () => {
-					setIsConnected(false);
-					setReadyState(WS_CLOSED);
-				},
-				onError: (err) => {
-					setError(err);
-					setIsError(true);
-				},
-			},
-		});
-
-		// Set message handler
-		manager.setMessageHandler((message) => {
-			setData(message);
-			setMessages((prev) => {
-				const newMessages = [...prev, message];
-				// Enforce maxMessages limit if specified
-				if (options?.maxMessages && newMessages.length > options.maxMessages) {
-					return newMessages.slice(-options.maxMessages);
-				}
-				return newMessages;
-			});
-		});
-
-		manager.connect();
-		managerRef.current = manager;
-
-		return () => {
-			manager.dispose();
-			managerRef.current = null;
-		};
-	}, [wsUrl, options?.maxMessages]);
-
-	// Handle abort signal
-	useEffect(() => {
-		if (options?.signal) {
-			const listener = () => {
-				managerRef.current?.close();
-			};
-			options.signal.addEventListener('abort', listener);
-			return () => {
-				options.signal?.removeEventListener('abort', listener);
-			};
-		}
-	}, [options?.signal]);
-
-	const reset = useCallback(() => {
-		setError(null);
-		setIsError(false);
-	}, []);
-
-	const send = useCallback((sendData: WebSocketRouteInput<TRoute>) => {
-		managerRef.current?.send(sendData);
-	}, []);
-
-	const close = useCallback(() => {
-		managerRef.current?.close();
-	}, []);
-
-	const clearMessages = useCallback(() => {
-		setMessages([]);
-	}, []);
-
-	return {
-		isConnected,
-		close,
-		data,
-		messages,
-		clearMessages,
-		error,
-		isError,
-		reset,
-		send,
-		readyState,
-	};
-}