@copilotkit/core 1.62.1 → 1.62.2

package/dist/index.mjs

@@ -1,11 +1,10 @@
 import { Throttler } from "@tanstack/pacer";
 import { AbstractAgent, EventType, HttpAgent, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
 import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema } from "@copilotkit/shared";
-import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, of, switchMap, throwError } from "rxjs";
-import { catchError, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
+import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, of, switchMap, throwError } from "rxjs";
+import { catchError, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
 import { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { fromFetch } from "rxjs/fetch";
 
 //#region src/utils/phoenix-observable.ts
 /**
@@ -130,6 +129,7 @@ const CLIENT_AG_UI_EVENT = "ag_ui_event";
 const REPLAY_COMPLETE_EVENT = "replay_complete";
 const STREAM_IDLE_EVENT = "stream_idle";
 const STOP_RUN_EVENT = "stop_run";
+const CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS = 100;
 var AgentThreadLockedError = class extends Error {
 	constructor(threadId) {
 		super(threadId ? `Thread ${threadId} is locked` : "Thread is locked");
@@ -279,12 +279,14 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	connect(input) {
 		this.threadId = input.threadId;
 		this.canonicalRunId = null;
-		return defer(() => this.requestJoinCredentials$("connect", input)).pipe(switchMap((credentials) => {
+		const replayCursor = this.getReconnectCursor(input);
+		return defer(() => this.requestJoinCredentials$("connect", input, replayCursor)).pipe(switchMap((credentials) => {
 			if (credentials === null) return EMPTY;
 			const canonicalInput = this.applyCanonicalRunIdentity(input, credentials, { fallbackToInputRunId: false });
 			return this.observeThread$(canonicalInput, credentials, {
 				completeOnRunError: false,
-				streamMode: "connect"
+				streamMode: "connect",
+				replayCursor
 			});
 		}));
 	}
@@ -307,7 +309,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	cleanup() {
 		this.cleanupOwned(this.activeChannel, this.socket);
 	}
-	requestJoinCredentials$(mode, input) {
+	requestJoinCredentials$(mode, input, replayCursor) {
 		return defer(async () => {
 			try {
 				const response = await fetch(this.buildRuntimeUrl(mode), {
@@ -324,7 +326,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 						context: input.context,
 						state: input.state,
 						forwardedProps: input.forwardedProps,
-						...mode === "connect" ? { lastSeenEventId: this.getReconnectCursor(input) } : {}
+						...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
 					}),
 					...this.config.credentials ? { credentials: this.config.credentials } : {}
 				});
@@ -360,10 +362,11 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	observeThread$(input, credentials, options) {
 		return this.observeThreadSession$(input, credentials, options).pipe(catchError((error) => {
 			if (!this.isSocketReconnectExhaustedError(error)) return throwError(() => error);
-			return this.requestJoinCredentials$("connect", input).pipe(switchMap((refreshedCredentials) => refreshedCredentials === null ? EMPTY : this.observeThread$(this.applyCanonicalRunIdentity(input, refreshedCredentials, { fallbackToInputRunId: options.streamMode === "run" }), refreshedCredentials, {
+			const replayCursor = this.getReconnectCursor(input);
+			return this.requestJoinCredentials$("connect", input, replayCursor).pipe(switchMap((refreshedCredentials) => refreshedCredentials === null ? EMPTY : this.observeThread$(this.applyCanonicalRunIdentity(input, refreshedCredentials, { fallbackToInputRunId: options.streamMode === "run" }), refreshedCredentials, {
 				...options,
 				channelMode: "connect",
-				replayCursor: this.getReconnectCursor(input)
+				replayCursor
 			})));
 		}));
 	}
@@ -400,15 +403,23 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 				bufferSize: 1,
 				refCount: true
 			}));
-			const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe(share());
-			const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT).pipe(ignoreElements(), share());
+			const reconnectCursor = this.readDurableEventId(options.replayCursor ?? this.getReconnectCursor(input));
+			let latestObservedReplayCursor = null;
+			const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe(tap((payload) => {
+				latestObservedReplayCursor = this.readEventId(payload) ?? latestObservedReplayCursor;
+			}), share());
+			const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT).pipe(shareReplay({
+				bufferSize: 1,
+				refCount: true
+			}));
 			const streamIdle$ = this.observeControlEvent$(input.threadId, channel$, STREAM_IDLE_EVENT).pipe(shareReplay({
 				bufferSize: 1,
 				refCount: true
 			}));
-			const streamIdleCompletion$ = options.streamMode === "connect" ? streamIdle$.pipe(take(1)) : EMPTY;
-			const terminal$ = merge(threadEvents$.pipe(ignoreElements(), endWith(null), take(1)), streamIdleCompletion$);
-			return merge(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe(takeUntil(terminal$)), threadEvents$.pipe(takeUntil(streamIdleCompletion$)), replayComplete$.pipe(takeUntil(terminal$)), streamIdleCompletion$.pipe(ignoreElements())).pipe(finalize(() => this.cleanupOwned(ownChannel, ownSocket)));
+			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;
+			const threadCompleted$ = threadEvents$.pipe(ignoreElements(), endWith(null), take(1));
+			const terminal$ = merge(threadCompleted$, streamIdleCompletion$);
+			return merge(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe(takeUntil(terminal$)), threadEvents$.pipe(takeUntil(streamIdleCompletion$)), replayComplete$.pipe(ignoreElements(), takeUntil(terminal$)), streamIdleCompletion$.pipe(ignoreElements(), takeUntil(threadCompleted$))).pipe(finalize(() => this.cleanupOwned(ownChannel, ownSocket)));
 		});
 	}
 	joinThreadChannel$(channel$) {
@@ -474,23 +485,36 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	updateLastSeenEventId(threadId, payload) {
 		const eventId = this.readEventId(payload);
 		if (!eventId) return;
-		this.sharedState.lastSeenEventIds.set(threadId, eventId);
+		this.advanceLastSeenEventId(threadId, eventId);
 	}
 	updateLastSeenEventIdFromControl(threadId, payload) {
 		const eventId = this.readControlEventId(payload);
 		if (!eventId) return;
+		this.advanceLastSeenEventId(threadId, eventId);
+	}
+	advanceLastSeenEventId(threadId, eventId) {
 		this.sharedState.lastSeenEventIds.set(threadId, eventId);
 	}
 	readEventId(payload) {
 		const metadata = payload.metadata;
 		if (!metadata || typeof metadata !== "object") return null;
-		const runnerEventId = metadata.cpki_event_id;
-		return typeof runnerEventId === "string" ? runnerEventId : null;
+		const eventMetadata = metadata;
+		return this.readDurableEventId(eventMetadata.cpki_event_id);
 	}
 	readControlEventId(payload) {
 		if (!payload || typeof payload !== "object") return null;
-		const latestEventId = payload.latestEventId;
-		return typeof latestEventId === "string" ? latestEventId : null;
+		const controlPayload = payload;
+		const latestEventId = controlPayload.latestEventId ?? controlPayload.latest_event_id;
+		return this.readDurableEventId(latestEventId);
+	}
+	readDurableEventId(eventId) {
+		if (typeof eventId !== "string" || eventId.trim() === "") return null;
+		return eventId.startsWith("cpki_ingested") ? null : eventId;
+	}
+	canFallbackCompleteConnect(streamIdlePayload, reconnectCursor, latestObservedReplayCursor) {
+		const idleCursor = this.readControlEventId(streamIdlePayload);
+		if (!idleCursor) return true;
+		return idleCursor === reconnectCursor || idleCursor === latestObservedReplayCursor;
 	}
 	applyCanonicalRunIdentity(input, credentials, options) {
 		this.threadId = credentials.threadId;
@@ -1659,7 +1683,9 @@ var RunHandler = class {
 	* downstream churn into duplicate `cpki_event_id` rows in the
 	* inspector and intermittent "Message not found" toasts.
 	*/
-	_lastConnectedThreadId = null;
+	_lastConnectedThreadIdsByAgent = /* @__PURE__ */ new Map();
+	_anonymousAgentIds = /* @__PURE__ */ new WeakMap();
+	_nextAnonymousAgentId = 0;
 	constructor(core) {
 		this.core = core;
 	}
@@ -1679,6 +1705,20 @@ var RunHandler = class {
 		return this.core;
 	}
 	/**
+	* Return a stable restore-tracking key for the logical agent being
+	* connected. Named agents share their last-thread marker across proxy
+	* instances; anonymous agents fall back to object identity.
+	*/
+	getConnectRestoreKey(agent) {
+		if (agent.agentId) return `agent:${agent.agentId}`;
+		const existing = this._anonymousAgentIds.get(agent);
+		if (existing) return existing;
+		const anonymousId = `anonymous:${this._nextAnonymousAgentId}`;
+		this._nextAnonymousAgentId += 1;
+		this._anonymousAgentIds.set(agent, anonymousId);
+		return anonymousId;
+	}
+	/**
 	* Get all tools as a readonly array
 	*/
 	get tools() {
@@ -1734,14 +1774,18 @@ var RunHandler = class {
 	async connectAgent({ agent }) {
 		try {
 			const incomingThreadId = agent.threadId ?? null;
-			const isFreshRestore = incomingThreadId !== this._lastConnectedThreadId;
-			this._lastConnectedThreadId = incomingThreadId;
+			const restoreKey = this.getConnectRestoreKey(agent);
+			const isFreshRestore = incomingThreadId !== (this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? null);
+			this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
 			await agent.detachActiveRun();
 			if (isFreshRestore) {
 				agent.setMessages([]);
 				agent.setState({});
-				const proxied = agent;
-				if (incomingThreadId && typeof proxied.clearReplayCursor === "function") proxied.clearReplayCursor(incomingThreadId);
+				const cursorAware = agent;
+				if (incomingThreadId) {
+					if (typeof cursorAware.clearReplayCursor === "function") cursorAware.clearReplayCursor(incomingThreadId);
+					if (typeof cursorAware.clearReconnectCursor === "function") cursorAware.clearReconnectCursor(incomingThreadId);
+				}
 			}
 			this._internal.applyHeadersToAgent(agent);
 			await this._internal.notifySubscribers((subscriber) => subscriber.onAgentRunStarted?.({
@@ -1755,7 +1799,8 @@ var RunHandler = class {
 			}, this.createAgentErrorSubscriber(agent));
 			return this.processAgentResult({
 				runAgentResult,
-				agent
+				agent,
+				executeFrontendTools: false
 			});
 		} catch (error) {
 			const connectError = error instanceof Error ? error : new Error(String(error));
@@ -1777,7 +1822,7 @@ var RunHandler = class {
 	/**
 	* Run an agent
 	*/
-	async runAgent({ agent, forwardedProps, resume }) {
+	async runAgent({ agent, forwardedProps, resume, runId }) {
 		if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
 		this._internal.applyHeadersToAgent(agent);
 		if (agent.detachActiveRun) await agent.detachActiveRun();
@@ -1804,6 +1849,7 @@ var RunHandler = class {
 					...forwardedProps
 				},
 				...resume !== void 0 ? { resume } : {},
+				...runId !== void 0 ? { runId } : {},
 				tools: this.buildFrontendTools(agent.agentId),
 				context: this._internal.getContextForAgent(agent.agentId)
 			}, this.createAgentErrorSubscriber(agent));
@@ -1832,25 +1878,27 @@ var RunHandler = class {
 	/**
 	* Process agent result and execute tools
 	*/
-	async processAgentResult({ runAgentResult, agent }) {
+	async processAgentResult({ runAgentResult, agent, executeFrontendTools = true }) {
 		const { newMessages } = runAgentResult;
 		const agentId = agent.agentId;
 		let needsFollowUp = false;
-		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,
-					agentId: agent.agentId
-				});
-				if (tool) {
-					if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId)) needsFollowUp = true;
-				} else {
-					const wildcardTool = this.getTool({
-						toolName: "*",
+		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,
 						agentId: agent.agentId
 					});
-					if (wildcardTool) {
-						if (await this.executeWildcardTool(wildcardTool, toolCall, message, agent, agentId)) needsFollowUp = true;
+					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;
+						}
 					}
 				}
 			}
@@ -3584,6 +3632,7 @@ function createStore(options) {
 //#endregion
 //#region src/threads.ts
 const THREADS_CHANNEL_EVENT = "thread_metadata";
+const THREAD_RUN_ACTIVITY_CHANNEL_EVENT = "thread_run_activity";
 const THREAD_SUBSCRIBE_PATH = "/threads/subscribe";
 const MAX_SOCKET_RETRIES = 5;
 const REQUEST_TIMEOUT_MS = 15e3;
@@ -3627,7 +3676,8 @@ const threadSocketEvents = createActionGroup("Thread Socket", {
 	errored: props(),
 	joinFailed: props(),
 	joinTimedOut: props(),
-	metadataReceived: props()
+	metadataReceived: props(),
+	runActivityReceived: props()
 });
 const threadDomainEvents = createActionGroup("Thread Domain", {
 	threadUpserted: props(),
@@ -3646,6 +3696,28 @@ function upsertThread(threads, thread) {
 	next[existingIndex] = thread;
 	return sortThreadsByRecency(next);
 }
+/**
+* Returns a non-empty string payload field or undefined for absent fields.
+*/
+function optionalString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* Converts gateway run-activity payloads into the internal TypeScript shape.
+*/
+function normalizeThreadRunActivityNotification(payload) {
+	const threadId = optionalString(payload.threadId ?? payload.thread_id);
+	const eventType = optionalString(payload.eventType ?? payload.event_type);
+	if (!threadId || !eventType) return null;
+	return {
+		type: "thread_run_activity",
+		threadId,
+		agentId: optionalString(payload.agentId ?? payload.agent_id),
+		runId: optionalString(payload.runId ?? payload.run_id),
+		eventType,
+		latestEventId: optionalString(payload.latestEventId ?? payload.latest_event_id)
+	};
+}
 const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.contextChanged, (state, { context }) => ({
 	...state,
 	context,
@@ -3679,12 +3751,14 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	};
 }), on(threadRestEvents.listSucceeded, (state, { sessionId, threads, joinCode, nextCursor }) => {
 	if (sessionId !== state.sessionId) return state;
+	const joinCodeChanged = joinCode !== state.metadataJoinCode;
 	return {
 		...state,
 		threads: sortThreadsByRecency(threads),
 		isLoading: false,
 		error: null,
 		metadataJoinCode: joinCode,
+		metadataCredentialsRequested: joinCodeChanged ? false : state.metadataCredentialsRequested,
 		nextCursor
 	};
 }), on(threadRestEvents.listFailed, (state, { sessionId, error }) => {
@@ -3713,7 +3787,10 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	};
 }), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId }) => {
 	if (sessionId !== state.sessionId) return state;
-	return state;
+	return {
+		...state,
+		metadataCredentialsRequested: false
+	};
 }), on(threadRestEvents.metadataCredentialsRequested, (state, { sessionId }) => {
 	if (sessionId !== state.sessionId) return state;
 	return {
@@ -3871,7 +3948,27 @@ function createThreadRequestId() {
 	return `thread-request-${threadRequestId}`;
 }
 function threadFromFetch(input, init) {
-	return fromFetch(input, init);
+	return new Observable((subscriber) => {
+		const { fetch: fetchImpl, selector, signal, ...requestInit } = init;
+		const controller = new AbortController();
+		const abortRequest = () => controller.abort();
+		if (signal?.aborted) abortRequest();
+		else signal?.addEventListener("abort", abortRequest, { once: true });
+		fetchImpl(input, {
+			...requestInit,
+			signal: controller.signal
+		}).then((response) => selector(response)).then((value) => {
+			if (subscriber.closed) return;
+			subscriber.next(value);
+			subscriber.complete();
+		}).catch((error) => {
+			if (!subscriber.closed) subscriber.error(error);
+		});
+		return () => {
+			signal?.removeEventListener("abort", abortRequest);
+			abortRequest();
+		};
+	});
 }
 function createThreadFetchObservable(environment, context, sessionId) {
 	return defer(() => {
@@ -4017,6 +4114,9 @@ function createThreadStore(environment) {
 					return merge(socketSignals$.pipe(map((signal) => signal.type === "open" ? threadSocketEvents.opened({ sessionId: action.sessionId }) : threadSocketEvents.errored({ sessionId: action.sessionId }))), channel$.pipe(switchMap$1(({ channel }) => ɵobservePhoenixEvent$(channel, THREADS_CHANNEL_EVENT)), map((payload) => threadSocketEvents.metadataReceived({
 						sessionId: action.sessionId,
 						payload
+					}))), channel$.pipe(switchMap$1(({ channel }) => ɵobservePhoenixEvent$(channel, THREAD_RUN_ACTIVITY_CHANNEL_EVENT)), map((payload) => normalizeThreadRunActivityNotification(payload)), filter((notification) => notification !== null), map((notification) => threadSocketEvents.runActivityReceived({
+						sessionId: action.sessionId,
+						notification
 					}))), ɵobservePhoenixJoinOutcome$(channel$).pipe(filter((outcome) => outcome.type !== "joined"), map((outcome) => outcome.type === "timeout" ? threadSocketEvents.joinTimedOut({ sessionId: action.sessionId }) : threadSocketEvents.joinFailed({ sessionId: action.sessionId })))).pipe(takeUntil(merge(shutdown$, fatalSocketShutdown$)));
 				});
 			}))),
@@ -4194,6 +4294,9 @@ function createThreadStore(environment) {
 				threadId
 			}));
 		},
+		subscribeToRunActivity(callback) {
+			return store.actions$.pipe(ofType(threadSocketEvents.runActivityReceived), filter((action) => action.sessionId === store.getState().sessionId), map((action) => action.notification)).subscribe(callback);
+		},
 		getState() {
 			return store.getState();
 		},