@nextclaw/ncp-toolkit 0.4.7 → 0.4.9

package/dist/index.d.ts

@@ -121,13 +121,15 @@ declare class DefaultNcpAgentBackend implements NcpAgentServerEndpoint, NcpSessi
     subscribe(listener: (event: NcpEndpointEvent) => void): () => void;
     send(envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions): AsyncIterable<NcpEndpointEvent>;
     abort(payload: NcpMessageAbortPayload): Promise<void>;
-    stream(payloadOrParams: NcpStreamRequestPayload | {
+    stream: (payloadOrParams: NcpStreamRequestPayload | {
         payload: NcpStreamRequestPayload;
         signal: AbortSignal;
-    }, opts?: NcpAgentRunStreamOptions): AsyncIterable<NcpEndpointEvent>;
+    }, opts?: NcpAgentRunStreamOptions) => AsyncIterable<NcpEndpointEvent>;
     listSessions(): Promise<NcpSessionSummary[]>;
     listSessionMessages(sessionId: string): Promise<NcpMessage[]>;
     getSession(sessionId: string): Promise<NcpSessionSummary | null>;
+    appendMessage: (sessionId: string, message: NcpMessage) => Promise<NcpSessionSummary | null>;
+    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;

package/dist/index.js

@@ -692,7 +692,7 @@ async function consume(events) {
 
 // src/agent/agent-backend/agent-backend.ts
 import {
-  NcpEventType as NcpEventType5
+  NcpEventType as NcpEventType8
 } from "@nextclaw/ncp";
 
 // src/errors/ncp-error-exception.ts
@@ -777,23 +777,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(
         {
@@ -831,65 +836,6 @@ var AgentRunExecutor = class {
   }
 };
 
-// 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/agent-backend-session-utils.ts
 import { NcpEventType as NcpEventType4 } from "@nextclaw/ncp";
 function readMessages(snapshot) {
@@ -962,6 +908,175 @@ function buildPersistedLiveSessionRecord(params) {
   };
 }
 
+// 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) {
+    return null;
+  }
+  let liveSession = params.sessionRegistry.getSession(normalizedSessionId);
+  if (!liveSession) {
+    const storedSession = await params.sessionStore.getSession(normalizedSessionId);
+    if (!storedSession) {
+      return null;
+    }
+    liveSession = await params.sessionRegistry.ensureSession(normalizedSessionId);
+  }
+  const nextMessage = {
+    ...structuredClone(params.message),
+    sessionId: normalizedSessionId
+  };
+  const event = {
+    type: NcpEventType6.MessageSent,
+    payload: {
+      sessionId: normalizedSessionId,
+      message: nextMessage
+    }
+  };
+  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-stream.ts
+import { NcpEventType as NcpEventType7 } from "@nextclaw/ncp";
+
+// 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/agent-backend-stream.ts
+async function* streamAgentBackendExecution(params) {
+  const payload = "payload" in params.payloadOrParams && "signal" in params.payloadOrParams ? params.payloadOrParams.payload : params.payloadOrParams;
+  const signal = "payload" in params.payloadOrParams && "signal" in params.payloadOrParams ? params.payloadOrParams.signal : params.opts?.signal ?? new AbortController().signal;
+  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();
+  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();
+  }
+}
+
 // src/agent/agent-backend/event-publisher.ts
 var EventPublisher = class {
   listeners = /* @__PURE__ */ new Set();
@@ -1008,18 +1123,7 @@ 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;
@@ -1053,7 +1157,7 @@ var DefaultNcpAgentBackend = class {
       return;
     }
     this.started = true;
-    this.publisher.publish({ type: NcpEventType5.EndpointReady });
+    this.publisher.publish({ type: NcpEventType8.EndpointReady });
   }
   async stop() {
     if (!this.started) {
@@ -1074,13 +1178,13 @@ var DefaultNcpAgentBackend = class {
   async emit(event) {
     await this.ensureStarted();
     switch (event.type) {
-      case NcpEventType5.MessageRequest:
+      case NcpEventType8.MessageRequest:
         await this.handleRequest(event.payload);
         return;
-      case NcpEventType5.MessageStreamRequest:
+      case NcpEventType8.MessageStreamRequest:
         await this.streamToSubscribers(event.payload);
         return;
-      case NcpEventType5.MessageAbort:
+      case NcpEventType8.MessageAbort:
         await this.handleAbort(event.payload);
         return;
       default:
@@ -1115,42 +1219,11 @@ var DefaultNcpAgentBackend = class {
   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();
-    }
-  }
+  stream = (payloadOrParams, opts) => streamAgentBackendExecution({
+    payloadOrParams,
+    opts,
+    sessionRegistry: this.sessionRegistry
+  });
   async listSessions() {
     const storedSessions = await this.sessionStore.listSessions();
     const summaries = storedSessions.map(
@@ -1175,6 +1248,30 @@ var DefaultNcpAgentBackend = class {
     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({
+      sessionId,
+      message,
+      sessionRegistry: this.sessionRegistry,
+      sessionStore: this.sessionStore,
+      publisher: this.publisher,
+      persistSession: async (nextSessionId) => this.persistSession(nextSessionId),
+      getSession: async (nextSessionId) => this.getSession(nextSessionId)
+    });
+  };
+  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)
+    });
+  };
   async updateSession(sessionId, patch) {
     const liveSession = this.sessionRegistry.getSession(sessionId);
     const storedSession = await this.sessionStore.getSession(sessionId);
@@ -1271,7 +1368,7 @@ var DefaultNcpAgentBackend = class {
   }
   async createAbortEvent(sessionId, messageId) {
     const abortEvent = {
-      type: NcpEventType5.MessageAbort,
+      type: NcpEventType8.MessageAbort,
       payload: {
         sessionId,
         ...messageId ? { messageId } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-toolkit",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "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",