@nextclaw/ncp-toolkit 0.4.8 → 0.4.10

package/dist/index.d.ts

@@ -8,32 +8,33 @@ declare class DefaultNcpAgentConversationStateManager implements NcpAgentConvers
     private readonly listeners;
     private readonly toolCallMessageIdByCallId;
     private readonly toolCallArgsRawByCallId;
+    private lastSettledRunId;
     private snapshotCache;
     private snapshotVersion;
     private stateVersion;
-    getSnapshot(): NcpAgentConversationSnapshot;
-    subscribe(listener: (snapshot: NcpAgentConversationSnapshot) => void): () => boolean;
-    reset(): void;
-    hydrate(payload: NcpAgentConversationHydrationParams): void;
-    dispatch(event: NcpEndpointEvent): Promise<void>;
-    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;
+    subscribe: (listener: (snapshot: NcpAgentConversationSnapshot) => void) => () => boolean;
+    reset: () => void;
+    hydrate: (payload: NcpAgentConversationHydrationParams) => void;
+    dispatch: (event: NcpEndpointEvent) => Promise<void>;
+    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;
     private applyToolCallArgs;
     private ensureStreamingMessage;
     private resolveToolCallTargetMessage;
@@ -42,6 +43,8 @@ declare class DefaultNcpAgentConversationStateManager implements NcpAgentConvers
     private replaceStreamingMessage;
     private setError;
     private clearActiveRun;
+    private isSettledRunId;
+    private markRunAsSettled;
     private settleStreamingMessage;
     private notifyListeners;
 }
@@ -99,6 +102,10 @@ interface AgentSessionStore {
 type DefaultNcpAgentBackendConfig = {
     createRuntime: CreateRuntimeFn;
     sessionStore: AgentSessionStore;
+    onSessionRunStatusChanged?: (payload: {
+        sessionKey: string;
+        status: "running" | "idle";
+    }) => void;
     endpointId?: string;
     version?: string;
     metadata?: Record<string, unknown>;
@@ -110,27 +117,29 @@ declare class DefaultNcpAgentBackend implements NcpAgentServerEndpoint, NcpSessi
         endpointKind: "agent";
     };
     private readonly sessionStore;
+    private readonly onSessionRunStatusChanged;
     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>;
+    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>;
+    listSessions: () => Promise<NcpSessionSummary[]>;
+    listSessionMessages: (sessionId: string) => Promise<NcpMessage[]>;
+    getSession: (sessionId: string) => Promise<NcpSessionSummary | null>;
     appendMessage: (sessionId: string, message: NcpMessage) => Promise<NcpSessionSummary | null>;
-    updateSession(sessionId: string, patch: NcpSessionPatch): Promise<NcpSessionSummary | null>;
-    deleteSession(sessionId: string): Promise<void>;
+    updateToolCallResult: (sessionId: string, toolCallId: string, content: unknown) => Promise<NcpSessionSummary | null>;
+    updateSession: (sessionId: string, patch: NcpSessionPatch) => Promise<NcpSessionSummary | null>;
+    deleteSession: (sessionId: string) => Promise<void>;
     private ensureStarted;
     private startSessionExecution;
     private finishSessionExecution;

package/dist/index.js

@@ -95,10 +95,11 @@ var DefaultNcpAgentConversationStateManager = class {
   listeners = /* @__PURE__ */ new Set();
   toolCallMessageIdByCallId = /* @__PURE__ */ new Map();
   toolCallArgsRawByCallId = /* @__PURE__ */ new Map();
+  lastSettledRunId = null;
   snapshotCache = null;
   snapshotVersion = -1;
   stateVersion = 0;
-  getSnapshot() {
+  getSnapshot = () => {
     if (this.snapshotCache && this.snapshotVersion === this.stateVersion) {
       return this.snapshotCache;
     }
@@ -114,12 +115,12 @@ var DefaultNcpAgentConversationStateManager = class {
     this.snapshotCache = snapshot;
     this.snapshotVersion = this.stateVersion;
     return snapshot;
-  }
-  subscribe(listener) {
+  };
+  subscribe = (listener) => {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
-  }
-  reset() {
+  };
+  reset = () => {
     if (this.messages.length === 0 && !this.streamingMessage && !this.error && !this.activeRun && this.toolCallMessageIdByCallId.size === 0 && this.toolCallArgsRawByCallId.size === 0) {
       return;
     }
@@ -129,10 +130,11 @@ var DefaultNcpAgentConversationStateManager = class {
     this.activeRun = null;
     this.toolCallMessageIdByCallId.clear();
     this.toolCallArgsRawByCallId.clear();
+    this.lastSettledRunId = null;
     this.stateVersion += 1;
     this.notifyListeners();
-  }
-  hydrate(payload) {
+  };
+  hydrate = (payload) => {
     this.messages = payload.messages.map(
       (message) => normalizeConversationMessage(message)
     );
@@ -145,10 +147,11 @@ var DefaultNcpAgentConversationStateManager = class {
     } : null;
     this.toolCallMessageIdByCallId.clear();
     this.toolCallArgsRawByCallId.clear();
+    this.lastSettledRunId = null;
     this.stateVersion += 1;
     this.notifyListeners();
-  }
-  async dispatch(event) {
+  };
+  dispatch = async (event) => {
     const versionBeforeDispatch = this.stateVersion;
     switch (event.type) {
       case NcpEventType.MessageSent:
@@ -211,12 +214,12 @@ var DefaultNcpAgentConversationStateManager = class {
     if (this.stateVersion !== versionBeforeDispatch) {
       this.notifyListeners();
     }
-  }
-  handleMessageSent(payload) {
+  };
+  handleMessageSent = (payload) => {
     this.upsertMessage(payload.message);
     this.setError(null);
-  }
-  handleMessageAbort(payload) {
+  };
+  handleMessageAbort = (payload) => {
     const targetMessageId = payload.messageId?.trim();
     this.clearActiveRun();
     this.setError(null);
@@ -241,16 +244,16 @@ var DefaultNcpAgentConversationStateManager = class {
         );
       }
     }
-  }
-  handleMessageTextStart(payload) {
+  };
+  handleMessageTextStart = (payload) => {
     this.ensureStreamingMessage(
       payload.sessionId,
       payload.messageId,
       "streaming"
     );
     this.setError(null);
-  }
-  handleMessageTextDelta(payload) {
+  };
+  handleMessageTextDelta = (payload) => {
     if (!payload.delta) {
       return;
     }
@@ -274,8 +277,8 @@ var DefaultNcpAgentConversationStateManager = class {
       parts: nextParts,
       status: "streaming"
     });
-  }
-  handleMessageTextEnd(payload) {
+  };
+  handleMessageTextEnd = (payload) => {
     if (this.streamingMessage?.id !== payload.messageId) {
       return;
     }
@@ -286,15 +289,15 @@ var DefaultNcpAgentConversationStateManager = class {
       ...this.streamingMessage,
       status: "pending"
     });
-  }
-  handleMessageReasoningStart(payload) {
+  };
+  handleMessageReasoningStart = (payload) => {
     this.ensureStreamingMessage(
       payload.sessionId,
       payload.messageId,
       "streaming"
     );
-  }
-  handleMessageReasoningDelta(payload) {
+  };
+  handleMessageReasoningDelta = (payload) => {
     if (!payload.delta) {
       return;
     }
@@ -318,13 +321,13 @@ var DefaultNcpAgentConversationStateManager = class {
       parts: nextParts,
       status: "streaming"
     });
-  }
-  handleMessageReasoningEnd(payload) {
+  };
+  handleMessageReasoningEnd = (payload) => {
     if (this.streamingMessage?.id !== payload.messageId) {
       return;
     }
-  }
-  handleMessageToolCallStart(payload) {
+  };
+  handleMessageToolCallStart = (payload) => {
     const targetMessage = this.resolveToolCallTargetMessage(
       payload.sessionId,
       payload.toolCallId,
@@ -344,12 +347,12 @@ var DefaultNcpAgentConversationStateManager = class {
       status: "streaming"
     });
     this.setError(null);
-  }
-  handleMessageToolCallArgs(payload) {
+  };
+  handleMessageToolCallArgs = (payload) => {
     this.toolCallArgsRawByCallId.set(payload.toolCallId, payload.args);
     this.applyToolCallArgs(payload.sessionId, payload.toolCallId, payload.args);
-  }
-  handleMessageToolCallArgsDelta(payload) {
+  };
+  handleMessageToolCallArgsDelta = (payload) => {
     const currentArgs = this.toolCallArgsRawByCallId.get(payload.toolCallId) ?? "";
     const nextArgs = `${currentArgs}${payload.delta}`;
     this.toolCallArgsRawByCallId.set(payload.toolCallId, nextArgs);
@@ -359,8 +362,8 @@ var DefaultNcpAgentConversationStateManager = class {
       nextArgs,
       payload.messageId
     );
-  }
-  handleMessageToolCallEnd(payload) {
+  };
+  handleMessageToolCallEnd = (payload) => {
     const targetMessage = this.resolveToolCallTargetMessage(
       payload.sessionId,
       payload.toolCallId
@@ -378,8 +381,8 @@ var DefaultNcpAgentConversationStateManager = class {
       parts: nextParts,
       status: "streaming"
     });
-  }
-  handleMessageToolCallResult(payload) {
+  };
+  handleMessageToolCallResult = (payload) => {
     const updated = this.updateMessageContainingToolCall(
       payload.toolCallId,
       (targetMessage, existingPart) => {
@@ -412,29 +415,30 @@ var DefaultNcpAgentConversationStateManager = class {
         status: "streaming"
       });
     }
-  }
-  handleRunStarted(payload) {
+  };
+  handleRunStarted = (payload) => {
+    if (this.isSettledRunId(payload.runId)) return;
     this.setError(null);
-    this.activeRun = {
-      runId: payload.runId ?? null,
-      sessionId: payload.sessionId
-    };
+    this.activeRun = { runId: payload.runId ?? null, sessionId: payload.sessionId };
     this.stateVersion += 1;
-  }
-  handleRunFinished(_payload) {
+  };
+  handleRunFinished = (payload) => {
+    this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
     this.settleStreamingMessage("final");
     this.setError(null);
     this.clearActiveRun();
-  }
-  handleRunError(payload) {
+  };
+  handleRunError = (payload) => {
+    this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
     this.settleStreamingMessage("error");
     this.setError(buildRuntimeError(payload));
     this.clearActiveRun();
-  }
-  handleRunMetadata(payload) {
+  };
+  handleRunMetadata = (payload) => {
     const m = payload.metadata;
     if (m?.kind === "ready") {
       const ready = m;
+      if (this.isSettledRunId(ready.runId)) return;
       this.activeRun = {
         runId: ready.runId ?? this.activeRun?.runId ?? null,
         sessionId: ready.sessionId ?? this.activeRun?.sessionId,
@@ -442,10 +446,11 @@ var DefaultNcpAgentConversationStateManager = class {
       };
       this.stateVersion += 1;
     } else if (m?.kind === "final") {
+      this.markRunAsSettled(payload.runId ?? this.activeRun?.runId ?? null);
       this.clearActiveRun();
     }
-  }
-  handleEndpointError(payload) {
+  };
+  handleEndpointError = (payload) => {
     if (payload.code === "abort-error") {
       this.handleMessageAbort({
         sessionId: this.activeRun?.sessionId ?? this.streamingMessage?.sessionId ?? "",
@@ -456,8 +461,8 @@ var DefaultNcpAgentConversationStateManager = class {
     this.settleStreamingMessage("error");
     this.clearActiveRun();
     this.setError(payload);
-  }
-  applyToolCallArgs(sessionId, toolCallId, args, messageId) {
+  };
+  applyToolCallArgs = (sessionId, toolCallId, args, messageId) => {
     const targetMessage = this.resolveToolCallTargetMessage(
       sessionId,
       toolCallId,
@@ -476,8 +481,8 @@ var DefaultNcpAgentConversationStateManager = class {
       parts: nextParts,
       status: "streaming"
     });
-  }
-  ensureStreamingMessage(sessionId, messageId, status) {
+  };
+  ensureStreamingMessage = (sessionId, messageId, status) => {
     if (this.streamingMessage?.id === messageId) {
       if (this.streamingMessage.status === status) {
         return this.streamingMessage;
@@ -534,8 +539,8 @@ var DefaultNcpAgentConversationStateManager = class {
     };
     this.replaceStreamingMessage(nextStreamingMessage);
     return nextStreamingMessage;
-  }
-  resolveToolCallTargetMessage(sessionId, 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(
@@ -543,8 +548,8 @@ var DefaultNcpAgentConversationStateManager = class {
       preferredMessageId,
       "streaming"
     );
-  }
-  updateMessageContainingToolCall(toolCallId, updater) {
+  };
+  updateMessageContainingToolCall = (toolCallId, updater) => {
     if (this.streamingMessage) {
       const part = findToolInvocationPart(
         this.streamingMessage.parts,
@@ -575,8 +580,8 @@ var DefaultNcpAgentConversationStateManager = class {
       return true;
     }
     return false;
-  }
-  upsertMessage(message) {
+  };
+  upsertMessage = (message) => {
     const normalizedMessage = normalizeConversationMessage(message);
     const messageIndex = this.messages.findIndex(
       (item) => item.id === normalizedMessage.id
@@ -590,15 +595,15 @@ var DefaultNcpAgentConversationStateManager = class {
     nextMessages[messageIndex] = normalizedMessage;
     this.messages = nextMessages;
     this.stateVersion += 1;
-  }
-  replaceStreamingMessage(nextStreamingMessage) {
+  };
+  replaceStreamingMessage = (nextStreamingMessage) => {
     if (!nextStreamingMessage && !this.streamingMessage) {
       return;
     }
     this.streamingMessage = nextStreamingMessage ? normalizeConversationMessage(nextStreamingMessage) : null;
     this.stateVersion += 1;
-  }
-  setError(nextError) {
+  };
+  setError = (nextError) => {
     const hasSameError = this.error?.code === nextError?.code && this.error?.message === nextError?.message && this.error?.details === nextError?.details && this.error?.cause === nextError?.cause;
     if (hasSameError) {
       return;
@@ -608,15 +613,19 @@ var DefaultNcpAgentConversationStateManager = class {
       details: nextError.details ? { ...nextError.details } : void 0
     } : null;
     this.stateVersion += 1;
-  }
-  clearActiveRun() {
-    if (!this.activeRun) {
-      return;
-    }
+  };
+  clearActiveRun = () => {
+    if (!this.activeRun) return;
     this.activeRun = null;
     this.stateVersion += 1;
-  }
-  settleStreamingMessage(status) {
+  };
+  isSettledRunId = (runId) => {
+    return Boolean(runId?.trim()) && runId === this.lastSettledRunId;
+  };
+  markRunAsSettled = (runId) => {
+    this.lastSettledRunId = runId?.trim() || null;
+  };
+  settleStreamingMessage = (status) => {
     if (!this.streamingMessage) {
       return;
     }
@@ -631,13 +640,11 @@ var DefaultNcpAgentConversationStateManager = class {
       this.toolCallArgsRawByCallId,
       settledMessage.id
     );
-  }
-  notifyListeners() {
+  };
+  notifyListeners = () => {
     const snapshot = this.getSnapshot();
-    for (const listener of this.listeners) {
-      listener(snapshot);
-    }
-  }
+    for (const listener of this.listeners) listener(snapshot);
+  };
 };
 
 // src/agent/agent-client-from-server.ts
@@ -692,7 +699,7 @@ async function consume(events) {
 
 // src/agent/agent-backend/agent-backend.ts
 import {
-  NcpEventType as NcpEventType6
+  NcpEventType as NcpEventType8
 } from "@nextclaw/ncp";
 
 // src/errors/ncp-error-exception.ts
@@ -777,23 +784,28 @@ function cloneMessages(messages) {
 }
 
 // src/agent/agent-backend/agent-run-executor.ts
+import {
+  isHiddenNcpMessage
+} from "@nextclaw/ncp";
 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
-      }
-    };
-    await session.stateManager.dispatch(messageSent);
-    await this.persistSession(envelope.sessionId);
-    yield structuredClone(messageSent);
+    if (!isHiddenNcpMessage(envelope.message)) {
+      const messageSent = {
+        type: NcpEventType3.MessageSent,
+        payload: {
+          sessionId: envelope.sessionId,
+          message: structuredClone(envelope.message),
+          metadata: envelope.metadata
+        }
+      };
+      await session.stateManager.dispatch(messageSent);
+      await this.persistSession(envelope.sessionId);
+      yield structuredClone(messageSent);
+    }
     try {
       for await (const event of session.runtime.run(
         {
@@ -903,8 +915,34 @@ function buildPersistedLiveSessionRecord(params) {
   };
 }
 
-// src/agent/agent-backend/agent-backend-append-message.ts
+// src/agent/agent-backend/agent-backend-update-tool-call-result.ts
 import { NcpEventType as NcpEventType5 } from "@nextclaw/ncp";
+async function updateAgentBackendToolCallResult(params) {
+  const normalizedSessionId = params.sessionId.trim();
+  const normalizedToolCallId = params.toolCallId.trim();
+  if (!normalizedSessionId || !normalizedToolCallId) {
+    return null;
+  }
+  const liveSession = await params.sessionRegistry.ensureSession(normalizedSessionId);
+  const event = {
+    type: NcpEventType5.MessageToolCallResult,
+    payload: {
+      sessionId: normalizedSessionId,
+      toolCallId: normalizedToolCallId,
+      content: params.content
+    }
+  };
+  await liveSession.stateManager.dispatch(event);
+  params.publisher.publish(event);
+  if (liveSession.activeExecution && !liveSession.activeExecution.closed) {
+    liveSession.activeExecution.publisher.publish(event);
+  }
+  await params.persistSession(normalizedSessionId);
+  return params.getSession(normalizedSessionId);
+}
+
+// src/agent/agent-backend/agent-backend-append-message.ts
+import { NcpEventType as NcpEventType6 } from "@nextclaw/ncp";
 async function appendAgentBackendMessage(params) {
   const normalizedSessionId = params.sessionId.trim();
   if (!normalizedSessionId) {
@@ -923,7 +961,7 @@ async function appendAgentBackendMessage(params) {
     sessionId: normalizedSessionId
   };
   const event = {
-    type: NcpEventType5.MessageSent,
+    type: NcpEventType6.MessageSent,
     payload: {
       sessionId: normalizedSessionId,
       message: nextMessage
@@ -938,6 +976,9 @@ async function appendAgentBackendMessage(params) {
   return params.getSession(normalizedSessionId);
 }
 
+// src/agent/agent-backend/agent-backend-stream.ts
+import { NcpEventType as NcpEventType7 } from "@nextclaw/ncp";
+
 // src/agent/agent-backend/async-queue.ts
 function createAsyncQueue() {
   const items = [];
@@ -1004,6 +1045,14 @@ async function* streamAgentBackendExecution(params) {
   const session = params.sessionRegistry.getSession(payload.sessionId);
   const execution = session?.activeExecution;
   if (!session || !execution || execution.closed) {
+    if (session) {
+      yield {
+        type: NcpEventType7.RunFinished,
+        payload: {
+          sessionId: payload.sessionId
+        }
+      };
+    }
     return;
   }
   const queue = createAsyncQueue();
@@ -1081,31 +1130,19 @@ var EventPublisher = class {
 };
 
 // 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 DEFAULT_SUPPORTED_PART_TYPES = ["text", "file", "source", "step-start", "reasoning", "tool-invocation", "card", "rich-text", "action", "extension"];
 var DefaultNcpAgentBackend = class {
   manifest;
   sessionStore;
+  onSessionRunStatusChanged;
   sessionRegistry;
   executor;
   publisher;
   started = false;
   constructor(config) {
     this.sessionStore = config.sessionStore;
-    this.sessionRegistry = new AgentLiveSessionRegistry(
-      this.sessionStore,
-      config.createRuntime
-    );
+    this.onSessionRunStatusChanged = config.onSessionRunStatusChanged;
+    this.sessionRegistry = new AgentLiveSessionRegistry(this.sessionStore, config.createRuntime);
     this.executor = new AgentRunExecutor(async (sessionId) => this.persistSession(sessionId));
     this.publisher = new EventPublisher();
     this.manifest = {
@@ -1121,14 +1158,14 @@ var DefaultNcpAgentBackend = class {
       metadata: config.metadata
     };
   }
-  async start() {
+  start = async () => {
     if (this.started) {
       return;
     }
     this.started = true;
-    this.publisher.publish({ type: NcpEventType6.EndpointReady });
-  }
-  async stop() {
+    this.publisher.publish({ type: NcpEventType8.EndpointReady });
+  };
+  stop = async () => {
     if (!this.started) {
       return;
     }
@@ -1143,57 +1180,68 @@ var DefaultNcpAgentBackend = class {
       this.finishSessionExecution(session, execution);
     }
     this.sessionRegistry.clear();
-  }
-  async emit(event) {
+  };
+  emit = async (event) => {
     await this.ensureStarted();
     switch (event.type) {
-      case NcpEventType6.MessageRequest:
+      case NcpEventType8.MessageRequest:
         await this.handleRequest(event.payload);
         return;
-      case NcpEventType6.MessageStreamRequest:
+      case NcpEventType8.MessageStreamRequest:
         await this.streamToSubscribers(event.payload);
         return;
-      case NcpEventType6.MessageAbort:
+      case NcpEventType8.MessageAbort:
         await this.handleAbort(event.payload);
         return;
       default:
         this.publisher.publish(event);
     }
-  }
-  subscribe(listener) {
+  };
+  subscribe = (listener) => {
     return this.publisher.subscribe(listener);
-  }
-  async *send(envelope, options) {
-    await this.ensureStarted();
-    const session = await this.sessionRegistry.ensureSession(
-      envelope.sessionId,
-      envelope.metadata
-    );
-    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;
+  };
+  send = (envelope, options) => {
+    return (async function* (self) {
+      await self.ensureStarted();
+      const session = await self.sessionRegistry.ensureSession(
+        envelope.sessionId,
+        envelope.metadata
+      );
+      const execution = self.startSessionExecution(
+        session,
+        envelope,
+        options?.signal
+      );
+      try {
+        for await (const event of self.executor.executeRun(
+          session,
+          envelope,
+          execution.controller
+        )) {
+          self.publishLiveEvent(execution, event);
+          yield event;
+        }
+        if (execution.controller.signal.aborted && !execution.abortHandled) {
+          const abortEvent = await self.createAbortEvent(session.sessionId);
+          execution.abortHandled = true;
+          self.publishLiveEvent(execution, abortEvent);
+          yield abortEvent;
+        }
+      } finally {
+        self.finishSessionExecution(session, execution);
+        await self.persistSession(session.sessionId);
       }
-    } finally {
-      this.finishSessionExecution(session, execution);
-    }
-  }
-  async abort(payload) {
+    })(this);
+  };
+  abort = async (payload) => {
     await this.handleAbort(payload);
-  }
+  };
   stream = (payloadOrParams, opts) => streamAgentBackendExecution({
     payloadOrParams,
     opts,
     sessionRegistry: this.sessionRegistry
   });
-  async listSessions() {
+  listSessions = async () => {
     const storedSessions = await this.sessionStore.listSessions();
     const summaries = storedSessions.map(
       (session) => toSessionSummary(session, this.sessionRegistry.getSession(session.sessionId))
@@ -1205,18 +1253,18 @@ var DefaultNcpAgentBackend = class {
       summaries.push(toLiveSessionSummary(liveSession));
     }
     return summaries.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-  }
-  async listSessionMessages(sessionId) {
+  };
+  listSessionMessages = async (sessionId) => {
     const liveSession = this.sessionRegistry.getSession(sessionId);
     if (liveSession) return readMessages(liveSession.stateManager.getSnapshot());
     const session = await this.sessionStore.getSession(sessionId);
     return session ? session.messages.map((message) => structuredClone(message)) : [];
-  }
-  async getSession(sessionId) {
+  };
+  getSession = async (sessionId) => {
     const liveSession = this.sessionRegistry.getSession(sessionId);
     const storedSession = await this.sessionStore.getSession(sessionId);
     return storedSession ? toSessionSummary(storedSession, liveSession) : liveSession ? toLiveSessionSummary(liveSession) : null;
-  }
+  };
   appendMessage = async (sessionId, message) => {
     await this.ensureStarted();
     return appendAgentBackendMessage({
@@ -1229,7 +1277,19 @@ var DefaultNcpAgentBackend = class {
       getSession: async (nextSessionId) => this.getSession(nextSessionId)
     });
   };
-  async updateSession(sessionId, patch) {
+  updateToolCallResult = async (sessionId, toolCallId, content) => {
+    await this.ensureStarted();
+    return updateAgentBackendToolCallResult({
+      sessionId,
+      toolCallId,
+      content,
+      sessionRegistry: this.sessionRegistry,
+      publisher: this.publisher,
+      persistSession: async (nextSessionId) => this.persistSession(nextSessionId),
+      getSession: async (nextSessionId) => this.getSession(nextSessionId)
+    });
+  };
+  updateSession = async (sessionId, patch) => {
     const liveSession = this.sessionRegistry.getSession(sessionId);
     const storedSession = await this.sessionStore.getSession(sessionId);
     if (!liveSession && !storedSession) return null;
@@ -1241,8 +1301,8 @@ var DefaultNcpAgentBackend = class {
       updatedAt: now()
     }));
     return this.getSession(sessionId);
-  }
-  async deleteSession(sessionId) {
+  };
+  deleteSession = async (sessionId) => {
     const liveSession = this.sessionRegistry.deleteSession(sessionId);
     const execution = liveSession?.activeExecution;
     if (execution) {
@@ -1251,13 +1311,13 @@ var DefaultNcpAgentBackend = class {
       this.closeExecution(execution);
     }
     await this.sessionStore.deleteSession(sessionId);
-  }
-  async ensureStarted() {
+  };
+  ensureStarted = async () => {
     if (!this.started) {
       await this.start();
     }
-  }
-  startSessionExecution(session, envelope, signal) {
+  };
+  startSessionExecution = (session, envelope, signal) => {
     if (session.activeExecution && !session.activeExecution.closed) {
       throw new NcpErrorException(
         "runtime-error",
@@ -1279,39 +1339,41 @@ var DefaultNcpAgentBackend = class {
       closed: false
     };
     session.activeExecution = execution;
+    this.onSessionRunStatusChanged?.({ sessionKey: session.sessionId, status: "running" });
     return execution;
-  }
-  finishSessionExecution(session, execution) {
+  };
+  finishSessionExecution = (session, execution) => {
     if (session.activeExecution === execution) {
       session.activeExecution = null;
+      this.onSessionRunStatusChanged?.({ sessionKey: session.sessionId, status: "idle" });
     }
     this.closeExecution(execution);
-  }
-  closeExecution(execution) {
+  };
+  closeExecution = (execution) => {
     if (execution.closed) {
       return;
     }
     execution.closed = true;
     execution.publisher.close();
-  }
-  publishLiveEvent(execution, event) {
+  };
+  publishLiveEvent = (execution, event) => {
     this.publisher.publish(event);
     if (!execution.closed) {
       execution.publisher.publish(event);
     }
-  }
-  async handleRequest(envelope) {
+  };
+  handleRequest = async (envelope) => {
     for await (const event of this.send(envelope)) {
       void event;
     }
-  }
-  async streamToSubscribers(payload) {
+  };
+  streamToSubscribers = async (payload) => {
     const signal = new AbortController().signal;
     for await (const event of this.stream({ payload, signal })) {
       void event;
     }
-  }
-  async handleAbort(payload) {
+  };
+  handleAbort = async (payload) => {
     const session = this.sessionRegistry.getSession(payload.sessionId);
     const execution = session?.activeExecution;
     if (!session || !execution || execution.closed) {
@@ -1322,10 +1384,10 @@ var DefaultNcpAgentBackend = class {
     const abortEvent = await this.createAbortEvent(payload.sessionId, payload.messageId);
     this.publishLiveEvent(execution, abortEvent);
     this.finishSessionExecution(session, execution);
-  }
-  async createAbortEvent(sessionId, messageId) {
+  };
+  createAbortEvent = async (sessionId, messageId) => {
     const abortEvent = {
-      type: NcpEventType6.MessageAbort,
+      type: NcpEventType8.MessageAbort,
       payload: {
         sessionId,
         ...messageId ? { messageId } : {}
@@ -1337,8 +1399,8 @@ var DefaultNcpAgentBackend = class {
     }
     await this.persistSession(sessionId);
     return abortEvent;
-  }
-  async persistSession(sessionId) {
+  };
+  persistSession = async (sessionId) => {
     const session = this.sessionRegistry.getSession(sessionId);
     if (!session) return;
     await this.sessionStore.saveSession(buildPersistedLiveSessionRecord({
@@ -1346,7 +1408,7 @@ var DefaultNcpAgentBackend = class {
       session,
       updatedAt: now()
     }));
-  }
+  };
 };
 
 // src/agent/agent-backend/in-memory-agent-session-store.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-toolkit",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "private": false,
   "description": "Toolkit implementations built on top of the NextClaw Communication Protocol.",
   "type": "module",
@@ -15,7 +15,7 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/ncp": "0.4.1"
+    "@nextclaw/ncp": "0.4.2"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
@@ -23,7 +23,7 @@
     "tsup": "^8.3.5",
     "typescript": "^5.6.3",
     "vitest": "^2.1.2",
-    "@nextclaw/ncp-agent-runtime": "0.3.1"
+    "@nextclaw/ncp-agent-runtime": "0.3.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --out-dir dist",