deepagentsdk 0.12.0 → 0.14.0

package/dist/file-saver-C6O2LAvg.cjs

@@ -1,679 +0,0 @@
-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