@copilotkit/runtime 1.66.1 → 1.66.2-canary.1785878925

package/dist/package.cjs

@@ -5,7 +5,7 @@ const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 var require_package = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
 	module.exports = {
 		"name": "@copilotkit/runtime",
-		"version": "1.66.1",
+		"version": "1.66.2-canary.1785878925",
 		"private": false,
 		"keywords": [
 			"ai",

package/dist/runtime/package.mjs

@@ -5,7 +5,7 @@ import { __commonJSMin } from "../_virtual/_rolldown/runtime.mjs";
 var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"name": "@copilotkit/runtime",
-		"version": "1.66.1",
+		"version": "1.66.2-canary.1785878925",
 		"private": false,
 		"keywords": [
 			"ai",

package/dist/v2/runtime/core/channel-manager.cjs

@@ -209,9 +209,21 @@ async function runCanonicalChannelAgent(runner, intelligence, lockTtlSeconds, lo
 				next: (event) => {
 					if (event.type !== _ag_ui_client.EventType.RUN_ERROR || terminalError) return;
 					const message = "message" in event && typeof event.message === "string" ? event.message : "Canonical Channel agent run failed";
-					terminalError = new Error(message);
+					const details = safeChannelRunErrorDetails(event);
+					terminalError = new Error(message, details ? { cause: details } : void 0);
 					terminalError.name = "ChannelCanonicalRunError";
 					if ("code" in event && typeof event.code === "string" && event.code.length > 0) terminalError.code = event.code;
+					if (details) {
+						terminalError.category = details.category;
+						terminalError.provider = details.provider;
+						terminalError.operation = details.operation;
+						terminalError.effectKind = details.effectKind;
+						terminalError.providerCode = details.providerCode;
+						terminalError.validationMessages = details.validationMessages;
+						terminalError.retryable = details.retryable;
+						terminalError.deliveryId = details.deliveryId;
+						terminalError.details = details;
+					}
 				},
 				error: reject,
 				complete: () => {
@@ -238,6 +250,25 @@ async function runCanonicalChannelAgent(runner, intelligence, lockTtlSeconds, lo
 	}
 	return result;
 }
+function safeChannelRunErrorDetails(event) {
+	if (!("details" in event) || typeof event.details !== "object" || event.details === null || Array.isArray(event.details)) return;
+	const details = event.details;
+	const allowed = new Set([
+		"category",
+		"provider",
+		"operation",
+		"effectKind",
+		"providerCode",
+		"validationMessages",
+		"retryable",
+		"deliveryId"
+	]);
+	if (!Object.keys(details).every((field) => allowed.has(field)) || details.category !== "validation" || details.provider !== "slack" && details.provider !== "teams" || !boundedString(details.operation, 80) || !boundedString(details.effectKind, 80) || details.providerCode !== "invalid_arguments" && details.providerCode !== "invalid_blocks" || details.retryable !== false || !boundedString(details.deliveryId, 512) || !Array.isArray(details.validationMessages) || details.validationMessages.length > 5 || !details.validationMessages.every((validationMessage) => typeof validationMessage === "string" && validationMessage.length <= 256 && validationMessage.startsWith("invalid field at /"))) return;
+	return details;
+}
+function boundedString(value, maxLength) {
+	return typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
 /** Convert canonical Intelligence history into AG-UI messages. */
 async function toAgentMessage(message, intelligence) {
 	const content = await hydrateManagedContent(message.content, intelligence);
@@ -289,6 +320,12 @@ async function hydrateManagedContent(content, intelligence) {
 function isSetupRequired(err) {
 	return err instanceof ChannelSetupRequiredError || typeof err === "object" && err !== null && err.code === "SETUP_REQUIRED";
 }
+/** Whether a failed initial activation can recover without new configuration. */
+function isRetryableActivationError(err) {
+	if (typeof err !== "object" || err === null) return false;
+	const value = err;
+	return (value.code === "GATEWAY_UNREACHABLE" || value.code === "GATEWAY_JOIN_FAILED") && value.retryable === true;
+}
 /**
 * Whether `err` is a Node/runtime module-resolution failure — i.e. the error
 * a dynamic `import()` throws when the target package is not installed.
@@ -302,8 +339,14 @@ function isModuleNotFound(err) {
 }
 /** Default deadline (ms) for a single `handle.stop()` during teardown. */
 const DEFAULT_STOP_HANDLE_TIMEOUT_MS = 5e3;
-/** Default cadence (ms) for the "still down" log while a session is dropped. */
+/** First delay (ms) before logging that a dropped session is still down. */
 const DEFAULT_RECONNECT_LOG_INTERVAL_MS = 3e4;
+/** Longest delay (ms) between reminders during one continuous outage. */
+const DEFAULT_RECONNECT_LOG_MAX_INTERVAL_MS = 15 * 6e4;
+/** First delay (ms) before retrying a transient initial activation failure. */
+const DEFAULT_ACTIVATION_RETRY_DELAY_MS = 1e3;
+/** Longest delay (ms) between transient initial activation attempts. */
+const DEFAULT_ACTIVATION_RETRY_MAX_DELAY_MS = 3e4;
 /**
 * Reject with `timeoutMessage` after `timeoutMs` if `inner` has not settled,
 * otherwise pass `inner` through. When `timeoutMs` is undefined, `inner` is
@@ -336,17 +379,18 @@ function withTimeout(inner, timeoutMs, timeoutMessage) {
 * {@link activate} starts it and a second call is a no-op. Activation throws
 * SYNCHRONOUSLY (a {@link ChannelConfigError}) only for a misconfiguration it
 * can detect up front — a duplicate or missing Channel name. Every OTHER
-* activation failure is recorded as the Channel's status (`error`, or
-* `setup_required` for a missing provider) and surfaced through {@link status}
-* and {@link ready} rather than thrown.
+* permanent activation failure is recorded as the Channel's status (`error`,
+* or `setup_required` for a missing provider) and surfaced through
+* {@link status} and {@link ready} rather than thrown. A retryable initial
+* gateway outage stays unsettled and retries until it connects or the manager
+* stops.
 *
-* Reconnection is NOT handled here — it is delegated to the Phoenix connection
+* Established-session reconnection is delegated to the Phoenix connection
 * layer that backs the launcher. When a managed control socket drops, Phoenix's
-* `Socket` reconnects and rejoins with the same Runtime declaration. Active
-* deliveries request fresh one-use join tokens through that control link. A
-* re-activation here would be both redundant AND broken: re-invoking the engine
-* on an already-started `Channel` throws in `channel.addAdapter` (started=true).
-* The manager therefore never re-activates on a drop.
+* `Socket` reconnects and rejoins with the same Runtime declaration. The manager
+* never re-activates an already-started Channel. It does retry a transient
+* INITIAL gateway activation failure: that happens before the launcher adds or
+* starts the managed adapter, so a later attempt is safe.
 *
 * It DOES, however, reflect real connection health through the session's
 * `onStateChange` observer so {@link ChannelManager.status} stays honest rather
@@ -381,8 +425,8 @@ var ChannelManager = class {
 	/**
 	* Start activation of every declared Channel (lazy + idempotent). Mints a
 	* distinct runtime instance id per Channel, derives its activation config,
-	* and calls the engine. Records each Channel as `connecting`, transitioning
-	* to `online`/`setup_required`/`error` as its activation settles.
+	* and calls the engine. Transient gateway failures retry with exponential
+	* backoff; other outcomes transition to `online`/`setup_required`/`error`.
 	*/
 	activate() {
 		if (this.activated || this.stopped) return;
@@ -399,24 +443,23 @@ var ChannelManager = class {
 				rejectSettled = reject;
 			});
 			settled.catch(() => {});
+			const entry = {
+				status: "connecting",
+				handle: void 0,
+				handleStopped: false,
+				settled
+			};
 			let activation;
-			let config;
 			try {
-				config = require_channel_activation_config.deriveChannelActivationConfig({
+				const config = require_channel_activation_config.deriveChannelActivationConfig({
 					intelligence: this.intelligence,
 					channel,
 					runtimeInstanceId
 				});
-				activation = this.activateChannel(config, channel);
+				activation = this.activateWithRetry(config, channel, name, entry);
 			} catch (err) {
 				activation = Promise.reject(err);
 			}
-			const entry = {
-				status: "connecting",
-				handle: void 0,
-				handleStopped: false,
-				settled
-			};
 			activation.then(async (handle) => {
 				entry.handle = handle;
 				if (this.stopped) {
@@ -469,6 +512,54 @@ var ChannelManager = class {
 		}
 	}
 	/**
+	* Retry only transient failures from the pre-adapter gateway connection.
+	* Permanent errors reject on the first attempt; teardown cancels a pending
+	* timer while preserving the existing late-settle handling for in-flight work.
+	*/
+	activateWithRetry(config, channel, name, entry) {
+		return new Promise((resolve, reject) => {
+			const attempt = () => {
+				let activation;
+				try {
+					activation = this.activateChannel(config, channel);
+				} catch (err) {
+					activation = Promise.reject(err);
+				}
+				activation.then((handle) => {
+					this.clearActivationRetry(entry);
+					resolve(handle);
+				}, (err) => {
+					if (this.stopped || !isRetryableActivationError(err)) {
+						this.clearActivationRetry(entry);
+						reject(err);
+						return;
+					}
+					const delayMs = entry.activationRetryDelayMs ?? DEFAULT_ACTIVATION_RETRY_DELAY_MS;
+					entry.status = "reconnecting";
+					entry.activationRetryDelayMs = Math.min(delayMs * 2, DEFAULT_ACTIVATION_RETRY_MAX_DELAY_MS);
+					this.log?.(`channel "${name}" failed to activate; retrying in ${delayMs}ms`, err);
+					const timer = setTimeout(() => {
+						entry.activationRetryTimer = void 0;
+						entry.cancelActivationRetry = void 0;
+						if (this.stopped || entry.status === "stopped") {
+							reject(err);
+							return;
+						}
+						entry.status = "connecting";
+						attempt();
+					}, delayMs);
+					timer.unref?.();
+					entry.activationRetryTimer = timer;
+					entry.cancelActivationRetry = () => {
+						this.clearActivationRetry(entry);
+						reject(err);
+					};
+				});
+			};
+			attempt();
+		});
+	}
+	/**
 	* Throw if two declared Channels share a `name`. `entries` is keyed by name,
 	* so a duplicate would overwrite the first Channel's entry and leak its live
 	* session. Called at the very start of {@link activate}, before any engine
@@ -611,29 +702,49 @@ var ChannelManager = class {
 		return entry.downSince === void 0 ? "unknown" : `${Math.round((Date.now() - entry.downSince) / 1e3)}s`;
 	}
 	/**
-	* Repeat a "still down" line for as long as this outage lasts. Runs THROUGH
-	* `gave_up` on purpose: that transition is where the old behavior went quiet,
-	* and an operator watching a silent process cannot tell a dead bot from an
-	* idle one.
+	* Repeat a "still down" line for as long as this outage lasts, with an
+	* exponential delay capped at 15 minutes. Runs THROUGH `gave_up` on purpose:
+	* that transition is where the old behavior went quiet, and an operator
+	* watching a silent process cannot tell a dead bot from an idle one.
 	*/
 	startReconnectLog(name, entry) {
 		if (entry.reconnectLogTimer !== void 0) return;
-		const timer = setInterval(() => {
+		const delayMs = entry.reconnectLogDelayMs ?? this.reconnectLogIntervalMs;
+		const timer = setTimeout(() => {
+			entry.reconnectLogTimer = void 0;
 			if (this.stopped || entry.status === "stopped") {
 				this.clearReconnectLog(entry);
 				return;
 			}
 			this.log?.(`channel "${name}" managed session still down after ${this.downFor(entry)}; Phoenix is retrying`);
-		}, this.reconnectLogIntervalMs);
+			entry.reconnectLogDelayMs = Math.min(delayMs * 2, Math.max(this.reconnectLogIntervalMs, DEFAULT_RECONNECT_LOG_MAX_INTERVAL_MS));
+			this.startReconnectLog(name, entry);
+		}, delayMs);
 		timer.unref?.();
 		entry.reconnectLogTimer = timer;
 	}
 	/** Stop this entry's "still down" repeat, if one is running. */
 	clearReconnectLog(entry) {
 		if (entry.reconnectLogTimer !== void 0) {
-			clearInterval(entry.reconnectLogTimer);
+			clearTimeout(entry.reconnectLogTimer);
 			entry.reconnectLogTimer = void 0;
 		}
+		entry.reconnectLogDelayMs = void 0;
+	}
+	/** Cancel a pending transient activation retry and reset its backoff. */
+	clearActivationRetry(entry) {
+		if (entry.activationRetryTimer !== void 0) {
+			clearTimeout(entry.activationRetryTimer);
+			entry.activationRetryTimer = void 0;
+		}
+		entry.activationRetryDelayMs = void 0;
+		entry.cancelActivationRetry = void 0;
+	}
+	/** Cancel a scheduled activation retry and settle its wrapper. */
+	cancelActivationRetry(entry) {
+		const cancel = entry.cancelActivationRetry;
+		if (cancel) cancel();
+		else this.clearActivationRetry(entry);
 	}
 	/**
 	* Drive a single entry to its terminal `stopped` state, tearing down its
@@ -670,6 +781,7 @@ var ChannelManager = class {
 	async stopEntry(entry) {
 		entry.status = "stopped";
 		this.clearReconnectLog(entry);
+		this.cancelActivationRetry(entry);
 		if (entry.handle && !entry.handleStopped) {
 			entry.handleStopped = true;
 			const handle = entry.handle;