@robota-sdk/agent-tools 3.0.0-beta.6 → 3.0.0-beta.61

package/dist/node/index.js

@@ -1,3 +1,272 @@
+// src/sandbox/e2b-sandbox-client.ts
+var E2BSandboxClient = class {
+  sandbox;
+  connectSandbox;
+  createSandboxFromSnapshot;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.connectSandbox = options.connectSandbox;
+    this.createSandboxFromSnapshot = options.createSandboxFromSnapshot;
+  }
+  async run(command, options) {
+    const result = await this.sandbox.commands.run(command, {
+      background: false,
+      timeoutMs: options?.timeoutMs,
+      cwd: options?.workingDirectory
+    });
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode ?? result.exit_code ?? 0
+    };
+  }
+  async readFile(path) {
+    const content = await this.sandbox.files.read(path);
+    return typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+  }
+  async writeFile(path, content) {
+    await this.sandbox.files.write(path, content);
+  }
+  async snapshot() {
+    if (this.sandbox.createSnapshot) {
+      const snapshot = await this.sandbox.createSnapshot();
+      const snapshotId = snapshot.snapshotId ?? snapshot.id;
+      if (!snapshotId) {
+        throw new Error("E2B createSnapshot() did not return a snapshot id.");
+      }
+      return snapshotId;
+    }
+    const sandboxId = this.sandbox.sandboxId;
+    if (!sandboxId) {
+      throw new Error("E2B sandboxId is required to create a resumable sandbox snapshot.");
+    }
+    if (!this.sandbox.pause) {
+      throw new Error("E2B sandbox adapter does not expose pause().");
+    }
+    await this.sandbox.pause();
+    return sandboxId;
+  }
+  async restore(snapshotId) {
+    if (this.createSandboxFromSnapshot) {
+      this.sandbox = await this.createSandboxFromSnapshot(snapshotId);
+      return;
+    }
+    if (this.connectSandbox) {
+      this.sandbox = await this.connectSandbox(snapshotId);
+      return;
+    }
+    if (this.sandbox.sandboxId === snapshotId && this.sandbox.connect) {
+      this.sandbox = await this.sandbox.connect();
+      return;
+    }
+    throw new Error(
+      "E2B sandbox restore requires connectSandbox(snapshotId) or sandbox.connect()."
+    );
+  }
+};
+
+// src/sandbox/in-memory-sandbox-client.ts
+var InMemorySandboxClient = class {
+  files = /* @__PURE__ */ new Map();
+  snapshots = /* @__PURE__ */ new Map();
+  runHandler;
+  snapshotSequence = 0;
+  constructor(options = {}) {
+    for (const [path, content] of Object.entries(options.files ?? {})) {
+      this.files.set(path, content);
+    }
+    this.runHandler = options.runHandler;
+  }
+  async run(command, options) {
+    if (this.runHandler) {
+      return this.runHandler(command, options, this.files);
+    }
+    return { stdout: "", stderr: "", exitCode: 0 };
+  }
+  async readFile(path) {
+    const content = this.files.get(path);
+    if (content === void 0) {
+      throw new Error(`Sandbox file not found: ${path}`);
+    }
+    return content;
+  }
+  async writeFile(path, content) {
+    this.files.set(path, content);
+  }
+  async snapshot() {
+    const snapshotId = `snapshot-${++this.snapshotSequence}`;
+    this.snapshots.set(snapshotId, new Map(this.files));
+    return snapshotId;
+  }
+  async restore(snapshotId) {
+    const snapshot = this.snapshots.get(snapshotId);
+    if (!snapshot) {
+      throw new Error(`Sandbox snapshot not found: ${snapshotId}`);
+    }
+    this.files.clear();
+    for (const [path, content] of snapshot.entries()) {
+      this.files.set(path, content);
+    }
+  }
+  getFile(path) {
+    return this.files.get(path);
+  }
+};
+
+// src/sandbox/workspace-manifest.ts
+import { readdir, readFile } from "fs/promises";
+import { isAbsolute, join, posix, resolve } from "path";
+var DEFAULT_TARGET_ROOT = "/workspace";
+var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+var SHELL_QUOTE_PATTERN = /'/g;
+async function applyWorkspaceManifest(sandboxClient, manifest, options = {}) {
+  if (sandboxClient.applyManifest) {
+    return sandboxClient.applyManifest(manifest, options);
+  }
+  const targetRoot = normalizeSandboxRoot(options.targetRoot ?? DEFAULT_TARGET_ROOT);
+  const appliedEntries = [];
+  for (const [rawPath, entry] of Object.entries(manifest.entries)) {
+    const path = validateWorkspaceManifestPath(rawPath);
+    const targetPath = joinSandboxPath(targetRoot, path);
+    appliedEntries.push(
+      await applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options)
+    );
+  }
+  return { entries: appliedEntries };
+}
+function validateWorkspaceManifestPath(path) {
+  if (path.length === 0) {
+    throw new Error("workspace manifest path must not be empty");
+  }
+  if (path.includes("\0")) {
+    throw new Error("workspace manifest path must not contain NUL bytes");
+  }
+  if (path.startsWith("/") || path.startsWith("\\") || WINDOWS_ABSOLUTE_PATH_PATTERN.test(path)) {
+    throw new Error("workspace manifest path must be workspace-relative");
+  }
+  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error("workspace manifest path must not resolve to the workspace root");
+  }
+  if (parts.some((part) => part === "..")) {
+    throw new Error("workspace manifest path cannot contain traversal segments");
+  }
+  const normalizedParts = parts.filter((part) => part !== ".");
+  if (normalizedParts.length === 0) {
+    throw new Error("workspace manifest path must not resolve to the workspace root");
+  }
+  return normalizedParts.join("/");
+}
+async function applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options) {
+  switch (entry.type) {
+    case "file":
+      await writeSandboxFile(sandboxClient, targetPath, targetRoot, entry.content);
+      return createAppliedEntry(path, entry.type);
+    case "dir":
+      await createSandboxDirectory(sandboxClient, targetPath);
+      return createAppliedEntry(path, entry.type);
+    case "localFile":
+      await copyLocalFile(sandboxClient, entry.src, targetPath, targetRoot, options);
+      return createAppliedEntry(path, entry.type);
+    case "localDir":
+      await copyLocalDirectory(sandboxClient, entry.src, targetPath, options);
+      return createAppliedEntry(path, entry.type);
+    case "gitRepo":
+      await cloneGitRepository(sandboxClient, entry, targetPath);
+      return createAppliedEntry(path, entry.type);
+    case "s3Mount":
+    case "gcsMount":
+    case "r2Mount":
+    case "azureBlobMount":
+      return {
+        path,
+        type: entry.type,
+        status: "unsupported",
+        message: `${entry.type} requires a provider-specific sandbox adapter.`
+      };
+    default:
+      return assertUnreachable(entry);
+  }
+}
+function createAppliedEntry(path, type) {
+  return { path, type, status: "applied" };
+}
+async function copyLocalFile(sandboxClient, source, targetPath, targetRoot, options) {
+  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
+  const content = await readFile(hostSourcePath, "utf8");
+  await writeSandboxFile(sandboxClient, targetPath, targetRoot, content);
+}
+async function copyLocalDirectory(sandboxClient, source, targetPath, options) {
+  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
+  await copyLocalDirectoryRecursive(sandboxClient, hostSourcePath, targetPath);
+}
+async function copyLocalDirectoryRecursive(sandboxClient, sourcePath, targetPath) {
+  await createSandboxDirectory(sandboxClient, targetPath);
+  const entries = await readdir(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const childSourcePath = join(sourcePath, entry.name);
+    const childTargetPath = joinSandboxPath(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      await copyLocalDirectoryRecursive(sandboxClient, childSourcePath, childTargetPath);
+      continue;
+    }
+    if (entry.isFile()) {
+      const content = await readFile(childSourcePath, "utf8");
+      await sandboxClient.writeFile(childTargetPath, content);
+    }
+  }
+}
+async function cloneGitRepository(sandboxClient, entry, targetPath) {
+  const shallowArgs = entry.shallow === false ? "" : " --depth 1";
+  const refArgs = entry.ref ? ` --branch ${quoteShellArg(entry.ref)}` : "";
+  await runSandboxCommand(
+    sandboxClient,
+    `git clone${shallowArgs}${refArgs} ${quoteShellArg(entry.url)} ${quoteShellArg(targetPath)}`
+  );
+}
+async function writeSandboxFile(sandboxClient, targetPath, targetRoot, content) {
+  const parentPath = posix.dirname(targetPath);
+  if (parentPath !== targetRoot) {
+    await createSandboxDirectory(sandboxClient, parentPath);
+  }
+  await sandboxClient.writeFile(targetPath, content);
+}
+async function createSandboxDirectory(sandboxClient, targetPath) {
+  await runSandboxCommand(sandboxClient, `mkdir -p ${quoteShellArg(targetPath)}`);
+}
+async function runSandboxCommand(sandboxClient, command) {
+  const result = await sandboxClient.run(command);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `workspace manifest command failed: ${command}
+${result.stderr ?? result.stdout}`
+    );
+  }
+}
+function resolveHostSourcePath(source, hostRoot) {
+  return isAbsolute(source) ? resolve(source) : resolve(hostRoot ?? process.cwd(), source);
+}
+function normalizeSandboxRoot(root) {
+  const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (!normalized.startsWith("/")) {
+    throw new Error("workspace manifest targetRoot must be an absolute sandbox path");
+  }
+  return normalized.length === 0 ? "/" : normalized;
+}
+function joinSandboxPath(root, path) {
+  const normalizedRoot = normalizeSandboxRoot(root);
+  if (normalizedRoot === "/") {
+    return `/${path}`;
+  }
+  return `${normalizedRoot}/${path}`;
+}
+function quoteShellArg(value) {
+  return `'${value.replace(SHELL_QUOTE_PATTERN, "'\\''")}'`;
+}
+function assertUnreachable(value) {
+  throw new Error(`unsupported workspace manifest entry: ${JSON.stringify(value)}`);
+}
+
 // src/registry/tool-registry.ts
 import { ValidationError } from "@robota-sdk/agent-core";
 import { logger } from "@robota-sdk/agent-core";
@@ -165,7 +434,9 @@ function zodToJsonSchema(schema, options = {}) {
     type: "object",
     properties,
     required,
-    ...options.allowAdditionalProperties && { additionalProperties: true }
+    ...(options.allowAdditionalProperties || schemaDef.unknownKeys === "passthrough") && {
+      additionalProperties: true
+    }
   };
 }
 function convertZodTypeToProperty(typeObj) {
@@ -244,6 +515,100 @@ function isRequiredField(typeObj) {
   return typeDef.typeName !== "ZodOptional" && typeDef.typeName !== "ZodNullable" && typeDef.typeName !== "ZodDefault";
 }
 
+// src/implementations/function-tool/parameter-validator.ts
+function validateParameterType(key, value, schema) {
+  const expectedType = schema["type"];
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") {
+        return `Parameter "${key}" must be a string, got ${typeof value}`;
+      }
+      break;
+    case "number":
+      if (typeof value !== "number" || isNaN(value)) {
+        return `Parameter "${key}" must be a number, got ${typeof value}`;
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return `Parameter "${key}" must be a boolean, got ${typeof value}`;
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return `Parameter "${key}" must be an array, got ${typeof value}`;
+      }
+      if (schema.items) {
+        for (let i = 0; i < value.length; i++) {
+          const itemError = validateParameterType(`${key}[${i}]`, value[i], schema.items);
+          if (itemError) {
+            return itemError;
+          }
+        }
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return `Parameter "${key}" must be an object, got ${typeof value}`;
+      }
+      break;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    const enumValues = schema.enum;
+    let isValidEnum = false;
+    for (const enumValue of enumValues) {
+      if (value === enumValue) {
+        isValidEnum = true;
+        break;
+      }
+    }
+    if (!isValidEnum) {
+      return `Parameter "${key}" must be one of: ${enumValues.join(", ")}, got ${value}`;
+    }
+  }
+  return void 0;
+}
+function getValidationErrors(parameters, schemaRequired, schemaProperties, additionalProperties) {
+  const errors = [];
+  for (const field of schemaRequired) {
+    if (!(field in parameters)) {
+      errors.push(`Missing required parameter: ${field}`);
+    }
+  }
+  for (const [key, value] of Object.entries(parameters)) {
+    const paramSchema = schemaProperties[key];
+    if (!paramSchema) {
+      if (additionalProperties === true) {
+        continue;
+      }
+      if (additionalProperties && typeof additionalProperties === "object") {
+        const additionalTypeError = validateParameterType(key, value, additionalProperties);
+        if (additionalTypeError) errors.push(additionalTypeError);
+        continue;
+      }
+      errors.push(`Unknown parameter: ${key}`);
+      continue;
+    }
+    const typeError = validateParameterType(key, value, paramSchema);
+    if (typeError) {
+      errors.push(typeError);
+    }
+  }
+  return errors;
+}
+function validateToolParameters(parameters, schemaRequired, schemaProperties, additionalProperties) {
+  const errors = getValidationErrors(
+    parameters,
+    schemaRequired,
+    schemaProperties,
+    additionalProperties
+  );
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/implementations/function-tool.ts
 var FunctionTool = class {
   schema;
@@ -274,7 +639,12 @@ var FunctionTool = class {
   async execute(parameters, context) {
     const toolName = this.schema.name;
     if (!this.validate(parameters)) {
-      const errors = this.getValidationErrors(parameters);
+      const errors = getValidationErrors(
+        parameters,
+        this.schema.parameters.required || [],
+        this.schema.parameters.properties || {},
+        this.schema.parameters.additionalProperties
+      );
       throw new ValidationError2(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
     }
     const startTime = Date.now();
@@ -310,17 +680,23 @@ var FunctionTool = class {
    * Validate parameters (simple boolean result)
    */
   validate(parameters) {
-    return this.getValidationErrors(parameters).length === 0;
+    return getValidationErrors(
+      parameters,
+      this.schema.parameters.required || [],
+      this.schema.parameters.properties || {},
+      this.schema.parameters.additionalProperties
+    ).length === 0;
   }
   /**
    * Validate tool parameters with detailed result
    */
   validateParameters(parameters) {
-    const errors = this.getValidationErrors(parameters);
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
+    return validateToolParameters(
+      parameters,
+      this.schema.parameters.required || [],
+      this.schema.parameters.properties || {},
+      this.schema.parameters.additionalProperties
+    );
   }
   /**
    * Get tool description
@@ -328,86 +704,6 @@ var FunctionTool = class {
   getDescription() {
     return this.schema.description;
   }
-  /**
-   * Get detailed validation errors
-   */
-  getValidationErrors(parameters) {
-    const errors = [];
-    const required = this.schema.parameters.required || [];
-    const properties = this.schema.parameters.properties || {};
-    for (const field of required) {
-      if (!(field in parameters)) {
-        errors.push(`Missing required parameter: ${field}`);
-      }
-    }
-    for (const [key, value] of Object.entries(parameters)) {
-      const paramSchema = properties[key];
-      if (!paramSchema) {
-        errors.push(`Unknown parameter: ${key}`);
-        continue;
-      }
-      const typeError = this.validateParameterType(key, value, paramSchema);
-      if (typeError) {
-        errors.push(typeError);
-      }
-    }
-    return errors;
-  }
-  /**
-   * Validate individual parameter type
-   */
-  validateParameterType(key, value, schema) {
-    const expectedType = schema["type"];
-    switch (expectedType) {
-      case "string":
-        if (typeof value !== "string") {
-          return `Parameter "${key}" must be a string, got ${typeof value}`;
-        }
-        break;
-      case "number":
-        if (typeof value !== "number" || isNaN(value)) {
-          return `Parameter "${key}" must be a number, got ${typeof value}`;
-        }
-        break;
-      case "boolean":
-        if (typeof value !== "boolean") {
-          return `Parameter "${key}" must be a boolean, got ${typeof value}`;
-        }
-        break;
-      case "array":
-        if (!Array.isArray(value)) {
-          return `Parameter "${key}" must be an array, got ${typeof value}`;
-        }
-        if (schema.items) {
-          for (let i = 0; i < value.length; i++) {
-            const itemError = this.validateParameterType(`${key}[${i}]`, value[i], schema.items);
-            if (itemError) {
-              return itemError;
-            }
-          }
-        }
-        break;
-      case "object":
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-          return `Parameter "${key}" must be an object, got ${typeof value}`;
-        }
-        break;
-    }
-    if (schema.enum && schema.enum.length > 0) {
-      const enumValues = schema.enum;
-      let isValidEnum = false;
-      for (const enumValue of enumValues) {
-        if (value === enumValue) {
-          isValidEnum = true;
-          break;
-        }
-      }
-      if (!isValidEnum) {
-        return `Parameter "${key}" must be one of: ${enumValues.join(", ")}, got ${value}`;
-      }
-    }
-    return void 0;
-  }
   /**
    * Validate constructor inputs
    */
@@ -451,6 +747,132 @@ function createZodFunctionTool(name, description, zodSchema, fn) {
 
 // src/implementations/openapi-tool.ts
 import { ToolExecutionError as ToolExecutionError2, ValidationError as ValidationError3 } from "@robota-sdk/agent-core";
+
+// src/implementations/openapi-schema-converter.ts
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+function findOperation(apiSpec, operationId) {
+  for (const [path, pathItem] of Object.entries(apiSpec.paths || {})) {
+    if (!pathItem) continue;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (operation?.operationId === operationId) {
+        return { method, path, operation };
+      }
+    }
+  }
+  return void 0;
+}
+function mapOpenAPIType(type) {
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "integer":
+      return "integer";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    default:
+      return "string";
+  }
+}
+function convertOpenAPISchemaToParameterSchema(schema) {
+  if ("$ref" in schema) {
+    return { type: "object" };
+  }
+  const result = {
+    type: mapOpenAPIType(schema.type)
+  };
+  if (schema.description) {
+    result.description = schema.description;
+  }
+  if (schema.enum) {
+    result.enum = schema.enum;
+  }
+  if (schema.minimum !== void 0) {
+    result.minimum = schema.minimum;
+  }
+  if (schema.maximum !== void 0) {
+    result.maximum = schema.maximum;
+  }
+  if (schema.pattern) {
+    result.pattern = schema.pattern;
+  }
+  if (schema.format) {
+    result.format = schema.format;
+  }
+  if (schema.default !== void 0) {
+    result.default = schema.default;
+  }
+  if (schema.type === "array" && schema.items) {
+    result.items = convertOpenAPISchemaToParameterSchema(schema.items);
+  }
+  if (schema.type === "object" && schema.properties) {
+    result.properties = {};
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      result.properties[propName] = convertOpenAPISchemaToParameterSchema(propSchema);
+    }
+    if (schema.required && schema.required.length > 0) {
+      result.required = schema.required;
+    }
+  }
+  return result;
+}
+function convertOpenAPIParamToSchema(param) {
+  const schema = param.schema;
+  return convertOpenAPISchemaToParameterSchema(schema);
+}
+function createSchemaFromOperation(operationId, opSpec) {
+  const properties = {};
+  const required = [];
+  const params = opSpec.parameters || [];
+  for (const param of params) {
+    properties[param.name] = convertOpenAPIParamToSchema(param);
+    if (param.required) {
+      required.push(param.name);
+    }
+  }
+  if (opSpec.requestBody) {
+    const requestBody = opSpec.requestBody;
+    const jsonContent = requestBody.content?.["application/json"];
+    if (jsonContent?.schema) {
+      const bodySchema = convertOpenAPISchemaToParameterSchema(jsonContent.schema);
+      if (bodySchema.type === "object" && bodySchema.properties) {
+        Object.assign(properties, bodySchema.properties);
+        const schemaWithRequired = bodySchema;
+        if (schemaWithRequired.required) {
+          required.push(...schemaWithRequired.required);
+        }
+      }
+    }
+  }
+  const schemaParams = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schemaParams.required = required;
+  }
+  return {
+    name: operationId,
+    description: opSpec.summary || opSpec.description || `OpenAPI operation: ${operationId}`,
+    parameters: schemaParams
+  };
+}
+
+// src/implementations/openapi-tool.ts
 var OpenAPITool = class {
   schema;
   apiSpec;
@@ -557,36 +979,13 @@ var OpenAPITool = class {
    * @private
    */
   async executeAPICall(parameters, _context) {
-    const operation = this.findOperation();
+    const operation = findOperation(this.apiSpec, this.operationId);
     if (!operation) {
       throw new Error(`Operation ${this.operationId} not found in OpenAPI spec`);
     }
-    const requestConfig = this.buildRequestConfig(operation, parameters);
+    this.buildRequestConfig(operation, parameters);
     throw new Error("Not implemented: actual API execution is not yet available");
   }
-  /**
-   * Find the operation in the OpenAPI specification
-   */
-  findOperation() {
-    for (const [path, pathItem] of Object.entries(this.apiSpec.paths || {})) {
-      if (!pathItem) continue;
-      for (const method of [
-        "get",
-        "post",
-        "put",
-        "delete",
-        "patch",
-        "head",
-        "options"
-      ]) {
-        const operation = pathItem[method];
-        if (operation?.operationId === this.operationId) {
-          return { method, path, operation };
-        }
-      }
-    }
-    return void 0;
-  }
   /**
    * Build HTTP request configuration from OpenAPI operation and parameters
    */
@@ -658,121 +1057,13 @@ var OpenAPITool = class {
    * Create tool schema from OpenAPI operation specification
    */
   createSchemaFromOpenAPI() {
-    const operation = this.findOperation();
+    const operation = findOperation(this.apiSpec, this.operationId);
     if (!operation) {
       throw new Error(
         `[STRICT-POLICY][EMITTER-CONTRACT] OpenAPI operation not found: ${this.operationId}. Emitter contract must provide a valid operationId present in the OpenAPI document.`
       );
     }
-    const { operation: opSpec } = operation;
-    const properties = {};
-    const required = [];
-    const params = opSpec.parameters || [];
-    for (const param of params) {
-      properties[param.name] = this.convertOpenAPIParamToSchema(param);
-      if (param.required) {
-        required.push(param.name);
-      }
-    }
-    if (opSpec.requestBody) {
-      const requestBody = opSpec.requestBody;
-      const jsonContent = requestBody.content?.["application/json"];
-      if (jsonContent?.schema) {
-        const bodySchema = this.convertOpenAPISchemaToParameterSchema(jsonContent.schema);
-        if (bodySchema.type === "object" && bodySchema.properties) {
-          Object.assign(properties, bodySchema.properties);
-          const schemaWithRequired = bodySchema;
-          if (schemaWithRequired.required) {
-            required.push(...schemaWithRequired.required);
-          }
-        }
-      }
-    }
-    const schemaParams = {
-      type: "object",
-      properties
-    };
-    if (required.length > 0) {
-      schemaParams.required = required;
-    }
-    return {
-      name: this.operationId,
-      description: opSpec.summary || opSpec.description || `OpenAPI operation: ${this.operationId}`,
-      parameters: schemaParams
-    };
-  }
-  /**
-   * Convert OpenAPI parameter to tool parameter schema
-   */
-  convertOpenAPIParamToSchema(param) {
-    const schema = param.schema;
-    return this.convertOpenAPISchemaToParameterSchema(schema);
-  }
-  /**
-   * Convert OpenAPI schema to parameter schema
-   */
-  convertOpenAPISchemaToParameterSchema(schema) {
-    if ("$ref" in schema) {
-      return { type: "object" };
-    }
-    const result = {
-      type: this.mapOpenAPIType(schema.type)
-    };
-    if (schema.description) {
-      result.description = schema.description;
-    }
-    if (schema.enum) {
-      result.enum = schema.enum;
-    }
-    if (schema.minimum !== void 0) {
-      result.minimum = schema.minimum;
-    }
-    if (schema.maximum !== void 0) {
-      result.maximum = schema.maximum;
-    }
-    if (schema.pattern) {
-      result.pattern = schema.pattern;
-    }
-    if (schema.format) {
-      result.format = schema.format;
-    }
-    if (schema.default !== void 0) {
-      result.default = schema.default;
-    }
-    if (schema.type === "array" && schema.items) {
-      result.items = this.convertOpenAPISchemaToParameterSchema(schema.items);
-    }
-    if (schema.type === "object" && schema.properties) {
-      result.properties = {};
-      for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        result.properties[propName] = this.convertOpenAPISchemaToParameterSchema(propSchema);
-      }
-      if (schema.required && schema.required.length > 0) {
-        result.required = schema.required;
-      }
-    }
-    return result;
-  }
-  /**
-   * Map OpenAPI type to JSON schema type
-   */
-  mapOpenAPIType(type) {
-    switch (type) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "integer":
-        return "integer";
-      case "boolean":
-        return "boolean";
-      case "array":
-        return "array";
-      case "object":
-        return "object";
-      default:
-        return "string";
-    }
+    return createSchemaFromOperation(this.operationId, operation.operation);
   }
 };
 function createOpenAPITool(config) {
@@ -788,9 +1079,33 @@ var BashSchema = z.object({
   timeout: z.number().optional().describe("Optional timeout in milliseconds (max 600000). Default is 120000 (2 minutes)"),
   workingDirectory: z.string().optional().describe("Working directory for the command. Defaults to the current working directory")
 });
-async function runBash(args) {
+async function runBash(args, options = {}) {
   const { command, timeout = DEFAULT_TIMEOUT_MS, workingDirectory } = args;
-  return new Promise((resolve3) => {
+  if (options.sandboxClient) {
+    try {
+      const sandboxResult = await options.sandboxClient.run(command, {
+        timeoutMs: timeout,
+        workingDirectory
+      });
+      const output = sandboxResult.stderr ? `${sandboxResult.stdout}
+stderr:
+${sandboxResult.stderr}` : sandboxResult.stdout;
+      const result = {
+        success: true,
+        output,
+        exitCode: sandboxResult.exitCode
+      };
+      return JSON.stringify(result);
+    } catch (err) {
+      const result = {
+        success: false,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      return JSON.stringify(result);
+    }
+  }
+  return new Promise((resolve4) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let timedOut = false;
@@ -809,12 +1124,17 @@ async function runBash(args) {
     const timer = setTimeout(() => {
       timedOut = true;
       child.kill("SIGTERM");
+      settle({
+        success: false,
+        output: Buffer.concat(stdoutChunks).toString("utf8"),
+        error: `Command timed out after ${timeout}ms`
+      });
     }, timeout);
     function settle(result) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve3(JSON.stringify(result));
+      resolve4(JSON.stringify(result));
     }
     child.on("error", (err) => {
       settle({
@@ -847,17 +1167,20 @@ ${stderr}` : stdout;
     });
   });
 }
-var bashTool = createZodFunctionTool(
-  "Bash",
-  "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.",
-  BashSchema,
-  async (params) => {
-    return runBash(params);
-  }
-);
+function createBashTool(options = {}) {
+  return createZodFunctionTool(
+    "Bash",
+    "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.",
+    BashSchema,
+    async (params) => {
+      return runBash(params, options);
+    }
+  );
+}
+var bashTool = createBashTool();
 
 // src/builtins/read-tool.ts
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
 import { z as z2 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var ReadSchema = z2.object({
@@ -884,88 +1207,152 @@ function formatWithLineNumbers(lines, startLine) {
     return `${lineNum}	${line}`;
   }).join("\n");
 }
-async function readFileTool(args) {
+function formatReadResult(filePath, content, startLine, limit) {
+  const allLines = content.split("\n");
+  if (allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  const zeroBasedStart = startLine - 1;
+  const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
+  const output = formatWithLineNumbers(selectedLines, startLine);
+  const totalLines = allLines.length;
+  const returnedLines = selectedLines.length;
+  const header = returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]
+` : `[File: ${filePath} (${totalLines} lines)]
+`;
+  const result = {
+    success: true,
+    output: header + output
+  };
+  return JSON.stringify(result);
+}
+async function readFileTool(args, options = {}) {
   const { filePath, offset, limit = DEFAULT_LIMIT } = args;
   const startLine = offset !== void 0 && offset > 0 ? offset : 1;
+  if (options.sandboxClient) {
+    try {
+      const content2 = await options.sandboxClient.readFile(filePath);
+      return formatReadResult(filePath, content2, startLine, limit);
+    } catch (err) {
+      const result = {
+        success: false,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      return JSON.stringify(result);
+    }
+  }
   let fileStats;
   try {
     fileStats = await stat(filePath);
   } catch (err) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `File not found: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   if (!fileStats.isFile()) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `Path is not a file: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   let buffer;
   try {
-    buffer = await readFile(filePath);
+    buffer = await readFile2(filePath);
   } catch (err) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: err instanceof Error ? err.message : String(err)
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   if (isBinary(buffer)) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `Binary file not supported: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   const content = buffer.toString("utf8");
-  const allLines = content.split("\n");
-  if (allLines[allLines.length - 1] === "") {
-    allLines.pop();
+  return formatReadResult(filePath, content, startLine, limit);
+}
+function createReadTool(options = {}) {
+  return createZodFunctionTool(
+    "Read",
+    "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.",
+    ReadSchema,
+    async (params) => {
+      return readFileTool(params, options);
+    }
+  );
+}
+var readTool = createReadTool();
+
+// src/builtins/write-tool.ts
+import { z as z3 } from "zod";
+
+// src/builtins/atomic-file-write.ts
+import { randomBytes } from "crypto";
+import { chmod, mkdir, rename, rm, stat as stat2, writeFile } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+var TEMP_RANDOM_BYTES = 6;
+var PRESERVED_MODE_BITS = 4095;
+var MISSING_FILE_ERROR_CODE = "ENOENT";
+function createTempFilePath(filePath) {
+  const dir = dirname(filePath);
+  const name = basename(filePath);
+  const suffix = randomBytes(TEMP_RANDOM_BYTES).toString("hex");
+  return join2(dir, `.${name}.robota-tmp-${process.pid}-${Date.now()}-${suffix}`);
+}
+async function readExistingMode(filePath) {
+  try {
+    const fileStats = await stat2(filePath);
+    return fileStats.mode & PRESERVED_MODE_BITS;
+  } catch (error) {
+    if (error instanceof Error && hasErrorCode(error, MISSING_FILE_ERROR_CODE)) return void 0;
+    throw error;
   }
-  const zeroBasedStart = startLine - 1;
-  const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
-  const output = formatWithLineNumbers(selectedLines, startLine);
-  const totalLines = allLines.length;
-  const returnedLines = selectedLines.length;
-  const header = returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]
-` : `[File: ${filePath} (${totalLines} lines)]
-`;
-  const result = {
-    success: true,
-    output: header + output
-  };
-  return JSON.stringify(result);
 }
-var readTool = createZodFunctionTool(
-  "Read",
-  "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.",
-  ReadSchema,
-  async (params) => {
-    return readFileTool(params);
+function hasErrorCode(error, code) {
+  return "code" in error && error.code === code;
+}
+async function atomicWriteUtf8File(filePath, content) {
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const existingMode = await readExistingMode(filePath);
+  const tempFilePath = createTempFilePath(filePath);
+  try {
+    await writeFile(tempFilePath, content, "utf8");
+    if (existingMode !== void 0) {
+      await chmod(tempFilePath, existingMode);
+    }
+    await rename(tempFilePath, filePath);
+  } catch (error) {
+    await rm(tempFilePath, { force: true }).catch(() => void 0);
+    throw error;
   }
-);
+}
 
 // src/builtins/write-tool.ts
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
-import { z as z3 } from "zod";
 var WriteSchema = z3.object({
   filePath: z3.string().describe("The absolute path to the file to write"),
   content: z3.string().describe("The content to write to the file")
 });
-async function writeFileTool(args) {
+async function writeFileTool(args, options = {}) {
   const { filePath, content } = args;
   try {
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, content, "utf8");
+    if (options.sandboxClient) {
+      await options.sandboxClient.writeFile(filePath, content);
+    } else {
+      await atomicWriteUtf8File(filePath, content);
+    }
     const result = {
       success: true,
       output: `Written ${Buffer.byteLength(content, "utf8")} bytes to ${filePath}`
@@ -980,17 +1367,20 @@ async function writeFileTool(args) {
     return JSON.stringify(result);
   }
 }
-var writeTool = createZodFunctionTool(
-  "Write",
-  "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.",
-  WriteSchema,
-  async (params) => {
-    return writeFileTool(params);
-  }
-);
+function createWriteTool(options = {}) {
+  return createZodFunctionTool(
+    "Write",
+    "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.",
+    WriteSchema,
+    async (params) => {
+      return writeFileTool(params, options);
+    }
+  );
+}
+var writeTool = createWriteTool();
 
 // src/builtins/edit-tool.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { z as z4 } from "zod";
 var EditSchema = z4.object({
   filePath: z4.string().describe("The absolute path to the file to modify"),
@@ -1000,11 +1390,11 @@ var EditSchema = z4.object({
     "Replace all occurrences of old_string (default: false). Useful for renaming variables"
   )
 });
-async function editFileTool(args) {
+async function editFileTool(args, options = {}) {
   const { filePath, oldString, newString, replaceAll = false } = args;
   let content;
   try {
-    content = await readFile2(filePath, "utf8");
+    content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await readFile3(filePath, "utf8");
   } catch (err) {
     const result2 = {
       success: false,
@@ -1036,7 +1426,11 @@ async function editFileTool(args) {
   }
   const updated = replaceAll ? content.split(oldString).join(newString) : content.slice(0, content.indexOf(oldString)) + newString + content.slice(content.indexOf(oldString) + oldString.length);
   try {
-    await writeFile2(filePath, updated, "utf8");
+    if (options.sandboxClient) {
+      await options.sandboxClient.writeFile(filePath, updated);
+    } else {
+      await atomicWriteUtf8File(filePath, updated);
+    }
   } catch (err) {
     const result2 = {
       success: false,
@@ -1046,24 +1440,30 @@ async function editFileTool(args) {
     return JSON.stringify(result2);
   }
   const count = replaceAll ? content.split(oldString).length - 1 : 1;
+  const matchIdx = content.indexOf(oldString);
+  const startLine = matchIdx >= 0 ? content.substring(0, matchIdx).split("\n").length : 1;
   const result = {
     success: true,
-    output: `Replaced ${count} occurrence(s) in ${filePath}`
+    output: `Replaced ${count} occurrence(s) in ${filePath}`,
+    startLine
   };
   return JSON.stringify(result);
 }
-var editTool = createZodFunctionTool(
-  "Edit",
-  "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.",
-  EditSchema,
-  async (params) => {
-    return editFileTool(params);
-  }
-);
+function createEditTool(options = {}) {
+  return createZodFunctionTool(
+    "Edit",
+    "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.",
+    EditSchema,
+    async (params) => {
+      return editFileTool(params, options);
+    }
+  );
+}
+var editTool = createEditTool();
 
 // src/builtins/glob-tool.ts
-import { stat as stat2 } from "fs/promises";
-import { resolve } from "path";
+import { stat as stat3 } from "fs/promises";
+import { resolve as resolve2 } from "path";
 import fg from "fast-glob";
 import { z as z5 } from "zod";
 var DEFAULT_MAX_RESULTS = 1e3;
@@ -1078,7 +1478,7 @@ var GlobSchema = z5.object({
 });
 async function globFileTool(args) {
   const { pattern, path: basePath } = args;
-  const cwd = basePath ? resolve(basePath) : process.cwd();
+  const cwd = basePath ? resolve2(basePath) : process.cwd();
   let matches;
   try {
     matches = await fg(pattern, {
@@ -1097,9 +1497,9 @@ async function globFileTool(args) {
   }
   const withMtime = await Promise.all(
     matches.map(async (p) => {
-      const absPath = resolve(cwd, p);
+      const absPath = resolve2(cwd, p);
       try {
-        const s = await stat2(absPath);
+        const s = await stat3(absPath);
         return { path: p, mtime: s.mtimeMs };
       } catch {
         return { path: p, mtime: 0 };
@@ -1134,8 +1534,8 @@ var globTool = createZodFunctionTool(
 );
 
 // src/builtins/grep-tool.ts
-import { readFile as readFile3, readdir, stat as stat3 } from "fs/promises";
-import { join, resolve as resolve2 } from "path";
+import { readFile as readFile4, readdir as readdir2, stat as stat4 } from "fs/promises";
+import { join as join3, resolve as resolve3 } from "path";
 import { z as z6 } from "zod";
 var GrepSchema = z6.object({
   pattern: z6.string().describe("The regular expression pattern to search for in file contents"),
@@ -1163,16 +1563,16 @@ async function collectFiles(dirPath, glob) {
   async function walk(current) {
     let entryNames;
     try {
-      entryNames = await readdir(current);
+      entryNames = await readdir2(current);
     } catch {
       return;
     }
     for (const name of entryNames) {
       if (name === "node_modules" || name === ".git") continue;
-      const fullPath = join(current, name);
+      const fullPath = join3(current, name);
       let fileStat;
       try {
-        fileStat = await stat3(fullPath);
+        fileStat = await stat4(fullPath);
       } catch {
         continue;
       }
@@ -1228,7 +1628,7 @@ async function grepFileTool(args) {
     contextLines = 0,
     outputMode = "files_with_matches"
   } = args;
-  const targetPath = searchPath ? resolve2(searchPath) : process.cwd();
+  const targetPath = searchPath ? resolve3(searchPath) : process.cwd();
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -1242,7 +1642,7 @@ async function grepFileTool(args) {
   }
   let targetStat;
   try {
-    targetStat = await stat3(targetPath);
+    targetStat = await stat4(targetPath);
   } catch {
     const result2 = {
       success: false,
@@ -1261,7 +1661,7 @@ async function grepFileTool(args) {
   for (const filePath of files) {
     let content;
     try {
-      const buffer = await readFile3(filePath);
+      const buffer = await readFile4(filePath);
       const checkLen = Math.min(buffer.length, 8192);
       let hasBinary = false;
       for (let i = 0; i < checkLen; i++) {
@@ -1425,17 +1825,25 @@ var webSearchTool = createZodFunctionTool(
   async (params) => runWebSearch(params)
 );
 export {
+  E2BSandboxClient,
   FunctionTool,
+  InMemorySandboxClient,
   OpenAPITool,
   ToolRegistry,
+  applyWorkspaceManifest,
   bashTool,
+  createBashTool,
+  createEditTool,
   createFunctionTool,
   createOpenAPITool,
+  createReadTool,
+  createWriteTool,
   createZodFunctionTool,
   editTool,
   globTool,
   grepTool,
   readTool,
+  validateWorkspaceManifestPath,
   webFetchTool,
   webSearchTool,
   writeTool,