@copilotkit/core 1.64.2-canary.1785346263 → 1.64.2-canary.1785366148

package/dist/index.cjs

@@ -1772,6 +1772,24 @@ const MAX_FOLLOW_UP_DEPTH = 100;
 var RunHandler = class {
 	_tools = [];
 	/**
+	* The full list of A2UI catalog components registered by the provider.
+	* Order is preserved for display in the inspector.
+	*/
+	_catalogComponents = [];
+	/**
+	* Names of catalog components the caller has explicitly disabled. A name
+	* absent from this set is enabled (default). Survives re-registration so a
+	* catalog identity change does not silently re-enable a disabled component.
+	*/
+	_disabledCatalogComponents = /* @__PURE__ */ new Set();
+	/**
+	* Keys of frontend tools explicitly disabled at runtime via the Inspector's
+	* Capabilities tool (`setToolEnabled`). Kept independently of each tool's own
+	* `available` flag so a hook re-registering the tool (which resets
+	* `available`) does not clobber the override. Key = `capabilityKey(name, agentId)`.
+	*/
+	_disabledToolKeys = /* @__PURE__ */ new Set();
+	/**
 	* Tracks whether the current run (including in-flight tool execution)
 	* has been aborted via `stopAgent()` or `agent.abortRun()`. Created
 	* fresh in `runAgent()`, aborted by `abortCurrentRun()`.
@@ -1886,6 +1904,32 @@ var RunHandler = class {
 		this._tools = [...tools];
 	}
 	/**
+	* Return the registered A2UI catalog components (readonly).
+	*/
+	get catalogComponents() {
+		return this._catalogComponents;
+	}
+	/**
+	* Replace the registered catalog component list. Preserves the disabled set
+	* (by name) so re-registration does not re-enable disabled components.
+	*/
+	setCatalogComponents(components) {
+		this._catalogComponents = [...components];
+	}
+	/**
+	* Enable or disable a catalog component by name.
+	*/
+	setCatalogComponentEnabled(name, enabled) {
+		if (enabled) this._disabledCatalogComponents.delete(name);
+		else this._disabledCatalogComponents.add(name);
+	}
+	/**
+	* Whether a catalog component is enabled. Unknown names default to enabled.
+	*/
+	isCatalogComponentEnabled(name) {
+		return !this._disabledCatalogComponents.has(name);
+	}
+	/**
 	* Connect an agent (establish initial connection)
 	*/
 	async connectAgent({ agent }) {
@@ -2350,11 +2394,30 @@ var RunHandler = class {
 			error: handlerResult.error
 		};
 	}
+	/** Stable identity for a tool override: agent-scope + name (NUL-separated). */
+	capabilityKey(name, agentId) {
+		return `${agentId ?? ""}\u0000${name}`;
+	}
+	/**
+	* Enable/disable a registered frontend tool at runtime without unregistering
+	* it. A disabled tool is omitted from {@link buildFrontendTools}, so the agent
+	* never receives it. Unlike the per-tool `available` flag, this override
+	* survives the tool being re-registered.
+	*/
+	setToolEnabled(name, enabled, agentId) {
+		const key = this.capabilityKey(name, agentId);
+		if (enabled) this._disabledToolKeys.delete(key);
+		else this._disabledToolKeys.add(key);
+	}
+	/** Whether a tool is currently enabled (not overridden off). Defaults true. */
+	isToolEnabled(name, agentId) {
+		return !this._disabledToolKeys.has(this.capabilityKey(name, agentId));
+	}
 	/**
 	* Build frontend tools for an agent
 	*/
 	buildFrontendTools(agentId) {
-		return this._tools.filter((tool) => tool.available !== false && tool.available !== "disabled" && (!tool.agentId || tool.agentId === agentId)).map((tool) => ({
+		return this._tools.filter((tool) => tool.available !== false && tool.available !== "disabled" && (!tool.agentId || tool.agentId === agentId) && this.isToolEnabled(tool.name, tool.agentId)).map((tool) => ({
 			name: tool.name,
 			description: tool.description ?? "",
 			parameters: createToolSchema(tool)
@@ -2995,6 +3058,13 @@ const MEMORY_ERROR_REGISTRY = Object.freeze({
 		message: "Failed to fetch memories",
 		docsPath: "docs/errors/memory.md#memory_list_failed"
 	},
+	MEMORY_RECALL_FAILED: {
+		code: "MEMORY_RECALL_FAILED",
+		category: "dependency",
+		retryable: true,
+		message: "Failed to recall memories",
+		docsPath: "docs/errors/memory.md#memory_recall_failed"
+	},
 	MEMORY_CREDENTIALS_FAILED: {
 		code: "MEMORY_CREDENTIALS_FAILED",
 		category: "dependency",
@@ -3068,6 +3138,7 @@ function isRetryableStatus(status) {
 //#region src/memory.ts
 const MEMORIES_PATH = "/memories";
 const MEMORIES_SUBSCRIBE_PATH = "/memories/subscribe";
+const MEMORIES_RECALL_PATH = "/memories/recall";
 const REQUEST_TIMEOUT_MS$1 = 15e3;
 /** Consecutive socket errors tolerated before the realtime stream gives up. */
 const MAX_SOCKET_RETRIES$1 = 5;
@@ -3282,10 +3353,12 @@ function memoryFromFetch(input, init) {
 	return (0, rxjs_fetch.fromFetch)(input, init);
 }
 /**
-* Fetches the memory snapshot and maps it to a success/failure action. Keeps
-* only user-scoped memories (v1 surfaces user scope only; the realtime stream
-* is user-scoped too), so project-scoped rows visible to the caller are
-* dropped from the store.
+* Fetches the memory snapshot and maps it to a success/failure action. Both
+* user- and project-scoped rows are kept: the store now opens a second
+* `project_meta:memories:<code>` realtime channel (when project credentials are
+* available) that keeps project rows in sync, so surfacing them in the snapshot
+* no longer risks a stale list. Rows are keyed by id across both channels, so
+* realtime deltas reconcile either scope idempotently.
 */
 function createMemoryFetchObservable(environment, context, sessionId) {
 	return (0, rxjs.defer)(() => {
@@ -3311,7 +3384,7 @@ function createMemoryFetchObservable(environment, context, sessionId) {
 			}
 		}), (0, rxjs_operators.map)((data) => memoryRestEvents.listSucceeded({
 			sessionId,
-			memories: data.memories.filter((memory) => memory.scope === "user")
+			memories: data.memories
 		})), (0, rxjs_operators.catchError)((error) => {
 			if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.listUnavailable({ sessionId }));
 			return (0, rxjs.of)(memoryRestEvents.listFailed({
@@ -3354,10 +3427,15 @@ function createMemoryCredentialsFetchObservable(environment, context, sessionId)
 	}), (0, rxjs_operators.map)((data) => {
 		if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
 		if (typeof data.joinCode !== "string" || data.joinCode.length === 0) throw new Error("missing joinCode");
+		const hasProjectCreds = typeof data.projectJoinToken === "string" && data.projectJoinToken.length > 0 && typeof data.projectJoinCode === "string" && data.projectJoinCode.length > 0;
 		return memoryRestEvents.credentialsSucceeded({
 			sessionId,
 			joinToken: data.joinToken,
-			joinCode: data.joinCode
+			joinCode: data.joinCode,
+			...hasProjectCreds ? {
+				projectJoinToken: data.projectJoinToken,
+				projectJoinCode: data.projectJoinCode
+			} : {}
 		});
 	}), (0, rxjs_operators.catchError)((error) => {
 		if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.credentialsUnavailable({ sessionId }));
@@ -3378,6 +3456,21 @@ function responseToMemory(data) {
 		invalidatedAt: data.invalidatedAt
 	};
 }
+/**
+* Projects a recall REST response memory (which carries a relevance `score`)
+* to the public {@link Memory} shape. `score` is copied through when supplied.
+*/
+function recallResponseToMemory(data) {
+	return {
+		id: data.id,
+		kind: data.kind,
+		scope: data.scope,
+		content: data.content,
+		sourceThreadIds: data.sourceThreadIds,
+		invalidatedAt: data.invalidatedAt,
+		...typeof data.score === "number" ? { score: data.score } : {}
+	};
+}
 const MEMORY_KINDS = new Set([
 	"topical",
 	"episodic",
@@ -3566,9 +3659,32 @@ function createMemoryStore(environment) {
 				return action.sessionId === state.sessionId && Boolean(state.context?.wsUrl);
 			}), (0, rxjs_operators.switchMap)(([action, state]) => {
 				const context = state.context;
-				const { joinToken, joinCode } = action;
+				const { joinToken, joinCode, projectJoinToken, projectJoinCode } = action;
 				const sessionId = action.sessionId;
 				const shutdown$ = actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped));
+				const channelMetadata$ = (channelJoinToken, topic) => {
+					const channel$ = ɵphoenixChannel$({
+						socket$: ɵphoenixSocket$({
+							url: context.wsUrl,
+							options: {
+								params: { join_token: channelJoinToken },
+								reconnectAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(100, 1e4),
+								rejoinAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 3e4)
+							}
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						})),
+						topic
+					}).pipe((0, rxjs_operators.shareReplay)({
+						bufferSize: 1,
+						refCount: true
+					}));
+					return (0, rxjs.merge)(channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, MEMORY_METADATA_EVENT)), (0, rxjs_operators.map)((event) => mapMemoryMetadataEvent(event, sessionId))), ɵjoinPhoenixChannel$(channel$).pipe((0, rxjs_operators.catchError)((error) => {
+						console.warn(`[memory] failed to join ${topic}`, error);
+						return rxjs.EMPTY;
+					})));
+				};
 				return (0, rxjs.defer)(() => {
 					const socket$ = ɵphoenixSocket$({
 						url: context.wsUrl,
@@ -3598,7 +3714,8 @@ function createMemoryStore(environment) {
 						console.warn(`[memory] failed to join user_meta:memories:${joinCode}`, error);
 						return (0, rxjs.of)(memoryDomainEvents.realtimeUnavailable({ sessionId }));
 					}));
-					return (0, rxjs.merge)((0, rxjs.of)(memoryDomainEvents.realtimeConnecting({ sessionId })), metadata$, join$, fatalStatus$).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$.pipe((0, rxjs.observeOn)(rxjs.asapScheduler)))), (0, rxjs_operators.finalize)(() => {}));
+					const projectMetadata$ = projectJoinToken && projectJoinCode ? channelMetadata$(projectJoinToken, `project_meta:memories:${projectJoinCode}`) : rxjs.EMPTY;
+					return (0, rxjs.merge)((0, rxjs.of)(memoryDomainEvents.realtimeConnecting({ sessionId })), metadata$, join$, projectMetadata$, fatalStatus$).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$.pipe((0, rxjs.observeOn)(rxjs.asapScheduler)))), (0, rxjs_operators.finalize)(() => {}));
 				});
 			})))
 		]
@@ -3640,6 +3757,34 @@ function createMemoryStore(environment) {
 			store.dispatch(memoryRestEvents.listRequested({ sessionId }));
 			return done;
 		},
+		recall(query, opts) {
+			const { context } = store.getState();
+			if (!context?.runtimeUrl) return Promise.reject(/* @__PURE__ */ new Error("Runtime URL is not configured"));
+			const body = { query };
+			if (opts?.limit !== void 0) body.limit = opts.limit;
+			if (opts?.scope !== void 0) body.scope = opts.scope;
+			return (0, rxjs.firstValueFrom)(memoryFromFetch(`${context.runtimeUrl}${MEMORIES_RECALL_PATH}`, {
+				selector: async (response) => {
+					if (!response.ok) throw new MemoryError("MEMORY_RECALL_FAILED", {
+						message: `Failed to recall memories: ${response.status}`,
+						retryable: isRetryableStatus(response.status)
+					});
+					return await response.json();
+				},
+				fetch: environment.fetch,
+				method: "POST",
+				headers: {
+					...context.headers,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(body)
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS$1,
+				with: () => {
+					throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+				}
+			}), (0, rxjs_operators.map)((data) => (data.memories ?? []).map((m) => recallResponseToMemory(m)))));
+		},
 		addMemory(input) {
 			return trackMutation(memoryAdapterEvents.addRequested({
 				requestId: createMemoryRequestId(),
@@ -3864,6 +4009,9 @@ var CopilotKitCore = class {
 	get tools() {
 		return this.runHandler.tools;
 	}
+	get catalogComponents() {
+		return this.runHandler.catalogComponents;
+	}
 	get runtimeUrl() {
 		return this.agentRegistry.runtimeUrl;
 	}
@@ -4185,6 +4333,40 @@ var CopilotKitCore = class {
 		this.runHandler.setTools(tools);
 	}
 	/**
+	* Enable/disable a registered frontend tool at runtime without unregistering
+	* it (Inspector "Capabilities" tool). A disabled tool is omitted from the
+	* tool list sent to the agent on the next run. The override is keyed by name
+	* (+ optional agentId) and survives the tool being re-registered.
+	*/
+	setToolEnabled(name, enabled, agentId) {
+		this.runHandler.setToolEnabled(name, enabled, agentId);
+	}
+	/** Whether a registered tool is currently enabled (defaults true). */
+	isToolEnabled(name, agentId) {
+		return this.runHandler.isToolEnabled(name, agentId);
+	}
+	/**
+	* A2UI catalog component management (delegated to RunHandler).
+	* Registers the full component list and controls per-component enablement.
+	*/
+	setCatalogComponents(components) {
+		this.runHandler.setCatalogComponents(components);
+		this.notifySubscribers((subscriber) => subscriber.onCatalogComponentsChanged?.({
+			copilotkit: this,
+			catalogComponents: this.runHandler.catalogComponents
+		}), "Subscriber onCatalogComponentsChanged error:");
+	}
+	setCatalogComponentEnabled(name, enabled) {
+		this.runHandler.setCatalogComponentEnabled(name, enabled);
+		this.notifySubscribers((subscriber) => subscriber.onCatalogComponentsChanged?.({
+			copilotkit: this,
+			catalogComponents: this.runHandler.catalogComponents
+		}), "Subscriber onCatalogComponentsChanged error:");
+	}
+	isCatalogComponentEnabled(name) {
+		return this.runHandler.isCatalogComponentEnabled(name);
+	}
+	/**
 	* Subscription lifecycle
 	*/
 	subscribe(subscriber) {