deepagentsdk 0.11.0 → 0.12.0

package/dist/file-saver-C6O2LAvg.cjs

@@ -0,0 +1,679 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_agent = require('./agent-Cuks-Idh.cjs');
+let child_process = require("child_process");
+let _ai_sdk_anthropic = require("@ai-sdk/anthropic");
+let _ai_sdk_openai = require("@ai-sdk/openai");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+
+//#region src/backends/sandbox.ts
+/**
+* Encode string to base64 for safe shell transmission.
+*/
+function toBase64(str) {
+	return Buffer.from(str, "utf-8").toString("base64");
+}
+/**
+* Build a Node.js script command with embedded base64 arguments.
+* This avoids shell argument parsing issues by embedding values directly in the script.
+*/
+function buildNodeScript(script, args) {
+	let result = script;
+	for (const [key, value] of Object.entries(args)) result = result.replace(new RegExp(`__${key}__`, "g"), value);
+	return `node -e '${result}'`;
+}
+/**
+* Abstract base class for sandbox backends.
+*
+* Implements all file operations using shell commands via execute().
+* Subclasses only need to implement execute() and id.
+*
+* @example Creating a custom sandbox backend
+* ```typescript
+* class MyCloudSandbox extends BaseSandbox {
+*   readonly id = 'my-cloud-123';
+*
+*   async execute(command: string): Promise<ExecuteResponse> {
+*     // Call your cloud provider's API
+*     const result = await myCloudApi.runCommand(command);
+*     return {
+*       output: result.stdout + result.stderr,
+*       exitCode: result.exitCode,
+*       truncated: false,
+*     };
+*   }
+* }
+* ```
+*/
+var BaseSandbox = class {
+	/**
+	* List files and directories in a path.
+	*/
+	async lsInfo(path) {
+		const pathB64 = toBase64(path);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const dirPath = Buffer.from("__PATH__", "base64").toString("utf-8");
+
+try {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    try {
+      const stat = fs.statSync(fullPath);
+      console.log(JSON.stringify({
+        path: entry.name,
+        is_dir: entry.isDirectory(),
+        size: stat.size,
+        modified_at: stat.mtime.toISOString()
+      }));
+    } catch (e) {}
+  }
+} catch (e) {}
+`, { PATH: pathB64 }));
+		const infos = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				infos.push({
+					path: data.path,
+					is_dir: data.is_dir,
+					size: data.size,
+					modified_at: data.modified_at
+				});
+			} catch {}
+		}
+		return infos;
+	}
+	/**
+	* Read file content with line numbers.
+	*/
+	async read(filePath, offset = 0, limit = require_agent.DEFAULT_READ_LIMIT) {
+		const pathB64 = toBase64(filePath);
+		const script = `
+const fs = require("fs");
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const offset = __OFFSET__;
+const limit = __LIMIT__;
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+const stat = fs.statSync(filePath);
+if (stat.size === 0) {
+  console.log("${require_agent.SYSTEM_REMINDER_FILE_EMPTY}");
+  process.exit(0);
+}
+
+const content = fs.readFileSync(filePath, "utf-8");
+const lines = content.split("\\n");
+const selected = lines.slice(offset, offset + limit);
+
+for (let i = 0; i < selected.length; i++) {
+  const lineNum = (offset + i + 1).toString().padStart(6, " ");
+  console.log(lineNum + "\\t" + selected[i]);
+}
+`;
+		const result = await this.execute(buildNodeScript(script, {
+			PATH: pathB64,
+			OFFSET: String(offset),
+			LIMIT: String(limit)
+		}));
+		if (result.exitCode !== 0) {
+			if (result.output.includes("Error: File not found")) return require_agent.FILE_NOT_FOUND(filePath);
+			return result.output.trim();
+		}
+		return result.output.trimEnd();
+	}
+	/**
+	* Read raw file data.
+	*/
+	async readRaw(filePath) {
+		const pathB64 = toBase64(filePath);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+const stat = fs.statSync(filePath);
+const content = fs.readFileSync(filePath, "utf-8");
+
+console.log(JSON.stringify({
+  content: content.split("\\n"),
+  created_at: stat.birthtime.toISOString(),
+  modified_at: stat.mtime.toISOString()
+}));
+`, { PATH: pathB64 }));
+		if (result.exitCode !== 0) throw new Error(`File '${filePath}' not found`);
+		try {
+			const data = JSON.parse(result.output.trim());
+			return {
+				content: data.content,
+				created_at: data.created_at,
+				modified_at: data.modified_at
+			};
+		} catch {
+			throw new Error(`Failed to parse file data for '${filePath}'`);
+		}
+	}
+	/**
+	* Write content to a new file.
+	*/
+	async write(filePath, content) {
+		const pathB64 = toBase64(filePath);
+		const contentB64 = toBase64(content);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const content = Buffer.from("__CONTENT__", "base64").toString("utf-8");
+
+if (fs.existsSync(filePath)) {
+  console.error("Error: File already exists");
+  process.exit(1);
+}
+
+const dir = path.dirname(filePath);
+if (dir && dir !== ".") {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+fs.writeFileSync(filePath, content, "utf-8");
+`, {
+			PATH: pathB64,
+			CONTENT: contentB64
+		}));
+		if (result.exitCode !== 0) {
+			if (result.output.includes("already exists")) return {
+				success: false,
+				error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+			};
+			return {
+				success: false,
+				error: result.output.trim() || `Failed to write '${filePath}'`
+			};
+		}
+		return {
+			success: true,
+			path: filePath
+		};
+	}
+	/**
+	* Edit a file by replacing string occurrences.
+	*/
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const pathB64 = toBase64(filePath);
+		const oldB64 = toBase64(oldString);
+		const newB64 = toBase64(newString);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+
+const filePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const oldStr = Buffer.from("__OLD__", "base64").toString("utf-8");
+const newStr = Buffer.from("__NEW__", "base64").toString("utf-8");
+const replaceAll = __REPLACE_ALL__;
+
+if (!fs.existsSync(filePath)) {
+  console.error("Error: File not found");
+  process.exit(1);
+}
+
+let content = fs.readFileSync(filePath, "utf-8");
+const count = content.split(oldStr).length - 1;
+
+if (count === 0) {
+  process.exit(2);
+}
+if (count > 1 && !replaceAll) {
+  process.exit(3);
+}
+
+if (replaceAll) {
+  content = content.split(oldStr).join(newStr);
+} else {
+  content = content.replace(oldStr, newStr);
+}
+
+fs.writeFileSync(filePath, content, "utf-8");
+console.log(count);
+`, {
+			PATH: pathB64,
+			OLD: oldB64,
+			NEW: newB64,
+			REPLACE_ALL: String(replaceAll)
+		}));
+		if (result.exitCode === 1) return {
+			success: false,
+			error: require_agent.FILE_NOT_FOUND(filePath)
+		};
+		if (result.exitCode === 2) return {
+			success: false,
+			error: require_agent.STRING_NOT_FOUND(filePath, oldString)
+		};
+		if (result.exitCode === 3) return {
+			success: false,
+			error: `Error: String '${oldString}' appears multiple times. Use replaceAll=true to replace all occurrences.`
+		};
+		return {
+			success: true,
+			path: filePath,
+			occurrences: parseInt(result.output.trim(), 10) || 1
+		};
+	}
+	/**
+	* Search for pattern in files.
+	*/
+	async grepRaw(pattern, path = "/", glob = null) {
+		const patternB64 = toBase64(pattern);
+		const pathB64 = toBase64(path);
+		const globB64 = glob ? toBase64(glob) : toBase64("**/*");
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const pattern = Buffer.from("__PATTERN__", "base64").toString("utf-8");
+const basePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const fileGlob = Buffer.from("__GLOB__", "base64").toString("utf-8");
+
+function walkDir(dir, baseDir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+      
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, baseDir));
+      } else {
+        results.push(relativePath);
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+function matchGlob(filepath, pattern) {
+  if (!pattern || pattern === "**/*") return true;
+  const regex = pattern
+    .replace(/\\./g, "\\\\.")
+    .replace(/\\*\\*/g, "<<<GLOBSTAR>>>")
+    .replace(/\\*/g, "[^/]*")
+    .replace(/<<<GLOBSTAR>>>/g, ".*")
+    .replace(/\\?/g, ".");
+  return new RegExp("^" + regex + "$").test(filepath);
+}
+
+const allFiles = walkDir(basePath, basePath);
+const files = allFiles.filter(f => matchGlob(f, fileGlob)).sort();
+
+for (const file of files) {
+  try {
+    const fullPath = path.join(basePath, file);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const lines = content.split("\\n");
+    
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(pattern)) {
+        console.log(JSON.stringify({
+          path: file,
+          line: i + 1,
+          text: lines[i]
+        }));
+      }
+    }
+  } catch (e) {}
+}
+`, {
+			PATTERN: patternB64,
+			PATH: pathB64,
+			GLOB: globB64
+		}));
+		const matches = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				matches.push({
+					path: data.path,
+					line: data.line,
+					text: data.text
+				});
+			} catch {}
+		}
+		return matches;
+	}
+	/**
+	* Find files matching glob pattern.
+	*/
+	async globInfo(pattern, path = "/") {
+		const pathB64 = toBase64(path);
+		const patternB64 = toBase64(pattern);
+		const result = await this.execute(buildNodeScript(`
+const fs = require("fs");
+const path = require("path");
+
+const basePath = Buffer.from("__PATH__", "base64").toString("utf-8");
+const pattern = Buffer.from("__PATTERN__", "base64").toString("utf-8");
+
+function walkDir(dir, baseDir) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+      
+      if (entry.isDirectory()) {
+        results.push(...walkDir(fullPath, baseDir));
+      } else {
+        results.push(relativePath);
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+function matchGlob(filepath, pattern) {
+  const regex = pattern
+    .replace(/\\./g, "\\\\.")
+    .replace(/\\*\\*/g, "<<<GLOBSTAR>>>")
+    .replace(/\\*/g, "[^/]*")
+    .replace(/<<<GLOBSTAR>>>/g, ".*")
+    .replace(/\\?/g, ".");
+  return new RegExp("^" + regex + "$").test(filepath);
+}
+
+const allFiles = walkDir(basePath, basePath);
+const matches = allFiles.filter(f => matchGlob(f, pattern)).sort();
+
+for (const m of matches) {
+  try {
+    const fullPath = path.join(basePath, m);
+    const stat = fs.statSync(fullPath);
+    console.log(JSON.stringify({
+      path: m,
+      is_dir: stat.isDirectory(),
+      size: stat.size,
+      modified_at: stat.mtime.toISOString()
+    }));
+  } catch (e) {}
+}
+`, {
+			PATH: pathB64,
+			PATTERN: patternB64
+		}));
+		const infos = [];
+		for (const line of result.output.trim().split("\n")) {
+			if (!line) continue;
+			try {
+				const data = JSON.parse(line);
+				infos.push({
+					path: data.path,
+					is_dir: data.is_dir,
+					size: data.size,
+					modified_at: data.modified_at
+				});
+			} catch {}
+		}
+		return infos;
+	}
+};
+
+//#endregion
+//#region src/backends/local-sandbox.ts
+/**
+* LocalSandbox: Execute commands locally using child_process.
+*
+* Useful for local development and testing without cloud sandboxes.
+* All file operations are inherited from BaseSandbox and executed
+* via shell commands in the local filesystem.
+*/
+/**
+* Local sandbox that executes commands using Node.js child_process.
+*
+* All commands are executed in a bash shell with the specified working directory.
+* Inherits all file operations (read, write, edit, ls, grep, glob) from BaseSandbox.
+*
+* @example Basic usage
+* ```typescript
+* import { LocalSandbox } from 'deepagentsdk';
+*
+* const sandbox = new LocalSandbox({ cwd: './workspace' });
+*
+* // Execute commands
+* const result = await sandbox.execute('ls -la');
+* console.log(result.output);
+*
+* // File operations
+* await sandbox.write('./src/index.ts', 'console.log("hello")');
+* const content = await sandbox.read('./src/index.ts');
+* ```
+*
+* @example With timeout and environment
+* ```typescript
+* const sandbox = new LocalSandbox({
+*   cwd: './workspace',
+*   timeout: 60000, // 60 seconds
+*   env: {
+*     NODE_ENV: 'development',
+*     DEBUG: '*',
+*   },
+* });
+* ```
+*
+* @example Error handling
+* ```typescript
+* const result = await sandbox.execute('npm test');
+* if (result.exitCode !== 0) {
+*   console.error('Tests failed:', result.output);
+* }
+* ```
+*/
+var LocalSandbox = class extends BaseSandbox {
+	cwd;
+	timeout;
+	env;
+	maxOutputSize;
+	_id;
+	/**
+	* Create a new LocalSandbox instance.
+	*
+	* @param options - Configuration options for the sandbox
+	*/
+	constructor(options = {}) {
+		super();
+		this.cwd = options.cwd || process.cwd();
+		this.timeout = options.timeout || 3e4;
+		this.env = options.env || {};
+		this.maxOutputSize = options.maxOutputSize || 1024 * 1024;
+		this._id = `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	}
+	/**
+	* Unique identifier for this sandbox instance.
+	* Format: `local-{timestamp}-{random}`
+	*/
+	get id() {
+		return this._id;
+	}
+	/**
+	* Execute a shell command in the local filesystem.
+	*
+	* Commands are executed using bash with the configured working directory
+	* and environment variables. Output is captured from both stdout and stderr.
+	*
+	* @param command - Shell command to execute
+	* @returns ExecuteResponse with output, exit code, and truncation status
+	*
+	* @example
+	* ```typescript
+	* const result = await sandbox.execute('echo "Hello" && ls -la');
+	* console.log(result.output);
+	* console.log('Exit code:', result.exitCode);
+	* ```
+	*/
+	async execute(command) {
+		return new Promise((resolve) => {
+			const child = (0, child_process.spawn)("bash", ["-c", command], {
+				cwd: this.cwd,
+				env: {
+					...process.env,
+					...this.env
+				},
+				timeout: this.timeout
+			});
+			let output = "";
+			let truncated = false;
+			child.stdout.on("data", (data) => {
+				if (output.length < this.maxOutputSize) output += data.toString();
+				else truncated = true;
+			});
+			child.stderr.on("data", (data) => {
+				if (output.length < this.maxOutputSize) output += data.toString();
+				else truncated = true;
+			});
+			child.on("close", (code) => {
+				resolve({
+					output,
+					exitCode: code,
+					truncated
+				});
+			});
+			child.on("error", (err) => {
+				resolve({
+					output: `Error: ${err.message}`,
+					exitCode: 1,
+					truncated: false
+				});
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/model-parser.ts
+/**
+* Utility to parse model strings into LanguageModel instances.
+* Provides backward compatibility for CLI and other string-based model specifications.
+*/
+/**
+* Parse a model string into a LanguageModel instance.
+*
+* Supports formats like:
+* - "anthropic/claude-sonnet-4-20250514"
+* - "openai/gpt-4o"
+* - "claude-sonnet-4-20250514" (defaults to Anthropic)
+*
+* @param modelString - The model string to parse
+* @returns A LanguageModel instance
+*
+* @example
+* ```typescript
+* const model = parseModelString("anthropic/claude-sonnet-4-20250514");
+* const agent = createDeepAgent({ model });
+* ```
+*/
+function parseModelString(modelString) {
+	const [provider, modelName] = modelString.split("/");
+	if (provider === "anthropic") return (0, _ai_sdk_anthropic.anthropic)(modelName || "claude-sonnet-4-20250514");
+	else if (provider === "openai") return (0, _ai_sdk_openai.openai)(modelName || "gpt-5-mini");
+	return (0, _ai_sdk_anthropic.anthropic)(modelString);
+}
+
+//#endregion
+//#region src/checkpointer/file-saver.ts
+/**
+* File-based checkpoint saver for local development.
+*/
+/**
+* File-based checkpoint saver.
+* 
+* Stores checkpoints as JSON files in a directory. Each thread gets
+* its own file named `{threadId}.json`.
+* 
+* @example
+* ```typescript
+* const saver = new FileSaver({ dir: './.checkpoints' });
+* const agent = createDeepAgent({
+*   model: anthropic('claude-sonnet-4-20250514'),
+*   checkpointer: saver,
+* });
+* ```
+*/
+var FileSaver = class {
+	dir;
+	constructor(options) {
+		this.dir = options.dir;
+		if (!(0, node_fs.existsSync)(this.dir)) (0, node_fs.mkdirSync)(this.dir, { recursive: true });
+	}
+	getFilePath(threadId) {
+		const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+		return (0, node_path.join)(this.dir, `${safeId}.json`);
+	}
+	async save(checkpoint) {
+		const filePath = this.getFilePath(checkpoint.threadId);
+		const data = {
+			...checkpoint,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		(0, node_fs.writeFileSync)(filePath, JSON.stringify(data, null, 2), "utf-8");
+	}
+	async load(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if (!(0, node_fs.existsSync)(filePath)) return;
+		try {
+			const content = (0, node_fs.readFileSync)(filePath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return;
+		}
+	}
+	async list() {
+		if (!(0, node_fs.existsSync)(this.dir)) return [];
+		return (0, node_fs.readdirSync)(this.dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+	}
+	async delete(threadId) {
+		const filePath = this.getFilePath(threadId);
+		if ((0, node_fs.existsSync)(filePath)) (0, node_fs.unlinkSync)(filePath);
+	}
+	async exists(threadId) {
+		return (0, node_fs.existsSync)(this.getFilePath(threadId));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'BaseSandbox', {
+  enumerable: true,
+  get: function () {
+    return BaseSandbox;
+  }
+});
+Object.defineProperty(exports, 'FileSaver', {
+  enumerable: true,
+  get: function () {
+    return FileSaver;
+  }
+});
+Object.defineProperty(exports, 'LocalSandbox', {
+  enumerable: true,
+  get: function () {
+    return LocalSandbox;
+  }
+});
+Object.defineProperty(exports, 'parseModelString', {
+  enumerable: true,
+  get: function () {
+    return parseModelString;
+  }
+});
+//# sourceMappingURL=file-saver-C6O2LAvg.cjs.map