@nextclaw/ncp-toolkit 0.4.7 → 0.4.8

package/dist/index.d.ts

@@ -121,13 +121,14 @@ 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>;
     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 NcpEventType6
 } from "@nextclaw/ncp";
 
 // src/errors/ncp-error-exception.ts
@@ -831,65 +831,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 +903,138 @@ function buildPersistedLiveSessionRecord(params) {
   };
 }
 
+// src/agent/agent-backend/agent-backend-append-message.ts
+import { NcpEventType as NcpEventType5 } 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: NcpEventType5.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/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) {
+    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();
@@ -1053,7 +1126,7 @@ var DefaultNcpAgentBackend = class {
       return;
     }
     this.started = true;
-    this.publisher.publish({ type: NcpEventType5.EndpointReady });
+    this.publisher.publish({ type: NcpEventType6.EndpointReady });
   }
   async stop() {
     if (!this.started) {
@@ -1074,13 +1147,13 @@ var DefaultNcpAgentBackend = class {
   async emit(event) {
     await this.ensureStarted();
     switch (event.type) {
-      case NcpEventType5.MessageRequest:
+      case NcpEventType6.MessageRequest:
         await this.handleRequest(event.payload);
         return;
-      case NcpEventType5.MessageStreamRequest:
+      case NcpEventType6.MessageStreamRequest:
         await this.streamToSubscribers(event.payload);
         return;
-      case NcpEventType5.MessageAbort:
+      case NcpEventType6.MessageAbort:
         await this.handleAbort(event.payload);
         return;
       default:
@@ -1115,42 +1188,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 +1217,18 @@ 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)
+    });
+  };
   async updateSession(sessionId, patch) {
     const liveSession = this.sessionRegistry.getSession(sessionId);
     const storedSession = await this.sessionStore.getSession(sessionId);
@@ -1271,7 +1325,7 @@ var DefaultNcpAgentBackend = class {
   }
   async createAbortEvent(sessionId, messageId) {
     const abortEvent = {
-      type: NcpEventType5.MessageAbort,
+      type: NcpEventType6.MessageAbort,
       payload: {
         sessionId,
         ...messageId ? { messageId } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-toolkit",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "private": false,
   "description": "Toolkit implementations built on top of the NextClaw Communication Protocol.",
   "type": "module",