@nextclaw/ncp 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+//#region src/types/message.d.ts
 /**
  * Participants in an NCP conversation.
  *
@@ -23,8 +24,8 @@ declare function isHiddenNcpMessage(message: Pick<NcpMessage, "metadata"> | null
 type NcpMessageStatus = "pending" | "streaming" | "final" | "error";
 /** Plain text content. The most common part type. */
 type NcpTextPart = {
-    type: "text";
-    text: string;
+  type: "text";
+  text: string;
 };
 /**
  * A file attachment, delivered either as a URL or inline Base64 content.
@@ -32,39 +33,34 @@ type NcpTextPart = {
  * `url` and `contentBase64` are mutually exclusive — populate exactly one.
  */
 type NcpFilePart = {
-    type: "file";
-    name?: string;
-    mimeType?: string;
-    /** Stable logical asset reference managed by the hosting app. */
-    assetUri?: string;
-    /** Remote URL pointing to the file. Mutually exclusive with `contentBase64`. */
-    url?: string;
-    /** Inline file content encoded as Base64. Mutually exclusive with `url`. */
-    contentBase64?: string;
-    sizeBytes?: number;
+  type: "file";
+  name?: string;
+  mimeType?: string; /** Stable logical asset reference managed by the hosting app. */
+  assetUri?: string; /** Remote URL pointing to the file. Mutually exclusive with `contentBase64`. */
+  url?: string; /** Inline file content encoded as Base64. Mutually exclusive with `url`. */
+  contentBase64?: string;
+  sizeBytes?: number;
 };
 /** A cited source or reference, typically surfaced alongside AI-generated content. */
 type NcpSourcePart = {
-    type: "source";
-    title?: string;
-    url?: string;
-    /** Short excerpt from the source relevant to the message. */
-    snippet?: string;
+  type: "source";
+  title?: string;
+  url?: string; /** Short excerpt from the source relevant to the message. */
+  snippet?: string;
 };
 /**
  * Marks the beginning of a logical reasoning step in a multi-step response.
  * Used by chain-of-thought or agentic flows to delimit discrete steps.
  */
 type NcpStepStartPart = {
-    type: "step-start";
-    stepId?: string;
-    /** Human-readable label for the step (e.g. "Searching the web"). */
-    title?: string;
+  type: "step-start";
+  stepId?: string; /** Human-readable label for the step (e.g. "Searching the web"). */
+  title?: string;
 };
 /** Internal reasoning text produced by the model before its final response. */
 type NcpReasoningPart = {
-    type: "reasoning";
-    text: string;
+  type: "reasoning";
+  text: string;
 };
 /**
  * Represents a tool call and its lifecycle.
@@ -75,40 +71,36 @@ type NcpReasoningPart = {
  * - `"result"`       — The tool has returned; `result` is populated.
  */
 type NcpToolInvocationPart = {
-    type: "tool-invocation";
-    toolName: string;
-    toolCallId?: string;
-    state?: "call" | "partial-call" | "result";
-    /** Tool input arguments. May be partial when `state === "partial-call"`. */
-    args?: unknown;
-    /** Tool output. Populated when `state === "result"`. */
-    result?: unknown;
+  type: "tool-invocation";
+  toolName: string;
+  toolCallId?: string;
+  state?: "call" | "partial-call" | "result"; /** Tool input arguments. May be partial when `state === "partial-call"`. */
+  args?: unknown; /** Tool output. Populated when `state === "result"`. */
+  result?: unknown;
 };
 /**
  * A rich card with arbitrary structured data.
  * Rendering is delegated to the platform (e.g. Slack block kit, Teams card).
  */
 type NcpCardPart = {
-    type: "card";
-    payload: Record<string, unknown>;
+  type: "card";
+  payload: Record<string, unknown>;
 };
 /** Formatted text with an explicit markup format hint. */
 type NcpRichTextPart = {
-    type: "rich-text";
-    format: "markdown" | "html" | "plain";
-    text: string;
+  type: "rich-text";
+  format: "markdown" | "html" | "plain";
+  text: string;
 };
 /**
  * An interactive action button or trigger exposed to the user.
  * The platform is responsible for rendering and routing the action.
  */
 type NcpActionPart = {
-    type: "action";
-    actionId: string;
-    /** Display label shown to the user. */
-    label: string;
-    /** Arbitrary data forwarded to the action handler. */
-    payload?: unknown;
+  type: "action";
+  actionId: string; /** Display label shown to the user. */
+  label: string; /** Arbitrary data forwarded to the action handler. */
+  payload?: unknown;
 };
 /**
  * Escape hatch for custom or future part types not yet in the NCP spec.
@@ -117,10 +109,9 @@ type NcpActionPart = {
  * Once a part type stabilizes, promote it to a first-class `NcpXxxPart`.
  */
 type NcpExtensionPart = {
-    type: "extension";
-    /** Namespaced identifier for the custom part (e.g. `"myapp.highlight"`). */
-    extensionType: string;
-    data: unknown;
+  type: "extension"; /** Namespaced identifier for the custom part (e.g. `"myapp.highlight"`). */
+  extensionType: string;
+  data: unknown;
 };
 /** Union of all recognized NCP message part types. */
 type NcpMessagePart = NcpTextPart | NcpFilePart | NcpSourcePart | NcpStepStartPart | NcpReasoningPart | NcpToolInvocationPart | NcpCardPart | NcpRichTextPart | NcpActionPart | NcpExtensionPart;
@@ -131,19 +122,16 @@ type NcpMessagePart = NcpTextPart | NcpFilePart | NcpSourcePart | NcpStepStartPa
  * heterogeneous content (text, files, tool calls, etc.) in a single message.
  */
 type NcpMessage = {
-    /** Globally unique message identifier. */
-    id: string;
-    /** The session this message belongs to. */
-    sessionId: string;
-    role: NcpMessageRole;
-    status: NcpMessageStatus;
-    parts: NcpMessagePart[];
-    /** ISO 8601 timestamp (e.g. `"2024-01-15T10:30:00.000Z"`). */
-    timestamp: string;
-    /** Arbitrary transport- or application-level metadata. */
-    metadata?: Record<string, unknown>;
-};
-
+  /** Globally unique message identifier. */id: string; /** The session this message belongs to. */
+  sessionId: string;
+  role: NcpMessageRole;
+  status: NcpMessageStatus;
+  parts: NcpMessagePart[]; /** ISO 8601 timestamp (e.g. `"2024-01-15T10:30:00.000Z"`). */
+  timestamp: string; /** Arbitrary transport- or application-level metadata. */
+  metadata?: Record<string, unknown>;
+};
+//#endregion
+//#region src/types/manifest.d.ts
 /**
  * High-level category of an endpoint.
  *
@@ -170,32 +158,24 @@ type NcpEndpointLatency = "realtime" | "seconds" | "minutes" | "hours" | "days";
  * or whether an existing run can be streamed again.
  */
 type NcpEndpointManifest = {
-    /** Category of this endpoint. */
-    endpointKind: NcpEndpointKind;
-    /** Stable unique identifier for this endpoint instance. */
-    endpointId: string;
-    /** SemVer string for the adapter implementation. */
-    version: string;
-    /** Whether this endpoint supports incremental streaming of message content. */
-    supportsStreaming: boolean;
-    /** Whether in-flight requests can be cancelled via `AbortSignal`. */
-    supportsAbort: boolean;
-    /** Whether this endpoint can push messages without a prior user request. */
-    supportsProactiveMessages: boolean;
-    /** Whether this endpoint can stream the live events of an active session by `sessionId`. */
-    supportsLiveSessionStream: boolean;
-    /**
-     * The subset of `NcpMessagePart` types this endpoint can send or receive.
-     * Using the literal union from `NcpMessagePart["type"]` prevents typos
-     * and keeps the manifest in sync with the protocol definition.
-     */
-    supportedPartTypes: ReadonlyArray<NcpMessagePart["type"]>;
-    /** Expected response latency — informs timeouts and UX treatment. */
-    expectedLatency: NcpEndpointLatency;
-    /** Arbitrary adapter- or deployment-specific metadata. */
-    metadata?: Record<string, unknown>;
-};
-
+  /** Category of this endpoint. */endpointKind: NcpEndpointKind; /** Stable unique identifier for this endpoint instance. */
+  endpointId: string; /** SemVer string for the adapter implementation. */
+  version: string; /** Whether this endpoint supports incremental streaming of message content. */
+  supportsStreaming: boolean; /** Whether in-flight requests can be cancelled via `AbortSignal`. */
+  supportsAbort: boolean; /** Whether this endpoint can push messages without a prior user request. */
+  supportsProactiveMessages: boolean; /** Whether this endpoint can stream the live events of an active session by `sessionId`. */
+  supportsLiveSessionStream: boolean;
+  /**
+   * The subset of `NcpMessagePart` types this endpoint can send or receive.
+   * Using the literal union from `NcpMessagePart["type"]` prevents typos
+   * and keeps the manifest in sync with the protocol definition.
+   */
+  supportedPartTypes: ReadonlyArray<NcpMessagePart["type"]>; /** Expected response latency — informs timeouts and UX treatment. */
+  expectedLatency: NcpEndpointLatency; /** Arbitrary adapter- or deployment-specific metadata. */
+  metadata?: Record<string, unknown>;
+};
+//#endregion
+//#region src/types/errors.d.ts
 /**
  * Protocol-level error categories.
  *
@@ -210,48 +190,132 @@ type NcpErrorCode = "config-error" | "auth-error" | "runtime-error" | "timeout-e
  * boundaries so that error metadata survives serialization.
  */
 type NcpError = {
-    /** Machine-readable category. */
-    code: NcpErrorCode;
-    /** Human-readable description intended for developers, not end-users. */
-    message: string;
-    /** Optional structured context (request ids, field paths, etc.). */
-    details?: Record<string, unknown>;
-    /** Original cause — preserved for debugging but not guaranteed serializable. */
-    cause?: unknown;
+  /** Machine-readable category. */code: NcpErrorCode; /** Human-readable description intended for developers, not end-users. */
+  message: string; /** Optional structured context (request ids, field paths, etc.). */
+  details?: Record<string, unknown>; /** Original cause — preserved for debugging but not guaranteed serializable. */
+  cause?: unknown;
 };
-
+//#endregion
+//#region src/types/session.d.ts
 type NcpSessionStatus = "idle" | "running";
 type NcpSessionSummary = {
-    sessionId: string;
-    agentId?: string;
-    messageCount: number;
-    updatedAt: string;
-    status?: NcpSessionStatus;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  agentId?: string;
+  messageCount: number;
+  updatedAt: string;
+  lastMessageAt?: string;
+  status?: NcpSessionStatus;
+  metadata?: Record<string, unknown>;
 };
 type ListSessionsOptions = {
-    limit?: number;
-    cursor?: string;
+  limit?: number;
+  cursor?: string;
 };
 type ListMessagesOptions = {
-    limit?: number;
-    cursor?: string;
+  limit?: number;
+  cursor?: string;
 };
 type NcpSessionPatch = {
-    metadata?: Record<string, unknown> | null;
+  metadata?: Record<string, unknown> | null;
 };
 /**
  * API for session list, message history, and session lifecycle.
  * Implementations that support persistence can provide this alongside NcpAgentClientEndpoint.
  */
 interface NcpSessionApi {
-    listSessions(options?: ListSessionsOptions): Promise<NcpSessionSummary[]>;
-    listSessionMessages(sessionId: string, options?: ListMessagesOptions): Promise<NcpMessage[]>;
-    getSession(sessionId: string): Promise<NcpSessionSummary | null>;
-    updateSession(sessionId: string, patch: NcpSessionPatch): Promise<NcpSessionSummary | null>;
-    deleteSession(sessionId: string): Promise<void>;
+  listSessions(options?: ListSessionsOptions): Promise<NcpSessionSummary[]>;
+  listSessionMessages(sessionId: string, options?: ListMessagesOptions): Promise<NcpMessage[]>;
+  getSession(sessionId: string): Promise<NcpSessionSummary | null>;
+  updateSession(sessionId: string, patch: NcpSessionPatch): Promise<NcpSessionSummary | null>;
+  deleteSession(sessionId: string): Promise<void>;
 }
-
+//#endregion
+//#region src/agent-runtime/llm-api.d.ts
+type OpenAIContentPart = {
+  type: "text";
+  text: string;
+} | {
+  type: "image_url";
+  image_url: {
+    url: string;
+    detail?: "low" | "high" | "auto";
+  };
+};
+type OpenAIToolCall = {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+type OpenAIChatMessage = {
+  role: "system";
+  content: string;
+} | {
+  role: "user";
+  content: string | OpenAIContentPart[];
+} | {
+  role: "assistant";
+  content?: string | null;
+  reasoning_content?: string;
+  tool_calls?: OpenAIToolCall[];
+} | {
+  role: "tool";
+  content: string;
+  tool_call_id: string;
+};
+type OpenAITool = {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+};
+type OpenAIToolCallDelta = {
+  index?: number;
+  id?: string;
+  type?: "function";
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+};
+type OpenAIChatChunk = {
+  id?: string;
+  choices?: Array<{
+    index?: number;
+    delta?: {
+      content?: string | null;
+      tool_calls?: OpenAIToolCallDelta[];
+      reasoning_content?: string;
+      reasoning?: string;
+    };
+    finish_reason?: string | null;
+  }>;
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+};
+type NcpLLMApiInput = {
+  messages: OpenAIChatMessage[];
+  tools?: OpenAITool[];
+  model?: string;
+  thinkingLevel?: string | null;
+  max_tokens?: number;
+};
+type NcpLLMApiOptions = {
+  signal?: AbortSignal;
+  temperature?: number;
+};
+interface NcpLLMApi {
+  generate(input: NcpLLMApiInput, options?: NcpLLMApiOptions): AsyncIterable<OpenAIChatChunk>;
+}
+//#endregion
+//#region src/types/events.d.ts
 /**
  * NCP event and payload definitions.
  *
@@ -260,329 +324,335 @@ interface NcpSessionApi {
  * instead; endpoints or upper layers choose as needed.
  */
 type NcpRequestEnvelope = {
-    sessionId: string;
-    message: NcpMessage;
-    correlationId?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  message: NcpMessage;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
+  providerRoute?: NcpProviderRuntimeRoute;
+  tools?: ReadonlyArray<OpenAITool>;
+};
+type NcpProviderRuntimeRoute = {
+  model: string;
+  apiKey?: string | null;
+  apiBase?: string | null;
+  headers: Record<string, string>;
 };
 /** Payload for message.incoming: message content from the other peer (partial or full). */
 type NcpResponseEnvelope = {
-    sessionId: string;
-    message: NcpMessage;
-    correlationId?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  message: NcpMessage;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
 };
 type NcpCompletedEnvelope = {
-    sessionId: string;
-    message: NcpMessage;
-    correlationId?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  message: NcpMessage;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
 };
 type NcpFailedEnvelope = {
-    sessionId: string;
-    messageId?: string;
-    error: NcpError;
-    correlationId?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  messageId?: string;
+  error: NcpError;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
 };
 type NcpMessageAcceptedPayload = {
-    messageId: string;
-    correlationId?: string;
-    transportId?: string;
+  messageId: string;
+  correlationId?: string;
+  transportId?: string;
 };
 /** Payload for message.abort: identifies which session's active execution to cancel. */
 type NcpMessageAbortPayload = {
-    sessionId: string;
-    messageId?: string;
+  sessionId: string;
+  messageId?: string;
 };
 /**
  * Payload for message.stream-request: attach to the live event stream of a session.
  * Used when reconnecting during an active response or attaching another live reader.
  */
 type NcpStreamRequestPayload = {
-    sessionId: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  metadata?: Record<string, unknown>;
 };
 /**
  * Payload for message.sent: the local peer has sent a message (outbound).
  * Typically non-streaming; add the message to the local conversation state.
  */
 type NcpMessageSentPayload = {
-    sessionId: string;
-    message: NcpMessage;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  message: NcpMessage;
+  metadata?: Record<string, unknown>;
 };
 type NcpTypingStartPayload = {
-    sessionId: string;
-    /** Participant who is typing (human user or bot/assistant). */
-    userId?: string;
+  sessionId: string; /** Participant who is typing (human user or bot/assistant). */
+  userId?: string;
 };
 type NcpTypingEndPayload = {
-    sessionId: string;
-    /** Participant who stopped typing (human user or bot/assistant). */
-    userId?: string;
+  sessionId: string; /** Participant who stopped typing (human user or bot/assistant). */
+  userId?: string;
 };
 type NcpPresenceUpdatedPayload = {
-    sessionId: string;
-    /** Participant this presence applies to (human user or bot/assistant). */
-    userId?: string;
-    status: "online" | "offline" | "away";
+  sessionId: string; /** Participant this presence applies to (human user or bot/assistant). */
+  userId?: string;
+  status: "online" | "offline" | "away";
 };
 type NcpMessageReadPayload = {
-    sessionId: string;
-    messageId: string;
-    readAt?: string;
-    readerId?: string;
+  sessionId: string;
+  messageId: string;
+  readAt?: string;
+  readerId?: string;
 };
 type NcpMessageDeliveredPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpMessageRecalledPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpMessageReactionPayload = {
-    sessionId: string;
-    messageId: string;
-    reaction: string;
-    added: boolean;
-    /** Participant who added or removed the reaction (human user or bot/assistant). */
-    userId?: string;
+  sessionId: string;
+  messageId: string;
+  reaction: string;
+  added: boolean; /** Participant who added or removed the reaction (human user or bot/assistant). */
+  userId?: string;
 };
 type NcpRunStartedPayload = {
-    sessionId?: string;
-    messageId?: string;
-    threadId?: string;
-    runId?: string;
+  sessionId?: string;
+  messageId?: string;
+  threadId?: string;
+  runId?: string;
 };
 type NcpRunFinishedPayload = {
-    sessionId?: string;
-    messageId?: string;
-    threadId?: string;
-    runId?: string;
+  sessionId?: string;
+  messageId?: string;
+  threadId?: string;
+  runId?: string;
 };
 type NcpRunErrorPayload = {
-    sessionId?: string;
-    messageId?: string;
-    error?: string;
-    threadId?: string;
-    runId?: string;
+  sessionId?: string;
+  messageId?: string;
+  error?: string;
+  threadId?: string;
+  runId?: string;
 };
 type NcpRunMetadataPayload = {
-    sessionId?: string;
-    messageId?: string;
-    runId?: string;
-    metadata: Record<string, unknown>;
+  sessionId?: string;
+  messageId?: string;
+  runId?: string;
+  metadata: Record<string, unknown>;
 };
 type NcpTextStartPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpTextDeltaPayload = {
-    sessionId: string;
-    messageId: string;
-    delta: string;
+  sessionId: string;
+  messageId: string;
+  delta: string;
 };
 type NcpTextEndPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpReasoningStartPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpReasoningDeltaPayload = {
-    sessionId: string;
-    messageId: string;
-    delta: string;
+  sessionId: string;
+  messageId: string;
+  delta: string;
 };
 type NcpReasoningEndPayload = {
-    sessionId: string;
-    messageId: string;
+  sessionId: string;
+  messageId: string;
 };
 type NcpToolCallStartPayload = {
-    sessionId: string;
-    messageId?: string;
-    toolCallId: string;
-    toolName: string;
+  sessionId: string;
+  messageId?: string;
+  toolCallId: string;
+  toolName: string;
 };
 type NcpToolCallArgsPayload = {
-    sessionId: string;
-    toolCallId: string;
-    args: string;
+  sessionId: string;
+  toolCallId: string;
+  args: string;
 };
 type NcpToolCallArgsDeltaPayload = {
-    sessionId: string;
-    messageId?: string;
-    toolCallId: string;
-    delta: string;
+  sessionId: string;
+  messageId?: string;
+  toolCallId: string;
+  delta: string;
 };
 type NcpToolCallEndPayload = {
-    sessionId: string;
-    toolCallId: string;
+  sessionId: string;
+  toolCallId: string;
 };
 type NcpToolCallResultPayload = {
-    sessionId: string;
-    toolCallId: string;
-    content: unknown;
+  sessionId: string;
+  toolCallId: string;
+  content: unknown;
 };
 declare enum NcpEventType {
-    EndpointReady = "endpoint.ready",
-    EndpointError = "endpoint.error",
-    MessageRequest = "message.request",
-    MessageStreamRequest = "message.stream-request",
-    MessageSent = "message.sent",
-    MessageAccepted = "message.accepted",
-    MessageIncoming = "message.incoming",
-    MessageCompleted = "message.completed",
-    MessageFailed = "message.failed",
-    MessageAbort = "message.abort",
-    MessageTextStart = "message.text-start",
-    MessageTextDelta = "message.text-delta",
-    MessageTextEnd = "message.text-end",
-    MessageReasoningStart = "message.reasoning-start",
-    MessageReasoningDelta = "message.reasoning-delta",
-    MessageReasoningEnd = "message.reasoning-end",
-    MessageToolCallStart = "message.tool-call-start",
-    MessageToolCallArgs = "message.tool-call-args",
-    MessageToolCallArgsDelta = "message.tool-call-args-delta",
-    MessageToolCallEnd = "message.tool-call-end",
-    MessageToolCallResult = "message.tool-call-result",
-    MessageRead = "message.read",
-    MessageDelivered = "message.delivered",
-    MessageRecalled = "message.recalled",
-    MessageReaction = "message.reaction",
-    RunStarted = "run.started",
-    RunFinished = "run.finished",
-    RunError = "run.error",
-    RunMetadata = "run.metadata",
-    TypingStart = "typing.start",
-    TypingEnd = "typing.end",
-    PresenceUpdated = "presence.updated"
+  EndpointReady = "endpoint.ready",
+  EndpointError = "endpoint.error",
+  MessageRequest = "message.request",
+  MessageStreamRequest = "message.stream-request",
+  MessageSent = "message.sent",
+  MessageAccepted = "message.accepted",
+  MessageIncoming = "message.incoming",
+  MessageCompleted = "message.completed",
+  MessageFailed = "message.failed",
+  MessageAbort = "message.abort",
+  MessageTextStart = "message.text-start",
+  MessageTextDelta = "message.text-delta",
+  MessageTextEnd = "message.text-end",
+  MessageReasoningStart = "message.reasoning-start",
+  MessageReasoningDelta = "message.reasoning-delta",
+  MessageReasoningEnd = "message.reasoning-end",
+  MessageToolCallStart = "message.tool-call-start",
+  MessageToolCallArgs = "message.tool-call-args",
+  MessageToolCallArgsDelta = "message.tool-call-args-delta",
+  MessageToolCallEnd = "message.tool-call-end",
+  MessageToolCallResult = "message.tool-call-result",
+  MessageRead = "message.read",
+  MessageDelivered = "message.delivered",
+  MessageRecalled = "message.recalled",
+  MessageReaction = "message.reaction",
+  RunStarted = "run.started",
+  RunFinished = "run.finished",
+  RunError = "run.error",
+  RunMetadata = "run.metadata",
+  TypingStart = "typing.start",
+  TypingEnd = "typing.end",
+  PresenceUpdated = "presence.updated"
 }
 type NcpEndpointEvent = {
-    type: NcpEventType.EndpointReady;
+  type: NcpEventType.EndpointReady;
 } | {
-    type: NcpEventType.MessageRequest;
-    payload: NcpRequestEnvelope;
+  type: NcpEventType.MessageRequest;
+  payload: NcpRequestEnvelope;
 } | {
-    type: NcpEventType.MessageStreamRequest;
-    payload: NcpStreamRequestPayload;
+  type: NcpEventType.MessageStreamRequest;
+  payload: NcpStreamRequestPayload;
 } | {
-    type: NcpEventType.MessageSent;
-    payload: NcpMessageSentPayload;
+  type: NcpEventType.MessageSent;
+  payload: NcpMessageSentPayload;
 } | {
-    type: NcpEventType.MessageAccepted;
-    payload: NcpMessageAcceptedPayload;
+  type: NcpEventType.MessageAccepted;
+  payload: NcpMessageAcceptedPayload;
 } | {
-    type: NcpEventType.MessageIncoming;
-    payload: NcpResponseEnvelope;
+  type: NcpEventType.MessageIncoming;
+  payload: NcpResponseEnvelope;
 } | {
-    type: NcpEventType.MessageCompleted;
-    payload: NcpCompletedEnvelope;
+  type: NcpEventType.MessageCompleted;
+  payload: NcpCompletedEnvelope;
 } | {
-    type: NcpEventType.MessageFailed;
-    payload: NcpFailedEnvelope;
+  type: NcpEventType.MessageFailed;
+  payload: NcpFailedEnvelope;
 } | {
-    type: NcpEventType.MessageAbort;
-    payload: NcpMessageAbortPayload;
+  type: NcpEventType.MessageAbort;
+  payload: NcpMessageAbortPayload;
 } | {
-    type: NcpEventType.EndpointError;
-    payload: NcpError;
+  type: NcpEventType.EndpointError;
+  payload: NcpError;
 } | {
-    type: NcpEventType.RunStarted;
-    payload: NcpRunStartedPayload;
+  type: NcpEventType.RunStarted;
+  payload: NcpRunStartedPayload;
 } | {
-    type: NcpEventType.RunFinished;
-    payload: NcpRunFinishedPayload;
+  type: NcpEventType.RunFinished;
+  payload: NcpRunFinishedPayload;
 } | {
-    type: NcpEventType.RunError;
-    payload: NcpRunErrorPayload;
+  type: NcpEventType.RunError;
+  payload: NcpRunErrorPayload;
 } | {
-    type: NcpEventType.RunMetadata;
-    payload: NcpRunMetadataPayload;
+  type: NcpEventType.RunMetadata;
+  payload: NcpRunMetadataPayload;
 } | {
-    type: NcpEventType.MessageTextStart;
-    payload: NcpTextStartPayload;
+  type: NcpEventType.MessageTextStart;
+  payload: NcpTextStartPayload;
 } | {
-    type: NcpEventType.MessageTextDelta;
-    payload: NcpTextDeltaPayload;
+  type: NcpEventType.MessageTextDelta;
+  payload: NcpTextDeltaPayload;
 } | {
-    type: NcpEventType.MessageTextEnd;
-    payload: NcpTextEndPayload;
+  type: NcpEventType.MessageTextEnd;
+  payload: NcpTextEndPayload;
 } | {
-    type: NcpEventType.MessageReasoningStart;
-    payload: NcpReasoningStartPayload;
+  type: NcpEventType.MessageReasoningStart;
+  payload: NcpReasoningStartPayload;
 } | {
-    type: NcpEventType.MessageReasoningDelta;
-    payload: NcpReasoningDeltaPayload;
+  type: NcpEventType.MessageReasoningDelta;
+  payload: NcpReasoningDeltaPayload;
 } | {
-    type: NcpEventType.MessageReasoningEnd;
-    payload: NcpReasoningEndPayload;
+  type: NcpEventType.MessageReasoningEnd;
+  payload: NcpReasoningEndPayload;
 } | {
-    type: NcpEventType.MessageToolCallStart;
-    payload: NcpToolCallStartPayload;
+  type: NcpEventType.MessageToolCallStart;
+  payload: NcpToolCallStartPayload;
 } | {
-    type: NcpEventType.MessageToolCallArgs;
-    payload: NcpToolCallArgsPayload;
+  type: NcpEventType.MessageToolCallArgs;
+  payload: NcpToolCallArgsPayload;
 } | {
-    type: NcpEventType.MessageToolCallArgsDelta;
-    payload: NcpToolCallArgsDeltaPayload;
+  type: NcpEventType.MessageToolCallArgsDelta;
+  payload: NcpToolCallArgsDeltaPayload;
 } | {
-    type: NcpEventType.MessageToolCallEnd;
-    payload: NcpToolCallEndPayload;
+  type: NcpEventType.MessageToolCallEnd;
+  payload: NcpToolCallEndPayload;
 } | {
-    type: NcpEventType.MessageToolCallResult;
-    payload: NcpToolCallResultPayload;
+  type: NcpEventType.MessageToolCallResult;
+  payload: NcpToolCallResultPayload;
 } | {
-    type: NcpEventType.TypingStart;
-    payload: NcpTypingStartPayload;
+  type: NcpEventType.TypingStart;
+  payload: NcpTypingStartPayload;
 } | {
-    type: NcpEventType.TypingEnd;
-    payload: NcpTypingEndPayload;
+  type: NcpEventType.TypingEnd;
+  payload: NcpTypingEndPayload;
 } | {
-    type: NcpEventType.PresenceUpdated;
-    payload: NcpPresenceUpdatedPayload;
+  type: NcpEventType.PresenceUpdated;
+  payload: NcpPresenceUpdatedPayload;
 } | {
-    type: NcpEventType.MessageRead;
-    payload: NcpMessageReadPayload;
+  type: NcpEventType.MessageRead;
+  payload: NcpMessageReadPayload;
 } | {
-    type: NcpEventType.MessageDelivered;
-    payload: NcpMessageDeliveredPayload;
+  type: NcpEventType.MessageDelivered;
+  payload: NcpMessageDeliveredPayload;
 } | {
-    type: NcpEventType.MessageRecalled;
-    payload: NcpMessageRecalledPayload;
+  type: NcpEventType.MessageRecalled;
+  payload: NcpMessageRecalledPayload;
 } | {
-    type: NcpEventType.MessageReaction;
-    payload: NcpMessageReactionPayload;
+  type: NcpEventType.MessageReaction;
+  payload: NcpMessageReactionPayload;
 };
 type NcpEndpointSubscriber = (event: NcpEndpointEvent) => void;
-
+//#endregion
+//#region src/types/run.d.ts
 /**
  * Run-related types: snapshot state and run.metadata schema conventions.
  * Not event payloads — event payloads live in events.ts.
  */
 /** Current run state for agent snapshot. Used by UI for run status and abort. */
 type NcpRunContext = {
-    runId: string | null;
-    sessionId?: string;
-    abortDisabledReason?: string | null;
+  runId: string | null;
+  sessionId?: string;
+  abortDisabledReason?: string | null;
 };
 /** Schema for run.metadata.metadata when kind is "ready" (run started, backend ready). */
 type NcpRunReadyMetadata = {
-    kind: "ready";
-    runId?: string;
-    sessionId?: string;
-    supportsAbort?: boolean;
-    abortDisabledReason?: string;
+  kind: "ready";
+  runId?: string;
+  sessionId?: string;
+  supportsAbort?: boolean;
+  abortDisabledReason?: string;
 };
 /** Schema for run.metadata.metadata when kind is "final" (run finished). */
 type NcpRunFinalMetadata = {
-    kind: "final";
-    sessionId?: string;
+  kind: "final";
+  sessionId?: string;
 };
-
+//#endregion
+//#region src/types/endpoint.d.ts
 /**
  * Core interface every NCP endpoint adapter must implement.
  *
@@ -597,40 +667,41 @@ type NcpRunFinalMetadata = {
  * await endpoint.emit({ type: NcpEventType.MessageRequest, payload: envelope });
  */
 interface NcpEndpoint {
-    /** Static capability declaration — available before `start()` is called. */
-    readonly manifest: NcpEndpointManifest;
-    /**
-     * Initializes the endpoint (opens connections, authenticates, etc.).
-     * Must be called before `emit`. Idempotent — safe to call more than once.
-     */
-    start(): Promise<void>;
-    /**
-     * Gracefully shuts down the endpoint and releases resources.
-     * Idempotent — safe to call more than once.
-     */
-    stop(): Promise<void>;
-    /**
-     * Sends an event to the remote participant (or broadcasts to local subscribers).
-     *
-     * For outbound events (e.g. message.request, message.abort), the implementation
-     * forwards to the wire. For symmetric in-process setups, it may broadcast locally.
-     */
-    emit(event: NcpEndpointEvent): Promise<void>;
-    /**
-     * Subscribes to endpoint events.
-     *
-     * @param listener - Called for every event emitted by this endpoint.
-     * @returns An unsubscribe function. Call it to stop receiving events.
-     *
-     * @example
-     * const unsubscribe = endpoint.subscribe((event) => {
-     *   if (event.type === NcpEventType.MessageCompleted) handleReply(event.payload);
-     * });
-     * unsubscribe();
-     */
-    subscribe(listener: NcpEndpointSubscriber): () => void;
+  /** Static capability declaration — available before `start()` is called. */
+  readonly manifest: NcpEndpointManifest;
+  /**
+   * Initializes the endpoint (opens connections, authenticates, etc.).
+   * Must be called before `emit`. Idempotent — safe to call more than once.
+   */
+  start(): Promise<void>;
+  /**
+   * Gracefully shuts down the endpoint and releases resources.
+   * Idempotent — safe to call more than once.
+   */
+  stop(): Promise<void>;
+  /**
+   * Sends an event to the remote participant (or broadcasts to local subscribers).
+   *
+   * For outbound events (e.g. message.request, message.abort), the implementation
+   * forwards to the wire. For symmetric in-process setups, it may broadcast locally.
+   */
+  emit(event: NcpEndpointEvent): Promise<void>;
+  /**
+   * Subscribes to endpoint events.
+   *
+   * @param listener - Called for every event emitted by this endpoint.
+   * @returns An unsubscribe function. Call it to stop receiving events.
+   *
+   * @example
+   * const unsubscribe = endpoint.subscribe((event) => {
+   *   if (event.type === NcpEventType.MessageCompleted) handleReply(event.payload);
+   * });
+   * unsubscribe();
+   */
+  subscribe(listener: NcpEndpointSubscriber): () => void;
 }
-
+//#endregion
+//#region src/endpoint/agent-client-endpoint.d.ts
 /**
  * Client-side endpoint for agent chat: initiates requests and can cancel in-flight runs.
  *
@@ -638,14 +709,15 @@ interface NcpEndpoint {
  * (e.g. frontend, CLI) that sends user messages and receives agent responses.
  */
 interface NcpAgentClientEndpoint extends NcpEndpoint {
-    /** Sends a new message request to the agent. Emits `message.request`. */
-    send(envelope: NcpRequestEnvelope): Promise<void>;
-    /** Attaches to the live event stream of a session. Emits `message.stream-request`. */
-    stream(payload: NcpStreamRequestPayload): Promise<void>;
-    /** Aborts the active execution of a session. Emits `message.abort`. */
-    abort(payload: NcpMessageAbortPayload): Promise<void>;
+  /** Sends a new message request to the agent. Emits `message.request`. */
+  send(envelope: NcpRequestEnvelope): Promise<void>;
+  /** Attaches to the live event stream of a session. Emits `message.stream-request`. */
+  stream(payload: NcpStreamRequestPayload): Promise<void>;
+  /** Aborts the active execution of a session. Emits `message.abort`. */
+  abort(payload: NcpMessageAbortPayload): Promise<void>;
 }
-
+//#endregion
+//#region src/endpoint/agent-server-endpoint.d.ts
 /**
  * Agent server-side endpoint: receives requests and produces downstream events.
  *
@@ -654,235 +726,158 @@ interface NcpAgentClientEndpoint extends NcpEndpoint {
  * downstream events (`message.incoming`, streaming deltas, `message.completed`, etc.).
  */
 interface NcpAgentServerEndpoint extends NcpEndpoint {
-    readonly manifest: NcpEndpointManifest & {
-        endpointKind: "agent";
-    };
-    /** Handles a new message request from client side and yields produced events. */
-    send(envelope: NcpRequestEnvelope, options?: {
-        signal?: AbortSignal;
-    }): AsyncIterable<NcpEndpointEvent>;
-    /** Streams live events for an active session and yields produced events. */
-    stream(payload: NcpStreamRequestPayload, options?: {
-        signal?: AbortSignal;
-    }): AsyncIterable<NcpEndpointEvent>;
-    /** Aborts the active execution of a session on server side. */
-    abort(payload: NcpMessageAbortPayload): Promise<void>;
-    /**
-     * Publishes server-downstream events (typically sent to frontend subscribers/transports).
-     * For handling client requests, prefer `send` / `stream` / `abort`.
-     */
-    emit(event: NcpEndpointEvent): Promise<void>;
+  readonly manifest: NcpEndpointManifest & {
+    endpointKind: "agent";
+  };
+  /** Handles a new message request from client side and yields produced events. */
+  send(envelope: NcpRequestEnvelope, options?: {
+    signal?: AbortSignal;
+  }): AsyncIterable<NcpEndpointEvent>;
+  /** Streams live events for an active session and yields produced events. */
+  stream(payload: NcpStreamRequestPayload, options?: {
+    signal?: AbortSignal;
+  }): AsyncIterable<NcpEndpointEvent>;
+  /** Aborts the active execution of a session on server side. */
+  abort(payload: NcpMessageAbortPayload): Promise<void>;
+  /**
+   * Publishes server-downstream events (typically sent to frontend subscribers/transports).
+   * For handling client requests, prefer `send` / `stream` / `abort`.
+   */
+  emit(event: NcpEndpointEvent): Promise<void>;
 }
-
+//#endregion
+//#region src/agent-runtime/runtime.d.ts
 type NcpAgentRunInput = {
-    sessionId: string;
-    messages: ReadonlyArray<NcpMessage>;
-    correlationId?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  messages: ReadonlyArray<NcpMessage>;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
 };
 type NcpAgentRunOptions = {
-    signal?: AbortSignal;
+  signal?: AbortSignal;
 };
 interface NcpAgentRuntime {
-    run(input: NcpAgentRunInput, options?: NcpAgentRunOptions): AsyncIterable<NcpEndpointEvent>;
+  run(input: NcpAgentRunInput, options?: NcpAgentRunOptions): AsyncIterable<NcpEndpointEvent>;
 }
-
-type OpenAIContentPart = {
-    type: "text";
-    text: string;
-} | {
-    type: "image_url";
-    image_url: {
-        url: string;
-        detail?: "low" | "high" | "auto";
-    };
-};
-type OpenAIToolCall = {
-    id: string;
-    type: "function";
-    function: {
-        name: string;
-        arguments: string;
-    };
-};
-type OpenAIChatMessage = {
-    role: "system";
-    content: string;
-} | {
-    role: "user";
-    content: string | OpenAIContentPart[];
-} | {
-    role: "assistant";
-    content?: string | null;
-    reasoning_content?: string;
-    tool_calls?: OpenAIToolCall[];
-} | {
-    role: "tool";
-    content: string;
-    tool_call_id: string;
-};
-type OpenAITool = {
-    type: "function";
-    function: {
-        name: string;
-        description?: string;
-        parameters?: Record<string, unknown>;
-    };
-};
-type OpenAIToolCallDelta = {
-    index?: number;
-    id?: string;
-    type?: "function";
-    function?: {
-        name?: string;
-        arguments?: string;
-    };
-};
-type OpenAIChatChunk = {
-    id?: string;
-    choices?: Array<{
-        index?: number;
-        delta?: {
-            content?: string | null;
-            tool_calls?: OpenAIToolCallDelta[];
-            reasoning_content?: string;
-            reasoning?: string;
-        };
-        finish_reason?: string | null;
-    }>;
-    usage?: {
-        prompt_tokens?: number;
-        completion_tokens?: number;
-        total_tokens?: number;
-    };
-};
-type NcpLLMApiInput = {
-    messages: OpenAIChatMessage[];
-    tools?: OpenAITool[];
-    model?: string;
-    thinkingLevel?: string | null;
-    max_tokens?: number;
-};
-type NcpLLMApiOptions = {
-    signal?: AbortSignal;
-    temperature?: number;
-};
-interface NcpLLMApi {
-    generate(input: NcpLLMApiInput, options?: NcpLLMApiOptions): AsyncIterable<OpenAIChatChunk>;
-}
-
+//#endregion
+//#region src/agent-runtime/context-builder.d.ts
 type NcpContextPrepareOptions = {
-    sessionMessages?: ReadonlyArray<NcpMessage>;
-    systemPrompt?: string;
-    maxMessages?: number;
+  sessionMessages?: ReadonlyArray<NcpMessage>;
+  systemPrompt?: string;
+  maxMessages?: number;
 };
 interface NcpContextBuilder {
-    prepare(input: NcpAgentRunInput, options?: NcpContextPrepareOptions): NcpLLMApiInput;
+  prepare(input: NcpAgentRunInput, options?: NcpContextPrepareOptions): NcpLLMApiInput;
 }
-
+//#endregion
+//#region src/agent-runtime/tool.d.ts
 type NcpToolDefinition = {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
+  name: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
 };
 interface NcpTool {
-    readonly name: string;
-    readonly description?: string;
-    readonly parameters?: Record<string, unknown>;
-    validateArgs?(args: Record<string, unknown>): string[];
-    execute(args: unknown): Promise<unknown>;
+  readonly name: string;
+  readonly description?: string;
+  readonly parameters?: Record<string, unknown>;
+  validateArgs?(args: Record<string, unknown>): string[];
+  execute(args: unknown): Promise<unknown>;
 }
 type NcpToolCallResult = {
-    toolCallId: string;
-    toolName: string;
-    args: Record<string, unknown> | null;
-    rawArgsText: string;
-    result: unknown;
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, unknown> | null;
+  rawArgsText: string;
+  result: unknown;
 };
 type NcpInvalidToolArgumentsResult = {
-    ok: false;
-    error: {
-        code: "invalid_tool_arguments";
-        message: string;
-        toolCallId: string;
-        toolName: string;
-        rawArgumentsText: string;
-        issues: string[];
-    };
+  ok: false;
+  error: {
+    code: "invalid_tool_arguments";
+    message: string;
+    toolCallId: string;
+    toolName: string;
+    rawArgumentsText: string;
+    issues: string[];
+  };
 };
 interface NcpToolRegistry {
-    listTools(): ReadonlyArray<NcpTool>;
-    getTool(name: string): NcpTool | undefined;
-    getToolDefinitions(): ReadonlyArray<NcpToolDefinition>;
-    execute(toolCallId: string, toolName: string, args: unknown): Promise<unknown>;
+  listTools(): ReadonlyArray<NcpTool>;
+  getTool(name: string): NcpTool | undefined;
+  getToolDefinitions(): ReadonlyArray<NcpToolDefinition>;
+  execute(toolCallId: string, toolName: string, args: unknown): Promise<unknown>;
 }
-
+//#endregion
+//#region src/agent-runtime/stream-encoder.d.ts
 type NcpEncodeContext = {
-    sessionId: string;
-    messageId: string;
-    runId: string;
-    correlationId?: string;
+  sessionId: string;
+  messageId: string;
+  runId: string;
+  correlationId?: string;
 };
 interface NcpStreamEncoder {
-    encode(stream: AsyncIterable<OpenAIChatChunk>, context: NcpEncodeContext): AsyncIterable<NcpEndpointEvent>;
+  encode(stream: AsyncIterable<OpenAIChatChunk>, context: NcpEncodeContext): AsyncIterable<NcpEndpointEvent>;
 }
-
+//#endregion
+//#region src/agent-runtime/round-buffer.d.ts
 type NcpPendingToolCall = {
-    toolCallId: string;
-    toolName: string;
-    args: unknown;
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
 };
 interface NcpRoundBuffer {
-    appendText(delta: string): void;
-    getText(): string;
-    appendToolCall(result: NcpToolCallResult): void;
-    getToolCalls(): ReadonlyArray<NcpToolCallResult>;
-    startToolCall(toolCallId: string, toolName: string): void;
-    appendToolCallArgs(args: unknown): void;
-    consumePendingToolCall(): NcpPendingToolCall | null;
-    clear(): void;
+  appendText(delta: string): void;
+  getText(): string;
+  appendToolCall(result: NcpToolCallResult): void;
+  getToolCalls(): ReadonlyArray<NcpToolCallResult>;
+  startToolCall(toolCallId: string, toolName: string): void;
+  appendToolCallArgs(args: unknown): void;
+  consumePendingToolCall(): NcpPendingToolCall | null;
+  clear(): void;
 }
-
+//#endregion
+//#region src/agent-backend/controller.d.ts
 type NcpAgentRunSendOptions = {
-    signal?: AbortSignal;
+  signal?: AbortSignal;
 };
 type NcpAgentRunStreamOptions = {
-    signal?: AbortSignal;
+  signal?: AbortSignal;
 };
 interface NcpAgentRunApi {
-    send(envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions): AsyncIterable<NcpEndpointEvent>;
-    stream(payload: NcpStreamRequestPayload, options?: NcpAgentRunStreamOptions): AsyncIterable<NcpEndpointEvent>;
-    abort(payload: NcpMessageAbortPayload): Promise<void>;
+  send(envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions): AsyncIterable<NcpEndpointEvent>;
+  stream(payload: NcpStreamRequestPayload, options?: NcpAgentRunStreamOptions): AsyncIterable<NcpEndpointEvent>;
+  abort(payload: NcpMessageAbortPayload): Promise<void>;
 }
 type NcpAgentStreamProvider = {
-    stream(params: {
-        payload: NcpStreamRequestPayload;
-        signal: AbortSignal;
-    }): AsyncIterable<NcpEndpointEvent>;
+  stream(params: {
+    payload: NcpStreamRequestPayload;
+    signal: AbortSignal;
+  }): AsyncIterable<NcpEndpointEvent>;
 };
-
+//#endregion
+//#region src/toolkit/conversation-state.d.ts
 /**
  * Read-only snapshot of conversation state maintained by a state manager.
  *
  * Consumed by UI or other layers; all updates flow through dispatch(event).
  */
 interface NcpConversationSnapshot {
-    /** Ordered list of finalized messages. */
-    readonly messages: ReadonlyArray<NcpMessage>;
-    /**
-     * Message currently being streamed (deltas apply here); null when idle.
-     * When message.completed is dispatched, this is appended to messages and cleared.
-     */
-    readonly streamingMessage: NcpMessage | null;
-    /** Latest error, if any (e.g. from message.failed or endpoint.error). */
-    readonly error: NcpError | null;
+  /** Ordered list of finalized messages. */
+  readonly messages: ReadonlyArray<NcpMessage>;
+  /**
+   * Message currently being streamed (deltas apply here); null when idle.
+   * When message.completed is dispatched, this is appended to messages and cleared.
+   */
+  readonly streamingMessage: NcpMessage | null;
+  /** Latest error, if any (e.g. from message.failed or endpoint.error). */
+  readonly error: NcpError | null;
 }
 /**
  * Agent snapshot: extends base snapshot with active run state.
  * Use for UI run status, abort button enable/disable, and abort payload.
  */
 interface NcpAgentConversationSnapshot extends NcpConversationSnapshot {
-    readonly activeRun: NcpRunContext | null;
+  readonly activeRun: NcpRunContext | null;
 }
 /**
  * State manager that holds conversation state and updates it from NCP events.
@@ -891,29 +886,30 @@ interface NcpAgentConversationSnapshot extends NcpConversationSnapshot {
  * Typically used by agent UIs or runtimes to keep a single source of truth for messages.
  */
 interface NcpConversationStateManager {
-    /** Returns the current snapshot. Call after dispatch or in subscribe callback. */
-    getSnapshot(): NcpConversationSnapshot;
-    /**
-     * Applies an NCP event to internal state (messages, streamingMessage, error).
-     * Notifies subscribers after the update.
-     */
-    dispatch(event: NcpEndpointEvent): Promise<void>;
-    /**
-     * Applies multiple NCP events in order and notifies subscribers once after
-     * the batch finishes mutating state.
-     */
-    dispatchBatch(events: readonly NcpEndpointEvent[]): Promise<void>;
-    /**
-     * Subscribes to state changes. Listener is called after each dispatch that mutates state.
-     * Returns an unsubscribe function.
-     */
-    subscribe(listener: (snapshot: NcpConversationSnapshot) => void): () => void;
+  /** Returns the current snapshot. Call after dispatch or in subscribe callback. */
+  getSnapshot(): NcpConversationSnapshot;
+  /**
+   * Applies an NCP event to internal state (messages, streamingMessage, error).
+   * Notifies subscribers after the update.
+   */
+  dispatch(event: NcpEndpointEvent): Promise<void>;
+  /**
+   * Applies multiple NCP events in order and notifies subscribers once after
+   * the batch finishes mutating state.
+   */
+  dispatchBatch(events: readonly NcpEndpointEvent[]): Promise<void>;
+  /**
+   * Subscribes to state changes. Listener is called after each dispatch that mutates state.
+   * Returns an unsubscribe function.
+   */
+  subscribe(listener: (snapshot: NcpConversationSnapshot) => void): () => void;
 }
-
+//#endregion
+//#region src/toolkit/agent/agent-conversation-state-manager.d.ts
 type NcpAgentConversationHydrationParams = {
-    sessionId: string;
-    messages: ReadonlyArray<NcpMessage>;
-    activeRun?: NcpRunContext | null;
+  sessionId: string;
+  messages: ReadonlyArray<NcpMessage>;
+  activeRun?: NcpRunContext | null;
 };
 /**
  * Agent-scenario state manager: extends the generic conversation state manager
@@ -923,59 +919,61 @@ type NcpAgentConversationHydrationParams = {
  * and use these handlers to update messages, streamingMessage, and error.
  */
 interface NcpAgentConversationStateManager extends NcpConversationStateManager {
-    getSnapshot(): NcpAgentConversationSnapshot;
-    reset(): void;
-    hydrate(payload: NcpAgentConversationHydrationParams): void;
-    /** Local peer sent a message (outbound); typically non-streaming. Add to messages. */
-    handleMessageSent(payload: NcpMessageSentPayload): void;
-    handleMessageAbort(payload: NcpMessageAbortPayload): void;
-    handleMessageTextStart(payload: NcpTextStartPayload): void;
-    handleMessageTextDelta(payload: NcpTextDeltaPayload): void;
-    handleMessageTextEnd(payload: NcpTextEndPayload): void;
-    handleMessageReasoningStart(payload: NcpReasoningStartPayload): void;
-    handleMessageReasoningDelta(payload: NcpReasoningDeltaPayload): void;
-    handleMessageReasoningEnd(payload: NcpReasoningEndPayload): void;
-    handleMessageToolCallStart(payload: NcpToolCallStartPayload): void;
-    handleMessageToolCallArgs(payload: NcpToolCallArgsPayload): void;
-    handleMessageToolCallArgsDelta(payload: NcpToolCallArgsDeltaPayload): void;
-    handleMessageToolCallEnd(payload: NcpToolCallEndPayload): void;
-    handleMessageToolCallResult(payload: NcpToolCallResultPayload): void;
-    handleRunStarted(payload: NcpRunStartedPayload): void;
-    handleRunFinished(payload: NcpRunFinishedPayload): void;
-    handleRunError(payload: NcpRunErrorPayload): void;
-    handleRunMetadata(payload: NcpRunMetadataPayload): void;
-    handleEndpointError(payload: NcpError): void;
+  getSnapshot(): NcpAgentConversationSnapshot;
+  reset(): void;
+  hydrate(payload: NcpAgentConversationHydrationParams): void;
+  /** Local peer sent a message (outbound); typically non-streaming. Add to messages. */
+  handleMessageSent(payload: NcpMessageSentPayload): void;
+  handleMessageAbort(payload: NcpMessageAbortPayload): void;
+  handleMessageTextStart(payload: NcpTextStartPayload): void;
+  handleMessageTextDelta(payload: NcpTextDeltaPayload): void;
+  handleMessageTextEnd(payload: NcpTextEndPayload): void;
+  handleMessageReasoningStart(payload: NcpReasoningStartPayload): void;
+  handleMessageReasoningDelta(payload: NcpReasoningDeltaPayload): void;
+  handleMessageReasoningEnd(payload: NcpReasoningEndPayload): void;
+  handleMessageToolCallStart(payload: NcpToolCallStartPayload): void;
+  handleMessageToolCallArgs(payload: NcpToolCallArgsPayload): void;
+  handleMessageToolCallArgsDelta(payload: NcpToolCallArgsDeltaPayload): void;
+  handleMessageToolCallEnd(payload: NcpToolCallEndPayload): void;
+  handleMessageToolCallResult(payload: NcpToolCallResultPayload): void;
+  handleRunStarted(payload: NcpRunStartedPayload): void;
+  handleRunFinished(payload: NcpRunFinishedPayload): void;
+  handleRunError(payload: NcpRunErrorPayload): void;
+  handleRunMetadata(payload: NcpRunMetadataPayload): void;
+  handleEndpointError(payload: NcpError): void;
 }
-
+//#endregion
+//#region src/toolkit/reply-tags.d.ts
 type NcpReplyTagParseResult = {
-    content: string;
-    replyTo?: string;
+  content: string;
+  replyTo?: string;
 };
 declare function stripReplyTagsFromText(content: string, currentMessageId?: string): NcpReplyTagParseResult;
 declare function sanitizeAssistantReplyTags(message: NcpMessage, currentMessageId?: string): NcpMessage;
-
+//#endregion
+//#region src/toolkit/reasoning-normalization.d.ts
 type NcpAssistantReasoningNormalizationMode = "off" | "think-tags";
 type NcpAssistantReasoningSegment = {
-    type: "text" | "reasoning";
-    text: string;
+  type: "text" | "reasoning";
+  text: string;
 };
 declare function readAssistantReasoningNormalizationMode(value: unknown): NcpAssistantReasoningNormalizationMode | null;
 declare function readAssistantReasoningNormalizationModeFromMetadata(metadata: Record<string, unknown> | null | undefined): NcpAssistantReasoningNormalizationMode | null;
 declare function writeAssistantReasoningNormalizationModeToMetadata(metadata: Record<string, unknown>, mode: NcpAssistantReasoningNormalizationMode): Record<string, unknown>;
 declare class NcpAssistantTextStreamNormalizer {
-    private readonly mode;
-    private buffer;
-    private phase;
-    private stripLeadingTextControlTags;
-    constructor(mode?: NcpAssistantReasoningNormalizationMode);
-    push(delta: string): NcpAssistantReasoningSegment[];
-    finish(): NcpAssistantReasoningSegment[];
-    private flush;
+  private readonly mode;
+  private buffer;
+  private phase;
+  private stripLeadingTextControlTags;
+  constructor(mode?: NcpAssistantReasoningNormalizationMode);
+  push(delta: string): NcpAssistantReasoningSegment[];
+  finish(): NcpAssistantReasoningSegment[];
+  private flush;
 }
 declare function normalizeAssistantText(text: string, mode: NcpAssistantReasoningNormalizationMode): {
-    text: string;
-    reasoning: string;
-    parts: NcpAssistantReasoningSegment[];
+  text: string;
+  reasoning: string;
+  parts: NcpAssistantReasoningSegment[];
 };
-
-export { type ListMessagesOptions, type ListSessionsOptions, NCP_INTERNAL_VISIBILITY_METADATA_KEY, type NcpActionPart, type NcpAgentClientEndpoint, type NcpAgentConversationHydrationParams, type NcpAgentConversationSnapshot, type NcpAgentConversationStateManager, type NcpAgentRunApi, type NcpAgentRunInput, type NcpAgentRunOptions, type NcpAgentRunSendOptions, type NcpAgentRunStreamOptions, type NcpAgentRuntime, type NcpAgentServerEndpoint, type NcpAgentStreamProvider, type NcpAssistantReasoningNormalizationMode, type NcpAssistantReasoningSegment, NcpAssistantTextStreamNormalizer, type NcpCardPart, type NcpCompletedEnvelope, type NcpContextBuilder, type NcpContextPrepareOptions, type NcpConversationSnapshot, type NcpConversationStateManager, type NcpEncodeContext, type NcpEndpoint, type NcpEndpointEvent, type NcpEndpointKind, type NcpEndpointLatency, type NcpEndpointManifest, type NcpEndpointSubscriber, type NcpError, type NcpErrorCode, NcpEventType, type NcpExtensionPart, type NcpFailedEnvelope, type NcpFilePart, type NcpInvalidToolArgumentsResult, type NcpLLMApi, type NcpLLMApiInput, type NcpLLMApiOptions, type NcpMessage, type NcpMessageAbortPayload, type NcpMessageAcceptedPayload, type NcpMessageDeliveredPayload, type NcpMessagePart, type NcpMessageReactionPayload, type NcpMessageReadPayload, type NcpMessageRecalledPayload, type NcpMessageRole, type NcpMessageSentPayload, type NcpMessageStatus, type NcpPendingToolCall, type NcpPresenceUpdatedPayload, type NcpReasoningDeltaPayload, type NcpReasoningEndPayload, type NcpReasoningPart, type NcpReasoningStartPayload, type NcpReplyTagParseResult, type NcpRequestEnvelope, type NcpResponseEnvelope, type NcpRichTextPart, type NcpRoundBuffer, type NcpRunContext, type NcpRunErrorPayload, type NcpRunFinalMetadata, type NcpRunFinishedPayload, type NcpRunMetadataPayload, type NcpRunReadyMetadata, type NcpRunStartedPayload, type NcpSessionApi, type NcpSessionPatch, type NcpSessionStatus, type NcpSessionSummary, type NcpSourcePart, type NcpStepStartPart, type NcpStreamEncoder, type NcpStreamRequestPayload, type NcpTextDeltaPayload, type NcpTextEndPayload, type NcpTextPart, type NcpTextStartPayload, type NcpTool, type NcpToolCallArgsDeltaPayload, type NcpToolCallArgsPayload, type NcpToolCallEndPayload, type NcpToolCallResult, type NcpToolCallResultPayload, type NcpToolCallStartPayload, type NcpToolDefinition, type NcpToolInvocationPart, type NcpToolRegistry, type NcpTypingEndPayload, type NcpTypingStartPayload, type OpenAIChatChunk, type OpenAIChatMessage, type OpenAIContentPart, type OpenAITool, type OpenAIToolCall, type OpenAIToolCallDelta, isHiddenNcpMessage, normalizeAssistantText, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, stripReplyTagsFromText, writeAssistantReasoningNormalizationModeToMetadata };
+//#endregion
+export { ListMessagesOptions, ListSessionsOptions, NCP_INTERNAL_VISIBILITY_METADATA_KEY, NcpActionPart, NcpAgentClientEndpoint, NcpAgentConversationHydrationParams, NcpAgentConversationSnapshot, NcpAgentConversationStateManager, NcpAgentRunApi, NcpAgentRunInput, NcpAgentRunOptions, NcpAgentRunSendOptions, NcpAgentRunStreamOptions, NcpAgentRuntime, NcpAgentServerEndpoint, NcpAgentStreamProvider, NcpAssistantReasoningNormalizationMode, NcpAssistantReasoningSegment, NcpAssistantTextStreamNormalizer, NcpCardPart, NcpCompletedEnvelope, NcpContextBuilder, NcpContextPrepareOptions, NcpConversationSnapshot, NcpConversationStateManager, NcpEncodeContext, NcpEndpoint, NcpEndpointEvent, NcpEndpointKind, NcpEndpointLatency, NcpEndpointManifest, NcpEndpointSubscriber, NcpError, NcpErrorCode, NcpEventType, NcpExtensionPart, NcpFailedEnvelope, NcpFilePart, NcpInvalidToolArgumentsResult, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessageAbortPayload, NcpMessageAcceptedPayload, NcpMessageDeliveredPayload, NcpMessagePart, NcpMessageReactionPayload, NcpMessageReadPayload, NcpMessageRecalledPayload, NcpMessageRole, NcpMessageSentPayload, NcpMessageStatus, NcpPendingToolCall, NcpPresenceUpdatedPayload, NcpProviderRuntimeRoute, NcpReasoningDeltaPayload, NcpReasoningEndPayload, NcpReasoningPart, NcpReasoningStartPayload, NcpReplyTagParseResult, NcpRequestEnvelope, NcpResponseEnvelope, NcpRichTextPart, NcpRoundBuffer, NcpRunContext, NcpRunErrorPayload, NcpRunFinalMetadata, NcpRunFinishedPayload, NcpRunMetadataPayload, NcpRunReadyMetadata, NcpRunStartedPayload, NcpSessionApi, NcpSessionPatch, NcpSessionStatus, NcpSessionSummary, NcpSourcePart, NcpStepStartPart, NcpStreamEncoder, NcpStreamRequestPayload, NcpTextDeltaPayload, NcpTextEndPayload, NcpTextPart, NcpTextStartPayload, NcpTool, NcpToolCallArgsDeltaPayload, NcpToolCallArgsPayload, NcpToolCallEndPayload, NcpToolCallResult, NcpToolCallResultPayload, NcpToolCallStartPayload, NcpToolDefinition, NcpToolInvocationPart, NcpToolRegistry, NcpTypingEndPayload, NcpTypingStartPayload, OpenAIChatChunk, OpenAIChatMessage, OpenAIContentPart, OpenAITool, OpenAIToolCall, OpenAIToolCallDelta, isHiddenNcpMessage, normalizeAssistantText, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, stripReplyTagsFromText, writeAssistantReasoningNormalizationModeToMetadata };