@copilotkit/core 1.61.1 → 1.62.0

package/dist/index.mjs

@@ -151,12 +151,6 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	activeChannel = null;
 	canonicalRunId = null;
 	sharedState;
-	/**
-	* Resolves when the active run's pipeline finalizes; `undefined` between runs.
-	* Set/cleared inside {@link connectAgent}'s observable lifecycle. Declared
-	* here so {@link RunCompletionAware} consumers can read it without a cast.
-	*/
-	activeRunCompletionPromise;
 	constructor(config, sharedState = { lastSeenEventIds: /* @__PURE__ */ new Map() }) {
 		super();
 		this.config = config;
@@ -202,7 +196,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 			const previousMessageIds = new Set(this.messages.map((m) => m.id));
 			const subscribers = [
 				{ onRunFinishedEvent: (event) => {
-					result = event.result;
+					if (event.outcome === "success") result = event.result;
 				} },
 				...this.subscribers,
 				subscriber ?? {}
@@ -210,10 +204,10 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 			await this.onInitialize(input, subscribers);
 			self.activeRunDetach$ = new Subject();
 			let resolveCompletion;
-			this.activeRunCompletionPromise = new Promise((resolve) => {
+			self.activeRunCompletionPromise = new Promise((resolve) => {
 				resolveCompletion = resolve;
 			});
-			const source$ = defer(() => this.connect(input)).pipe(transformChunks(this.debug), takeUntil(self.activeRunDetach$));
+			const source$ = defer(() => this.connect(input)).pipe(transformChunks(this.debugLogger), takeUntil(self.activeRunDetach$));
 			const applied$ = this.apply(input, source$, subscribers);
 			await lastValueFrom(this.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
 				this.isRunning = false;
@@ -223,7 +217,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 				this.onFinalize(input, subscribers);
 				resolveCompletion?.();
 				resolveCompletion = void 0;
-				this.activeRunCompletionPromise = void 0;
+				self.activeRunCompletionPromise = void 0;
 				self.activeRunDetach$ = void 0;
 			})), { defaultValue: void 0 });
 			const newMessages = structuredClone_(this.messages).filter((m) => !previousMessageIds.has(m.id));
@@ -725,8 +719,9 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		cloned.setState(this.state);
 		cloned.setMessages(this.messages);
 		if (this.delegate) {
-			cloned.delegate = this.delegate.clone();
-			cloned.syncDelegate(cloned.delegate);
+			const clonedDelegate = this.delegate.clone();
+			cloned.delegate = clonedDelegate;
+			cloned.syncDelegate(clonedDelegate);
 		}
 		return cloned;
 	}
@@ -881,6 +876,17 @@ var AgentRegistry = class {
 	_openGenerativeUIEnabled = false;
 	_licenseStatus;
 	_telemetryDisabled = false;
+	/**
+	* The headers each HttpAgent was constructed with, captured on the first
+	* `applyHeadersToAgent` call for that agent (which, for agents the registry
+	* owns, happens at registration before any core headers are applied). Core
+	* headers are merged ON TOP of this baseline so that headers configured
+	* directly on an agent (e.g. an `Authorization` for a self-hosted backend)
+	* survive registration instead of being silently replaced. The baseline is
+	* captured once and never re-captured, so a later direct mutation of
+	* `agent.headers` is not folded into it. See #5635.
+	*/
+	agentOwnHeaders = /* @__PURE__ */ new WeakMap();
 	constructor(core) {
 		this.core = core;
 	}
@@ -1053,10 +1059,19 @@ var AgentRegistry = class {
 		console.warn(`Agent ${id} not found`);
 	}
 	/**
-	* Apply current headers to an agent
+	* Apply current core headers to an agent, merged ON TOP of the agent's own
+	* construction-time headers (the per-agent baseline in `agentOwnHeaders`).
+	* Core wins on a key conflict. Non-`HttpAgent` agents are left untouched
+	* because only `HttpAgent` carries a `headers` field. See #5635.
 	*/
 	applyHeadersToAgent(agent) {
-		if (agent instanceof HttpAgent) agent.headers = { ...this.core.headers };
+		if (agent instanceof HttpAgent) {
+			if (!this.agentOwnHeaders.has(agent)) this.agentOwnHeaders.set(agent, { ...agent.headers });
+			agent.headers = {
+				...this.agentOwnHeaders.get(agent),
+				...this.core.headers
+			};
+		}
 	}
 	/**
 	* Apply current headers to all agents
@@ -1728,7 +1743,11 @@ var RunHandler = class {
 				const proxied = agent;
 				if (incomingThreadId && typeof proxied.clearReplayCursor === "function") proxied.clearReplayCursor(incomingThreadId);
 			}
-			if (agent instanceof HttpAgent) agent.headers = { ...this._internal.headers };
+			this._internal.applyHeadersToAgent(agent);
+			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),
@@ -1749,15 +1768,18 @@ var RunHandler = class {
 					context
 				});
 			}
-			return { newMessages: [] };
+			return {
+				result: void 0,
+				newMessages: []
+			};
 		}
 	}
 	/**
 	* Run an agent
 	*/
-	async runAgent({ agent, forwardedProps }) {
+	async runAgent({ agent, forwardedProps, resume }) {
 		if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
-		if (agent instanceof HttpAgent) agent.headers = { ...this._internal.headers };
+		this._internal.applyHeadersToAgent(agent);
 		if (agent.detachActiveRun) await agent.detachActiveRun();
 		const isTopLevel = this._runDepth === 0;
 		let originalAbortRun;
@@ -1769,6 +1791,10 @@ var RunHandler = class {
 				controller.abort();
 				originalAbortRun();
 			};
+			await this._internal.notifySubscribers((subscriber) => subscriber.onAgentRunStarted?.({
+				copilotkit: this.core,
+				agent
+			}), "Subscriber onAgentRunStarted error:");
 		}
 		this._runDepth++;
 		try {
@@ -1777,6 +1803,7 @@ var RunHandler = class {
 					...this._internal.properties,
 					...forwardedProps
 				},
+				...resume !== void 0 ? { resume } : {},
 				tools: this.buildFrontendTools(agent.agentId),
 				context: this._internal.getContextForAgent(agent.agentId)
 			}, this.createAgentErrorSubscriber(agent));
@@ -1793,7 +1820,10 @@ var RunHandler = class {
 				code: CopilotKitCoreErrorCode.AGENT_RUN_FAILED,
 				context
 			});
-			return { newMessages: [] };
+			return {
+				result: void 0,
+				newMessages: []
+			};
 		} finally {
 			this._runDepth--;
 			if (isTopLevel && originalAbortRun) agent.abortRun = originalAbortRun;
@@ -2065,18 +2095,19 @@ var RunHandler = class {
 			throw error;
 		}
 		const toolCallId = randomUUID$1();
+		const assistantToolCall = {
+			id: toolCallId,
+			type: "function",
+			function: {
+				name,
+				arguments: JSON.stringify(parameters)
+			}
+		};
 		const assistantMessage = {
 			id: randomUUID$1(),
 			role: "assistant",
 			content: "",
-			toolCalls: [{
-				id: toolCallId,
-				type: "function",
-				function: {
-					name,
-					arguments: JSON.stringify(parameters)
-				}
-			}]
+			toolCalls: [assistantToolCall]
 		};
 		agent.messages.push(assistantMessage);
 		let handlerResult = {
@@ -2086,7 +2117,7 @@ var RunHandler = class {
 		};
 		if (tool.handler) handlerResult = await this.executeToolHandler({
 			tool,
-			toolCall: assistantMessage.toolCalls[0],
+			toolCall: assistantToolCall,
 			agent,
 			agentId: resolvedAgentId,
 			handlerArgs: parameters,
@@ -2172,9 +2203,9 @@ const EMPTY_TOOL_SCHEMA = {
 */
 function createToolSchema(tool) {
 	if (!tool.parameters) return { ...EMPTY_TOOL_SCHEMA };
-	const rawSchema = schemaToJsonSchema(tool.parameters, { zodToJsonSchema });
+	const rawSchema = schemaToJsonSchema(tool.parameters, { zodToJsonSchema: (schema, options) => zodToJsonSchema(schema, options) });
 	if (!rawSchema || typeof rawSchema !== "object") return { ...EMPTY_TOOL_SCHEMA };
-	const { $schema, ...schema } = rawSchema;
+	const { $schema: _$schema, ...schema } = rawSchema;
 	if (typeof schema.type !== "string") schema.type = "object";
 	if (typeof schema.properties !== "object" || schema.properties === null) schema.properties = {};
 	stripAdditionalProperties(schema);
@@ -2761,9 +2792,19 @@ var CopilotKitCore = class {
 	* });
 	* ```
 	*
-	* The resulting header set is also re-applied to every registered
-	* `HttpAgent`-derived agent (replacing its `headers`) and `onHeadersChanged`
-	* subscribers are notified.
+	* The resulting header set is also re-applied to every agent in the registry
+	* and `onHeadersChanged` subscribers are notified. These headers are merged
+	* ON TOP of the headers each `HttpAgent` was constructed with, so per-agent
+	* headers (e.g. an `Authorization` for a self-hosted backend) are preserved;
+	* on a key conflict the core-level value wins.
+	*
+	* Because the agent's construction-time headers form the merge baseline, this
+	* method can override a per-agent header but cannot REMOVE one: clearing a
+	* core key here only drops the core-level override, after which the agent's
+	* own value (if any) re-surfaces. To change a header an agent was constructed
+	* with, set it at the provider/core level instead of on the agent, or update
+	* it on the agent directly. The clear-on-logout pattern above is for
+	* core-level headers.
 	*/
 	setHeaders(headers) {
 		this._headers = normalizeHeaders(headers);
@@ -2822,6 +2863,23 @@ var CopilotKitCore = class {
 		return this.agentRegistry.getAgent(id);
 	}
 	/**
+	* Re-apply the current headers to a single agent (delegated to
+	* AgentRegistry). Core headers are merged on top of the agent's own
+	* construction-time headers rather than replacing them, so headers
+	* configured directly on an `HttpAgent` (e.g. an `Authorization` for a
+	* self-hosted backend) survive header updates instead of being silently
+	* dropped (see #5635). On a key conflict the core-level value wins.
+	*
+	* The merge baseline is the agent's headers as captured the first time the
+	* agent is applied (at registration), so the way to change headers
+	* afterwards is `setHeaders` (which re-applies to every agent), not mutating
+	* `agent.headers` directly — a direct mutation is overwritten on the next
+	* re-apply.
+	*/
+	applyHeadersToAgent(agent) {
+		this.agentRegistry.applyHeadersToAgent(agent);
+	}
+	/**
 	* Context management (delegated to ContextStore).
 	* Pass `agentIds` to restrict the entry to runs of specific agents;
 	* omit it for context every agent should receive.
@@ -3538,7 +3596,9 @@ const initialThreadState = {
 	sessionId: 0,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
-	nextCursor: null
+	nextCursor: null,
+	inFlightMutationCount: 0,
+	pendingDeletes: {}
 };
 const threadAdapterEvents = createActionGroup("Thread Adapter", {
 	started: empty(),
@@ -3547,7 +3607,9 @@ const threadAdapterEvents = createActionGroup("Thread Adapter", {
 	fetchNextPageRequested: empty(),
 	renameRequested: props(),
 	archiveRequested: props(),
-	deleteRequested: props()
+	unarchiveRequested: props(),
+	deleteRequested: props(),
+	newThreadStarted: empty()
 });
 const threadRestEvents = createActionGroup("Thread REST", {
 	listRequested: props(),
@@ -3594,7 +3656,9 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	error: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
-	nextCursor: null
+	nextCursor: null,
+	inFlightMutationCount: 0,
+	pendingDeletes: {}
 })), on(threadAdapterEvents.stopped, (state) => ({
 	...state,
 	threads: [],
@@ -3603,7 +3667,9 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	error: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
-	nextCursor: null
+	nextCursor: null,
+	inFlightMutationCount: 0,
+	pendingDeletes: {}
 })), on(threadRestEvents.listRequested, (state, { sessionId }) => {
 	if (sessionId !== state.sessionId || !state.context) return state;
 	return {
@@ -3645,12 +3711,9 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		isFetchingNextPage: false,
 		error
 	};
-}), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId, error }) => {
+}), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId }) => {
 	if (sessionId !== state.sessionId) return state;
-	return {
-		...state,
-		error
-	};
+	return state;
 }), on(threadRestEvents.metadataCredentialsRequested, (state, { sessionId }) => {
 	if (sessionId !== state.sessionId) return state;
 	return {
@@ -3663,10 +3726,105 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		...state,
 		isFetchingNextPage: true
 	};
-}), on(threadRestEvents.mutationFinished, (state, { outcome }) => ({
+}), on(threadAdapterEvents.renameRequested, (state, { threadId, name }) => {
+	const existing = state.threads.find((thread) => thread.id === threadId);
+	const inFlightMutationCount = state.inFlightMutationCount + 1;
+	if (!existing) return {
+		...state,
+		inFlightMutationCount
+	};
+	return {
+		...state,
+		threads: upsertThread(state.threads, {
+			...existing,
+			name
+		}),
+		inFlightMutationCount
+	};
+}), on(threadAdapterEvents.archiveRequested, (state, { threadId }) => {
+	const existing = state.threads.find((thread) => thread.id === threadId);
+	const inFlightMutationCount = state.inFlightMutationCount + 1;
+	if (!existing) return {
+		...state,
+		inFlightMutationCount
+	};
+	if (!state.context?.includeArchived) return {
+		...state,
+		threads: state.threads.filter((thread) => thread.id !== threadId),
+		inFlightMutationCount
+	};
+	return {
+		...state,
+		threads: upsertThread(state.threads, {
+			...existing,
+			archived: true
+		}),
+		inFlightMutationCount
+	};
+}), on(threadAdapterEvents.unarchiveRequested, (state, { threadId }) => {
+	const existing = state.threads.find((thread) => thread.id === threadId);
+	const inFlightMutationCount = state.inFlightMutationCount + 1;
+	if (!existing) return {
+		...state,
+		inFlightMutationCount
+	};
+	return {
+		...state,
+		threads: upsertThread(state.threads, {
+			...existing,
+			archived: false
+		}),
+		inFlightMutationCount
+	};
+}), on(threadAdapterEvents.deleteRequested, (state, { requestId, threadId }) => {
+	const existing = state.threads.find((thread) => thread.id === threadId);
+	const inFlightMutationCount = state.inFlightMutationCount + 1;
+	if (!existing) return {
+		...state,
+		inFlightMutationCount
+	};
+	return {
+		...state,
+		threads: state.threads.filter((thread) => thread.id !== threadId),
+		pendingDeletes: {
+			...state.pendingDeletes,
+			[requestId]: existing
+		},
+		inFlightMutationCount
+	};
+}), on(threadAdapterEvents.newThreadStarted, (state) => ({
 	...state,
-	error: outcome.ok ? state.error : outcome.error
-})), on(threadDomainEvents.threadUpserted, (state, { sessionId, thread }) => {
+	error: null
+})), on(threadRestEvents.mutationFinished, (state, { outcome }) => {
+	if (outcome.sessionId !== state.sessionId) return state;
+	const inFlightMutationCount = Math.max(0, state.inFlightMutationCount - 1);
+	if (outcome.ok) {
+		if (state.pendingDeletes[outcome.requestId] === void 0) return {
+			...state,
+			inFlightMutationCount
+		};
+		const { [outcome.requestId]: _settled, ...rest } = state.pendingDeletes;
+		return {
+			...state,
+			inFlightMutationCount,
+			pendingDeletes: rest
+		};
+	}
+	const rolledBack = state.pendingDeletes[outcome.requestId];
+	if (rolledBack === void 0) return {
+		...state,
+		inFlightMutationCount,
+		error: outcome.error
+	};
+	const { [outcome.requestId]: _restored, ...rest } = state.pendingDeletes;
+	return {
+		...state,
+		threads: upsertThread(state.threads, rolledBack),
+		pendingDeletes: rest,
+		inFlightMutationCount,
+		error: outcome.error
+	};
+}), on(threadDomainEvents.threadUpserted, (state, { sessionId, thread }) => {
 	if (sessionId !== state.sessionId) return state;
 	return {
 		...state,
@@ -3679,23 +3837,49 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		threads: state.threads.filter((thread) => thread.id !== threadId)
 	};
 }));
-const selectThreads = createSelector((state) => state.threads);
-const selectThreadsIsLoading = createSelector((state) => state.isLoading);
-const selectThreadsError = createSelector((state) => state.error);
-const selectHasNextPage = createSelector((state) => state.nextCursor != null);
-const selectIsFetchingNextPage = createSelector((state) => state.isFetchingNextPage);
+/**
+* Builds a fresh set of memoized thread selectors.
+*
+* Each `createSelector` closure owns a private one-entry cache. Sharing a
+* single module-level selector instance across multiple concurrent stores
+* (e.g. a `<CopilotThreadsDrawer>` plus an independent `useThreads`) makes every
+* cross-store emission a cache miss, defeating memoization and risking
+* emission instability for any future selector that allocates a new
+* object/array. Creating a per-store instance keeps each store's cache
+* isolated so concurrent stores never thrash one another.
+*/
+function createThreadSelectors() {
+	return {
+		threads: createSelector((state) => state.threads),
+		isLoading: createSelector((state) => state.isLoading),
+		error: createSelector((state) => state.error),
+		hasNextPage: createSelector((state) => state.nextCursor != null),
+		isFetchingNextPage: createSelector((state) => state.isFetchingNextPage),
+		isMutating: createSelector((state) => state.inFlightMutationCount > 0)
+	};
+}
+const standaloneSelectors = createThreadSelectors();
+const selectThreads = standaloneSelectors.threads;
+const selectThreadsIsLoading = standaloneSelectors.isLoading;
+const selectThreadsError = standaloneSelectors.error;
+const selectHasNextPage = standaloneSelectors.hasNextPage;
+const selectIsFetchingNextPage = standaloneSelectors.isFetchingNextPage;
+const selectIsMutating = standaloneSelectors.isMutating;
 let threadRequestId = 0;
 function createThreadRequestId() {
 	threadRequestId += 1;
 	return `thread-request-${threadRequestId}`;
 }
+function threadFromFetch(input, init) {
+	return fromFetch(input, init);
+}
 function createThreadFetchObservable(environment, context, sessionId) {
 	return defer(() => {
 		const params = { agentId: context.agentId };
 		if (context.includeArchived) params.includeArchived = "true";
 		if (context.limit != null) params.limit = String(context.limit);
 		const qs = new URLSearchParams(params);
-		return fromFetch(`${context.runtimeUrl}/threads?${qs.toString()}`, {
+		return threadFromFetch(`${context.runtimeUrl}/threads?${qs.toString()}`, {
 			selector: (response) => {
 				if (!response.ok) throw new Error(`Failed to fetch threads: ${response.status}`);
 				return response.json();
@@ -3723,7 +3907,7 @@ function createThreadFetchObservable(environment, context, sessionId) {
 }
 function createThreadMetadataCredentialsObservable(environment, context, sessionId) {
 	return defer(() => {
-		return fromFetch(`${context.runtimeUrl}${THREAD_SUBSCRIBE_PATH}`, {
+		return threadFromFetch(`${context.runtimeUrl}${THREAD_SUBSCRIBE_PATH}`, {
 			selector: async (response) => {
 				if (!response.ok) throw new Error(`Failed to fetch thread metadata credentials: ${response.status}`);
 				return response.json();
@@ -3756,7 +3940,7 @@ function createThreadMetadataCredentialsObservable(environment, context, session
 }
 function createThreadMutationObservable(environment, context, request) {
 	return defer(() => {
-		return fromFetch(`${context.runtimeUrl}${request.path}`, {
+		return threadFromFetch(`${context.runtimeUrl}${request.path}`, {
 			selector: async (response) => {
 				if (!response.ok) throw new Error(`Request failed: ${response.status}`);
 				return null;
@@ -3770,10 +3954,12 @@ function createThreadMutationObservable(environment, context, request) {
 			body: JSON.stringify(request.body)
 		}).pipe(map(() => threadRestEvents.mutationFinished({ outcome: {
 			requestId: request.requestId,
+			sessionId: request.sessionId,
 			ok: true
 		} })), catchError((error) => {
 			return of(threadRestEvents.mutationFinished({ outcome: {
 				requestId: request.requestId,
+				sessionId: request.sessionId,
 				ok: false,
 				error: error instanceof Error ? error : new Error(String(error))
 			} }));
@@ -3781,6 +3967,7 @@ function createThreadMutationObservable(environment, context, request) {
 	});
 }
 function createThreadStore(environment) {
+	const selectors = createThreadSelectors();
 	const store = createStore({
 		reducer: threadReducer,
 		effects: [
@@ -3847,6 +4034,10 @@ function createThreadStore(environment) {
 					thread: action.payload.thread
 				});
 			}))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.joinFailed, threadSocketEvents.joinTimedOut, threadSocketEvents.errored, threadRestEvents.metadataCredentialsFailed), withLatestFrom(state$), filter(([action, state]) => action.sessionId === state.sessionId), tap(([action]) => {
+				const reason = threadSocketEvents.joinTimedOut.match(action) ? "channel join timed out" : threadSocketEvents.joinFailed.match(action) ? "channel join was rejected" : threadRestEvents.metadataCredentialsFailed.match(action) ? "metadata credentials fetch failed" : "socket errored";
+				console.warn(`[threads] realtime ${reason}; the thread list may be stale until reconnect`);
+			})), { dispatch: false }),
 			createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.fetchNextPageRequested), withLatestFrom(state$), filter(([, state]) => Boolean(state.context) && Boolean(state.nextCursor)), switchMap$1(([, state]) => {
 				const context = state.context;
 				const params = {
@@ -3855,7 +4046,7 @@ function createThreadStore(environment) {
 				};
 				if (context.includeArchived) params.includeArchived = "true";
 				if (context.limit != null) params.limit = String(context.limit);
-				return fromFetch(`${context.runtimeUrl}/threads?${new URLSearchParams(params).toString()}`, {
+				return threadFromFetch(`${context.runtimeUrl}/threads?${new URLSearchParams(params).toString()}`, {
 					selector: (response) => {
 						if (!response.ok) throw new Error(`Failed to fetch next page: ${response.status}`);
 						return response.json();
@@ -3877,12 +4068,14 @@ function createThreadStore(environment) {
 					error: error instanceof Error ? error : new Error(String(error))
 				}))), takeUntil(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))));
 			}))),
-			createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.renameRequested, threadAdapterEvents.archiveRequested, threadAdapterEvents.deleteRequested), withLatestFrom(state$), mergeMap(([action, state]) => {
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.renameRequested, threadAdapterEvents.archiveRequested, threadAdapterEvents.unarchiveRequested, threadAdapterEvents.deleteRequested), withLatestFrom(state$), mergeMap(([action, state]) => {
+				const sessionId = state.sessionId;
 				const context = state.context;
 				if (!context?.runtimeUrl) {
 					const requestId = action.requestId;
 					return of(threadRestEvents.mutationFinished({ outcome: {
 						requestId,
+						sessionId,
 						ok: false,
 						error: /* @__PURE__ */ new Error("Runtime URL is not configured")
 					} }));
@@ -3890,6 +4083,7 @@ function createThreadStore(environment) {
 				const commonBody = { agentId: context.agentId };
 				if (threadAdapterEvents.renameRequested.match(action)) return createThreadMutationObservable(environment, context, {
 					requestId: action.requestId,
+					sessionId,
 					method: "PATCH",
 					path: `/threads/${encodeURIComponent(action.threadId)}`,
 					body: {
@@ -3899,12 +4093,24 @@ function createThreadStore(environment) {
 				});
 				if (threadAdapterEvents.archiveRequested.match(action)) return createThreadMutationObservable(environment, context, {
 					requestId: action.requestId,
+					sessionId,
 					method: "POST",
 					path: `/threads/${encodeURIComponent(action.threadId)}/archive`,
 					body: commonBody
 				});
+				if (threadAdapterEvents.unarchiveRequested.match(action)) return createThreadMutationObservable(environment, context, {
+					requestId: action.requestId,
+					sessionId,
+					method: "PATCH",
+					path: `/threads/${encodeURIComponent(action.threadId)}`,
+					body: {
+						...commonBody,
+						archived: false
+					}
+				});
 				return createThreadMutationObservable(environment, context, {
 					requestId: action.requestId,
+					sessionId,
 					method: "DELETE",
 					path: `/threads/${encodeURIComponent(action.threadId)}`,
 					body: commonBody
@@ -3915,6 +4121,7 @@ function createThreadStore(environment) {
 	function trackMutation(dispatchAction) {
 		const resultPromise = firstValueFrom(merge(store.actions$.pipe(ofType(threadRestEvents.mutationFinished), filter((action) => action.outcome.requestId === dispatchAction.requestId), map((action) => action.outcome)), store.actions$.pipe(ofType(threadAdapterEvents.stopped), map(() => ({
 			requestId: dispatchAction.requestId,
+			sessionId: store.getState().sessionId,
 			ok: false,
 			error: /* @__PURE__ */ new Error("Thread store stopped before mutation completed")
 		})))).pipe(take(1))).then((outcome) => {
@@ -3924,13 +4131,23 @@ function createThreadStore(environment) {
 		store.dispatch(dispatchAction);
 		return resultPromise;
 	}
+	let errorSubscription = null;
+	const subscribeErrors = () => {
+		if (!environment.onError || errorSubscription) return;
+		errorSubscription = store.actions$.pipe(ofType(threadRestEvents.mutationFinished), filter((action) => !action.outcome.ok && action.outcome.sessionId === store.getState().sessionId)).subscribe((action) => {
+			if (!action.outcome.ok) environment.onError?.(action.outcome.error);
+		});
+	};
 	return {
 		start() {
 			store.init();
+			subscribeErrors();
 			store.dispatch(threadAdapterEvents.started());
 		},
 		stop() {
 			store.dispatch(threadAdapterEvents.stopped());
+			errorSubscription?.unsubscribe();
+			errorSubscription = null;
 			store.stop();
 		},
 		setContext(context) {
@@ -3941,6 +4158,14 @@ function createThreadStore(environment) {
 			if (!context) return;
 			store.dispatch(threadRestEvents.listRequested({ sessionId }));
 		},
+		refetchThreads() {
+			const { sessionId, context } = store.getState();
+			if (!context) return;
+			store.dispatch(threadRestEvents.listRequested({ sessionId }));
+		},
+		startNewThread() {
+			store.dispatch(threadAdapterEvents.newThreadStarted());
+		},
 		fetchNextPage() {
 			store.dispatch(threadAdapterEvents.fetchNextPageRequested());
 		},
@@ -3957,6 +4182,12 @@ function createThreadStore(environment) {
 				threadId
 			}));
 		},
+		unarchiveThread(threadId) {
+			return trackMutation(threadAdapterEvents.unarchiveRequested({
+				requestId: createThreadRequestId(),
+				threadId
+			}));
+		},
 		deleteThread(threadId) {
 			return trackMutation(threadAdapterEvents.deleteRequested({
 				requestId: createThreadRequestId(),
@@ -3966,15 +4197,21 @@ function createThreadStore(environment) {
 		getState() {
 			return store.getState();
 		},
-		select: store.select.bind(store)
+		getServerState() {
+			return initialThreadState;
+		},
+		select: store.select.bind(store),
+		selectors
 	};
 }
 const ɵthreadAdapterEvents = threadAdapterEvents;
+const ɵcreateThreadSelectors = createThreadSelectors;
 const ɵselectThreads = selectThreads;
 const ɵselectThreadsIsLoading = selectThreadsIsLoading;
 const ɵselectThreadsError = selectThreadsError;
 const ɵselectHasNextPage = selectHasNextPage;
 const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
+const ɵselectIsMutating = selectIsMutating;
 /**
 * Number of consecutive WebSocket connection failures after which the
 * threads channel tears itself down rather than retrying indefinitely.
@@ -3984,5 +4221,50 @@ const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
 const ɵMAX_SOCKET_RETRIES = MAX_SOCKET_RETRIES;
 
 //#endregion
-export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, isRunCompletionAware, ofType, on, parseToolArguments, props, select, ɵMAX_SOCKET_RETRIES, createThreadStore as ɵcreateThreadStore, ɵjoinPhoenixChannel$, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+//#region src/features.ts
+/**
+* Central registry of CopilotKit feature names.
+*
+* Feature names are the strings passed to a license context's `checkFeature`
+* (see `@copilotkit/shared`'s `LicenseContextValue`). Historically the only
+* features referenced by literal were the chat surfaces (`chat`, `sidebar`,
+* `popup`); this module makes the set explicit and typed so new surfaces —
+* such as the threads drawer — register a real, discoverable feature name
+* rather than an ad-hoc string scattered across components.
+*
+* `checkFeature` itself still accepts any `string` for backward compatibility;
+* this registry simply documents and types the names CopilotKit recognises.
+*/
+/**
+* The set of feature names CopilotKit recognises.
+*
+* Frozen so the array cannot be mutated at runtime. Add new surfaces here when
+* they begin gating behaviour on `checkFeature`.
+*/
+const ɵCOPILOTKIT_FEATURES = Object.freeze([
+	"chat",
+	"sidebar",
+	"popup",
+	"threads"
+]);
+const FEATURE_SET = new Set(ɵCOPILOTKIT_FEATURES);
+/**
+* Type guard: returns `true` when `name` is a recognised CopilotKit feature.
+*
+* @param name - Candidate feature name.
+* @returns Whether `name` is a registered feature.
+*
+* @example
+* ```ts
+* if (ɵisCopilotKitFeature("threads")) {
+*   // narrowed to ɵCopilotKitFeature
+* }
+* ```
+*/
+function ɵisCopilotKitFeature(name) {
+	return FEATURE_SET.has(name);
+}
+
+//#endregion
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, isRunCompletionAware, ofType, on, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵMAX_SOCKET_RETRIES, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, ɵjoinPhoenixChannel$, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
 //# sourceMappingURL=index.mjs.map