@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.0

package/dist/runtime/runner/intelligence.mjs

@@ -0,0 +1,616 @@
+import { AgentRunner, ThreadAlreadyRunningError } from "./agent-runner.mjs";
+import { AG_UI_CHANNEL_EVENT, finalizeRunEvents, logger, phoenixExponentialBackoff, stripIntelligenceRoutingFields } from "@copilotkit/shared";
+import { Observable } from "rxjs";
+import { EventType } from "@ag-ui/client";
+import { Socket } from "phoenix";
+import { randomUUID as randomUUID$1 } from "node:crypto";
+
+//#region src/runtime/runner/intelligence.ts
+const MAX_CONSECUTIVE_SOCKET_ERRORS = 5;
+const EVENT_RETRY_BASE_MS = 100;
+const EVENT_RETRY_MAX_MS = 2e3;
+const RUNNER_EVENT_BATCH_CAPABILITY = "runner_event_batch_v1";
+const MAX_RUNNER_EVENT_BATCH_SIZE = 32;
+const RUNNER_EVENT_BATCH_FLUSH_MS = 5;
+const EVENT_DURABILITY_DEADLINE_MS = 6e4;
+var IntelligenceAgentRunner = class extends AgentRunner {
+	constructor(options) {
+		super();
+		this.threads = /* @__PURE__ */ new Map();
+		this.options = options;
+	}
+	/**
+	* Create a new Phoenix socket with explicit exponential backoff.
+	*
+	* Each run/connect gets its own socket so that:
+	*  - A socket failure only affects a single thread, not all threads.
+	*  - Cleanup is simple: channel.leave() + socket.disconnect() tears
+	*    down everything for that run with no shared-state concerns.
+	*  - Each run gets its own independent retry budget.
+	*
+	* reconnectAfterMs — delay before Phoenix reconnects the WebSocket
+	*   after an unclean close. 100ms base, doubling up to maxReconnectMs (default 10s).
+	*
+	* rejoinAfterMs — delay before Phoenix re-joins a channel that
+	*   entered the "errored" state. 1s base, doubling up to maxRejoinMs (default 30s).
+	*
+	* These are set explicitly because Phoenix's default schedule is a
+	* fixed stepped array (not exponential), and any code that calls
+	* socket.disconnect() in an onError handler will set
+	* closeWasClean = true and reset the reconnect timer — permanently
+	* killing retries.
+	*
+	* heartbeatIntervalMs — how often Phoenix pings the server
+	*   (default 15s). Phoenix's own default is 30s, which equals a common
+	*   reverse-proxy WebSocket idle timeout (e.g. Azure Application Gateway
+	*   behind AGIC), so a run that emits no events for 30s would have its
+	*   socket dropped by the proxy. The proxy timeout must exceed this value.
+	*/
+	createSocket(authToken = this.options.authToken) {
+		const socket = new Socket(this.options.url, {
+			...authToken ? { authToken } : {},
+			reconnectAfterMs: phoenixExponentialBackoff(100, this.options.maxReconnectMs ?? 1e4),
+			rejoinAfterMs: phoenixExponentialBackoff(1e3, this.options.maxRejoinMs ?? 3e4),
+			heartbeatIntervalMs: this.options.heartbeatIntervalMs ?? 15e3
+		});
+		socket.connect();
+		return socket;
+	}
+	createRunnerEventPayload(event, request, state) {
+		const payload = { ...this.stampRunnerMetadata(this.stampCanonicalRunOwnership(event, request), state) };
+		payload.threadId = request.threadId;
+		payload.runId = request.input.runId;
+		payload.thread_id = request.threadId;
+		payload.run_id = request.input.runId;
+		return payload;
+	}
+	stampCanonicalRunOwnership(event, request) {
+		const eventRecord = event;
+		eventRecord.threadId = request.threadId;
+		eventRecord.runId = request.input.runId;
+		return eventRecord;
+	}
+	/** Remove agent-controlled durable identity before the runtime assigns it. */
+	withoutAgentEventIdentity(event) {
+		const source = event;
+		const metadata = { ...source.metadata };
+		delete metadata.cpki_event_id;
+		delete metadata.cpki_event_seq;
+		return {
+			...source,
+			metadata
+		};
+	}
+	stampRunnerMetadata(event, state) {
+		const eventRecord = event;
+		const existingMetadata = eventRecord.metadata ?? {};
+		const hasEventId = typeof existingMetadata.cpki_event_id === "string";
+		const hasEventSeq = typeof existingMetadata.cpki_event_seq === "number";
+		if (hasEventId && hasEventSeq) {
+			const eventSeq = existingMetadata.cpki_event_seq;
+			state.nextEventSeq = Math.max(state.nextEventSeq, eventSeq + 1);
+			return eventRecord;
+		}
+		const eventSeq = state.nextEventSeq++;
+		eventRecord.metadata = {
+			...existingMetadata,
+			cpki_event_id: typeof existingMetadata.cpki_event_id === "string" ? existingMetadata.cpki_event_id : randomUUID$1(),
+			cpki_event_seq: eventSeq
+		};
+		return eventRecord;
+	}
+	run(request) {
+		return this.createRunObservable(request);
+	}
+	runWithStartupBoundary(request) {
+		let resolveStartup;
+		let rejectStartup;
+		const startup = new Promise((resolve, reject) => {
+			resolveStartup = resolve;
+			rejectStartup = reject;
+		});
+		return {
+			events: this.createRunObservable(request, {
+				resolveStartup: () => resolveStartup?.(),
+				rejectStartup: (error) => rejectStartup?.(error)
+			}),
+			startup
+		};
+	}
+	createRunObservable(request, startupBoundary) {
+		const { threadId, agent, input } = request;
+		if (this.threads.get(threadId)?.isRunning) throw new ThreadAlreadyRunningError();
+		return new Observable((observer) => {
+			if (this.threads.get(threadId)?.isRunning) {
+				observer.error(new ThreadAlreadyRunningError());
+				return;
+			}
+			const socket = this.createSocket(request.authToken);
+			const channel = socket.channel(`ingestion:${input.runId}`, {
+				thread_id: threadId,
+				run_id: input.runId
+			});
+			let cancelRun;
+			const cancellation = new Promise((resolve) => {
+				cancelRun = resolve;
+			});
+			let resolveCompletion;
+			const completion = new Promise((resolve) => {
+				resolveCompletion = resolve;
+			});
+			const state = {
+				threadId,
+				runId: input.runId,
+				socket,
+				channel,
+				isRunning: true,
+				stopRequested: false,
+				agent,
+				currentEvents: [],
+				nextEventSeq: 1,
+				hasRunStarted: false,
+				hasJoined: false,
+				supportsRunnerEventBatch: false,
+				producerFinished: false,
+				cancellation,
+				cancelRun,
+				completion,
+				resolveCompletion,
+				stopTimer: null,
+				pendingEvents: /* @__PURE__ */ new Map(),
+				activeEventBatch: null,
+				nextEventPushAttempt: 0,
+				eventRetryTimer: null,
+				eventFlushTimer: null,
+				eventDeadlineTimer: null,
+				socketReconnectWatchdog: null,
+				eventRetryAttempt: 0,
+				completeRun: () => observer.complete(),
+				failRun: (error) => {
+					startupBoundary?.rejectStartup(error);
+					observer.error(error);
+				}
+			};
+			this.threads.set(threadId, state);
+			let consecutiveSocketErrors = 0;
+			let plannedRestart = false;
+			socket.onClose((event) => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				plannedRestart = plannedRestart || event?.code === 1012;
+				if (state.socketReconnectWatchdog === null) state.socketReconnectWatchdog = setTimeout(() => {
+					state.socketReconnectWatchdog = null;
+					if (!state.isRunning || socket.isConnected()) return;
+					socket.disconnect(() => {
+						if (state.isRunning && !socket.isConnected()) socket.connect();
+					});
+				}, 1e3);
+			});
+			socket.onOpen(() => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				if (state.socketReconnectWatchdog !== null) {
+					clearTimeout(state.socketReconnectWatchdog);
+					state.socketReconnectWatchdog = null;
+				}
+				consecutiveSocketErrors = 0;
+				plannedRestart = false;
+			});
+			socket.onError(() => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				if (plannedRestart || state.hasJoined) return;
+				consecutiveSocketErrors += 1;
+				if (consecutiveSocketErrors >= MAX_CONSECUTIVE_SOCKET_ERRORS) state.agent?.abortRun();
+			});
+			channel.on(AG_UI_CHANNEL_EVENT, (payload) => {
+				if (this.isCurrentThreadState(threadId, state) && payload.type === EventType.CUSTOM && payload.name === "stop") this.stop({
+					threadId,
+					runId: state.runId
+				}).catch((error) => {
+					logger.error({
+						err: error,
+						threadId,
+						runId: state.runId
+					}, "Failed to stop Intelligence run");
+				});
+			});
+			channel.join().receive("ok", (response) => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				const supportsRunnerEventBatch = this.supportsRunnerEventBatch(response);
+				const activeEventBatch = state.supportsRunnerEventBatch === supportsRunnerEventBatch ? state.activeEventBatch : null;
+				state.supportsRunnerEventBatch = supportsRunnerEventBatch;
+				if (state.hasJoined) {
+					this.resetPendingEventRetry(state);
+					if (activeEventBatch !== null) {
+						state.activeEventBatch = activeEventBatch;
+						this.retryActiveEventBatch(state);
+					} else this.replayPendingEvents(state);
+					return;
+				}
+				state.hasJoined = true;
+				startupBoundary?.resolveStartup();
+				this.executeAgentRun(request, state, threadId, (event) => {
+					observer.next(stripIntelligenceRoutingFields(event));
+				});
+			}).receive("error", (resp) => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				if (state.hasJoined) {
+					if (this.isPermanentEventFailure(resp)) {
+						const reason = typeof resp.reason === "string" ? `: ${resp.reason}` : "";
+						this.failThread(threadId, state, /* @__PURE__ */ new Error(`Gateway permanently rejected channel rejoin${reason}`));
+					}
+					return;
+				}
+				if (this.isRetryableJoinError(resp)) return;
+				const error = /* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(resp)}`);
+				const errorEvent = {
+					type: EventType.RUN_ERROR,
+					message: error.message,
+					code: "CHANNEL_JOIN_ERROR"
+				};
+				observer.next(errorEvent);
+				state.currentEvents.push(errorEvent);
+				this.removeThread(threadId, state);
+				startupBoundary?.rejectStartup(error);
+				observer.complete();
+			}).receive("timeout", () => {
+				if (!this.isCurrentThreadState(threadId, state)) return;
+				if (state.hasJoined) return;
+				const error = /* @__PURE__ */ new Error("Timed out joining channel");
+				const errorEvent = {
+					type: EventType.RUN_ERROR,
+					message: error.message,
+					code: "CHANNEL_JOIN_TIMEOUT"
+				};
+				observer.next(errorEvent);
+				state.currentEvents.push(errorEvent);
+				this.removeThread(threadId, state);
+				startupBoundary?.rejectStartup(error);
+				observer.complete();
+			});
+			return () => {
+				this.removeThread(threadId, state);
+			};
+		});
+	}
+	connect(request) {
+		const { threadId } = request;
+		return new Observable((observer) => {
+			const socket = this.createSocket();
+			const channel = socket.channel(`thread:${threadId}`);
+			channel.on("ag_ui_event", (payload) => {
+				observer.next(payload);
+				if (payload.type === EventType.RUN_FINISHED || payload.type === EventType.RUN_ERROR) observer.complete();
+			});
+			const cleanup = () => {
+				channel.leave();
+				socket.disconnect();
+			};
+			channel.join().receive("ok", () => void 0).receive("error", (resp) => {
+				observer.error(/* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(resp)}`));
+				cleanup();
+			}).receive("timeout", () => {
+				observer.error(/* @__PURE__ */ new Error("Timed out joining channel"));
+				cleanup();
+			});
+			return () => {
+				cleanup();
+			};
+		});
+	}
+	isRunning(request) {
+		const state = this.threads.get(request.threadId);
+		return Promise.resolve(state?.isRunning ?? false);
+	}
+	/** Stops this run and waits until its terminal events have been acknowledged. */
+	stop(request) {
+		const state = this.threads.get(request.threadId);
+		if (!state || !state.isRunning || state.stopRequested) return Promise.resolve(false);
+		if (request.runId !== void 0 && state.runId !== request.runId) return Promise.resolve(false);
+		state.stopRequested = true;
+		state.cancelRun();
+		state.stopTimer = setTimeout(() => {
+			this.failThread(state.threadId, state, /* @__PURE__ */ new Error("Timed out stopping Intelligence run"));
+		}, EVENT_DURABILITY_DEADLINE_MS);
+		if (state.agent) {
+			try {
+				state.agent.abortRun();
+			} catch {}
+			if (typeof state.agent.detachActiveRun === "function") try {
+				Promise.resolve(state.agent.detachActiveRun()).catch((error) => {
+					logger.warn({
+						err: error,
+						threadId: state.threadId,
+						runId: state.runId
+					}, "Failed to detach stopped agent");
+				});
+			} catch (error) {
+				logger.warn({
+					err: error,
+					threadId: state.threadId,
+					runId: state.runId
+				}, "Failed to detach stopped agent");
+			}
+		}
+		return state.completion.then((completed) => {
+			if (!completed) throw new Error("Intelligence run stopped before terminal events were acknowledged");
+			return true;
+		});
+	}
+	async executeAgentRun(request, state, threadId, onRunError) {
+		const { currentEvents } = state;
+		const pushCanonicalEvent = (event) => {
+			if (!this.isCurrentThreadState(threadId, state)) return;
+			const canonicalEvent = this.stampRunnerMetadata(this.stampCanonicalRunOwnership(this.withoutAgentEventIdentity(event), request), state);
+			currentEvents.push(canonicalEvent);
+			if (canonicalEvent.type === EventType.RUN_STARTED) state.hasRunStarted = true;
+			this.queueRunnerEvent(this.createRunnerEventPayload(canonicalEvent, request, state), state);
+			if (canonicalEvent.type === EventType.RUN_ERROR) onRunError(canonicalEvent);
+		};
+		const getPersistedInputMessages = () => request.persistedInputMessages ?? request.input.messages;
+		const buildRunStartedEvent = (source) => {
+			const baseInput = source?.input ?? request.input;
+			const persistedInputMessages = getPersistedInputMessages();
+			const event = source ?? {
+				type: EventType.RUN_STARTED,
+				threadId: request.threadId,
+				runId: request.input.runId
+			};
+			event.threadId = request.threadId;
+			event.runId = request.input.runId;
+			event.input = {
+				...baseInput,
+				threadId: request.threadId,
+				runId: request.input.runId,
+				...persistedInputMessages !== void 0 ? { messages: persistedInputMessages } : {}
+			};
+			return event;
+		};
+		const ensureRunStarted = () => {
+			if (!state.hasRunStarted) {
+				state.hasRunStarted = true;
+				pushCanonicalEvent(buildRunStartedEvent());
+			}
+		};
+		try {
+			if (state.stopRequested) return;
+			const backendThreadId = request.backendThreadId ?? request.threadId;
+			request.agent.threadId = backendThreadId;
+			await Promise.race([request.agent.runAgent(request.input, { onEvent: ({ event }) => {
+				if (state.stopRequested || state.producerFinished) return;
+				if (event.type === EventType.RUN_STARTED) {
+					pushCanonicalEvent(buildRunStartedEvent(event));
+					return;
+				}
+				ensureRunStarted();
+				pushCanonicalEvent(event);
+			} }), state.cancellation]);
+		} catch (error) {
+			if (state.stopRequested || !this.isCurrentThreadState(threadId, state)) return;
+			ensureRunStarted();
+			if (!currentEvents.find((event) => event.type === EventType.RUN_ERROR)) pushCanonicalEvent({
+				type: EventType.RUN_ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		} finally {
+			if (!this.isCurrentThreadState(threadId, state)) return;
+			ensureRunStarted();
+			const appended = finalizeRunEvents(currentEvents, {
+				stopRequested: state.stopRequested,
+				protocolVersion: request.input.protocolVersion
+			});
+			for (const event of appended) pushCanonicalEvent(event);
+			state.producerFinished = true;
+			this.completeWhenDurable(threadId, state);
+		}
+	}
+	/** Queue one immutable event payload until Redis-backed gateway acknowledgement. */
+	queueRunnerEvent(payload, state) {
+		if (!this.isCurrentThreadState(state.threadId, state)) return;
+		const eventId = this.runnerEventId(payload);
+		if (!state.pendingEvents.has(eventId)) state.pendingEvents.set(eventId, {
+			payload: structuredClone(payload),
+			queuedAt: Date.now()
+		});
+		this.scheduleEventDeadline(state);
+		this.replayPendingEvents(state);
+	}
+	pushPendingEventBatch(eventIds, events, state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || this.failIfEventDeadlineExceeded(state) || state.channel.state !== "joined" || !state.socket.isConnected()) return;
+		const attempt = ++state.nextEventPushAttempt;
+		state.activeEventBatch = {
+			eventIds,
+			attempt
+		};
+		const payloads = events.map((event) => event.payload);
+		const isBatch = state.supportsRunnerEventBatch;
+		state.channel.push(isBatch ? "events" : "event", isBatch ? { events: payloads } : payloads[0]).receive("ok", () => {
+			if (!this.isCurrentThreadState(state.threadId, state) || state.activeEventBatch?.attempt !== attempt) return;
+			if (this.failIfEventDeadlineExceeded(state)) return;
+			for (const eventId of eventIds) state.pendingEvents.delete(eventId);
+			state.activeEventBatch = null;
+			state.eventRetryAttempt = 0;
+			if (state.pendingEvents.size === 0) {
+				this.clearPendingEventRetry(state);
+				this.clearPendingEventFlush(state);
+			}
+			this.scheduleEventDeadline(state);
+			this.completeWhenDurable(state.threadId, state);
+			this.replayPendingEvents(state);
+		}).receive("error", (response) => this.handlePendingEventFailure(state, attempt, response)).receive("timeout", () => this.handlePendingEventFailure(state, attempt));
+	}
+	handlePendingEventFailure(state, attempt, response) {
+		if (!this.isCurrentThreadState(state.threadId, state) || state.activeEventBatch?.attempt !== attempt) return;
+		if (this.failIfEventDeadlineExceeded(state)) return;
+		if (this.isPermanentEventFailure(response)) {
+			const reason = typeof response === "object" && response !== null && typeof response.reason === "string" ? response.reason : "permanent_gateway_rejection";
+			this.failThread(state.threadId, state, /* @__PURE__ */ new Error(`Runner event durability failed: ${reason}`));
+			return;
+		}
+		this.schedulePendingEventRetry(state);
+	}
+	schedulePendingEventRetry(state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || state.pendingEvents.size === 0 || state.eventRetryTimer !== null) return;
+		const delay = Math.min(EVENT_RETRY_BASE_MS * 2 ** state.eventRetryAttempt, EVENT_RETRY_MAX_MS);
+		state.eventRetryAttempt += 1;
+		state.eventRetryTimer = setTimeout(() => {
+			state.eventRetryTimer = null;
+			if (!this.isCurrentThreadState(state.threadId, state) || state.pendingEvents.size === 0) return;
+			this.retryActiveEventBatch(state);
+		}, delay);
+	}
+	clearPendingEventRetry(state) {
+		if (state.eventRetryTimer !== null) {
+			clearTimeout(state.eventRetryTimer);
+			state.eventRetryTimer = null;
+		}
+	}
+	schedulePendingEventFlush(state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || state.pendingEvents.size === 0 || state.activeEventBatch !== null || state.eventFlushTimer !== null) return;
+		const oldestQueuedAt = Math.min(...[...state.pendingEvents.values()].map((event) => event.queuedAt));
+		const delay = Math.max(0, oldestQueuedAt + RUNNER_EVENT_BATCH_FLUSH_MS - Date.now());
+		state.eventFlushTimer = setTimeout(() => {
+			state.eventFlushTimer = null;
+			if (!this.isCurrentThreadState(state.threadId, state)) return;
+			this.flushPendingEventBatch(state);
+		}, delay);
+	}
+	clearPendingEventFlush(state) {
+		if (state.eventFlushTimer !== null) {
+			clearTimeout(state.eventFlushTimer);
+			state.eventFlushTimer = null;
+		}
+	}
+	resetPendingEventRetry(state) {
+		this.clearPendingEventRetry(state);
+		this.clearPendingEventFlush(state);
+		state.eventRetryAttempt = 0;
+		state.activeEventBatch = null;
+	}
+	replayPendingEvents(state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || state.activeEventBatch !== null) return;
+		const pendingEvents = [...state.pendingEvents.entries()].sort(([, left], [, right]) => this.runnerEventSeq(left.payload) - this.runnerEventSeq(right.payload));
+		if (pendingEvents.length === 0) return;
+		const batchSize = state.supportsRunnerEventBatch ? MAX_RUNNER_EVENT_BATCH_SIZE : 1;
+		if (!state.supportsRunnerEventBatch || pendingEvents.length >= batchSize) {
+			this.clearPendingEventFlush(state);
+			const batch = pendingEvents.slice(0, batchSize);
+			this.pushPendingEventBatch(batch.map(([eventId]) => eventId), batch.map(([, event]) => event), state);
+			return;
+		}
+		this.schedulePendingEventFlush(state);
+	}
+	flushPendingEventBatch(state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || state.activeEventBatch !== null || state.pendingEvents.size === 0) return;
+		const batch = [...state.pendingEvents.entries()].sort(([, left], [, right]) => this.runnerEventSeq(left.payload) - this.runnerEventSeq(right.payload)).slice(0, MAX_RUNNER_EVENT_BATCH_SIZE);
+		this.pushPendingEventBatch(batch.map(([eventId]) => eventId), batch.map(([, event]) => event), state);
+	}
+	retryActiveEventBatch(state) {
+		if (!this.isCurrentThreadState(state.threadId, state) || this.failIfEventDeadlineExceeded(state)) return;
+		const activeBatch = state.activeEventBatch;
+		if (activeBatch === null) {
+			this.replayPendingEvents(state);
+			return;
+		}
+		const events = activeBatch.eventIds.map((eventId) => state.pendingEvents.get(eventId)).filter((event) => event !== void 0);
+		if (events.length !== activeBatch.eventIds.length) {
+			state.activeEventBatch = null;
+			this.replayPendingEvents(state);
+			return;
+		}
+		this.pushPendingEventBatch(activeBatch.eventIds, events, state);
+	}
+	completeWhenDurable(threadId, state) {
+		if (!this.isCurrentThreadState(threadId, state) || !state.producerFinished || state.pendingEvents.size !== 0) return;
+		if (this.threads.get(threadId) !== state) return;
+		this.removeThread(threadId, state, true);
+		state.completeRun();
+	}
+	runnerEventId(payload) {
+		return payload.metadata.cpki_event_id;
+	}
+	runnerEventSeq(payload) {
+		return payload.metadata.cpki_event_seq;
+	}
+	supportsRunnerEventBatch(response) {
+		if (typeof response !== "object" || response === null) return false;
+		const capabilities = response.capabilities;
+		return Array.isArray(capabilities) && capabilities.includes(RUNNER_EVENT_BATCH_CAPABILITY);
+	}
+	isRetryableJoinError(response) {
+		if (typeof response !== "object" || response === null) return false;
+		const value = response;
+		if (value.retryable === false) return false;
+		return value.retryable === true || value.reason === "gateway_draining";
+	}
+	isPermanentEventFailure(response) {
+		return typeof response === "object" && response !== null && response.retryable === false;
+	}
+	scheduleEventDeadline(state) {
+		if (state.eventDeadlineTimer !== null) {
+			clearTimeout(state.eventDeadlineTimer);
+			state.eventDeadlineTimer = null;
+		}
+		if (!this.isCurrentThreadState(state.threadId, state) || state.pendingEvents.size === 0) return;
+		const deadline = Math.min(...[...state.pendingEvents.values()].map((event) => event.queuedAt)) + EVENT_DURABILITY_DEADLINE_MS;
+		state.eventDeadlineTimer = setTimeout(() => {
+			state.eventDeadlineTimer = null;
+			if (!this.isCurrentThreadState(state.threadId, state)) return;
+			if (!this.failIfEventDeadlineExceeded(state)) this.scheduleEventDeadline(state);
+		}, Math.max(0, deadline - Date.now()));
+	}
+	failThread(threadId, state, error) {
+		if (!this.isCurrentThreadState(threadId, state)) return;
+		this.removeThread(threadId, state);
+		try {
+			state.agent?.abortRun();
+		} catch {}
+		state.failRun(error);
+	}
+	failIfEventDeadlineExceeded(state) {
+		if (state.pendingEvents.size === 0) return false;
+		const oldestQueuedAt = Math.min(...[...state.pendingEvents.values()].map((event) => event.queuedAt));
+		if (Date.now() < oldestQueuedAt + EVENT_DURABILITY_DEADLINE_MS) return false;
+		this.failThread(state.threadId, state, /* @__PURE__ */ new Error("Timed out trying to durably deliver runner events"));
+		return true;
+	}
+	isCurrentThreadState(threadId, state) {
+		return state.isRunning && this.threads.get(threadId) === state;
+	}
+	/**
+	* Tear down all resources for a thread: leave the channel,
+	* disconnect the per-run socket, and remove the thread state.
+	*
+	* Idempotent — safe to call multiple times for the same threadId
+	* (e.g. from join error handlers, finalize, and Observable teardown).
+	*/
+	removeThread(threadId, state, completed = false) {
+		if (this.threads.get(threadId) !== state) return;
+		this.threads.delete(threadId);
+		state.isRunning = false;
+		state.resolveCompletion(completed);
+		if (state.stopTimer !== null) {
+			clearTimeout(state.stopTimer);
+			state.stopTimer = null;
+		}
+		this.clearPendingEventRetry(state);
+		this.clearPendingEventFlush(state);
+		if (state.eventDeadlineTimer !== null) {
+			clearTimeout(state.eventDeadlineTimer);
+			state.eventDeadlineTimer = null;
+		}
+		state.activeEventBatch = null;
+		if (state.socketReconnectWatchdog !== null) {
+			clearTimeout(state.socketReconnectWatchdog);
+			state.socketReconnectWatchdog = null;
+		}
+		try {
+			state.channel.leave();
+		} catch {}
+		try {
+			state.socket.disconnect();
+		} catch {}
+	}
+};
+
+//#endregion
+export { IntelligenceAgentRunner };
+//# sourceMappingURL=intelligence.mjs.map