@copilotkit/core 1.77.0 → 1.77.1

package/dist/index.cjs

@@ -196,10 +196,17 @@ function ɵcreatePhoenixJoinOutcome$(channel) {
 *
 * The socket is constructed and connected on subscription, and disconnected on
 * teardown. Each subscription creates an isolated socket instance.
+*
+* Heartbeats default to every 15s: Phoenix's own 30s default matches common
+* reverse-proxy WebSocket idle timeouts (e.g. Azure Application Gateway), which
+* would drop the socket during a quiet run. Callers may override it.
 */
 function ɵphoenixSocket$(options) {
 	return (0, rxjs.defer)(() => {
-		const socket = new phoenix.Socket(options.url, options.options);
+		const socket = new phoenix.Socket(options.url, {
+			heartbeatIntervalMs: 15e3,
+			...options.options
+		});
 		const signals$ = ɵcreatePhoenixSocketSignals$(socket).pipe((0, rxjs_operators.shareReplay)({
 			bufferSize: 1,
 			refCount: true
@@ -283,6 +290,11 @@ 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;
+function isMcpResourceRead(input) {
+	const forwardedProps = input.forwardedProps;
+	const request = forwardedProps?.__proxiedMCPRequest;
+	return forwardedProps?.__copilotkitMcpResourceReadOnly === true && typeof request === "object" && request !== null && request.method === "resources/read";
+}
 var AgentThreadLockedError = class extends Error {
 	constructor(threadId) {
 		super(threadId ? `Thread ${threadId} is locked` : "Thread is locked");
@@ -390,10 +402,22 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	* server-pushed AG-UI events to the Observable subscriber.
 	*/
 	run(input) {
-		this.threadId = input.threadId;
-		this.canonicalRunId = input.runId;
+		if (!isMcpResourceRead(input)) {
+			this.threadId = input.threadId;
+			this.canonicalRunId = input.runId;
+		}
 		return (0, rxjs.defer)(() => this.requestJoinCredentials$("run", input)).pipe((0, rxjs.switchMap)((credentials) => {
 			if (credentials === null) return (0, rxjs.throwError)(() => /* @__PURE__ */ new Error("REST run request returned no credentials"));
+			if ("kind" in credentials) return (0, rxjs.of)({
+				type: _ag_ui_client.EventType.RUN_STARTED,
+				threadId: credentials.threadId,
+				runId: credentials.runId
+			}, {
+				type: _ag_ui_client.EventType.RUN_FINISHED,
+				threadId: credentials.threadId,
+				runId: credentials.runId,
+				result: credentials.result
+			});
 			const canonicalInput = this.applyCanonicalRunIdentity(input, credentials, { fallbackToInputRunId: true });
 			return this.observeThread$(canonicalInput, credentials, {
 				completeOnRunError: false,
@@ -485,7 +509,18 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 					const text = await response.text().catch(() => "");
 					throw new Error(text || response.statusText || String(response.status));
 				}
-				return this.normalizeJoinCredentials(await response.json(), input);
+				const payload = await response.json();
+				if (mode === "run" && isMcpResourceRead(input) && typeof payload === "object" && payload !== null && payload.kind === "mcp-resource-read") {
+					const resource = payload;
+					if (typeof resource.threadId !== "string" || !resource.threadId || typeof resource.runId !== "string" || !resource.runId) throw new Error("invalid MCP resource response identity");
+					return {
+						kind: "mcp-resource-read",
+						threadId: resource.threadId,
+						runId: resource.runId,
+						result: resource.result
+					};
+				}
+				return this.normalizeJoinCredentials(payload, input);
 			} catch (error) {
 				if (error instanceof AgentThreadLockedError) throw error;
 				throw new Error(`REST ${mode} request failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
@@ -1268,6 +1303,21 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		}
 		return cloned;
 	}
+	/** Run presentation-only MCP reads on a separate client agent so their
+	* lifecycle cannot replace an in-flight approval's detach/completion state. */
+	async ɵrunMcpResourceRead(parameters) {
+		const request = parameters.forwardedProps?.__proxiedMCPRequest;
+		if (typeof request !== "object" || request === null || request.method !== "resources/read") throw new Error("Only MCP resources/read can use the read-only path");
+		await this.ensureRuntimeConfiguration();
+		const resourceParameters = {
+			...parameters,
+			forwardedProps: {
+				...parameters.forwardedProps,
+				__copilotkitMcpResourceReadOnly: true
+			}
+		};
+		return this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE ? this.clone().runAgent(resourceParameters) : this.runAgent(resourceParameters);
+	}
 	/**
 	* Drop the delegate's cached `lastSeenEventId` for this thread so
 	* the next connect requests a full historical replay from the
@@ -3489,7 +3539,7 @@ var RunHandler = class {
 			this.processAgentResult({
 				runAgentResult,
 				agent,
-				toolExecutionMode: "human-in-the-loop",
+				toolExecutionMode: "restore",
 				signal: controller.signal
 			}).catch(async (error) => {
 				await this._internal.emitError({
@@ -3620,8 +3670,8 @@ var RunHandler = class {
 		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;
+		if (toolExecutionMode === "restore" && 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 === "restore" ? [...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,
@@ -3637,7 +3687,7 @@ var RunHandler = class {
 				return wildcardTool;
 			};
 			const executableTool = tool ?? getWildcardTool();
-			if (toolExecutionMode === "human-in-the-loop" && (executableTool?.type !== "human-in-the-loop" || !executableTool.handler)) continue;
+			if (toolExecutionMode === "restore" && (!executableTool?.handler || executableTool.type !== "human-in-the-loop" && executableTool.reconnectBehavior !== "resume-pending")) 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);
@@ -3668,14 +3718,14 @@ var RunHandler = class {
 					if (signal?.aborted) abortInteraction();
 				}
 				const executionSignal = interactionController?.signal ?? signal;
-				const discardOnAbort = toolExecutionMode === "human-in-the-loop" || !!interactionController;
+				const discardOnAbort = toolExecutionMode === "restore" || !!interactionController;
 				try {
 					if (tool) {
-						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId, executionSignal, discardOnAbort)) needsFollowUp = true;
+						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId, executionSignal, discardOnAbort, toolExecutionMode === "restore")) needsFollowUp = true;
 					} else {
 						const fallbackTool = getWildcardTool();
 						if (fallbackTool) {
-							if (await this.executeWildcardTool(fallbackTool, toolCall, message, agent, agentId, executionSignal, discardOnAbort)) needsFollowUp = true;
+							if (await this.executeWildcardTool(fallbackTool, toolCall, message, agent, agentId, executionSignal, discardOnAbort, toolExecutionMode === "restore")) needsFollowUp = true;
 						}
 					}
 				} finally {
@@ -3709,7 +3759,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, signal = this._runAbortController?.signal, discardOnAbort = false }) {
+	async executeToolHandler({ tool, toolCall, agent, agentId, handlerArgs, toolType, messageId, signal = this._runAbortController?.signal, discardOnAbort = false, isReplay = false }) {
 		let toolCallResult = "";
 		let toolCallText = "";
 		let errorMessage;
@@ -3745,7 +3795,8 @@ var RunHandler = class {
 			const result = await tool.handler(parsedArgs, {
 				toolCall,
 				agent,
-				signal
+				signal,
+				...isReplay ? { isReplay } : {}
 			});
 			({content: toolCallResult, text: toolCallText} = toToolResultContent(result));
 		} catch (error) {
@@ -3783,7 +3834,7 @@ var RunHandler = class {
 	/**
 	* Execute a specific tool
 	*/
-	async executeSpecificTool(tool, toolCall, message, agent, agentId, signal, discardOnAbort = false) {
+	async executeSpecificTool(tool, toolCall, message, agent, agentId, signal, discardOnAbort = false, isReplay = false) {
 		const threadId = agent.threadId;
 		if (tool?.agentId && tool.agentId !== agent.agentId) return false;
 		let handlerResult = {
@@ -3801,7 +3852,8 @@ var RunHandler = class {
 			toolType: "specific",
 			messageId: message.id,
 			signal,
-			discardOnAbort
+			discardOnAbort,
+			isReplay
 		});
 		{
 			const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
@@ -3825,7 +3877,7 @@ 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, signal, discardOnAbort = false) {
+	async executeWildcardTool(wildcardTool, toolCall, message, agent, agentId, signal, discardOnAbort = false, isReplay = false) {
 		const threadId = agent.threadId;
 		if (wildcardTool?.agentId && wildcardTool.agentId !== agent.agentId) return false;
 		let toolCallResult = "";
@@ -3866,7 +3918,8 @@ var RunHandler = class {
 				const result = await wildcardTool.handler(wildcardArgs, {
 					toolCall,
 					agent,
-					signal
+					signal,
+					...isReplay ? { isReplay } : {}
 				});
 				({content: toolCallResult, text: toolCallText} = toToolResultContent(result));
 			} catch (error) {
@@ -4649,9 +4702,12 @@ var TrajectoryConnection = class {
 					session.retry = void 0;
 					this.connect(session);
 				}
-			}
+			},
+			linkedThreads: /* @__PURE__ */ new Set(),
+			agentWatches: /* @__PURE__ */ new Map()
 		};
 		this.session = session;
+		session.runWatch = this.core.subscribe({ onAgentRunStarted: ({ agent }) => this.watchAgent(session, agent) });
 		if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
 			window.addEventListener("offline", session.onOffline);
 			window.addEventListener("online", session.onOnline);
@@ -4679,6 +4735,29 @@ var TrajectoryConnection = class {
 		if (session?.ready) session.collector?.emit(name, value);
 		else if (session?.started) this.addDropped(session, 1, false);
 	}
+	watchAgent(session, agent) {
+		if (this.session !== session || session.agentWatches.has(agent)) return;
+		session.agentWatches.set(agent, agent.subscribe({ onRunStartedEvent: ({ event }) => this.linkThread(session, event) }));
+	}
+	/** Sends one `thread.linked` per Thread. A link that cannot be sent waits for the next run. */
+	linkThread(session, { threadId }) {
+		const connection = session.connection;
+		if (!session.ready || !connection || !threadId || session.linkedThreads.has(threadId)) return;
+		session.linkedThreads.add(threadId);
+		const event = {
+			type: "CUSTOM",
+			name: "thread.linked",
+			timestamp: Date.now(),
+			value: { threadId }
+		};
+		try {
+			const { beforeSend } = session.config;
+			const kept = beforeSend === void 0 ? event : beforeSend(event);
+			if (kept !== null) this.send(session, connection, kept);
+		} catch {
+			this.report(session, "INVALID_EVENT");
+		}
+	}
 	report(session, code) {
 		try {
 			session.config.onError?.({
@@ -4694,6 +4773,9 @@ var TrajectoryConnection = class {
 		if (this.session !== session) return;
 		this.session = void 0;
 		clearTimeout(session.retry);
+		session.runWatch?.unsubscribe();
+		for (const watch of session.agentWatches.values()) watch.unsubscribe();
+		session.agentWatches.clear();
 		session.collector?.stop();
 		session.ready = false;
 		if (session.queue.length > 0) this.report(session, "EVENTS_DROPPED");
@@ -4740,6 +4822,7 @@ var TrajectoryConnection = class {
 		});
 		session.ready = false;
 		this.discardQueue(session);
+		session.linkedThreads.clear();
 		for (const pending of connection.pending) pending.finish("PERSISTENCE_UNKNOWN");
 		if (!this.current(session, connection)) return;
 		this.cleanup(session, connection);