@useago/sdk 0.1.6 → 0.2.0

package/dist/AgoClient-CNT-8sh_.js

@@ -0,0 +1,905 @@
+//#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
+export { ClientContextRegistry as a, AgoApiError as c, AgoNetworkError as d, AgoStreamError as f, isStreamNetworkError as i, AgoError as l, EventEmitter as n, FunctionRegistry as o, SSEHandler as r, logger as s, AgoClient as t, AgoFunctionError as u };
+
+//# sourceMappingURL=AgoClient-CNT-8sh_.js.map