@copilotkit/core 1.55.0-next.8 → 1.55.0-next.9

package/dist/index.cjs

@@ -1123,10 +1123,16 @@ var SuggestionEngine = class {
 	/**
 	* Reload suggestions for a specific agent
 	* This triggers generation of new suggestions based on current configs
+	*
+	* @param agentId - The consumer agent ID
+	* @param consumerAgent - Optional: the specific agent instance whose messages should be used
+	*   for availability filtering and context. When running with per-thread clones, the thread
+	*   clone holds the conversation messages; passing it here ensures dynamic suggestions fire
+	*   after the first message even though the registry agent has an empty message list.
 	*/
-	reloadSuggestions(agentId) {
+	reloadSuggestions(agentId, consumerAgent) {
 		this.clearSuggestions(agentId);
-		const agent = this.core.getAgent(agentId);
+		const agent = consumerAgent ?? this.core.getAgent(agentId);
 		if (!agent) return;
 		const messageCount = agent.messages?.length ?? 0;
 		let hasAnySuggestions = false;
@@ -1139,7 +1145,7 @@ var SuggestionEngine = class {
 					hasAnySuggestions = true;
 					this.notifySuggestionsStartedLoading(agentId);
 				}
-				this.generateSuggestions(suggestionId, config, agentId);
+				this.generateSuggestions(suggestionId, config, agentId, agent);
 			} else if (isStaticSuggestionsConfig(config)) this.addStaticSuggestions(suggestionId, config, agentId);
 		}
 	}
@@ -1167,12 +1173,12 @@ var SuggestionEngine = class {
 	/**
 	* Generate suggestions using a provider agent
 	*/
-	async generateSuggestions(suggestionId, config, consumerAgentId) {
+	async generateSuggestions(suggestionId, config, consumerAgentId, consumerAgent) {
 		let agent = void 0;
 		try {
 			const suggestionsProviderAgent = this.core.getAgent(config.providerAgentId ?? "default");
 			if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${config.providerAgentId}`);
-			const suggestionsConsumerAgent = this.core.getAgent(consumerAgentId);
+			const suggestionsConsumerAgent = consumerAgent ?? this.core.getAgent(consumerAgentId);
 			if (!suggestionsConsumerAgent) throw new Error(`Suggestions consumer agent not found: ${consumerAgentId}`);
 			agent = suggestionsProviderAgent.clone();
 			agent.threadId = suggestionId;
@@ -1505,6 +1511,7 @@ var RunHandler = class {
 		if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
 		if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
 		if (agent.detachActiveRun) await agent.detachActiveRun();
+		this._internal.subscribeAgentToStateManager(agent);
 		const isTopLevel = this._runDepth === 0;
 		let originalAbortRun;
 		if (isTopLevel) {
@@ -1575,7 +1582,7 @@ var RunHandler = class {
 			await this._internal.waitForPendingFrameworkUpdates();
 			return await this.runAgent({ agent });
 		}
-		this._internal.suggestionEngine.reloadSuggestions(agentId);
+		this._internal.suggestionEngine.reloadSuggestions(agentId, agent);
 		return runAgentResult;
 	}
 	/**
@@ -1976,6 +1983,7 @@ function parseToolArguments(rawArgs, toolName) {
 var StateManager = class {
 	stateByRun = /* @__PURE__ */ new Map();
 	messageToRun = /* @__PURE__ */ new Map();
+	activeRun = /* @__PURE__ */ new Map();
 	agentSubscriptions = /* @__PURE__ */ new Map();
 	constructor(core) {
 		this.core = core;
@@ -1985,36 +1993,70 @@ var StateManager = class {
 	*/
 	initialize() {}
 	/**
-	* Subscribe to an agent's events to track state and messages
+	* Subscribe to an agent's events to track state and messages.
+	*
+	* Registry agents (subscribed via `onAgentsChanged`) use the bare `agentId`
+	* key so that `unsubscribeFromAgent(agentId)` can remove them when they
+	* are replaced. Per-thread clones (subscribed via `subscribeAgentToStateManager`)
+	* pass `{ isClone: true }` to use a composite `agentId:threadId` key, keeping
+	* their subscription independent of the registry agent's.
 	*/
-	subscribeToAgent(agent) {
+	subscribeToAgent(agent, { isClone = false } = {}) {
 		if (!agent.agentId) return;
 		const agentId = agent.agentId;
-		this.unsubscribeFromAgent(agentId);
+		const subscriptionKey = isClone && agent.threadId ? `${agentId}:${agent.threadId}` : agentId;
+		const existingUnsubscribe = this.agentSubscriptions.get(subscriptionKey);
+		if (existingUnsubscribe) {
+			existingUnsubscribe();
+			this.agentSubscriptions.delete(subscriptionKey);
+		}
+		let revoked = false;
+		let subRunId;
+		let runFinished = false;
+		const effectiveInput = (input) => ({
+			...input,
+			runId: subRunId ?? input.runId
+		});
 		const { unsubscribe } = agent.subscribe({
-			onRunStartedEvent: ({ event, state }) => {
-				this.handleRunStarted(agent, event, state);
+			onRunStartedEvent: ({ input, state }) => {
+				if (revoked) return;
+				if (runFinished && input.runId === subRunId) subRunId = (0, _ag_ui_client.randomUUID)();
+				else subRunId = input.runId;
+				runFinished = false;
+				this.handleRunStarted(agent, effectiveInput(input), state);
 			},
-			onRunFinishedEvent: ({ event, state }) => {
-				this.handleRunFinished(agent, event, state);
+			onRunFinishedEvent: ({ input, state }) => {
+				if (revoked) return;
+				runFinished = true;
+				this.handleRunFinished(agent, effectiveInput(input), state);
 			},
 			onStateSnapshotEvent: ({ event, input, state }) => {
-				this.handleStateSnapshot(agent, event, input, state);
+				if (revoked) return;
+				this.handleStateSnapshot(agent, event, effectiveInput(input), state);
 			},
 			onStateDeltaEvent: ({ event, input, state }) => {
-				this.handleStateDelta(agent, event, input, state);
+				if (revoked) return;
+				this.handleStateDelta(agent, event, effectiveInput(input), state);
 			},
 			onMessagesSnapshotEvent: ({ event, input, messages }) => {
-				this.handleMessagesSnapshot(agent, event, input, messages);
+				if (revoked) return;
+				this.handleMessagesSnapshot(agent, event, effectiveInput(input), messages);
 			},
 			onNewMessage: ({ message, input }) => {
-				this.handleNewMessage(agent, message, input);
+				if (revoked) return;
+				this.handleNewMessage(agent, message, input ? effectiveInput(input) : void 0);
 			}
 		});
-		this.agentSubscriptions.set(agentId, unsubscribe);
+		this.agentSubscriptions.set(subscriptionKey, () => {
+			revoked = true;
+			unsubscribe();
+		});
 	}
 	/**
-	* Unsubscribe from an agent's events
+	* Unsubscribe a registry agent's subscription (bare `agentId` key).
+	* Per-thread clone subscriptions use composite `agentId:threadId` keys and
+	* are replaced (not removed) by subsequent subscribeToAgent(agent, { isClone: true })
+	* calls for the same (agentId, threadId) pair.
 	*/
 	unsubscribeFromAgent(agentId) {
 		const unsubscribe = this.agentSubscriptions.get(agentId);
@@ -2054,18 +2096,20 @@ var StateManager = class {
 	/**
 	* Handle run started event
 	*/
-	handleRunStarted(agent, event, state) {
+	handleRunStarted(agent, input, state) {
 		if (!agent.agentId) return;
-		const { threadId, runId } = event;
-		this.saveState(agent.agentId, threadId, runId, state);
+		const { threadId, runId } = input;
+		this.activeRun.set(`${agent.agentId}:${threadId}`, runId);
+		if (state && Object.keys(state).length > 0) this.saveState(agent.agentId, threadId, runId, state);
 	}
 	/**
 	* Handle run finished event
 	*/
-	handleRunFinished(agent, event, state) {
+	handleRunFinished(agent, input, state) {
 		if (!agent.agentId) return;
-		const { threadId, runId } = event;
-		this.saveState(agent.agentId, threadId, runId, state);
+		const { threadId, runId } = input;
+		this.activeRun.delete(`${agent.agentId}:${threadId}`);
+		if (state && Object.keys(state).length > 0) this.saveState(agent.agentId, threadId, runId, state);
 	}
 	/**
 	* Handle state snapshot event
@@ -2099,7 +2143,13 @@ var StateManager = class {
 	* Handle new message event
 	*/
 	handleNewMessage(agent, message, input) {
-		if (!agent.agentId || !input) return;
+		if (!agent.agentId) return;
+		if (!input) {
+			const threadId = agent.threadId ?? "";
+			const runId = this.activeRun.get(`${agent.agentId}:${threadId}`);
+			if (runId) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+			return;
+		}
 		const { threadId, runId } = input;
 		this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
 	}
@@ -2409,6 +2459,9 @@ var CopilotKitCore = class {
 	getRunIdsForThread(agentId, threadId) {
 		return this.stateManager.getRunIdsForThread(agentId, threadId);
 	}
+	subscribeAgentToStateManager(agent) {
+		this.stateManager.subscribeToAgent(agent, { isClone: true });
+	}
 	/**
 	* Internal method used by RunHandler to build frontend tools
 	*/