@copilotkit/core 1.63.2 → 1.64.0

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 ?? {};
 	}
@@ -1747,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.
 */
@@ -1981,33 +2000,64 @@ var RunHandler = class {
 		const agentId = agent.agentId;
 		let needsFollowUp = false;
 		if (executeFrontendTools) {
-			for (const message of newMessages) if (message.role === "assistant") {
-				for (const toolCall of message.toolCalls || []) if (newMessages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id) === -1) {
-					const tool = this.getTool({
-						toolName: toolCall.function.name,
+			for (const message of newMessages) if (message.role === "assistant") for (const toolCall of message.toolCalls || []) {
+				const tool = this.getTool({
+					toolName: toolCall.function.name,
+					agentId: agent.agentId
+				});
+				let wildcardTool;
+				const getWildcardTool = () => {
+					if (tool || wildcardTool) return wildcardTool;
+					wildcardTool = this.getTool({
+						toolName: "*",
 						agentId: agent.agentId
 					});
-					if (tool) {
-						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId)) needsFollowUp = true;
-					} else {
-						const wildcardTool = this.getTool({
-							toolName: "*",
-							agentId: agent.agentId
-						});
-						if (wildcardTool) {
-							if (await this.executeWildcardTool(wildcardTool, toolCall, message, agent, agentId)) needsFollowUp = true;
-						}
+					return wildcardTool;
+				};
+				let existingResultIndex = newMessages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+				const existingResult = existingResultIndex === -1 ? void 0 : newMessages[existingResultIndex];
+				const executableTool = tool ?? getWildcardTool();
+				if (existingResult && executableTool?.handler && this.isFrontendPlaceholderResult(existingResult)) {
+					newMessages.splice(existingResultIndex, 1);
+					existingResultIndex = -1;
+					const agentMsgIdx = agent.messages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+					if (agentMsgIdx !== -1) agent.messages.splice(agentMsgIdx, 1);
+				}
+				if (existingResultIndex === -1) if (tool) {
+					if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId)) needsFollowUp = true;
+				} else {
+					const fallbackTool = getWildcardTool();
+					if (fallbackTool) {
+						if (await this.executeWildcardTool(fallbackTool, toolCall, message, agent, agentId)) needsFollowUp = true;
 					}
 				}
 			}
 		}
-		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 });
 		}
 		this._internal.suggestionEngine.reloadSuggestions(agentId);
 		return runAgentResult;
 	}
+	isFrontendPlaceholderResult(message) {
+		if (message.role !== "tool") return false;
+		return this.normalizeToolResultContent(message.content) === "Forwarded to client";
+	}
+	normalizeToolResultContent(content) {
+		if (typeof content === "string") return content.trim();
+		if (Array.isArray(content)) {
+			const text = content.flatMap((part) => {
+				if (typeof part === "string") return [part];
+				if (part && typeof part === "object" && "text" in part && typeof part.text === "string") return [part.text];
+				return [];
+			}).join("").trim();
+			return text.length > 0 ? text : null;
+		}
+		if (content && typeof content === "object" && "text" in content && typeof content.text === "string") return content.text.trim();
+		return null;
+	}
 	/**
 	* Shared handler execution logic used by executeSpecificTool, executeWildcardTool, and runTool.
 	* Handles arg parsing, subscriber notifications, handler invocation, result stringification,
@@ -2106,13 +2156,15 @@ var RunHandler = class {
 		{
 			const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
 			if (messageIndex === -1) return false;
+			let insertAt = messageIndex + 1;
+			while (insertAt < agent.messages.length && agent.messages[insertAt]?.role === "tool") insertAt++;
 			const toolMessage = {
 				id: (0, _copilotkit_shared.randomUUID)(),
 				role: "tool",
 				toolCallId: toolCall.id,
 				content: handlerResult.result
 			};
-			agent.messages.splice(messageIndex + 1, 0, toolMessage);
+			agent.messages.splice(insertAt, 0, toolMessage);
 			if (!handlerResult.error && tool?.followUp !== false) return true;
 		}
 		return false;
@@ -2195,13 +2247,15 @@ var RunHandler = class {
 		{
 			const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
 			if (messageIndex === -1) return false;
+			let insertAt = messageIndex + 1;
+			while (insertAt < agent.messages.length && agent.messages[insertAt]?.role === "tool") insertAt++;
 			const toolMessage = {
 				id: (0, _copilotkit_shared.randomUUID)(),
 				role: "tool",
 				toolCallId: toolCall.id,
 				content: toolCallResult
 			};
-			agent.messages.splice(messageIndex + 1, 0, toolMessage);
+			agent.messages.splice(insertAt, 0, toolMessage);
 			if (!errorMessage && wildcardTool?.followUp !== false) return true;
 		}
 		return false;
@@ -2324,6 +2378,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);