@copilotkit/core 1.73.0 → 1.73.2-canary.1790068297

package/dist/index.mjs

@@ -379,16 +379,24 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	requestJoinCredentials$(mode, input, replayCursor) {
 		return defer(async () => {
 			try {
-				const response = await (this.config.fetch ?? globalFetch)(this.buildRuntimeUrl(mode), {
+				const requestFetch = this.config.fetch ?? globalFetch;
+				const body = {
+					...input,
+					...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
+				};
+				const single = this.config.transport === "single";
+				const response = await requestFetch(single ? this.config.runtimeUrl : this.buildRuntimeUrl(mode), {
 					method: "POST",
+					redirect: "error",
 					headers: {
 						"Content-Type": "application/json",
 						...this.headers
 					},
-					body: JSON.stringify({
-						...input,
-						...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
-					}),
+					body: JSON.stringify(single ? {
+						method: `agent/${mode}`,
+						params: { agentId: this.config.agentId },
+						body
+					} : body),
 					...this.credentials ? { credentials: this.credentials } : {}
 				});
 				if (response.status === 204 && mode === "connect") return null;
@@ -622,6 +630,90 @@ function isRuntimeInfoRequestError(error) {
 	return typeof error === "object" && error !== null && typeof error.runtimeInfoStatus === "number";
 }
 
+//#endregion
+//#region src/core/message-filter.ts
+function toolCallIdsOf(message) {
+	const calls = message.toolCalls;
+	if (!Array.isArray(calls)) return [];
+	return calls.map((call) => call.id).filter((id) => Boolean(id));
+}
+function resultCallIdOf(message) {
+	if (message.role !== "tool") return void 0;
+	return message.toolCallId;
+}
+/**
+* Repair the tool-call pairs a filter broke.
+*
+* Every provider rejects a half pair. A tool result whose call is gone reads as
+* a reply to nothing, and an assistant tool call whose result is gone leaves
+* the turn unanswered — the failure reporters hit on #1482 when a trimmed
+* history landed mid-HITL and Anthropic answered "a tool result is expected".
+* A filter written as `messages.slice(-1)` cannot know this, so the repair runs
+* for every filter rather than being something each caller opts into.
+*
+* Both repairs restore, never discard, and both are anchored on the untrimmed
+* thread:
+*
+* - A kept tool result whose assistant call was trimmed away gets that call put
+*   back in front of it. Dropping the result instead would be protocol-safe and
+*   semantically wrong: on a human-in-the-loop turn the result IS the new
+*   information, and a backend that already holds the call would be asked to
+*   resume with nothing.
+* - A kept assistant call whose result was trimmed gets that result restored,
+*   placed directly after the call.
+*
+* Restoring a call pulls in every result for that call, not only the one the
+* filter kept. Providers reject an assistant turn with a parallel tool call
+* left unanswered, so a half-answered set is as invalid as a missing one.
+*
+* A call with no result anywhere in `full` is left alone. That is an open call
+* (a pending frontend tool, an unanswered interrupt), not a broken pair. A
+* result whose call is nowhere in `full` is left alone too: it was already
+* unpaired before the filter ran, so it is not this function's to fix.
+*
+* The filter's own ordering is preserved. Restorations are the only insertions,
+* and messages the filter synthesized (absent from `full`) pass through
+* untouched.
+*/
+function ɵrepairToolCallPairs(kept, full) {
+	const callIdToIssuer = /* @__PURE__ */ new Map();
+	const callIdToResult = /* @__PURE__ */ new Map();
+	for (const message of full) {
+		for (const callId of toolCallIdsOf(message)) callIdToIssuer.set(callId, message);
+		const resultCallId = resultCallIdOf(message);
+		if (resultCallId !== void 0) callIdToResult.set(resultCallId, message);
+	}
+	const repaired = [];
+	const emitted = /* @__PURE__ */ new Set();
+	const emit = (message) => {
+		if (emitted.has(message.id)) return;
+		emitted.add(message.id);
+		repaired.push(message);
+	};
+	/** Emit an assistant turn together with every result it is owed. */
+	const emitWithResults = (message) => {
+		emit(message);
+		for (const callId of toolCallIdsOf(message)) {
+			const result = callIdToResult.get(callId);
+			if (result) emit(result);
+		}
+	};
+	for (const message of kept) {
+		const resultCallId = resultCallIdOf(message);
+		if (resultCallId === void 0) {
+			emitWithResults(message);
+			continue;
+		}
+		const issuer = callIdToIssuer.get(resultCallId);
+		if (issuer) {
+			emitWithResults(issuer);
+			continue;
+		}
+		emit(message);
+	}
+	return repaired;
+}
+
 //#endregion
 //#region src/agent.ts
 function hasHeaders(agent) {
@@ -660,6 +752,18 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	_capabilities;
 	delegate;
 	runtimeInfoPromise;
+	_messageFilter;
+	/**
+	* The HTTP `run` this agent started and has not yet seen finish, as the
+	* exact `{ threadId, runId }` it POSTed. `abortRun` narrows `/stop` to this
+	* run only while `threadId` still matches: `threadId` is a public field the
+	* host may reassign under a live run, and a runId from another thread must
+	* not be sent as if it were this thread's. Released when the run stream
+	* finalizes, cleared on `connect` (a reconnected thread may run under a
+	* runId this client never saw) and never copied by `clone`. Without a
+	* provable active run the stop stays thread-wide.
+	*/
+	activeRun;
 	constructor(config) {
 		const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
 		const transport = config.transport ?? "auto";
@@ -678,10 +782,47 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		this.runtimeMode = config.runtimeMode ?? RUNTIME_MODE_SSE;
 		this.intelligence = config.intelligence;
 		this._capabilities = config.capabilities;
+		this._messageFilter = config.messageFilter;
 		if (config.debug) this.debug = config.debug;
 		if (this.transport === "single") this.singleEndpointUrl = this.runtimeEndpointUrl;
 	}
 	/**
+	* Adopt the runtime mode a fresh `/info` just reported.
+	*
+	* A live proxy outlives the runtime configuration that minted it: a
+	* redeploy, an env-var change or a rollback can flip `intelligence` → `sse`
+	* under a page that is already open. The registry preserves the proxy across
+	* that re-sync on purpose — it is backing an open conversation — so the new
+	* mode is pushed onto the instance here instead of replacing it.
+	*
+	* Without this the mode was decided once, at construction, and `run()` kept
+	* taking the delegate path against a runtime serving plain SSE, where
+	* `response.json()` on a `text/event-stream` body throws for the rest of the
+	* page's life. See #7130.
+	*
+	* A delegate built for the old mode is torn down: it speaks a protocol the
+	* runtime no longer serves, and it may be holding a websocket open. The
+	* memoized `/info` promise goes with it — it answered for the old
+	* configuration, so a later `ensureRuntimeConfiguration()` must re-ask
+	* rather than treat that answer as current.
+	*
+	* Only `wsUrl` is compared on the Intelligence metadata, because that is the
+	* one field the delegate bakes in at construction.
+	*/
+	adoptRuntimeMode(runtimeMode, intelligence) {
+		const unchanged = this.runtimeMode === runtimeMode && this.intelligence?.wsUrl === intelligence?.wsUrl;
+		this.runtimeMode = runtimeMode;
+		this.intelligence = intelligence;
+		if (unchanged) return;
+		this.runtimeInfoPromise = void 0;
+		const staleDelegate = this.delegate;
+		this.delegate = void 0;
+		if (staleDelegate) {
+			staleDelegate.abortRun();
+			this.detachActiveRun();
+		}
+	}
+	/**
 	* The agent id used for outbound runtime requests — `runtimeAgentId` when
 	* set (manually-registered proxy), otherwise `agentId` (registry id
 	* matches runtime id). Subscriber bookkeeping keeps using `agentId`
@@ -699,6 +840,67 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	get capabilities() {
 		return this._capabilities;
 	}
+	/**
+	* The filter applied to the outbound message list on every run.
+	*
+	* Registry-owned. `AgentRegistry` writes it whenever the core-level filter
+	* changes, so an agent discovered before the app configured one still picks
+	* it up — and so a value written here by hand is replaced on the registry's
+	* next sweep. Configure it through `CopilotKitCore` instead.
+	*/
+	get messageFilter() {
+		return this._messageFilter;
+	}
+	set messageFilter(filter) {
+		this._messageFilter = filter;
+	}
+	/**
+	* Narrow the outbound payload with the configured message filter.
+	*
+	* **Called from the HTTP paths only, and that placement is the Intelligence
+	* exemption.** An earlier revision applied the filter in
+	* `prepareRunAgentInput`, which runs before the runtime mode is resolved:
+	* with the default `"auto"` transport, or on a proxy still `"pending"` its
+	* first `/info`, `run()` prepared the input, *then* resolved the mode, then
+	* handed that already-filtered input to `#runViaDelegate` — so a managed
+	* runtime received a truncated thread despite the exemption. Filtering here
+	* makes that unreachable by construction: `#runViaHttp` and
+	* `#connectViaHttp` are only entered once the mode is known not to be
+	* Intelligence. Do not move this back up the call chain.
+	*
+	* The managed runtime is the store of record for the thread — the threads
+	* drawer and the Slack transcript read from it — so a client-side truncation
+	* there has a blast radius nobody asked for. Every reporter on #1482 is
+	* self-hosted.
+	*
+	* `prepareRunAgentInput` has already deep-cloned the thread and stripped
+	* `activity` messages by the time the input reaches here, so the filter
+	* cannot reach the messages the UI renders no matter what it does with the
+	* array it is handed. The filter gets a *second* deep clone on top of that,
+	* because `input.messages` is also the repair baseline and the untrimmed
+	* fallback: sharing the message objects let a filter that mutates a kept
+	* message's `toolCallId` corrupt the baseline, and an orphaned tool result
+	* then went out on the wire — a payload the provider rejects, which is
+	* exactly the failure this whole mechanism exists to prevent.
+	*/
+	#applyMessageFilter(input) {
+		const filter = this._messageFilter;
+		if (!filter) return input;
+		try {
+			const kept = filter(structuredClone_(input.messages), { agentId: this.agentId ?? "" });
+			if (!Array.isArray(kept)) {
+				console.warn("ProxiedCopilotRuntimeAgent: messageFilter returned a non-array value; sending the full message history instead.");
+				return input;
+			}
+			return {
+				...input,
+				messages: ɵrepairToolCallPairs(kept, input.messages)
+			};
+		} catch (error) {
+			console.warn("ProxiedCopilotRuntimeAgent: messageFilter failed; sending the full message history instead.", error);
+			return input;
+		}
+	}
 	requestInit(input) {
 		return {
 			...super.requestInit(input),
@@ -722,6 +924,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		if (!this.agentId || !this.threadId) return;
 		if (typeof fetch === "undefined") return;
 		const routedId = this.routedAgentId();
+		const runId = this.activeRun?.threadId === this.threadId ? this.activeRun.runId : void 0;
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) return;
 			const headers = new Headers({
@@ -736,7 +939,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 					params: {
 						agentId: routedId,
 						threadId: this.threadId
-					}
+					},
+					...runId === void 0 ? {} : { body: { runId } }
 				}),
 				...this.credentials ? { credentials: this.credentials } : {}
 			}).catch((error) => {
@@ -755,6 +959,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 				"Content-Type": "application/json",
 				...this.headers
 			},
+			...runId === void 0 ? {} : { body: JSON.stringify({ runId }) },
 			...this.credentials ? { credentials: this.credentials } : {}
 		}).catch((error) => {
 			console.error("ProxiedCopilotRuntimeAgent: stop request failed", error);
@@ -810,7 +1015,9 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	#connectViaDelegate(input) {
 		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.connect(input))));
 	}
-	#connectViaHttp(input) {
+	#connectViaHttp(unfiltered) {
+		const input = this.#applyMessageFilter(unfiltered);
+		this.activeRun = void 0;
 		const routedId = this.routedAgentId();
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
@@ -824,13 +1031,24 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	#runViaDelegate(input) {
 		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.run(input))));
 	}
-	#runViaHttp(input) {
+	#runViaHttp(unfiltered) {
+		const input = this.#applyMessageFilter(unfiltered);
+		const activeRun = {
+			threadId: input.threadId,
+			runId: input.runId
+		};
+		const trackActiveRun = (source) => {
+			this.activeRun = activeRun;
+			return source.pipe(finalize(() => {
+				if (this.activeRun === activeRun) this.activeRun = void 0;
+			}));
+		};
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
 			const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.routedAgentId() });
-			return withAbortErrorHandling(transformHttpEventStream(runHttpRequest(() => this.fetch(this.singleEndpointUrl, requestInit))));
+			return trackActiveRun(withAbortErrorHandling(transformHttpEventStream(runHttpRequest(() => this.fetch(this.singleEndpointUrl, requestInit)))));
 		}
-		return withAbortErrorHandling(super.run(input));
+		return trackActiveRun(withAbortErrorHandling(super.run(input)));
 	}
 	clone() {
 		const cloned = new ProxiedCopilotRuntimeAgent({
@@ -845,7 +1063,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 			intelligence: this.intelligence,
 			capabilities: this._capabilities,
 			debug: this.debug,
-			fetch: this.fetch
+			fetch: this.fetch,
+			messageFilter: this._messageFilter
 		});
 		cloned.threadId = this.threadId;
 		cloned.setState(this.state);
@@ -973,9 +1192,11 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	createIntelligenceDelegate() {
 		const routedId = this.routedAgentId();
 		if (!this.runtimeUrl || !routedId || !this.intelligence?.wsUrl) throw new Error("Intelligence mode requires runtimeUrl, agentId, and intelligence websocket metadata");
+		const single = this.transport === "single";
 		return new IntelligenceAgent({
 			url: this.intelligence.wsUrl,
-			runtimeUrl: this.runtimeUrl,
+			runtimeUrl: single ? this.runtimeEndpointUrl ?? this.runtimeUrl : this.runtimeUrl,
+			transport: single ? "single" : "rest",
 			agentId: routedId,
 			headers: { ...this.headers },
 			credentials: this.credentials,
@@ -1238,6 +1459,7 @@ var AgentRegistry = class {
 		this.localAgents = this.assignAgentIds(agents);
 		this.applyHeadersToAgents(this.localAgents);
 		this.applyCredentialsToAgents(this.localAgents);
+		this.applyMessageFilterToAgents(this.localAgents);
 		this.applyRuntimeFetchToAgents(this.localAgents);
 		this._agents = this.localAgents;
 	}
@@ -1329,6 +1551,7 @@ var AgentRegistry = class {
 		};
 		this.applyHeadersToAgents(this._agents);
 		this.applyCredentialsToAgents(this._agents);
+		this.applyMessageFilterToAgents(this._agents);
 		this.applyRuntimeFetchToAgents(this._agents);
 		this.notifyAgentsChanged();
 	}
@@ -1381,7 +1604,8 @@ var AgentRegistry = class {
 			credentials: friends.credentials,
 			runtimeMode: this._runtimeUrl ? this._runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected ? this._runtimeMode : "pending" : RUNTIME_MODE_SSE,
 			intelligence: this._intelligence,
-			debug: debug ? resolveDebugConfig(debug) : void 0
+			debug: debug ? resolveDebugConfig(debug) : void 0,
+			messageFilter: friends.messageFilter
 		});
 		this.applyHeadersToAgent(agent);
 		this.applyRuntimeFetchToAgent(agent);
@@ -1450,6 +1674,45 @@ var AgentRegistry = class {
 			this.applyCredentialsToAgent(agent);
 		});
 	}
+	/**
+	* Carry the mode a fresh `/info` reported onto a proxy this re-sync kept.
+	*
+	* `canReuseRuntimeAgent` deliberately ignores the mode: a preserved proxy is
+	* backing an open conversation, and replacing the instance to change one
+	* field would drop it. The mode is therefore pushed onto the survivor here,
+	* the same way headers and credentials are. Without it the mode was fixed at
+	* construction, so a runtime that flipped `intelligence` → `sse` under an
+	* open page left every later run on the delegate path. See #7130.
+	*/
+	applyRuntimeModeToAgent(agent, runtimeInfo) {
+		if (agent instanceof ProxiedCopilotRuntimeAgent) agent.adoptRuntimeMode(runtimeInfo.mode ?? RUNTIME_MODE_SSE, runtimeInfo.intelligence);
+	}
+	/**
+	* Apply the core's message filter to an agent.
+	*
+	* The test is the class, not which bucket the agent is registered in: every
+	* `ProxiedCopilotRuntimeAgent` gets the core filter, whether it came from
+	* `/info` or from `registerProxiedAgent` (which files its proxy under
+	* `localAgents`). Agents of any other class are left untouched — an
+	* `AbstractAgent` the app built has no such hook, and its owner already has
+	* the AG-UI middleware seam.
+	*
+	* This is the sole writer of `agent.messageFilter` in normal operation. The
+	* public setter exists for the registry and for tests; a value written
+	* directly onto an agent is replaced the next time the registry sweeps, the
+	* same way per-agent credentials are.
+	*/
+	applyMessageFilterToAgent(agent) {
+		if (agent instanceof ProxiedCopilotRuntimeAgent) agent.messageFilter = this.core.messageFilter;
+	}
+	/**
+	* Apply the core's message filter to all agents
+	*/
+	applyMessageFilterToAgents(agents) {
+		Object.values(agents).forEach((agent) => {
+			this.applyMessageFilterToAgent(agent);
+		});
+	}
 	createRuntimeFetch() {
 		if (!this.runtimeFetch) this.runtimeFetch = (async (input, init) => {
 			const meta = () => runtimeRequestMeta(init);
@@ -1837,7 +2100,9 @@ var AgentRegistry = class {
 				if (existing instanceof ProxiedCopilotRuntimeAgent && this.canReuseRuntimeAgent(existing, runtimeUrl, this._runtimeTransport)) {
 					this.applyHeadersToAgent(existing);
 					this.applyCredentialsToAgent(existing);
+					this.applyMessageFilterToAgent(existing);
 					this.applyRuntimeFetchToAgent(existing);
+					this.applyRuntimeModeToAgent(existing, runtimeInfoResponse);
 					return [id, existing];
 				}
 				const agent = new ProxiedCopilotRuntimeAgent({
@@ -1849,7 +2114,8 @@ var AgentRegistry = class {
 					runtimeMode: runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE,
 					intelligence: runtimeInfoResponse.intelligence,
 					capabilities,
-					debug: rawDebug ? resolveDebugConfig(rawDebug) : void 0
+					debug: rawDebug ? resolveDebugConfig(rawDebug) : void 0,
+					messageFilter: this.core.messageFilter
 				});
 				this.applyHeadersToAgent(agent);
 				this.applyRuntimeFetchToAgent(agent);
@@ -2241,7 +2507,10 @@ var SuggestionEngine = class {
 						credentials
 					}) } : {}
 				});
-			} else suggestionAgent = suggestionsProviderAgent.clone();
+			} else {
+				suggestionAgent = suggestionsProviderAgent.clone();
+				if (suggestionAgent instanceof ProxiedCopilotRuntimeAgent) suggestionAgent.messageFilter = void 0;
+			}
 			suggestionAgent.threadId = suggestionId;
 			suggestionAgent.setMessages(seededMessages);
 			suggestionAgent.setState(seededState);
@@ -2603,6 +2872,19 @@ var WebMCPRegistry = class {
 //#endregion
 //#region src/core/run-handler.ts
 /**
+* Live approvals cancelled by stopping their own run, keyed by the handler's
+* signal. The value reports whether that stop is still current: no reconnect
+* has started and the thread is unchanged, so nothing will restore the call.
+*
+* Kept here rather than in `AbortSignal.reason`: React Native's global
+* `AbortController` is the `abort-controller@3` polyfill, whose `abort()`
+* takes no reason and whose signals never expose one.
+*/
+const liveHITLStops = /* @__PURE__ */ new WeakMap();
+function discardAbortedResult(signal, discardOnAbort, errorMessage) {
+	return !!(discardOnAbort && signal?.aborted && !(liveHITLStops.get(signal)?.() && errorMessage));
+}
+/**
 * 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
@@ -2715,6 +2997,10 @@ var RunHandler = class {
 	_lastConnectedThreadIdsByAgent = /* @__PURE__ */ new Map();
 	_anonymousAgentIds = /* @__PURE__ */ new WeakMap();
 	_nextAnonymousAgentId = 0;
+	/** Prevent reconnects from starting an interaction already executing locally. */
+	_executingToolCalls = /* @__PURE__ */ new WeakMap();
+	_connectionGenerations = /* @__PURE__ */ new WeakMap();
+	_interactionAbortControllers = /* @__PURE__ */ new WeakMap();
 	constructor(core) {
 		this.core = core;
 	}
@@ -2723,8 +3009,14 @@ var RunHandler = class {
 	* that in-flight tool handlers should stop and `processAgentResult` should
 	* not start a follow-up run.
 	*/
-	abortCurrentRun() {
+	abortCurrentRun(agent) {
 		this._runAbortController?.abort();
+		const replay = this._interactionAbortControllers.get(agent);
+		if (replay) {
+			for (const controller of replay.controllers) controller.abort();
+			this._interactionAbortControllers.delete(agent);
+			this._executingToolCalls.delete(agent);
+		}
 	}
 	/**
 	* Typed access to CopilotKitCore's internal ("friend") methods.
@@ -2880,7 +3172,14 @@ var RunHandler = class {
 	* Connect an agent (establish initial connection)
 	*/
 	async connectAgent({ agent }) {
+		this._connectionGenerations.set(agent, {});
 		const incomingThreadId = agent.threadId ?? null;
+		const previousReplay = this._interactionAbortControllers.get(agent);
+		if (previousReplay && previousReplay.threadId !== incomingThreadId) {
+			for (const controller of previousReplay.controllers) controller.abort();
+			this._interactionAbortControllers.delete(agent);
+			this._executingToolCalls.delete(agent);
+		}
 		try {
 			const restoreKey = this.getConnectRestoreKey(agent);
 			const isFreshRestore = incomingThreadId !== (this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? null);
@@ -2905,11 +3204,33 @@ var RunHandler = class {
 				tools: this.buildFrontendTools(agent.agentId),
 				context: this._internal.getContextForAgent(agent.agentId)
 			}, this.createAgentErrorSubscriber(agent));
-			return this.processAgentResult({
+			if ((agent.threadId ?? null) !== incomingThreadId) return runAgentResult;
+			const controller = new AbortController();
+			const replay = this._interactionAbortControllers.get(agent) ?? {
+				threadId: incomingThreadId,
+				controllers: /* @__PURE__ */ new Set()
+			};
+			replay.controllers.add(controller);
+			this._interactionAbortControllers.set(agent, replay);
+			this.processAgentResult({
 				runAgentResult,
 				agent,
-				executeFrontendTools: false
+				toolExecutionMode: "human-in-the-loop",
+				signal: controller.signal
+			}).catch(async (error) => {
+				await this._internal.emitError({
+					error: error instanceof Error ? error : new Error(String(error)),
+					code: CopilotKitCoreErrorCode.AGENT_CONNECT_FAILED,
+					context: {
+						agentId: agent.agentId,
+						threadId: incomingThreadId
+					}
+				});
+			}).finally(() => {
+				replay.controllers.delete(controller);
+				if (replay.controllers.size === 0 && this._interactionAbortControllers.get(agent) === replay) this._interactionAbortControllers.delete(agent);
 			});
+			return runAgentResult;
 		} catch (error) {
 			const connectError = error instanceof Error ? error : new Error(String(error));
 			if (!isAbortError$1(connectError)) {
@@ -3011,45 +3332,83 @@ var RunHandler = class {
 	/**
 	* Process agent result and execute tools
 	*/
-	async processAgentResult({ runAgentResult, agent, runId, executeFrontendTools = true }) {
+	async processAgentResult({ runAgentResult, agent, runId, toolExecutionMode = "all", signal = this._runAbortController?.signal }) {
 		const { newMessages } = runAgentResult;
 		const agentId = agent.agentId;
 		let needsFollowUp = false;
-		if (executeFrontendTools) {
-			for (const message of newMessages) if (message.role === "assistant") for (const toolCall of message.toolCalls || []) {
-				const tool = this.getTool({
-					toolName: toolCall.function.name,
+		const threadId = agent.threadId;
+		const executing = this._executingToolCalls.get(agent) ?? /* @__PURE__ */ new Set();
+		this._executingToolCalls.set(agent, executing);
+		if (toolExecutionMode === "human-in-the-loop" && agent.messages.some((message) => message.role === "assistant" && message.toolCalls?.some((call) => executing.has(JSON.stringify([threadId, call.id])) && !agent.messages.some((result) => result.role === "tool" && result.toolCallId === call.id && !this.isFrontendPlaceholderResult(result))))) return runAgentResult;
+		const messagesToProcess = toolExecutionMode === "human-in-the-loop" ? [...agent.messages] : newMessages;
+		for (const message of messagesToProcess) 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: WILDCARD_TOOL_NAME,
 					agentId: agent.agentId
 				});
-				let wildcardTool;
-				const getWildcardTool = () => {
-					if (tool || wildcardTool) return wildcardTool;
-					wildcardTool = this.getTool({
-						toolName: WILDCARD_TOOL_NAME,
-						agentId: agent.agentId
-					});
-					return wildcardTool;
+				return wildcardTool;
+			};
+			const executableTool = tool ?? getWildcardTool();
+			if (toolExecutionMode === "human-in-the-loop" && (executableTool?.type !== "human-in-the-loop" || !executableTool.handler)) continue;
+			const executionKey = JSON.stringify([threadId, toolCall.id]);
+			if (signal?.aborted || agent.threadId !== threadId || executing.has(executionKey)) continue;
+			const existingResultIndex = newMessages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+			let existingResult = agent.messages.find((m) => m.role === "tool" && m.toolCallId === toolCall.id) ?? newMessages[existingResultIndex];
+			if (existingResult && executableTool?.handler && this.isFrontendPlaceholderResult(existingResult)) {
+				if (existingResultIndex !== -1) newMessages.splice(existingResultIndex, 1);
+				existingResult = void 0;
+				const agentMsgIdx = agent.messages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+				if (agentMsgIdx !== -1) agent.messages.splice(agentMsgIdx, 1);
+			}
+			if (!existingResult) {
+				executing.add(executionKey);
+				const interactionController = toolExecutionMode === "all" && executableTool?.type === "human-in-the-loop" ? new AbortController() : void 0;
+				const interactions = this._interactionAbortControllers.get(agent) ?? {
+					threadId: threadId ?? null,
+					controllers: /* @__PURE__ */ new Set()
+				};
+				const abortInteraction = () => {
+					if (!interactionController) return;
+					const connectionGeneration = this._connectionGenerations.get(agent);
+					liveHITLStops.set(interactionController.signal, () => this._connectionGenerations.get(agent) === connectionGeneration && agent.threadId === threadId);
+					interactionController.abort();
 				};
-				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 (interactionController) {
+					interactions.controllers.add(interactionController);
+					this._interactionAbortControllers.set(agent, interactions);
+					signal?.addEventListener("abort", abortInteraction, { once: true });
+					if (signal?.aborted) abortInteraction();
 				}
-				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;
+				const executionSignal = interactionController?.signal ?? signal;
+				const discardOnAbort = toolExecutionMode === "human-in-the-loop" || !!interactionController;
+				try {
+					if (tool) {
+						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId, executionSignal, discardOnAbort)) needsFollowUp = true;
+					} else {
+						const fallbackTool = getWildcardTool();
+						if (fallbackTool) {
+							if (await this.executeWildcardTool(fallbackTool, toolCall, message, agent, agentId, executionSignal, discardOnAbort)) needsFollowUp = true;
+						}
+					}
+				} finally {
+					executing.delete(executionKey);
+					if (interactionController) {
+						signal?.removeEventListener("abort", abortInteraction);
+						interactions.controllers.delete(interactionController);
+						if (interactions.controllers.size === 0 && this._interactionAbortControllers.get(agent) === interactions) this._interactionAbortControllers.delete(agent);
 					}
 				}
+				if (interactionController?.signal.aborted) return runAgentResult;
 			}
 		}
-		if (needsFollowUp && !this._runAbortController?.signal.aborted) if (this._runDepth >= MAX_FOLLOW_UP_DEPTH) 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.`);
+		if (needsFollowUp && agent.threadId === threadId && !signal?.aborted) if (this._runDepth >= MAX_FOLLOW_UP_DEPTH) 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();
 			const continuationHandoff = this._internal.stateManager.markNextRunAsContinuation(agent, runId);
@@ -3069,7 +3428,7 @@ var RunHandler = class {
 	* Handles arg parsing, subscriber notifications, handler invocation, result stringification,
 	* and error handling.
 	*/
-	async executeToolHandler({ tool, toolCall, agent, agentId, handlerArgs, toolType, messageId }) {
+	async executeToolHandler({ tool, toolCall, agent, agentId, handlerArgs, toolType, messageId, signal = this._runAbortController?.signal, discardOnAbort = false }) {
 		let toolCallResult = "";
 		let errorMessage;
 		let isArgumentError = false;
@@ -3104,7 +3463,7 @@ var RunHandler = class {
 			const result = await tool.handler(parsedArgs, {
 				toolCall,
 				agent,
-				signal: this._runAbortController?.signal
+				signal
 			});
 			if (result === void 0 || result === null) toolCallResult = "";
 			else if (typeof result === "string") toolCallResult = result;
@@ -3112,7 +3471,7 @@ var RunHandler = class {
 		} catch (error) {
 			const handlerError = error instanceof Error ? error : new Error(String(error));
 			errorMessage = handlerError.message;
-			await this._internal.emitError({
+			if (!discardAbortedResult(signal, discardOnAbort, errorMessage)) await this._internal.emitError({
 				error: handlerError,
 				code: CopilotKitCoreErrorCode.TOOL_HANDLER_FAILED,
 				context: {
@@ -3143,7 +3502,8 @@ var RunHandler = class {
 	/**
 	* Execute a specific tool
 	*/
-	async executeSpecificTool(tool, toolCall, message, agent, agentId) {
+	async executeSpecificTool(tool, toolCall, message, agent, agentId, signal, discardOnAbort = false) {
+		const threadId = agent.threadId;
 		if (tool?.agentId && tool.agentId !== agent.agentId) return false;
 		let handlerResult = {
 			result: "",
@@ -3157,11 +3517,13 @@ var RunHandler = class {
 			agentId,
 			handlerArgs: toolCall.function.arguments,
 			toolType: "specific",
-			messageId: message.id
+			messageId: message.id,
+			signal,
+			discardOnAbort
 		});
 		{
 			const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
-			if (messageIndex === -1) return false;
+			if (discardAbortedResult(signal, discardOnAbort, handlerResult.error) || agent.threadId !== threadId || messageIndex === -1 || agent.messages.some((m) => m.role === "tool" && m.toolCallId === toolCall.id && !this.isFrontendPlaceholderResult(m))) return false;
 			let insertAt = messageIndex + 1;
 			while (insertAt < agent.messages.length && agent.messages[insertAt]?.role === "tool") insertAt++;
 			const toolMessage = {
@@ -3181,7 +3543,8 @@ var RunHandler = class {
 	* specific tools, so this method keeps its own arg-wrapping logic rather than
 	* delegating to `executeToolHandler`.
 	*/
-	async executeWildcardTool(wildcardTool, toolCall, message, agent, agentId) {
+	async executeWildcardTool(wildcardTool, toolCall, message, agent, agentId, signal, discardOnAbort = false) {
+		const threadId = agent.threadId;
 		if (wildcardTool?.agentId && wildcardTool.agentId !== agent.agentId) return false;
 		let toolCallResult = "";
 		let errorMessage;
@@ -3219,7 +3582,8 @@ var RunHandler = class {
 			if (!errorMessage) try {
 				const result = await wildcardTool.handler(wildcardArgs, {
 					toolCall,
-					agent
+					agent,
+					signal
 				});
 				if (result === void 0 || result === null) toolCallResult = "";
 				else if (typeof result === "string") toolCallResult = result;
@@ -3227,7 +3591,7 @@ var RunHandler = class {
 			} catch (error) {
 				const handlerError = error instanceof Error ? error : new Error(String(error));
 				errorMessage = handlerError.message;
-				await this._internal.emitError({
+				if (!discardAbortedResult(signal, discardOnAbort, errorMessage)) await this._internal.emitError({
 					error: handlerError,
 					code: CopilotKitCoreErrorCode.TOOL_HANDLER_FAILED,
 					context: {
@@ -3252,7 +3616,7 @@ var RunHandler = class {
 		}
 		{
 			const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
-			if (messageIndex === -1) return false;
+			if (discardAbortedResult(signal, discardOnAbort, errorMessage) || agent.threadId !== threadId || messageIndex === -1 || agent.messages.some((m) => m.role === "tool" && m.toolCallId === toolCall.id && !this.isFrontendPlaceholderResult(m))) return false;
 			let insertAt = messageIndex + 1;
 			while (insertAt < agent.messages.length && agent.messages[insertAt]?.role === "tool") insertAt++;
 			const toolMessage = {
@@ -5037,6 +5401,7 @@ function normalizeHeaders(headers) {
 var CopilotKitCore = class {
 	_headers;
 	_credentials;
+	_messageFilter;
 	_properties;
 	_defaultThrottleMs;
 	_debug;
@@ -5061,9 +5426,10 @@ var CopilotKitCore = class {
 	* store that was registered prior to that initial notification.
 	*/
 	previousAgentIds = /* @__PURE__ */ new Set();
-	constructor({ runtimeUrl, runtimeTransport = "auto", deferInitialConnection = false, headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
+	constructor({ runtimeUrl, runtimeTransport = "auto", deferInitialConnection = false, headers = {}, credentials, messageFilter, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
 		this._headers = normalizeHeaders(headers);
 		this._credentials = credentials;
+		this._messageFilter = messageFilter;
 		this._properties = properties;
 		this._debug = debug;
 		this.agentRegistry = new AgentRegistry(this);
@@ -5183,6 +5549,9 @@ var CopilotKitCore = class {
 	get credentials() {
 		return this._credentials;
 	}
+	get messageFilter() {
+		return this._messageFilter;
+	}
 	get properties() {
 		return this._properties;
 	}
@@ -5328,6 +5697,17 @@ var CopilotKitCore = class {
 		this.agentRegistry.applyCredentialsToAgents(this.agentRegistry.agents);
 		this.agentRegistry.handleCredentialsChanged();
 	}
+	/**
+	* Replace the message filter applied to every runtime agent.
+	*
+	* Applies to agents already discovered as well as ones discovered later, so
+	* a filter set before `/info` lands is not lost. Pass `undefined` to go back
+	* to sending the full thread.
+	*/
+	setMessageFilter(messageFilter) {
+		this._messageFilter = messageFilter;
+		this.agentRegistry.applyMessageFilterToAgents(this.agentRegistry.agents);
+	}
 	setProperties(properties) {
 		this._properties = properties;
 		this.notifySubscribers((subscriber) => subscriber.onPropertiesChanged?.({
@@ -5676,7 +6056,7 @@ var CopilotKitCore = class {
 		return this.runHandler.connectAgent(params);
 	}
 	stopAgent(params) {
-		this.runHandler.abortCurrentRun();
+		this.runHandler.abortCurrentRun(params.agent);
 		params.agent.abortRun();
 	}
 	async runAgent(params) {