@nextclaw/ncp-toolkit 0.5.0 → 0.5.2

package/dist/index.js

@@ -1,1562 +1,1282 @@
-// src/agent/agent-conversation-state-manager.ts
-import {
-  NcpEventType
-} from "@nextclaw/ncp";
-
-// src/agent/agent-conversation-message-normalizer.ts
-import { sanitizeAssistantReplyTags } from "@nextclaw/ncp";
+import { NcpEventType, isHiddenNcpMessage, sanitizeAssistantReplyTags } from "@nextclaw/ncp";
+//#region src/agent/agent-conversation-message-normalizer.ts
 function cloneConversationMessage(message) {
-  return {
-    ...message,
-    parts: [...message.parts],
-    metadata: message.metadata ? { ...message.metadata } : void 0
-  };
+	return {
+		...message,
+		parts: [...message.parts],
+		metadata: message.metadata ? { ...message.metadata } : void 0
+	};
 }
 function normalizeConversationMessage(message) {
-  return cloneConversationMessage(sanitizeAssistantReplyTags(message));
+	return cloneConversationMessage(sanitizeAssistantReplyTags(message));
 }
-
-// src/agent/agent-conversation-state-manager.utils.ts
+//#endregion
+//#region src/agent/agent-conversation-state-manager.utils.ts
 function buildRuntimeError(payload) {
-  const message = payload.error?.trim();
-  return {
-    code: "runtime-error",
-    message: message && message.length > 0 ? message : "Agent run failed.",
-    details: {
-      sessionId: payload.sessionId,
-      messageId: payload.messageId,
-      threadId: payload.threadId,
-      runId: payload.runId
-    }
-  };
+	const message = payload.error?.trim();
+	return {
+		code: "runtime-error",
+		message: message && message.length > 0 ? message : "Agent run failed.",
+		details: {
+			sessionId: payload.sessionId,
+			messageId: payload.messageId,
+			threadId: payload.threadId,
+			runId: payload.runId
+		}
+	};
 }
 function shouldPromoteStreamingMessageId(message, nextMessageId) {
-  if (!nextMessageId.trim()) {
-    return false;
-  }
-  if (message.id.startsWith("tool-")) {
-    return true;
-  }
-  return message.parts.some((part) => part.type === "tool-invocation");
+	if (!nextMessageId.trim()) return false;
+	if (message.id.startsWith("tool-")) return true;
+	return message.parts.some((part) => part.type === "tool-invocation");
 }
 function remapTrackedToolCallsToMessageId(toolCallMessageIdByCallId, fromMessageId, toMessageId) {
-  for (const [toolCallId, trackedMessageId] of toolCallMessageIdByCallId) {
-    if (trackedMessageId !== fromMessageId) {
-      continue;
-    }
-    toolCallMessageIdByCallId.set(toolCallId, toMessageId);
-  }
+	for (const [toolCallId, trackedMessageId] of toolCallMessageIdByCallId) {
+		if (trackedMessageId !== fromMessageId) continue;
+		toolCallMessageIdByCallId.set(toolCallId, toMessageId);
+	}
 }
 function clearToolCallTrackingByMessageId(toolCallMessageIdByCallId, toolCallArgsRawByCallId, messageId) {
-  for (const [toolCallId, trackedMessageId] of toolCallMessageIdByCallId) {
-    if (trackedMessageId !== messageId) {
-      continue;
-    }
-    toolCallMessageIdByCallId.delete(toolCallId);
-    toolCallArgsRawByCallId.delete(toolCallId);
-  }
+	for (const [toolCallId, trackedMessageId] of toolCallMessageIdByCallId) {
+		if (trackedMessageId !== messageId) continue;
+		toolCallMessageIdByCallId.delete(toolCallId);
+		toolCallArgsRawByCallId.delete(toolCallId);
+	}
 }
 function findToolInvocationPart(parts, toolCallId) {
-  for (let index = parts.length - 1; index >= 0; index -= 1) {
-    const part = parts[index];
-    if (part.type === "tool-invocation" && part.toolCallId === toolCallId) {
-      return part;
-    }
-  }
-  return null;
+	for (let index = parts.length - 1; index >= 0; index -= 1) {
+		const part = parts[index];
+		if (part.type === "tool-invocation" && part.toolCallId === toolCallId) return part;
+	}
+	return null;
 }
 function findToolNameByCallId(parts, toolCallId) {
-  const part = findToolInvocationPart(parts, toolCallId);
-  return part?.toolName ?? null;
+	return findToolInvocationPart(parts, toolCallId)?.toolName ?? null;
 }
 function upsertToolInvocationPart(parts, toolPart) {
-  const nextParts = [...parts];
-  for (let index = nextParts.length - 1; index >= 0; index -= 1) {
-    const part = nextParts[index];
-    if (part.type === "tool-invocation" && part.toolCallId === toolPart.toolCallId) {
-      nextParts[index] = {
-        ...part,
-        ...toolPart
-      };
-      return nextParts;
-    }
-  }
-  nextParts.push(toolPart);
-  return nextParts;
+	const nextParts = [...parts];
+	for (let index = nextParts.length - 1; index >= 0; index -= 1) {
+		const part = nextParts[index];
+		if (part.type === "tool-invocation" && part.toolCallId === toolPart.toolCallId) {
+			nextParts[index] = {
+				...part,
+				...toolPart
+			};
+			return nextParts;
+		}
+	}
+	nextParts.push(toolPart);
+	return nextParts;
 }
-
-// src/agent/agent-conversation-state-manager.ts
-var DEFAULT_ASSISTANT_ROLE = "assistant";
+//#endregion
+//#region src/agent/agent-conversation-state-manager.ts
+const DEFAULT_ASSISTANT_ROLE = "assistant";
 var DefaultNcpAgentConversationStateManager = class {
-  messages = [];
-  streamingMessage = null;
-  error = null;
-  activeRun = null;
-  listeners = /* @__PURE__ */ new Set();
-  toolCallMessageIdByCallId = /* @__PURE__ */ new Map();
-  toolCallArgsRawByCallId = /* @__PURE__ */ new Map();
-  lastSettledRunId = null;
-  snapshotCache = null;
-  snapshotVersion = -1;
-  stateVersion = 0;
-  getSnapshot = () => {
-    if (this.snapshotCache && this.snapshotVersion === this.stateVersion) {
-      return this.snapshotCache;
-    }
-    const snapshot = {
-      messages: this.messages,
-      streamingMessage: this.streamingMessage,
-      error: this.error ? {
-        ...this.error,
-        details: this.error.details ? { ...this.error.details } : void 0
-      } : null,
-      activeRun: this.activeRun ? { ...this.activeRun } : null
-    };
-    this.snapshotCache = snapshot;
-    this.snapshotVersion = this.stateVersion;
-    return snapshot;
-  };
-  subscribe = (listener) => {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  };
-  reset = () => {
-    if (this.messages.length === 0 && !this.streamingMessage && !this.error && !this.activeRun && this.toolCallMessageIdByCallId.size === 0 && this.toolCallArgsRawByCallId.size === 0) {
-      return;
-    }
-    this.messages = [];
-    this.streamingMessage = null;
-    this.error = null;
-    this.activeRun = null;
-    this.toolCallMessageIdByCallId.clear();
-    this.toolCallArgsRawByCallId.clear();
-    this.lastSettledRunId = null;
-    this.stateVersion += 1;
-    this.notifyListeners();
-  };
-  hydrate = (payload) => {
-    this.messages = payload.messages.map(
-      (message) => normalizeConversationMessage(message)
-    );
-    this.streamingMessage = null;
-    this.error = null;
-    this.activeRun = payload.activeRun ? {
-      ...payload.activeRun,
-      sessionId: payload.activeRun.sessionId ?? payload.sessionId,
-      abortDisabledReason: payload.activeRun.abortDisabledReason ?? null
-    } : null;
-    this.toolCallMessageIdByCallId.clear();
-    this.toolCallArgsRawByCallId.clear();
-    this.lastSettledRunId = null;
-    this.stateVersion += 1;
-    this.notifyListeners();
-  };
-  dispatch = (event) => this.dispatchBatch([event]);
-  dispatchBatch = async (events) => {
-    if (!events.length) return;
-    const versionBeforeDispatch = this.stateVersion;
-    events.forEach(this.applyEvent);
-    if (this.stateVersion !== versionBeforeDispatch) this.notifyListeners();
-  };
-  applyEvent = (event) => {
-    switch (event.type) {
-      case NcpEventType.MessageSent:
-        this.handleMessageSent(event.payload);
-        break;
-      case NcpEventType.MessageAbort:
-        this.handleMessageAbort(event.payload);
-        break;
-      case NcpEventType.MessageTextStart:
-        this.handleMessageTextStart(event.payload);
-        break;
-      case NcpEventType.MessageTextDelta:
-        this.handleMessageTextDelta(event.payload);
-        break;
-      case NcpEventType.MessageTextEnd:
-        this.handleMessageTextEnd(event.payload);
-        break;
-      case NcpEventType.MessageReasoningStart:
-        this.handleMessageReasoningStart(event.payload);
-        break;
-      case NcpEventType.MessageReasoningDelta:
-        this.handleMessageReasoningDelta(event.payload);
-        break;
-      case NcpEventType.MessageReasoningEnd:
-        this.handleMessageReasoningEnd(event.payload);
-        break;
-      case NcpEventType.MessageToolCallStart:
-        this.handleMessageToolCallStart(event.payload);
-        break;
-      case NcpEventType.MessageToolCallArgs:
-        this.handleMessageToolCallArgs(event.payload);
-        break;
-      case NcpEventType.MessageToolCallArgsDelta:
-        this.handleMessageToolCallArgsDelta(event.payload);
-        break;
-      case NcpEventType.MessageToolCallEnd:
-        this.handleMessageToolCallEnd(event.payload);
-        break;
-      case NcpEventType.MessageToolCallResult:
-        this.handleMessageToolCallResult(event.payload);
-        break;
-      case NcpEventType.RunStarted:
-        this.handleRunStarted(event.payload);
-        break;
-      case NcpEventType.RunFinished:
-        this.handleRunFinished(event.payload);
-        break;
-      case NcpEventType.RunError:
-        this.handleRunError(event.payload);
-        break;
-      case NcpEventType.RunMetadata:
-        this.handleRunMetadata(event.payload);
-        break;
-      case NcpEventType.EndpointError:
-        this.handleEndpointError(event.payload);
-        break;
-      default:
-        break;
-    }
-  };
-  handleMessageSent = (payload) => {
-    this.upsertMessage(payload.message);
-    this.setError(null);
-  };
-  handleMessageAbort = (payload) => {
-    const targetMessageId = payload.messageId?.trim();
-    this.clearActiveRun();
-    this.setError(null);
-    if (this.streamingMessage && (!targetMessageId || this.streamingMessage.id === targetMessageId)) {
-      const streamingMessageId = this.streamingMessage.id;
-      this.upsertMessage({
-        ...this.streamingMessage,
-        status: "final"
-      });
-      this.replaceStreamingMessage(null);
-      if (targetMessageId) {
-        clearToolCallTrackingByMessageId(
-          this.toolCallMessageIdByCallId,
-          this.toolCallArgsRawByCallId,
-          targetMessageId
-        );
-      } else {
-        clearToolCallTrackingByMessageId(
-          this.toolCallMessageIdByCallId,
-          this.toolCallArgsRawByCallId,
-          streamingMessageId
-        );
-      }
-    }
-  };
-  handleMessageTextStart = (payload) => {
-    this.ensureStreamingMessage(
-      payload.sessionId,
-      payload.messageId,
-      "streaming"
-    );
-    this.setError(null);
-  };
-  handleMessageTextDelta = (payload) => {
-    if (!payload.delta) {
-      return;
-    }
-    const targetMessage = this.ensureStreamingMessage(
-      payload.sessionId,
-      payload.messageId,
-      "streaming"
-    );
-    const nextParts = [...targetMessage.parts];
-    const lastPart = nextParts[nextParts.length - 1];
-    if (lastPart?.type === "text") {
-      nextParts[nextParts.length - 1] = {
-        type: "text",
-        text: `${lastPart.text}${payload.delta}`
-      };
-    } else {
-      nextParts.push({ type: "text", text: payload.delta });
-    }
-    this.replaceStreamingMessage({
-      ...targetMessage,
-      parts: nextParts,
-      status: "streaming"
-    });
-  };
-  handleMessageTextEnd = (payload) => {
-    if (this.streamingMessage?.id !== payload.messageId) {
-      return;
-    }
-    if (this.streamingMessage.status !== "streaming") {
-      return;
-    }
-    this.replaceStreamingMessage({
-      ...this.streamingMessage,
-      status: "pending"
-    });
-  };
-  handleMessageReasoningStart = (payload) => {
-    this.ensureStreamingMessage(
-      payload.sessionId,
-      payload.messageId,
-      "streaming"
-    );
-  };
-  handleMessageReasoningDelta = (payload) => {
-    if (!payload.delta) {
-      return;
-    }
-    const targetMessage = this.ensureStreamingMessage(
-      payload.sessionId,
-      payload.messageId,
-      "streaming"
-    );
-    const nextParts = [...targetMessage.parts];
-    const lastPart = nextParts[nextParts.length - 1];
-    if (lastPart?.type === "reasoning") {
-      nextParts[nextParts.length - 1] = {
-        type: "reasoning",
-        text: `${lastPart.text}${payload.delta}`
-      };
-    } else {
-      nextParts.push({ type: "reasoning", text: payload.delta });
-    }
-    this.replaceStreamingMessage({
-      ...targetMessage,
-      parts: nextParts,
-      status: "streaming"
-    });
-  };
-  handleMessageReasoningEnd = (payload) => {
-    if (this.streamingMessage?.id !== payload.messageId) {
-      return;
-    }
-  };
-  handleMessageToolCallStart = (payload) => {
-    const targetMessage = this.resolveToolCallTargetMessage(
-      payload.sessionId,
-      payload.toolCallId,
-      payload.messageId
-    );
-    this.toolCallArgsRawByCallId.set(payload.toolCallId, "");
-    const nextParts = upsertToolInvocationPart(targetMessage.parts, {
-      type: "tool-invocation",
-      toolCallId: payload.toolCallId,
-      toolName: payload.toolName,
-      state: "partial-call",
-      args: ""
-    });
-    this.replaceStreamingMessage({
-      ...targetMessage,
-      parts: nextParts,
-      status: "streaming"
-    });
-    this.setError(null);
-  };
-  handleMessageToolCallArgs = (payload) => {
-    this.toolCallArgsRawByCallId.set(payload.toolCallId, payload.args);
-    this.applyToolCallArgs(payload.sessionId, payload.toolCallId, payload.args);
-  };
-  handleMessageToolCallArgsDelta = (payload) => {
-    const currentArgs = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
-    const nextArgs = `${currentArgs}${payload.delta}`;
-    this.toolCallArgsRawByCallId.set(payload.toolCallId, nextArgs);
-    this.applyToolCallArgs(
-      payload.sessionId,
-      payload.toolCallId,
-      nextArgs,
-      payload.messageId
-    );
-  };
-  handleMessageToolCallEnd = (payload) => {
-    const targetMessage = this.resolveToolCallTargetMessage(
-      payload.sessionId,
-      payload.toolCallId
-    );
-    const args = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
-    const nextParts = upsertToolInvocationPart(targetMessage.parts, {
-      type: "tool-invocation",
-      toolCallId: payload.toolCallId,
-      toolName: findToolNameByCallId(targetMessage.parts, payload.toolCallId) ?? "unknown",
-      state: "call",
-      args
-    });
-    this.replaceStreamingMessage({
-      ...targetMessage,
-      parts: nextParts,
-      status: "streaming"
-    });
-  };
-  handleMessageToolCallResult = (payload) => {
-    const updated = this.updateMessageContainingToolCall(
-      payload.toolCallId,
-      (targetMessage, existingPart) => {
-        const mergedPart = {
-          type: "tool-invocation",
-          toolCallId: payload.toolCallId,
-          toolName: existingPart.toolName,
-          state: "result",
-          args: existingPart.args,
-          result: payload.content
-        };
-        return upsertToolInvocationPart(targetMessage.parts, mergedPart);
-      }
-    );
-    if (!updated) {
-      const fallbackMessage = this.resolveToolCallTargetMessage(
-        payload.sessionId,
-        payload.toolCallId
-      );
-      const nextParts = upsertToolInvocationPart(fallbackMessage.parts, {
-        type: "tool-invocation",
-        toolCallId: payload.toolCallId,
-        toolName: "unknown",
-        state: "result",
-        result: payload.content
-      });
-      this.replaceStreamingMessage({
-        ...fallbackMessage,
-        parts: nextParts,
-        status: "streaming"
-      });
-    }
-  };
-  handleRunStarted = (payload) => {
-    if (this.isSettledRunId(payload.runId)) return;
-    this.setError(null);
-    this.activeRun = { runId: payload.runId ?? null, sessionId: payload.sessionId };
-    this.stateVersion += 1;
-  };
-  handleRunFinished = (payload) => {
-    this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
-    this.settleStreamingMessage("final");
-    this.setError(null);
-    this.clearActiveRun();
-  };
-  handleRunError = (payload) => {
-    this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
-    this.settleStreamingMessage("error");
-    this.setError(buildRuntimeError(payload));
-    this.clearActiveRun();
-  };
-  handleRunMetadata = (payload) => {
-    const m = payload.metadata;
-    if (m?.kind === "ready") {
-      const ready = m;
-      if (this.isSettledRunId(ready.runId)) return;
-      this.activeRun = {
-        runId: ready.runId ?? this.activeRun?.runId ?? null,
-        sessionId: ready.sessionId ?? this.activeRun?.sessionId,
-        abortDisabledReason: ready.supportsAbort === false ? ready.abortDisabledReason ?? "Unsupported" : null
-      };
-      this.stateVersion += 1;
-    } else if (m?.kind === "final") {
-      this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
-      this.clearActiveRun();
-    }
-  };
-  handleEndpointError = (payload) => {
-    if (payload.code === "abort-error") {
-      this.handleMessageAbort({
-        sessionId: this.activeRun?.sessionId ?? this.streamingMessage?.sessionId ?? "",
-        ...this.streamingMessage?.id ? { messageId: this.streamingMessage.id } : {}
-      });
-      return;
-    }
-    this.settleStreamingMessage("error");
-    this.clearActiveRun();
-    this.setError(payload);
-  };
-  applyToolCallArgs = (sessionId, toolCallId, args, messageId) => {
-    const targetMessage = this.resolveToolCallTargetMessage(
-      sessionId,
-      toolCallId,
-      messageId
-    );
-    const toolName = findToolNameByCallId(targetMessage.parts, toolCallId) ?? "unknown";
-    const nextParts = upsertToolInvocationPart(targetMessage.parts, {
-      type: "tool-invocation",
-      toolCallId,
-      toolName,
-      state: "partial-call",
-      args
-    });
-    this.replaceStreamingMessage({
-      ...targetMessage,
-      parts: nextParts,
-      status: "streaming"
-    });
-  };
-  ensureStreamingMessage = (sessionId, messageId, status) => {
-    if (this.streamingMessage?.id === messageId) {
-      if (this.streamingMessage.status === status) {
-        return this.streamingMessage;
-      }
-      const nextStreamingMessage2 = {
-        ...this.streamingMessage,
-        status
-      };
-      this.replaceStreamingMessage(nextStreamingMessage2);
-      return nextStreamingMessage2;
-    }
-    const messageIndex = this.messages.findIndex(
-      (message) => message.id === messageId
-    );
-    if (messageIndex >= 0) {
-      const existingMessage = cloneConversationMessage(
-        this.messages[messageIndex]
-      );
-      const nextMessages = [...this.messages];
-      nextMessages.splice(messageIndex, 1);
-      this.messages = nextMessages;
-      this.stateVersion += 1;
-      const nextStreamingMessage2 = {
-        ...existingMessage,
-        sessionId,
-        status
-      };
-      this.replaceStreamingMessage(nextStreamingMessage2);
-      return nextStreamingMessage2;
-    }
-    const existingStreamingMessage = this.streamingMessage;
-    if (existingStreamingMessage && existingStreamingMessage.id !== messageId && existingStreamingMessage.sessionId === sessionId && shouldPromoteStreamingMessageId(existingStreamingMessage, messageId)) {
-      const nextStreamingMessage2 = {
-        ...existingStreamingMessage,
-        id: messageId,
-        sessionId,
-        status
-      };
-      remapTrackedToolCallsToMessageId(
-        this.toolCallMessageIdByCallId,
-        existingStreamingMessage.id,
-        messageId
-      );
-      this.replaceStreamingMessage(nextStreamingMessage2);
-      return nextStreamingMessage2;
-    }
-    const nextStreamingMessage = {
-      id: messageId,
-      sessionId,
-      role: DEFAULT_ASSISTANT_ROLE,
-      status,
-      parts: [],
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.replaceStreamingMessage(nextStreamingMessage);
-    return nextStreamingMessage;
-  };
-  resolveToolCallTargetMessage = (sessionId, toolCallId, messageId) => {
-    const preferredMessageId = messageId?.trim() || this.toolCallMessageIdByCallId.get(toolCallId) || this.streamingMessage?.id || `tool-${toolCallId}`;
-    this.toolCallMessageIdByCallId.set(toolCallId, preferredMessageId);
-    return this.ensureStreamingMessage(
-      sessionId,
-      preferredMessageId,
-      "streaming"
-    );
-  };
-  updateMessageContainingToolCall = (toolCallId, updater) => {
-    if (this.streamingMessage) {
-      const part = findToolInvocationPart(
-        this.streamingMessage.parts,
-        toolCallId
-      );
-      if (part) {
-        const nextParts = updater(this.streamingMessage, part);
-        this.replaceStreamingMessage({
-          ...this.streamingMessage,
-          parts: nextParts
-        });
-        return true;
-      }
-    }
-    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
-      const candidateMessage = this.messages[index];
-      const part = findToolInvocationPart(candidateMessage.parts, toolCallId);
-      if (!part) {
-        continue;
-      }
-      const nextMessages = [...this.messages];
-      nextMessages[index] = {
-        ...candidateMessage,
-        parts: updater(candidateMessage, part)
-      };
-      this.messages = nextMessages;
-      this.stateVersion += 1;
-      return true;
-    }
-    return false;
-  };
-  upsertMessage = (message) => {
-    const normalizedMessage = normalizeConversationMessage(message);
-    const messageIndex = this.messages.findIndex(
-      (item) => item.id === normalizedMessage.id
-    );
-    if (messageIndex < 0) {
-      this.messages = [...this.messages, normalizedMessage];
-      this.stateVersion += 1;
-      return;
-    }
-    const nextMessages = [...this.messages];
-    nextMessages[messageIndex] = normalizedMessage;
-    this.messages = nextMessages;
-    this.stateVersion += 1;
-  };
-  replaceStreamingMessage = (nextStreamingMessage) => {
-    if (!nextStreamingMessage && !this.streamingMessage) {
-      return;
-    }
-    this.streamingMessage = nextStreamingMessage ? normalizeConversationMessage(nextStreamingMessage) : null;
-    this.stateVersion += 1;
-  };
-  setError = (nextError) => {
-    const hasSameError = this.error?.code === nextError?.code && this.error?.message === nextError?.message && this.error?.details === nextError?.details && this.error?.cause === nextError?.cause;
-    if (hasSameError) {
-      return;
-    }
-    this.error = nextError ? {
-      ...nextError,
-      details: nextError.details ? { ...nextError.details } : void 0
-    } : null;
-    this.stateVersion += 1;
-  };
-  clearActiveRun = () => {
-    if (!this.activeRun) return;
-    this.activeRun = null;
-    this.stateVersion += 1;
-  };
-  isSettledRunId = (runId) => {
-    return Boolean(runId?.trim()) && runId === this.lastSettledRunId;
-  };
-  markRunAsSettled = (runId) => {
-    this.lastSettledRunId = runId?.trim() || null;
-  };
-  settleStreamingMessage = (status) => {
-    if (!this.streamingMessage) {
-      return;
-    }
-    const settledMessage = {
-      ...this.streamingMessage,
-      status
-    };
-    this.upsertMessage(settledMessage);
-    this.replaceStreamingMessage(null);
-    clearToolCallTrackingByMessageId(
-      this.toolCallMessageIdByCallId,
-      this.toolCallArgsRawByCallId,
-      settledMessage.id
-    );
-  };
-  notifyListeners = () => {
-    const snapshot = this.getSnapshot();
-    for (const listener of this.listeners) listener(snapshot);
-  };
+	messages = [];
+	streamingMessage = null;
+	error = null;
+	activeRun = null;
+	listeners = /* @__PURE__ */ new Set();
+	toolCallMessageIdByCallId = /* @__PURE__ */ new Map();
+	toolCallArgsRawByCallId = /* @__PURE__ */ new Map();
+	lastSettledRunId = null;
+	snapshotCache = null;
+	snapshotVersion = -1;
+	stateVersion = 0;
+	getSnapshot = () => {
+		if (this.snapshotCache && this.snapshotVersion === this.stateVersion) return this.snapshotCache;
+		const snapshot = {
+			messages: this.messages,
+			streamingMessage: this.streamingMessage,
+			error: this.error ? {
+				...this.error,
+				details: this.error.details ? { ...this.error.details } : void 0
+			} : null,
+			activeRun: this.activeRun ? { ...this.activeRun } : null
+		};
+		this.snapshotCache = snapshot;
+		this.snapshotVersion = this.stateVersion;
+		return snapshot;
+	};
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	reset = () => {
+		if (this.messages.length === 0 && !this.streamingMessage && !this.error && !this.activeRun && this.toolCallMessageIdByCallId.size === 0 && this.toolCallArgsRawByCallId.size === 0) return;
+		this.messages = [];
+		this.streamingMessage = null;
+		this.error = null;
+		this.activeRun = null;
+		this.toolCallMessageIdByCallId.clear();
+		this.toolCallArgsRawByCallId.clear();
+		this.lastSettledRunId = null;
+		this.stateVersion += 1;
+		this.notifyListeners();
+	};
+	hydrate = (payload) => {
+		this.messages = payload.messages.map((message) => normalizeConversationMessage(message));
+		this.streamingMessage = null;
+		this.error = null;
+		this.activeRun = payload.activeRun ? {
+			...payload.activeRun,
+			sessionId: payload.activeRun.sessionId ?? payload.sessionId,
+			abortDisabledReason: payload.activeRun.abortDisabledReason ?? null
+		} : null;
+		this.toolCallMessageIdByCallId.clear();
+		this.toolCallArgsRawByCallId.clear();
+		this.lastSettledRunId = null;
+		this.stateVersion += 1;
+		this.notifyListeners();
+	};
+	dispatch = (event) => this.dispatchBatch([event]);
+	dispatchBatch = async (events) => {
+		if (!events.length) return;
+		const versionBeforeDispatch = this.stateVersion;
+		events.forEach(this.applyEvent);
+		if (this.stateVersion !== versionBeforeDispatch) this.notifyListeners();
+	};
+	applyEvent = (event) => {
+		switch (event.type) {
+			case NcpEventType.MessageSent:
+				this.handleMessageSent(event.payload);
+				break;
+			case NcpEventType.MessageAbort:
+				this.handleMessageAbort(event.payload);
+				break;
+			case NcpEventType.MessageTextStart:
+				this.handleMessageTextStart(event.payload);
+				break;
+			case NcpEventType.MessageTextDelta:
+				this.handleMessageTextDelta(event.payload);
+				break;
+			case NcpEventType.MessageTextEnd:
+				this.handleMessageTextEnd(event.payload);
+				break;
+			case NcpEventType.MessageReasoningStart:
+				this.handleMessageReasoningStart(event.payload);
+				break;
+			case NcpEventType.MessageReasoningDelta:
+				this.handleMessageReasoningDelta(event.payload);
+				break;
+			case NcpEventType.MessageReasoningEnd:
+				this.handleMessageReasoningEnd(event.payload);
+				break;
+			case NcpEventType.MessageToolCallStart:
+				this.handleMessageToolCallStart(event.payload);
+				break;
+			case NcpEventType.MessageToolCallArgs:
+				this.handleMessageToolCallArgs(event.payload);
+				break;
+			case NcpEventType.MessageToolCallArgsDelta:
+				this.handleMessageToolCallArgsDelta(event.payload);
+				break;
+			case NcpEventType.MessageToolCallEnd:
+				this.handleMessageToolCallEnd(event.payload);
+				break;
+			case NcpEventType.MessageToolCallResult:
+				this.handleMessageToolCallResult(event.payload);
+				break;
+			case NcpEventType.RunStarted:
+				this.handleRunStarted(event.payload);
+				break;
+			case NcpEventType.RunFinished:
+				this.handleRunFinished(event.payload);
+				break;
+			case NcpEventType.RunError:
+				this.handleRunError(event.payload);
+				break;
+			case NcpEventType.RunMetadata:
+				this.handleRunMetadata(event.payload);
+				break;
+			case NcpEventType.EndpointError:
+				this.handleEndpointError(event.payload);
+				break;
+			default: break;
+		}
+	};
+	handleMessageSent = (payload) => {
+		this.upsertMessage(payload.message);
+		this.setError(null);
+	};
+	handleMessageAbort = (payload) => {
+		const targetMessageId = payload.messageId?.trim();
+		this.clearActiveRun();
+		this.setError(null);
+		if (this.streamingMessage && (!targetMessageId || this.streamingMessage.id === targetMessageId)) {
+			const streamingMessageId = this.streamingMessage.id;
+			this.upsertMessage({
+				...this.streamingMessage,
+				status: "final"
+			});
+			this.replaceStreamingMessage(null);
+			if (targetMessageId) clearToolCallTrackingByMessageId(this.toolCallMessageIdByCallId, this.toolCallArgsRawByCallId, targetMessageId);
+			else clearToolCallTrackingByMessageId(this.toolCallMessageIdByCallId, this.toolCallArgsRawByCallId, streamingMessageId);
+		}
+	};
+	handleMessageTextStart = (payload) => {
+		this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
+		this.setError(null);
+	};
+	handleMessageTextDelta = (payload) => {
+		if (!payload.delta) return;
+		const targetMessage = this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
+		const nextParts = [...targetMessage.parts];
+		const lastPart = nextParts[nextParts.length - 1];
+		if (lastPart?.type === "text") nextParts[nextParts.length - 1] = {
+			type: "text",
+			text: `${lastPart.text}${payload.delta}`
+		};
+		else nextParts.push({
+			type: "text",
+			text: payload.delta
+		});
+		this.replaceStreamingMessage({
+			...targetMessage,
+			parts: nextParts,
+			status: "streaming"
+		});
+	};
+	handleMessageTextEnd = (payload) => {
+		if (this.streamingMessage?.id !== payload.messageId) return;
+		if (this.streamingMessage.status !== "streaming") return;
+		this.replaceStreamingMessage({
+			...this.streamingMessage,
+			status: "pending"
+		});
+	};
+	handleMessageReasoningStart = (payload) => {
+		this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
+	};
+	handleMessageReasoningDelta = (payload) => {
+		if (!payload.delta) return;
+		const targetMessage = this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
+		const nextParts = [...targetMessage.parts];
+		const lastPart = nextParts[nextParts.length - 1];
+		if (lastPart?.type === "reasoning") nextParts[nextParts.length - 1] = {
+			type: "reasoning",
+			text: `${lastPart.text}${payload.delta}`
+		};
+		else nextParts.push({
+			type: "reasoning",
+			text: payload.delta
+		});
+		this.replaceStreamingMessage({
+			...targetMessage,
+			parts: nextParts,
+			status: "streaming"
+		});
+	};
+	handleMessageReasoningEnd = (payload) => {
+		if (this.streamingMessage?.id !== payload.messageId) return;
+	};
+	handleMessageToolCallStart = (payload) => {
+		const targetMessage = this.resolveToolCallTargetMessage(payload.sessionId, payload.toolCallId, payload.messageId);
+		this.toolCallArgsRawByCallId.set(payload.toolCallId, "");
+		const nextParts = upsertToolInvocationPart(targetMessage.parts, {
+			type: "tool-invocation",
+			toolCallId: payload.toolCallId,
+			toolName: payload.toolName,
+			state: "partial-call",
+			args: ""
+		});
+		this.replaceStreamingMessage({
+			...targetMessage,
+			parts: nextParts,
+			status: "streaming"
+		});
+		this.setError(null);
+	};
+	handleMessageToolCallArgs = (payload) => {
+		this.toolCallArgsRawByCallId.set(payload.toolCallId, payload.args);
+		this.applyToolCallArgs(payload.sessionId, payload.toolCallId, payload.args);
+	};
+	handleMessageToolCallArgsDelta = (payload) => {
+		const nextArgs = `${this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? ""}${payload.delta}`;
+		this.toolCallArgsRawByCallId.set(payload.toolCallId, nextArgs);
+		this.applyToolCallArgs(payload.sessionId, payload.toolCallId, nextArgs, payload.messageId);
+	};
+	handleMessageToolCallEnd = (payload) => {
+		const targetMessage = this.resolveToolCallTargetMessage(payload.sessionId, payload.toolCallId);
+		const args = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
+		const nextParts = upsertToolInvocationPart(targetMessage.parts, {
+			type: "tool-invocation",
+			toolCallId: payload.toolCallId,
+			toolName: findToolNameByCallId(targetMessage.parts, payload.toolCallId) ?? "unknown",
+			state: "call",
+			args
+		});
+		this.replaceStreamingMessage({
+			...targetMessage,
+			parts: nextParts,
+			status: "streaming"
+		});
+	};
+	handleMessageToolCallResult = (payload) => {
+		if (!this.updateMessageContainingToolCall(payload.toolCallId, (targetMessage, existingPart) => {
+			const mergedPart = {
+				type: "tool-invocation",
+				toolCallId: payload.toolCallId,
+				toolName: existingPart.toolName,
+				state: "result",
+				args: existingPart.args,
+				result: payload.content
+			};
+			return upsertToolInvocationPart(targetMessage.parts, mergedPart);
+		})) {
+			const fallbackMessage = this.resolveToolCallTargetMessage(payload.sessionId, payload.toolCallId);
+			const nextParts = upsertToolInvocationPart(fallbackMessage.parts, {
+				type: "tool-invocation",
+				toolCallId: payload.toolCallId,
+				toolName: "unknown",
+				state: "result",
+				result: payload.content
+			});
+			this.replaceStreamingMessage({
+				...fallbackMessage,
+				parts: nextParts,
+				status: "streaming"
+			});
+		}
+	};
+	handleRunStarted = (payload) => {
+		if (this.isSettledRunId(payload.runId)) return;
+		this.setError(null);
+		this.activeRun = {
+			runId: payload.runId ?? null,
+			sessionId: payload.sessionId
+		};
+		this.stateVersion += 1;
+	};
+	handleRunFinished = (payload) => {
+		this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
+		this.settleStreamingMessage("final");
+		this.setError(null);
+		this.clearActiveRun();
+	};
+	handleRunError = (payload) => {
+		this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
+		this.settleStreamingMessage("error");
+		this.setError(buildRuntimeError(payload));
+		this.clearActiveRun();
+	};
+	handleRunMetadata = (payload) => {
+		const m = payload.metadata;
+		if (m?.kind === "ready") {
+			const ready = m;
+			if (this.isSettledRunId(ready.runId)) return;
+			this.activeRun = {
+				runId: ready.runId ?? this.activeRun?.runId ?? null,
+				sessionId: ready.sessionId ?? this.activeRun?.sessionId,
+				abortDisabledReason: ready.supportsAbort === false ? ready.abortDisabledReason ?? "Unsupported" : null
+			};
+			this.stateVersion += 1;
+		} else if (m?.kind === "final") {
+			this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
+			this.clearActiveRun();
+		}
+	};
+	handleEndpointError = (payload) => {
+		if (payload.code === "abort-error") {
+			this.handleMessageAbort({
+				sessionId: this.activeRun?.sessionId ?? this.streamingMessage?.sessionId ?? "",
+				...this.streamingMessage?.id ? { messageId: this.streamingMessage.id } : {}
+			});
+			return;
+		}
+		this.settleStreamingMessage("error");
+		this.clearActiveRun();
+		this.setError(payload);
+	};
+	applyToolCallArgs = (sessionId, toolCallId, args, messageId) => {
+		const targetMessage = this.resolveToolCallTargetMessage(sessionId, toolCallId, messageId);
+		const toolName = findToolNameByCallId(targetMessage.parts, toolCallId) ?? "unknown";
+		const nextParts = upsertToolInvocationPart(targetMessage.parts, {
+			type: "tool-invocation",
+			toolCallId,
+			toolName,
+			state: "partial-call",
+			args
+		});
+		this.replaceStreamingMessage({
+			...targetMessage,
+			parts: nextParts,
+			status: "streaming"
+		});
+	};
+	ensureStreamingMessage = (sessionId, messageId, status) => {
+		if (this.streamingMessage?.id === messageId) {
+			if (this.streamingMessage.status === status) return this.streamingMessage;
+			const nextStreamingMessage = {
+				...this.streamingMessage,
+				status
+			};
+			this.replaceStreamingMessage(nextStreamingMessage);
+			return nextStreamingMessage;
+		}
+		const messageIndex = this.messages.findIndex((message) => message.id === messageId);
+		if (messageIndex >= 0) {
+			const existingMessage = cloneConversationMessage(this.messages[messageIndex]);
+			const nextMessages = [...this.messages];
+			nextMessages.splice(messageIndex, 1);
+			this.messages = nextMessages;
+			this.stateVersion += 1;
+			const nextStreamingMessage = {
+				...existingMessage,
+				sessionId,
+				status
+			};
+			this.replaceStreamingMessage(nextStreamingMessage);
+			return nextStreamingMessage;
+		}
+		const existingStreamingMessage = this.streamingMessage;
+		if (existingStreamingMessage && existingStreamingMessage.id !== messageId && existingStreamingMessage.sessionId === sessionId && shouldPromoteStreamingMessageId(existingStreamingMessage, messageId)) {
+			const nextStreamingMessage = {
+				...existingStreamingMessage,
+				id: messageId,
+				sessionId,
+				status
+			};
+			remapTrackedToolCallsToMessageId(this.toolCallMessageIdByCallId, existingStreamingMessage.id, messageId);
+			this.replaceStreamingMessage(nextStreamingMessage);
+			return nextStreamingMessage;
+		}
+		const nextStreamingMessage = {
+			id: messageId,
+			sessionId,
+			role: DEFAULT_ASSISTANT_ROLE,
+			status,
+			parts: [],
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.replaceStreamingMessage(nextStreamingMessage);
+		return nextStreamingMessage;
+	};
+	resolveToolCallTargetMessage = (sessionId, toolCallId, messageId) => {
+		const preferredMessageId = messageId?.trim() || this.toolCallMessageIdByCallId.get(toolCallId) || this.streamingMessage?.id || `tool-${toolCallId}`;
+		this.toolCallMessageIdByCallId.set(toolCallId, preferredMessageId);
+		return this.ensureStreamingMessage(sessionId, preferredMessageId, "streaming");
+	};
+	updateMessageContainingToolCall = (toolCallId, updater) => {
+		if (this.streamingMessage) {
+			const part = findToolInvocationPart(this.streamingMessage.parts, toolCallId);
+			if (part) {
+				const nextParts = updater(this.streamingMessage, part);
+				this.replaceStreamingMessage({
+					...this.streamingMessage,
+					parts: nextParts
+				});
+				return true;
+			}
+		}
+		for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+			const candidateMessage = this.messages[index];
+			const part = findToolInvocationPart(candidateMessage.parts, toolCallId);
+			if (!part) continue;
+			const nextMessages = [...this.messages];
+			nextMessages[index] = {
+				...candidateMessage,
+				parts: updater(candidateMessage, part)
+			};
+			this.messages = nextMessages;
+			this.stateVersion += 1;
+			return true;
+		}
+		return false;
+	};
+	upsertMessage = (message) => {
+		const normalizedMessage = normalizeConversationMessage(message);
+		const messageIndex = this.messages.findIndex((item) => item.id === normalizedMessage.id);
+		if (messageIndex < 0) {
+			this.messages = [...this.messages, normalizedMessage];
+			this.stateVersion += 1;
+			return;
+		}
+		const nextMessages = [...this.messages];
+		nextMessages[messageIndex] = normalizedMessage;
+		this.messages = nextMessages;
+		this.stateVersion += 1;
+	};
+	replaceStreamingMessage = (nextStreamingMessage) => {
+		if (!nextStreamingMessage && !this.streamingMessage) return;
+		this.streamingMessage = nextStreamingMessage ? normalizeConversationMessage(nextStreamingMessage) : null;
+		this.stateVersion += 1;
+	};
+	setError = (nextError) => {
+		if (this.error?.code === nextError?.code && this.error?.message === nextError?.message && this.error?.details === nextError?.details && this.error?.cause === nextError?.cause) return;
+		this.error = nextError ? {
+			...nextError,
+			details: nextError.details ? { ...nextError.details } : void 0
+		} : null;
+		this.stateVersion += 1;
+	};
+	clearActiveRun = () => {
+		if (!this.activeRun) return;
+		this.activeRun = null;
+		this.stateVersion += 1;
+	};
+	isSettledRunId = (runId) => {
+		return Boolean(runId?.trim()) && runId === this.lastSettledRunId;
+	};
+	markRunAsSettled = (runId) => {
+		this.lastSettledRunId = runId?.trim() || null;
+	};
+	settleStreamingMessage = (status) => {
+		if (!this.streamingMessage) return;
+		const settledMessage = {
+			...this.streamingMessage,
+			status
+		};
+		this.upsertMessage(settledMessage);
+		this.replaceStreamingMessage(null);
+		clearToolCallTrackingByMessageId(this.toolCallMessageIdByCallId, this.toolCallArgsRawByCallId, settledMessage.id);
+	};
+	notifyListeners = () => {
+		const snapshot = this.getSnapshot();
+		for (const listener of this.listeners) listener(snapshot);
+	};
 };
-
-// src/agent/agent-client-from-server.ts
-import {
-  NcpEventType as NcpEventType2
-} from "@nextclaw/ncp";
+//#endregion
+//#region src/agent/agent-client-from-server.ts
+/**
+* Creates an NcpAgentClientEndpoint that forwards to an in-process NcpAgentServerEndpoint.
+* Use when the agent runs in-process and you need to pass a client endpoint to the HTTP server.
+*/
 function createAgentClientFromServer(server) {
-  return {
-    get manifest() {
-      return server.manifest;
-    },
-    async start() {
-      await server.start();
-    },
-    async stop() {
-      await server.stop();
-    },
-    async emit(event) {
-      switch (event.type) {
-        case NcpEventType2.MessageRequest:
-          await consume(server.send(event.payload));
-          return;
-        case NcpEventType2.MessageStreamRequest:
-          await consume(server.stream(event.payload));
-          return;
-        case NcpEventType2.MessageAbort:
-          await server.abort(event.payload);
-          return;
-        default:
-          await server.emit(event);
-      }
-    },
-    subscribe(listener) {
-      return server.subscribe(listener);
-    },
-    async send(envelope) {
-      await consume(server.send(envelope));
-    },
-    async stream(payload) {
-      await consume(server.stream(payload));
-    },
-    async abort(payload) {
-      await server.abort(payload);
-    }
-  };
+	return {
+		get manifest() {
+			return server.manifest;
+		},
+		async start() {
+			await server.start();
+		},
+		async stop() {
+			await server.stop();
+		},
+		async emit(event) {
+			switch (event.type) {
+				case NcpEventType.MessageRequest:
+					await consume(server.send(event.payload));
+					return;
+				case NcpEventType.MessageStreamRequest:
+					await consume(server.stream(event.payload));
+					return;
+				case NcpEventType.MessageAbort:
+					await server.abort(event.payload);
+					return;
+				default: await server.emit(event);
+			}
+		},
+		subscribe(listener) {
+			return server.subscribe(listener);
+		},
+		async send(envelope) {
+			await consume(server.send(envelope));
+		},
+		async stream(payload) {
+			await consume(server.stream(payload));
+		},
+		async abort(payload) {
+			await server.abort(payload);
+		}
+	};
 }
 async function consume(events) {
-  for await (const event of events) {
-    void event;
-  }
+	for await (const event of events);
 }
-
-// src/agent/agent-backend/agent-backend.ts
-import {
-  NcpEventType as NcpEventType6
-} from "@nextclaw/ncp";
-
-// src/agent/agent-backend/event-publisher.ts
+//#endregion
+//#region src/agent/agent-backend/event-publisher.ts
 var EventPublisher = class {
-  listeners = /* @__PURE__ */ new Set();
-  closeListeners = /* @__PURE__ */ new Set();
-  closed = false;
-  subscribe(listener) {
-    if (this.closed) {
-      return () => void 0;
-    }
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  onClose(listener) {
-    if (this.closed) {
-      listener();
-      return () => void 0;
-    }
-    this.closeListeners.add(listener);
-    return () => {
-      this.closeListeners.delete(listener);
-    };
-  }
-  publish(event) {
-    if (this.closed) {
-      return;
-    }
-    for (const listener of this.listeners) {
-      listener(structuredClone(event));
-    }
-  }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.listeners.clear();
-    for (const listener of this.closeListeners) {
-      listener();
-    }
-    this.closeListeners.clear();
-  }
+	listeners = /* @__PURE__ */ new Set();
+	closeListeners = /* @__PURE__ */ new Set();
+	closed = false;
+	subscribe(listener) {
+		if (this.closed) return () => void 0;
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	onClose(listener) {
+		if (this.closed) {
+			listener();
+			return () => void 0;
+		}
+		this.closeListeners.add(listener);
+		return () => {
+			this.closeListeners.delete(listener);
+		};
+	}
+	publish(event) {
+		if (this.closed) return;
+		for (const listener of this.listeners) listener(structuredClone(event));
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.listeners.clear();
+		for (const listener of this.closeListeners) listener();
+		this.closeListeners.clear();
+	}
 };
-
-// src/agent/agent-backend/agent-live-session-registry.ts
-function readOptionalAgentId(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().toLowerCase();
-  return trimmed.length > 0 ? trimmed : void 0;
+//#endregion
+//#region src/agent/agent-backend/agent-live-session-registry.ts
+function readOptionalAgentId$2(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim().toLowerCase();
+	return trimmed.length > 0 ? trimmed : void 0;
 }
-function readAgentIdFromMetadata(metadata) {
-  return readOptionalAgentId(metadata?.agent_id) ?? readOptionalAgentId(metadata?.agentId);
+function readAgentIdFromMetadata$1(metadata) {
+	return readOptionalAgentId$2(metadata?.agent_id) ?? readOptionalAgentId$2(metadata?.agentId);
 }
 var AgentLiveSessionRegistry = class {
-  constructor(sessionStore, createRuntime) {
-    this.sessionStore = sessionStore;
-    this.createRuntime = createRuntime;
-  }
-  sessions = /* @__PURE__ */ new Map();
-  ensureSession = async (sessionId, initialMetadata) => {
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      if (!existing.agentId) {
-        existing.agentId = readAgentIdFromMetadata(initialMetadata) ?? existing.agentId;
-      }
-      if (initialMetadata && Object.keys(initialMetadata).length > 0) {
-        existing.metadata = {
-          ...existing.metadata,
-          ...structuredClone(initialMetadata)
-        };
-      }
-      return existing;
-    }
-    const storedSession = await this.sessionStore.getSession(sessionId);
-    const stateManager = new DefaultNcpAgentConversationStateManager();
-    stateManager.hydrate({
-      sessionId,
-      messages: cloneMessages(storedSession?.messages ?? [])
-    });
-    const sessionMetadata = {
-      ...storedSession?.metadata ? structuredClone(storedSession.metadata) : {},
-      ...initialMetadata ? structuredClone(initialMetadata) : {}
-    };
-    const sessionAgentId = readOptionalAgentId(storedSession?.agentId) ?? readAgentIdFromMetadata(initialMetadata);
-    const session = {
-      sessionId,
-      ...sessionAgentId ? { agentId: sessionAgentId } : {},
-      stateManager,
-      metadata: sessionMetadata,
-      runtime: null,
-      publisher: new EventPublisher(),
-      activeExecution: null
-    };
-    session.runtime = this.createRuntime({
-      sessionId,
-      ...sessionAgentId ? { agentId: sessionAgentId } : {},
-      stateManager,
-      sessionMetadata,
-      setSessionMetadata: (nextMetadata) => {
-        session.metadata = {
-          ...structuredClone(nextMetadata)
-        };
-      }
-    });
-    this.sessions.set(sessionId, session);
-    return session;
-  };
-  getSession = (sessionId) => {
-    return this.sessions.get(sessionId) ?? null;
-  };
-  deleteSession = (sessionId) => {
-    const session = this.sessions.get(sessionId) ?? null;
-    if (session) {
-      this.sessions.delete(sessionId);
-    }
-    return session;
-  };
-  clear = () => {
-    this.sessions.clear();
-  };
-  listSessions = () => {
-    return [...this.sessions.values()];
-  };
+	sessions = /* @__PURE__ */ new Map();
+	constructor(sessionStore, createRuntime) {
+		this.sessionStore = sessionStore;
+		this.createRuntime = createRuntime;
+	}
+	ensureSession = async (sessionId, initialMetadata) => {
+		const existing = this.sessions.get(sessionId);
+		if (existing) {
+			if (!existing.agentId) existing.agentId = readAgentIdFromMetadata$1(initialMetadata) ?? existing.agentId;
+			if (initialMetadata && Object.keys(initialMetadata).length > 0) existing.metadata = {
+				...existing.metadata,
+				...structuredClone(initialMetadata)
+			};
+			return existing;
+		}
+		const storedSession = await this.sessionStore.getSession(sessionId);
+		const stateManager = new DefaultNcpAgentConversationStateManager();
+		stateManager.hydrate({
+			sessionId,
+			messages: cloneMessages(storedSession?.messages ?? [])
+		});
+		const sessionMetadata = {
+			...storedSession?.metadata ? structuredClone(storedSession.metadata) : {},
+			...initialMetadata ? structuredClone(initialMetadata) : {}
+		};
+		const sessionAgentId = readOptionalAgentId$2(storedSession?.agentId) ?? readAgentIdFromMetadata$1(initialMetadata);
+		const session = {
+			sessionId,
+			...sessionAgentId ? { agentId: sessionAgentId } : {},
+			stateManager,
+			metadata: sessionMetadata,
+			runtime: null,
+			publisher: new EventPublisher(),
+			activeExecution: null
+		};
+		session.runtime = this.createRuntime({
+			sessionId,
+			...sessionAgentId ? { agentId: sessionAgentId } : {},
+			stateManager,
+			sessionMetadata,
+			setSessionMetadata: (nextMetadata) => {
+				session.metadata = { ...structuredClone(nextMetadata) };
+			}
+		});
+		this.sessions.set(sessionId, session);
+		return session;
+	};
+	getSession = (sessionId) => {
+		return this.sessions.get(sessionId) ?? null;
+	};
+	deleteSession = (sessionId) => {
+		const session = this.sessions.get(sessionId) ?? null;
+		if (session) this.sessions.delete(sessionId);
+		return session;
+	};
+	clear = () => {
+		this.sessions.clear();
+	};
+	listSessions = () => {
+		return [...this.sessions.values()];
+	};
 };
 function cloneMessages(messages) {
-  return messages.map((message) => structuredClone(message));
+	return messages.map((message) => structuredClone(message));
 }
-
-// src/errors/ncp-error-exception.ts
+//#endregion
+//#region src/errors/ncp-error-exception.ts
+/**
+* Throwable form of protocol error for exception-based control flows.
+*/
 var NcpErrorException = class extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "NcpErrorException";
-    this.code = code;
-    this.details = details;
-  }
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "NcpErrorException";
+		this.code = code;
+		this.details = details;
+	}
 };
-
-// src/agent/agent-backend/agent-backend-execution-utils.ts
+//#endregion
+//#region src/agent/agent-backend/agent-backend-execution-utils.ts
 function startAgentBackendSessionExecution(params) {
-  const { session, envelope, signal, onStatusChanged } = params;
-  if (session.activeExecution && !session.activeExecution.closed) {
-    throw new NcpErrorException(
-      "runtime-error",
-      `Session ${session.sessionId} already has an active execution.`,
-      { sessionId: session.sessionId }
-    );
-  }
-  const controller = new AbortController();
-  if (signal) {
-    signal.addEventListener("abort", () => controller.abort(), {
-      once: true
-    });
-  }
-  const execution = {
-    controller,
-    requestEnvelope: structuredClone(envelope),
-    abortHandled: false,
-    closed: false
-  };
-  session.activeExecution = execution;
-  onStatusChanged?.({ sessionKey: session.sessionId, status: "running" });
-  return execution;
+	const { session, envelope, signal, onStatusChanged } = params;
+	if (session.activeExecution && !session.activeExecution.closed) throw new NcpErrorException("runtime-error", `Session ${session.sessionId} already has an active execution.`, { sessionId: session.sessionId });
+	const controller = new AbortController();
+	if (signal) signal.addEventListener("abort", () => controller.abort(), { once: true });
+	const execution = {
+		controller,
+		requestEnvelope: structuredClone(envelope),
+		abortHandled: false,
+		closed: false
+	};
+	session.activeExecution = execution;
+	onStatusChanged?.({
+		sessionKey: session.sessionId,
+		status: "running"
+	});
+	return execution;
 }
 function finishAgentBackendSessionExecution(params) {
-  const { session, execution, onStatusChanged } = params;
-  if (session.activeExecution === execution) {
-    session.activeExecution = null;
-    onStatusChanged?.({ sessionKey: session.sessionId, status: "idle" });
-  }
-  closeAgentBackendSessionExecution(execution);
+	const { session, execution, onStatusChanged } = params;
+	if (session.activeExecution === execution) {
+		session.activeExecution = null;
+		onStatusChanged?.({
+			sessionKey: session.sessionId,
+			status: "idle"
+		});
+	}
+	closeAgentBackendSessionExecution(execution);
 }
 function closeAgentBackendSessionExecution(execution) {
-  if (execution.closed) {
-    return;
-  }
-  execution.closed = true;
+	if (execution.closed) return;
+	execution.closed = true;
 }
-
-// src/agent/agent-backend/agent-run-executor.ts
-import {
-  isHiddenNcpMessage
-} from "@nextclaw/ncp";
-import { NcpEventType as NcpEventType3 } from "@nextclaw/ncp";
+//#endregion
+//#region src/agent/agent-backend/agent-run-executor.ts
 var AgentRunExecutor = class {
-  async *executeRun(session, envelope, controller) {
-    if (!isHiddenNcpMessage(envelope.message)) {
-      const messageSent = {
-        type: NcpEventType3.MessageSent,
-        payload: {
-          sessionId: envelope.sessionId,
-          message: structuredClone(envelope.message),
-          metadata: envelope.metadata
-        }
-      };
-      await session.stateManager.dispatch(messageSent);
-      yield structuredClone(messageSent);
-    }
-    try {
-      for await (const event of session.runtime.run(
-        {
-          sessionId: envelope.sessionId,
-          messages: [envelope.message],
-          correlationId: envelope.correlationId,
-          metadata: envelope.metadata
-        },
-        { signal: controller.signal }
-      )) {
-        yield structuredClone(event);
-      }
-    } catch (error) {
-      if (!controller.signal.aborted) {
-        const runErrorEvent = await this.publishFailure(
-          error,
-          envelope,
-          session
-        );
-        yield structuredClone(runErrorEvent);
-      }
-    }
-  }
-  async publishFailure(error, envelope, session) {
-    const message = error instanceof Error ? error.message : String(error);
-    const runErrorEvent = {
-      type: NcpEventType3.RunError,
-      payload: {
-        sessionId: envelope.sessionId,
-        error: message
-      }
-    };
-    await session.stateManager.dispatch(runErrorEvent);
-    return runErrorEvent;
-  }
+	async *executeRun(session, envelope, controller) {
+		if (!isHiddenNcpMessage(envelope.message)) {
+			const messageSent = {
+				type: NcpEventType.MessageSent,
+				payload: {
+					sessionId: envelope.sessionId,
+					message: structuredClone(envelope.message),
+					metadata: envelope.metadata
+				}
+			};
+			await session.stateManager.dispatch(messageSent);
+			yield structuredClone(messageSent);
+		}
+		try {
+			for await (const event of session.runtime.run({
+				sessionId: envelope.sessionId,
+				messages: [envelope.message],
+				correlationId: envelope.correlationId,
+				metadata: envelope.metadata
+			}, { signal: controller.signal })) yield structuredClone(event);
+		} catch (error) {
+			if (!controller.signal.aborted) {
+				const runErrorEvent = await this.publishFailure(error, envelope, session);
+				yield structuredClone(runErrorEvent);
+			}
+		}
+	}
+	async publishFailure(error, envelope, session) {
+		const message = error instanceof Error ? error.message : String(error);
+		const runErrorEvent = {
+			type: NcpEventType.RunError,
+			payload: {
+				sessionId: envelope.sessionId,
+				error: message
+			}
+		};
+		await session.stateManager.dispatch(runErrorEvent);
+		return runErrorEvent;
+	}
 };
-
-// src/agent/agent-backend/agent-backend-session-realtime.ts
-import { NcpEventType as NcpEventType4 } from "@nextclaw/ncp";
-
-// src/agent/agent-backend/async-queue.ts
+//#endregion
+//#region src/agent/agent-backend/async-queue.ts
 function createAsyncQueue() {
-  const items = [];
-  let closed = false;
-  let pendingResolve = null;
-  const iterable = {
-    [Symbol.asyncIterator]() {
-      return {
-        next: () => {
-          if (items.length > 0) {
-            return Promise.resolve({
-              value: items.shift(),
-              done: false
-            });
-          }
-          if (closed) {
-            return Promise.resolve({
-              value: void 0,
-              done: true
-            });
-          }
-          return new Promise((resolve) => {
-            pendingResolve = resolve;
-          });
-        }
-      };
-    }
-  };
-  return {
-    push(item) {
-      if (closed) {
-        return;
-      }
-      if (pendingResolve) {
-        const resolve = pendingResolve;
-        pendingResolve = null;
-        resolve({ value: item, done: false });
-        return;
-      }
-      items.push(item);
-    },
-    close() {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      if (pendingResolve) {
-        const resolve = pendingResolve;
-        pendingResolve = null;
-        resolve({
-          value: void 0,
-          done: true
-        });
-      }
-    },
-    iterable
-  };
+	const items = [];
+	let closed = false;
+	let pendingResolve = null;
+	return {
+		push(item) {
+			if (closed) return;
+			if (pendingResolve) {
+				const resolve = pendingResolve;
+				pendingResolve = null;
+				resolve({
+					value: item,
+					done: false
+				});
+				return;
+			}
+			items.push(item);
+		},
+		close() {
+			if (closed) return;
+			closed = true;
+			if (pendingResolve) {
+				const resolve = pendingResolve;
+				pendingResolve = null;
+				resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		},
+		iterable: { [Symbol.asyncIterator]() {
+			return { next: () => {
+				if (items.length > 0) return Promise.resolve({
+					value: items.shift(),
+					done: false
+				});
+				if (closed) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					pendingResolve = resolve;
+				});
+			} };
+		} }
+	};
+}
+//#endregion
+//#region src/agent/agent-backend/agent-backend-session-realtime.ts
+function readEventSessionId(event) {
+	const payload = "payload" in event ? event.payload : null;
+	if (!payload || typeof payload !== "object") return null;
+	return "sessionId" in payload && typeof payload.sessionId === "string" ? payload.sessionId : null;
 }
-
-// src/agent/agent-backend/agent-backend-session-realtime.ts
 var AgentBackendSessionRealtime = class {
-  constructor(params) {
-    this.params = params;
-  }
-  publishSessionEvent = async (session, event, options = {}) => {
-    if (options.dispatchToStateManager) {
-      await session.stateManager.dispatch(event);
-    }
-    this.params.publishEndpointEvent(event);
-    session.publisher.publish(event);
-    if (options.persistSession !== false) {
-      await this.params.persistSession(session.sessionId);
-    }
-  };
-  streamSessionEvents = (payloadOrParams, opts) => {
-    return (async function* (self) {
-      const payload = "payload" in payloadOrParams && "signal" in payloadOrParams ? payloadOrParams.payload : payloadOrParams;
-      const signal = "payload" in payloadOrParams && "signal" in payloadOrParams ? payloadOrParams.signal : opts?.signal ?? new AbortController().signal;
-      const session = await self.params.sessionRegistry.ensureSession(
-        payload.sessionId
-      );
-      const queue = createAsyncQueue();
-      const unsubscribe = session.publisher.subscribe((event) => {
-        queue.push(event);
-      });
-      const unsubscribeClose = session.publisher.onClose(() => {
-        queue.close();
-      });
-      const stop = () => {
-        unsubscribe();
-        unsubscribeClose();
-        queue.close();
-        signal.removeEventListener("abort", stop);
-      };
-      signal.addEventListener("abort", stop, { once: true });
-      try {
-        for await (const event of queue.iterable) {
-          if (signal.aborted) {
-            break;
-          }
-          yield event;
-        }
-      } finally {
-        stop();
-      }
-    })(this);
-  };
-  appendMessage = async (sessionId, message) => {
-    const normalizedSessionId = sessionId.trim();
-    if (!normalizedSessionId) {
-      return null;
-    }
-    let liveSession = this.params.sessionRegistry.getSession(normalizedSessionId);
-    if (!liveSession) {
-      const storedSession = await this.params.sessionStore.getSession(normalizedSessionId);
-      if (!storedSession) {
-        return null;
-      }
-      liveSession = await this.params.sessionRegistry.ensureSession(normalizedSessionId);
-    }
-    const nextMessage = {
-      ...structuredClone(message),
-      sessionId: normalizedSessionId
-    };
-    await this.publishSessionEvent(
-      liveSession,
-      {
-        type: NcpEventType4.MessageSent,
-        payload: {
-          sessionId: normalizedSessionId,
-          message: nextMessage
-        }
-      },
-      {
-        dispatchToStateManager: true
-      }
-    );
-    return this.params.getSessionSummary(normalizedSessionId);
-  };
-  updateToolCallResult = async (sessionId, toolCallId, content) => {
-    const normalizedSessionId = sessionId.trim();
-    const normalizedToolCallId = toolCallId.trim();
-    if (!normalizedSessionId || !normalizedToolCallId) {
-      return null;
-    }
-    const liveSession = await this.params.sessionRegistry.ensureSession(normalizedSessionId);
-    await this.publishSessionEvent(
-      liveSession,
-      {
-        type: NcpEventType4.MessageToolCallResult,
-        payload: {
-          sessionId: normalizedSessionId,
-          toolCallId: normalizedToolCallId,
-          content
-        }
-      },
-      {
-        dispatchToStateManager: true
-      }
-    );
-    return this.params.getSessionSummary(normalizedSessionId);
-  };
+	constructor(params) {
+		this.params = params;
+	}
+	publishSessionEvent = async (session, event, options = {}) => {
+		if (options.dispatchToStateManager) await session.stateManager.dispatch(event);
+		this.params.publishEndpointEvent(event);
+		session.publisher.publish(event);
+		if (options.persistSession !== false) await this.params.persistSession(session.sessionId);
+	};
+	streamSessionEvents = (payloadOrParams, opts) => {
+		return (async function* (self) {
+			const payload = "payload" in payloadOrParams && "signal" in payloadOrParams ? payloadOrParams.payload : payloadOrParams;
+			const signal = "payload" in payloadOrParams && "signal" in payloadOrParams ? payloadOrParams.signal : opts?.signal ?? new AbortController().signal;
+			const queue = createAsyncQueue();
+			const unsubscribe = self.params.subscribeEndpointEvent((event) => {
+				if (readEventSessionId(event) !== payload.sessionId) return;
+				queue.push(event);
+			});
+			const stop = () => {
+				unsubscribe();
+				queue.close();
+				signal.removeEventListener("abort", stop);
+			};
+			const liveSession = self.params.sessionRegistry.getSession(payload.sessionId);
+			const unsubscribeClose = liveSession ? liveSession.publisher.onClose(() => {
+				queue.close();
+			}) : () => void 0;
+			signal.addEventListener("abort", stop, { once: true });
+			try {
+				for await (const event of queue.iterable) {
+					if (signal.aborted) break;
+					yield event;
+				}
+			} finally {
+				unsubscribeClose();
+				stop();
+			}
+		})(this);
+	};
+	appendMessage = async (sessionId, message) => {
+		const normalizedSessionId = sessionId.trim();
+		if (!normalizedSessionId) return null;
+		let liveSession = this.params.sessionRegistry.getSession(normalizedSessionId);
+		if (!liveSession) {
+			if (!await this.params.sessionStore.getSession(normalizedSessionId)) return null;
+			liveSession = await this.params.sessionRegistry.ensureSession(normalizedSessionId);
+		}
+		const nextMessage = {
+			...structuredClone(message),
+			sessionId: normalizedSessionId
+		};
+		await this.publishSessionEvent(liveSession, {
+			type: NcpEventType.MessageSent,
+			payload: {
+				sessionId: normalizedSessionId,
+				message: nextMessage
+			}
+		}, { dispatchToStateManager: true });
+		return this.params.getSessionSummary(normalizedSessionId);
+	};
+	updateToolCallResult = async (sessionId, toolCallId, content) => {
+		const normalizedSessionId = sessionId.trim();
+		const normalizedToolCallId = toolCallId.trim();
+		if (!normalizedSessionId || !normalizedToolCallId) return null;
+		const liveSession = await this.params.sessionRegistry.ensureSession(normalizedSessionId);
+		await this.publishSessionEvent(liveSession, {
+			type: NcpEventType.MessageToolCallResult,
+			payload: {
+				sessionId: normalizedSessionId,
+				toolCallId: normalizedToolCallId,
+				content
+			}
+		}, { dispatchToStateManager: true });
+		return this.params.getSessionSummary(normalizedSessionId);
+	};
 };
-
-// src/agent/agent-backend/agent-backend-session-utils.ts
-import { NcpEventType as NcpEventType5 } from "@nextclaw/ncp";
-var AUTO_SESSION_LABEL_MAX_LENGTH = 64;
-function readOptionalAgentId2(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().toLowerCase();
-  return trimmed.length > 0 ? trimmed : void 0;
+//#endregion
+//#region src/agent/agent-backend/agent-backend-session-utils.ts
+const AUTO_SESSION_LABEL_MAX_LENGTH = 64;
+function readOptionalAgentId$1(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim().toLowerCase();
+	return trimmed.length > 0 ? trimmed : void 0;
 }
 function readMessages(snapshot) {
-  const messages = snapshot.messages.map((message) => structuredClone(message));
-  if (snapshot.streamingMessage) {
-    messages.push(structuredClone(snapshot.streamingMessage));
-  }
-  return messages;
+	const messages = snapshot.messages.map((message) => structuredClone(message));
+	if (snapshot.streamingMessage) messages.push(structuredClone(snapshot.streamingMessage));
+	return messages;
 }
 function toSessionSummary(session, liveSession) {
-  const metadata = withAutoSessionLabel({
-    metadata: session.metadata ? structuredClone({
-      ...session.metadata,
-      ...liveSession?.metadata ? liveSession.metadata : {}
-    }) : liveSession?.metadata ? structuredClone(liveSession.metadata) : {},
-    messages: session.messages
-  });
-  return {
-    sessionId: session.sessionId,
-    ...readOptionalAgentId2(session.agentId) ? { agentId: readOptionalAgentId2(session.agentId) } : {},
-    messageCount: session.messages.length,
-    updatedAt: session.updatedAt,
-    status: liveSession?.activeExecution ? "running" : "idle",
-    ...Object.keys(metadata).length > 0 ? { metadata } : {}
-  };
+	const metadata = withAutoSessionLabel({
+		metadata: session.metadata ? structuredClone({
+			...session.metadata,
+			...liveSession?.metadata ? liveSession.metadata : {}
+		}) : liveSession?.metadata ? structuredClone(liveSession.metadata) : {},
+		messages: session.messages
+	});
+	return {
+		sessionId: session.sessionId,
+		...readOptionalAgentId$1(session.agentId) ? { agentId: readOptionalAgentId$1(session.agentId) } : {},
+		messageCount: session.messages.length,
+		updatedAt: session.updatedAt,
+		status: liveSession?.activeExecution ? "running" : "idle",
+		...Object.keys(metadata).length > 0 ? { metadata } : {}
+	};
 }
 function toLiveSessionSummary(session) {
-  const snapshot = session.stateManager.getSnapshot();
-  const messages = readMessages(snapshot);
-  const metadata = withAutoSessionLabel({
-    metadata: Object.keys(session.metadata).length > 0 ? structuredClone(session.metadata) : session.activeExecution?.requestEnvelope.metadata ? structuredClone(session.activeExecution.requestEnvelope.metadata) : {},
-    messages
-  });
-  return {
-    sessionId: session.sessionId,
-    ...readOptionalAgentId2(session.agentId) ? { agentId: readOptionalAgentId2(session.agentId) } : {},
-    messageCount: messages.length,
-    updatedAt: now(),
-    status: session.activeExecution ? "running" : "idle",
-    ...Object.keys(metadata).length > 0 ? { metadata } : {}
-  };
+	const messages = readMessages(session.stateManager.getSnapshot());
+	const metadata = withAutoSessionLabel({
+		metadata: Object.keys(session.metadata).length > 0 ? structuredClone(session.metadata) : session.activeExecution?.requestEnvelope.metadata ? structuredClone(session.activeExecution.requestEnvelope.metadata) : {},
+		messages
+	});
+	return {
+		sessionId: session.sessionId,
+		...readOptionalAgentId$1(session.agentId) ? { agentId: readOptionalAgentId$1(session.agentId) } : {},
+		messageCount: messages.length,
+		updatedAt: now(),
+		status: session.activeExecution ? "running" : "idle",
+		...Object.keys(metadata).length > 0 ? { metadata } : {}
+	};
 }
 function now() {
-  return (/* @__PURE__ */ new Date()).toISOString();
+	return (/* @__PURE__ */ new Date()).toISOString();
 }
 function readOptionalString(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
 }
 function truncateLabel(value) {
-  const characters = Array.from(value);
-  if (characters.length <= AUTO_SESSION_LABEL_MAX_LENGTH) {
-    return value;
-  }
-  return `${characters.slice(0, AUTO_SESSION_LABEL_MAX_LENGTH).join("")}\u2026`;
+	const characters = Array.from(value);
+	if (characters.length <= AUTO_SESSION_LABEL_MAX_LENGTH) return value;
+	return `${characters.slice(0, AUTO_SESSION_LABEL_MAX_LENGTH).join("")}…`;
 }
 function resolveAutoSessionLabelFromMessages(messages) {
-  for (const message of messages) {
-    if (message.role !== "user") {
-      continue;
-    }
-    for (const part of message.parts) {
-      if (part.type === "text" || part.type === "rich-text") {
-        const text = readOptionalString(part.text);
-        if (text) {
-          return truncateLabel(text);
-        }
-      }
-    }
-  }
-  return null;
+	for (const message of messages) {
+		if (message.role !== "user") continue;
+		for (const part of message.parts) if (part.type === "text" || part.type === "rich-text") {
+			const text = readOptionalString(part.text);
+			if (text) return truncateLabel(text);
+		}
+	}
+	return null;
 }
 function withAutoSessionLabel(params) {
-  const existingLabel = readOptionalString(params.metadata.label);
-  if (existingLabel) {
-    return params.metadata;
-  }
-  const nextLabel = resolveAutoSessionLabelFromMessages(params.messages);
-  if (!nextLabel) {
-    return params.metadata;
-  }
-  return {
-    ...params.metadata,
-    label: nextLabel
-  };
+	if (readOptionalString(params.metadata.label)) return params.metadata;
+	const nextLabel = resolveAutoSessionLabelFromMessages(params.messages);
+	if (!nextLabel) return params.metadata;
+	return {
+		...params.metadata,
+		label: nextLabel
+	};
 }
-
-// src/agent/agent-backend/agent-backend-session-persistence.ts
-function readOptionalAgentId3(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().toLowerCase();
-  return trimmed.length > 0 ? trimmed : void 0;
+//#endregion
+//#region src/agent/agent-backend/agent-backend-session-persistence.ts
+function readOptionalAgentId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim().toLowerCase();
+	return trimmed.length > 0 ? trimmed : void 0;
 }
-function readAgentIdFromMetadata2(metadata) {
-  return readOptionalAgentId3(metadata?.agent_id) ?? readOptionalAgentId3(metadata?.agentId);
+function readAgentIdFromMetadata(metadata) {
+	return readOptionalAgentId(metadata?.agent_id) ?? readOptionalAgentId(metadata?.agentId);
 }
 function resolvePersistedAgentId(params) {
-  return readOptionalAgentId3(params.liveSession?.agentId) ?? readOptionalAgentId3(params.storedSession?.agentId) ?? readAgentIdFromMetadata2(params.liveSession?.metadata) ?? readAgentIdFromMetadata2(params.storedSession?.metadata);
+	return readOptionalAgentId(params.liveSession?.agentId) ?? readOptionalAgentId(params.storedSession?.agentId) ?? readAgentIdFromMetadata(params.liveSession?.metadata) ?? readAgentIdFromMetadata(params.storedSession?.metadata);
 }
 function buildUpdatedSessionRecord(params) {
-  const nextMetadata = params.patch.metadata === null ? {} : params.patch.metadata ? structuredClone(params.patch.metadata) : structuredClone(params.liveSession?.metadata ?? params.storedSession?.metadata ?? {});
-  if (params.liveSession) {
-    params.liveSession.metadata = structuredClone(nextMetadata);
-  }
-  return {
-    sessionId: params.sessionId,
-    ...resolvePersistedAgentId({
-      liveSession: params.liveSession,
-      storedSession: params.storedSession
-    }) ? {
-      agentId: resolvePersistedAgentId({
-        liveSession: params.liveSession,
-        storedSession: params.storedSession
-      })
-    } : {},
-    messages: params.liveSession ? readMessages(params.liveSession.stateManager.getSnapshot()) : params.storedSession?.messages.map((message) => structuredClone(message)) ?? [],
-    updatedAt: params.updatedAt,
-    metadata: nextMetadata
-  };
+	const nextMetadata = params.patch.metadata === null ? {} : params.patch.metadata ? structuredClone(params.patch.metadata) : structuredClone(params.liveSession?.metadata ?? params.storedSession?.metadata ?? {});
+	if (params.liveSession) params.liveSession.metadata = structuredClone(nextMetadata);
+	return {
+		sessionId: params.sessionId,
+		...resolvePersistedAgentId({
+			liveSession: params.liveSession,
+			storedSession: params.storedSession
+		}) ? { agentId: resolvePersistedAgentId({
+			liveSession: params.liveSession,
+			storedSession: params.storedSession
+		}) } : {},
+		messages: params.liveSession ? readMessages(params.liveSession.stateManager.getSnapshot()) : params.storedSession?.messages.map((message) => structuredClone(message)) ?? [],
+		updatedAt: params.updatedAt,
+		metadata: nextMetadata
+	};
 }
 function buildPersistedLiveSessionRecord(params) {
-  const messages = readMessages(params.session.stateManager.getSnapshot());
-  const metadata = withAutoSessionLabel({
-    metadata: {
-      ...params.session.metadata ? structuredClone(params.session.metadata) : {},
-      ...params.session.activeExecution?.requestEnvelope.metadata ? structuredClone(params.session.activeExecution.requestEnvelope.metadata) : {}
-    },
-    messages
-  });
-  return {
-    sessionId: params.sessionId,
-    ...readOptionalAgentId3(params.session.agentId) ?? readAgentIdFromMetadata2(params.session.metadata) ?? readAgentIdFromMetadata2(params.session.activeExecution?.requestEnvelope.metadata) ? {
-      agentId: readOptionalAgentId3(params.session.agentId) ?? readAgentIdFromMetadata2(params.session.metadata) ?? readAgentIdFromMetadata2(params.session.activeExecution?.requestEnvelope.metadata)
-    } : {},
-    messages,
-    updatedAt: params.updatedAt,
-    metadata
-  };
+	const messages = readMessages(params.session.stateManager.getSnapshot());
+	const metadata = withAutoSessionLabel({
+		metadata: {
+			...params.session.metadata ? structuredClone(params.session.metadata) : {},
+			...params.session.activeExecution?.requestEnvelope.metadata ? structuredClone(params.session.activeExecution.requestEnvelope.metadata) : {}
+		},
+		messages
+	});
+	return {
+		sessionId: params.sessionId,
+		...readOptionalAgentId(params.session.agentId) ?? readAgentIdFromMetadata(params.session.metadata) ?? readAgentIdFromMetadata(params.session.activeExecution?.requestEnvelope.metadata) ? { agentId: readOptionalAgentId(params.session.agentId) ?? readAgentIdFromMetadata(params.session.metadata) ?? readAgentIdFromMetadata(params.session.activeExecution?.requestEnvelope.metadata) } : {},
+		messages,
+		updatedAt: params.updatedAt,
+		metadata
+	};
 }
-
-// src/agent/agent-backend/agent-backend.ts
-var DEFAULT_SUPPORTED_PART_TYPES = [
-  "text",
-  "file",
-  "source",
-  "step-start",
-  "reasoning",
-  "tool-invocation",
-  "card",
-  "rich-text",
-  "action",
-  "extension"
+//#endregion
+//#region src/agent/agent-backend/agent-backend.ts
+const DEFAULT_SUPPORTED_PART_TYPES = [
+	"text",
+	"file",
+	"source",
+	"step-start",
+	"reasoning",
+	"tool-invocation",
+	"card",
+	"rich-text",
+	"action",
+	"extension"
 ];
 var DefaultNcpAgentBackend = class {
-  manifest;
-  sessionStore;
-  onSessionRunStatusChanged;
-  sessionRegistry;
-  executor;
-  publisher;
-  sessionRealtime;
-  started = false;
-  constructor(config) {
-    this.sessionStore = config.sessionStore;
-    this.onSessionRunStatusChanged = config.onSessionRunStatusChanged;
-    this.sessionRegistry = new AgentLiveSessionRegistry(
-      this.sessionStore,
-      config.createRuntime
-    );
-    this.executor = new AgentRunExecutor();
-    this.publisher = new EventPublisher();
-    this.sessionRealtime = new AgentBackendSessionRealtime({
-      sessionRegistry: this.sessionRegistry,
-      sessionStore: this.sessionStore,
-      publishEndpointEvent: (event) => this.publishEndpointEvent(event),
-      persistSession: (sessionId) => this.persistSession(sessionId),
-      getSessionSummary: (sessionId) => this.getSession(sessionId)
-    });
-    this.manifest = {
-      endpointKind: "agent",
-      endpointId: config.endpointId?.trim() || "ncp-agent-backend",
-      version: config.version?.trim() || "0.1.0",
-      supportsStreaming: true,
-      supportsAbort: true,
-      supportsProactiveMessages: false,
-      supportsLiveSessionStream: true,
-      supportedPartTypes: config.supportedPartTypes ?? DEFAULT_SUPPORTED_PART_TYPES,
-      expectedLatency: config.expectedLatency ?? "seconds",
-      metadata: config.metadata
-    };
-  }
-  start = async () => {
-    if (this.started) {
-      return;
-    }
-    this.started = true;
-    this.publisher.publish({ type: NcpEventType6.EndpointReady });
-  };
-  stop = async () => {
-    if (!this.started) {
-      return;
-    }
-    this.started = false;
-    for (const session of this.sessionRegistry.listSessions()) {
-      const execution = session.activeExecution;
-      if (!execution) {
-        session.publisher.close();
-        continue;
-      }
-      execution.abortHandled = true;
-      execution.controller.abort();
-      this.finishSessionExecution(session, execution);
-      session.publisher.close();
-    }
-    this.sessionRegistry.clear();
-  };
-  emit = async (event) => {
-    await this.ensureStarted();
-    switch (event.type) {
-      case NcpEventType6.MessageRequest:
-        for await (const emittedEvent of this.send(event.payload)) {
-          void emittedEvent;
-        }
-        return;
-      case NcpEventType6.MessageStreamRequest:
-        await this.ensureStarted();
-        return;
-      case NcpEventType6.MessageAbort:
-        await this.handleAbort(event.payload);
-        return;
-      default:
-        this.publisher.publish(event);
-    }
-  };
-  subscribe = (listener) => {
-    return this.publisher.subscribe(listener);
-  };
-  send = (envelope, options) => {
-    return (async function* (self) {
-      await self.ensureStarted();
-      const session = await self.sessionRegistry.ensureSession(
-        envelope.sessionId,
-        envelope.metadata
-      );
-      const execution = self.startSessionExecution(
-        session,
-        envelope,
-        options?.signal
-      );
-      try {
-        for await (const event of self.executor.executeRun(
-          session,
-          envelope,
-          execution.controller
-        )) {
-          await self.sessionRealtime.publishSessionEvent(session, event);
-          yield event;
-        }
-        if (execution.controller.signal.aborted && !execution.abortHandled) {
-          const abortEvent = {
-            type: NcpEventType6.MessageAbort,
-            payload: {
-              sessionId: session.sessionId
-            }
-          };
-          execution.abortHandled = true;
-          await self.sessionRealtime.publishSessionEvent(session, abortEvent, {
-            dispatchToStateManager: true
-          });
-          yield abortEvent;
-        }
-      } finally {
-        self.finishSessionExecution(session, execution);
-        await self.persistSession(session.sessionId);
-      }
-    })(this);
-  };
-  abort = async (payload) => {
-    await this.handleAbort(payload);
-  };
-  stream = (payloadOrParams, opts) => this.sessionRealtime.streamSessionEvents(payloadOrParams, opts);
-  listSessions = async () => {
-    const storedSessions = await this.sessionStore.listSessions();
-    const summaries = storedSessions.map(
-      (session) => toSessionSummary(
-        session,
-        this.sessionRegistry.getSession(session.sessionId)
-      )
-    );
-    for (const liveSession of this.sessionRegistry.listSessions()) {
-      if (summaries.some((session) => session.sessionId === liveSession.sessionId)) {
-        continue;
-      }
-      summaries.push(toLiveSessionSummary(liveSession));
-    }
-    return summaries.sort(
-      (left, right) => right.updatedAt.localeCompare(left.updatedAt)
-    );
-  };
-  listSessionMessages = async (sessionId) => {
-    const liveSession = this.sessionRegistry.getSession(sessionId);
-    if (liveSession)
-      return readMessages(liveSession.stateManager.getSnapshot());
-    const session = await this.sessionStore.getSession(sessionId);
-    return session ? session.messages.map((message) => structuredClone(message)) : [];
-  };
-  getSession = async (sessionId) => {
-    const liveSession = this.sessionRegistry.getSession(sessionId);
-    const storedSession = await this.sessionStore.getSession(sessionId);
-    return storedSession ? toSessionSummary(storedSession, liveSession) : liveSession ? toLiveSessionSummary(liveSession) : null;
-  };
-  appendMessage = async (sessionId, message) => {
-    await this.ensureStarted();
-    return this.sessionRealtime.appendMessage(sessionId, message);
-  };
-  updateToolCallResult = async (sessionId, toolCallId, content) => {
-    await this.ensureStarted();
-    return this.sessionRealtime.updateToolCallResult(
-      sessionId,
-      toolCallId,
-      content
-    );
-  };
-  updateSession = async (sessionId, patch) => {
-    const liveSession = this.sessionRegistry.getSession(sessionId);
-    const storedSession = await this.sessionStore.getSession(sessionId);
-    if (!liveSession && !storedSession) return null;
-    await this.sessionStore.replaceSession(
-      buildUpdatedSessionRecord({
-        sessionId,
-        patch,
-        liveSession,
-        storedSession,
-        updatedAt: now()
-      })
-    );
-    return this.getSession(sessionId);
-  };
-  deleteSession = async (sessionId) => {
-    const liveSession = this.sessionRegistry.deleteSession(sessionId);
-    const execution = liveSession?.activeExecution;
-    if (execution) {
-      execution.abortHandled = true;
-      execution.controller.abort();
-      closeAgentBackendSessionExecution(execution);
-    }
-    liveSession?.publisher.close();
-    await this.sessionStore.deleteSession(sessionId);
-  };
-  ensureStarted = async () => {
-    if (!this.started) {
-      await this.start();
-    }
-  };
-  startSessionExecution = (session, envelope, signal) => startAgentBackendSessionExecution({
-    session,
-    envelope,
-    signal,
-    onStatusChanged: this.onSessionRunStatusChanged
-  });
-  finishSessionExecution = (session, execution) => finishAgentBackendSessionExecution({
-    session,
-    execution,
-    onStatusChanged: this.onSessionRunStatusChanged
-  });
-  publishEndpointEvent = (event) => {
-    this.publisher.publish(event);
-  };
-  handleAbort = async (payload) => {
-    const session = this.sessionRegistry.getSession(payload.sessionId);
-    const execution = session?.activeExecution;
-    if (!session || !execution || execution.closed) {
-      return;
-    }
-    execution.abortHandled = true;
-    execution.controller.abort();
-    const abortEvent = {
-      type: NcpEventType6.MessageAbort,
-      payload: {
-        sessionId: payload.sessionId,
-        ...payload.messageId ? { messageId: payload.messageId } : {}
-      }
-    };
-    await this.sessionRealtime.publishSessionEvent(session, abortEvent, {
-      dispatchToStateManager: true
-    });
-    this.finishSessionExecution(session, execution);
-  };
-  persistSession = async (sessionId) => {
-    const session = this.sessionRegistry.getSession(sessionId);
-    if (!session) return;
-    await this.sessionStore.saveSession(
-      buildPersistedLiveSessionRecord({
-        sessionId,
-        session,
-        updatedAt: now()
-      })
-    );
-  };
+	manifest;
+	sessionStore;
+	onSessionRunStatusChanged;
+	sessionRegistry;
+	executor;
+	publisher;
+	sessionRealtime;
+	started = false;
+	constructor(config) {
+		this.sessionStore = config.sessionStore;
+		this.onSessionRunStatusChanged = config.onSessionRunStatusChanged;
+		this.sessionRegistry = new AgentLiveSessionRegistry(this.sessionStore, config.createRuntime);
+		this.executor = new AgentRunExecutor();
+		this.publisher = new EventPublisher();
+		this.sessionRealtime = new AgentBackendSessionRealtime({
+			sessionRegistry: this.sessionRegistry,
+			sessionStore: this.sessionStore,
+			publishEndpointEvent: (event) => this.publisher.publish(event),
+			subscribeEndpointEvent: (listener) => this.publisher.subscribe(listener),
+			persistSession: (sessionId) => this.persistSession(sessionId),
+			getSessionSummary: (sessionId) => this.getSession(sessionId)
+		});
+		this.manifest = {
+			endpointKind: "agent",
+			endpointId: config.endpointId?.trim() || "ncp-agent-backend",
+			version: config.version?.trim() || "0.1.0",
+			supportsStreaming: true,
+			supportsAbort: true,
+			supportsProactiveMessages: false,
+			supportsLiveSessionStream: true,
+			supportedPartTypes: config.supportedPartTypes ?? DEFAULT_SUPPORTED_PART_TYPES,
+			expectedLatency: config.expectedLatency ?? "seconds",
+			metadata: config.metadata
+		};
+	}
+	start = async () => {
+		if (this.started) return;
+		this.started = true;
+		this.publisher.publish({ type: NcpEventType.EndpointReady });
+	};
+	stop = async () => {
+		if (!this.started) return;
+		this.started = false;
+		for (const session of this.sessionRegistry.listSessions()) {
+			const execution = session.activeExecution;
+			if (!execution) {
+				session.publisher.close();
+				continue;
+			}
+			execution.abortHandled = true;
+			execution.controller.abort();
+			this.finishSessionExecution(session, execution);
+			session.publisher.close();
+		}
+		this.sessionRegistry.clear();
+	};
+	emit = async (event) => {
+		await this.ensureStarted();
+		switch (event.type) {
+			case NcpEventType.MessageRequest:
+				for await (const emittedEvent of this.send(event.payload));
+				return;
+			case NcpEventType.MessageStreamRequest:
+				await this.ensureStarted();
+				return;
+			case NcpEventType.MessageAbort:
+				await this.handleAbort(event.payload);
+				return;
+			default: this.publisher.publish(event);
+		}
+	};
+	subscribe = (listener) => {
+		return this.publisher.subscribe(listener);
+	};
+	send = (envelope, options) => {
+		return (async function* (self) {
+			await self.ensureStarted();
+			const session = await self.sessionRegistry.ensureSession(envelope.sessionId, envelope.metadata);
+			const execution = self.startSessionExecution(session, envelope, options?.signal);
+			try {
+				for await (const event of self.executor.executeRun(session, envelope, execution.controller)) {
+					await self.sessionRealtime.publishSessionEvent(session, event);
+					yield event;
+				}
+				if (execution.controller.signal.aborted && !execution.abortHandled) {
+					const abortEvent = {
+						type: NcpEventType.MessageAbort,
+						payload: { sessionId: session.sessionId }
+					};
+					execution.abortHandled = true;
+					await self.sessionRealtime.publishSessionEvent(session, abortEvent, { dispatchToStateManager: true });
+					yield abortEvent;
+				}
+			} finally {
+				self.finishSessionExecution(session, execution);
+				await self.persistSession(session.sessionId);
+			}
+		})(this);
+	};
+	abort = async (payload) => {
+		await this.handleAbort(payload);
+	};
+	stream = (payloadOrParams, opts) => this.sessionRealtime.streamSessionEvents(payloadOrParams, opts);
+	listSessions = async () => {
+		const summaries = (await this.sessionStore.listSessions()).map((session) => toSessionSummary(session, this.sessionRegistry.getSession(session.sessionId)));
+		for (const liveSession of this.sessionRegistry.listSessions()) {
+			if (summaries.some((session) => session.sessionId === liveSession.sessionId)) continue;
+			summaries.push(toLiveSessionSummary(liveSession));
+		}
+		return summaries.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+	};
+	listSessionMessages = async (sessionId) => {
+		const liveSession = this.sessionRegistry.getSession(sessionId);
+		if (liveSession) return readMessages(liveSession.stateManager.getSnapshot());
+		const session = await this.sessionStore.getSession(sessionId);
+		return session ? session.messages.map((message) => structuredClone(message)) : [];
+	};
+	getSession = async (sessionId) => {
+		const liveSession = this.sessionRegistry.getSession(sessionId);
+		const storedSession = await this.sessionStore.getSession(sessionId);
+		return storedSession ? toSessionSummary(storedSession, liveSession) : liveSession ? toLiveSessionSummary(liveSession) : null;
+	};
+	appendMessage = async (sessionId, message) => {
+		await this.ensureStarted();
+		return this.sessionRealtime.appendMessage(sessionId, message);
+	};
+	updateToolCallResult = async (sessionId, toolCallId, content) => {
+		await this.ensureStarted();
+		return this.sessionRealtime.updateToolCallResult(sessionId, toolCallId, content);
+	};
+	updateSession = async (sessionId, patch) => {
+		const liveSession = this.sessionRegistry.getSession(sessionId);
+		const storedSession = await this.sessionStore.getSession(sessionId);
+		if (!liveSession && !storedSession) return null;
+		await this.sessionStore.replaceSession(buildUpdatedSessionRecord({
+			sessionId,
+			patch,
+			liveSession,
+			storedSession,
+			updatedAt: now()
+		}));
+		return this.getSession(sessionId);
+	};
+	deleteSession = async (sessionId) => {
+		const liveSession = this.sessionRegistry.deleteSession(sessionId);
+		const execution = liveSession?.activeExecution;
+		if (execution) {
+			execution.abortHandled = true;
+			execution.controller.abort();
+			closeAgentBackendSessionExecution(execution);
+		}
+		liveSession?.publisher.close();
+		await this.sessionStore.deleteSession(sessionId);
+	};
+	ensureStarted = async () => {
+		if (!this.started) await this.start();
+	};
+	startSessionExecution = (session, envelope, signal) => startAgentBackendSessionExecution({
+		session,
+		envelope,
+		signal,
+		onStatusChanged: this.onSessionRunStatusChanged
+	});
+	finishSessionExecution = (session, execution) => finishAgentBackendSessionExecution({
+		session,
+		execution,
+		onStatusChanged: this.onSessionRunStatusChanged
+	});
+	handleAbort = async (payload) => {
+		const session = this.sessionRegistry.getSession(payload.sessionId);
+		const execution = session?.activeExecution;
+		if (!session || !execution || execution.closed) return;
+		execution.abortHandled = true;
+		execution.controller.abort();
+		const abortEvent = {
+			type: NcpEventType.MessageAbort,
+			payload: {
+				sessionId: payload.sessionId,
+				...payload.messageId ? { messageId: payload.messageId } : {}
+			}
+		};
+		await this.sessionRealtime.publishSessionEvent(session, abortEvent, { dispatchToStateManager: true });
+		this.finishSessionExecution(session, execution);
+	};
+	persistSession = async (sessionId) => {
+		const session = this.sessionRegistry.getSession(sessionId);
+		if (!session) return;
+		await this.sessionStore.saveSession(buildPersistedLiveSessionRecord({
+			sessionId,
+			session,
+			updatedAt: now()
+		}));
+	};
 };
-
-// src/agent/agent-backend/in-memory-agent-session-store.ts
+//#endregion
+//#region src/agent/agent-backend/in-memory-agent-session-store.ts
 var InMemoryAgentSessionStore = class {
-  sessions = /* @__PURE__ */ new Map();
-  getSession = async (sessionId) => {
-    const session = this.sessions.get(sessionId);
-    return session ? structuredClone(session) : null;
-  };
-  listSessions = async () => {
-    return [...this.sessions.values()].map((session) => structuredClone(session));
-  };
-  saveSession = async (session) => {
-    this.sessions.set(session.sessionId, structuredClone(session));
-  };
-  replaceSession = async (session) => {
-    this.sessions.set(session.sessionId, structuredClone(session));
-  };
-  deleteSession = async (sessionId) => {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return null;
-    }
-    this.sessions.delete(sessionId);
-    return structuredClone(session);
-  };
-};
-export {
-  AgentRunExecutor,
-  DefaultNcpAgentBackend,
-  DefaultNcpAgentConversationStateManager,
-  EventPublisher,
-  InMemoryAgentSessionStore,
-  NcpErrorException,
-  createAgentClientFromServer
+	sessions = /* @__PURE__ */ new Map();
+	getSession = async (sessionId) => {
+		const session = this.sessions.get(sessionId);
+		return session ? structuredClone(session) : null;
+	};
+	listSessions = async () => {
+		return [...this.sessions.values()].map((session) => structuredClone(session));
+	};
+	saveSession = async (session) => {
+		this.sessions.set(session.sessionId, structuredClone(session));
+	};
+	replaceSession = async (session) => {
+		this.sessions.set(session.sessionId, structuredClone(session));
+	};
+	deleteSession = async (sessionId) => {
+		const session = this.sessions.get(sessionId);
+		if (!session) return null;
+		this.sessions.delete(sessionId);
+		return structuredClone(session);
+	};
 };
+//#endregion
+export { AgentRunExecutor, DefaultNcpAgentBackend, DefaultNcpAgentConversationStateManager, EventPublisher, InMemoryAgentSessionStore, NcpErrorException, createAgentClientFromServer };