@copilotkit/core 1.70.1 → 1.70.2

package/dist/index.mjs

@@ -1,12 +1,88 @@
 import { Throttler } from "@tanstack/pacer";
-import { AbstractAgent, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
+import { AGUIConnectNotImplementedError, AbstractAgent, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
 import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, parseInspectorMetadataV1, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema } from "@copilotkit/shared";
 import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, observeOn, of, switchMap, throwError } from "rxjs";
 import { catchError, concatWith, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn as observeOn$1, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
 import { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { fromFetch } from "rxjs/fetch";
 
+//#region src/utils/connect-replay.ts
+/**
+* Runs an agent's `connect()` stream through the AbstractAgent apply pipeline
+* with the `verifyEvents` step omitted.
+*
+* `verifyEvents` enforces AG-UI's *single run* lifecycle rules: exactly one
+* RUN_STARTED opening the stream, no events after a terminal RUN_FINISHED /
+* RUN_ERROR. Those rules are correct for `/run`, but a `/connect` response is a
+* replay of a thread's history and can legitimately carry several past runs
+* back to back — including a run that ended in RUN_ERROR followed by a later
+* RUN_STARTED. Verifying a replay against single-run rules makes hydration of
+* an existing thread fail outright:
+*
+*   Cannot send event type 'RUN_STARTED': The run has already errored with
+*   'RUN_ERROR'. No further events can be sent.
+*
+* `transformChunks` is still applied — message reassembly is needed either way.
+*
+* This mirrors the base `AbstractAgent.connectAgent` implementation exactly
+* apart from that omission, so callers keep the same subscriber notifications,
+* detach semantics, and `{ result, newMessages }` return shape.
+*
+* TODO: Remove this in favour of the base implementation once AG-UI's
+* AbstractAgent supports opting out of `verifyEvents` for transports whose
+* connection life-cycle isn't a single run. As of `@ag-ui/client@0.0.57`
+* `connectAgent(parameters?, subscriber?)` takes no such option.
+*
+* @param agent - The agent whose `connect()` stream should be consumed.
+* @param parameters - Run parameters, forwarded to `prepareRunAgentInput`.
+* @param subscriber - Optional one-shot subscriber for this connect call.
+*/
+async function ɵconnectWithoutEventVerification(agent, parameters, subscriber) {
+	const self = agent;
+	try {
+		agent.isRunning = true;
+		agent.agentId = agent.agentId ?? randomUUID();
+		const input = self.prepareRunAgentInput(parameters);
+		let result;
+		const previousMessageIds = new Set(agent.messages.map((m) => m.id));
+		const subscribers = [
+			{ onRunFinishedEvent: (event) => {
+				if (event.outcome === "success") result = event.result;
+			} },
+			...agent.subscribers,
+			subscriber ?? {}
+		];
+		await self.onInitialize(input, subscribers);
+		self.activeRunDetach$ = new Subject();
+		let resolveCompletion;
+		self.activeRunCompletionPromise = new Promise((resolve) => {
+			resolveCompletion = resolve;
+		});
+		const source$ = defer(() => self.connect(input)).pipe(transformChunks(self.debugLogger), takeUntil(self.activeRunDetach$));
+		const applied$ = self.apply(input, source$, subscribers);
+		await lastValueFrom(self.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
+			agent.isRunning = false;
+			if (error instanceof AGUIConnectNotImplementedError) return EMPTY;
+			return self.onError(input, error, subscribers);
+		}), finalize(() => {
+			agent.isRunning = false;
+			self.onFinalize(input, subscribers);
+			resolveCompletion?.();
+			resolveCompletion = void 0;
+			self.activeRunCompletionPromise = void 0;
+			self.activeRunDetach$ = void 0;
+		})), { defaultValue: void 0 });
+		const newMessages = structuredClone_(agent.messages).filter((m) => !previousMessageIds.has(m.id));
+		return {
+			result,
+			newMessages
+		};
+	} finally {
+		agent.isRunning = false;
+	}
+}
+
+//#endregion
 //#region src/utils/phoenix-observable.ts
 /**
 * Adapt Phoenix socket open/error callbacks into an observable signal stream.
@@ -203,72 +279,22 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	/**
 	* Override of AbstractAgent.connectAgent that removes the `verifyEvents` step.
 	*
-	* Background: AbstractAgent's connectAgent pipeline runs events through
-	* `verifyEvents`, which validates that the stream follows the AG-UI protocol
-	* lifecycle — specifically, it expects a RUN_STARTED event before any content
-	* events and a RUN_FINISHED/RUN_ERROR event to complete the stream.
-	*
 	* IntelligenceAgent uses long-lived WebSocket connections rather than
 	* request-scoped SSE streams. When connecting to replay historical messages
 	* for an existing thread, the connection semantics don't map to a single
-	* agent run start/stop cycle. The replayed events may not include
-	* RUN_STARTED/RUN_FINISHED bookends (or may contain events from multiple
-	* past runs), which causes verifyEvents to either never complete or to
-	* error out.
+	* agent run start/stop cycle: the replayed events may omit the
+	* RUN_STARTED/RUN_FINISHED bookends, or carry events from several past runs,
+	* either of which makes `verifyEvents` stall or error out.
 	*
-	* This override replicates the base connectAgent implementation exactly,
-	* substituting only `transformChunks` (which is still needed for message
-	* reassembly) and omitting `verifyEvents`.
-	*
-	* TODO: Remove this override once AG-UI's AbstractAgent supports opting out
-	* of verifyEvents for transports with different connection life-cycles.
+	* See {@link ɵconnectWithoutEventVerification} for the pipeline itself, which
+	* the self-hosted `/connect` path shares for the same reason.
 	*/
 	async connectAgent(parameters, subscriber) {
-		const self = this;
-		try {
-			this.isRunning = true;
-			this.agentId = this.agentId ?? randomUUID();
-			const effectiveParameters = parameters?.runId || !this.canonicalRunId ? parameters : {
-				...parameters,
-				runId: this.canonicalRunId
-			};
-			const input = this.prepareRunAgentInput(effectiveParameters);
-			let result;
-			const previousMessageIds = new Set(this.messages.map((m) => m.id));
-			const subscribers = [
-				{ onRunFinishedEvent: (event) => {
-					if (event.outcome === "success") result = event.result;
-				} },
-				...this.subscribers,
-				subscriber ?? {}
-			];
-			await this.onInitialize(input, subscribers);
-			self.activeRunDetach$ = new Subject();
-			let resolveCompletion;
-			self.activeRunCompletionPromise = new Promise((resolve) => {
-				resolveCompletion = resolve;
-			});
-			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;
-				return this.onError(input, error, subscribers);
-			}), finalize(() => {
-				this.isRunning = false;
-				this.onFinalize(input, subscribers);
-				resolveCompletion?.();
-				resolveCompletion = void 0;
-				self.activeRunCompletionPromise = void 0;
-				self.activeRunDetach$ = void 0;
-			})), { defaultValue: void 0 });
-			const newMessages = structuredClone_(this.messages).filter((m) => !previousMessageIds.has(m.id));
-			return {
-				result,
-				newMessages
-			};
-		} finally {
-			this.isRunning = false;
-		}
+		const effectiveParameters = parameters?.runId || !this.canonicalRunId ? parameters : {
+			...parameters,
+			runId: this.canonicalRunId
+		};
+		return ɵconnectWithoutEventVerification(this, effectiveParameters, subscriber);
 	}
 	abortRun() {
 		if (this.activeChannel && this.canonicalRunId) {
@@ -360,13 +386,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 						...this.headers
 					},
 					body: JSON.stringify({
-						threadId: input.threadId,
-						runId: input.runId,
-						messages: input.messages,
-						tools: input.tools,
-						context: input.context,
-						state: input.state,
-						forwardedProps: input.forwardedProps,
+						...input,
 						...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
 					}),
 					...this.credentials ? { credentials: this.credentials } : {}
@@ -733,7 +753,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		});
 	}
 	async connectAgent(parameters, subscriber) {
-		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return super.connectAgent(parameters, subscriber);
+		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return ɵconnectWithoutEventVerification(this, parameters, subscriber);
 		if (this.delegate) await this.delegate.detachActiveRun();
 		await this.resolveDelegate();
 		const delegate = this.delegate;
@@ -985,6 +1005,74 @@ function runtimeRequestMeta(init) {
 	return init?.ɵruntimeRequest;
 }
 
+//#endregion
+//#region src/utils/single-route-resource-request.ts
+/** Returns true when a path belongs to an Intelligence resource API. */
+function isIntelligenceResourcePath(path) {
+	return path === "/threads" || path.startsWith("/threads/") || path === "/memories" || path.startsWith("/memories/") || path === "/annotate";
+}
+/** Reads a JSON resource body without changing invalid JSON error behavior. */
+async function readResourceBody(input, init, headers, method) {
+	if (method === "GET" || method === "HEAD") return void 0;
+	let text;
+	if (init?.body != null) text = await new Response(init.body).text();
+	else if (input instanceof Request) text = await input.clone().text();
+	if (!text) return void 0;
+	if (headers.get("content-type")?.toLowerCase().includes("application/json")) try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+	return text;
+}
+/**
+* Converts one Runtime resource fetch into a single-route JSON envelope.
+* Requests outside the mounted Runtime or outside its resource APIs pass
+* through unchanged.
+*/
+async function createSingleRouteResourceRequest(input, init, runtimeUrl) {
+	const runtime = new URL(runtimeUrl);
+	const inputUrl = input instanceof Request ? input.url : input instanceof URL ? input.href : input;
+	const target = new URL(inputUrl, runtime);
+	const runtimePath = runtime.pathname.replace(/\/$/, "");
+	if (target.origin !== runtime.origin) return null;
+	if (!target.pathname.startsWith(`${runtimePath}/`)) return null;
+	const resourcePath = target.pathname.slice(runtimePath.length);
+	if (!isIntelligenceResourcePath(resourcePath)) return null;
+	const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+	const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+	const body = await readResourceBody(input, init, headers, method);
+	headers.set("content-type", "application/json");
+	headers.delete("content-length");
+	return {
+		input: runtimeUrl,
+		init: {
+			...input instanceof Request ? {
+				cache: input.cache,
+				credentials: input.credentials,
+				integrity: input.integrity,
+				keepalive: input.keepalive,
+				mode: input.mode,
+				redirect: input.redirect,
+				referrer: input.referrer,
+				referrerPolicy: input.referrerPolicy,
+				signal: input.signal
+			} : {},
+			...init,
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				method: "resource/request",
+				params: {
+					path: `${resourcePath}${target.search}`,
+					httpMethod: method
+				},
+				...body === void 0 ? {} : { body }
+			})
+		}
+	};
+}
+
 //#endregion
 //#region src/core/agent-registry.ts
 /** Maximum wait for optional Inspector metadata before degrading to absence. */
@@ -1026,7 +1114,9 @@ var AgentRegistry = class {
 	_runtimeMode = RUNTIME_MODE_SSE;
 	_intelligence;
 	_threadEndpoints;
+	_singleRouteResourceOperations = false;
 	_suggestions;
+	_inspectorLearning = false;
 	_inspectorMetadata;
 	_inspectorMetadataSupported = false;
 	inspectorMetadataRefreshReady = false;
@@ -1097,6 +1187,9 @@ var AgentRegistry = class {
 	get suggestions() {
 		return this._suggestions;
 	}
+	get inspectorLearning() {
+		return this._inspectorLearning;
+	}
 	get inspectorMetadata() {
 		return this._inspectorMetadata;
 	}
@@ -1147,6 +1240,7 @@ var AgentRegistry = class {
 		this.resetRuntimeEntitlementRetry();
 		this._licenseStatus = void 0;
 		this._runtimeEntitlements = void 0;
+		this._singleRouteResourceOperations = false;
 		this._runtimeUrl = normalizedRuntimeUrl;
 		if (options?.deferConnection) return;
 		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
@@ -1175,6 +1269,7 @@ var AgentRegistry = class {
 		this.resetRuntimeEntitlementRetry();
 		this._requestedTransport = runtimeTransport;
 		this._runtimeTransport = runtimeTransport;
+		this._singleRouteResourceOperations = false;
 		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
 	}
 	hasLiveRuntimeKnowledgeToProtect() {
@@ -1346,7 +1441,8 @@ var AgentRegistry = class {
 			const meta = () => runtimeRequestMeta(init);
 			const watchdog = this.armRuntimeRequestWatchdog(meta());
 			try {
-				const response = await fetch(input, init);
+				const singleRouteRequest = this._runtimeTransport === "single" && this._singleRouteResourceOperations && this._runtimeUrl ? await createSingleRouteResourceRequest(input, init, this._runtimeUrl) : null;
+				const response = singleRouteRequest ? await fetch(singleRouteRequest.input, singleRouteRequest.init) : await fetch(input, init);
 				watchdog.clear();
 				this.handleRuntimeRequestOutcome(response.ok ? "ok" : meta()?.nonCritical ? "ignored" : "failed", watchdog.checked);
 				return response;
@@ -1495,6 +1591,7 @@ var AgentRegistry = class {
 	}
 	invalidateInspectorMetadataConnection() {
 		this._inspectorMetadataSupported = false;
+		this._inspectorLearning = false;
 		this.inspectorMetadataRefreshReady = false;
 		this.inspectorMetadataConnectionGeneration += 1;
 		this.inspectorMetadataGeneration += 1;
@@ -1693,7 +1790,9 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._threadEndpoints = void 0;
+			this._singleRouteResourceOperations = false;
 			this._suggestions = void 0;
+			this._inspectorLearning = false;
 			this._a2uiEnabled = false;
 			this._a2uiAgents = void 0;
 			this._openGenerativeUIEnabled = false;
@@ -1762,8 +1861,10 @@ var AgentRegistry = class {
 			this._audioFileTranscriptionEnabled = runtimeInfoResponse.audioFileTranscriptionEnabled ?? false;
 			this._runtimeMode = runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE;
 			this._intelligence = runtimeInfoResponse.intelligence;
-			this._threadEndpoints = runtimeInfoResponse.threadEndpoints;
+			this._singleRouteResourceOperations = resolvedTransport === "single" && runtimeInfoResponse.singleRoute?.resourceOperations === true;
+			this._threadEndpoints = this._singleRouteResourceOperations ? runtimeInfoResponse.singleRoute?.threadEndpoints : runtimeInfoResponse.threadEndpoints;
 			this._suggestions = runtimeInfoResponse.suggestions;
+			this._inspectorLearning = runtimeInfoResponse.inspectorLearning === true;
 			this._inspectorMetadataSupported = runtimeInfoResponse.inspectorMetadata === true;
 			this.inspectorMetadataRefreshReady = false;
 			if (!this._inspectorMetadataSupported) this.setInspectorMetadata(void 0);
@@ -1797,7 +1898,9 @@ var AgentRegistry = class {
 				this._runtimeMode = RUNTIME_MODE_SSE;
 				this._intelligence = void 0;
 				this._threadEndpoints = void 0;
+				this._singleRouteResourceOperations = false;
 				this._suggestions = void 0;
+				this._inspectorLearning = false;
 				this._a2uiEnabled = false;
 				this._a2uiAgents = void 0;
 				this._openGenerativeUIEnabled = false;
@@ -4299,8 +4402,24 @@ const selectMemoriesAvailable = createSelector((state) => state.available);
 */
 const selectMemoriesRealtimeStatus = createSelector((state) => state.realtimeStatus);
 const MEMORY_METADATA_EVENT = "memory_metadata";
+/** Runs a memory request through the injected fetch and aborts on unsubscribe. */
 function memoryFromFetch(input, init) {
-	return fromFetch(input, init);
+	const { selector, fetch: fetchImplementation, signal: outerSignal, ...requestInit } = init;
+	return new Observable((subscriber) => {
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		if (outerSignal?.aborted) controller.abort();
+		else outerSignal?.addEventListener("abort", abort);
+		const subscription = from(fetchImplementation(input, {
+			...requestInit,
+			signal: controller.signal
+		})).pipe(mergeMap((response) => from(selector(response)))).subscribe(subscriber);
+		return () => {
+			outerSignal?.removeEventListener("abort", abort);
+			controller.abort();
+			subscription.unsubscribe();
+		};
+	});
 }
 /**
 * Fetches the memory snapshot and maps it to a success/failure action. Both
@@ -5058,6 +5177,10 @@ var CopilotKitCore = class {
 	get suggestions() {
 		return this.agentRegistry.suggestions;
 	}
+	/** Whether the connected Runtime exposes debug-authorized Learning data. */
+	get inspectorLearning() {
+		return this.agentRegistry.inspectorLearning;
+	}
 	/** Trusted, optional metadata advertised by the connected runtime. */
 	get inspectorMetadata() {
 		return this.agentRegistry.inspectorMetadata;
@@ -5247,12 +5370,12 @@ var CopilotKitCore = class {
 	/**
 	* Lazily creates, starts, and context-syncs the core-owned memory store on
 	* first access, then returns it. Subsequent calls return the existing store.
-	* The store is constructed with a bound `globalThis.fetch` and immediately
-	* has its runtime context synced from the current connection state.
+	* The store uses the Core Runtime fetch so REST and single-route transports
+	* share the same resource behavior. Its Runtime context is synced at once.
 	*/
 	ensureMemoryStore() {
 		if (!this._memoryStore) {
-			this._memoryStore = createMemoryStore({ fetch: globalThis.fetch.bind(globalThis) });
+			this._memoryStore = createMemoryStore({ fetch: this.ɵruntimeFetch });
 			this._memoryStore.start();
 			this.syncMemoryContext();
 		}