@useago/sdk 0.1.7 → 0.2.1

package/dist/AgoClient-D0l1GTRs.cjs

@@ -0,0 +1,976 @@
+//#region src/client/errors.ts
+/**
+* Base error class for AGO SDK
+*/
+var AgoError = class extends Error {
+	constructor(message, code, statusCode) {
+		super(message);
+		this.code = code;
+		this.statusCode = statusCode;
+		this.name = "AgoError";
+	}
+};
+/**
+* Error from API response
+*/
+var AgoApiError = class AgoApiError extends AgoError {
+	constructor(message, code, statusCode, type, param, docUrl) {
+		super(message, code, statusCode);
+		this.type = type;
+		this.param = param;
+		this.docUrl = docUrl;
+		this.name = "AgoApiError";
+	}
+	static fromResponse(data, statusCode) {
+		const error = data.error;
+		return new AgoApiError(error.message, error.code, statusCode, error.type, error.param, error.doc_url);
+	}
+};
+/**
+* Network/connection error
+*/
+var AgoNetworkError = class extends AgoError {
+	constructor(message, originalError) {
+		super(message, "network_error");
+		this.originalError = originalError;
+		this.name = "AgoNetworkError";
+	}
+};
+/**
+* SSE stream error
+*/
+var AgoStreamError = class extends AgoError {
+	constructor(message) {
+		super(message, "stream_error");
+		this.name = "AgoStreamError";
+	}
+};
+/**
+* Function execution error
+*/
+var AgoFunctionError = class extends AgoError {
+	constructor(message, functionName, originalError) {
+		super(message, "function_error");
+		this.functionName = functionName;
+		this.originalError = originalError;
+		this.name = "AgoFunctionError";
+	}
+};
+//#endregion
+//#region src/utils/logger.ts
+/**
+* Debug logger for SDK
+*/
+var Logger = class {
+	constructor(enabled = false) {
+		this.enabled = enabled;
+	}
+	enable() {
+		this.enabled = true;
+	}
+	disable() {
+		this.enabled = false;
+	}
+	log(...args) {
+		if (this.enabled) console.log("[AGO SDK]", ...args);
+	}
+	warn(...args) {
+		if (this.enabled) console.warn("[AGO SDK]", ...args);
+	}
+	error(...args) {
+		console.error("[AGO SDK]", ...args);
+	}
+	debug(...args) {
+		if (this.enabled) console.debug("[AGO SDK]", ...args);
+	}
+};
+var logger = new Logger();
+//#endregion
+//#region src/api/HttpClient.ts
+var WIDGET_ID_KEY = "ago_widget_id";
+function generateWidgetId() {
+	if (typeof localStorage !== "undefined") {
+		const stored = localStorage.getItem(WIDGET_ID_KEY);
+		if (stored) return stored;
+	}
+	const id = crypto.randomUUID();
+	if (typeof localStorage !== "undefined") try {
+		localStorage.setItem(WIDGET_ID_KEY, id);
+	} catch {}
+	return id;
+}
+/**
+* HTTP client with authentication headers
+*/
+var HttpClient = class {
+	constructor(config) {
+		this.baseUrl = config.baseUrl.replace(/\/$/, "");
+		this.headers = { "X-Widget-Id": config.widgetId || generateWidgetId() };
+		if (config.userEmail) this.headers["X-User-Email"] = config.userEmail;
+		if (config.userJwt) this.headers["Authorization"] = `Bearer ${config.userJwt}`;
+		if (config.permission) this.headers["X-Widget-Permission"] = config.permission;
+	}
+	/**
+	* Update configuration (e.g., JWT token)
+	*/
+	updateConfig(config) {
+		if (config.baseUrl) this.baseUrl = config.baseUrl.replace(/\/$/, "");
+		if (config.widgetId) this.headers["X-Widget-Id"] = config.widgetId;
+		if (config.userEmail) this.headers["X-User-Email"] = config.userEmail;
+		if (config.userJwt) this.headers["Authorization"] = `Bearer ${config.userJwt}`;
+		if (config.permission !== void 0) if (config.permission) this.headers["X-Widget-Permission"] = config.permission;
+		else delete this.headers["X-Widget-Permission"];
+	}
+	/**
+	* Make a GET request
+	*/
+	async get(path) {
+		return this.request("GET", path);
+	}
+	/**
+	* Make a POST request with JSON body
+	*/
+	async post(path, body) {
+		return this.request("POST", path, body);
+	}
+	/**
+	* Make a POST request and return the raw Response (for streaming)
+	*/
+	async postStream(path, body) {
+		const url = `${this.baseUrl}${path}`;
+		logger.debug("POST (stream)", url, body);
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					...this.headers,
+					"Content-Type": "application/json"
+				},
+				body: body ? JSON.stringify(body) : void 0
+			});
+			if (!response.ok) await this.handleErrorResponse(response);
+			return response;
+		} catch (error) {
+			if (error instanceof AgoApiError) throw error;
+			throw new AgoNetworkError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : void 0);
+		}
+	}
+	/**
+	* Make a POST request with FormData (for file uploads)
+	*/
+	async postFormData(path, formData) {
+		const url = `${this.baseUrl}${path}`;
+		logger.debug("POST (formData)", url);
+		const headers = { ...this.headers };
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers,
+				body: formData
+			});
+			if (!response.ok) await this.handleErrorResponse(response);
+			return response;
+		} catch (error) {
+			if (error instanceof AgoApiError) throw error;
+			throw new AgoNetworkError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : void 0);
+		}
+	}
+	async request(method, path, body) {
+		const url = `${this.baseUrl}${path}`;
+		logger.debug(method, url, body);
+		try {
+			const response = await fetch(url, {
+				method,
+				headers: {
+					...this.headers,
+					"Content-Type": "application/json"
+				},
+				body: body ? JSON.stringify(body) : void 0
+			});
+			if (!response.ok) await this.handleErrorResponse(response);
+			if (response.status === 204) return;
+			return response.json();
+		} catch (error) {
+			if (error instanceof AgoApiError) throw error;
+			throw new AgoNetworkError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : void 0);
+		}
+	}
+	async handleErrorResponse(response) {
+		let errorData;
+		try {
+			errorData = await response.json();
+		} catch {}
+		if (errorData?.error) throw AgoApiError.fromResponse(errorData, response.status);
+		throw new AgoApiError(`HTTP ${response.status}: ${response.statusText}`, "http_error", response.status, "api_error");
+	}
+};
+//#endregion
+//#region src/functions/FunctionRegistry.ts
+/**
+* Registry for client-side functions that AGO can call
+*/
+var FunctionRegistry = class {
+	constructor() {
+		this.functions = /* @__PURE__ */ new Map();
+	}
+	register(nameOrDef, handler, schema) {
+		if (typeof nameOrDef === "object") {
+			const { name, handler: h, description, parameters } = nameOrDef;
+			return this.register(name, h, {
+				description,
+				parameters
+			});
+		}
+		const name = nameOrDef;
+		if (!handler || !schema) throw new Error("handler and schema are required");
+		if (this.functions.has(name)) logger.warn(`Function "${name}" is being overwritten`);
+		this.functions.set(name, {
+			schema: {
+				...schema,
+				name
+			},
+			handler
+		});
+		logger.log(`Registered function: ${name}`);
+	}
+	/**
+	* Unregister a function
+	*/
+	unregister(name) {
+		const deleted = this.functions.delete(name);
+		if (deleted) logger.log(`Unregistered function: ${name}`);
+		return deleted;
+	}
+	/**
+	* Get a registered function
+	*/
+	get(name) {
+		return this.functions.get(name);
+	}
+	/**
+	* Check if a function is registered
+	*/
+	has(name) {
+		return this.functions.has(name);
+	}
+	/**
+	* Get all registered function schemas (for sending to backend)
+	*/
+	getSchemas() {
+		return Array.from(this.functions.values()).map((f) => f.schema);
+	}
+	/**
+	* Execute a registered function
+	*/
+	async execute(name, args) {
+		const registration = this.functions.get(name);
+		if (!registration) throw new AgoFunctionError(`Function "${name}" is not registered`, name);
+		logger.log(`Executing function: ${name}`, args);
+		try {
+			const result = await registration.handler(args);
+			logger.log(`Function ${name} completed:`, result);
+			return result;
+		} catch (error) {
+			logger.error(`Function ${name} failed:`, error);
+			throw new AgoFunctionError(`Function "${name}" execution failed: ${error instanceof Error ? error.message : "Unknown error"}`, name, error instanceof Error ? error : void 0);
+		}
+	}
+	/**
+	* Clear all registered functions
+	*/
+	clear() {
+		this.functions.clear();
+		logger.log("Cleared all registered functions");
+	}
+	/**
+	* Get the number of registered functions
+	*/
+	get size() {
+		return this.functions.size;
+	}
+};
+//#endregion
+//#region src/state/ClientContextRegistry.ts
+/**
+* Registry that collects client-side context from across the component tree.
+*
+* Components register/unregister context slices via unique keys.
+* When a message is sent the registry produces a single snapshot.
+*/
+var ClientContextRegistry = class {
+	constructor() {
+		this.entries = /* @__PURE__ */ new Map();
+		this.dynamicProviders = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Register or update a static context entry.
+	*/
+	set(key, entry) {
+		this.entries.set(key, entry);
+		logger.log(`ClientContext set: ${key}`);
+	}
+	/**
+	* Remove a static context entry (typically on component unmount).
+	*/
+	remove(key) {
+		const deleted = this.entries.delete(key);
+		if (deleted) logger.log(`ClientContext removed: ${key}`);
+		return deleted;
+	}
+	/**
+	* Register a dynamic context provider. The function is called every time
+	* a message is sent, so it always returns the freshest data.
+	*
+	* Use this for context that lives outside React state — global stores,
+	* refs, or computed values that shouldn't trigger re-renders.
+	*/
+	addDynamicProvider(key, provider) {
+		this.dynamicProviders.set(key, provider);
+		logger.log(`DynamicContext provider added: ${key}`);
+	}
+	/**
+	* Remove a dynamic context provider.
+	*/
+	removeDynamicProvider(key) {
+		const deleted = this.dynamicProviders.delete(key);
+		if (deleted) logger.log(`DynamicContext provider removed: ${key}`);
+		return deleted;
+	}
+	/**
+	* Build a snapshot of the current client context.
+	* Evaluates every registered dynamic provider. Returns `null` when there is
+	* nothing to report.
+	*/
+	getSnapshot() {
+		if (this.entries.size === 0 && this.dynamicProviders.size === 0) return null;
+		const entries = {};
+		for (const [key, entry] of this.entries) entries[key] = entry;
+		for (const [key, provider] of this.dynamicProviders) try {
+			const entry = provider();
+			if (entry) entries[key] = entry;
+		} catch (err) {
+			logger.error(`DynamicContext provider "${key}" threw:`, err);
+		}
+		if (Object.keys(entries).length === 0) return null;
+		return { entries };
+	}
+	/**
+	* Remove all entries and dynamic providers.
+	*/
+	clear() {
+		this.entries.clear();
+		this.dynamicProviders.clear();
+		logger.log("ClientContext cleared");
+	}
+};
+//#endregion
+//#region src/streaming/SSEHandler.ts
+/**
+* Handles SSE streaming responses from AGO backend
+*/
+var SSEHandler = class {
+	constructor(callbacks) {
+		this.callbacks = callbacks;
+		this.buffer = "";
+		this.message = {};
+		this.toolCalls = [];
+		this.sources = [];
+		this.followUpReplies = [];
+		this.isFirstChunk = true;
+	}
+	/**
+	* Process a streaming response
+	*/
+	async processStream(response) {
+		if (!response.body) throw new AgoStreamError("Response has no body");
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const text = decoder.decode(value, { stream: true });
+				this.buffer += text;
+				this.processBuffer();
+			}
+			if (this.buffer.trim()) this.processBuffer();
+			return this.buildFinalMessage();
+		} catch (error) {
+			const streamError = error instanceof Error ? error : new AgoStreamError("Stream processing failed");
+			this.callbacks.onError?.(streamError);
+			throw streamError;
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	processBuffer() {
+		const parts = this.buffer.split("\n\n");
+		this.buffer = parts.pop() || "";
+		for (const part of parts) {
+			if (!part.trim()) continue;
+			const lines = part.split("\n");
+			for (const line of lines) {
+				if (line.startsWith(": ")) continue;
+				if (line.startsWith("data: ")) {
+					const jsonStr = line.slice(6);
+					try {
+						const data = JSON.parse(jsonStr);
+						this.handleChunk(data);
+					} catch (error) {
+						logger.warn("Failed to parse SSE data:", jsonStr, error);
+					}
+				}
+			}
+		}
+	}
+	handleChunk(data) {
+		if (data.message_id && !this.message.id) this.message.id = data.message_id;
+		if (data.thread?.id) {
+			this.message.conversationId = data.thread.id;
+			if (this.isFirstChunk && this.message.id) {
+				this.isFirstChunk = false;
+				this.callbacks.onStart?.({
+					conversationId: this.message.conversationId,
+					messageId: this.message.id
+				});
+			}
+		}
+		if (data.content !== void 0) {
+			this.message.content = (this.message.content || "") + data.content;
+			if (this.message.conversationId && this.message.id) this.callbacks.onChunk?.({
+				content: data.content,
+				conversationId: this.message.conversationId,
+				messageId: this.message.id
+			});
+		}
+		if (data.full_content !== void 0) this.message.content = data.full_content;
+		if (data.status) this.message.status = data.status;
+		if (data.agent) this.message.agent = {
+			id: data.agent.id,
+			name: data.agent.name,
+			displayName: data.agent.display_name
+		};
+		if (data.knowledge_sources) this.sources = data.knowledge_sources.map((s) => {
+			const doc = s.knowledge_document;
+			return {
+				id: doc.id,
+				title: doc.title,
+				url: doc.use_external_link ? doc.external_link_url : doc.internal_link_url
+			};
+		});
+		if (data.type === "client_function" && data.function_name) this.callbacks.onClientFunction?.({
+			invocationId: data.id || "",
+			functionName: data.function_name,
+			arguments: data.arguments || {},
+			conversationId: this.message.conversationId || ""
+		});
+		if (data.tool_call_data && data.type && data.type !== "client_function") {
+			const toolCall = this.parseToolCall(data);
+			this.callbacks.onToolCall?.(toolCall);
+			const existingIndex = this.toolCalls.findIndex((t) => t.id === toolCall.id);
+			if (existingIndex >= 0) this.toolCalls[existingIndex] = toolCall;
+			else this.toolCalls.push(toolCall);
+		}
+		if (data.follow_up_replies) this.followUpReplies = data.follow_up_replies;
+	}
+	parseToolCall(data) {
+		return {
+			id: data.id || "",
+			type: data.type || "status_message",
+			status: data.status || "unknown",
+			toolName: data.tool_name || "",
+			toolDisplayName: data.tool_display_name,
+			message: data.message,
+			formSchema: data.form_schema,
+			data: data.data,
+			functionName: data.function_name,
+			arguments: data.arguments
+		};
+	}
+	buildFinalMessage() {
+		const message = {
+			id: this.message.id || "",
+			conversationId: this.message.conversationId || "",
+			content: this.message.content || "",
+			role: "assistant",
+			status: this.message.status || "DONE",
+			agent: this.message.agent,
+			sources: this.sources.length > 0 ? this.sources : void 0,
+			toolCalls: this.toolCalls.length > 0 ? this.toolCalls : void 0,
+			followUpReplies: this.followUpReplies.length > 0 ? this.followUpReplies : void 0,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.callbacks.onComplete?.(message);
+		return message;
+	}
+};
+/**
+* Check if an error is a network error that should trigger polling fallback
+*/
+function isStreamNetworkError(error) {
+	const message = error.message.toLowerCase();
+	return message.includes("load failed") || message.includes("failed to fetch") || message.includes("network") || message.includes("abort");
+}
+//#endregion
+//#region src/utils/eventEmitter.ts
+/**
+* Simple typed event emitter
+*/
+var EventEmitter = class {
+	constructor() {
+		this.handlers = /* @__PURE__ */ new Map();
+	}
+	on(event, handler) {
+		if (!this.handlers.has(event)) this.handlers.set(event, /* @__PURE__ */ new Set());
+		this.handlers.get(event).add(handler);
+	}
+	off(event, handler) {
+		const eventHandlers = this.handlers.get(event);
+		if (eventHandlers) eventHandlers.delete(handler);
+	}
+	emit(event, data) {
+		const eventHandlers = this.handlers.get(event);
+		if (eventHandlers) eventHandlers.forEach((handler) => {
+			try {
+				handler(data);
+			} catch (error) {
+				console.error(`Error in event handler for ${String(event)}:`, error);
+			}
+		});
+	}
+	/**
+	* Subscribe to an event and auto-unsubscribe after the first call.
+	*/
+	once(event, handler) {
+		const wrapper = ((data) => {
+			this.off(event, wrapper);
+			handler(data);
+		});
+		this.on(event, wrapper);
+	}
+	/**
+	* Returns a Promise that resolves the next time `event` fires.
+	* Rejects if `timeout` (ms) is reached first.
+	*/
+	waitFor(event, options) {
+		return new Promise((resolve, reject) => {
+			let timer;
+			const handler = ((data) => {
+				if (timer) clearTimeout(timer);
+				resolve(data);
+			});
+			this.once(event, handler);
+			if (options?.timeout) timer = setTimeout(() => {
+				this.off(event, handler);
+				reject(/* @__PURE__ */ new Error(`waitFor("${String(event)}") timed out after ${options.timeout}ms`));
+			}, options.timeout);
+		});
+	}
+	removeAllListeners(event) {
+		if (event) this.handlers.delete(event);
+		else this.handlers.clear();
+	}
+};
+//#endregion
+//#region src/client/AgoClient.ts
+/**
+* Main SDK client for AGO Chat integration
+*/
+var AgoClient = class {
+	constructor(config) {
+		this.config = config;
+		this.httpClient = new HttpClient(config);
+		this.functionRegistry = new FunctionRegistry();
+		this.contextRegistry = new ClientContextRegistry();
+		this.eventEmitter = new EventEmitter();
+		if (config.debug) logger.enable();
+		logger.log("AgoClient initialized");
+	}
+	/**
+	* Send a message and receive a streaming response
+	*/
+	async sendMessage(content, options) {
+		const clientFunctions = this.functionRegistry.getSchemas();
+		const clientContext = this.contextRegistry.getSnapshot();
+		const configAgent = this.config.agent || this.config.defaultAgentId;
+		const body = {
+			content,
+			conversation_id: options?.conversationId,
+			agent_id: options?.agentId || configAgent
+		};
+		if (clientFunctions.length > 0) body.client_functions = clientFunctions;
+		if (clientContext) body.client_context = clientContext;
+		let response;
+		if (options?.files && options.files.length > 0) {
+			const formData = new FormData();
+			formData.append("content", content);
+			if (options.conversationId) formData.append("conversation_id", options.conversationId);
+			if (options.agentId || configAgent) formData.append("agent_id", options.agentId || configAgent || "");
+			if (clientFunctions.length > 0) formData.append("client_functions", JSON.stringify(clientFunctions));
+			if (clientContext) formData.append("client_context", JSON.stringify(clientContext));
+			for (const file of options.files) formData.append("files", file);
+			response = await this.httpClient.postFormData("/api/sdk/v1/messages", formData);
+		} else response = await this.httpClient.postStream("/api/sdk/v1/messages", body);
+		return this.processSSEResponse(response);
+	}
+	async processSSEResponse(response) {
+		return new SSEHandler({
+			onStart: (data) => {
+				this.eventEmitter.emit("message:start", data);
+			},
+			onChunk: (data) => {
+				this.eventEmitter.emit("message:chunk", data);
+			},
+			onToolCall: (toolCall) => {
+				this.eventEmitter.emit("toolCall:received", toolCall);
+				if (toolCall.type === "form") this.eventEmitter.emit("toolCall:form", toolCall);
+			},
+			onClientFunction: async (data) => {
+				this.eventEmitter.emit("function:invoke", data);
+				await this.handleClientFunctionInvocation(data);
+			},
+			onComplete: (message) => {
+				this.eventEmitter.emit("message:complete", message);
+			},
+			onError: (error) => {
+				this.eventEmitter.emit("message:error", { error: error.message });
+			}
+		}).processStream(response);
+	}
+	async handleClientFunctionInvocation(data) {
+		let result;
+		let error;
+		try {
+			result = await this.functionRegistry.execute(data.functionName, data.arguments);
+		} catch (err) {
+			error = err instanceof Error ? err.message : "Unknown error";
+			logger.error("Client function execution failed:", err);
+		}
+		if (data.invocationId) try {
+			await this.submitToolCallForm(data.invocationId, {
+				result,
+				error,
+				_type: "client_function_result"
+			});
+		} catch (submitError) {
+			logger.error("Failed to submit function result:", submitError);
+		}
+		this.eventEmitter.emit("function:result", {
+			invocationId: data.invocationId,
+			result,
+			error
+		});
+	}
+	/**
+	* Get list of conversations
+	*/
+	async getConversations() {
+		return (await this.httpClient.get("/api/sdk/v1/conversations")).items.map((item) => ({
+			id: item.id,
+			title: item.title,
+			lastMessageDate: new Date(item.last_message_date)
+		}));
+	}
+	/**
+	* Get a specific conversation with messages
+	*/
+	async getConversation(conversationId) {
+		const response = await this.httpClient.get(`/api/sdk/v1/conversations/${conversationId}`);
+		return {
+			id: response.id,
+			title: response.title,
+			lastMessageDate: new Date(response.last_message_date),
+			messages: response.messages.map((m) => ({
+				id: m.id,
+				conversationId: response.id,
+				content: m.content,
+				role: m.role,
+				status: m.status,
+				createdAt: new Date(m.created_at)
+			}))
+		};
+	}
+	/**
+	* Get messages for a conversation
+	*/
+	async getMessages(conversationId) {
+		return (await this.getConversation(conversationId)).messages || [];
+	}
+	/**
+	* Submit form data for a tool call
+	*/
+	async submitToolCallForm(toolCallId, formData) {
+		await this.httpClient.post(`/api/tool-calls/${toolCallId}/submit/`, { formData });
+	}
+	/**
+	* Confirm a tool call
+	*/
+	async confirmToolCall(toolCallId) {
+		await this.httpClient.post(`/api/tool-calls/${toolCallId}/confirm/`);
+	}
+	/**
+	* Reject a tool call
+	*/
+	async rejectToolCall(toolCallId) {
+		await this.httpClient.post(`/api/tool-calls/${toolCallId}/reject/`);
+	}
+	/**
+	* Submit feedback for a message
+	*/
+	async submitFeedback(messageId, rating) {
+		await this.httpClient.post(`/api/sdk/v1/messages/${messageId}/feedback`, { rating });
+	}
+	registerFunction(nameOrDef, handler, schema) {
+		if (typeof nameOrDef === "object") this.functionRegistry.register(nameOrDef);
+		else this.functionRegistry.register(nameOrDef, handler, schema);
+	}
+	/**
+	* Short alias for `registerFunction`. Also accepts an array of definitions.
+	*
+	* ```ts
+	* client.register(lookupOrder);
+	* client.register([lookupOrder, cancelOrder]);
+	* ```
+	*/
+	register(definition) {
+		if (Array.isArray(definition)) for (const def of definition) this.functionRegistry.register(def);
+		else this.functionRegistry.register(definition);
+	}
+	/**
+	* Unregister a client-side function
+	*/
+	unregisterFunction(name) {
+		return this.functionRegistry.unregister(name);
+	}
+	/**
+	* Get all registered function schemas
+	*/
+	getRegisteredFunctions() {
+		return this.functionRegistry.getSchemas();
+	}
+	/**
+	* Register a navigation function that lets AGO navigate users to different pages.
+	* @param navigate - A callback that performs the navigation (e.g. react-router's navigate)
+	* @param routes - Map of route names to paths, with descriptions for the LLM
+	*/
+	registerNavigationFunction(navigate, routes) {
+		const routeNames = routes.map((r) => r.name);
+		const routeDescriptions = routes.map((r) => `- "${r.name}": ${r.description}`).join("\n");
+		this.registerFunction("navigateToPage", async (args) => {
+			const pageName = args.page;
+			const route = routes.find((r) => r.name === pageName);
+			if (!route) return {
+				success: false,
+				error: `Unknown page: ${pageName}`
+			};
+			navigate(route.path);
+			return {
+				success: true,
+				navigatedTo: route.path
+			};
+		}, {
+			description: `Navigate the user to a page in the application. Available pages:\n${routeDescriptions}`,
+			parameters: {
+				type: "object",
+				properties: { page: {
+					type: "string",
+					description: "The page to navigate to",
+					enum: routeNames
+				} },
+				required: ["page"]
+			}
+		});
+	}
+	/**
+	* Register or update a piece of client-side context.
+	* This context is sent with every message so the AI understands the user's situation.
+	*
+	* ```ts
+	* client.setContext("order-page", {
+	*   name: "Order detail",
+	*   description: "User is viewing order #123",
+	*   data: { orderId: "123", status: "shipped" },
+	* });
+	* ```
+	*/
+	setContext(key, entry) {
+		this.contextRegistry.set(key, entry);
+	}
+	/**
+	* Remove a previously registered context entry.
+	*/
+	removeContext(key) {
+		return this.contextRegistry.remove(key);
+	}
+	/**
+	* Register a dynamic context provider. The callback is invoked every time
+	* a message is sent, so the AI always gets the freshest data.
+	*
+	* Use this for context that lives outside React state — global stores,
+	* refs, or computed values.
+	*
+	* ```ts
+	* client.addDynamicContext("cart", () => ({
+	*   name: "Checkout",
+	*   data: { itemCount: cart.items.length, total: cart.total },
+	* }));
+	* ```
+	*/
+	addDynamicContext(key, provider) {
+		this.contextRegistry.addDynamicProvider(key, provider);
+	}
+	/**
+	* Remove a dynamic context provider.
+	*/
+	removeDynamicContext(key) {
+		return this.contextRegistry.removeDynamicProvider(key);
+	}
+	/**
+	* Enable automatic capture of the current browser page (URL + title).
+	* Injected as a dynamic context entry named `browser-page`.
+	*/
+	enableAutoPageContext() {
+		this.contextRegistry.addDynamicProvider("browser-page", () => {
+			const url = typeof window !== "undefined" ? window.location.href : void 0;
+			const title = typeof document !== "undefined" ? document.title : void 0;
+			if (!url && !title) return null;
+			return {
+				name: "Browser page",
+				description: "Current page the user is viewing",
+				data: {
+					url,
+					title
+				}
+			};
+		});
+	}
+	/**
+	* Get the current context snapshot.
+	*/
+	getContextSnapshot() {
+		return this.contextRegistry.getSnapshot();
+	}
+	/**
+	* Subscribe to an event
+	*/
+	on(event, handler) {
+		this.eventEmitter.on(event, handler);
+	}
+	/**
+	* Unsubscribe from an event
+	*/
+	off(event, handler) {
+		this.eventEmitter.off(event, handler);
+	}
+	/**
+	* Subscribe to an event once — auto-unsubscribes after the first call.
+	*/
+	once(event, handler) {
+		this.eventEmitter.once(event, handler);
+	}
+	/**
+	* Returns a Promise that resolves the next time `event` fires.
+	*
+	* ```ts
+	* const msg = await client.waitFor("message:complete", { timeout: 10000 });
+	* ```
+	*/
+	waitFor(event, options) {
+		return this.eventEmitter.waitFor(event, options);
+	}
+	/**
+	* Update client configuration
+	*/
+	updateConfig(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+		this.httpClient.updateConfig(config);
+		if (config.debug !== void 0) config.debug ? logger.enable() : logger.disable();
+	}
+	/**
+	* Clean up resources
+	*/
+	destroy() {
+		this.eventEmitter.removeAllListeners();
+		this.functionRegistry.clear();
+		this.contextRegistry.clear();
+		logger.log("AgoClient destroyed");
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AgoApiError", {
+	enumerable: true,
+	get: function() {
+		return AgoApiError;
+	}
+});
+Object.defineProperty(exports, "AgoClient", {
+	enumerable: true,
+	get: function() {
+		return AgoClient;
+	}
+});
+Object.defineProperty(exports, "AgoError", {
+	enumerable: true,
+	get: function() {
+		return AgoError;
+	}
+});
+Object.defineProperty(exports, "AgoFunctionError", {
+	enumerable: true,
+	get: function() {
+		return AgoFunctionError;
+	}
+});
+Object.defineProperty(exports, "AgoNetworkError", {
+	enumerable: true,
+	get: function() {
+		return AgoNetworkError;
+	}
+});
+Object.defineProperty(exports, "AgoStreamError", {
+	enumerable: true,
+	get: function() {
+		return AgoStreamError;
+	}
+});
+Object.defineProperty(exports, "ClientContextRegistry", {
+	enumerable: true,
+	get: function() {
+		return ClientContextRegistry;
+	}
+});
+Object.defineProperty(exports, "EventEmitter", {
+	enumerable: true,
+	get: function() {
+		return EventEmitter;
+	}
+});
+Object.defineProperty(exports, "FunctionRegistry", {
+	enumerable: true,
+	get: function() {
+		return FunctionRegistry;
+	}
+});
+Object.defineProperty(exports, "SSEHandler", {
+	enumerable: true,
+	get: function() {
+		return SSEHandler;
+	}
+});
+Object.defineProperty(exports, "isStreamNetworkError", {
+	enumerable: true,
+	get: function() {
+		return isStreamNetworkError;
+	}
+});
+Object.defineProperty(exports, "logger", {
+	enumerable: true,
+	get: function() {
+		return logger;
+	}
+});
+
+//# sourceMappingURL=AgoClient-D0l1GTRs.cjs.map