@nextclaw/ncp-toolkit 0.1.0 → 0.2.0

package/README.md

@@ -5,10 +5,14 @@ Toolkit implementations built on top of `@nextclaw/ncp` protocol contracts.
 ## Build
 
 ```bash
-pnpm -C packages/nextclaw-ncp-toolkit build
+pnpm -C packages/ncp-packages/nextclaw-ncp-toolkit build
 ```
 
 ## Scope
 
 - Reference conversation-state manager implementations
 - Protocol-level helper logic that depends on `@nextclaw/ncp` contracts
+- Composable agent backend building block: `DefaultNcpAgentBackend`
+- Default in-memory adapter: `InMemoryAgentSessionStore`
+- In-process adapter helper: `createAgentClientFromServer`
+- Runtime throwable helper: `NcpErrorException`

package/dist/index.d.ts

@@ -1,22 +1,22 @@
-import { NcpAgentConversationStateManager, NcpConversationSnapshot, NcpEndpointEvent, NcpRequestEnvelope, NcpMessageSentPayload, NcpMessageAcceptedPayload, NcpResponseEnvelope, NcpCompletedEnvelope, NcpFailedEnvelope, NcpMessageAbortPayload, NcpTextStartPayload, NcpTextDeltaPayload, NcpTextEndPayload, NcpReasoningStartPayload, NcpReasoningDeltaPayload, NcpReasoningEndPayload, NcpToolCallStartPayload, NcpToolCallArgsPayload, NcpToolCallArgsDeltaPayload, NcpToolCallEndPayload, NcpToolCallResultPayload, NcpRunStartedPayload, NcpRunFinishedPayload, NcpRunErrorPayload, NcpRunMetadataPayload, NcpError } from '@nextclaw/ncp';
+import { NcpAgentConversationStateManager, NcpAgentConversationSnapshot, NcpAgentConversationHydrationParams, NcpEndpointEvent, NcpMessageSentPayload, NcpMessageAbortPayload, NcpTextStartPayload, NcpTextDeltaPayload, NcpTextEndPayload, NcpReasoningStartPayload, NcpReasoningDeltaPayload, NcpReasoningEndPayload, NcpToolCallStartPayload, NcpToolCallArgsPayload, NcpToolCallArgsDeltaPayload, NcpToolCallEndPayload, NcpToolCallResultPayload, NcpRunStartedPayload, NcpRunFinishedPayload, NcpRunErrorPayload, NcpRunMetadataPayload, NcpError, NcpAgentServerEndpoint, NcpAgentClientEndpoint, NcpEndpointSubscriber, NcpAgentRuntime, NcpRequestEnvelope, NcpMessage, NcpSessionApi, NcpAgentStreamProvider, NcpAgentRunApi, NcpEndpointManifest, NcpAgentRunSendOptions, NcpStreamRequestPayload, NcpAgentRunStreamOptions, NcpSessionSummary, NcpErrorCode } from '@nextclaw/ncp';
 
 declare class DefaultNcpAgentConversationStateManager implements NcpAgentConversationStateManager {
     private messages;
     private streamingMessage;
     private error;
+    private activeRun;
     private readonly listeners;
     private readonly toolCallMessageIdByCallId;
     private readonly toolCallArgsRawByCallId;
+    private snapshotCache;
+    private snapshotVersion;
     private stateVersion;
-    getSnapshot(): NcpConversationSnapshot;
-    subscribe(listener: (snapshot: NcpConversationSnapshot) => void): () => boolean;
-    dispatch(event: NcpEndpointEvent): void;
-    handleMessageRequest(payload: NcpRequestEnvelope): void;
+    getSnapshot(): NcpAgentConversationSnapshot;
+    subscribe(listener: (snapshot: NcpAgentConversationSnapshot) => void): () => boolean;
+    reset(): void;
+    hydrate(payload: NcpAgentConversationHydrationParams): void;
+    dispatch(event: NcpEndpointEvent): Promise<void>;
     handleMessageSent(payload: NcpMessageSentPayload): void;
-    handleMessageAccepted(_payload: NcpMessageAcceptedPayload): void;
-    handleMessageIncoming(payload: NcpResponseEnvelope): void;
-    handleMessageCompleted(payload: NcpCompletedEnvelope): void;
-    handleMessageFailed(payload: NcpFailedEnvelope): void;
     handleMessageAbort(payload: NcpMessageAbortPayload): void;
     handleMessageTextStart(payload: NcpTextStartPayload): void;
     handleMessageTextDelta(payload: NcpTextDeltaPayload): void;
@@ -29,10 +29,10 @@ declare class DefaultNcpAgentConversationStateManager implements NcpAgentConvers
     handleMessageToolCallArgsDelta(payload: NcpToolCallArgsDeltaPayload): void;
     handleMessageToolCallEnd(payload: NcpToolCallEndPayload): void;
     handleMessageToolCallResult(payload: NcpToolCallResultPayload): void;
-    handleRunStarted(_payload: NcpRunStartedPayload): void;
+    handleRunStarted(payload: NcpRunStartedPayload): void;
     handleRunFinished(_payload: NcpRunFinishedPayload): void;
     handleRunError(payload: NcpRunErrorPayload): void;
-    handleRunMetadata(_payload: NcpRunMetadataPayload): void;
+    handleRunMetadata(payload: NcpRunMetadataPayload): void;
     handleEndpointError(payload: NcpError): void;
     private applyToolCallArgs;
     private ensureStreamingMessage;
@@ -41,11 +41,127 @@ declare class DefaultNcpAgentConversationStateManager implements NcpAgentConvers
     private findToolInvocationPart;
     private findToolNameByCallId;
     private upsertToolInvocationPart;
-    private findLastReasoningPartIndex;
     private upsertMessage;
     private replaceStreamingMessage;
     private setError;
+    private clearActiveRun;
     private clearToolCallTrackingByMessageId;
+    private notifyListeners;
 }
 
-export { DefaultNcpAgentConversationStateManager };
+/**
+ * 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.
+ */
+declare function createAgentClientFromServer(server: NcpAgentServerEndpoint): NcpAgentClientEndpoint;
+
+declare class EventPublisher {
+    private readonly listeners;
+    private readonly closeListeners;
+    private closed;
+    subscribe(listener: NcpEndpointSubscriber): () => void;
+    onClose(listener: () => void): () => void;
+    publish(event: NcpEndpointEvent): void;
+    close(): void;
+}
+
+type RuntimeFactoryParams = {
+    sessionId: string;
+    stateManager: NcpAgentConversationStateManager;
+};
+type CreateRuntimeFn = (params: RuntimeFactoryParams) => NcpAgentRuntime;
+type AgentSessionRecord = {
+    sessionId: string;
+    messages: NcpMessage[];
+    updatedAt: string;
+};
+type LiveSessionExecution = {
+    controller: AbortController;
+    publisher: EventPublisher;
+    requestEnvelope: NcpRequestEnvelope;
+    abortHandled: boolean;
+    closed: boolean;
+};
+type LiveSessionState = {
+    sessionId: string;
+    runtime: NcpAgentRuntime;
+    stateManager: NcpAgentConversationStateManager;
+    activeExecution: LiveSessionExecution | null;
+};
+interface AgentSessionStore {
+    getSession(sessionId: string): Promise<AgentSessionRecord | null>;
+    listSessions(): Promise<AgentSessionRecord[]>;
+    saveSession(session: AgentSessionRecord): Promise<void>;
+    deleteSession(sessionId: string): Promise<AgentSessionRecord | null>;
+}
+
+type DefaultNcpAgentBackendConfig = {
+    createRuntime: CreateRuntimeFn;
+    sessionStore: AgentSessionStore;
+    endpointId?: string;
+    version?: string;
+    metadata?: Record<string, unknown>;
+    supportedPartTypes?: NcpEndpointManifest["supportedPartTypes"];
+    expectedLatency?: NcpEndpointManifest["expectedLatency"];
+};
+declare class DefaultNcpAgentBackend implements NcpAgentServerEndpoint, NcpSessionApi, NcpAgentStreamProvider, NcpAgentRunApi {
+    readonly manifest: NcpEndpointManifest & {
+        endpointKind: "agent";
+    };
+    private readonly sessionStore;
+    private readonly sessionRegistry;
+    private readonly executor;
+    private readonly publisher;
+    private started;
+    constructor(config: DefaultNcpAgentBackendConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    emit(event: NcpEndpointEvent): Promise<void>;
+    subscribe(listener: (event: NcpEndpointEvent) => void): () => void;
+    send(envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions): AsyncIterable<NcpEndpointEvent>;
+    abort(payload: NcpMessageAbortPayload): Promise<void>;
+    stream(payloadOrParams: NcpStreamRequestPayload | {
+        payload: NcpStreamRequestPayload;
+        signal: AbortSignal;
+    }, opts?: NcpAgentRunStreamOptions): AsyncIterable<NcpEndpointEvent>;
+    listSessions(): Promise<NcpSessionSummary[]>;
+    listSessionMessages(sessionId: string): Promise<NcpMessage[]>;
+    getSession(sessionId: string): Promise<NcpSessionSummary | null>;
+    deleteSession(sessionId: string): Promise<void>;
+    private ensureStarted;
+    private startSessionExecution;
+    private finishSessionExecution;
+    private closeExecution;
+    private publishLiveEvent;
+    private handleRequest;
+    private streamToSubscribers;
+    private handleAbort;
+    private createAbortEvent;
+    private persistSession;
+}
+
+declare class AgentRunExecutor {
+    private readonly persistSession;
+    constructor(persistSession: (sessionId: string) => Promise<void>);
+    executeRun(session: LiveSessionState, envelope: NcpRequestEnvelope, controller: AbortController): AsyncGenerator<NcpEndpointEvent>;
+    private publishFailure;
+}
+
+declare class InMemoryAgentSessionStore implements AgentSessionStore {
+    private readonly sessions;
+    getSession(sessionId: string): Promise<AgentSessionRecord | null>;
+    listSessions(): Promise<AgentSessionRecord[]>;
+    saveSession(session: AgentSessionRecord): Promise<void>;
+    deleteSession(sessionId: string): Promise<AgentSessionRecord | null>;
+}
+
+/**
+ * Throwable form of protocol error for exception-based control flows.
+ */
+declare class NcpErrorException extends Error {
+    readonly code: NcpErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(code: NcpErrorCode, message: string, details?: Record<string, unknown>);
+}
+
+export { AgentRunExecutor, type AgentSessionRecord, type AgentSessionStore, type CreateRuntimeFn, DefaultNcpAgentBackend, type DefaultNcpAgentBackendConfig, DefaultNcpAgentConversationStateManager, EventPublisher, InMemoryAgentSessionStore, type LiveSessionExecution, type LiveSessionState, NcpErrorException, type RuntimeFactoryParams, createAgentClientFromServer };

package/dist/index.js

@@ -1,4 +1,7 @@
 // src/agent/agent-conversation-state-manager.ts
+import {
+  NcpEventType
+} from "@nextclaw/ncp";
 var DEFAULT_ASSISTANT_ROLE = "assistant";
 var cloneMessage = (message) => {
   return {
@@ -13,7 +16,7 @@ var buildRuntimeError = (payload) => {
     code: "runtime-error",
     message: message && message.length > 0 ? message : "Agent run failed.",
     details: {
-      sessionKey: payload.sessionKey,
+      sessionId: payload.sessionId,
       messageId: payload.messageId,
       threadId: payload.threadId,
       runId: payload.runId
@@ -24,205 +27,153 @@ var DefaultNcpAgentConversationStateManager = class {
   messages = [];
   streamingMessage = null;
   error = null;
+  activeRun = null;
   listeners = /* @__PURE__ */ new Set();
   toolCallMessageIdByCallId = /* @__PURE__ */ new Map();
   toolCallArgsRawByCallId = /* @__PURE__ */ new Map();
+  snapshotCache = null;
+  snapshotVersion = -1;
   stateVersion = 0;
   getSnapshot() {
-    return {
+    if (this.snapshotCache && this.snapshotVersion === this.stateVersion) {
+      return this.snapshotCache;
+    }
+    const snapshot = {
       messages: this.messages.map((message) => cloneMessage(message)),
       streamingMessage: this.streamingMessage ? cloneMessage(this.streamingMessage) : null,
-      error: this.error ? { ...this.error, details: this.error.details ? { ...this.error.details } : void 0 } : null
+      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);
   }
-  dispatch(event) {
+  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.stateVersion += 1;
+    this.notifyListeners();
+  }
+  hydrate(payload) {
+    this.messages = payload.messages.map((message) => cloneMessage(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.stateVersion += 1;
+    this.notifyListeners();
+  }
+  async dispatch(event) {
     const versionBeforeDispatch = this.stateVersion;
     switch (event.type) {
-      case "message.request":
-        this.handleMessageRequest(event.payload);
-        break;
-      case "message.sent":
+      case NcpEventType.MessageSent:
         this.handleMessageSent(event.payload);
         break;
-      case "message.accepted":
-        this.handleMessageAccepted(event.payload);
-        break;
-      case "message.incoming":
-        this.handleMessageIncoming(event.payload);
-        break;
-      case "message.completed":
-        this.handleMessageCompleted(event.payload);
-        break;
-      case "message.failed":
-        this.handleMessageFailed(event.payload);
-        break;
-      case "message.abort":
+      case NcpEventType.MessageAbort:
         this.handleMessageAbort(event.payload);
         break;
-      case "message.text-start":
+      case NcpEventType.MessageTextStart:
         this.handleMessageTextStart(event.payload);
         break;
-      case "message.text-delta":
+      case NcpEventType.MessageTextDelta:
         this.handleMessageTextDelta(event.payload);
         break;
-      case "message.text-end":
+      case NcpEventType.MessageTextEnd:
         this.handleMessageTextEnd(event.payload);
         break;
-      case "message.reasoning-start":
+      case NcpEventType.MessageReasoningStart:
         this.handleMessageReasoningStart(event.payload);
         break;
-      case "message.reasoning-delta":
+      case NcpEventType.MessageReasoningDelta:
         this.handleMessageReasoningDelta(event.payload);
         break;
-      case "message.reasoning-end":
+      case NcpEventType.MessageReasoningEnd:
         this.handleMessageReasoningEnd(event.payload);
         break;
-      case "message.tool-call-start":
+      case NcpEventType.MessageToolCallStart:
         this.handleMessageToolCallStart(event.payload);
         break;
-      case "message.tool-call-args":
+      case NcpEventType.MessageToolCallArgs:
         this.handleMessageToolCallArgs(event.payload);
         break;
-      case "message.tool-call-args-delta":
+      case NcpEventType.MessageToolCallArgsDelta:
         this.handleMessageToolCallArgsDelta(event.payload);
         break;
-      case "message.tool-call-end":
+      case NcpEventType.MessageToolCallEnd:
         this.handleMessageToolCallEnd(event.payload);
         break;
-      case "message.tool-call-result":
+      case NcpEventType.MessageToolCallResult:
         this.handleMessageToolCallResult(event.payload);
         break;
-      case "run.started":
+      case NcpEventType.RunStarted:
         this.handleRunStarted(event.payload);
         break;
-      case "run.finished":
+      case NcpEventType.RunFinished:
         this.handleRunFinished(event.payload);
         break;
-      case "run.error":
+      case NcpEventType.RunError:
         this.handleRunError(event.payload);
         break;
-      case "run.metadata":
+      case NcpEventType.RunMetadata:
         this.handleRunMetadata(event.payload);
         break;
-      case "endpoint.error":
+      case NcpEventType.EndpointError:
         this.handleEndpointError(event.payload);
         break;
-      case "endpoint.ready":
-      case "typing.start":
-      case "typing.end":
-      case "presence.updated":
-      case "message.read":
-      case "message.delivered":
-      case "message.recalled":
-      case "message.reaction":
-        break;
       default:
         break;
     }
     if (this.stateVersion !== versionBeforeDispatch) {
-      const snapshot = this.getSnapshot();
-      for (const listener of this.listeners) {
-        listener(snapshot);
-      }
+      this.notifyListeners();
     }
   }
-  handleMessageRequest(payload) {
-    this.upsertMessage(payload.message);
-    this.setError(null);
-  }
   handleMessageSent(payload) {
     this.upsertMessage(payload.message);
     this.setError(null);
   }
-  handleMessageAccepted(_payload) {
-  }
-  handleMessageIncoming(payload) {
-    const incomingMessage = cloneMessage(payload.message);
-    if (incomingMessage.status === "streaming" || incomingMessage.status === "pending") {
-      this.replaceStreamingMessage(incomingMessage);
-      this.setError(null);
-      return;
-    }
-    this.upsertMessage(incomingMessage);
-    if (this.streamingMessage?.id === incomingMessage.id) {
-      this.replaceStreamingMessage(null);
-      this.clearToolCallTrackingByMessageId(incomingMessage.id);
-    }
-    this.setError(null);
-  }
-  handleMessageCompleted(payload) {
-    const completedMessage = {
-      ...cloneMessage(payload.message),
-      status: "final"
-    };
-    this.upsertMessage(completedMessage);
-    if (this.streamingMessage?.id === completedMessage.id) {
-      this.replaceStreamingMessage(null);
-    }
-    this.clearToolCallTrackingByMessageId(completedMessage.id);
-    this.setError(null);
-  }
-  handleMessageFailed(payload) {
-    this.setError(payload.error);
-    const targetMessageId = payload.messageId?.trim();
-    if (!targetMessageId) {
-      return;
-    }
-    if (this.streamingMessage?.id === targetMessageId) {
-      this.upsertMessage({
-        ...this.streamingMessage,
-        status: "error"
-      });
-      this.replaceStreamingMessage(null);
-      this.clearToolCallTrackingByMessageId(targetMessageId);
-      return;
-    }
-    const messageIndex = this.messages.findIndex((message) => message.id === targetMessageId);
-    if (messageIndex < 0) {
-      return;
-    }
-    const nextMessages = [...this.messages];
-    nextMessages[messageIndex] = {
-      ...nextMessages[messageIndex],
-      status: "error"
-    };
-    this.messages = nextMessages;
-    this.stateVersion += 1;
-  }
   handleMessageAbort(payload) {
     const targetMessageId = payload.messageId?.trim();
-    this.setError({
-      code: "abort-error",
-      message: "Message aborted.",
-      details: {
-        messageId: targetMessageId,
-        correlationId: payload.correlationId
-      }
-    });
+    this.clearActiveRun();
+    this.setError(null);
     if (this.streamingMessage && (!targetMessageId || this.streamingMessage.id === targetMessageId)) {
+      const streamingMessageId = this.streamingMessage.id;
       this.upsertMessage({
         ...this.streamingMessage,
-        status: "error"
+        status: "final"
       });
       this.replaceStreamingMessage(null);
       if (targetMessageId) {
         this.clearToolCallTrackingByMessageId(targetMessageId);
+      } else {
+        this.clearToolCallTrackingByMessageId(streamingMessageId);
       }
     }
   }
   handleMessageTextStart(payload) {
-    this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
     this.setError(null);
   }
   handleMessageTextDelta(payload) {
     if (!payload.delta) {
       return;
     }
-    const targetMessage = this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    const targetMessage = this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
     const nextParts = [...targetMessage.parts];
     const lastPart = nextParts[nextParts.length - 1];
     if (lastPart?.type === "text") {
@@ -252,23 +203,20 @@ var DefaultNcpAgentConversationStateManager = class {
     });
   }
   handleMessageReasoningStart(payload) {
-    this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
   }
   handleMessageReasoningDelta(payload) {
     if (!payload.delta) {
       return;
     }
-    const targetMessage = this.ensureStreamingMessage(payload.sessionKey, payload.messageId, "streaming");
+    const targetMessage = this.ensureStreamingMessage(payload.sessionId, payload.messageId, "streaming");
     const nextParts = [...targetMessage.parts];
-    const reasoningPartIndex = this.findLastReasoningPartIndex(nextParts);
-    if (reasoningPartIndex >= 0) {
-      const existingPart = nextParts[reasoningPartIndex];
-      if (existingPart?.type === "reasoning") {
-        nextParts[reasoningPartIndex] = {
-          type: "reasoning",
-          text: `${existingPart.text}${payload.delta}`
-        };
-      }
+    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 });
     }
@@ -285,7 +233,7 @@ var DefaultNcpAgentConversationStateManager = class {
   }
   handleMessageToolCallStart(payload) {
     const targetMessage = this.resolveToolCallTargetMessage(
-      payload.sessionKey,
+      payload.sessionId,
       payload.toolCallId,
       payload.messageId
     );
@@ -306,16 +254,16 @@ var DefaultNcpAgentConversationStateManager = class {
   }
   handleMessageToolCallArgs(payload) {
     this.toolCallArgsRawByCallId.set(payload.toolCallId, payload.args);
-    this.applyToolCallArgs(payload.sessionKey, 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.sessionKey, payload.toolCallId, nextArgs, payload.messageId);
+    this.applyToolCallArgs(payload.sessionId, payload.toolCallId, nextArgs, payload.messageId);
   }
   handleMessageToolCallEnd(payload) {
-    const targetMessage = this.resolveToolCallTargetMessage(payload.sessionKey, payload.toolCallId);
+    const targetMessage = this.resolveToolCallTargetMessage(payload.sessionId, payload.toolCallId);
     const args = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
     const nextParts = this.upsertToolInvocationPart(targetMessage.parts, {
       type: "tool-invocation",
@@ -343,7 +291,7 @@ var DefaultNcpAgentConversationStateManager = class {
       return this.upsertToolInvocationPart(targetMessage.parts, mergedPart);
     });
     if (!updated) {
-      const fallbackMessage = this.resolveToolCallTargetMessage(payload.sessionKey, payload.toolCallId);
+      const fallbackMessage = this.resolveToolCallTargetMessage(payload.sessionId, payload.toolCallId);
       const nextParts = this.upsertToolInvocationPart(fallbackMessage.parts, {
         type: "tool-invocation",
         toolCallId: payload.toolCallId,
@@ -358,21 +306,59 @@ var DefaultNcpAgentConversationStateManager = class {
       });
     }
   }
-  handleRunStarted(_payload) {
+  handleRunStarted(payload) {
     this.setError(null);
+    this.activeRun = {
+      runId: payload.runId ?? null,
+      sessionId: payload.sessionId
+    };
+    this.stateVersion += 1;
   }
   handleRunFinished(_payload) {
+    if (this.streamingMessage) {
+      const finalizedMessage = {
+        ...this.streamingMessage,
+        status: "final"
+      };
+      this.upsertMessage(finalizedMessage);
+      this.replaceStreamingMessage(null);
+      this.clearToolCallTrackingByMessageId(finalizedMessage.id);
+    }
+    this.setError(null);
+    this.clearActiveRun();
   }
   handleRunError(payload) {
+    if (this.streamingMessage) {
+      const failedMessage = {
+        ...this.streamingMessage,
+        status: "error"
+      };
+      this.upsertMessage(failedMessage);
+      this.replaceStreamingMessage(null);
+      this.clearToolCallTrackingByMessageId(failedMessage.id);
+    }
     this.setError(buildRuntimeError(payload));
+    this.clearActiveRun();
   }
-  handleRunMetadata(_payload) {
+  handleRunMetadata(payload) {
+    const m = payload.metadata;
+    if (m?.kind === "ready") {
+      const ready = m;
+      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.clearActiveRun();
+    }
   }
   handleEndpointError(payload) {
     this.setError(payload);
   }
-  applyToolCallArgs(sessionKey, toolCallId, args, messageId) {
-    const targetMessage = this.resolveToolCallTargetMessage(sessionKey, toolCallId, messageId);
+  applyToolCallArgs(sessionId, toolCallId, args, messageId) {
+    const targetMessage = this.resolveToolCallTargetMessage(sessionId, toolCallId, messageId);
     const toolName = this.findToolNameByCallId(targetMessage.parts, toolCallId) ?? "unknown";
     const nextParts = this.upsertToolInvocationPart(targetMessage.parts, {
       type: "tool-invocation",
@@ -387,7 +373,7 @@ var DefaultNcpAgentConversationStateManager = class {
       status: "streaming"
     });
   }
-  ensureStreamingMessage(sessionKey, messageId, status) {
+  ensureStreamingMessage(sessionId, messageId, status) {
     if (this.streamingMessage?.id === messageId) {
       if (this.streamingMessage.status === status) {
         return this.streamingMessage;
@@ -399,9 +385,24 @@ var DefaultNcpAgentConversationStateManager = class {
       this.replaceStreamingMessage(nextStreamingMessage2);
       return nextStreamingMessage2;
     }
+    const messageIndex = this.messages.findIndex((message) => message.id === messageId);
+    if (messageIndex >= 0) {
+      const existingMessage = cloneMessage(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 nextStreamingMessage = {
       id: messageId,
-      sessionKey,
+      sessionId,
       role: DEFAULT_ASSISTANT_ROLE,
       status,
       parts: [],
@@ -410,10 +411,10 @@ var DefaultNcpAgentConversationStateManager = class {
     this.replaceStreamingMessage(nextStreamingMessage);
     return nextStreamingMessage;
   }
-  resolveToolCallTargetMessage(sessionKey, toolCallId, messageId) {
+  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(sessionKey, preferredMessageId, "streaming");
+    return this.ensureStreamingMessage(sessionId, preferredMessageId, "streaming");
   }
   updateMessageContainingToolCall(toolCallId, updater) {
     if (this.streamingMessage) {
@@ -469,14 +470,6 @@ var DefaultNcpAgentConversationStateManager = class {
     nextParts.push(toolPart);
     return nextParts;
   }
-  findLastReasoningPartIndex(parts) {
-    for (let index = parts.length - 1; index >= 0; index -= 1) {
-      if (parts[index]?.type === "reasoning") {
-        return index;
-      }
-    }
-    return -1;
-  }
   upsertMessage(message) {
     const normalizedMessage = cloneMessage(message);
     const messageIndex = this.messages.findIndex((item) => item.id === normalizedMessage.id);
@@ -505,6 +498,13 @@ var DefaultNcpAgentConversationStateManager = class {
     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;
+  }
   clearToolCallTrackingByMessageId(messageId) {
     for (const [toolCallId, trackedMessageId] of this.toolCallMessageIdByCallId) {
       if (trackedMessageId !== messageId) {
@@ -514,7 +514,638 @@ var DefaultNcpAgentConversationStateManager = class {
       this.toolCallArgsRawByCallId.delete(toolCallId);
     }
   }
+  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";
+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);
+    }
+  };
+}
+async function consume(events) {
+  for await (const event of events) {
+    void event;
+  }
+}
+
+// src/agent/agent-backend/agent-backend.ts
+import {
+  NcpEventType as NcpEventType4
+} from "@nextclaw/ncp";
+
+// src/errors/ncp-error-exception.ts
+var NcpErrorException = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "NcpErrorException";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/agent/agent-backend/agent-live-session-registry.ts
+var AgentLiveSessionRegistry = class {
+  constructor(sessionStore, createRuntime) {
+    this.sessionStore = sessionStore;
+    this.createRuntime = createRuntime;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  async ensureSession(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      return existing;
+    }
+    const storedSession = await this.sessionStore.getSession(sessionId);
+    const stateManager = new DefaultNcpAgentConversationStateManager();
+    stateManager.hydrate({
+      sessionId,
+      messages: cloneMessages(storedSession?.messages ?? [])
+    });
+    const session = {
+      sessionId,
+      stateManager,
+      runtime: this.createRuntime({ sessionId, stateManager }),
+      activeExecution: null
+    };
+    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));
+}
+
+// src/agent/agent-backend/agent-run-executor.ts
+import { NcpEventType as NcpEventType3 } from "@nextclaw/ncp";
+var AgentRunExecutor = class {
+  constructor(persistSession) {
+    this.persistSession = persistSession;
+  }
+  async *executeRun(session, envelope, controller) {
+    const messageSent = {
+      type: NcpEventType3.MessageSent,
+      payload: {
+        sessionId: envelope.sessionId,
+        message: structuredClone(envelope.message),
+        metadata: envelope.metadata
+      }
+    };
+    let messageSentPublished = false;
+    try {
+      for await (const event of session.runtime.run(
+        {
+          sessionId: envelope.sessionId,
+          messages: [envelope.message],
+          correlationId: envelope.correlationId
+        },
+        { signal: controller.signal }
+      )) {
+        if (!messageSentPublished) {
+          messageSentPublished = true;
+          await this.persistSession(envelope.sessionId);
+          yield structuredClone(messageSent);
+        }
+        await this.persistSession(envelope.sessionId);
+        yield structuredClone(event);
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        const runErrorEvent = await this.publishFailure(error, envelope, session);
+        yield structuredClone(runErrorEvent);
+      }
+    } finally {
+      await this.persistSession(envelope.sessionId);
+    }
+  }
+  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);
+    await this.persistSession(envelope.sessionId);
+    return runErrorEvent;
+  }
+};
+
+// 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
+  };
+}
+
+// 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();
+  }
+};
+
+// 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"
+];
+var DefaultNcpAgentBackend = class {
+  manifest;
+  sessionStore;
+  sessionRegistry;
+  executor;
+  publisher;
+  started = false;
+  constructor(config) {
+    this.sessionStore = config.sessionStore;
+    this.sessionRegistry = new AgentLiveSessionRegistry(
+      this.sessionStore,
+      config.createRuntime
+    );
+    this.executor = new AgentRunExecutor(async (sessionId) => this.persistSession(sessionId));
+    this.publisher = new EventPublisher();
+    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
+    };
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    this.publisher.publish({ type: NcpEventType4.EndpointReady });
+  }
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+    for (const session of this.sessionRegistry.listSessions()) {
+      const execution = session.activeExecution;
+      if (!execution) {
+        continue;
+      }
+      execution.abortHandled = true;
+      execution.controller.abort();
+      this.finishSessionExecution(session, execution);
+    }
+    this.sessionRegistry.clear();
+  }
+  async emit(event) {
+    await this.ensureStarted();
+    switch (event.type) {
+      case NcpEventType4.MessageRequest:
+        await this.handleRequest(event.payload);
+        return;
+      case NcpEventType4.MessageStreamRequest:
+        await this.streamToSubscribers(event.payload);
+        return;
+      case NcpEventType4.MessageAbort:
+        await this.handleAbort(event.payload);
+        return;
+      default:
+        this.publisher.publish(event);
+    }
+  }
+  subscribe(listener) {
+    return this.publisher.subscribe(listener);
+  }
+  async *send(envelope, options) {
+    await this.ensureStarted();
+    const session = await this.sessionRegistry.ensureSession(envelope.sessionId);
+    const execution = this.startSessionExecution(session, envelope, options?.signal);
+    try {
+      for await (const event of this.executor.executeRun(session, envelope, execution.controller)) {
+        this.publishLiveEvent(execution, event);
+        yield event;
+      }
+      if (execution.controller.signal.aborted && !execution.abortHandled) {
+        const abortEvent = await this.createAbortEvent(session.sessionId);
+        execution.abortHandled = true;
+        this.publishLiveEvent(execution, abortEvent);
+        yield abortEvent;
+      }
+    } finally {
+      this.finishSessionExecution(session, execution);
+    }
+  }
+  async abort(payload) {
+    await this.handleAbort(payload);
+  }
+  async *stream(payloadOrParams, opts) {
+    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 = this.sessionRegistry.getSession(payload.sessionId);
+    const execution = session?.activeExecution;
+    if (!session || !execution || execution.closed) {
+      return;
+    }
+    const queue = createAsyncQueue();
+    const unsubscribe = execution.publisher.subscribe((event) => {
+      queue.push(event);
+    });
+    const unsubscribeClose = execution.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;
+        if (isTerminalEvent(event)) {
+          break;
+        }
+      }
+    } finally {
+      stop();
+    }
+  }
+  async listSessions() {
+    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));
+  }
+  async listSessionMessages(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)) : [];
+  }
+  async getSession(sessionId) {
+    const liveSession = this.sessionRegistry.getSession(sessionId);
+    const storedSession = await this.sessionStore.getSession(sessionId);
+    if (storedSession) {
+      return toSessionSummary(storedSession, liveSession);
+    }
+    if (liveSession) {
+      return toLiveSessionSummary(liveSession);
+    }
+    return null;
+  }
+  async deleteSession(sessionId) {
+    const liveSession = this.sessionRegistry.deleteSession(sessionId);
+    const execution = liveSession?.activeExecution;
+    if (execution) {
+      execution.abortHandled = true;
+      execution.controller.abort();
+      this.closeExecution(execution);
+    }
+    await this.sessionStore.deleteSession(sessionId);
+  }
+  async ensureStarted() {
+    if (!this.started) {
+      await this.start();
+    }
+  }
+  startSessionExecution(session, envelope, signal) {
+    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,
+      publisher: new EventPublisher(),
+      requestEnvelope: structuredClone(envelope),
+      abortHandled: false,
+      closed: false
+    };
+    session.activeExecution = execution;
+    return execution;
+  }
+  finishSessionExecution(session, execution) {
+    if (session.activeExecution === execution) {
+      session.activeExecution = null;
+    }
+    this.closeExecution(execution);
+  }
+  closeExecution(execution) {
+    if (execution.closed) {
+      return;
+    }
+    execution.closed = true;
+    execution.publisher.close();
+  }
+  publishLiveEvent(execution, event) {
+    this.publisher.publish(event);
+    if (!execution.closed) {
+      execution.publisher.publish(event);
+    }
+  }
+  async handleRequest(envelope) {
+    for await (const event of this.send(envelope)) {
+      void event;
+    }
+  }
+  async streamToSubscribers(payload) {
+    const signal = new AbortController().signal;
+    for await (const event of this.stream({ payload, signal })) {
+      void event;
+    }
+  }
+  async handleAbort(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 = await this.createAbortEvent(payload.sessionId, payload.messageId);
+    this.publishLiveEvent(execution, abortEvent);
+    this.finishSessionExecution(session, execution);
+  }
+  async createAbortEvent(sessionId, messageId) {
+    const abortEvent = {
+      type: NcpEventType4.MessageAbort,
+      payload: {
+        sessionId,
+        ...messageId ? { messageId } : {}
+      }
+    };
+    const liveSession = this.sessionRegistry.getSession(sessionId);
+    if (liveSession) {
+      await liveSession.stateManager.dispatch(abortEvent);
+    }
+    await this.persistSession(sessionId);
+    return abortEvent;
+  }
+  async persistSession(sessionId) {
+    const session = this.sessionRegistry.getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    const snapshot = session.stateManager.getSnapshot();
+    await this.sessionStore.saveSession({
+      sessionId,
+      messages: readMessages(snapshot),
+      updatedAt: now()
+    });
+  }
+};
+function readMessages(snapshot) {
+  const messages = snapshot.messages.map((message) => structuredClone(message));
+  if (snapshot.streamingMessage) {
+    messages.push(structuredClone(snapshot.streamingMessage));
+  }
+  return messages;
+}
+function toSessionSummary(session, liveSession) {
+  return {
+    sessionId: session.sessionId,
+    messageCount: session.messages.length,
+    updatedAt: session.updatedAt,
+    status: liveSession?.activeExecution ? "running" : "idle"
+  };
+}
+function toLiveSessionSummary(session) {
+  const snapshot = session.stateManager.getSnapshot();
+  return {
+    sessionId: session.sessionId,
+    messageCount: readMessages(snapshot).length,
+    updatedAt: now(),
+    status: session.activeExecution ? "running" : "idle"
+  };
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isTerminalEvent(event) {
+  switch (event.type) {
+    case NcpEventType4.MessageAbort:
+    case NcpEventType4.RunFinished:
+    case NcpEventType4.RunError:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/agent/agent-backend/in-memory-agent-session-store.ts
+var InMemoryAgentSessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  async getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session ? structuredClone(session) : null;
+  }
+  async listSessions() {
+    return [...this.sessions.values()].map((session) => structuredClone(session));
+  }
+  async saveSession(session) {
+    this.sessions.set(session.sessionId, structuredClone(session));
+  }
+  async deleteSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return null;
+    }
+    this.sessions.delete(sessionId);
+    return structuredClone(session);
+  }
 };
 export {
-  DefaultNcpAgentConversationStateManager
+  AgentRunExecutor,
+  DefaultNcpAgentBackend,
+  DefaultNcpAgentConversationStateManager,
+  EventPublisher,
+  InMemoryAgentSessionStore,
+  NcpErrorException,
+  createAgentClientFromServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-toolkit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "Toolkit implementations built on top of the NextClaw Communication Protocol.",
   "type": "module",
@@ -15,18 +15,15 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/ncp": "0.1.0"
+    "@nextclaw/ncp": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^9.1.0",
     "prettier": "^3.3.3",
     "tsup": "^8.3.5",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.2"
+    "vitest": "^2.1.2",
+    "@nextclaw/ncp-agent-runtime": "0.1.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --out-dir dist",