@copilotkit/core 1.57.1 → 1.57.2

package/dist/index.cjs

@@ -255,10 +255,22 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	* Reconnect to an existing thread by fetching websocket credentials and
 	* joining the realtime thread channel.
 	*/
+	/**
+	* Reconnect to an existing thread by fetching websocket credentials
+	* and joining the realtime thread channel.
+	*
+	* Note: this method does NOT clear the replay cursor. Whether to
+	* request a full historical replay vs. resume from
+	* `lastSeenEventId` is a decision the caller (typically
+	* `RunHandler.connectAgent`) makes by calling
+	* {@link clearReconnectCursor} ahead of time on a fresh thread
+	* restore. Same-thread churn re-connects preserve the cursor so the
+	* gateway only streams events past it instead of replaying the
+	* entire history every time the chat re-opens a socket.
+	*/
 	connect(input) {
 		this.threadId = input.threadId;
 		this.canonicalRunId = null;
-		this.clearReconnectCursor(input.threadId);
 		return (0, rxjs.defer)(() => this.requestJoinCredentials$("connect", input)).pipe((0, rxjs.switchMap)((credentials) => {
 			if (credentials === null) return rxjs.EMPTY;
 			const canonicalInput = this.applyCanonicalRunIdentity(input, credentials, { fallbackToInputRunId: false });
@@ -440,6 +452,14 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	getReconnectCursor(input) {
 		return this.getLastSeenEventId(input.threadId);
 	}
+	/**
+	* Drop the cached `lastSeenEventId` cursor for `threadId` so the
+	* next connect to that topic asks the gateway for a full historical
+	* replay (rather than resuming). Public because
+	* `RunHandler.connectAgent` calls it on a detected thread switch
+	* to rebuild local state from scratch, and skips it on same-thread
+	* churn so the gateway can resume.
+	*/
 	clearReconnectCursor(threadId) {
 		this.sharedState.lastSeenEventIds.delete(threadId);
 	}
@@ -694,6 +714,22 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		}
 		return cloned;
 	}
+	/**
+	* Drop the delegate's cached `lastSeenEventId` for this thread so
+	* the next connect requests a full historical replay from the
+	* gateway. Used by `RunHandler.connectAgent` on a detected thread
+	* switch (the chat moved between threads, so its local
+	* messages/state are about to be cleared and need rebuilding from
+	* the gateway). Skipped on same-thread churn re-connects so the
+	* gateway can resume from the cursor instead.
+	*
+	* No-op for non-Intelligence runtime modes — the HTTP transport
+	* doesn't replay.
+	*/
+	clearReplayCursor(threadId) {
+		if (this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return;
+		this.delegate?.clearReconnectCursor?.(threadId);
+	}
 	async resolveDelegate() {
 		await this.ensureRuntimeMode();
 		if (!this.delegate) {
@@ -825,6 +861,7 @@ var AgentRegistry = class {
 	_a2uiEnabled = false;
 	_openGenerativeUIEnabled = false;
 	_licenseStatus;
+	_telemetryDisabled = false;
 	constructor(core) {
 		this.core = core;
 	}
@@ -864,6 +901,9 @@ var AgentRegistry = class {
 	get licenseStatus() {
 		return this._licenseStatus;
 	}
+	get telemetryDisabled() {
+		return this._telemetryDisabled;
+	}
 	/**
 	* Initialize agents from configuration
 	*/
@@ -1063,6 +1103,7 @@ var AgentRegistry = class {
 			this._a2uiEnabled = runtimeInfoResponse.a2uiEnabled ?? false;
 			this._openGenerativeUIEnabled = runtimeInfoResponse.openGenerativeUIEnabled ?? false;
 			this._licenseStatus = runtimeInfoResponse.licenseStatus;
+			this._telemetryDisabled = runtimeInfoResponse.telemetryDisabled ?? false;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connected);
 			await this.notifyAgentsChanged();
 		} catch (error) {
@@ -1531,6 +1572,23 @@ var RunHandler = class {
 	* `processAgentResult`.
 	*/
 	_runDepth = 0;
+	/**
+	* Tracks the threadId of the most recent `connectAgent` call so we
+	* can distinguish a fresh thread restore (different threadId than
+	* last time — chat is rebuilding state from scratch, must clear
+	* messages/state and ask the gateway for a full replay) from a
+	* same-thread churn re-connect (effect-dep churn or transient
+	* disconnect — local messages/state are still meaningful, must
+	* preserve them and let the gateway resume from
+	* `lastSeenEventId`).
+	*
+	* Tyler's bug fired because every `connectAgent` was treated as a
+	* fresh restore, which forced the gateway to replay the full
+	* thread history on every churn re-connect and amplified the
+	* downstream churn into duplicate `cpki_event_id` rows in the
+	* inspector and intermittent "Message not found" toasts.
+	*/
+	_lastConnectedThreadId = null;
 	constructor(core) {
 		this.core = core;
 	}
@@ -1604,9 +1662,16 @@ var RunHandler = class {
 	*/
 	async connectAgent({ agent }) {
 		try {
+			const incomingThreadId = agent.threadId ?? null;
+			const isFreshRestore = incomingThreadId !== this._lastConnectedThreadId;
+			this._lastConnectedThreadId = incomingThreadId;
 			await agent.detachActiveRun();
-			agent.setMessages([]);
-			agent.setState({});
+			if (isFreshRestore) {
+				agent.setMessages([]);
+				agent.setState({});
+				const proxied = agent;
+				if (incomingThreadId && typeof proxied.clearReplayCursor === "function") proxied.clearReplayCursor(incomingThreadId);
+			}
 			if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
 			const runAgentResult = await agent.connectAgent({
 				forwardedProps: this._internal.properties,
@@ -2600,6 +2665,9 @@ var CopilotKitCore = class {
 	get licenseStatus() {
 		return this.agentRegistry.licenseStatus;
 	}
+	get telemetryDisabled() {
+		return this.agentRegistry.telemetryDisabled;
+	}
 	/**
 	* Configuration updates
 	*/