@copilotkit/core 1.55.0-next.8 → 1.55.0

package/dist/index.mjs

@@ -519,7 +519,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	runtimeInfoPromise;
 	constructor(config) {
 		const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
-		const transport = config.transport ?? "rest";
+		const transport = config.transport ?? "auto";
 		const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(config.agentId ?? "")}/run`;
 		if (!runUrl) throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
 		super({
@@ -688,6 +688,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 	}
 	async fetchRuntimeInfo() {
 		const headers = { ...this.headers };
+		if (this.transport === "auto") return this.fetchRuntimeInfoAutoDetect(headers);
 		let init;
 		let url;
 		if (this.transport === "single") {
@@ -710,6 +711,30 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
 		return await response.json();
 	}
+	async fetchRuntimeInfoAutoDetect(headers) {
+		try {
+			const response = await fetch(`${this.runtimeUrl}/info`, {
+				headers: { ...headers },
+				...this.credentials ? { credentials: this.credentials } : {}
+			});
+			if (response.status >= 200 && response.status < 300) {
+				this.transport = "rest";
+				return await response.json();
+			}
+		} catch {}
+		const singleHeaders = { ...headers };
+		if (!singleHeaders["Content-Type"]) singleHeaders["Content-Type"] = "application/json";
+		const response = await fetch(this.runtimeUrl, {
+			method: "POST",
+			headers: singleHeaders,
+			body: JSON.stringify({ method: "info" }),
+			...this.credentials ? { credentials: this.credentials } : {}
+		});
+		if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+		this.transport = "single";
+		this.singleEndpointUrl = this.runtimeUrl;
+		return await response.json();
+	}
 	createSingleRouteRequestInit(input, method, params) {
 		if (!this.agentId) throw new Error("ProxiedCopilotRuntimeAgent requires agentId to make runtime requests");
 		const baseInit = super.requestInit(input);
@@ -766,11 +791,12 @@ var AgentRegistry = class {
 	_runtimeUrl;
 	_runtimeVersion;
 	_runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
-	_runtimeTransport = "rest";
+	_runtimeTransport = "auto";
 	_audioFileTranscriptionEnabled = false;
 	_runtimeMode = RUNTIME_MODE_SSE;
 	_intelligence;
 	_a2uiEnabled = false;
+	_openGenerativeUIEnabled = false;
 	_licenseStatus;
 	constructor(core) {
 		this.core = core;
@@ -805,6 +831,9 @@ var AgentRegistry = class {
 	get a2uiEnabled() {
 		return this._a2uiEnabled;
 	}
+	get openGenerativeUIEnabled() {
+		return this._openGenerativeUIEnabled;
+	}
 	get licenseStatus() {
 		return this._licenseStatus;
 	}
@@ -917,6 +946,7 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._a2uiEnabled = false;
+			this._openGenerativeUIEnabled = false;
 			this.remoteAgents = {};
 			this._agents = this.localAgents;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Disconnected);
@@ -952,6 +982,7 @@ var AgentRegistry = class {
 			this._runtimeMode = runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE;
 			this._intelligence = runtimeInfoResponse.intelligence;
 			this._a2uiEnabled = runtimeInfoResponse.a2uiEnabled ?? false;
+			this._openGenerativeUIEnabled = runtimeInfoResponse.openGenerativeUIEnabled ?? false;
 			this._licenseStatus = runtimeInfoResponse.licenseStatus;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connected);
 			await this.notifyAgentsChanged();
@@ -962,6 +993,7 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._a2uiEnabled = false;
+			this._openGenerativeUIEnabled = false;
 			this.remoteAgents = {};
 			this._agents = this.localAgents;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
@@ -981,24 +1013,45 @@ var AgentRegistry = class {
 		const baseHeaders = this.core.headers;
 		const credentials = this.core.credentials;
 		const headers = { ...baseHeaders };
-		if (this._runtimeTransport === "single") {
-			if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
-			const response = await fetch(this.runtimeUrl, {
-				method: "POST",
-				headers,
-				body: JSON.stringify({ method: "info" }),
-				...credentials ? { credentials } : {}
-			});
-			if ("ok" in response && !response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
-			return await response.json();
-		}
+		if (this._runtimeTransport === "single") return this.fetchRuntimeInfoSingle(headers, credentials);
+		if (this._runtimeTransport === "auto") return this.fetchRuntimeInfoAutoDetect(headers, credentials);
 		const response = await fetch(`${this.runtimeUrl}/info`, {
 			headers,
 			...credentials ? { credentials } : {}
 		});
-		if ("ok" in response && !response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+		if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
 		return await response.json();
 	}
+	async fetchRuntimeInfoSingle(headers, credentials) {
+		if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+		const response = await fetch(this.runtimeUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ method: "info" }),
+			...credentials ? { credentials } : {}
+		});
+		if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+		return await response.json();
+	}
+	/**
+	* Auto-detect transport by trying REST first, then falling back to single-endpoint.
+	* Updates `_runtimeTransport` to the detected value so subsequent requests use it directly.
+	*/
+	async fetchRuntimeInfoAutoDetect(headers, credentials) {
+		try {
+			const response = await fetch(`${this.runtimeUrl}/info`, {
+				headers: { ...headers },
+				...credentials ? { credentials } : {}
+			});
+			if (response.status >= 200 && response.status < 300) {
+				this._runtimeTransport = "rest";
+				return await response.json();
+			}
+		} catch {}
+		const result = await this.fetchRuntimeInfoSingle({ ...headers }, credentials);
+		this._runtimeTransport = "single";
+		return result;
+	}
 	/**
 	* Assign agent IDs to a record of agents
 	*/
@@ -1122,10 +1175,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;
@@ -1138,7 +1197,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);
 		}
 	}
@@ -1166,12 +1225,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;
@@ -1487,13 +1546,15 @@ var RunHandler = class {
 			});
 		} catch (error) {
 			const connectError = error instanceof Error ? error : new Error(String(error));
-			const context = {};
-			if (agent.agentId) context.agentId = agent.agentId;
-			await this._internal.emitError({
-				error: connectError,
-				code: CopilotKitCoreErrorCode.AGENT_CONNECT_FAILED,
-				context
-			});
+			if (!(connectError.name === "AbortError" || connectError.message === "Fetch is aborted" || connectError.message === "signal is aborted without reason" || connectError.message === "component unmounted")) {
+				const context = {};
+				if (agent.agentId) context.agentId = agent.agentId;
+				await this._internal.emitError({
+					error: connectError,
+					code: CopilotKitCoreErrorCode.AGENT_CONNECT_FAILED,
+					context
+				});
+			}
 			return { newMessages: [] };
 		}
 	}
@@ -1504,6 +1565,7 @@ var RunHandler = class {
 		if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
 		if (agent instanceof 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) {
@@ -1574,7 +1636,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;
 	}
 	/**
@@ -1975,6 +2037,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;
@@ -1984,36 +2047,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 = 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);
@@ -2053,18 +2150,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
@@ -2098,7 +2197,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);
 	}
@@ -2183,13 +2288,14 @@ var CopilotKitCore = class {
 	_headers;
 	_credentials;
 	_properties;
+	_defaultThrottleMs;
 	subscribers = /* @__PURE__ */ new Set();
 	agentRegistry;
 	contextStore;
 	suggestionEngine;
 	runHandler;
 	stateManager;
-	constructor({ runtimeUrl, runtimeTransport = "rest", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [] }) {
+	constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [] }) {
 		this._headers = headers;
 		this._credentials = credentials;
 		this._properties = properties;
@@ -2269,6 +2375,22 @@ var CopilotKitCore = class {
 	get properties() {
 		return this._properties;
 	}
+	/**
+	* Default throttle interval (ms) applied by framework hooks (e.g.
+	* `useAgent()`) when the hook/component does not specify an explicit
+	* `throttleMs`. An explicit `0` passed as `throttleMs` to `useAgent()`
+	* or `<CopilotChat>` overrides this default and disables throttling.
+	*/
+	get defaultThrottleMs() {
+		return this._defaultThrottleMs;
+	}
+	setDefaultThrottleMs(value) {
+		if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
+			this._defaultThrottleMs = void 0;
+			return;
+		}
+		this._defaultThrottleMs = value;
+	}
 	get runtimeConnectionStatus() {
 		return this.agentRegistry.runtimeConnectionStatus;
 	}
@@ -2284,6 +2406,9 @@ var CopilotKitCore = class {
 	get a2uiEnabled() {
 		return this.agentRegistry.a2uiEnabled;
 	}
+	get openGenerativeUIEnabled() {
+		return this.agentRegistry.openGenerativeUIEnabled;
+	}
 	get licenseStatus() {
 		return this.agentRegistry.licenseStatus;
 	}
@@ -2408,6 +2533,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
 	*/