@copilotkit/core 1.75.1 → 1.76.0

package/dist/index.mjs

@@ -1,11 +1,28 @@
 import { Throttler } from "@tanstack/pacer";
-import { AGUIConnectNotImplementedError, AbstractAgent, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
-import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, parseInspectorMetadataV1, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema } from "@copilotkit/shared";
+import { AGUIConnectNotImplementedError, AbstractAgent, CompatibilityBoundary, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
+import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, parseInspectorMetadataV1, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema, stripIntelligenceRoutingFields } from "@copilotkit/shared";
 import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, observeOn, of, switchMap, throwError } from "rxjs";
-import { catchError, concatWith, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn as observeOn$1, scan, share, shareReplay, startWith, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
+import { catchError, concatMap, concatWith, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn as observeOn$1, scan, share, shareReplay, startWith, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
 import { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
+//#region src/utils/http-agent.ts
+/**
+* Whether an agent is an `HttpAgent`, including one built from another copy of
+* `@ag-ui/client` (an app that pins its own 0.x version next to CopilotKit's
+* 1.0, for example). `instanceof` is false across package copies, which made
+* CopilotKit silently skip headers and abort wiring for those agents. The
+* fallback checks the public fields CopilotKit uses, which every published
+* `HttpAgent` has.
+*/
+function ɵisHttpAgent(agent) {
+	if (agent instanceof HttpAgent) return true;
+	if (typeof agent !== "object" || agent === null) return false;
+	const candidate = agent;
+	return typeof candidate.url === "string" && typeof candidate.headers === "object" && candidate.headers !== null && candidate.abortController instanceof AbortController && typeof candidate.runAgent === "function";
+}
+
+//#endregion
 //#region src/utils/connect-replay.ts
 /**
 * Runs an agent's `connect()` stream through the AbstractAgent apply pipeline
@@ -22,18 +39,27 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 *   Cannot send event type 'RUN_STARTED': The run has already errored with
 *   'RUN_ERROR'. No further events can be sent.
 *
-* `transformChunks` is still applied — message reassembly is needed either way.
+* The AG-UI 1.0 compatibility boundary still runs first, so stored 0.x history
+* is translated (THINKING_* events, `binary` parts, legacy nulls) exactly as in
+* the base pipeline. `enforceEvents` is omitted too: a replay is stored
+* history, and one event that the 1.0 schema rejects (the Intelligence gateway
+* replays RUN_STARTED without `runId`, for example) must not stop the whole
+* thread from hydrating. That keeps the leniency this path had before 1.0.
 *
 * Connection-local replay hooks track the phase before applying events. An
 * explicitly live RUN_ERROR clears busy without closing the connection;
 * historical errors remain data. Connections without hooks retain the existing
-* completion behavior. Subscriber, detach, and result contracts are preserved.
+* completion behavior.
+*
+* Apart from the above, this mirrors the base `AbstractAgent.connectAgent`
+* implementation, so callers keep the same subscriber notifications, detach
+* semantics, and `{ result, newMessages }` return shape.
 *
 * TODO: Remove this in favour of the base implementation once AG-UI's
 * AbstractAgent supports opting out of `verifyEvents` for transports whose
 * connection life-cycle isn't a single run AND preserves the connection-local
 * replay lifecycle and running-state behavior below. Skipping verification alone
-* is insufficient. As of `@ag-ui/client@0.0.57`
+* is insufficient. As of `@ag-ui/client@1.0.1`
 * `connectAgent(parameters?, subscriber?)` takes no such option.
 *
 * @param agent - The agent whose `connect()` stream should be consumed.
@@ -42,6 +68,9 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 */
 async function ɵconnectWithoutEventVerification(agent, parameters, subscriber, connect) {
 	const self = agent;
+	let finalizeRun = () => {
+		agent.isRunning = false;
+	};
 	try {
 		agent.isRunning = true;
 		agent.agentId = agent.agentId ?? randomUUID();
@@ -65,12 +94,35 @@ async function ɵconnectWithoutEventVerification(agent, parameters, subscriber,
 			...agent.subscribers,
 			subscriber ?? {}
 		];
-		await self.onInitialize(input, subscribers);
-		self.activeRunDetach$ = new Subject();
+		const activeRunDetach$ = new Subject();
+		self.activeRunDetach$ = activeRunDetach$;
 		let resolveCompletion;
 		self.activeRunCompletionPromise = new Promise((resolve) => {
 			resolveCompletion = resolve;
 		});
+		let detached = false;
+		let finalized = false;
+		const detachSubscription = activeRunDetach$.subscribe(() => {
+			detached = true;
+		});
+		finalizeRun = () => {
+			if (finalized) return;
+			finalized = true;
+			detachSubscription.unsubscribe();
+			if (self.activeRunDetach$ === activeRunDetach$) {
+				agent.isRunning = false;
+				self.activeRunCompletionPromise = void 0;
+				self.activeRunDetach$ = void 0;
+				self.onFinalize(input, subscribers);
+			}
+			resolveCompletion?.();
+			resolveCompletion = void 0;
+		};
+		await self.onInitialize(input, subscribers);
+		if (detached) return {
+			result: void 0,
+			newMessages: []
+		};
 		const lifecycle = {
 			onReplayStarted: () => {
 				isReplaying = true;
@@ -80,29 +132,23 @@ async function ɵconnectWithoutEventVerification(agent, parameters, subscriber,
 				isReplaying = false;
 			}
 		};
-		const source$ = defer(() => connect ? connect(input, lifecycle) : self.connect(input)).pipe(tap((event) => {
+		const source$ = defer(() => new CompatibilityBoundary().run(input, { run: () => connect ? connect(input, lifecycle) : self.connect(input) })).pipe(tap((event) => {
 			if (!isReplaying && event.type === EventType.RUN_ERROR) liveErrors.add(event);
-		}), transformChunks(self.debugLogger), takeUntil(self.activeRunDetach$));
+		}), transformChunks(self.debugLogger), takeUntil(activeRunDetach$));
 		const applied$ = self.apply(input, source$, subscribers);
 		await lastValueFrom(self.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
+			if (self.activeRunDetach$ !== activeRunDetach$) return EMPTY;
 			agent.isRunning = false;
 			if (error instanceof AGUIConnectNotImplementedError) return EMPTY;
 			return self.onError(input, error, subscribers);
-		}), finalize(() => {
-			agent.isRunning = false;
-			self.onFinalize(input, subscribers);
-			resolveCompletion?.();
-			resolveCompletion = void 0;
-			self.activeRunCompletionPromise = void 0;
-			self.activeRunDetach$ = void 0;
-		})), { defaultValue: void 0 });
+		}), finalize(() => finalizeRun())), { defaultValue: void 0 });
 		const newMessages = structuredClone_(agent.messages).filter((m) => !previousMessageIds.has(m.id));
 		return {
 			result,
 			newMessages
 		};
 	} finally {
-		agent.isRunning = false;
+		finalizeRun();
 	}
 }
 
@@ -585,7 +631,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	observeThreadEvents$(threadId, channel$, options) {
 		return channel$.pipe(switchMap$1(({ channel }) => this.observeChannelEvent$(channel, CLIENT_AG_UI_EVENT)), tap((payload) => {
 			this.updateLastSeenEventId(threadId, payload);
-		}), mergeMap((payload) => this.createThreadNotifications(payload, {
+		}), map((payload) => options.streamMode === "run" ? stripIntelligenceRoutingFields(payload) : payload), mergeMap((payload) => this.createThreadNotifications(payload, {
 			completeOnRunError: options.completeOnRunError,
 			completeOnRunFinished: options.streamMode === "run",
 			errorOnRunError: options.streamMode === "run"
@@ -839,6 +885,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	_capabilities;
 	delegate;
 	runtimeInfoPromise;
+	connectionAttempt;
 	_messageFilter;
 	/**
 	* The HTTP `run` this agent started and has not yet seen finish, as the
@@ -901,13 +948,12 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		this.runtimeMode = runtimeMode;
 		this.intelligence = intelligence;
 		if (unchanged) return;
+		this.connectionAttempt = void 0;
 		this.runtimeInfoPromise = void 0;
 		const staleDelegate = this.delegate;
 		this.delegate = void 0;
-		if (staleDelegate) {
-			staleDelegate.abortRun();
-			this.detachActiveRun();
-		}
+		if (staleDelegate) staleDelegate.abortRun();
+		this.detachActiveRun();
 	}
 	/**
 	* The agent id used for outbound runtime requests — `runtimeAgentId` when
@@ -998,8 +1044,11 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		return this._capabilities ?? {};
 	}
 	async detachActiveRun() {
-		if (this.delegate) await this.delegate.detachActiveRun();
-		await super.detachActiveRun();
+		this.connectionAttempt = void 0;
+		this.isRunning = false;
+		const delegateDetach = this.delegate?.detachActiveRun();
+		const proxyDetach = super.detachActiveRun();
+		await Promise.all([delegateDetach, proxyDetach]);
 	}
 	abortRun() {
 		if (this.delegate) {
@@ -1053,41 +1102,74 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		});
 	}
 	async connectAgent(parameters, subscriber) {
+		const detached = this.detachActiveRun();
+		const connection = {};
+		const threadId = this.threadId;
+		this.connectionAttempt = connection;
+		const isCurrentConnection = () => this.connectionAttempt === connection && this.threadId === threadId;
+		await detached;
+		if (!isCurrentConnection()) return {
+			result: void 0,
+			newMessages: []
+		};
+		await this.ensureRuntimeConfiguration();
+		if (!isCurrentConnection()) return {
+			result: void 0,
+			newMessages: []
+		};
 		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return ɵconnectWithoutEventVerification(this, parameters, subscriber, (input, lifecycle) => this.connect(input, lifecycle));
-		if (this.delegate) await this.delegate.detachActiveRun();
 		await this.resolveDelegate();
+		if (!isCurrentConnection()) return {
+			result: void 0,
+			newMessages: []
+		};
 		const delegate = this.delegate;
 		const bridgeSub = delegate.subscribe({
 			onMessagesChanged: () => {
+				if (!isCurrentConnection()) return;
 				this.setMessages([...delegate.messages]);
 			},
 			onStateChanged: () => {
+				if (!isCurrentConnection()) return;
 				this.setState({ ...delegate.state });
 			},
 			onRunInitialized: () => {
+				if (!isCurrentConnection()) return;
 				this.isRunning = true;
 			},
 			onRunFinalized: () => {
+				if (!isCurrentConnection()) return;
+				this.pendingInterrupts = structuredClone_(delegate.pendingInterrupts);
 				this.isRunning = false;
 			},
 			onRunFailed: () => {
+				if (!isCurrentConnection()) return;
 				this.isRunning = false;
 			},
 			onRunErrorEvent: () => {
+				if (!isCurrentConnection()) return;
 				this.isRunning = delegate.isRunning;
 			},
 			onRunStartedEvent: () => {
+				if (!isCurrentConnection()) return;
 				this.isRunning = delegate.isRunning;
 			}
 		});
-		const forwardedSubs = this.subscribers.map((s) => delegate.subscribe(s));
+		const forwardedSubs = [...this.subscribers, ...subscriber ? [subscriber] : []].map((subscriber) => delegate.subscribe(new Proxy(subscriber, { get(target, property, receiver) {
+			const callback = Reflect.get(target, property, receiver);
+			if (typeof callback !== "function") return callback;
+			return (...args) => isCurrentConnection() ? Reflect.apply(callback, target, args) : void 0;
+		} })));
 		try {
-			const result = await delegate.connectAgent(parameters, subscriber);
-			this.setMessages([...delegate.messages]);
-			this.setState({ ...delegate.state });
+			const result = await delegate.connectAgent(parameters);
+			if (isCurrentConnection()) {
+				this.setMessages([...delegate.messages]);
+				this.setState({ ...delegate.state });
+				this.pendingInterrupts = structuredClone_(delegate.pendingInterrupts);
+			}
 			return result;
 		} finally {
-			this.isRunning = false;
+			if (isCurrentConnection()) this.isRunning = false;
 			bridgeSub.unsubscribe();
 			for (const sub of forwardedSubs) sub.unsubscribe();
 		}
@@ -1109,14 +1191,31 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		const input = this.#applyMessageFilter(unfiltered);
 		this.activeRun = void 0;
 		const routedId = this.routedAgentId();
+		let httpEvents;
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
 			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: routedId });
-			return withAbortErrorHandling(transformHttpEventStream(runHttpRequest(() => this.fetch(this.singleEndpointUrl, requestInit))));
+			httpEvents = runHttpRequest(() => this.fetch(this.singleEndpointUrl, requestInit));
+		} else {
+			const connectUrl = `${this.runtimeUrl}/agent/${routedId}/connect`;
+			const connectRequestInit = this.requestInit(input);
+			httpEvents = runHttpRequest(() => this.fetch(connectUrl, connectRequestInit));
 		}
-		const connectUrl = `${this.runtimeUrl}/agent/${routedId}/connect`;
-		const connectRequestInit = this.requestInit(input);
-		return withAbortErrorHandling(transformHttpEventStream(runHttpRequest(() => this.fetch(connectUrl, connectRequestInit))));
+		return withAbortErrorHandling(defer(() => {
+			let replayStarted = false;
+			const emptyHistory = [{
+				type: EventType.MESSAGES_SNAPSHOT,
+				messages: []
+			}, {
+				type: EventType.STATE_SNAPSHOT,
+				snapshot: {}
+			}];
+			return transformHttpEventStream(httpEvents).pipe(concatMap((event) => {
+				if (replayStarted) return of(event);
+				replayStarted = true;
+				return from([...emptyHistory, event]);
+			}), concatWith(defer(() => replayStarted ? EMPTY : from(emptyHistory))));
+		}));
 	}
 	#runViaDelegate(input) {
 		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.run(input))));
@@ -1159,6 +1258,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		cloned.threadId = this.threadId;
 		cloned.setState(this.state);
 		cloned.setMessages(this.messages);
+		cloned.pendingInterrupts = structuredClone_(this.pendingInterrupts);
 		if (this.delegate) {
 			const clonedDelegate = this.delegate.clone();
 			cloned.delegate = clonedDelegate;
@@ -1196,6 +1296,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		if (this.runtimeMode === RUNTIME_MODE_INTELLIGENCE || this.runtimeMode !== "pending" && this.transport !== "auto") return;
 		if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
 		const runtimeInfoPromise = this.runtimeInfoPromise ?? this.fetchRuntimeInfo().then((runtimeInfo) => {
+			if (this.runtimeInfoPromise !== runtimeInfoPromise) return;
 			this.runtimeMode = runtimeInfo.mode ?? RUNTIME_MODE_SSE;
 			this.intelligence = runtimeInfo.intelligence;
 		});
@@ -1300,6 +1401,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		delegate.debugLogger = this.debugLogger;
 		delegate.setMessages(this.messages);
 		delegate.setState(this.state);
+		delegate.pendingInterrupts = structuredClone_(this.pendingInterrupts);
 		if (hasHeaders(delegate)) delegate.headers = { ...this.headers };
 		if (hasCredentials(delegate)) delegate.credentials = this.credentials;
 	}
@@ -1735,7 +1837,7 @@ var AgentRegistry = class {
 	* because only `HttpAgent` carries a `headers` field. See #5635.
 	*/
 	applyHeadersToAgent(agent) {
-		if (agent instanceof HttpAgent) {
+		if (ɵisHttpAgent(agent)) {
 			if (!this.agentOwnHeaders.has(agent)) this.agentOwnHeaders.set(agent, { ...agent.headers });
 			agent.headers = {
 				...this.agentOwnHeaders.get(agent),
@@ -3086,6 +3188,7 @@ var RunHandler = class {
 	* inspector and intermittent "Message not found" toasts.
 	*/
 	_lastConnectedThreadIdsByAgent = /* @__PURE__ */ new Map();
+	_lastActiveThreadIdsByAgent = /* @__PURE__ */ new Map();
 	_anonymousAgentIds = /* @__PURE__ */ new WeakMap();
 	_nextAnonymousAgentId = 0;
 	/** Prevent reconnects from starting an interaction already executing locally. */
@@ -3263,7 +3366,8 @@ var RunHandler = class {
 	* Connect an agent (establish initial connection)
 	*/
 	async connectAgent({ agent }) {
-		this._connectionGenerations.set(agent, {});
+		const connection = {};
+		this._connectionGenerations.set(agent, connection);
 		const incomingThreadId = agent.threadId ?? null;
 		const previousReplay = this._interactionAbortControllers.get(agent);
 		if (previousReplay && previousReplay.threadId !== incomingThreadId) {
@@ -3273,12 +3377,19 @@ var RunHandler = class {
 		}
 		try {
 			const restoreKey = this.getConnectRestoreKey(agent);
-			const isFreshRestore = incomingThreadId !== (this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? null);
-			this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
+			const previousThreadId = this._lastActiveThreadIdsByAgent.get(restoreKey);
+			const isFreshRestore = incomingThreadId !== (previousThreadId ?? this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? null);
 			await agent.detachActiveRun();
+			if (this._connectionGenerations.get(agent) !== connection || (agent.threadId ?? null) !== incomingThreadId) return {
+				result: void 0,
+				newMessages: []
+			};
+			this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
+			this._lastActiveThreadIdsByAgent.set(restoreKey, incomingThreadId);
 			if (isFreshRestore) {
 				agent.setMessages([]);
 				agent.setState({});
+				if (previousThreadId !== void 0 && previousThreadId !== incomingThreadId) agent.pendingInterrupts = [];
 				const cursorAware = agent;
 				if (incomingThreadId) {
 					if (typeof cursorAware.clearReplayCursor === "function") cursorAware.clearReplayCursor(incomingThreadId);
@@ -3290,12 +3401,16 @@ var RunHandler = class {
 				copilotkit: this.core,
 				agent
 			}), "Subscriber onAgentRunStarted error:");
+			if (this._connectionGenerations.get(agent) !== connection || (agent.threadId ?? null) !== incomingThreadId) return {
+				result: void 0,
+				newMessages: []
+			};
 			const runAgentResult = await agent.connectAgent({
 				forwardedProps: this._internal.properties,
 				tools: this.buildFrontendTools(agent.agentId),
 				context: this._internal.getContextForAgent(agent.agentId)
 			}, this.createAgentErrorSubscriber(agent));
-			if ((agent.threadId ?? null) !== incomingThreadId) return runAgentResult;
+			if (this._connectionGenerations.get(agent) !== connection || (agent.threadId ?? null) !== incomingThreadId) return runAgentResult;
 			const controller = new AbortController();
 			const replay = this._interactionAbortControllers.get(agent) ?? {
 				threadId: incomingThreadId,
@@ -3352,6 +3467,12 @@ var RunHandler = class {
 			continuationHandoff?.cancel();
 			throw error;
 		}
+		const resumedRunId = this._internal.stateManager.getContinuationRunId(agent, {
+			threadId: agent.threadId,
+			resume,
+			forwardedProps
+		});
+		const logicalHandoff = continuationHandoff ?? (resumedRunId ? this._internal.stateManager.markNextRunAsContinuation(agent, resumedRunId) : void 0);
 		const isTopLevel = this._runDepth === 0;
 		let originalAbortRun;
 		if (isTopLevel) {
@@ -3369,18 +3490,19 @@ var RunHandler = class {
 		}
 		this._runDepth++;
 		try {
-			let logicalRunId = runId;
+			let logicalRunId = resumedRunId ?? runId;
 			const agentSubscriber = this.createAgentErrorSubscriber(agent);
 			let started = false;
 			const onRunStartedEvent = agentSubscriber.onRunStartedEvent;
 			const onRunInitialized = agentSubscriber.onRunInitialized;
 			agentSubscriber.onRunInitialized = async (params) => {
-				continuationHandoff?.bind(params.input);
+				this._lastActiveThreadIdsByAgent.set(this.getConnectRestoreKey(agent), params.input.threadId);
+				logicalHandoff?.bind(params.input);
 				return onRunInitialized?.(params);
 			};
 			agentSubscriber.onRunStartedEvent = async (params) => {
 				started = true;
-				if (!continuationHandoff) logicalRunId = params.input.runId;
+				if (!logicalHandoff) logicalRunId = params.input.runId;
 				return onRunStartedEvent?.(params);
 			};
 			const pinRunIdOnWire = runId !== void 0 && !continuationHandoff;
@@ -3395,14 +3517,14 @@ var RunHandler = class {
 				context: this._internal.getContextForAgent(agent.agentId)
 			};
 			const runAgentResult = await agent.runAgent(agentRunInput, agentSubscriber);
-			if (!started) continuationHandoff?.cancel();
+			if (!started) logicalHandoff?.cancel();
 			return await this.processAgentResult({
 				runAgentResult,
 				agent,
 				runId: logicalRunId
 			});
 		} catch (error) {
-			continuationHandoff?.cancel();
+			logicalHandoff?.cancel();
 			const runError = error instanceof Error ? error : new Error(String(error));
 			const context = {};
 			if (agent.agentId) context.agentId = agent.agentId;
@@ -3944,6 +4066,15 @@ var StateManager = class {
 	activeRun = /* @__PURE__ */ new Map();
 	agentSubscriptions = /* @__PURE__ */ new Map();
 	pendingContinuations = /* @__PURE__ */ new WeakMap();
+	interruptedRuns = /* @__PURE__ */ new WeakMap();
+	/** Find the interrupted logical run without consuming its pending answers. */
+	getContinuationRunId(agent, input) {
+		const pending = this.interruptedRuns.get(agent)?.get(input.threadId);
+		if (!pending) return void 0;
+		if (pending.interruptIds === null) return input.resume === void 0 && isContinuation(input) ? pending.runId : void 0;
+		const submitted = new Set(input.resume?.map((entry) => entry.interruptId));
+		return submitted.size > 0 && submitted.size === input.resume?.length && submitted.size === pending.interruptIds.length && pending.interruptIds.every((id) => submitted.has(id)) ? pending.runId : void 0;
+	}
 	constructor(core) {
 		this.core = core;
 	}
@@ -3987,6 +4118,7 @@ var StateManager = class {
 		}
 		let revoked = false;
 		let subRunId;
+		let legacyInterrupted = false;
 		let runFinished = false;
 		const pendingResults = /* @__PURE__ */ new WeakMap();
 		const reconcilePendingResults = (historyMessages, input) => {
@@ -4052,21 +4184,43 @@ var StateManager = class {
 				if (revoked) return;
 				const internalContinuation = [...this.pendingContinuations.get(agent) ?? []].find((pending) => pending.expectedInput === input);
 				internalContinuation?.cancel();
+				const startedInput = event.input ?? {
+					...input,
+					threadId: event.threadId
+				};
+				const resumedRunId = this.getContinuationRunId(agent, startedInput);
+				this.interruptedRuns.get(agent)?.delete(startedInput.threadId);
+				legacyInterrupted = false;
 				if (internalContinuation) subRunId = internalContinuation.expectedRunId ?? event.runId ?? input.runId;
+				else if (resumedRunId) subRunId = resumedRunId;
 				else if (runFinished && input.runId === subRunId && !isContinuation(input) && (event.runId == null || event.runId === subRunId)) subRunId = randomUUID();
 				else subRunId = event.runId || input.runId;
 				runFinished = false;
 				this.handleRunStarted(agent, effectiveInput(input), state);
 			},
-			onRunFinishedEvent: ({ input, state, messages }) => {
+			onRunFinishedEvent: ({ event, input, state, messages }) => {
 				if (revoked) return;
 				runFinished = true;
 				const effective = effectiveInput(input);
+				let interrupted = this.interruptedRuns.get(agent);
+				if (event.outcome?.type === "interrupt" || legacyInterrupted) {
+					if (!interrupted) {
+						interrupted = /* @__PURE__ */ new Map();
+						this.interruptedRuns.set(agent, interrupted);
+					}
+					interrupted.set(event.threadId, {
+						runId: effective.runId,
+						interruptIds: event.outcome?.type === "interrupt" ? event.outcome.interrupts.map((interrupt) => interrupt.id) : null
+					});
+				} else interrupted?.delete(event.threadId);
 				const mutation = reconcilePendingResults(messages, input);
 				clearPendingResults(input);
 				this.handleRunFinished(agent, effective, state);
 				return mutation;
 			},
+			onCustomEvent: ({ event }) => {
+				if (!revoked && event.name === "on_interrupt") legacyInterrupted = true;
+			},
 			onRunErrorEvent: ({ input, state, messages }) => {
 				if (revoked) return;
 				runFinished = true;
@@ -4123,6 +4277,7 @@ var StateManager = class {
 			unsubscribe: () => {
 				revoked = true;
 				this.pendingContinuations.delete(agent);
+				this.interruptedRuns.delete(agent);
 				unsubscribe();
 			}
 		});
@@ -4283,6 +4438,8 @@ var StateManager = class {
 	* Clear all state for an agent
 	*/
 	clearAgentState(agentId) {
+		const agent = this.agentSubscriptions.get(agentId)?.agent;
+		if (agent) this.interruptedRuns.delete(agent);
 		this.stateByRun.delete(agentId);
 		this.messageToRun.delete(agentId);
 		this.rawEventByMessage.delete(agentId);
@@ -4291,6 +4448,8 @@ var StateManager = class {
 	* Clear all state for a thread
 	*/
 	clearThreadState(agentId, threadId) {
+		const agent = this.agentSubscriptions.get(agentId)?.agent;
+		if (agent) this.interruptedRuns.get(agent)?.delete(threadId);
 		this.stateByRun.get(agentId)?.delete(threadId);
 		this.messageToRun.get(agentId)?.delete(threadId);
 		this.rawEventByMessage.get(agentId)?.delete(threadId);
@@ -7355,5 +7514,5 @@ function onInspectorViewThreadResult(handler) {
 }
 
 //#endregion
-export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, WebMCPRegistry, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, getWebMCPModelContext, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, WebMCPRegistry, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, getWebMCPModelContext, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, ɵisHttpAgent, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
 //# sourceMappingURL=index.mjs.map