(function(global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('graphql'), require('zod'), require('uuid'), require('@segment/analytics-node'), require('chalk')) :
  typeof define === 'function' && define.amd ? define(['exports', 'graphql', 'zod', 'uuid', '@segment/analytics-node', 'chalk'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitShared = {}), global.GraphQL,global.Zod,global.UUID,global.SegmentAnalyticsNode,global.chalk));
})(this, function(exports, graphql, zod, uuid, _segment_analytics_node, chalk) {
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
//#region \0rolldown/runtime.js
	var __create = Object.create;
	var __defProp = Object.defineProperty;
	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames = Object.getOwnPropertyNames;
	var __getProtoOf = Object.getPrototypeOf;
	var __hasOwnProp = Object.prototype.hasOwnProperty;
	var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" || typeof from === "function") {
			for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
				key = keys[i];
				if (!__hasOwnProp.call(to, key) && key !== except) {
					__defProp(to, key, {
						get: ((k) => from[k]).bind(null, key),
						enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
					});
				}
			}
		}
		return to;
	};
	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
		value: mod,
		enumerable: true
	}) : target, mod));

//#endregion

//#region src/utils/conditions.ts
	function executeConditions({ conditions, value }) {
		if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) return true;
		return conditions.every((condition) => executeCondition(condition, value));
	}
	function executeCondition(condition, value) {
		const targetValue = condition.path ? getValueFromPath(value, condition.path) : value;
		switch (condition.rule) {
			case "AND": return condition.conditions.every((c) => executeCondition(c, value));
			case "OR": return condition.conditions.some((c) => executeCondition(c, value));
			case "NOT": return !condition.conditions.every((c) => executeCondition(c, value));
			case "EQUALS": return targetValue === condition.value;
			case "NOT_EQUALS": return targetValue !== condition.value;
			case "GREATER_THAN": return targetValue > condition.value;
			case "LESS_THAN": return targetValue < condition.value;
			case "CONTAINS": return Array.isArray(targetValue) && targetValue.includes(condition.value);
			case "NOT_CONTAINS": return Array.isArray(targetValue) && !targetValue.includes(condition.value);
			case "MATCHES": return new RegExp(condition.value).test(String(targetValue));
			case "STARTS_WITH": return String(targetValue).startsWith(condition.value);
			case "ENDS_WITH": return String(targetValue).endsWith(condition.value);
			case "EXISTS": return targetValue !== void 0 && targetValue !== null;
			case "NOT_EXISTS": return targetValue === void 0 || targetValue === null;
		}
	}
	function getValueFromPath(obj, path) {
		return path.split(".").reduce((acc, part) => acc === null || acc === void 0 ? void 0 : acc[part], obj);
	}

//#endregion
//#region src/utils/console-styling.ts
/**
	* Console styling utilities for CopilotKit branded messages
	* Provides consistent, readable colors across light and dark console themes
	*/
	/**
	* Color palette optimized for console readability
	*/
	const ConsoleColors = {
		primary: "#007acc",
		success: "#22c55e",
		feature: "#a855f7",
		cta: "#ef4444",
		info: "#06b6d4",
		inherit: "inherit",
		warning: "#f59e0b"
	};
	/**
	* Console style templates for common patterns
	*/
	const ConsoleStyles = {
		header: `color: ${ConsoleColors.warning}; font-weight: bold; font-size: 16px;`,
		section: `color: ${ConsoleColors.success}; font-weight: bold;`,
		highlight: `color: ${ConsoleColors.feature}; font-weight: bold;`,
		cta: `color: ${ConsoleColors.success}; font-weight: bold;`,
		info: `color: ${ConsoleColors.info}; font-weight: bold;`,
		link: `color: ${ConsoleColors.primary}; text-decoration: underline;`,
		body: `color: ${ConsoleColors.inherit};`,
		warning: `color: ${ConsoleColors.cta}; font-weight: bold;`
	};
	/**
	* Styled console message for CopilotKit Platform promotion
	* Displays a beautiful, branded advertisement in the console
	*/
	function logCopilotKitPlatformMessage() {
		console.log(`%cCopilotKit Warning%c

useCopilotChatHeadless_c provides full compatibility with CopilotKit's newly released Headless UI feature set. To enable this premium feature, add your public license key, available for free at:

%chttps://cloud.copilotkit.ai%c

Alternatively, useCopilotChat is available for basic programmatic control, and does not require an API key.

To learn more about premium features, read the documentation here:

%chttps://docs.copilotkit.ai/premium%c`, ConsoleStyles.header, ConsoleStyles.body, ConsoleStyles.cta, ConsoleStyles.body, ConsoleStyles.link, ConsoleStyles.body);
	}
	function publicApiKeyRequired(feature) {
		console.log(`
%cCopilotKit Warning%c \n
In order to use ${feature}, you need to add your CopilotKit API key, available for free at https://cloud.copilotkit.ai.
    `.trim(), ConsoleStyles.header, ConsoleStyles.body);
	}
	/**
	* Create a styled console message with custom content
	*
	* @param template - Template string with %c placeholders
	* @param styles - Array of style strings matching the %c placeholders
	*
	* @example
	* ```typescript
	* logStyled(
	*   '%cCopilotKit%c Welcome to the platform!',
	*   [ConsoleStyles.header, ConsoleStyles.body]
	* );
	* ```
	*/
	function logStyled(template, styles) {
		console.log(template, ...styles);
	}
	/**
	* Quick styled console methods for common use cases
	*/
	const styledConsole = {
		success: (message) => logStyled(`%c✅ ${message}`, [ConsoleStyles.section]),
		info: (message) => logStyled(`%cℹ️ ${message}`, [ConsoleStyles.info]),
		feature: (message) => logStyled(`%c✨ ${message}`, [ConsoleStyles.highlight]),
		cta: (message) => logStyled(`%c🚀 ${message}`, [ConsoleStyles.cta]),
		logCopilotKitPlatformMessage,
		publicApiKeyRequired
	};

//#endregion
//#region src/utils/errors.ts
	let Severity = /* @__PURE__ */ function(Severity) {
		Severity["CRITICAL"] = "critical";
		Severity["WARNING"] = "warning";
		Severity["INFO"] = "info";
		return Severity;
	}({});
	let ErrorVisibility = /* @__PURE__ */ function(ErrorVisibility) {
		ErrorVisibility["BANNER"] = "banner";
		ErrorVisibility["TOAST"] = "toast";
		ErrorVisibility["SILENT"] = "silent";
		ErrorVisibility["DEV_ONLY"] = "dev_only";
		return ErrorVisibility;
	}({});
	const ERROR_NAMES = {
		COPILOT_ERROR: "CopilotError",
		COPILOT_API_DISCOVERY_ERROR: "CopilotApiDiscoveryError",
		COPILOT_REMOTE_ENDPOINT_DISCOVERY_ERROR: "CopilotKitRemoteEndpointDiscoveryError",
		COPILOT_KIT_AGENT_DISCOVERY_ERROR: "CopilotKitAgentDiscoveryError",
		COPILOT_KIT_LOW_LEVEL_ERROR: "CopilotKitLowLevelError",
		COPILOT_KIT_VERSION_MISMATCH_ERROR: "CopilotKitVersionMismatchError",
		RESOLVED_COPILOT_KIT_ERROR: "ResolvedCopilotKitError",
		CONFIGURATION_ERROR: "ConfigurationError",
		MISSING_PUBLIC_API_KEY_ERROR: "MissingPublicApiKeyError",
		UPGRADE_REQUIRED_ERROR: "UpgradeRequiredError"
	};
	const BANNER_ERROR_NAMES = [
		ERROR_NAMES.CONFIGURATION_ERROR,
		ERROR_NAMES.MISSING_PUBLIC_API_KEY_ERROR,
		ERROR_NAMES.UPGRADE_REQUIRED_ERROR,
		ERROR_NAMES.COPILOT_API_DISCOVERY_ERROR,
		ERROR_NAMES.COPILOT_REMOTE_ENDPOINT_DISCOVERY_ERROR,
		ERROR_NAMES.COPILOT_KIT_AGENT_DISCOVERY_ERROR
	];
	const COPILOT_CLOUD_ERROR_NAMES = BANNER_ERROR_NAMES;
	let CopilotKitErrorCode = /* @__PURE__ */ function(CopilotKitErrorCode) {
		CopilotKitErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
		CopilotKitErrorCode["NOT_FOUND"] = "NOT_FOUND";
		CopilotKitErrorCode["AGENT_NOT_FOUND"] = "AGENT_NOT_FOUND";
		CopilotKitErrorCode["API_NOT_FOUND"] = "API_NOT_FOUND";
		CopilotKitErrorCode["REMOTE_ENDPOINT_NOT_FOUND"] = "REMOTE_ENDPOINT_NOT_FOUND";
		CopilotKitErrorCode["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
		CopilotKitErrorCode["MISUSE"] = "MISUSE";
		CopilotKitErrorCode["UNKNOWN"] = "UNKNOWN";
		CopilotKitErrorCode["VERSION_MISMATCH"] = "VERSION_MISMATCH";
		CopilotKitErrorCode["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
		CopilotKitErrorCode["MISSING_PUBLIC_API_KEY_ERROR"] = "MISSING_PUBLIC_API_KEY_ERROR";
		CopilotKitErrorCode["UPGRADE_REQUIRED_ERROR"] = "UPGRADE_REQUIRED_ERROR";
		return CopilotKitErrorCode;
	}({});
	const BASE_URL = "https://docs.copilotkit.ai";
	const getSeeMoreMarkdown = (link) => `See more: [${link}](${link})`;
	const ERROR_CONFIG = {
		[CopilotKitErrorCode.NETWORK_ERROR]: {
			statusCode: 503,
			troubleshootingUrl: `${BASE_URL}/troubleshooting/common-issues#i-am-getting-a-network-errors--api-not-found`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.NOT_FOUND]: {
			statusCode: 404,
			troubleshootingUrl: `${BASE_URL}/troubleshooting/common-issues#i-am-getting-a-network-errors--api-not-found`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.AGENT_NOT_FOUND]: {
			statusCode: 500,
			troubleshootingUrl: `${BASE_URL}/coagents/troubleshooting/common-issues#i-am-getting-agent-not-found-error`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.API_NOT_FOUND]: {
			statusCode: 404,
			troubleshootingUrl: `${BASE_URL}/troubleshooting/common-issues#i-am-getting-a-network-errors--api-not-found`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.REMOTE_ENDPOINT_NOT_FOUND]: {
			statusCode: 404,
			troubleshootingUrl: `${BASE_URL}/troubleshooting/common-issues#i-am-getting-copilotkits-remote-endpoint-not-found-error`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.AUTHENTICATION_ERROR]: {
			statusCode: 401,
			troubleshootingUrl: `${BASE_URL}/troubleshooting/common-issues#authentication-errors`,
			visibility: ErrorVisibility.BANNER,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.MISUSE]: {
			statusCode: 400,
			troubleshootingUrl: null,
			visibility: ErrorVisibility.DEV_ONLY,
			severity: Severity.WARNING
		},
		[CopilotKitErrorCode.UNKNOWN]: {
			statusCode: 500,
			visibility: ErrorVisibility.TOAST,
			severity: Severity.CRITICAL
		},
		[CopilotKitErrorCode.CONFIGURATION_ERROR]: {
			statusCode: 400,
			troubleshootingUrl: null,
			severity: Severity.WARNING,
			visibility: ErrorVisibility.BANNER
		},
		[CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR]: {
			statusCode: 400,
			troubleshootingUrl: null,
			severity: Severity.CRITICAL,
			visibility: ErrorVisibility.BANNER
		},
		[CopilotKitErrorCode.UPGRADE_REQUIRED_ERROR]: {
			statusCode: 402,
			troubleshootingUrl: null,
			severity: Severity.WARNING,
			visibility: ErrorVisibility.BANNER
		},
		[CopilotKitErrorCode.VERSION_MISMATCH]: {
			statusCode: 400,
			troubleshootingUrl: null,
			visibility: ErrorVisibility.DEV_ONLY,
			severity: Severity.INFO
		}
	};
	var CopilotKitError = class extends graphql.GraphQLError {
		constructor({ message = "Unknown error occurred", code, severity, visibility }) {
			var _ref;
			const name = ERROR_NAMES.COPILOT_ERROR;
			const config = ERROR_CONFIG[code];
			const { statusCode } = config;
			const resolvedVisibility = (_ref = visibility !== null && visibility !== void 0 ? visibility : config.visibility) !== null && _ref !== void 0 ? _ref : ErrorVisibility.TOAST;
			const resolvedSeverity = severity !== null && severity !== void 0 ? severity : "severity" in config ? config.severity : void 0;
			super(message, { extensions: {
				name,
				statusCode,
				code,
				visibility: resolvedVisibility,
				severity: resolvedSeverity,
				troubleshootingUrl: "troubleshootingUrl" in config ? config.troubleshootingUrl : null,
				originalError: {
					message,
					stack: (/* @__PURE__ */ new Error()).stack
				}
			} });
			this.code = code;
			this.name = name;
			this.statusCode = statusCode;
			this.severity = resolvedSeverity;
			this.visibility = resolvedVisibility;
		}
	};
	/**
	* Error thrown when we can identify wrong usage of our components.
	* This helps us notify the developer before real errors can happen
	*
	* @extends CopilotKitError
	*/
	var CopilotKitMisuseError = class extends CopilotKitError {
		constructor({ message, code = CopilotKitErrorCode.MISUSE }) {
			const docsLink = "troubleshootingUrl" in ERROR_CONFIG[code] && ERROR_CONFIG[code].troubleshootingUrl ? getSeeMoreMarkdown(ERROR_CONFIG[code].troubleshootingUrl) : null;
			const finalMessage = docsLink ? `${message}.\n\n${docsLink}` : message;
			super({
				message: finalMessage,
				code
			});
			this.name = ERROR_NAMES.COPILOT_API_DISCOVERY_ERROR;
		}
	};
	const getVersionMismatchErrorMessage = ({ reactCoreVersion, runtimeVersion, runtimeClientGqlVersion }) => `Version mismatch detected: @copilotkit/runtime@${runtimeVersion !== null && runtimeVersion !== void 0 ? runtimeVersion : ""} is not compatible with @copilotkit/react-core@${reactCoreVersion} and @copilotkit/runtime-client-gql@${runtimeClientGqlVersion}. Please ensure all installed copilotkit packages are on the same version.`;
	/**
	* Error thrown when CPK versions does not match
	*
	* @extends CopilotKitError
	*/
	var CopilotKitVersionMismatchError = class extends CopilotKitError {
		constructor({ reactCoreVersion, runtimeVersion, runtimeClientGqlVersion }) {
			const code = CopilotKitErrorCode.VERSION_MISMATCH;
			super({
				message: getVersionMismatchErrorMessage({
					reactCoreVersion,
					runtimeVersion,
					runtimeClientGqlVersion
				}),
				code
			});
			this.name = ERROR_NAMES.COPILOT_KIT_VERSION_MISMATCH_ERROR;
		}
	};
	/**
	* Error thrown when the CopilotKit API endpoint cannot be discovered or accessed.
	* This typically occurs when:
	* - The API endpoint URL is invalid or misconfigured
	* - The API service is not running at the expected location
	* - There are network/firewall issues preventing access
	*
	* @extends CopilotKitError
	*/
	var CopilotKitApiDiscoveryError = class extends CopilotKitError {
		constructor(params = {}) {
			var _params$url, _params$message, _params$code;
			const url = (_params$url = params.url) !== null && _params$url !== void 0 ? _params$url : "";
			let operationSuffix = "";
			if (url === null || url === void 0 ? void 0 : url.includes("/info")) operationSuffix = `when fetching CopilotKit info`;
			else if (url.includes("/actions/execute")) operationSuffix = `when attempting to execute actions.`;
			else if (url.includes("/agents/state")) operationSuffix = `when attempting to get agent state.`;
			else if (url.includes("/agents/execute")) operationSuffix = `when attempting to execute agent(s).`;
			const message = (_params$message = params.message) !== null && _params$message !== void 0 ? _params$message : params.url ? `Failed to find CopilotKit API endpoint at url ${params.url} ${operationSuffix}` : `Failed to find CopilotKit API endpoint.`;
			const code = (_params$code = params.code) !== null && _params$code !== void 0 ? _params$code : CopilotKitErrorCode.API_NOT_FOUND;
			const errorMessage = `${message}.\n\n${getSeeMoreMarkdown(ERROR_CONFIG[code].troubleshootingUrl)}`;
			super({
				message: errorMessage,
				code
			});
			this.name = ERROR_NAMES.COPILOT_API_DISCOVERY_ERROR;
		}
	};
	/**
	* This error is used for endpoints specified in runtime's remote endpoints. If they cannot be contacted
	* This typically occurs when:
	* - The API endpoint URL is invalid or misconfigured
	* - The API service is not running at the expected location
	*
	* @extends CopilotKitApiDiscoveryError
	*/
	var CopilotKitRemoteEndpointDiscoveryError = class extends CopilotKitApiDiscoveryError {
		constructor(params) {
			var _params$message2;
			const message = (_params$message2 = params === null || params === void 0 ? void 0 : params.message) !== null && _params$message2 !== void 0 ? _params$message2 : (params === null || params === void 0 ? void 0 : params.url) ? `Failed to find or contact remote endpoint at url ${params.url}` : "Failed to find or contact remote endpoint";
			const code = CopilotKitErrorCode.REMOTE_ENDPOINT_NOT_FOUND;
			super({
				message,
				code
			});
			this.name = ERROR_NAMES.COPILOT_REMOTE_ENDPOINT_DISCOVERY_ERROR;
		}
	};
	/**
	* Error thrown when a LangGraph agent cannot be found or accessed.
	* This typically occurs when:
	* - The specified agent name does not exist in the deployment
	* - The agent configuration is invalid or missing
	* - The agent service is not properly deployed or initialized
	*
	* @extends CopilotKitError
	*/
	var CopilotKitAgentDiscoveryError = class extends CopilotKitError {
		constructor(params) {
			const { agentName, availableAgents } = params;
			const code = CopilotKitErrorCode.AGENT_NOT_FOUND;
			const seeMore = getSeeMoreMarkdown(ERROR_CONFIG[code].troubleshootingUrl);
			let message;
			if (availableAgents.length) {
				const agentList = availableAgents.map((agent) => agent.name).join(", ");
				if (agentName) message = `Agent '${agentName}' was not found. Available agents are: ${agentList}. Please verify the agent name in your configuration and ensure it matches one of the available agents.\n\n${seeMore}`;
				else message = `The requested agent was not found. Available agents are: ${agentList}. Please verify the agent name in your configuration and ensure it matches one of the available agents.\n\n${seeMore}`;
			} else message = `${agentName ? `Agent '${agentName}'` : "The requested agent"} was not found. Please set up at least one agent before proceeding. ${seeMore}`;
			super({
				message,
				code
			});
			this.name = ERROR_NAMES.COPILOT_KIT_AGENT_DISCOVERY_ERROR;
		}
	};
	/**
	* Handles low-level networking errors that occur before a request reaches the server.
	* These errors arise from issues in the underlying communication infrastructure rather than
	* application-level logic or server responses. Typically used to handle "fetch failed" errors
	* where no HTTP status code is available.
	*
	* Common scenarios include:
	* - Connection failures (ECONNREFUSED) when server is down/unreachable
	* - DNS resolution failures (ENOTFOUND) when domain can't be resolved
	* - Timeouts (ETIMEDOUT) when request takes too long
	* - Protocol/transport layer errors like SSL/TLS issues
	*/
	var CopilotKitLowLevelError = class extends CopilotKitError {
		constructor({ error, url, message }) {
			let code = CopilotKitErrorCode.NETWORK_ERROR;
			const errorCode = error.code;
			const errorMessage = message !== null && message !== void 0 ? message : resolveLowLevelErrorMessage({
				errorCode,
				url
			});
			super({
				message: errorMessage,
				code
			});
			this.name = ERROR_NAMES.COPILOT_KIT_LOW_LEVEL_ERROR;
		}
	};
	/**
	* Generic catch-all error handler for HTTP responses from the CopilotKit API where a status code is available.
	* Used when we receive an HTTP error status and wish to handle broad range of them
	*
	* This differs from CopilotKitLowLevelError in that:
	* - ResolvedCopilotKitError: Server was reached and returned an HTTP status
	* - CopilotKitLowLevelError: Error occurred before reaching server (e.g. network failure)
	*
	* @param status - The HTTP status code received from the API response
	* @param message - Optional error message to include
	* @param code - Optional specific CopilotKitErrorCode to override default behavior
	*
	* Default behavior:
	* - 400 Bad Request: Maps to CopilotKitApiDiscoveryError
	* - All other status codes: Maps to UNKNOWN error code if no specific code provided
	*/
	var ResolvedCopilotKitError = class extends CopilotKitError {
		constructor({ status, message, code, isRemoteEndpoint, url }) {
			let resolvedCode = code;
			if (!resolvedCode) switch (status) {
				case 400: throw new CopilotKitApiDiscoveryError({
					message,
					url
				});
				case 404: throw isRemoteEndpoint ? new CopilotKitRemoteEndpointDiscoveryError({
					message,
					url
				}) : new CopilotKitApiDiscoveryError({
					message,
					url
				});
				default:
					resolvedCode = CopilotKitErrorCode.UNKNOWN;
					break;
			}
			super({
				message,
				code: resolvedCode
			});
			this.name = ERROR_NAMES.RESOLVED_COPILOT_KIT_ERROR;
		}
	};
	var ConfigurationError = class extends CopilotKitError {
		constructor(message) {
			super({
				message,
				code: CopilotKitErrorCode.CONFIGURATION_ERROR
			});
			this.name = ERROR_NAMES.CONFIGURATION_ERROR;
			this.severity = Severity.WARNING;
		}
	};
	var MissingPublicApiKeyError = class extends ConfigurationError {
		constructor(message) {
			super(message);
			this.name = ERROR_NAMES.MISSING_PUBLIC_API_KEY_ERROR;
			this.severity = Severity.CRITICAL;
		}
	};
	var UpgradeRequiredError = class extends ConfigurationError {
		constructor(message) {
			super(message);
			this.name = ERROR_NAMES.UPGRADE_REQUIRED_ERROR;
			this.severity = Severity.WARNING;
		}
	};
	/**
	* Checks if an error is already a structured CopilotKit error.
	* This utility centralizes the logic for detecting structured errors across the codebase.
	*
	* @param error - The error to check
	* @returns true if the error is already structured, false otherwise
	*/
	function isStructuredCopilotKitError(error) {
		var _error$extensions;
		return error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError || (error === null || error === void 0 ? void 0 : error.name) && error.name.includes("CopilotKit") || (error === null || error === void 0 || (_error$extensions = error.extensions) === null || _error$extensions === void 0 ? void 0 : _error$extensions.code) !== void 0;
	}
	/**
	* Returns the error as-is if it's already structured, otherwise converts it using the provided converter function.
	* This utility centralizes the pattern of preserving structured errors while converting unstructured ones.
	*
	* @param error - The error to process
	* @param converter - Function to convert unstructured errors to structured ones
	* @returns The structured error
	*/
	function ensureStructuredError(error, converter) {
		return isStructuredCopilotKitError(error) ? error : converter(error);
	}
	async function getPossibleVersionMismatch({ runtimeVersion, runtimeClientGqlVersion }) {
		if (!runtimeVersion || runtimeVersion === "" || !runtimeClientGqlVersion) return;
		if (COPILOTKIT_VERSION !== runtimeVersion || COPILOTKIT_VERSION !== runtimeClientGqlVersion || runtimeVersion !== runtimeClientGqlVersion) return {
			runtimeVersion,
			runtimeClientGqlVersion,
			reactCoreVersion: COPILOTKIT_VERSION,
			message: getVersionMismatchErrorMessage({
				runtimeVersion,
				runtimeClientGqlVersion,
				reactCoreVersion: COPILOTKIT_VERSION
			})
		};
	}
	const resolveLowLevelErrorMessage = ({ errorCode, url }) => {
		const troubleshootingLink = ERROR_CONFIG[CopilotKitErrorCode.NETWORK_ERROR].troubleshootingUrl;
		const genericMessage = (description = `Failed to fetch from url ${url}.`) => `${description}.

Possible reasons:
- -The server may have an error preventing it from returning a response (Check the server logs for more info).
- -The server might be down or unreachable
- -There might be a network issue (e.g., DNS failure, connection timeout) 
- -The URL might be incorrect
- -The server is not running on the specified port

${getSeeMoreMarkdown(troubleshootingLink)}`;
		if (url.includes("/info")) return genericMessage(`Failed to fetch CopilotKit agents/action information from url ${url}.`);
		if (url.includes("/actions/execute")) return genericMessage(`Fetch call to ${url} to execute actions failed.`);
		if (url.includes("/agents/state")) return genericMessage(`Fetch call to ${url} to get agent state failed.`);
		if (url.includes("/agents/execute")) return genericMessage(`Fetch call to ${url} to execute agent(s) failed.`);
		switch (errorCode) {
			case "ECONNREFUSED": return `Connection to ${url} was refused. Ensure the server is running and accessible.\n\n${getSeeMoreMarkdown(troubleshootingLink)}`;
			case "ENOTFOUND": return `The server on ${url} could not be found. Check the URL or your network configuration.\n\n${getSeeMoreMarkdown(ERROR_CONFIG[CopilotKitErrorCode.NOT_FOUND].troubleshootingUrl)}`;
			case "ETIMEDOUT": return `The connection to ${url} timed out. The server might be overloaded or taking too long to respond.\n\n${getSeeMoreMarkdown(troubleshootingLink)}`;
			default: return;
		}
	};

//#endregion
//#region src/utils/json-schema.ts
	function actionParametersToJsonSchema(actionParameters) {
		let parameters = {};
		for (let parameter of actionParameters || []) parameters[parameter.name] = convertAttribute(parameter);
		let requiredParameterNames = [];
		for (let arg of actionParameters || []) if (arg.required !== false) requiredParameterNames.push(arg.name);
		return {
			type: "object",
			properties: parameters,
			required: requiredParameterNames
		};
	}
	function jsonSchemaToActionParameters(jsonSchema) {
		if (jsonSchema.type !== "object" || !jsonSchema.properties) return [];
		const parameters = [];
		const requiredFields = jsonSchema.required || [];
		for (const [name, schema] of Object.entries(jsonSchema.properties)) {
			const parameter = convertJsonSchemaToParameter(name, schema, requiredFields.includes(name));
			parameters.push(parameter);
		}
		return parameters;
	}
	function convertJsonSchemaToParameter(name, schema, isRequired) {
		const baseParameter = {
			name,
			description: schema.description
		};
		if (!isRequired) baseParameter.required = false;
		switch (schema.type) {
			case "string": return {
				...baseParameter,
				type: "string",
				...schema.enum && { enum: schema.enum }
			};
			case "number":
			case "boolean": return {
				...baseParameter,
				type: schema.type
			};
			case "object":
				if (schema.properties) {
					const attributes = [];
					const requiredFields = schema.required || [];
					for (const [propName, propSchema] of Object.entries(schema.properties)) attributes.push(convertJsonSchemaToParameter(propName, propSchema, requiredFields.includes(propName)));
					return {
						...baseParameter,
						type: "object",
						attributes
					};
				}
				return {
					...baseParameter,
					type: "object"
				};
			case "array": if (schema.items.type === "object" && "properties" in schema.items) {
				const attributes = [];
				const requiredFields = schema.items.required || [];
				for (const [propName, propSchema] of Object.entries(schema.items.properties || {})) attributes.push(convertJsonSchemaToParameter(propName, propSchema, requiredFields.includes(propName)));
				return {
					...baseParameter,
					type: "object[]",
					attributes
				};
			} else if (schema.items.type === "array") throw new Error("Nested arrays are not supported");
			else return {
				...baseParameter,
				type: `${schema.items.type}[]`
			};
			default: return {
				...baseParameter,
				type: "string"
			};
		}
	}
	function convertAttribute(attribute) {
		switch (attribute.type) {
			case "string": return {
				type: "string",
				description: attribute.description,
				...attribute.enum && { enum: attribute.enum }
			};
			case "number":
			case "boolean": return {
				type: attribute.type,
				description: attribute.description
			};
			case "object":
			case "object[]":
				var _attribute$attributes, _attribute$attributes2;
				const properties = (_attribute$attributes = attribute.attributes) === null || _attribute$attributes === void 0 ? void 0 : _attribute$attributes.reduce((acc, attr) => {
					acc[attr.name] = convertAttribute(attr);
					return acc;
				}, {});
				const required = (_attribute$attributes2 = attribute.attributes) === null || _attribute$attributes2 === void 0 ? void 0 : _attribute$attributes2.filter((attr) => attr.required !== false).map((attr) => attr.name);
				if (attribute.type === "object[]") return {
					type: "array",
					items: {
						type: "object",
						...properties && { properties },
						...required && required.length > 0 && { required }
					},
					description: attribute.description
				};
				return {
					type: "object",
					description: attribute.description,
					...properties && { properties },
					...required && required.length > 0 && { required }
				};
			default:
				var _attribute$type;
				if ((_attribute$type = attribute.type) === null || _attribute$type === void 0 ? void 0 : _attribute$type.endsWith("[]")) return {
					type: "array",
					items: { type: attribute.type.slice(0, -2) },
					description: attribute.description
				};
				return {
					type: "string",
					description: attribute.description
				};
		}
	}
	function convertJsonSchemaToZodSchema(jsonSchema, required) {
		if (jsonSchema.type === "object") {
			const spec = {};
			if (!jsonSchema.properties || !Object.keys(jsonSchema.properties).length) return !required ? zod.z.object(spec).optional() : zod.z.object(spec);
			for (const [key, value] of Object.entries(jsonSchema.properties)) spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
			let schema = zod.z.object(spec).describe(jsonSchema.description);
			return required ? schema : schema.optional();
		} else if (jsonSchema.type === "string") {
			if (jsonSchema.enum && jsonSchema.enum.length > 0) {
				let schema = zod.z.enum(jsonSchema.enum).describe(jsonSchema.description);
				return required ? schema : schema.optional();
			}
			let schema = zod.z.string().describe(jsonSchema.description);
			return required ? schema : schema.optional();
		} else if (jsonSchema.type === "number") {
			let schema = zod.z.number().describe(jsonSchema.description);
			return required ? schema : schema.optional();
		} else if (jsonSchema.type === "boolean") {
			let schema = zod.z.boolean().describe(jsonSchema.description);
			return required ? schema : schema.optional();
		} else if (jsonSchema.type === "array") {
			let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, true);
			let schema = zod.z.array(itemSchema).describe(jsonSchema.description);
			return required ? schema : schema.optional();
		}
		throw new Error("Invalid JSON schema");
	}
	function getZodParameters(parameters) {
		if (!parameters) return zod.z.object({});
		return convertJsonSchemaToZodSchema(actionParametersToJsonSchema(parameters), true);
	}

//#endregion
//#region src/utils/random-id.ts
	function randomId() {
		return "ck-" + (0, uuid.v4)();
	}
	function randomUUID() {
		return (0, uuid.v4)();
	}
	/**
	* Recursively converts an object to a serializable form by converting functions to their string representation.
	*/
	function toSerializable(value) {
		if (typeof value === "function") return value.toString();
		if (Array.isArray(value)) return value.map(toSerializable);
		if (value !== null && typeof value === "object") {
			const result = {};
			for (const key of Object.keys(value)) result[key] = toSerializable(value[key]);
			return result;
		}
		return value;
	}
	function dataToUUID(input, namespace) {
		const BASE_NAMESPACE = "e4b01160-ff74-4c6e-9b27-d53cd930fe8e";
		const boundNamespace = namespace ? (0, uuid.v5)(namespace, BASE_NAMESPACE) : BASE_NAMESPACE;
		return (0, uuid.v5)(typeof input === "string" ? input : JSON.stringify(toSerializable(input)), boundNamespace);
	}
	function isValidUUID(uuid$1) {
		return (0, uuid.validate)(uuid$1);
	}

//#endregion
//#region src/utils/requests.ts
/**
	* Safely read a Response/Request body with sensible defaults:
	* - clones the response/request to avoid consuming the original response/request
	* - Skips GET/HEAD
	* - Tries JSON first regardless of content-type
	* - Falls back to text and optionally parses when it "looks" like JSON
	*/
	async function readBody(r) {
		const method = "method" in r ? r.method.toUpperCase() : void 0;
		if (method === "GET" || method === "HEAD") return;
		if (!("body" in r) || r.body == null) return;
		try {
			return await r.clone().json();
		} catch (_unused) {
			try {
				const text = await r.clone().text();
				const trimmed = text.trim();
				if (trimmed.length === 0) return text;
				if (trimmed.startsWith("{") || trimmed.startsWith("[")) try {
					return JSON.parse(trimmed);
				} catch (_unused2) {
					return text;
				}
				return text;
			} catch (_unused3) {
				try {
					var _c$body;
					const stream = (_c$body = r.clone().body) !== null && _c$body !== void 0 ? _c$body : null;
					if (!stream) return void 0;
					const reader = stream.getReader();
					const decoder = new TextDecoder();
					let out = "";
					while (true) {
						const { done, value } = await reader.read();
						if (done) break;
						if (typeof value === "string") out += value;
						else out += decoder.decode(value, { stream: true });
					}
					out += decoder.decode();
					const trimmed = out.trim();
					if (trimmed.length === 0) return out;
					if (trimmed.startsWith("{") || trimmed.startsWith("[")) try {
						return JSON.parse(trimmed);
					} catch (_unused4) {
						return out;
					}
					return out;
				} catch (_unused5) {
					return;
				}
			}
		}
	}

//#endregion
//#region src/utils/index.ts
/**
	* Safely parses a JSON string into an object
	* @param json The JSON string to parse
	* @param fallback Optional fallback value to return if parsing fails. If not provided or set to "unset", returns null
	* @returns The parsed JSON object, or the fallback value (or null) if parsing fails
	*/
	function parseJson(json, fallback = "unset") {
		try {
			return JSON.parse(json);
		} catch (e) {
			return fallback === "unset" ? null : fallback;
		}
	}
	/**
	* Maps an array of items to a new array, skipping items that throw errors during mapping
	* @param items The array to map
	* @param callback The mapping function to apply to each item
	* @returns A new array containing only the successfully mapped items
	*/
	function tryMap(items, callback) {
		return items.reduce((acc, item, index, array) => {
			try {
				acc.push(callback(item, index, array));
			} catch (error) {
				console.error(error);
			}
			return acc;
		}, []);
	}
	/**
	* Checks if the current environment is macOS
	* @returns {boolean} True if running on macOS, false otherwise
	*/
	function isMacOS() {
		return /Mac|iMac|Macintosh/i.test(navigator.userAgent);
	}

//#endregion
//#region src/constants/index.ts
	const COPILOT_CLOUD_API_URL = "https://api.cloud.copilotkit.ai";
	const COPILOT_CLOUD_VERSION = "v1";
	const COPILOT_CLOUD_CHAT_URL = `${COPILOT_CLOUD_API_URL}/copilotkit/${COPILOT_CLOUD_VERSION}`;
	const COPILOT_CLOUD_PUBLIC_API_KEY_HEADER = "X-CopilotCloud-Public-Api-Key";

//#endregion
//#region src/telemetry/utils.ts
	function flattenObject(obj, parentKey = "", res = {}) {
		for (let key in obj) {
			const propName = parentKey ? `${parentKey}.${key}` : key;
			if (typeof obj[key] === "object" && obj[key] !== null) flattenObject(obj[key], propName, res);
			else res[propName] = obj[key];
		}
		return res;
	}

//#endregion
//#region package.json
	var version = "1.54.0";

//#endregion
//#region src/telemetry/scarf-client.ts
	const SCARF_BASE_URL = `https://copilotkit.gateway.scarf.sh/${version}`;
	var ScarfClient = class {
		constructor() {}
		async logEvent(properties) {
			try {
				const controller = new AbortController();
				const timeoutId = setTimeout(() => controller.abort(), 3e3);
				const queryParams = new URLSearchParams();
				Object.entries(properties).forEach(([key, value]) => {
					if (value !== null && value !== void 0) queryParams.append(key, String(value));
				});
				const url = `${SCARF_BASE_URL}?${queryParams.toString()}`;
				const response = await fetch(url, {
					method: "GET",
					signal: controller.signal
				});
				clearTimeout(timeoutId);
				if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
			} catch (_unused) {}
		}
	};
	var scarf_client_default = new ScarfClient();

//#endregion
//#region src/telemetry/telemetry-client.ts
/**
	* Checks if telemetry is disabled via environment variables.
	* Users can opt out by setting:
	* - COPILOTKIT_TELEMETRY_DISABLED=true or COPILOTKIT_TELEMETRY_DISABLED=1
	* - DO_NOT_TRACK=true or DO_NOT_TRACK=1
	*/
	function isTelemetryDisabled() {
		return process.env.COPILOTKIT_TELEMETRY_DISABLED === "true" || process.env.COPILOTKIT_TELEMETRY_DISABLED === "1" || process.env.DO_NOT_TRACK === "true" || process.env.DO_NOT_TRACK === "1";
	}
	var TelemetryClient = class {
		constructor({ packageName, packageVersion, telemetryDisabled, telemetryBaseUrl, sampleRate }) {
			this.globalProperties = {};
			this.cloudConfiguration = null;
			this.telemetryDisabled = false;
			this.sampleRate = .05;
			this.anonymousId = `anon_${(0, uuid.v4)()}`;
			this.packageName = packageName;
			this.packageVersion = packageVersion;
			this.telemetryDisabled = telemetryDisabled || isTelemetryDisabled();
			if (this.telemetryDisabled) return;
			this.setSampleRate(sampleRate);
			this.segment = new _segment_analytics_node.Analytics({ writeKey: process.env.COPILOTKIT_SEGMENT_WRITE_KEY || "n7XAZtQCGS2v1vvBy3LgBCv2h3Y8whja" });
			this.setGlobalProperties({
				"copilotkit.package.name": packageName,
				"copilotkit.package.version": packageVersion
			});
		}
		shouldSendEvent() {
			return Math.random() < this.sampleRate;
		}
		async capture(event, properties) {
			if (!this.shouldSendEvent() || !this.segment) return;
			const flattenedProperties = flattenObject(properties);
			const propertiesWithGlobal = {
				...this.globalProperties,
				...flattenedProperties
			};
			const orderedPropertiesWithGlobal = Object.keys(propertiesWithGlobal).sort().reduce((obj, key) => {
				obj[key] = propertiesWithGlobal[key];
				return obj;
			}, {});
			this.segment.track({
				anonymousId: this.anonymousId,
				event,
				properties: { ...orderedPropertiesWithGlobal }
			});
			await scarf_client_default.logEvent({ event });
		}
		setGlobalProperties(properties) {
			const flattenedProperties = flattenObject(properties);
			this.globalProperties = {
				...this.globalProperties,
				...flattenedProperties
			};
		}
		setCloudConfiguration(properties) {
			this.cloudConfiguration = properties;
			this.setGlobalProperties({ cloud: {
				publicApiKey: properties.publicApiKey,
				baseUrl: properties.baseUrl
			} });
		}
		setSampleRate(sampleRate) {
			let _sampleRate;
			_sampleRate = sampleRate !== null && sampleRate !== void 0 ? sampleRate : .05;
			if (process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE) _sampleRate = parseFloat(process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE);
			if (_sampleRate < 0 || _sampleRate > 1) throw new Error("Sample rate must be between 0 and 1");
			this.sampleRate = _sampleRate;
			this.setGlobalProperties({
				sampleRate: this.sampleRate,
				sampleRateAdjustmentFactor: 1 - this.sampleRate,
				sampleWeight: 1 / this.sampleRate
			});
		}
	};

//#endregion
//#region src/index.ts
	const COPILOTKIT_VERSION = version;

//#endregion
exports.BANNER_ERROR_NAMES = BANNER_ERROR_NAMES;
exports.COPILOTKIT_VERSION = COPILOTKIT_VERSION;
exports.COPILOT_CLOUD_API_URL = COPILOT_CLOUD_API_URL;
exports.COPILOT_CLOUD_CHAT_URL = COPILOT_CLOUD_CHAT_URL;
exports.COPILOT_CLOUD_ERROR_NAMES = COPILOT_CLOUD_ERROR_NAMES;
exports.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER = COPILOT_CLOUD_PUBLIC_API_KEY_HEADER;
exports.COPILOT_CLOUD_VERSION = COPILOT_CLOUD_VERSION;
exports.ConfigurationError = ConfigurationError;
exports.ConsoleColors = ConsoleColors;
exports.ConsoleStyles = ConsoleStyles;
exports.CopilotKitAgentDiscoveryError = CopilotKitAgentDiscoveryError;
exports.CopilotKitApiDiscoveryError = CopilotKitApiDiscoveryError;
exports.CopilotKitError = CopilotKitError;
exports.CopilotKitErrorCode = CopilotKitErrorCode;
exports.CopilotKitLowLevelError = CopilotKitLowLevelError;
exports.CopilotKitMisuseError = CopilotKitMisuseError;
exports.CopilotKitRemoteEndpointDiscoveryError = CopilotKitRemoteEndpointDiscoveryError;
exports.CopilotKitVersionMismatchError = CopilotKitVersionMismatchError;
exports.ERROR_CONFIG = ERROR_CONFIG;
exports.ERROR_NAMES = ERROR_NAMES;
exports.ErrorVisibility = ErrorVisibility;
exports.MissingPublicApiKeyError = MissingPublicApiKeyError;
exports.ResolvedCopilotKitError = ResolvedCopilotKitError;
exports.Severity = Severity;
exports.TelemetryClient = TelemetryClient;
exports.UpgradeRequiredError = UpgradeRequiredError;
exports.actionParametersToJsonSchema = actionParametersToJsonSchema;
exports.convertJsonSchemaToZodSchema = convertJsonSchemaToZodSchema;
exports.dataToUUID = dataToUUID;
exports.ensureStructuredError = ensureStructuredError;
exports.executeConditions = executeConditions;
exports.getPossibleVersionMismatch = getPossibleVersionMismatch;
exports.getZodParameters = getZodParameters;
exports.isMacOS = isMacOS;
exports.isStructuredCopilotKitError = isStructuredCopilotKitError;
exports.isTelemetryDisabled = isTelemetryDisabled;
exports.isValidUUID = isValidUUID;
exports.jsonSchemaToActionParameters = jsonSchemaToActionParameters;
exports.logCopilotKitPlatformMessage = logCopilotKitPlatformMessage;
exports.logStyled = logStyled;
exports.parseJson = parseJson;
exports.publicApiKeyRequired = publicApiKeyRequired;
exports.randomId = randomId;
exports.randomUUID = randomUUID;
exports.readBody = readBody;
exports.styledConsole = styledConsole;
exports.tryMap = tryMap;
});
//# sourceMappingURL=index.umd.js.map