@deepagents/context 2.1.0 → 2.2.0

package/README.md

@@ -27,14 +27,13 @@ like store implementations, sandbox tooling, and filesystem-based skill loading.
 
 The server-side package also ships the sandbox primitives used by
 `@deepagents/text2sql` and other tool-driven agents. Use `createBashTool()`
-with `createVirtualSandbox()`, `createContainerTool()`, `createDockerSandbox()`,
-or `createAgentOsSandbox()` depending on whether commands should run in memory,
+with `createVirtualSandbox()`, `createDockerSandbox()`, or
+`createAgentOsSandbox()` depending on whether commands should run in memory,
 Docker, or Agent OS.
 
 See the docs for the full API surface:
 
 - [Sandbox](https://januarylabs.github.io/deepagents/docs/context/sandbox)
-- [Container Tool](https://januarylabs.github.io/deepagents/docs/context/container-tool)
 - [Subcommand Builders](https://januarylabs.github.io/deepagents/docs/context/subcommand)
 
 ## Basic Usage
@@ -408,31 +407,36 @@ The package includes durable stream persistence utilities:
 - `persistedWriter` (low-level writer wrapper)
 
 ```typescript
-import { SqliteStreamStore, StreamManager } from '@deepagents/context';
+import {
+  PollingChangeSource,
+  SqliteStreamStore,
+  StreamManager,
+} from '@deepagents/context';
 
 const store = new SqliteStreamStore('./streams.db');
-const manager = new StreamManager({
-  store,
-  watchPolling: {
+const changeSource = new PollingChangeSource({
+  reads: store,
+  config: {
     minMs: 25,
     maxMs: 500,
     multiplier: 2,
     jitterRatio: 0.15,
     statusCheckEvery: 3,
-    chunkPageSize: 128,
-  },
-  cancelPolling: {
-    minMs: 50,
-    maxMs: 500,
-    multiplier: 2,
-    jitterRatio: 0.15,
   },
 });
+const manager = new StreamManager({
+  store,
+  changeSource,
+  chunkPageSize: 128,
+});
 
 // Discover active streams without writing raw SQL.
 const runningStreamIds = await store.listStreamIds({ status: 'running' });
 const runningViaConvenienceMethod = await store.listRunningStreamIds();
 
+// Streams auto-fail if a persisted chunk has type: 'error'
+// (the stream's `error` field is populated from `errorText`).
+
 // Shutdown cleanup (idempotent)
 store.close();
 ```

package/dist/browser.js

@@ -2222,6 +2222,18 @@ function soul() {
 
 // packages/context/src/lib/store/store.ts
 var ContextStore = class {
+  /**
+   * Add multiple messages to the graph.
+   *
+   * Stores can override this for atomic/batched persistence. The default keeps
+   * the single-message contract for implementations that do not need a custom
+   * batch path.
+   */
+  async addMessages(messages) {
+    for (const message2 of messages) {
+      await this.addMessage(message2);
+    }
+  }
 };
 
 // packages/context/src/lib/stream-buffer.ts
@@ -2235,11 +2247,12 @@ async function persistedWriter(options) {
   } = options;
   let seq = 0;
   let buffer = [];
+  let failedByErrorChunk = false;
   async function flush() {
     if (buffer.length === 0) return;
     const batch = buffer;
     buffer = [];
-    await store.appendChunks(batch);
+    await appendBatch(batch);
   }
   function makeChunk(part) {
     return {
@@ -2249,9 +2262,19 @@ async function persistedWriter(options) {
       createdAt: Date.now()
     };
   }
+  function isStreamErrorPart(part) {
+    return part.type === "error";
+  }
+  async function appendBatch(batch) {
+    const hasErrorPart = !failedByErrorChunk && batch.map((chunk) => chunk.data).some(isStreamErrorPart);
+    await store.appendChunks(batch);
+    if (hasErrorPart) {
+      failedByErrorChunk = true;
+    }
+  }
   async function persistChunk(chunk) {
     if (strategy === "immediate") {
-      await store.appendChunks([chunk]);
+      await appendBatch([chunk]);
     } else {
       buffer.push(chunk);
       if (buffer.length >= flushSize) {
@@ -2281,10 +2304,12 @@ async function persistedWriter(options) {
     flush,
     async complete() {
       await flush();
+      if (failedByErrorChunk) return;
       await store.updateStreamStatus(streamId, "completed");
     },
     async fail(error) {
       await flush();
+      if (failedByErrorChunk) return;
       await store.updateStreamStatus(streamId, "failed", { error });
     },
     async cleanup() {
@@ -2294,6 +2319,15 @@ async function persistedWriter(options) {
 }
 
 // packages/context/src/lib/stream/stream-store.ts
+function collectStreamFailures(chunks) {
+  const failures = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    if (chunk.data.type === "error" && !failures.has(chunk.streamId)) {
+      failures.set(chunk.streamId, chunk.data.errorText);
+    }
+  }
+  return [...failures].map(([streamId, error]) => ({ streamId, error }));
+}
 var StreamStore = class {
   async listRunningStreamIds() {
     return this.listStreamIds({ status: "running" });
@@ -2373,6 +2407,7 @@ export {
   assistant,
   assistantText,
   clarification,
+  collectStreamFailures,
   correction,
   defaultTokenizer,
   estimate,