1021 lines
41 KiB
JavaScript
1021 lines
41 KiB
JavaScript
(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
|