@ai-sdk/harness-deepagents 1.0.93 → 1.0.94

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @ai-sdk/harness-deepagents
 
+## 1.0.94
+
+### Patch Changes
+
+- 9ec34bd: Preserve Deep Agents conversation context when a stopped session is resumed.
+- 8961fde: feat(harness): allow changing `model` between turns via call options
+- Updated dependencies [8961fde]
+- Updated dependencies [eb59f2a]
+  - @ai-sdk/harness@1.0.94
+  - @ai-sdk/provider-utils@5.0.34
+
 ## 1.0.93
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -1892,6 +1892,124 @@ function createLocalShellBackend({
   });
 }
 
+// src/bridge/persistent-memory-saver.ts
+import { mkdir as mkdir2, readFile, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+var SNAPSHOT_HEADER = "deepagents-memory-saver-v1";
+function encodeString(value) {
+  return Buffer.from(value, "utf8").toString("base64");
+}
+function decodeString(value) {
+  return Buffer.from(value, "base64").toString("utf8");
+}
+function encodeBytes(value) {
+  return Buffer.from(value).toString("base64");
+}
+function decodeBytes(value) {
+  return Buffer.from(value, "base64");
+}
+async function loadMemorySaver({
+  path,
+  saver
+}) {
+  let snapshot;
+  try {
+    snapshot = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  const [header, ...lines] = snapshot.split("\n");
+  if (header !== SNAPSHOT_HEADER) {
+    throw new Error("Unsupported Deep Agents conversation checkpoint format");
+  }
+  const storage = /* @__PURE__ */ Object.create(null);
+  const writes = /* @__PURE__ */ Object.create(null);
+  for (const line of lines) {
+    if (line === "") continue;
+    const fields = line.split("	");
+    if (fields[0] === "S" && fields.length === 7) {
+      const [, threadIdValue, namespaceValue, checkpointIdValue] = fields;
+      const threadId = decodeString(threadIdValue);
+      const namespace = decodeString(namespaceValue);
+      const checkpointId = decodeString(checkpointIdValue);
+      storage[threadId] ??= /* @__PURE__ */ Object.create(null);
+      storage[threadId][namespace] ??= /* @__PURE__ */ Object.create(null);
+      storage[threadId][namespace][checkpointId] = [
+        decodeBytes(fields[4]),
+        decodeBytes(fields[5]),
+        fields[6] === "" ? void 0 : decodeString(fields[6])
+      ];
+      continue;
+    }
+    if (fields[0] === "W" && fields.length === 6) {
+      const [, keyValue, indexValue, taskIdValue, channelValue, value] = fields;
+      const key = decodeString(keyValue);
+      const index = decodeString(indexValue);
+      writes[key] ??= /* @__PURE__ */ Object.create(null);
+      writes[key][index] = [
+        decodeString(taskIdValue),
+        decodeString(channelValue),
+        decodeBytes(value)
+      ];
+      continue;
+    }
+    throw new Error("Invalid Deep Agents conversation checkpoint");
+  }
+  saver.storage = storage;
+  saver.writes = writes;
+}
+async function saveMemorySaver({
+  path,
+  saver
+}) {
+  const lines = [SNAPSHOT_HEADER];
+  for (const [threadId, namespaces] of Object.entries(saver.storage)) {
+    for (const [namespace, checkpoints] of Object.entries(namespaces)) {
+      for (const [
+        checkpointId,
+        [checkpoint, metadata, parentCheckpointId]
+      ] of Object.entries(checkpoints)) {
+        lines.push(
+          [
+            "S",
+            encodeString(threadId),
+            encodeString(namespace),
+            encodeString(checkpointId),
+            encodeBytes(checkpoint),
+            encodeBytes(metadata),
+            parentCheckpointId == null ? "" : encodeString(parentCheckpointId)
+          ].join("	")
+        );
+      }
+    }
+  }
+  for (const [key, indexedWrites] of Object.entries(saver.writes)) {
+    for (const [index, [taskId, channel, value]] of Object.entries(
+      indexedWrites
+    )) {
+      lines.push(
+        [
+          "W",
+          encodeString(key),
+          encodeString(index),
+          encodeString(taskId),
+          encodeString(channel),
+          encodeBytes(value)
+        ].join("	")
+      );
+    }
+  }
+  await mkdir2(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${process.pid}.tmp`;
+  await writeFile2(temporaryPath, `${lines.join("\n")}
+`, "utf8");
+  await rename(temporaryPath, path);
+}
+async function removeMemorySaverSnapshot(path) {
+  await rm(path, { force: true });
+}
+
 // src/bridge/tool-filtering.ts
 import {
   AIMessage as AIMessage18,
@@ -2008,14 +2126,22 @@ function buildModel({
     } : {}
   });
 }
-function createReasoningMiddleware({
-  thinking,
-  effort
-}) {
-  if (!thinking && !effort) return void 0;
+function createModelMiddleware() {
   return createMiddleware({
-    name: "harnessReasoning",
+    name: "harnessModel",
     wrapModelCall: async (request, handler) => {
+      if (!activeModel && !activeThinking && !activeEffort) {
+        return handler(request);
+      }
+      if (activeModel) {
+        const configuredModel2 = buildModel({
+          rawModel: activeModel,
+          thinking: activeThinking,
+          effort: activeEffort
+        });
+        if (!configuredModel2) throw new Error("Deep Agents model is missing");
+        return handler({ ...request, model: configuredModel2 });
+      }
       let model = request.model;
       if ("_getModelInstance" in model && typeof model._getModelInstance === "function") {
         model = await model._getModelInstance();
@@ -2025,8 +2151,8 @@ function createReasoningMiddleware({
       }
       const configuredModel = buildModel({
         rawModel: model.model,
-        thinking,
-        effort
+        thinking: activeThinking,
+        effort: activeEffort
       });
       if (!configuredModel) throw new Error("Deep Agents model is missing");
       return handler({ ...request, model: configuredModel });
@@ -2040,13 +2166,26 @@ if (!workdir || !bridgeStateDir) {
   console.error("deepagents bridge: missing --workdir / --bridge-state-dir");
   process.exit(1);
 }
+var conversationCheckpointPath = `${bridgeStateDir}/conversation.checkpoint`;
 var agent;
 var currentTurn;
 var mcpClient;
 var mcpToolNames = /* @__PURE__ */ new Set();
 var currentResponseFormat;
 var checkpointer = new MemorySaver2();
+if (args.resume === "true") {
+  await loadMemorySaver({
+    path: conversationCheckpointPath,
+    saver: checkpointer
+  });
+} else {
+  await removeMemorySaverSnapshot(conversationCheckpointPath);
+}
 var agentConfigurationSignature;
+var activeModel;
+var activeThinking;
+var activeEffort;
+var modelMiddleware = createModelMiddleware();
 var responseFormatMiddleware = createMiddleware({
   name: "HarnessResponseFormat",
   wrapModelCall(request, handler) {
@@ -2083,6 +2222,9 @@ function buildHostTools(toolSchemas) {
 }
 async function runTurn(start, turn) {
   currentTurn = turn;
+  if (start.model) activeModel = start.model;
+  activeThinking = start.thinking;
+  activeEffort = start.effort;
   currentResponseFormat = start.responseFormat?.type === "json" && start.responseFormat.schema != null ? toolStrategy(start.responseFormat.schema) : void 0;
   const emit = (event) => turn.emit(event);
   const interruptOn = buildInterruptOn(
@@ -2108,15 +2250,6 @@ async function runTurn(start, turn) {
       });
     }
     await closeMcpClient();
-    const model = buildModel({
-      rawModel: start.model,
-      thinking: start.thinking,
-      effort: start.effort
-    });
-    const reasoningMiddleware = model ? void 0 : createReasoningMiddleware({
-      thinking: start.thinking,
-      effort: start.effort
-    });
     const builtinToolFilteringMiddleware = createBuiltinToolFilteringMiddleware(
       {
         builtinToolFiltering: start.builtinToolFiltering,
@@ -2129,7 +2262,7 @@ async function runTurn(start, turn) {
     );
     const middleware = [
       responseFormatMiddleware,
-      ...reasoningMiddleware ? [reasoningMiddleware] : [],
+      modelMiddleware,
       ...builtinToolFilteringMiddleware ? [builtinToolFilteringMiddleware] : []
     ];
     const hostTools = buildHostTools(start.tools);
@@ -2142,8 +2275,6 @@ async function runTurn(start, turn) {
     );
     mcpToolNames = new Set(mcpTools.map((mcpTool) => mcpTool.name));
     agent = createDeepAgent({
-      // Defer to Deep Agents's own default when the host configured no model.
-      ...model ? { model } : {},
       tools: [...mcpTools, ...hostTools],
       backend: createLocalShellBackend({ rootDir: workdir }),
       systemPrompt: start.instructions ? { suffix: start.instructions } : void 0,
@@ -2165,7 +2296,7 @@ async function runTurn(start, turn) {
   const streamEventState = createDeepAgentsStreamEventState();
   const emitStreamEvent = createEmitStreamEvent({
     state: streamEventState,
-    configuredModel: start.model,
+    configuredModel: activeModel,
     hostToolNames,
     mcpToolNames,
     structuredOutputToolNames: new Set(
@@ -2268,9 +2399,16 @@ await runBridge({
   onStart: runTurn,
   onStop: async () => {
     await closeMcpClient();
+    await saveMemorySaver({
+      path: conversationCheckpointPath,
+      saver: checkpointer
+    });
     return {};
   },
-  onDestroy: closeMcpClient
+  onDestroy: async () => {
+    await closeMcpClient();
+    await removeMemorySaverSnapshot(conversationCheckpointPath);
+  }
 });
 async function loadMcpTools({
   mcpServers