@nextclaw/kernel 0.6.14 → 0.6.16

package/dist/index.js

@@ -5,8 +5,8 @@ import { APP_NAME, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, CLEAR_THINKING_TOK
 import { NCP_AI_EXECUTION_METADATA_KEY, NcpEventType, createUnavailableNcpAiExecutionMetadata, normalizeAssistantText, readNcpAiExecutionMetadata, sanitizeAssistantReplyTags } from "@nextclaw/ncp";
 import { LocalAssetStore, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, ncpMessageToOpenAiMessages, validateToolArgs } from "@nextclaw/ncp-agent-runtime";
 import { createHash, createHmac, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
-import { CHAT_INLINE_TOKENS_METADATA_KEY, CHAT_SESSION_MATERIALIZATION_METADATA_KEY, CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND, CHAT_WORKSPACE_FILE_TOKEN_KIND, EventBus, Ingress, PANEL_APP_INLINE_HOST_CONTRACT, eventKeys, ingressKeys, isRuntimeDefaultModelValue, normalizeRuntimeModelSelectionMode, readInlineContentHeight } from "@nextclaw/shared";
-import { catchError, from, lastValueFrom, tap } from "rxjs";
+import { CHAT_INLINE_TOKENS_METADATA_KEY, CHAT_INLINE_TOKENS_SCHEMA_VERSION, CHAT_SESSION_MATERIALIZATION_METADATA_KEY, CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND, CHAT_WORKSPACE_FILE_TOKEN_KIND, EventBus, Ingress, PANEL_APP_INLINE_HOST_CONTRACT, eventKeys, ingressKeys, isRuntimeDefaultModelValue, normalizeRuntimeModelSelectionMode, readInlineContentHeight } from "@nextclaw/shared";
+import { catchError, filter, from, lastValueFrom, tap } from "rxjs";
 import { appendFileSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { execFileSync, spawn } from "node:child_process";
@@ -692,7 +692,11 @@ function createUnavailableAiExecutionMetadataEvent(params) {
 	};
 }
 //#endregion
-//#region src/managers/agent-run-request.manager.ts
+//#region src/utils/agent-run-request.utils.ts
+function readOptionalString$11(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
 function toAgentRunRequest(envelope) {
 	const metadata = envelope.metadata ?? {};
 	const peerId = readOptionalString$11(envelope.peerId);
@@ -730,26 +734,21 @@ function toAgentRunRequest(envelope) {
 	const messageSessionId = readOptionalString$11(sourceMessage.sessionId);
 	const sessionId = envelopeSessionId ?? messageSessionId;
 	if (sessionId && peerId) throw new Error("agent-run.send cannot accept both sessionId and peerId.");
-	const message = {
-		...sourceMessage,
-		sessionId: sessionId ?? "",
-		id: sourceMessage.id ?? `user-message-${randomUUID()}`,
-		role: sourceMessage.role ?? "user",
-		status: sourceMessage.status ?? "final",
-		timestamp: sourceMessage.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-		parts: structuredClone(sourceMessage.parts)
-	};
 	return {
 		...requestMetadata,
 		sessionId,
 		peerId,
-		message
+		message: {
+			...sourceMessage,
+			sessionId: sessionId ?? "",
+			id: sourceMessage.id ?? `user-message-${randomUUID()}`,
+			role: sourceMessage.role ?? "user",
+			status: sourceMessage.status ?? "final",
+			timestamp: sourceMessage.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+			parts: structuredClone(sourceMessage.parts)
+		}
 	};
 }
-function readOptionalString$11(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
 function createCompletedAssistantMessageEvent(params) {
 	return {
 		occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -761,6 +760,17 @@ function createCompletedAssistantMessageEvent(params) {
 		}
 	};
 }
+function createMessageSentEvent(params) {
+	return {
+		occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		type: NcpEventType.MessageSent,
+		payload: {
+			sessionId: params.sessionId,
+			message: params.message,
+			correlationId: params.correlationId
+		}
+	};
+}
 function createSyntheticRunErrorEvent(params) {
 	const { correlationId, error, runId, sessionId, startedAt } = params;
 	const endedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -807,19 +817,16 @@ function readMessageTask(message) {
 	return message.parts.flatMap((part) => (part.type === "text" || part.type === "rich-text" || part.type === "reasoning") && part.text.trim() ? [part.text.trim()] : [])[0] ?? "Session";
 }
 function resolveRunSpec(params) {
-	const { agentManager, configManager, request, runId, session } = params;
-	const modelSource = request.model !== void 0 ? "request" : session.model !== void 0 ? "session" : "default";
-	const model = request.model ?? session.model ?? configManager.getDefaultModel();
-	const agentId = request.agentId ?? session.agentId ?? agentManager.getDefaultAgentId();
+	const { defaultAgentId, model, modelMaxTokens, request, runId, session } = params;
 	return {
-		modelSource,
+		modelSource: request.model !== void 0 ? "request" : session.model !== void 0 ? "session" : "default",
 		spec: {
 			runId,
 			runtimeId: session.agentRuntimeId,
-			agentId,
+			agentId: request.agentId ?? session.agentId ?? defaultAgentId,
 			model,
 			requestedModel: request.model ?? null,
-			maxTokens: request.maxTokens ?? configManager.getModelMaxTokens(model),
+			maxTokens: request.maxTokens ?? modelMaxTokens,
 			thinkingEffort: request.thinkingEffort ?? session.thinkingEffort ?? null,
 			correlationId: request.correlationId
 		}
@@ -850,8 +857,11 @@ function attachRunSpecMetadata(params) {
 		metadata
 	};
 }
+//#endregion
+//#region src/managers/agent-run-request.manager.ts
 var AgentRunRequestManager = class {
 	cleanups = [];
+	observedSessionRuns = /* @__PURE__ */ new Set();
 	started = false;
 	constructor(agentRuntimeManager, agentManager, configManager, contextProviderManager, eventBus, ingress, sessionManager, sessionRunManager, toolProviderManager) {
 		this.agentRuntimeManager = agentRuntimeManager;
@@ -871,8 +881,18 @@ var AgentRunRequestManager = class {
 	};
 	dispose = () => {
 		while (this.cleanups.length > 0) this.cleanups.pop()?.();
+		this.observedSessionRuns.clear();
 		this.started = false;
 	};
+	listQueuedInputs = (sessionId) => {
+		return this.sessionRunManager.getSessionRun(sessionId)?.listQueuedRequests().map(this.toQueuedInput) ?? [];
+	};
+	removeQueuedInput = (sessionId, queuedInputId) => {
+		const removed = this.sessionRunManager.getSessionRun(sessionId)?.removeQueuedRequest(queuedInputId) ?? null;
+		if (!removed) return null;
+		this.publishRunQueueUpdated(sessionId);
+		return this.toQueuedInput(removed);
+	};
 	handleSendRequest = async (envelope) => {
 		if (!envelope.payload) throw new Error("Invalid agent run send request.");
 		return toRunHandle(await this.send(toAgentRunRequest(envelope.payload)));
@@ -899,41 +919,46 @@ var AgentRunRequestManager = class {
 	};
 	send = async (request) => {
 		const session = await this.getOrCreateSessionForRequest(request);
-		const sessionRun = this.sessionRunManager.getSessionRun(session.sessionId) ?? await this.sessionRunManager.createSessionRun(session.sessionId);
+		const sessionRun = await this.sessionRunManager.getOrCreateSessionRun(session.sessionId);
+		this.observeSessionRun(sessionRun);
 		const baseMessage = {
 			...request.message,
 			sessionId: session.sessionId
 		};
-		let stopPublishingRunStatus = () => void 0;
-		stopPublishingRunStatus = sessionRun.onStatusChange((status) => {
-			this.eventBus.emit(eventKeys.sessionRunStatus, {
-				sessionKey: sessionRun.sessionId,
-				status
-			}, {
-				emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				source: "agent-run-request"
-			});
-			if (status === "idle") stopPublishingRunStatus();
-		});
-		this.cleanups.push(stopPublishingRunStatus);
+		const queuedRequest = sessionRun.enqueueRequest({
+			...request,
+			sessionId: session.sessionId,
+			message: baseMessage
+		}, session);
+		const activeRequest = sessionRun.beginNextRun();
+		this.publishRunQueueUpdated(session.sessionId);
+		if (activeRequest?.id === queuedRequest.id) await this.startQueuedRun(sessionRun, activeRequest);
+		else if (activeRequest) this.startQueuedRun(sessionRun, activeRequest).catch(() => void 0);
+		return {
+			sessionId: session.sessionId,
+			userMessageId: queuedRequest.request.message.id,
+			runId: activeRequest?.id === queuedRequest.id ? activeRequest.runId : null,
+			correlationId: request.correlationId
+		};
+	};
+	startQueuedRun = async (sessionRun, activeRequest) => {
+		const { request, session } = activeRequest;
 		const requestRunStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const activeRun = (() => {
-			try {
-				return sessionRun.beginRun();
-			} catch (error) {
-				stopPublishingRunStatus();
-				throw error;
-			}
-		})();
+		const model = request.model ?? session.model ?? this.configManager.getDefaultModel();
 		const { modelSource, spec } = resolveRunSpec({
-			agentManager: this.agentManager,
-			configManager: this.configManager,
+			defaultAgentId: this.agentManager.getDefaultAgentId(),
+			model,
+			modelMaxTokens: this.configManager.getModelMaxTokens(model),
 			request,
-			runId: activeRun.runId,
+			runId: activeRequest.runId,
 			session
 		});
 		const message = attachRunSpecMetadata({
-			message: baseMessage,
+			message: {
+				...request.message,
+				sessionId: session.sessionId,
+				timestamp: requestRunStartedAt
+			},
 			modelSource,
 			request,
 			session,
@@ -945,32 +970,44 @@ var AgentRunRequestManager = class {
 			sessionId: session.sessionId,
 			message
 		};
-		sessionRun.inbox.enqueue(message);
-		const runtime = this.agentRuntimeManager.getOrCreate({
-			agentRuntimeId: session.agentRuntimeId,
-			session,
-			sessionRun
+		const messageSentEvent = createMessageSentEvent({
+			sessionId: session.sessionId,
+			message,
+			correlationId: request.correlationId
 		});
-		const contextBlocks = await this.contextProviderManager.buildContext(providerRequest);
-		const tools = await this.toolProviderManager.buildTools(providerRequest);
-		this.startRuntimeRun({
-			options: {
-				contextBlocks,
+		await sessionRun.applyEvents([messageSentEvent]);
+		this.publishNcpEvent(messageSentEvent);
+		try {
+			const runtime = this.agentRuntimeManager.getOrCreate({
+				agentRuntimeId: session.agentRuntimeId,
 				session,
+				sessionRun
+			});
+			const contextBlocks = await this.contextProviderManager.buildContext(providerRequest);
+			const tools = await this.toolProviderManager.buildTools(providerRequest);
+			sessionRun.inbox.enqueue(message);
+			this.startRuntimeRun({
+				options: {
+					contextBlocks,
+					session,
+					sessionRun,
+					signal: activeRequest.signal,
+					tools
+				},
+				requestRunStartedAt,
+				runtime,
+				spec
+			});
+		} catch (error) {
+			await this.publishRunStartupFailure({
+				error,
+				requestRunStartedAt,
 				sessionRun,
-				signal: activeRun.signal,
-				tools
-			},
-			requestRunStartedAt,
-			runtime,
-			spec
-		});
-		return {
-			sessionId: session.sessionId,
-			userMessageId: message.id,
-			runId: spec.runId,
-			correlationId: request.correlationId
-		};
+				spec
+			});
+			this.startNextQueuedRun(sessionRun);
+			throw error;
+		}
 	};
 	startRuntimeRun = (params) => {
 		const { options, requestRunStartedAt, runtime, spec } = params;
@@ -979,7 +1016,7 @@ var AgentRunRequestManager = class {
 		let executionMetadataSeen = false;
 		let runtimeFailed = false;
 		let runStartedAt = requestRunStartedAt;
-		lastValueFrom(from(runtime.run(spec, options)).pipe(tap((event) => {
+		lastValueFrom(from(runtime.run(spec, options)).pipe(filter((event) => event.type !== NcpEventType.MessageSent), tap((event) => {
 			const eventsToPublish = [];
 			if (event.type === NcpEventType.RunError) runtimeFailed = true;
 			if (hasAiExecutionMetadata(event)) executionMetadataSeen = true;
@@ -996,10 +1033,7 @@ var AgentRunRequestManager = class {
 				messageCompletedSeen = true;
 			}
 			eventsToPublish.push(event);
-			for (const eventToPublish of eventsToPublish) this.eventBus.emit(eventKeys.ncpEvent, eventToPublish, {
-				emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				source: "agent-run-request"
-			});
+			eventsToPublish.forEach(this.publishNcpEvent);
 		}), catchError(async (error) => {
 			runtimeFailed = true;
 			if (!executionMetadataSeen) {
@@ -1008,10 +1042,7 @@ var AgentRunRequestManager = class {
 					sessionId: session.sessionId
 				});
 				await sessionRun.applyEvents([metadataEvent]);
-				this.eventBus.emit(eventKeys.ncpEvent, metadataEvent, {
-					emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					source: "agent-run-request"
-				});
+				this.publishNcpEvent(metadataEvent);
 			}
 			const event = createSyntheticRunErrorEvent({
 				error,
@@ -1021,19 +1052,75 @@ var AgentRunRequestManager = class {
 				startedAt: runStartedAt
 			});
 			await sessionRun.applyEvents([event]);
-			this.eventBus.emit(eventKeys.ncpEvent, event, {
-				emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				source: "agent-run-request"
-			});
-		})), { defaultValue: void 0 }).finally(() => {
-			if (!runtimeFailed) return;
-			this.agentRuntimeManager.disposeRuntime({
+			this.publishNcpEvent(event);
+		})), { defaultValue: void 0 }).finally(async () => {
+			if (runtimeFailed) await this.agentRuntimeManager.disposeRuntime({
 				agentRuntimeId: session.agentRuntimeId,
 				session,
 				sessionRun
 			}).catch(() => void 0);
+			this.startNextQueuedRun(sessionRun);
+		});
+	};
+	publishRunStartupFailure = async (params) => {
+		const { error, requestRunStartedAt, sessionRun, spec } = params;
+		const metadataEvent = createUnavailableAiExecutionMetadataEvent({
+			spec,
+			sessionId: sessionRun.sessionId
+		});
+		const errorEvent = createSyntheticRunErrorEvent({
+			error,
+			runId: spec.runId,
+			sessionId: sessionRun.sessionId,
+			correlationId: spec.correlationId,
+			startedAt: requestRunStartedAt
 		});
+		await sessionRun.applyEvents([metadataEvent, errorEvent]);
+		this.publishNcpEvent(metadataEvent);
+		this.publishNcpEvent(errorEvent);
 	};
+	startNextQueuedRun = (sessionRun) => {
+		const nextRequest = sessionRun.beginNextRun();
+		if (!nextRequest) return;
+		this.publishRunQueueUpdated(sessionRun.sessionId);
+		this.startQueuedRun(sessionRun, nextRequest).catch(() => void 0);
+	};
+	observeSessionRun = (sessionRun) => {
+		if (this.observedSessionRuns.has(sessionRun)) return;
+		this.observedSessionRuns.add(sessionRun);
+		const stop = sessionRun.onStatusChange((status) => {
+			this.eventBus.emit(eventKeys.sessionRunStatus, {
+				sessionKey: sessionRun.sessionId,
+				status
+			}, {
+				emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				source: "agent-run-request"
+			});
+		});
+		this.cleanups.push(() => {
+			stop();
+			this.observedSessionRuns.delete(sessionRun);
+		});
+	};
+	publishRunQueueUpdated = (sessionId) => {
+		this.eventBus.emit(eventKeys.sessionRunQueueUpdated, { sessionKey: sessionId }, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "agent-run-request"
+		});
+	};
+	publishNcpEvent = (event) => {
+		this.eventBus.emit(eventKeys.ncpEvent, event, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "agent-run-request"
+		});
+	};
+	toQueuedInput = (queuedRequest) => ({
+		id: queuedRequest.id,
+		sessionId: queuedRequest.request.message.sessionId,
+		enqueuedAt: queuedRequest.enqueuedAt,
+		message: structuredClone(queuedRequest.request.message),
+		metadata: structuredClone(queuedRequest.request.metadata ?? {})
+	});
 	getOrCreateSessionForRequest = async (request) => {
 		const sessionMaterialization = readSessionMaterialization(request.metadata ?? {});
 		if (sessionMaterialization && (request.sessionId || request.peerId)) throw new Error("session_materialization requires a new session request.");
@@ -7344,6 +7431,7 @@ var SessionRun = class {
 	inbox = new MessageInbox();
 	sessionId;
 	statusListeners = /* @__PURE__ */ new Set();
+	queuedRequests = [];
 	activeRunId = null;
 	activeRunController = null;
 	constructor(seed, stateManager = new DefaultNcpAgentConversationStateManager()) {
@@ -7369,32 +7457,52 @@ var SessionRun = class {
 			this.statusListeners.delete(listener);
 		};
 	};
-	beginRun = () => {
-		if (this.activeRunId) throw new Error(`Session ${this.sessionId} already has an active run.`);
-		const wasRunning = this.isRunning();
-		const runId = `agent-run-${randomUUID()}`;
+	enqueueRequest = (request, session) => {
+		const wasBusy = this.isBusy();
+		const queuedRequest = {
+			id: `queued-input-${randomUUID()}`,
+			runId: `agent-run-${randomUUID()}`,
+			enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			request: structuredClone(request),
+			session: structuredClone(session)
+		};
+		this.queuedRequests.push(queuedRequest);
+		this.emitStatusChangeIfNeeded(wasBusy);
+		return structuredClone(queuedRequest);
+	};
+	listQueuedRequests = () => structuredClone(this.queuedRequests);
+	removeQueuedRequest = (queuedRequestId) => {
+		const index = this.queuedRequests.findIndex(({ id }) => id === queuedRequestId);
+		if (index < 0) return null;
+		const wasBusy = this.isBusy();
+		const [removed] = this.queuedRequests.splice(index, 1);
+		this.emitStatusChangeIfNeeded(wasBusy);
+		return removed ? structuredClone(removed) : null;
+	};
+	beginNextRun = () => {
+		if (this.activeRunId) return null;
+		const wasBusy = this.isBusy();
+		const queuedRequest = this.queuedRequests.shift();
+		if (!queuedRequest) return null;
 		const controller = new AbortController();
-		this.activeRunId = runId;
+		this.activeRunId = queuedRequest.runId;
 		this.activeRunController = controller;
-		this.emitStatusChangeIfNeeded(wasRunning);
+		this.emitStatusChangeIfNeeded(wasBusy);
 		return {
-			runId,
+			...structuredClone(queuedRequest),
 			signal: controller.signal
 		};
 	};
 	abortRun = (runId, reason) => {
 		if (!this.activeRunId || !this.activeRunController) return false;
 		if (runId && this.activeRunId !== runId) return false;
-		const wasRunning = this.isRunning();
 		this.activeRunController.abort(reason);
-		this.activeRunController = null;
-		this.activeRunId = null;
-		this.emitStatusChangeIfNeeded(wasRunning);
 		return true;
 	};
 	isRunning = () => this.activeRunId !== null;
+	isBusy = () => this.isRunning() || this.queuedRequests.length > 0;
 	dispose = () => {
-		const wasRunning = this.isRunning();
+		const wasBusy = this.isBusy();
 		this.activeRunController?.abort({
 			code: "abort-error",
 			message: "Session run owner was disposed; the current run was cancelled.",
@@ -7402,33 +7510,46 @@ var SessionRun = class {
 		});
 		this.activeRunController = null;
 		this.activeRunId = null;
-		this.emitStatusChangeIfNeeded(wasRunning);
+		this.queuedRequests.length = 0;
+		this.emitStatusChangeIfNeeded(wasBusy);
 		this.statusListeners.clear();
 	};
 	applyRunEvents = (events) => {
-		const wasRunning = this.isRunning();
+		const wasBusy = this.isBusy();
 		for (const event of events) {
 			if (event.type === NcpEventType.RunStarted && event.payload.runId) this.activeRunId = event.payload.runId;
-			if ((event.type === NcpEventType.RunFinished || event.type === NcpEventType.RunError) && (!event.payload.runId || event.payload.runId === this.activeRunId)) {
+			if ((event.type === NcpEventType.MessageAbort || event.type === NcpEventType.RunFinished || event.type === NcpEventType.RunError) && (!event.payload.runId || event.payload.runId === this.activeRunId)) {
 				this.activeRunId = null;
 				this.activeRunController = null;
 			}
 		}
-		this.emitStatusChangeIfNeeded(wasRunning);
+		this.emitStatusChangeIfNeeded(wasBusy);
 	};
-	emitStatusChangeIfNeeded = (wasRunning) => {
-		const running = this.isRunning();
-		if (running === wasRunning) return;
-		for (const listener of [...this.statusListeners]) listener(running ? "running" : "idle");
+	emitStatusChangeIfNeeded = (wasBusy) => {
+		const busy = this.isBusy();
+		if (busy === wasBusy) return;
+		for (const listener of [...this.statusListeners]) listener(busy ? "running" : "idle");
 	};
 };
 var SessionRunManager = class {
 	runs = /* @__PURE__ */ new Map();
+	pendingCreations = /* @__PURE__ */ new Map();
 	constructor(sessionManager) {
 		this.sessionManager = sessionManager;
 	}
 	getSessionRun = (sessionId) => this.runs.get(sessionId) ?? null;
-	isSessionRunning = (sessionId) => this.runs.get(sessionId.trim())?.isRunning() ?? false;
+	isSessionRunning = (sessionId) => this.runs.get(sessionId.trim())?.isBusy() ?? false;
+	getOrCreateSessionRun = async (sessionId) => {
+		const existing = this.getSessionRun(sessionId);
+		if (existing) return existing;
+		const pending = this.pendingCreations.get(sessionId);
+		if (pending) return await pending;
+		const creation = this.createSessionRun(sessionId).finally(() => {
+			this.pendingCreations.delete(sessionId);
+		});
+		this.pendingCreations.set(sessionId, creation);
+		return await creation;
+	};
 	createSessionRun = async (sessionId) => {
 		if (this.runs.has(sessionId)) throw new Error(`Session run already exists: ${sessionId}`);
 		const run = new SessionRun({
@@ -7447,6 +7568,7 @@ var SessionRunManager = class {
 	dispose = () => {
 		for (const run of this.runs.values()) run.dispose();
 		this.runs.clear();
+		this.pendingCreations.clear();
 	};
 };
 //#endregion
@@ -9494,7 +9616,6 @@ var NcpAgentRuntimeWrapper = class {
 		const messages = sessionRun.inbox.drain();
 		let executionMetadataSeen = false;
 		try {
-			for (const event of this.toMessageSentEvents(messages, spec, sessionRun.sessionId)) yield await this.applyEvent(sessionRun, event);
 			const input = {
 				sessionId: sessionRun.sessionId,
 				runId: spec.runId,
@@ -9545,15 +9666,6 @@ var NcpAgentRuntimeWrapper = class {
 		});
 		return this.runtime;
 	};
-	toMessageSentEvents = (messages, spec, sessionId) => messages.map((message) => ({
-		occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-		type: NcpEventType.MessageSent,
-		payload: {
-			sessionId,
-			message,
-			correlationId: spec.correlationId
-		}
-	}));
 	buildMetadata = (session, spec) => ({
 		...session.metadata,
 		agentId: spec.agentId,
@@ -10386,21 +10498,21 @@ function readString$2(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function readWorkspaceReferences(metadata) {
-	const rawTokens = metadata?.[CHAT_INLINE_TOKENS_METADATA_KEY];
-	if (!Array.isArray(rawTokens)) return [];
+	const raw = metadata?.[CHAT_INLINE_TOKENS_METADATA_KEY];
+	const rawTokens = Array.isArray(raw) ? raw : isRecord$2(raw) && raw.schemaVersion === CHAT_INLINE_TOKENS_SCHEMA_VERSION && Array.isArray(raw.items) ? raw.items : null;
+	if (!rawTokens) return [];
 	const references = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const rawToken of rawTokens) {
 		if (!isRecord$2(rawToken)) continue;
-		const token = rawToken;
-		const kind = token.kind === CHAT_WORKSPACE_FILE_TOKEN_KIND ? CHAT_WORKSPACE_FILE_TOKEN_KIND : token.kind === CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND ? CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND : null;
-		const key = readString$2(token.key);
+		const kind = rawToken.kind === CHAT_WORKSPACE_FILE_TOKEN_KIND ? CHAT_WORKSPACE_FILE_TOKEN_KIND : rawToken.kind === CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND ? CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND : null;
+		const key = readString$2(rawToken.key);
 		if (!kind || !key || seen.has(`${kind}:${key}`)) continue;
 		seen.add(`${kind}:${key}`);
 		references.push({
 			kind,
 			key,
-			label: readString$2(token.label) ?? key
+			label: readString$2(rawToken.label) ?? key
 		});
 	}
 	return references;