@copilotkit/core 1.63.1 → 1.63.2-canary.1784918757

package/dist/index.cjs

@@ -602,6 +602,12 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 	get capabilities() {
 		return this._capabilities;
 	}
+	requestInit(input) {
+		return {
+			...super.requestInit(input),
+			...this.credentials ? { credentials: this.credentials } : {}
+		};
+	}
 	async getCapabilities() {
 		return this._capabilities ?? {};
 	}
@@ -695,10 +701,12 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		}
 	}
 	connect(input) {
+		if (this.runtimeMode === "pending" || this.transport === "auto" && this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return (0, rxjs.defer)(() => (0, rxjs.from)(this.ensureRuntimeConfiguration())).pipe((0, rxjs_operators.switchMap)(() => this.connect(input)));
 		if (this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return this.#connectViaDelegate(input);
 		return this.#connectViaHttp(input);
 	}
 	run(input) {
+		if (this.runtimeMode === "pending" || this.transport === "auto" && this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return (0, rxjs.defer)(() => (0, rxjs.from)(this.ensureRuntimeConfiguration())).pipe((0, rxjs_operators.switchMap)(() => this.run(input)));
 		if (this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return this.#runViaDelegate(input);
 		return this.#runViaHttp(input);
 	}
@@ -768,7 +776,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		this.delegate?.clearReconnectCursor?.(threadId);
 	}
 	async resolveDelegate() {
-		await this.ensureRuntimeMode();
+		await this.ensureRuntimeConfiguration();
 		if (!this.delegate) {
 			if (this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) throw new Error("A delegate is only created for Intelligence mode");
 			this.delegate = this.createIntelligenceDelegate();
@@ -776,14 +784,21 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		this.syncDelegate(this.delegate);
 		return this.delegate;
 	}
-	async ensureRuntimeMode() {
-		if (this.runtimeMode !== "pending") return;
+	/** Resolve transport and runtime mode before the first outbound request. */
+	async ensureRuntimeConfiguration() {
+		if (this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE || this.runtimeMode !== "pending" && this.transport !== "auto") return;
 		if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
-		this.runtimeInfoPromise ??= this.fetchRuntimeInfo().then((runtimeInfo) => {
+		const runtimeInfoPromise = this.runtimeInfoPromise ?? this.fetchRuntimeInfo().then((runtimeInfo) => {
 			this.runtimeMode = runtimeInfo.mode ?? _copilotkit_shared.RUNTIME_MODE_SSE;
 			this.intelligence = runtimeInfo.intelligence;
 		});
-		await this.runtimeInfoPromise;
+		this.runtimeInfoPromise = runtimeInfoPromise;
+		try {
+			await runtimeInfoPromise;
+		} catch (error) {
+			if (this.runtimeInfoPromise === runtimeInfoPromise) this.runtimeInfoPromise = void 0;
+			throw error;
+		}
 	}
 	async fetchRuntimeInfo() {
 		const headers = { ...this.headers };
@@ -1738,6 +1753,19 @@ const SUGGEST_TOOL = {
 //#endregion
 //#region src/core/run-handler.ts
 /**
+* Absolute safety cap on the depth of recursive follow-up runs triggered by
+* `processAgentResult`. Without this, any scenario that keeps
+* `needsFollowUp = true` (e.g. the LLM repeatedly calling the same tool, a
+* backend that errors after receiving tool results, or input processors that
+* reprocess tool messages) would loop indefinitely, silently consuming API
+* quota and potentially DOS'ing the backend.
+*
+* The cap is deliberately high so that legitimate multi-step agent workflows
+* (search → fill form → confirm → update → send email, etc.) are never
+* affected; it only trips on runaway recursion.
+*/
+const MAX_FOLLOW_UP_DEPTH = 100;
+/**
 * Handles agent execution, tool calling, and agent connectivity for CopilotKitCore.
 * Manages the complete lifecycle of agent runs including tool execution and follow-ups.
 */
@@ -1992,7 +2020,8 @@ var RunHandler = class {
 				}
 			}
 		}
-		if (needsFollowUp && !this._runAbortController?.signal.aborted) {
+		if (needsFollowUp && !this._runAbortController?.signal.aborted) if (this._runDepth >= MAX_FOLLOW_UP_DEPTH) _copilotkit_shared.logger.warn(`[CopilotKit] Follow-up depth limit (${MAX_FOLLOW_UP_DEPTH}) reached for agent "${agentId}". Stopping recursive follow-up runs to prevent an infinite loop. This usually indicates a tool that keeps requesting a follow-up (e.g. the LLM repeatedly calling the same tool). Consider setting "followUp: false" on the offending tool.`);
+		else {
 			await this._internal.waitForPendingFrameworkUpdates();
 			return await this.runAgent({ agent });
 		}
@@ -2315,6 +2344,7 @@ var RunHandler = class {
 				await emitAgentError(error, error instanceof AgentThreadLockedError ? CopilotKitCoreErrorCode.AGENT_THREAD_LOCKED : CopilotKitCoreErrorCode.AGENT_RUN_FAILED_EVENT, { source: "onRunFailed" });
 			},
 			onRunErrorEvent: async ({ event }) => {
+				if (this._runAbortController?.signal.aborted === true || event?.code === "abort") return;
 				const eventError = event?.rawEvent instanceof Error ? event.rawEvent : event?.rawEvent?.error instanceof Error ? event.rawEvent.error : void 0;
 				const errorMessage = typeof event?.rawEvent?.error === "string" ? event.rawEvent.error : event?.message ?? "Agent run error";
 				const rawError = eventError ?? new Error(errorMessage);
@@ -5248,6 +5278,111 @@ function ɵisCopilotKitFeature(name) {
 	return FEATURE_SET.has(name);
 }
 
+//#endregion
+//#region src/interrupt-state.ts
+function toolResultContent(response) {
+	if (response.status === "cancelled") return JSON.stringify({ status: "cancelled" });
+	return JSON.stringify(response.payload ?? { status: "resolved" });
+}
+/**
+* @internal Framework-neutral interrupt response state shared by framework
+* adapters. Application authors must not depend on this API.
+*/
+var ɵInterruptState = class {
+	#responses = {};
+	#pending = null;
+	#sealed = false;
+	/** Return the active normalized interrupt without exposing mutable state. */
+	get pending() {
+		const pending = this.#pending;
+		if (pending?.kind === "standard") return {
+			kind: "standard",
+			interrupts: [...pending.interrupts]
+		};
+		return pending;
+	}
+	/** Replace the current interrupt with a legacy custom-event interrupt. */
+	setLegacy(event) {
+		this.#replace({
+			kind: "legacy",
+			event
+		});
+	}
+	/** Replace the current interrupt with an AG-UI standard interrupt set. */
+	setStandard(interrupts) {
+		this.#replace({
+			kind: "standard",
+			interrupts: [...interrupts]
+		});
+	}
+	/** Clear all pending interrupt data and accumulated responses. */
+	clear() {
+		this.#pending = null;
+		this.#sealed = false;
+		for (const id of Object.keys(this.#responses)) delete this.#responses[id];
+	}
+	/** Record a resolved response and return the next framework action. */
+	resolve(payload, interruptId) {
+		const pending = this.#pending;
+		if (!pending || this.#sealed) return { kind: "ignored" };
+		if (pending.kind === "legacy") {
+			this.#sealed = true;
+			return {
+				kind: "legacy-resume",
+				payload,
+				interruptValue: pending.event.value
+			};
+		}
+		return this.#respond(pending.interrupts, interruptId, {
+			status: "resolved",
+			payload
+		});
+	}
+	/** Record a cancelled response and return the next framework action. */
+	cancel(interruptId) {
+		const pending = this.#pending;
+		if (!pending || this.#sealed) return { kind: "ignored" };
+		if (pending.kind === "legacy") {
+			this.#sealed = true;
+			return { kind: "dismiss" };
+		}
+		return this.#respond(pending.interrupts, interruptId, { status: "cancelled" });
+	}
+	#replace(pending) {
+		this.clear();
+		this.#pending = pending;
+	}
+	#respond(interrupts, interruptId, response) {
+		const id = interruptId ?? interrupts[0]?.id;
+		if (!id || !interrupts.some((interrupt) => interrupt.id === id)) return { kind: "ignored" };
+		this.#responses[id] = response;
+		if (!interrupts.every((interrupt) => this.#responses[interrupt.id])) return { kind: "waiting" };
+		const expired = interrupts.find((interrupt) => (0, _ag_ui_client.isInterruptExpired)(interrupt));
+		if (expired) {
+			this.#sealed = true;
+			return {
+				kind: "expired",
+				interrupt: expired
+			};
+		}
+		const mutableInterrupts = [...interrupts];
+		const resume = (0, _ag_ui_client.buildResumeArray)(mutableInterrupts, this.#responses);
+		const toolResults = mutableInterrupts.flatMap((interrupt) => {
+			if (!interrupt.toolCallId) return [];
+			return [{
+				toolCallId: interrupt.toolCallId,
+				content: toolResultContent(this.#responses[interrupt.id])
+			}];
+		});
+		this.#sealed = true;
+		return {
+			kind: "resume",
+			resume,
+			toolResults
+		};
+	}
+};
+
 //#endregion
 exports.AgentRegistry = AgentRegistry;
 exports.AgentThreadLockedError = AgentThreadLockedError;
@@ -5279,6 +5414,7 @@ exports.parseToolArguments = parseToolArguments;
 exports.props = props;
 exports.select = select;
 exports.ɵCOPILOTKIT_FEATURES = ɵCOPILOTKIT_FEATURES;
+exports.ɵInterruptState = ɵInterruptState;
 exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
 exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;