@copilotkit/runtime 1.64.2-canary.rc-1 → 1.64.2

package/dist/v2/runtime/core/channel-manager.mjs

@@ -1,6 +1,8 @@
 import "reflect-metadata";
 import { ChannelConfigError, deriveChannelActivationConfig } from "./channel-activation-config.mjs";
+import { EMPTY } from "rxjs";
 import { randomUUID } from "node:crypto";
+import { AbstractAgent, EventType } from "@ag-ui/client";
 
 //#region src/v2/runtime/core/channel-manager.ts
 /**
@@ -45,7 +47,7 @@ const CHANNELS_INTELLIGENCE_SPECIFIER = "@copilotkit/channels-intelligence";
 *   transport-level drop diagnostics are not silent in the managed path.
 * @returns The launcher's {@link ChannelsHandle}.
 */
-async function defaultActivateChannel(config, channel, importChannelsIntelligence = () => import(CHANNELS_INTELLIGENCE_SPECIFIER), log) {
+async function defaultActivateChannel(config, channel, importChannelsIntelligence = () => import(CHANNELS_INTELLIGENCE_SPECIFIER), log, services) {
 	let mod;
 	try {
 		mod = await importChannelsIntelligence();
@@ -53,6 +55,7 @@ async function defaultActivateChannel(config, channel, importChannelsIntelligenc
 		if (isModuleNotFound(err)) throw new Error("Managed Channels require '@copilotkit/channels-intelligence' to be installed. Add it to your app's dependencies.", { cause: err });
 		throw err;
 	}
+	if (!services) throw new Error("Managed Channels require the runtime AgentRunner and Intelligence client");
 	return mod.startChannelsOverRealtimeGateway([channel], {
 		wsUrl: config.wsUrl,
 		apiKey: config.apiKey,
@@ -62,10 +65,202 @@ async function defaultActivateChannel(config, channel, importChannelsIntelligenc
 		},
 		runtimeInstanceId: config.runtimeInstanceId,
 		adapter: config.adapter,
+		...config.showToolStatus !== void 0 ? { showToolStatus: config.showToolStatus } : {},
+		...config.replyContinuation !== void 0 ? { replyContinuation: config.replyContinuation } : {},
 		appApiBaseUrl: config.apiUrl,
-		...log ? { log } : {}
+		...log ? { log } : {},
+		runCanonical: (args) => runCanonicalChannelAgent(services.runner, services.intelligence, services.lockTtlSeconds ?? 20, services.lockHeartbeatIntervalSeconds ?? 15, args, services.lockKeyPrefix),
+		loadHistory: async ({ deliveryId, threadId, appUserId }) => {
+			const history = await services.intelligence.getThreadMessages({
+				threadId,
+				userId: appUserId,
+				channelDeliveryId: deliveryId
+			});
+			return Promise.all(history.messages.map((message) => toAgentMessage(message, services.intelligence)));
+		}
 	});
 }
+/** One outer agent that lets the standard runner own the whole local tool loop. */
+var ChannelOuterAgent = class extends AbstractAgent {
+	constructor(inner, canonicalThreadId, executeLoop) {
+		super({
+			threadId: inner.threadId,
+			initialMessages: inner.messages,
+			initialState: inner.state,
+			...inner.agentId ? { agentId: inner.agentId } : {}
+		});
+		this.inner = inner;
+		this.canonicalThreadId = canonicalThreadId;
+		this.executeLoop = executeLoop;
+	}
+	run() {
+		return EMPTY;
+	}
+	async runAgent(parameters, subscriber) {
+		if (!parameters?.runId) throw new Error("Canonical Channel run requires a runId");
+		return {
+			result: await this.executeLoop(subscriber ?? {}, {
+				threadId: this.canonicalThreadId,
+				runId: parameters.runId
+			}),
+			newMessages: []
+		};
+	}
+	abortRun() {
+		this.inner.abortRun();
+	}
+};
+/** Drive one public Channel run through the runtime's existing AgentRunner. */
+async function runCanonicalChannelAgent(runner, intelligence, lockTtlSeconds, lockHeartbeatIntervalSeconds, args, lockKeyPrefix) {
+	const lock = await intelligence.ɵacquireThreadLock({
+		threadId: args.threadId,
+		runId: args.runId,
+		userId: args.userId,
+		agentId: args.agentId,
+		channelDeliveryId: args.deliveryId,
+		ttlSeconds: lockTtlSeconds,
+		...lockKeyPrefix !== void 0 ? { lockKeyPrefix } : {}
+	});
+	const canonicalThreadId = lock.threadId;
+	const canonicalRunId = lock.runId;
+	let result = {
+		iterations: 0,
+		interrupted: false
+	};
+	const outer = new ChannelOuterAgent(args.agent, canonicalThreadId, async (subscriber, canonicalRun) => {
+		result = await args.execute(subscriber, canonicalRun);
+		return result;
+	});
+	let stopPromise;
+	let heartbeatError;
+	let heartbeatTimer;
+	const stopCanonicalRun = () => {
+		stopPromise ??= Promise.resolve().then(() => runner.stop({
+			threadId: canonicalThreadId,
+			runId: canonicalRunId
+		})).catch(() => false);
+	};
+	const abortCanonicalRun = () => {
+		try {
+			args.agent.abortRun();
+		} catch {}
+		stopCanonicalRun();
+	};
+	args.signal?.addEventListener("abort", abortCanonicalRun, { once: true });
+	heartbeatTimer = setInterval(() => {
+		intelligence.ɵrenewThreadLock({
+			threadId: canonicalThreadId,
+			runId: canonicalRunId,
+			ttlSeconds: lockTtlSeconds,
+			...lockKeyPrefix !== void 0 ? { lockKeyPrefix } : {}
+		}).catch((error) => {
+			if (heartbeatTimer === void 0) return;
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = void 0;
+			heartbeatError = error;
+			try {
+				args.agent.abortRun();
+			} catch {}
+			stopCanonicalRun();
+		});
+	}, lockHeartbeatIntervalSeconds * 1e3);
+	heartbeatTimer.unref?.();
+	try {
+		await new Promise((resolve, reject) => {
+			let terminalError;
+			runner.run({
+				threadId: canonicalThreadId,
+				agent: outer,
+				input: {
+					threadId: canonicalThreadId,
+					runId: canonicalRunId,
+					messages: args.agent.messages,
+					state: args.agent.state,
+					tools: [...args.tools],
+					context: [...args.context],
+					forwardedProps: void 0
+				},
+				persistedInputMessages: args.persistedInputMessages
+			}).subscribe({
+				next: (event) => {
+					if (event.type !== EventType.RUN_ERROR || terminalError) return;
+					const message = "message" in event && typeof event.message === "string" ? event.message : "Canonical Channel agent run failed";
+					terminalError = new Error(message);
+					terminalError.name = "ChannelCanonicalRunError";
+					if ("code" in event && typeof event.code === "string" && event.code.length > 0) terminalError.code = event.code;
+				},
+				error: reject,
+				complete: () => {
+					if (terminalError) reject(terminalError);
+					else resolve();
+				}
+			});
+			if (args.signal?.aborted) abortCanonicalRun();
+		});
+	} finally {
+		args.signal?.removeEventListener("abort", abortCanonicalRun);
+		if (heartbeatTimer !== void 0) {
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = void 0;
+		}
+		await intelligence.ɵcleanupThreadLock({
+			threadId: canonicalThreadId,
+			runId: canonicalRunId
+		}).catch(() => void 0);
+	}
+	if (heartbeatError !== void 0) {
+		await stopPromise;
+		throw heartbeatError;
+	}
+	return result;
+}
+/** Convert canonical Intelligence history into AG-UI messages. */
+async function toAgentMessage(message, intelligence) {
+	const content = await hydrateManagedContent(message.content, intelligence);
+	return {
+		id: message.id,
+		role: message.role,
+		content: content ?? "",
+		...message.activityType ? { activityType: message.activityType } : {},
+		...message.toolCalls ? { toolCalls: message.toolCalls.map((call) => ({
+			id: call.id,
+			type: "function",
+			function: {
+				name: call.name,
+				arguments: call.args
+			}
+		})) } : {},
+		...message.toolCallId ? { toolCallId: message.toolCallId } : {}
+	};
+}
+/** Resolves managed asset references only at the authorized Runtime boundary. */
+async function hydrateManagedContent(content, intelligence) {
+	if (Array.isArray(content)) return Promise.all(content.map(async (part) => {
+		if (typeof part !== "object" || part === null || !("source" in part) || typeof part.source !== "object" || part.source === null || !("value" in part.source) || typeof part.source.value !== "string" || !part.source.value.startsWith("cpki-asset://")) return part;
+		const assetId = part.source.value.slice(13);
+		const asset = await intelligence.ɵgetManagedChannelAsset(assetId);
+		return {
+			...part,
+			source: {
+				type: "data",
+				value: Buffer.from(asset.bytes).toString("base64"),
+				mimeType: asset.mimeType ?? ("mimeType" in part.source && typeof part.source.mimeType === "string" ? part.source.mimeType : "application/octet-stream")
+			}
+		};
+	}));
+	if (typeof content === "object" && content !== null && "assetId" in content && typeof content.assetId === "string") {
+		const asset = await intelligence.ɵgetManagedChannelAsset(content.assetId);
+		return {
+			...content,
+			source: {
+				type: "data",
+				value: Buffer.from(asset.bytes).toString("base64"),
+				mimeType: asset.mimeType ?? ("mimeType" in content && typeof content.mimeType === "string" ? content.mimeType : "application/octet-stream")
+			}
+		};
+	}
+	return content;
+}
 /** Whether `err` signals a missing managed provider rather than a hard failure. */
 function isSetupRequired(err) {
 	return err instanceof ChannelSetupRequiredError || typeof err === "object" && err !== null && err.code === "SETUP_REQUIRED";
@@ -83,6 +278,8 @@ function isModuleNotFound(err) {
 }
 /** Default deadline (ms) for a single `handle.stop()` during teardown. */
 const DEFAULT_STOP_HANDLE_TIMEOUT_MS = 5e3;
+/** Default cadence (ms) for the "still down" log while a session is dropped. */
+const DEFAULT_RECONNECT_LOG_INTERVAL_MS = 3e4;
 /**
 * Reject with `timeoutMessage` after `timeoutMs` if `inner` has not settled,
 * otherwise pass `inner` through. When `timeoutMs` is undefined, `inner` is
@@ -125,15 +322,12 @@ function withTimeout(inner, timeoutMs, timeoutMessage) {
 * and {@link ready} rather than thrown.
 *
 * Reconnection is NOT handled here — it is delegated to the Phoenix connection
-* layer that backs the launcher. When a managed socket drops, Phoenix's `Socket`
-* auto-reconnects and auto-rejoins, re-sending the channel's join declaration;
-* the Intelligence gateway's `join/3` re-runs `record_heartbeat` (re-registering
-* the runtime's listener) and its `terminate/2` releases the dead socket's
-* leases (verified against Intelligence #511 `sdk_channel.ex`). So the transport
-* self-heals under the persistent adapter and a re-activation here would be both
-* redundant AND broken: re-invoking the engine on an already-started `Channel`
-* throws in `channel.addAdapter` (started=true). The manager therefore never
-* re-activates on a drop.
+* layer that backs the launcher. When a managed control socket drops, Phoenix's
+* `Socket` reconnects and rejoins with the same Runtime declaration. Active
+* deliveries request fresh one-use join tokens through that control link. A
+* re-activation here would be both redundant AND broken: re-invoking the engine
+* on an already-started `Channel` throws in `channel.addAdapter` (started=true).
+* The manager therefore never re-activates on a drop.
 *
 * It DOES, however, reflect real connection health through the session's
 * `onStateChange` observer so {@link ChannelManager.status} stays honest rather
@@ -148,11 +342,22 @@ var ChannelManager = class {
 		this.activated = false;
 		this.stopped = false;
 		this.intelligence = args.intelligence;
+		this.runner = args.runner;
+		this.lockTtlSeconds = args.lockTtlSeconds ?? 20;
+		this.lockHeartbeatIntervalSeconds = args.lockHeartbeatIntervalSeconds ?? 15;
+		this.lockKeyPrefix = args.lockKeyPrefix;
 		this.channels = args.channels;
 		this.log = args.log;
-		this.activateChannel = args.activateChannel ?? ((config, channel) => defaultActivateChannel(config, channel, void 0, this.log));
+		this.activateChannel = args.activateChannel ?? ((config, channel) => defaultActivateChannel(config, channel, void 0, this.log, this.runner ? {
+			runner: this.runner,
+			intelligence: this.intelligence,
+			lockTtlSeconds: this.lockTtlSeconds,
+			lockHeartbeatIntervalSeconds: this.lockHeartbeatIntervalSeconds,
+			...this.lockKeyPrefix !== void 0 ? { lockKeyPrefix: this.lockKeyPrefix } : {}
+		} : void 0));
 		this.mintRuntimeInstanceId = args.mintRuntimeInstanceId ?? (() => `rti_${randomUUID().replace(/-/g, "")}`);
 		this.stopHandleTimeoutMs = args.stopHandleTimeoutMs ?? DEFAULT_STOP_HANDLE_TIMEOUT_MS;
+		this.reconnectLogIntervalMs = args.reconnectLogIntervalMs ?? DEFAULT_RECONNECT_LOG_INTERVAL_MS;
 	}
 	/**
 	* Start activation of every declared Channel (lazy + idempotent). Mints a
@@ -410,8 +615,7 @@ var ChannelManager = class {
 	*
 	* - `reconnecting` → status `reconnecting` (dropped, Phoenix retrying);
 	* - `online` → status `online` (rejoined, sendable again);
-	* - `gave_up` → status `error` (dead after the bounded reconnect window);
-	* - `fenced` → status `error` immediately (another activation superseded it).
+	* - `gave_up` → status `error` (dead after the bounded reconnect window).
 	*
 	* Makes NO re-activation — reconnection is delegated to the Phoenix connection
 	* layer (see {@link ChannelManager}), which auto-rejoins under the persistent
@@ -423,23 +627,55 @@ var ChannelManager = class {
 	* @param entry - The Channel's activation entry.
 	*/
 	registerConnectionObserver(name, entry) {
-		entry.handle?.onStateChange?.((state) => {
+		entry.handle?.onStateChange?.((state, detail) => {
 			if (this.stopped || entry.status === "stopped") return;
+			const cause = detail?.reason ?? detail?.code;
+			const because = cause !== void 0 ? ` — ${cause}` : "";
 			if (state === "reconnecting") {
 				entry.status = "reconnecting";
-				this.log?.(`channel "${name}" managed session dropped; reconnecting (Phoenix auto-rejoin)`);
+				entry.downSince ??= Date.now();
+				this.log?.(`channel "${name}" managed session dropped; reconnecting (Phoenix auto-rejoin)${because}`);
+				this.startReconnectLog(name, entry);
 			} else if (state === "online") {
 				entry.status = "online";
+				this.clearReconnectLog(entry);
+				entry.downSince = void 0;
 				this.log?.(`channel "${name}" managed session back online`);
 			} else if (state === "gave_up") {
 				entry.status = "error";
-				this.log?.(`channel "${name}" managed session gave up reconnecting; marking error`);
-			} else {
-				entry.status = "error";
-				this.log?.(`channel "${name}" managed session was generation-fenced by a replacement; marking error`);
+				this.log?.(`channel "${name}" managed session gave up reconnecting after ${this.downFor(entry)}; marking error (still retrying — a successful rejoin restores online)${because}`);
 			}
 		});
 	}
+	/** Rendered downtime for this outage episode (`"45s"`), or `"unknown"`. */
+	downFor(entry) {
+		return entry.downSince === void 0 ? "unknown" : `${Math.round((Date.now() - entry.downSince) / 1e3)}s`;
+	}
+	/**
+	* Repeat a "still down" line for as long as this outage lasts. Runs THROUGH
+	* `gave_up` on purpose: that transition is where the old behavior went quiet,
+	* and an operator watching a silent process cannot tell a dead bot from an
+	* idle one.
+	*/
+	startReconnectLog(name, entry) {
+		if (entry.reconnectLogTimer !== void 0) return;
+		const timer = setInterval(() => {
+			if (this.stopped || entry.status === "stopped") {
+				this.clearReconnectLog(entry);
+				return;
+			}
+			this.log?.(`channel "${name}" managed session still down after ${this.downFor(entry)}; Phoenix is retrying`);
+		}, this.reconnectLogIntervalMs);
+		timer.unref?.();
+		entry.reconnectLogTimer = timer;
+	}
+	/** Stop this entry's "still down" repeat, if one is running. */
+	clearReconnectLog(entry) {
+		if (entry.reconnectLogTimer !== void 0) {
+			clearInterval(entry.reconnectLogTimer);
+			entry.reconnectLogTimer = void 0;
+		}
+	}
 	/**
 	* Drive a single entry to its terminal `stopped` state, tearing down its
 	* handle AT MOST ONCE. Idempotent: it always sets `status = "stopped"`, and
@@ -477,6 +713,7 @@ var ChannelManager = class {
 	*/
 	async stopEntry(entry) {
 		entry.status = "stopped";
+		this.clearReconnectLog(entry);
 		if (entry.handle && !entry.handleStopped) {
 			entry.handleStopped = true;
 			const handle = entry.handle;