@copilotkit/core 1.56.5 → 1.57.0-canary.1778078321

package/dist/index.cjs

@@ -502,6 +502,7 @@ function withAbortErrorHandling(observable) {
 var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui_client.HttpAgent {
 	runtimeUrl;
 	credentials;
+	runtimeAgentId;
 	transport;
 	singleEndpointUrl;
 	runtimeMode;
@@ -512,7 +513,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 	constructor(config) {
 		const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
 		const transport = config.transport ?? "auto";
-		const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(config.agentId ?? "")}/run`;
+		const routedId = config.runtimeAgentId ?? config.agentId ?? "";
+		const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(routedId)}/run`;
 		if (!runUrl) throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
 		super({
 			...config,
@@ -520,6 +522,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		});
 		this.runtimeUrl = normalizedRuntimeUrl ?? config.runtimeUrl;
 		this.credentials = config.credentials;
+		this.runtimeAgentId = config.runtimeAgentId;
 		this.transport = transport;
 		this.runtimeMode = config.runtimeMode ?? _copilotkit_shared.RUNTIME_MODE_SSE;
 		this.intelligence = config.intelligence;
@@ -527,6 +530,21 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		if (config.debug) this.debug = config.debug;
 		if (this.transport === "single") this.singleEndpointUrl = this.runtimeUrl;
 	}
+	/**
+	* The agent id used for outbound runtime requests — `runtimeAgentId` when
+	* set (manually-registered proxy), otherwise `agentId` (registry id
+	* matches runtime id). Subscriber bookkeeping keeps using `agentId`
+	* directly.
+	*
+	* Throws when both are unset: a proxy reaching an HTTP path with no
+	* routable id is a bug, and a missing id would otherwise produce a
+	* malformed `/agent//run` or `/agent/undefined/connect` URL silently.
+	*/
+	routedAgentId() {
+		const id = this.runtimeAgentId ?? this.agentId;
+		if (!id) throw new Error("ProxiedCopilotRuntimeAgent: cannot make a runtime request without an agentId or runtimeAgentId.");
+		return id;
+	}
 	get capabilities() {
 		return this._capabilities;
 	}
@@ -546,6 +564,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		}
 		if (!this.agentId || !this.threadId) return;
 		if (typeof fetch === "undefined") return;
+		const routedId = this.routedAgentId();
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) return;
 			const headers = new Headers({
@@ -558,7 +577,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 				body: JSON.stringify({
 					method: "agent/stop",
 					params: {
-						agentId: this.agentId,
+						agentId: routedId,
 						threadId: this.threadId
 					}
 				}),
@@ -569,7 +588,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 			return;
 		}
 		if (!this.runtimeUrl) return;
-		const stopPath = `${this.runtimeUrl}/agent/${encodeURIComponent(this.agentId)}/stop/${encodeURIComponent(this.threadId)}`;
+		const stopPath = `${this.runtimeUrl}/agent/${encodeURIComponent(routedId)}/stop/${encodeURIComponent(this.threadId)}`;
 		const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
 		const base = new URL(this.runtimeUrl, origin);
 		const stopUrl = new URL(stopPath, base);
@@ -633,12 +652,13 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.connect(input))));
 	}
 	#connectViaHttp(input) {
+		const routedId = this.routedAgentId();
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
-			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: this.agentId });
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: routedId });
 			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
 		}
-		return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input))));
+		return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(`${this.runtimeUrl}/agent/${routedId}/connect`, this.requestInit(input))));
 	}
 	#runViaDelegate(input) {
 		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.run(input))));
@@ -646,7 +666,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 	#runViaHttp(input) {
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
-			const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.agentId });
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.routedAgentId() });
 			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
 		}
 		return withAbortErrorHandling(super.run(input));
@@ -655,6 +675,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		const cloned = new ProxiedCopilotRuntimeAgent({
 			runtimeUrl: this.runtimeUrl,
 			agentId: this.agentId,
+			runtimeAgentId: this.runtimeAgentId,
 			description: this.description,
 			headers: { ...this.headers },
 			credentials: this.credentials,
@@ -763,17 +784,18 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		};
 	}
 	createIntelligenceDelegate() {
-		if (!this.runtimeUrl || !this.agentId || !this.intelligence?.wsUrl) throw new Error("Intelligence mode requires runtimeUrl, agentId, and intelligence websocket metadata");
+		const routedId = this.routedAgentId();
+		if (!this.runtimeUrl || !routedId || !this.intelligence?.wsUrl) throw new Error("Intelligence mode requires runtimeUrl, agentId, and intelligence websocket metadata");
 		return new IntelligenceAgent({
 			url: this.intelligence.wsUrl,
 			runtimeUrl: this.runtimeUrl,
-			agentId: this.agentId,
+			agentId: routedId,
 			headers: { ...this.headers },
 			credentials: this.credentials
 		});
 	}
 	syncDelegate(delegate) {
-		delegate.agentId = this.agentId;
+		delegate.agentId = this.routedAgentId();
 		delegate.description = this.description;
 		delegate.threadId = this.threadId;
 		delegate.setMessages(this.messages);
@@ -907,6 +929,52 @@ var AgentRegistry = class {
 		this.notifyAgentsChanged();
 	}
 	/**
+	* Register a proxied agent that routes outbound runtime requests to an
+	* existing runtime agent (`runtimeAgentId`) while exposing a distinct local
+	* registry id (`agentId`). Throws if `agentId` is already taken by either a
+	* local or runtime-discovered agent.
+	*
+	* Use this to mount multiple frontend agents against a single runtime
+	* agent (e.g. a chat-1 / chat-2 pair both proxying to "default") without
+	* implicit per-thread cloning. The returned `unregister` removes the proxy
+	* from the registry and emits `onAgentsChanged`.
+	*/
+	registerProxiedAgent({ agentId, runtimeAgentId }) {
+		if (Object.prototype.hasOwnProperty.call(this._agents, agentId)) throw new Error(`CopilotKitCore.registerProxiedAgent: agentId "${agentId}" is already registered. Pick a different agentId, or unregister the existing agent first.`);
+		const friends = this.core;
+		const debug = friends.debug;
+		const agent = new ProxiedCopilotRuntimeAgent({
+			runtimeUrl: this._runtimeUrl,
+			agentId,
+			runtimeAgentId,
+			transport: this._runtimeTransport,
+			credentials: friends.credentials,
+			runtimeMode: this._runtimeUrl ? this._runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected ? this._runtimeMode : "pending" : _copilotkit_shared.RUNTIME_MODE_SSE,
+			intelligence: this._intelligence,
+			debug: debug ? (0, _copilotkit_shared.resolveDebugConfig)(debug) : void 0
+		});
+		this.applyHeadersToAgent(agent);
+		this.localAgents[agentId] = agent;
+		this._agents = {
+			...this.localAgents,
+			...this.remoteAgents
+		};
+		this.notifyAgentsChanged();
+		return {
+			agent,
+			unregister: () => {
+				if (this.localAgents[agentId] === agent) {
+					delete this.localAgents[agentId];
+					this._agents = {
+						...this.localAgents,
+						...this.remoteAgents
+					};
+					this.notifyAgentsChanged();
+				}
+			}
+		};
+	}
+	/**
 	* Get an agent by ID
 	*/
 	getAgent(id) {
@@ -1186,16 +1254,10 @@ 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, consumerAgent) {
+	reloadSuggestions(agentId) {
 		this.clearSuggestions(agentId);
-		const agent = consumerAgent ?? this.core.getAgent(agentId);
+		const agent = this.core.getAgent(agentId);
 		const messageCount = agent?.messages?.length ?? 0;
 		let hasAnySuggestions = false;
 		for (const config of Object.values(this._suggestionsConfig)) {
@@ -1208,7 +1270,7 @@ var SuggestionEngine = class {
 					hasAnySuggestions = true;
 					this.notifySuggestionsStartedLoading(agentId);
 				}
-				this.generateSuggestions(suggestionId, config, agentId, agent);
+				this.generateSuggestions(suggestionId, config, agentId);
 			} else if (isStaticSuggestionsConfig(config)) this.addStaticSuggestions(suggestionId, config, agentId);
 		}
 	}
@@ -1236,12 +1298,12 @@ var SuggestionEngine = class {
 	/**
 	* Generate suggestions using a provider agent
 	*/
-	async generateSuggestions(suggestionId, config, consumerAgentId, consumerAgent) {
+	async generateSuggestions(suggestionId, config, consumerAgentId) {
 		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 = consumerAgent ?? this.core.getAgent(consumerAgentId);
+			const suggestionsConsumerAgent = this.core.getAgent(consumerAgentId);
 			if (!suggestionsConsumerAgent) throw new Error(`Suggestions consumer agent not found: ${consumerAgentId}`);
 			agent = suggestionsProviderAgent.clone();
 			agent.threadId = suggestionId;
@@ -1546,10 +1608,6 @@ var RunHandler = class {
 			agent.setMessages([]);
 			agent.setState({});
 			if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
-			await this._internal.notifySubscribers((subscriber) => subscriber.onAgentRunStarted?.({
-				copilotkit: this.core,
-				agent
-			}), "Subscriber onAgentRunStarted error:");
 			const runAgentResult = await agent.connectAgent({
 				forwardedProps: this._internal.properties,
 				tools: this.buildFrontendTools(agent.agentId),
@@ -1580,11 +1638,6 @@ 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);
-		await this._internal.notifySubscribers((subscriber) => subscriber.onAgentRunStarted?.({
-			copilotkit: this.core,
-			agent
-		}), "Subscriber onAgentRunStarted error:");
 		const isTopLevel = this._runDepth === 0;
 		let originalAbortRun;
 		if (isTopLevel) {
@@ -1655,7 +1708,7 @@ var RunHandler = class {
 			await this._internal.waitForPendingFrameworkUpdates();
 			return await this.runAgent({ agent });
 		}
-		this._internal.suggestionEngine.reloadSuggestions(agentId, agent);
+		this._internal.suggestionEngine.reloadSuggestions(agentId);
 		return runAgentResult;
 	}
 	/**
@@ -2067,21 +2120,14 @@ var StateManager = class {
 	initialize() {}
 	/**
 	* 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, { isClone = false } = {}) {
+	subscribeToAgent(agent) {
 		if (!agent.agentId) return;
 		const agentId = agent.agentId;
-		const subscriptionKey = isClone && agent.threadId ? `${agentId}:${agent.threadId}` : agentId;
-		const existingUnsubscribe = this.agentSubscriptions.get(subscriptionKey);
+		const existingUnsubscribe = this.agentSubscriptions.get(agentId);
 		if (existingUnsubscribe) {
 			existingUnsubscribe();
-			this.agentSubscriptions.delete(subscriptionKey);
+			this.agentSubscriptions.delete(agentId);
 		}
 		let revoked = false;
 		let subRunId;
@@ -2125,16 +2171,13 @@ var StateManager = class {
 				this.handleNewMessage(agent, message, input ? effectiveInput(input) : void 0);
 			}
 		});
-		this.agentSubscriptions.set(subscriptionKey, () => {
+		this.agentSubscriptions.set(agentId, () => {
 			revoked = true;
 			unsubscribe();
 		});
 	}
 	/**
-	* 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.
+	* Unsubscribe an agent's subscription.
 	*/
 	unsubscribeFromAgent(agentId) {
 		const unsubscribe = this.agentSubscriptions.get(agentId);
@@ -2265,6 +2308,61 @@ var StateManager = class {
 	}
 };
 
+//#endregion
+//#region src/core/thread-store-registry.ts
+var ThreadStoreRegistry = class {
+	_stores = {};
+	_snapshot = null;
+	constructor(core) {
+		this.core = core;
+	}
+	register(agentId, store) {
+		if (agentId in this._stores) {
+			const prevStore = this._stores[agentId];
+			delete this._stores[agentId];
+			this._snapshot = null;
+			this.notifyUnregistered(agentId, prevStore).catch((err) => {
+				console.error("ThreadStoreRegistry notifyUnregistered failed:", err);
+			});
+		}
+		this._stores[agentId] = store;
+		this._snapshot = null;
+		this.notifyRegistered(agentId, store).catch((err) => {
+			console.error("ThreadStoreRegistry notifyRegistered failed:", err);
+		});
+	}
+	unregister(agentId) {
+		if (!(agentId in this._stores)) return;
+		const prevStore = this._stores[agentId];
+		delete this._stores[agentId];
+		this._snapshot = null;
+		this.notifyUnregistered(agentId, prevStore).catch((err) => {
+			console.error("ThreadStoreRegistry notifyUnregistered failed:", err);
+		});
+	}
+	get(agentId) {
+		return this._stores[agentId];
+	}
+	getAll() {
+		if (this._snapshot === null) this._snapshot = Object.freeze({ ...this._stores });
+		return this._snapshot;
+	}
+	async notifyRegistered(agentId, store) {
+		await this.core.notifySubscribers((subscriber) => subscriber.onThreadStoreRegistered?.({
+			copilotkit: this.core,
+			agentId,
+			store
+		}), "Subscriber onThreadStoreRegistered error:");
+	}
+	async notifyUnregistered(agentId, prevStore) {
+		await this.core.notifySubscribers((subscriber) => subscriber.onThreadStoreUnregistered?.({
+			copilotkit: this.core,
+			agentId,
+			prevStore
+		}), "Subscriber onThreadStoreUnregistered error:");
+	}
+};
+
 //#endregion
 //#region src/core/core.ts
 let CopilotKitCoreErrorCode = /* @__PURE__ */ function(CopilotKitCoreErrorCode) {
@@ -2333,6 +2431,14 @@ var CopilotKitCore = class {
 	suggestionEngine;
 	runHandler;
 	stateManager;
+	threadStoreRegistry;
+	/**
+	* Tracks the agent IDs from the most recent `onAgentsChanged` notification.
+	* Used to gate thread-store auto-unregister so the FIRST empty-agents
+	* notification (before published agents are merged in) does not rip out a
+	* store that was registered prior to that initial notification.
+	*/
+	previousAgentIds = /* @__PURE__ */ new Set();
 	constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
 		this._headers = headers;
 		this._credentials = credentials;
@@ -2343,16 +2449,30 @@ var CopilotKitCore = class {
 		this.suggestionEngine = new SuggestionEngine(this);
 		this.runHandler = new RunHandler(this);
 		this.stateManager = new StateManager(this);
+		this.threadStoreRegistry = new ThreadStoreRegistry(this);
 		this.agentRegistry.initialize(agents__unsafe_dev_only);
 		this.runHandler.initialize(tools);
 		this.suggestionEngine.initialize(suggestionsConfig);
 		this.stateManager.initialize();
 		this.agentRegistry.setRuntimeTransport(runtimeTransport);
 		this.agentRegistry.setRuntimeUrl(runtimeUrl);
+		this.previousAgentIds = new Set(Object.keys(agents__unsafe_dev_only));
 		this.subscribe({ onAgentsChanged: ({ agents }) => {
 			Object.values(agents).forEach((agent) => {
 				if (agent.agentId) this.stateManager.subscribeToAgent(agent);
 			});
+			const currentAgentIds = new Set(Object.keys(agents));
+			for (const agentId of Object.keys(this.threadStoreRegistry.getAll())) if (this.previousAgentIds.has(agentId) && !currentAgentIds.has(agentId)) try {
+				this.threadStoreRegistry.unregister(agentId);
+			} catch (err) {
+				console.error(`CopilotKitCore.onAgentsChanged: threadStoreRegistry.unregister failed for "${agentId}":`, err);
+			}
+			for (const agentId of this.previousAgentIds) if (!currentAgentIds.has(agentId)) try {
+				this.stateManager.unsubscribeFromAgent(agentId);
+			} catch (err) {
+				console.error(`CopilotKitCore.onAgentsChanged: stateManager.unsubscribeFromAgent failed for "${agentId}":`, err);
+			}
+			this.previousAgentIds = currentAgentIds;
 		} });
 	}
 	/**
@@ -2514,6 +2634,28 @@ var CopilotKitCore = class {
 	removeAgent__unsafe_dev_only(id) {
 		this.agentRegistry.removeAgent__unsafe_dev_only(id);
 	}
+	/**
+	* Register a proxied agent against an existing runtime agent. The proxy is
+	* exposed under `agentId` (local registry id) and routes outbound runtime
+	* requests to `runtimeAgentId`. Throws if `agentId` is already taken.
+	*
+	* Returns the minted proxy and an `unregister` handle for cleanup.
+	*
+	* Use this to mount multiple frontend agents against a single runtime
+	* agent (e.g. one per chat window) without implicit per-thread cloning.
+	*
+	* @example
+	* const { agent, unregister } = copilotkit.registerProxiedAgent({
+	*   agentId: "chat-1",
+	*   runtimeAgentId: "default",
+	* });
+	* // ... <CopilotChat agentId="chat-1" />
+	* // on cleanup:
+	* unregister();
+	*/
+	registerProxiedAgent(params) {
+		return this.agentRegistry.registerProxiedAgent(params);
+	}
 	getAgent(id) {
 		return this.agentRegistry.getAgent(id);
 	}
@@ -2527,6 +2669,21 @@ var CopilotKitCore = class {
 		this.contextStore.removeContext(id);
 	}
 	/**
+	* Thread store registry (delegated to ThreadStoreRegistry)
+	*/
+	registerThreadStore(agentId, store) {
+		this.threadStoreRegistry.register(agentId, store);
+	}
+	unregisterThreadStore(agentId) {
+		this.threadStoreRegistry.unregister(agentId);
+	}
+	getThreadStore(agentId) {
+		return this.threadStoreRegistry.get(agentId);
+	}
+	getThreadStores() {
+		return this.threadStoreRegistry.getAll();
+	}
+	/**
 	* Suggestions management (delegated to SuggestionEngine)
 	*/
 	addSuggestionsConfig(config) {
@@ -2732,9 +2889,6 @@ 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
 	*/
@@ -3611,6 +3765,11 @@ function createThreadStore(environment) {
 		setContext(context) {
 			store.dispatch(threadAdapterEvents.contextChanged({ context }));
 		},
+		refresh() {
+			const { sessionId, context } = store.getState();
+			if (!context) return;
+			store.dispatch(threadRestEvents.listRequested({ sessionId }));
+		},
 		fetchNextPage() {
 			store.dispatch(threadAdapterEvents.fetchNextPageRequested());
 		},
@@ -3645,6 +3804,13 @@ const ɵselectThreadsIsLoading = selectThreadsIsLoading;
 const ɵselectThreadsError = selectThreadsError;
 const ɵselectHasNextPage = selectHasNextPage;
 const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
+/**
+* Number of consecutive WebSocket connection failures after which the
+* threads channel tears itself down rather than retrying indefinitely.
+* Exposed for tests so they can assert teardown semantics without
+* hardcoding the threshold separately from production.
+*/
+const ɵMAX_SOCKET_RETRIES = MAX_SOCKET_RETRIES;
 
 //#endregion
 exports.AgentRegistry = AgentRegistry;
@@ -3672,6 +3838,7 @@ exports.on = on;
 exports.parseToolArguments = parseToolArguments;
 exports.props = props;
 exports.select = select;
+exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
 exports.ɵcreateThreadStore = createThreadStore;
 exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
 exports.ɵobservePhoenixEvent$ = ɵobservePhoenixEvent$;