@ai-sdk/harness-deepagents 1.0.93 → 1.0.95

package/src/bridge/persistent-memory-saver.ts

@@ -0,0 +1,137 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import type { MemorySaver } from '@langchain/langgraph';
+
+const SNAPSHOT_HEADER = 'deepagents-memory-saver-v1';
+
+function encodeString(value: string): string {
+  return Buffer.from(value, 'utf8').toString('base64');
+}
+
+function decodeString(value: string): string {
+  return Buffer.from(value, 'base64').toString('utf8');
+}
+
+function encodeBytes(value: Uint8Array): string {
+  return Buffer.from(value).toString('base64');
+}
+
+function decodeBytes(value: string): Uint8Array {
+  return Buffer.from(value, 'base64');
+}
+
+export async function loadMemorySaver({
+  path,
+  saver,
+}: {
+  path: string;
+  saver: MemorySaver;
+}): Promise<void> {
+  let snapshot: string;
+  try {
+    snapshot = await readFile(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).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: MemorySaver['storage'] = Object.create(null);
+  const writes: MemorySaver['writes'] = Object.create(null);
+
+  for (const line of lines) {
+    if (line === '') continue;
+    const fields = line.split('\t');
+    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] ??= Object.create(null);
+      storage[threadId][namespace] ??= Object.create(null);
+      storage[threadId][namespace][checkpointId] = [
+        decodeBytes(fields[4]),
+        decodeBytes(fields[5]),
+        fields[6] === '' ? undefined : 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] ??= 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;
+}
+
+export async function saveMemorySaver({
+  path,
+  saver,
+}: {
+  path: string;
+  saver: MemorySaver;
+}): Promise<void> {
+  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('\t'),
+        );
+      }
+    }
+  }
+
+  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('\t'),
+      );
+    }
+  }
+
+  await mkdir(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${process.pid}.tmp`;
+  await writeFile(temporaryPath, `${lines.join('\n')}\n`, 'utf8');
+  await rename(temporaryPath, path);
+}
+
+export async function removeMemorySaverSnapshot(path: string): Promise<void> {
+  await rm(path, { force: true });
+}

package/src/deepagents-bootstrap.ts

@@ -69,19 +69,23 @@ function installRipgrepCommand(): string {
 }
 
 async function readBridgeAsset(name: string): Promise<string> {
-  const candidates = [
-    new URL(`./bridge/${name}`, import.meta.url),
-    new URL(`../bridge/${name}`, import.meta.url),
-  ];
-  let lastErr: unknown;
-  for (const url of candidates) {
-    try {
-      return await readFile(fileURLToPath(url), 'utf8');
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code !== 'ENOENT') throw err;
-      lastErr = err;
-    }
-  }
-  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
+  return readFile(
+    fileURLToPath(
+      resolveBridgeAssetUrl({
+        name,
+        moduleUrl: import.meta.url,
+      }),
+    ),
+    'utf8',
+  );
+}
+
+export function resolveBridgeAssetUrl({
+  name,
+  moduleUrl,
+}: {
+  name: string;
+  moduleUrl: string | URL;
+}): URL {
+  return new URL(`./bridge/${name}`, moduleUrl);
 }

package/src/deepagents-harness.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from 'node:crypto';
 import { posix } from 'node:path';
 import {
   commonTool,
@@ -21,6 +20,7 @@ import {
 } from '@ai-sdk/harness';
 import {
   applyCredentialForwarding,
+  createBridgeToken,
   createSandboxCredentialEnvironment,
   markBridgeStarting,
   createBridgeErrorHandler,
@@ -34,6 +34,7 @@ import {
   shellQuote,
   warnCredentialBrokeringUnavailable,
   waitForBridgeReady,
+  withBridgeToken,
   writeSkills as writeHarnessSkills,
   type WriteSkillsResult,
 } from '@ai-sdk/harness/utils';
@@ -222,7 +223,6 @@ export function createDeepAgents(
     lifecycleStateSchema: deepAgentsResumeStateSchema,
     getBootstrap: getDeepAgentsBootstrap,
     doStart: async startOpts => {
-      const model = startOpts.model ?? settings.model;
       const permissionMode = startOpts.permissionMode;
       const sandboxSession = startOpts.sandboxSession;
       const toolSafeSandboxSession =
@@ -355,7 +355,7 @@ export function createDeepAgents(
             sessionId: startOpts.sessionId,
             channel: attachChannel,
             proc: undefined,
-            model,
+            model: settings.model,
             thinking: settings.thinking,
             effort: settings.effort,
             bridgePort: coords.port,
@@ -382,7 +382,7 @@ export function createDeepAgents(
       });
       const token =
         settings.mintBridgeToken == null
-          ? randomBytes(32).toString('hex')
+          ? createBridgeToken()
           : settings.mintBridgeToken(sandboxId!);
 
       const forwardedAuthEnvironment = credentialsBrokered
@@ -413,7 +413,7 @@ export function createDeepAgents(
       });
 
       const proc = await toolSafeSandboxSession.spawn({
-        command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(bootstrapDir)}`,
+        command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(bootstrapDir)}${isResume ? ' --resume true' : ''}`,
         env,
         abortSignal: startOpts.abortSignal,
       });
@@ -470,7 +470,7 @@ export function createDeepAgents(
         sessionId: startOpts.sessionId,
         channel,
         proc,
-        model,
+        model: settings.model,
         thinking: settings.thinking,
         effort: settings.effort,
         bridgePort: boundPort,
@@ -606,18 +606,6 @@ function openWebSocket({
   });
 }
 
-function withBridgeToken({
-  endpoint,
-  token,
-}: {
-  endpoint: HarnessV1PortEndpoint;
-  token: string;
-}): HarnessV1PortEndpoint {
-  const bridgeUrl = new URL(endpoint.url);
-  bridgeUrl.searchParams.set('agent_bridge_token', token);
-  return { ...endpoint, url: bridgeUrl.toString() };
-}
-
 function createSession({
   sessionId,
   channel,
@@ -785,7 +773,6 @@ function createSession({
   return {
     sessionId,
     isResume,
-    modelId: model,
     doPromptTurn: async promptOpts => {
       if (
         promptOpts.responseFormat?.type === 'json' &&
@@ -822,7 +809,9 @@ function createSession({
         ...(promptOpts.responseFormat == null
           ? {}
           : { responseFormat: promptOpts.responseFormat }),
-        ...(model ? { model } : {}),
+        ...((promptOpts.model ?? model)
+          ? { model: promptOpts.model ?? model }
+          : {}),
         ...(thinking ? { thinking } : {}),
         ...(effort ? { effort } : {}),
         ...(skillsPaths?.length ? { skillsPaths } : {}),
@@ -915,7 +904,6 @@ function createSession({
       }
       stopped = true;
       await teardown({ channel, proc, operation: 'stop' });
-      // In-memory conversation is lost on teardown; the sandbox snapshot preserves the workspace files, not the conversation.
       const payload: HarnessV1ResumeSessionState = {
         type: 'resume-session',
         harnessId: 'deepagents',