@samrahimi/smol-js 0.1.0

package/dist/index.js

@@ -0,0 +1,1771 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Agent: () => Agent,
+  AgentLogger: () => AgentLogger,
+  AgentMemory: () => AgentMemory,
+  CodeAgent: () => CodeAgent,
+  FINAL_ANSWER_PROMPT: () => FINAL_ANSWER_PROMPT,
+  FinalAnswerTool: () => FinalAnswerTool,
+  LocalExecutor: () => LocalExecutor,
+  LogLevel: () => LogLevel,
+  Model: () => Model,
+  OpenAIModel: () => OpenAIModel,
+  Tool: () => Tool,
+  UserInputTool: () => UserInputTool,
+  createTool: () => createTool,
+  finalAnswerTool: () => finalAnswerTool,
+  generateSystemPrompt: () => generateSystemPrompt,
+  getErrorRecoveryPrompt: () => getErrorRecoveryPrompt
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["OFF"] = -1] = "OFF";
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 2] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/memory/AgentMemory.ts
+var AgentMemory = class {
+  /**
+   * System prompt step (always first)
+   */
+  systemPrompt;
+  /**
+   * All execution steps
+   */
+  steps = [];
+  constructor(systemPrompt) {
+    this.systemPrompt = {
+      type: "system",
+      content: systemPrompt,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Reset memory, keeping only the system prompt.
+   */
+  reset() {
+    this.steps = [];
+  }
+  /**
+   * Add a task step.
+   */
+  addTask(task) {
+    const step = {
+      type: "task",
+      task,
+      timestamp: Date.now()
+    };
+    this.steps.push(step);
+    return step;
+  }
+  /**
+   * Create a new action step.
+   */
+  createActionStep(stepNumber) {
+    const step = {
+      type: "action",
+      stepNumber,
+      timing: {
+        startTime: Date.now()
+      },
+      modelInputMessages: [],
+      timestamp: Date.now()
+    };
+    this.steps.push(step);
+    return step;
+  }
+  /**
+   * Add a final answer step.
+   */
+  addFinalAnswer(answer) {
+    const step = {
+      type: "final",
+      answer,
+      timestamp: Date.now()
+    };
+    this.steps.push(step);
+    return step;
+  }
+  /**
+   * Get the last step.
+   */
+  getLastStep() {
+    return this.steps[this.steps.length - 1];
+  }
+  /**
+   * Get all action steps.
+   */
+  getActionSteps() {
+    return this.steps.filter((s) => s.type === "action");
+  }
+  /**
+   * Convert memory to messages for LLM context.
+   */
+  toMessages() {
+    const messages = [];
+    messages.push({
+      role: "system",
+      content: this.systemPrompt.content
+    });
+    for (const step of this.steps) {
+      switch (step.type) {
+        case "task":
+          messages.push({
+            role: "user",
+            content: `Task: ${step.task}`
+          });
+          break;
+        case "action":
+          if (step.modelOutputMessage) {
+            messages.push({
+              role: "assistant",
+              content: step.modelOutputMessage.content
+            });
+          }
+          if (step.observation) {
+            messages.push({
+              role: "user",
+              content: step.observation
+            });
+          }
+          if (step.error) {
+            messages.push({
+              role: "user",
+              content: `Error: ${step.error.message}`
+            });
+          }
+          break;
+        case "final":
+          break;
+      }
+    }
+    return messages;
+  }
+  /**
+   * Get total token usage across all steps.
+   */
+  getTotalTokenUsage() {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (const step of this.steps) {
+      if (step.type === "action" && step.tokenUsage) {
+        inputTokens += step.tokenUsage.inputTokens;
+        outputTokens += step.tokenUsage.outputTokens;
+      }
+    }
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    };
+  }
+  /**
+   * Get a summary of the memory for logging.
+   */
+  getSummary() {
+    const actionSteps = this.getActionSteps();
+    const lines = [
+      `System Prompt: ${this.systemPrompt.content.slice(0, 100)}...`,
+      `Total Steps: ${this.steps.length}`,
+      `Action Steps: ${actionSteps.length}`
+    ];
+    const tokenUsage = this.getTotalTokenUsage();
+    if (tokenUsage.totalTokens > 0) {
+      lines.push(`Total Tokens: ${tokenUsage.totalTokens}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Serialize memory to JSON.
+   */
+  toJSON() {
+    return {
+      systemPrompt: this.systemPrompt,
+      steps: this.steps
+    };
+  }
+};
+
+// src/logging/AgentLogger.ts
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var LOG_DIR = path.join(os.homedir(), ".smol-js");
+var AgentLogger = class {
+  level;
+  logFile;
+  sessionId;
+  constructor(level = 1 /* INFO */) {
+    this.level = level;
+    this.sessionId = this.generateSessionId();
+    if (level > -1 /* OFF */) {
+      this.initLogFile();
+    }
+  }
+  /**
+   * Generate a unique session ID.
+   */
+  generateSessionId() {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, "-");
+    return `session-${timestamp}`;
+  }
+  /**
+   * Initialize the log file.
+   */
+  initLogFile() {
+    try {
+      if (!fs.existsSync(LOG_DIR)) {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+      }
+      const logPath = path.join(LOG_DIR, `${this.sessionId}.log`);
+      this.logFile = fs.createWriteStream(logPath, { flags: "a" });
+      this.writeToFile(`=== Session Started: ${(/* @__PURE__ */ new Date()).toISOString()} ===
+
+`);
+    } catch (error) {
+      console.warn("Could not create log file:", error.message);
+    }
+  }
+  /**
+   * Write to the log file.
+   */
+  writeToFile(content) {
+    if (this.logFile) {
+      const cleanContent = content.replace(/\x1b\[[0-9;]*m/g, "");
+      this.logFile.write(cleanContent);
+    }
+  }
+  /**
+   * Set the log level.
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Log a header (task start, step start, etc.)
+   */
+  header(message, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const line = "\u2550".repeat(60);
+    const output = `
+${import_chalk.default.cyan(line)}
+${import_chalk.default.cyan.bold(message)}
+${import_chalk.default.cyan(line)}
+`;
+    console.log(output);
+    this.writeToFile(`
+${"\u2550".repeat(60)}
+${message}
+${"\u2550".repeat(60)}
+`);
+  }
+  /**
+   * Log a subheader.
+   */
+  subheader(message, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `
+${import_chalk.default.cyan("\u2500".repeat(40))}
+${import_chalk.default.cyan(message)}
+`;
+    console.log(output);
+    this.writeToFile(`
+${"\u2500".repeat(40)}
+${message}
+`);
+  }
+  /**
+   * Log reasoning/thought from the agent.
+   */
+  reasoning(content, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.yellow.bold("\u{1F4AD} Reasoning:")}
+${import_chalk.default.yellow(content)}
+`;
+    console.log(output);
+    this.writeToFile(`
+\u{1F4AD} Reasoning:
+${content}
+`);
+  }
+  /**
+   * Log code block.
+   */
+  code(content, language = "javascript", level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.green.bold("\u{1F4DD} Code:")}
+${import_chalk.default.green("```" + language)}
+${import_chalk.default.green(content)}
+${import_chalk.default.green("```")}
+`;
+    console.log(output);
+    this.writeToFile(`
+\u{1F4DD} Code:
+\`\`\`${language}
+${content}
+\`\`\`
+`);
+  }
+  /**
+   * Log execution output.
+   */
+  output(content, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.blue.bold("\u{1F4E4} Output:")}
+${import_chalk.default.blue(content)}
+`;
+    console.log(output);
+    this.writeToFile(`
+\u{1F4E4} Output:
+${content}
+`);
+  }
+  /**
+   * Log execution logs (print statements).
+   */
+  logs(content, level = 1 /* INFO */) {
+    if (this.level < level || !content.trim()) return;
+    const output = `${import_chalk.default.gray.bold("\u{1F4CB} Logs:")}
+${import_chalk.default.gray(content)}
+`;
+    console.log(output);
+    this.writeToFile(`
+\u{1F4CB} Logs:
+${content}
+`);
+  }
+  /**
+   * Log an error.
+   */
+  error(message, error, level = 0 /* ERROR */) {
+    if (this.level < level) return;
+    const errorMessage = error ? `${message}: ${error.message}` : message;
+    const output = `${import_chalk.default.red.bold("\u274C Error:")}
+${import_chalk.default.red(errorMessage)}
+`;
+    console.error(output);
+    this.writeToFile(`
+\u274C Error:
+${errorMessage}
+`);
+    if (error?.stack && this.level >= 2 /* DEBUG */) {
+      console.error(import_chalk.default.red.dim(error.stack));
+      this.writeToFile(`Stack: ${error.stack}
+`);
+    }
+  }
+  /**
+   * Log a warning.
+   */
+  warn(message, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.yellow.bold("\u26A0\uFE0F Warning:")} ${import_chalk.default.yellow(message)}
+`;
+    console.warn(output);
+    this.writeToFile(`
+\u26A0\uFE0F Warning: ${message}
+`);
+  }
+  /**
+   * Log general info.
+   */
+  info(message, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.white(message)}`;
+    console.log(output);
+    this.writeToFile(`${message}
+`);
+  }
+  /**
+   * Log debug info.
+   */
+  debug(message) {
+    if (this.level < 2 /* DEBUG */) return;
+    const output = `${import_chalk.default.dim("[DEBUG]")} ${import_chalk.default.dim(message)}`;
+    console.log(output);
+    this.writeToFile(`[DEBUG] ${message}
+`);
+  }
+  /**
+   * Log final answer.
+   */
+  finalAnswer(answer, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const line = "\u2550".repeat(60);
+    const answerStr = typeof answer === "string" ? answer : JSON.stringify(answer, null, 2);
+    const output = `
+${import_chalk.default.magenta(line)}
+${import_chalk.default.magenta.bold("\u2705 Final Answer:")}
+${import_chalk.default.magenta(answerStr)}
+${import_chalk.default.magenta(line)}
+`;
+    console.log(output);
+    this.writeToFile(`
+${"\u2550".repeat(60)}
+\u2705 Final Answer:
+${answerStr}
+${"\u2550".repeat(60)}
+`);
+  }
+  /**
+   * Log step progress.
+   */
+  stepProgress(current, max, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.cyan.bold(`
+\u{1F504} Step ${current}/${max}`)}
+`;
+    console.log(output);
+    this.writeToFile(`
+\u{1F504} Step ${current}/${max}
+`);
+  }
+  /**
+   * Log waiting message for code execution delay.
+   */
+  waiting(seconds, level = 1 /* INFO */) {
+    if (this.level < level) return;
+    const output = `${import_chalk.default.yellow(`\u23F3 Waiting ${seconds}s before code execution (Ctrl+C to abort)...`)}`;
+    console.log(output);
+    this.writeToFile(`\u23F3 Waiting ${seconds}s before code execution...
+`);
+  }
+  /**
+   * Stream content character by character.
+   */
+  streamChar(char) {
+    if (this.level < 1 /* INFO */) return;
+    process.stdout.write(import_chalk.default.yellow(char));
+  }
+  /**
+   * End streaming (add newline).
+   */
+  streamEnd() {
+    if (this.level < 1 /* INFO */) return;
+    console.log();
+  }
+  /**
+   * Close the log file.
+   */
+  close() {
+    if (this.logFile) {
+      this.writeToFile(`
+=== Session Ended: ${(/* @__PURE__ */ new Date()).toISOString()} ===
+`);
+      this.logFile.end();
+    }
+  }
+  /**
+   * Get the log file path.
+   */
+  getLogPath() {
+    return this.logFile ? path.join(LOG_DIR, `${this.sessionId}.log`) : void 0;
+  }
+};
+
+// src/agents/Agent.ts
+var Agent = class {
+  /**
+   * The LLM model for generation
+   */
+  model;
+  /**
+   * Available tools mapped by name
+   */
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Agent memory tracking all steps
+   */
+  memory;
+  /**
+   * Logger for formatted output
+   */
+  logger;
+  /**
+   * Configuration options
+   */
+  config;
+  /**
+   * Current step number
+   */
+  currentStep = 0;
+  /**
+   * Whether the agent is currently running
+   */
+  isRunning = false;
+  constructor(config) {
+    this.model = config.model;
+    this.logger = new AgentLogger(config.verboseLevel ?? 1 /* INFO */);
+    this.config = {
+      maxSteps: config.maxSteps ?? 20,
+      codeExecutionDelay: config.codeExecutionDelay ?? 5e3,
+      customInstructions: config.customInstructions ?? "",
+      verboseLevel: config.verboseLevel ?? 1 /* INFO */,
+      streamOutputs: config.streamOutputs ?? true
+    };
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+  /**
+   * Run the agent on a task.
+   *
+   * @param task - The task description
+   * @param reset - Whether to reset memory before running
+   * @returns The final result
+   */
+  async run(task, reset = true) {
+    const startTime = Date.now();
+    if (reset || !this.memory) {
+      const systemPrompt = this.initializeSystemPrompt();
+      this.memory = new AgentMemory(systemPrompt);
+      this.currentStep = 0;
+    }
+    this.memory.addTask(task);
+    this.isRunning = true;
+    this.logger.header(`\u{1F680} Starting Agent: ${task.slice(0, 50)}${task.length > 50 ? "..." : ""}`);
+    let finalOutput = null;
+    let isFinalAnswer = false;
+    try {
+      while (this.currentStep < this.config.maxSteps && this.isRunning) {
+        this.currentStep++;
+        this.logger.stepProgress(this.currentStep, this.config.maxSteps);
+        const memoryStep = this.memory.createActionStep(this.currentStep);
+        try {
+          const actionOutput = await this.executeStep(memoryStep);
+          memoryStep.timing.endTime = Date.now();
+          memoryStep.timing.duration = memoryStep.timing.endTime - memoryStep.timing.startTime;
+          memoryStep.actionOutput = actionOutput;
+          memoryStep.isFinalAnswer = actionOutput.isFinalAnswer;
+          if (actionOutput.isFinalAnswer) {
+            finalOutput = actionOutput.output;
+            isFinalAnswer = true;
+            this.logger.finalAnswer(finalOutput);
+            break;
+          }
+        } catch (error) {
+          memoryStep.error = error;
+          memoryStep.timing.endTime = Date.now();
+          memoryStep.timing.duration = memoryStep.timing.endTime - memoryStep.timing.startTime;
+          this.logger.error("Step execution failed", error);
+        }
+      }
+      if (!isFinalAnswer && this.currentStep >= this.config.maxSteps) {
+        this.logger.warn(`Max steps (${this.config.maxSteps}) reached without final answer`);
+        finalOutput = await this.provideFinalAnswer(task);
+      }
+    } finally {
+      this.isRunning = false;
+    }
+    const duration = Date.now() - startTime;
+    const tokenUsage = this.memory.getTotalTokenUsage();
+    this.memory.addFinalAnswer(finalOutput);
+    this.logger.info(`
+\u23F1\uFE0F Total time: ${(duration / 1e3).toFixed(2)}s`);
+    this.logger.info(`\u{1F4CA} Total tokens: ${tokenUsage.totalTokens}`);
+    const logPath = this.logger.getLogPath();
+    if (logPath) {
+      this.logger.info(`\u{1F4C1} Log file: ${logPath}`);
+    }
+    return {
+      output: finalOutput,
+      steps: this.memory.steps,
+      tokenUsage,
+      duration
+    };
+  }
+  /**
+   * Generate a final answer when max steps is reached.
+   */
+  async provideFinalAnswer(task) {
+    this.logger.subheader("Generating final answer from accumulated context");
+    const messages = this.memory.toMessages();
+    messages.push({
+      role: "user",
+      content: `You have reached the maximum number of steps. Based on your work so far, provide the best answer you can for the original task: "${task}"
+
+Summarize what you accomplished and provide a final answer. Call final_answer() with your response.`
+    });
+    const response = await this.model.generate(messages);
+    return response.content;
+  }
+  /**
+   * Stop the agent.
+   */
+  stop() {
+    this.isRunning = false;
+    this.logger.info("Agent stopped by user");
+  }
+  /**
+   * Get the current memory.
+   */
+  getMemory() {
+    return this.memory;
+  }
+  /**
+   * Get registered tools.
+   */
+  getTools() {
+    return this.tools;
+  }
+  /**
+   * Add a tool to the agent.
+   */
+  addTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Remove a tool from the agent.
+   */
+  removeTool(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Sleep for a specified duration.
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+
+// src/executor/LocalExecutor.ts
+var vm = __toESM(require("vm"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_OUTPUT_LENGTH = 5e4;
+var PACKAGE_CACHE_DIR = path2.join(os2.homedir(), ".smol-js", "packages");
+var LocalExecutor = class {
+  context;
+  state = {};
+  tools = /* @__PURE__ */ new Map();
+  config;
+  capturedLogs = [];
+  constructor(config = {}) {
+    this.config = {
+      timeout: DEFAULT_TIMEOUT_MS,
+      allowFs: true,
+      workingDirectory: process.cwd(),
+      ...config
+    };
+    this.context = this.createContext();
+  }
+  /**
+   * Create the VM context with available globals.
+   */
+  createContext() {
+    const consoleProxy = {
+      log: (...args) => {
+        const output = args.map((arg) => this.stringify(arg)).join(" ");
+        this.capturedLogs.push(output);
+      },
+      error: (...args) => {
+        const output = args.map((arg) => this.stringify(arg)).join(" ");
+        this.capturedLogs.push(`[ERROR] ${output}`);
+      },
+      warn: (...args) => {
+        const output = args.map((arg) => this.stringify(arg)).join(" ");
+        this.capturedLogs.push(`[WARN] ${output}`);
+      },
+      info: (...args) => {
+        const output = args.map((arg) => this.stringify(arg)).join(" ");
+        this.capturedLogs.push(output);
+      },
+      debug: (...args) => {
+        const output = args.map((arg) => this.stringify(arg)).join(" ");
+        this.capturedLogs.push(`[DEBUG] ${output}`);
+      }
+    };
+    const print = (...args) => consoleProxy.log(...args);
+    const dynamicImport = async (packageName) => {
+      const authorized = this.config.authorizedImports ?? [];
+      const basePackage = packageName.split("/")[0];
+      if (!authorized.includes(basePackage) && !authorized.includes(packageName)) {
+        throw new Error(
+          `Import not authorized: ${packageName}. Add it to authorizedImports to allow.`
+        );
+      }
+      try {
+        if (!fs2.existsSync(PACKAGE_CACHE_DIR)) {
+          fs2.mkdirSync(PACKAGE_CACHE_DIR, { recursive: true });
+        }
+        const safeFileName = packageName.replace(/[/@]/g, "_") + ".mjs";
+        const cachedPath = path2.join(PACKAGE_CACHE_DIR, safeFileName);
+        let needsFetch = !fs2.existsSync(cachedPath);
+        if (!needsFetch) {
+          const content = fs2.readFileSync(cachedPath, "utf-8");
+          if (content.includes('export * from "/') || content.includes("export * from '/")) {
+            needsFetch = true;
+            fs2.unlinkSync(cachedPath);
+          }
+        }
+        if (needsFetch) {
+          this.capturedLogs.push(`[import] Fetching ${packageName}...`);
+          const jsdelivrUrl = `https://cdn.jsdelivr.net/npm/${packageName}/+esm`;
+          const response = await fetch(jsdelivrUrl);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
+          let code = await response.text();
+          const importMatches = code.matchAll(/from\s+["'](https:\/\/cdn\.jsdelivr\.net\/[^"']+)["']/g);
+          for (const match of importMatches) {
+            const depUrl = match[1];
+            const depName = depUrl.split("/npm/")[1]?.split("/")[0] || "dep";
+            const depFileName = depName.replace(/[/@]/g, "_") + "_dep.mjs";
+            const depCachedPath = path2.join(PACKAGE_CACHE_DIR, depFileName);
+            if (!fs2.existsSync(depCachedPath)) {
+              this.capturedLogs.push(`[import] Fetching dependency from ${depUrl}...`);
+              const depResponse = await fetch(depUrl);
+              if (depResponse.ok) {
+                const depCode = await depResponse.text();
+                fs2.writeFileSync(depCachedPath, depCode, "utf-8");
+              }
+            }
+            code = code.replace(depUrl, `file://${depCachedPath}`);
+          }
+          fs2.writeFileSync(cachedPath, code, "utf-8");
+          this.capturedLogs.push(`[import] Cached ${packageName} to ${cachedPath}`);
+        } else {
+          this.capturedLogs.push(`[import] Using cached ${packageName}`);
+        }
+        const fileUrl = `file://${cachedPath}`;
+        const module2 = await import(fileUrl);
+        return module2.default ?? module2;
+      } catch (error) {
+        throw new Error(`Failed to import ${packageName}: ${error.message}`);
+      }
+    };
+    const contextObj = {
+      // Console and print
+      console: consoleProxy,
+      print,
+      // Built-in objects
+      Object,
+      Array,
+      String,
+      Number,
+      Boolean,
+      Date,
+      Math,
+      JSON,
+      RegExp,
+      Error,
+      Map,
+      Set,
+      WeakMap,
+      WeakSet,
+      Promise,
+      Symbol,
+      Proxy,
+      Reflect,
+      // Type checking
+      parseInt,
+      parseFloat,
+      isNaN,
+      isFinite,
+      typeof: (v) => typeof v,
+      // Timers (promisified for async support)
+      setTimeout: global.setTimeout,
+      clearTimeout: global.clearTimeout,
+      setInterval: global.setInterval,
+      clearInterval: global.clearInterval,
+      // Async utilities
+      fetch: global.fetch,
+      // Dynamic import for npm packages
+      importPackage: dynamicImport,
+      // URL handling
+      URL,
+      URLSearchParams,
+      // Text encoding
+      TextEncoder,
+      TextDecoder,
+      // Buffer (useful for many operations)
+      Buffer,
+      // State reference (variables persist here)
+      __state__: this.state,
+      // Final answer marker
+      __final_answer__: null,
+      __is_final_answer__: false
+    };
+    if (this.config.allowFs) {
+      contextObj.fs = {
+        readFileSync: (filePath, encoding) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), filePath);
+          return fs2.readFileSync(resolvedPath, encoding ?? "utf-8");
+        },
+        writeFileSync: (filePath, data) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), filePath);
+          return fs2.writeFileSync(resolvedPath, data);
+        },
+        existsSync: (filePath) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), filePath);
+          return fs2.existsSync(resolvedPath);
+        },
+        readdirSync: (dirPath) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), dirPath);
+          return fs2.readdirSync(resolvedPath);
+        },
+        mkdirSync: (dirPath, options) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), dirPath);
+          return fs2.mkdirSync(resolvedPath, options);
+        },
+        unlinkSync: (filePath) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), filePath);
+          return fs2.unlinkSync(resolvedPath);
+        },
+        statSync: (filePath) => {
+          const resolvedPath = path2.resolve(this.config.workingDirectory ?? process.cwd(), filePath);
+          return fs2.statSync(resolvedPath);
+        }
+      };
+      contextObj.path = {
+        join: path2.join,
+        resolve: (...paths) => path2.resolve(this.config.workingDirectory ?? process.cwd(), ...paths),
+        dirname: path2.dirname,
+        basename: path2.basename,
+        extname: path2.extname
+      };
+    }
+    return vm.createContext(contextObj);
+  }
+  /**
+   * Add tools to the executor context.
+   */
+  sendTools(tools) {
+    for (const [name, tool] of Object.entries(tools)) {
+      this.tools.set(name, tool);
+      this.context[name] = async (...args) => {
+        let callArgs;
+        if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+          callArgs = args[0];
+        } else {
+          const inputNames = Object.keys(tool.inputs);
+          callArgs = {};
+          args.forEach((arg, i) => {
+            if (i < inputNames.length) {
+              callArgs[inputNames[i]] = arg;
+            }
+          });
+        }
+        return tool.call(callArgs);
+      };
+    }
+  }
+  /**
+   * Send variables to the executor state.
+   */
+  sendVariables(variables) {
+    Object.assign(this.state, variables);
+    Object.assign(this.context, variables);
+  }
+  /**
+   * Execute JavaScript code and return the result.
+   */
+  async execute(code) {
+    this.capturedLogs = [];
+    this.context.__is_final_answer__ = false;
+    this.context.__final_answer__ = null;
+    Object.assign(this.context, this.state);
+    const wrappedCode = this.wrapCode(code);
+    try {
+      const script = new vm.Script(wrappedCode, {
+        filename: "agent-code.js"
+      });
+      const result = await script.runInContext(this.context, {
+        timeout: this.config.timeout,
+        displayErrors: true
+      });
+      const output = result instanceof Promise ? await result : result;
+      this.updateStateFromContext();
+      const isFinalAnswer = this.context.__is_final_answer__;
+      const finalOutput = isFinalAnswer ? this.context.__final_answer__ : output;
+      const logs = this.capturedLogs.join("\n").slice(0, MAX_OUTPUT_LENGTH);
+      return {
+        output: finalOutput,
+        logs,
+        isFinalAnswer
+      };
+    } catch (error) {
+      const logs = this.capturedLogs.join("\n").slice(0, MAX_OUTPUT_LENGTH);
+      return {
+        output: null,
+        logs,
+        isFinalAnswer: false,
+        error
+      };
+    }
+  }
+  /**
+   * Wrap code to handle async execution and final_answer calls.
+   */
+  wrapCode(code) {
+    const finalAnswerFunc = `
+      function final_answer(answer) {
+        __is_final_answer__ = true;
+        __final_answer__ = answer;
+        return answer;
+      }
+    `;
+    return `
+      ${finalAnswerFunc}
+      (async () => {
+        let __last_result__;
+        ${this.instrumentCode(code)}
+        return __last_result__;
+      })()
+    `;
+  }
+  /**
+   * Instrument code to capture the last expression value and convert
+   * let/const/var declarations to global assignments for state persistence.
+   */
+  instrumentCode(code) {
+    const lines = code.trim().split("\n");
+    if (lines.length === 0) {
+      return code;
+    }
+    const processedLines = lines.map((line, index) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.endsWith("*/")) {
+        return line;
+      }
+      let transformed = line;
+      let hasDeclaration = false;
+      transformed = transformed.replace(
+        /\b(let|const|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g,
+        (_match, _keyword, varName) => {
+          hasDeclaration = true;
+          return `${varName} =`;
+        }
+      );
+      transformed = transformed.replace(
+        /\b(let|const|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=[;,]|$)/g,
+        (_match, _keyword, varName) => {
+          hasDeclaration = true;
+          return `${varName} = undefined`;
+        }
+      );
+      if (hasDeclaration) {
+        return transformed;
+      }
+      if (trimmed.startsWith("if") || trimmed.startsWith("else") || trimmed.startsWith("for") || trimmed.startsWith("while") || trimmed.startsWith("do") || trimmed.startsWith("switch") || trimmed.startsWith("case") || trimmed.startsWith("default") || trimmed.startsWith("try") || trimmed.startsWith("catch") || trimmed.startsWith("finally") || trimmed.startsWith("return") || trimmed.startsWith("throw") || trimmed.startsWith("break") || trimmed.startsWith("continue") || trimmed.startsWith("function") || trimmed.startsWith("class") || trimmed.startsWith("import") || trimmed.startsWith("export") || trimmed === "{" || trimmed === "}" || trimmed.endsWith("{") || trimmed.endsWith("}")) {
+        return line;
+      }
+      if (index === lines.length - 1 || this.isLastMeaningfulLine(lines, index)) {
+        if (!trimmed.endsWith(";")) {
+          return `__last_result__ = ${line}`;
+        } else {
+          const withoutSemi = trimmed.slice(0, -1);
+          if (!withoutSemi.endsWith("}") && !withoutSemi.endsWith(")")) {
+            return `__last_result__ = ${withoutSemi};`;
+          }
+        }
+      }
+      return line;
+    });
+    return processedLines.join("\n");
+  }
+  /**
+   * Check if this is the last meaningful line of code.
+   */
+  isLastMeaningfulLine(lines, currentIndex) {
+    for (let i = currentIndex + 1; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Update internal state from context after execution.
+   */
+  updateStateFromContext() {
+    const excludeKeys = /* @__PURE__ */ new Set([
+      "console",
+      "print",
+      "Object",
+      "Array",
+      "String",
+      "Number",
+      "Boolean",
+      "Date",
+      "Math",
+      "JSON",
+      "RegExp",
+      "Error",
+      "Map",
+      "Set",
+      "WeakMap",
+      "WeakSet",
+      "Promise",
+      "Symbol",
+      "Proxy",
+      "Reflect",
+      "parseInt",
+      "parseFloat",
+      "isNaN",
+      "isFinite",
+      "typeof",
+      "setTimeout",
+      "clearTimeout",
+      "setInterval",
+      "clearInterval",
+      "fetch",
+      "importPackage",
+      "URL",
+      "URLSearchParams",
+      "TextEncoder",
+      "TextDecoder",
+      "Buffer",
+      "__state__",
+      "__final_answer__",
+      "__is_final_answer__",
+      "fs",
+      "path",
+      "final_answer",
+      // Exclude tools
+      ...this.tools.keys()
+    ]);
+    for (const key of Object.keys(this.context)) {
+      if (!excludeKeys.has(key)) {
+        this.state[key] = this.context[key];
+      }
+    }
+  }
+  /**
+   * Stringify a value for logging.
+   */
+  stringify(value) {
+    if (value === void 0) return "undefined";
+    if (value === null) return "null";
+    if (typeof value === "string") return value;
+    if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  /**
+   * Reset the executor state.
+   */
+  reset() {
+    this.state = {};
+    this.capturedLogs = [];
+    this.context = this.createContext();
+    const tools = Object.fromEntries(this.tools);
+    this.sendTools(tools);
+  }
+  /**
+   * Get the current state.
+   */
+  getState() {
+    return { ...this.state };
+  }
+};
+
+// src/tools/Tool.ts
+var Tool = class {
+  /**
+   * Whether the tool has been set up
+   */
+  isSetup = false;
+  /**
+   * Optional setup method called before first use.
+   * Override this for expensive initialization (loading models, etc.)
+   */
+  async setup() {
+    this.isSetup = true;
+  }
+  /**
+   * Call the tool, ensuring setup is complete and validating arguments.
+   */
+  async call(args) {
+    if (!this.isSetup) {
+      await this.setup();
+    }
+    this.validateArguments(args);
+    return this.execute(args);
+  }
+  /**
+   * Validate that provided arguments match the input schema.
+   */
+  validateArguments(args) {
+    const providedKeys = new Set(Object.keys(args));
+    for (const [key, input] of Object.entries(this.inputs)) {
+      if (input.required !== false && !providedKeys.has(key)) {
+        throw new Error(`Missing required argument: ${key}`);
+      }
+      if (providedKeys.has(key) && args[key] !== void 0 && args[key] !== null) {
+        const value = args[key];
+        if (!this.checkType(value, input.type)) {
+          throw new Error(
+            `Argument '${key}' has invalid type. Expected ${input.type}, got ${typeof value}`
+          );
+        }
+      }
+      providedKeys.delete(key);
+    }
+    if (providedKeys.size > 0) {
+      console.warn(`Unknown arguments provided to ${this.name}: ${[...providedKeys].join(", ")}`);
+    }
+  }
+  /**
+   * Check if a value matches the expected type.
+   */
+  checkType(value, expectedType) {
+    switch (expectedType) {
+      case "string":
+        return typeof value === "string";
+      case "number":
+        return typeof value === "number";
+      case "boolean":
+        return typeof value === "boolean";
+      case "array":
+        return Array.isArray(value);
+      case "object":
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      case "any":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Generate a code-friendly prompt representation of this tool.
+   * Used in the CodeAgent system prompt.
+   */
+  toCodePrompt() {
+    const argsSignature = Object.entries(this.inputs).map(([name, input]) => {
+      const optional = input.required === false ? "?" : "";
+      return `${name}${optional}: ${this.typeToJsType(input.type)}`;
+    }).join(", ");
+    const argsDoc = Object.entries(this.inputs).map(([name, input]) => `   * @param ${name} - ${input.description}`).join("\n");
+    return `
+/**
+ * ${this.description}
+ *
+${argsDoc}
+ * @returns ${this.outputType}
+ */
+async function ${this.name}(${argsSignature}): Promise<${this.typeToJsType(this.outputType)}> { ... }
+`.trim();
+  }
+  /**
+   * Convert tool input type to JS/TS type string.
+   */
+  typeToJsType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "array":
+        return "any[]";
+      case "object":
+        return "Record<string, any>";
+      case "any":
+        return "any";
+      default:
+        return type;
+    }
+  }
+  /**
+   * Serialize the tool to a JSON-compatible object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputs: this.inputs,
+      outputType: this.outputType
+    };
+  }
+};
+function createTool(config) {
+  return new class extends Tool {
+    name = config.name;
+    description = config.description;
+    inputs = config.inputs;
+    outputType = config.outputType;
+    async execute(args) {
+      return config.execute(args);
+    }
+  }();
+}
+
+// src/tools/defaultTools.ts
+var FinalAnswerTool = class extends Tool {
+  name = "final_answer";
+  description = "Returns the final answer to the user query. Use this when you have completed the task and have the final result.";
+  inputs = {
+    answer: {
+      type: "any",
+      description: "The final answer to return. Can be any type (string, number, object, etc.)",
+      required: true
+    }
+  };
+  outputType = "any";
+  async execute(args) {
+    return args.answer;
+  }
+};
+var UserInputTool = class extends Tool {
+  name = "user_input";
+  description = "Asks the user for additional input or clarification.";
+  inputs = {
+    question: {
+      type: "string",
+      description: "The question to ask the user",
+      required: true
+    }
+  };
+  outputType = "string";
+  inputHandler;
+  constructor(inputHandler) {
+    super();
+    this.inputHandler = inputHandler;
+  }
+  async execute(args) {
+    const question = args.question;
+    if (this.inputHandler) {
+      return this.inputHandler(question);
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve2) => {
+      rl.question(`
+[Agent asks]: ${question}
+Your response: `, (answer) => {
+        rl.close();
+        resolve2(answer);
+      });
+    });
+  }
+};
+var finalAnswerTool = new FinalAnswerTool();
+
+// src/prompts/codeAgent.ts
+function generateSystemPrompt(variables) {
+  const { tools, authorizedImports, customInstructions } = variables;
+  return `You are an expert JavaScript developer and problem-solving agent. Your role is to solve tasks by writing and executing JavaScript code step by step.
+
+## How You Work
+
+You follow a ReAct (Reasoning + Acting) framework:
+1. **Thought**: Analyze the current situation and decide what to do next
+2. **Code**: Write JavaScript code to perform the action
+3. **Observation**: See the result of your code execution
+4. Repeat until you have the final answer
+
+## Available Tools
+
+You have access to the following tools as async functions:
+
+${tools}
+
+## Available Imports
+
+You can dynamically import the following npm packages using \`await importPackage('package-name')\`:
+${authorizedImports || "(No additional packages authorized)"}
+
+## Built-in Capabilities
+
+The following are available in your execution environment:
+- \`console.log()\` / \`print()\` - Output text (captured in logs)
+- \`fs\` - File system operations (readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync)
+- \`path\` - Path utilities (join, resolve, dirname, basename)
+- \`fetch()\` - HTTP requests
+- \`Buffer\` - Binary data handling
+- \`JSON\` - JSON parsing/stringifying
+- Standard JavaScript globals (Math, Date, Array methods, etc.)
+
+## Response Format
+
+Always respond with your thought process followed by a code block:
+
+Thought: [Your reasoning about what to do]
+
+\`\`\`javascript
+// Your code here
+\`\`\`
+
+## Rules
+
+1. **Always use final_answer()**: When you have the complete answer, call \`final_answer(yourResult)\` to return it.
+
+2. **One action per step**: Execute one logical action per code block. Don't try to do everything at once.
+
+3. **Handle errors gracefully**: If something fails, explain what went wrong and try a different approach.
+
+4. **Use async/await**: All tool calls and imports are async. Always use await.
+
+5. **Variables persist**: Variables you define in one step are available in the next step.
+
+6. **Be concise**: Write clean, minimal code. Don't over-engineer.
+
+7. **Print for debugging**: Use console.log() to output intermediate results you want to see.
+
+8. **No require()**: Use \`await importPackage('name')\` for npm packages instead of require().
+
+## Examples
+
+### Example 1: Simple calculation
+Thought: I need to calculate the sum of squares from 1 to 10.
+
+\`\`\`javascript
+let sum = 0;
+for (let i = 1; i <= 10; i++) {
+  sum += i * i;
+}
+console.log("Sum of squares:", sum);
+final_answer(sum);
+\`\`\`
+
+### Example 2: Using a tool
+Thought: I need to search the web for current information.
+
+\`\`\`javascript
+const results = await web_search({ query: "latest JavaScript features 2024" });
+console.log("Search results:", results);
+\`\`\`
+
+### Example 3: Reading a file
+Thought: I need to read the contents of package.json.
+
+\`\`\`javascript
+const content = fs.readFileSync('package.json', 'utf-8');
+const pkg = JSON.parse(content);
+console.log("Package name:", pkg.name);
+final_answer(pkg);
+\`\`\`
+
+### Example 4: Using dynamic imports
+Thought: I need to use lodash for array manipulation.
+
+\`\`\`javascript
+const _ = await importPackage('lodash');
+const numbers = [1, 2, 3, 4, 5];
+const chunked = _.chunk(numbers, 2);
+final_answer(chunked);
+\`\`\`
+
+### Example 5: Multi-step task
+Thought: First, I'll fetch the data from the API.
+
+\`\`\`javascript
+const response = await fetch('https://api.example.com/data');
+const data = await response.json();
+console.log("Fetched items:", data.length);
+\`\`\`
+
+(Observation: Fetched items: 42)
+
+Thought: Now I'll process the data and return the result.
+
+\`\`\`javascript
+const processed = data.filter(item => item.active).map(item => item.name);
+final_answer(processed);
+\`\`\`
+
+${customInstructions ? `
+## Additional Instructions
+
+${customInstructions}` : ""}
+
+Now, let's solve the task step by step. Remember to always call final_answer() when you have the complete answer.`;
+}
+var FINAL_ANSWER_PROMPT = `Based on the steps you've taken so far, provide the best answer you can to the original task.
+If you couldn't fully complete the task, explain what you accomplished and what remains to be done.
+Call final_answer() with your response.`;
+function getErrorRecoveryPrompt(error) {
+  return `Your previous code encountered an error:
+
+${error}
+
+Please analyze the error and try a different approach. Fix the issue and continue working on the task.`;
+}
+
+// src/agents/CodeAgent.ts
+var CODE_BLOCK_REGEX = /```(?:javascript|js)?\n([\s\S]*?)```/;
+var THOUGHT_REGEX = /(?:Thought|Reasoning):\s*([\s\S]*?)(?=```|$)/i;
+var CodeAgent = class extends Agent {
+  /**
+   * The JavaScript code executor
+   */
+  executor;
+  /**
+   * Authorized imports for dynamic npm package loading
+   */
+  authorizedImports;
+  constructor(config) {
+    super(config);
+    this.authorizedImports = config.additionalAuthorizedImports ?? [];
+    this.executor = new LocalExecutor({
+      ...config.executorConfig,
+      authorizedImports: this.authorizedImports,
+      workingDirectory: config.workingDirectory
+    });
+    if (!this.tools.has("final_answer")) {
+      this.tools.set("final_answer", new FinalAnswerTool());
+    }
+    this.executor.sendTools(Object.fromEntries(this.tools));
+  }
+  /**
+   * Initialize the system prompt with tool definitions.
+   */
+  initializeSystemPrompt() {
+    const toolDocs = Array.from(this.tools.values()).filter((tool) => tool.name !== "final_answer").map((tool) => tool.toCodePrompt()).join("\n\n");
+    const finalAnswerDoc = `
+/**
+ * Returns the final answer to the user. Call this when you have completed the task.
+ * @param answer - The final answer (can be any type)
+ */
+function final_answer(answer: any): void { ... }
+`.trim();
+    const allTools = toolDocs ? `${toolDocs}
+
+${finalAnswerDoc}` : finalAnswerDoc;
+    const importsDoc = this.authorizedImports.length > 0 ? this.authorizedImports.map((pkg) => `- ${pkg}`).join("\n") : "None (use built-in capabilities only)";
+    return generateSystemPrompt({
+      tools: allTools,
+      authorizedImports: importsDoc,
+      customInstructions: this.config.customInstructions
+    });
+  }
+  /**
+   * Execute a single step: get LLM response, extract code, execute it.
+   */
+  async executeStep(memoryStep) {
+    const messages = this.memory.toMessages();
+    memoryStep.modelInputMessages = [...messages];
+    const lastStep = this.memory.getActionSteps().slice(-2)[0];
+    if (lastStep?.error) {
+      messages.push({
+        role: "user",
+        content: getErrorRecoveryPrompt(lastStep.error.message)
+      });
+    }
+    const response = await this.generateResponse(messages);
+    memoryStep.modelOutputMessage = response;
+    memoryStep.tokenUsage = response.tokenUsage;
+    const content = response.content ?? "";
+    const thoughtMatch = content.match(THOUGHT_REGEX);
+    if (thoughtMatch) {
+      this.logger.reasoning(thoughtMatch[1].trim());
+    }
+    const codeMatch = content.match(CODE_BLOCK_REGEX);
+    if (!codeMatch) {
+      this.logger.warn("No code block found in response");
+      memoryStep.observation = "No code block was found in your response. Please provide JavaScript code in a ```javascript code block.";
+      return {
+        output: null,
+        isFinalAnswer: false
+      };
+    }
+    const code = codeMatch[1].trim();
+    memoryStep.codeAction = code;
+    this.logger.code(code);
+    if (this.config.codeExecutionDelay > 0) {
+      this.logger.waiting(this.config.codeExecutionDelay / 1e3);
+      await this.sleep(this.config.codeExecutionDelay);
+    }
+    this.logger.subheader("Executing code...");
+    const result = await this.executor.execute(code);
+    if (result.logs) {
+      this.logger.logs(result.logs);
+    }
+    if (result.error) {
+      this.logger.error("Code execution error", result.error);
+      memoryStep.error = result.error;
+      memoryStep.observation = `Error during code execution:
+${result.error.message}`;
+      return {
+        output: null,
+        isFinalAnswer: false
+      };
+    }
+    const outputStr = this.formatOutput(result.output);
+    this.logger.output(outputStr);
+    memoryStep.observation = this.formatObservation(result.logs, outputStr);
+    return {
+      output: result.output,
+      isFinalAnswer: result.isFinalAnswer
+    };
+  }
+  /**
+   * Generate response from the LLM, optionally streaming.
+   */
+  async generateResponse(messages) {
+    if (this.config.streamOutputs && this.model.supportsStreaming() && this.model.generateStream) {
+      this.logger.subheader("Agent thinking...");
+      let fullContent = "";
+      const generator = this.model.generateStream(messages, {
+        stopSequences: ["Observation:", "Observation:\n"]
+      });
+      for await (const chunk of generator) {
+        this.logger.streamChar(chunk);
+        fullContent += chunk;
+      }
+      this.logger.streamEnd();
+      return {
+        role: "assistant",
+        content: fullContent
+      };
+    } else {
+      this.logger.subheader("Agent thinking...");
+      return this.model.generate(messages, {
+        stopSequences: ["Observation:", "Observation:\n"]
+      });
+    }
+  }
+  /**
+   * Format output for display.
+   */
+  formatOutput(output) {
+    if (output === void 0 || output === null) {
+      return "(no output)";
+    }
+    if (typeof output === "string") {
+      return output;
+    }
+    try {
+      return JSON.stringify(output, null, 2);
+    } catch {
+      return String(output);
+    }
+  }
+  /**
+   * Format the observation to send back to the LLM.
+   */
+  formatObservation(logs, output) {
+    const parts = [];
+    if (logs.trim()) {
+      parts.push(`Execution logs:
+${logs}`);
+    }
+    parts.push(`Last output:
+${output}`);
+    return `Observation:
+${parts.join("\n\n")}`;
+  }
+  /**
+   * Reset the agent and executor state.
+   */
+  reset() {
+    this.executor.reset();
+    this.currentStep = 0;
+  }
+  /**
+   * Get the executor instance.
+   */
+  getExecutor() {
+    return this.executor;
+  }
+  /**
+   * Override addTool to also register with executor.
+   */
+  addTool(tool) {
+    super.addTool(tool);
+    this.executor.sendTools({ [tool.name]: tool });
+  }
+};
+
+// src/models/Model.ts
+var Model = class {
+  /**
+   * Check if the model supports streaming.
+   */
+  supportsStreaming() {
+    return typeof this.generateStream === "function";
+  }
+  /**
+   * Extract token usage from a response message.
+   */
+  extractTokenUsage(_response) {
+    return void 0;
+  }
+  /**
+   * Convert messages to the format expected by the model's API.
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      ...msg.name && { name: msg.name },
+      ...msg.toolCallId && { tool_call_id: msg.toolCallId }
+    }));
+  }
+};
+
+// src/models/OpenAIModel.ts
+var import_openai = __toESM(require("openai"));
+var DEFAULT_CONFIG = {
+  modelId: "anthropic/claude-sonnet-4.5",
+  baseUrl: "https://openrouter.ai/api/v1",
+  maxTokens: 4096,
+  temperature: 0.7,
+  timeout: 12e4
+};
+var OpenAIModel = class extends Model {
+  modelId;
+  client;
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.modelId = this.config.modelId ?? DEFAULT_CONFIG.modelId;
+    const apiKey = this.config.apiKey ?? process.env.OPENAI_API_KEY ?? process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "API key is required. Set OPENAI_API_KEY or OPENROUTER_API_KEY environment variable, or pass apiKey in config."
+      );
+    }
+    this.client = new import_openai.default({
+      apiKey,
+      baseURL: this.config.baseUrl,
+      timeout: this.config.timeout,
+      defaultHeaders: this.config.defaultHeaders
+    });
+  }
+  /**
+   * Generate a response from the model.
+   */
+  async generate(messages, options = {}) {
+    const formattedMessages = this.formatMessages(messages);
+    const response = await this.client.chat.completions.create({
+      model: this.modelId,
+      messages: formattedMessages,
+      max_tokens: options.maxTokens ?? this.config.maxTokens,
+      temperature: options.temperature ?? this.config.temperature,
+      ...options.stopSequences && { stop: options.stopSequences }
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    if (!message) {
+      throw new Error("No response from model");
+    }
+    const tokenUsage = response.usage ? {
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens,
+      totalTokens: response.usage.total_tokens
+    } : void 0;
+    return {
+      role: "assistant",
+      content: message.content ?? "",
+      tokenUsage
+    };
+  }
+  /**
+   * Generate a streaming response from the model.
+   */
+  async *generateStream(messages, options = {}) {
+    const formattedMessages = this.formatMessages(messages);
+    const stream = await this.client.chat.completions.create({
+      model: this.modelId,
+      messages: formattedMessages,
+      max_tokens: options.maxTokens ?? this.config.maxTokens,
+      temperature: options.temperature ?? this.config.temperature,
+      ...options.stopSequences && { stop: options.stopSequences },
+      stream: true
+    });
+    let fullContent = "";
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.content) {
+        fullContent += delta.content;
+        yield delta.content;
+      }
+    }
+    return {
+      role: "assistant",
+      content: fullContent
+    };
+  }
+  /**
+   * Format messages for the OpenAI API.
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          role: "user",
+          content: msg.content ?? ""
+        };
+      }
+      return {
+        role: msg.role,
+        content: msg.content ?? ""
+      };
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  AgentLogger,
+  AgentMemory,
+  CodeAgent,
+  FINAL_ANSWER_PROMPT,
+  FinalAnswerTool,
+  LocalExecutor,
+  LogLevel,
+  Model,
+  OpenAIModel,
+  Tool,
+  UserInputTool,
+  createTool,
+  finalAnswerTool,
+  generateSystemPrompt,
+  getErrorRecoveryPrompt
+});
+//# sourceMappingURL=index.js.map