@copilotkit/core 1.74.0 → 1.75.1

package/dist/index.mjs

@@ -2,7 +2,7 @@ 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 { 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, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
+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 { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
@@ -24,20 +24,23 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 *
 * `transformChunks` is still applied — message reassembly is needed either way.
 *
-* This mirrors the base `AbstractAgent.connectAgent` implementation exactly
-* apart from that omission, so callers keep the same subscriber notifications,
-* detach semantics, and `{ result, newMessages }` return shape.
+* 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.
 *
 * 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. As of `@ag-ui/client@0.0.57`
+* 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`
 * `connectAgent(parameters?, subscriber?)` takes no such option.
 *
 * @param agent - The agent whose `connect()` stream should be consumed.
 * @param parameters - Run parameters, forwarded to `prepareRunAgentInput`.
 * @param subscriber - Optional one-shot subscriber for this connect call.
 */
-async function ɵconnectWithoutEventVerification(agent, parameters, subscriber) {
+async function ɵconnectWithoutEventVerification(agent, parameters, subscriber, connect) {
 	const self = agent;
 	try {
 		agent.isRunning = true;
@@ -45,10 +48,20 @@ async function ɵconnectWithoutEventVerification(agent, parameters, subscriber)
 		const input = self.prepareRunAgentInput(parameters);
 		let result;
 		const previousMessageIds = new Set(agent.messages.map((m) => m.id));
+		let isReplaying = true;
+		const liveErrors = /* @__PURE__ */ new WeakSet();
 		const subscribers = [
-			{ onRunFinishedEvent: (event) => {
-				if (event.outcome === "success") result = event.result;
-			} },
+			{
+				onRunStartedEvent: () => {
+					agent.isRunning = true;
+				},
+				onRunErrorEvent: ({ event }) => {
+					if (liveErrors.has(event)) agent.isRunning = false;
+				},
+				onRunFinishedEvent: (event) => {
+					if (event.outcome === "success") result = event.result;
+				}
+			},
 			...agent.subscribers,
 			subscriber ?? {}
 		];
@@ -58,7 +71,18 @@ async function ɵconnectWithoutEventVerification(agent, parameters, subscriber)
 		self.activeRunCompletionPromise = new Promise((resolve) => {
 			resolveCompletion = resolve;
 		});
-		const source$ = defer(() => self.connect(input)).pipe(transformChunks(self.debugLogger), takeUntil(self.activeRunDetach$));
+		const lifecycle = {
+			onReplayStarted: () => {
+				isReplaying = true;
+				agent.isRunning = true;
+			},
+			onReplayFinished: () => {
+				isReplaying = false;
+			}
+		};
+		const source$ = defer(() => 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$));
 		const applied$ = self.apply(input, source$, subscribers);
 		await lastValueFrom(self.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
 			agent.isRunning = false;
@@ -205,9 +229,11 @@ function ɵobservePhoenixSocketHealth$(socketSignals$, maxConsecutiveErrors) {
 const globalFetch = (...args) => fetch(...args);
 const CLIENT_AG_UI_EVENT = "ag_ui_event";
 const REPLAY_COMPLETE_EVENT = "replay_complete";
+const REPLAY_FAILED_EVENT = "replay_failed";
 const STREAM_IDLE_EVENT = "stream_idle";
 const STOP_RUN_EVENT = "stop_run";
 const CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS = 100;
+const CONNECT_IDLE_WARNING_MS = 3e4;
 const MAX_UNOPENED_CREDENTIAL_REFRESHES = 2;
 var AgentThreadLockedError = class extends Error {
 	constructor(threadId) {
@@ -295,7 +321,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 			...parameters,
 			runId: this.canonicalRunId
 		};
-		return ɵconnectWithoutEventVerification(this, effectiveParameters, subscriber);
+		return ɵconnectWithoutEventVerification(this, effectiveParameters, subscriber, (input, lifecycle) => this.connect(input, lifecycle));
 	}
 	abortRun() {
 		if (this.activeChannel && this.canonicalRunId) {
@@ -344,17 +370,22 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	* gateway only streams events past it instead of replaying the
 	* entire history every time the chat re-opens a socket.
 	*/
-	connect(input) {
+	connect(input, lifecycle) {
 		this.threadId = input.threadId;
 		this.canonicalRunId = null;
 		const replayCursor = this.getReconnectCursor(input);
 		return defer(() => this.requestJoinCredentials$("connect", input, replayCursor)).pipe(switchMap((credentials) => {
-			if (credentials === null) return EMPTY;
+			if (credentials === null) {
+				lifecycle?.onReplayStarted?.();
+				lifecycle?.onReplayFinished?.();
+				return EMPTY;
+			}
 			const canonicalInput = this.applyCanonicalRunIdentity(input, credentials, { fallbackToInputRunId: false });
 			return this.observeThread$(canonicalInput, credentials, {
 				completeOnRunError: false,
 				streamMode: "connect",
-				replayCursor
+				replayCursor,
+				lifecycle
 			});
 		}));
 	}
@@ -454,8 +485,24 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	}
 	observeThreadSession$(input, credentials, options) {
 		return defer(() => {
+			options.lifecycle?.onReplayStarted?.();
 			let ownSocket = null;
 			let ownChannel = null;
+			let replayFinished = false;
+			let warnedAboutIdle = false;
+			let idleWarning;
+			const clearIdleWarning = () => {
+				clearTimeout(idleWarning);
+				idleWarning = void 0;
+			};
+			const scheduleIdleWarning = () => {
+				clearIdleWarning();
+				if (options.streamMode !== "connect" || !replayFinished || warnedAboutIdle) return;
+				idleWarning = setTimeout(() => {
+					warnedAboutIdle = true;
+					this.debugLogger?.lifecycle("INTELLIGENCE", "No progress or stream_idle for 30 seconds after replay_complete; the run may still be active or its status unavailable.", { threadId: input.threadId });
+				}, CONNECT_IDLE_WARNING_MS);
+			};
 			const socket$ = ɵphoenixSocket$({
 				url: credentials.realtime.clientUrl,
 				options: {
@@ -489,19 +536,42 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 			let latestObservedReplayCursor = null;
 			const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe(tap((payload) => {
 				latestObservedReplayCursor = this.readEventId(payload) ?? latestObservedReplayCursor;
+				scheduleIdleWarning();
 			}), share());
-			const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT).pipe(shareReplay({
-				bufferSize: 1,
-				refCount: true
+			const controlCursor = {
+				applied: null,
+				replayFailed: false
+			};
+			const replayFailed$ = channel$.pipe(switchMap$1(({ channel }) => this.observeChannelEvent$(channel, REPLAY_FAILED_EVENT)), tap(() => {
+				controlCursor.replayFailed = true;
 			}));
-			const streamIdle$ = this.observeControlEvent$(input.threadId, channel$, STREAM_IDLE_EVENT).pipe(shareReplay({
+			const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT, controlCursor).pipe(tap(() => {
+				replayFinished = true;
+				scheduleIdleWarning();
+				options.lifecycle?.onReplayFinished?.();
+			}), share());
+			const streamIdle$ = this.observeControlEvent$(input.threadId, channel$, STREAM_IDLE_EVENT, controlCursor).pipe(share());
+			const replayRestart$ = merge(this.observeControlEvent$(input.threadId, channel$, "phx_error", controlCursor), ɵobservePhoenixSocketSignals$(socket$).pipe(filter((signal) => signal.type === "error"))).pipe(tap(() => {
+				replayFinished = false;
+				warnedAboutIdle = false;
+				clearIdleWarning();
+				options.lifecycle?.onReplayStarted?.();
+			}), share());
+			const streamIdleCompletion$ = options.streamMode === "connect" ? replayRestart$.pipe(startWith(null), switchMap(() => merge(combineLatest([replayComplete$.pipe(take(1)), streamIdle$.pipe(take(1))]), streamIdle$.pipe(take(1), filter((payload) => this.canFallbackCompleteConnect(payload, reconnectCursor, latestObservedReplayCursor)), delay(CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS), tap(() => {
+				this.debugLogger?.lifecycle("INTELLIGENCE", "Completing connection on stream_idle fallback without replay_complete.", {
+					threadId: input.threadId,
+					fallbackMs: CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS
+				});
+			})))), take(1), shareReplay({
 				bufferSize: 1,
 				refCount: true
-			}));
-			const streamIdleCompletion$ = options.streamMode === "connect" ? merge(combineLatest([replayComplete$.pipe(take(1)), streamIdle$.pipe(take(1))]), streamIdle$.pipe(take(1), filter((payload) => this.canFallbackCompleteConnect(payload, reconnectCursor, latestObservedReplayCursor)), delay(CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS))).pipe(take(1)) : EMPTY;
+			})) : EMPTY;
 			const threadCompleted$ = threadEvents$.pipe(ignoreElements(), endWith(null), take(1));
 			const terminal$ = merge(threadCompleted$, streamIdleCompletion$);
-			return merge(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$, options.onSocketOpen).pipe(takeUntil(terminal$)), threadEvents$.pipe(takeUntil(streamIdleCompletion$)), replayComplete$.pipe(ignoreElements(), takeUntil(terminal$)), streamIdleCompletion$.pipe(ignoreElements(), takeUntil(threadCompleted$))).pipe(finalize(() => this.cleanupOwned(ownChannel, ownSocket)));
+			return merge(replayFailed$.pipe(ignoreElements(), takeUntil(terminal$)), replayComplete$.pipe(ignoreElements(), takeUntil(terminal$)), this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$, options.onSocketOpen).pipe(takeUntil(terminal$)), threadEvents$.pipe(takeUntil(streamIdleCompletion$)), streamIdleCompletion$.pipe(ignoreElements(), takeUntil(threadCompleted$))).pipe(finalize(() => {
+				clearIdleWarning();
+				this.cleanupOwned(ownChannel, ownSocket);
+			}));
 		});
 	}
 	joinThreadChannel$(channel$) {
@@ -521,8 +591,8 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 			errorOnRunError: options.streamMode === "run"
 		})), dematerialize());
 	}
-	observeControlEvent$(threadId, channel$, eventName) {
-		return channel$.pipe(switchMap$1(({ channel }) => this.observeChannelEvent$(channel, eventName)), tap((payload) => this.updateLastSeenEventIdFromControl(threadId, payload)));
+	observeControlEvent$(threadId, channel$, eventName, controlCursor) {
+		return channel$.pipe(switchMap$1(({ channel }) => this.observeChannelEvent$(channel, eventName)), tap((payload) => this.updateLastSeenEventIdFromControl(threadId, payload, controlCursor)));
 	}
 	observeChannelEvent$(channel, eventName) {
 		return ɵobservePhoenixEvent$(channel, eventName);
@@ -571,9 +641,11 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 		if (!eventId) return;
 		this.advanceLastSeenEventId(threadId, eventId);
 	}
-	updateLastSeenEventIdFromControl(threadId, payload) {
+	updateLastSeenEventIdFromControl(threadId, payload, controlCursor) {
 		const eventId = this.readControlEventId(payload);
 		if (!eventId) return;
+		if (eventId === controlCursor.applied && !controlCursor.replayFailed) return;
+		controlCursor.applied = eventId;
 		this.advanceLastSeenEventId(threadId, eventId);
 	}
 	advanceLastSeenEventId(threadId, eventId) {
@@ -981,7 +1053,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		});
 	}
 	async connectAgent(parameters, subscriber) {
-		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return ɵconnectWithoutEventVerification(this, parameters, subscriber);
+		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();
 		const delegate = this.delegate;
@@ -1002,7 +1074,10 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 				this.isRunning = false;
 			},
 			onRunErrorEvent: () => {
-				this.isRunning = false;
+				this.isRunning = delegate.isRunning;
+			},
+			onRunStartedEvent: () => {
+				this.isRunning = delegate.isRunning;
 			}
 		});
 		const forwardedSubs = this.subscribers.map((s) => delegate.subscribe(s));
@@ -1017,9 +1092,9 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 			for (const sub of forwardedSubs) sub.unsubscribe();
 		}
 	}
-	connect(input) {
-		if (this.runtimeMode === "pending" || this.transport === "auto" && this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return defer(() => from(this.ensureRuntimeConfiguration())).pipe(switchMap$1(() => this.connect(input)));
-		if (this.runtimeMode === RUNTIME_MODE_INTELLIGENCE) return this.#connectViaDelegate(input);
+	connect(input, lifecycle) {
+		if (this.runtimeMode === "pending" || this.transport === "auto" && this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return defer(() => from(this.ensureRuntimeConfiguration())).pipe(switchMap$1(() => this.connect(input, lifecycle)));
+		if (this.runtimeMode === RUNTIME_MODE_INTELLIGENCE) return this.#connectViaDelegate(input, lifecycle);
 		return this.#connectViaHttp(input);
 	}
 	run(input) {
@@ -1027,8 +1102,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		if (this.runtimeMode === RUNTIME_MODE_INTELLIGENCE) return this.#runViaDelegate(input);
 		return this.#runViaHttp(input);
 	}
-	#connectViaDelegate(input) {
-		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.connect(input))));
+	#connectViaDelegate(input, lifecycle) {
+		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.connect(input, lifecycle))));
 	}
 	#connectViaHttp(unfiltered) {
 		const input = this.#applyMessageFilter(unfiltered);
@@ -1222,6 +1297,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		delegate.agentId = this.routedAgentId();
 		delegate.description = this.description;
 		delegate.threadId = this.threadId;
+		delegate.debugLogger = this.debugLogger;
 		delegate.setMessages(this.messages);
 		delegate.setState(this.state);
 		if (hasHeaders(delegate)) delegate.headers = { ...this.headers };
@@ -5393,6 +5469,7 @@ const ALLOWED_KEYS = new Set([
 	"onMessagesChanged",
 	"onStateChanged",
 	"onRunInitialized",
+	"onRunStartedEvent",
 	"onRunFinalized",
 	"onRunFailed",
 	"onRunErrorEvent"
@@ -5994,6 +6071,10 @@ var CopilotKitCore = class {
 				const fn = sub.onRunInitialized;
 				guarded.onRunInitialized = (params) => safeCall("onRunInitialized", fn, params);
 			}
+			if (sub.onRunStartedEvent) {
+				const fn = sub.onRunStartedEvent;
+				guarded.onRunStartedEvent = (params) => safeCall("onRunStartedEvent", fn, params);
+			}
 			if (sub.onRunFinalized) {
 				const fn = sub.onRunFinalized;
 				guarded.onRunFinalized = (params) => safeCall("onRunFinalized", fn, params);
@@ -6045,6 +6126,7 @@ var CopilotKitCore = class {
 		});
 		const lifecycleOnly = {};
 		if (subscriber.onRunInitialized) lifecycleOnly.onRunInitialized = subscriber.onRunInitialized;
+		if (subscriber.onRunStartedEvent) lifecycleOnly.onRunStartedEvent = subscriber.onRunStartedEvent;
 		if (subscriber.onRunFinalized) lifecycleOnly.onRunFinalized = subscriber.onRunFinalized;
 		if (subscriber.onRunFailed) lifecycleOnly.onRunFailed = subscriber.onRunFailed;
 		if (subscriber.onRunErrorEvent) lifecycleOnly.onRunErrorEvent = subscriber.onRunErrorEvent;