npm - @samrahimi/smol-js - Versions diffs - 0.4.0 → 0.6.0 - Mend

@samrahimi/smol-js 0.4.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,3159 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"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 __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
+));
+// src/cli.ts
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_dotenv = __toESM(require("dotenv"));
+// src/orchestrator/Orchestrator.ts
+var import_chalk2 = __toESM(require("chalk"));
+// src/orchestrator/YAMLLoader.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_yaml = __toESM(require("yaml"));
+// src/memory/AgentMemory.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += estimateTokens(msg.content ?? "");
+    if (msg.toolCalls) {
+      total += estimateTokens(JSON.stringify(msg.toolCalls));
+    }
+    total += 4;
+  }
+  return total;
+}
+var AgentMemory = class {
+  /** System prompt step (always first) */
+  systemPrompt;
+  /** All execution steps */
+  steps = [];
+  maxContextLength;
+  memoryStrategy;
+  model;
+  constructor(systemPrompt, config) {
+    this.systemPrompt = {
+      type: "system",
+      content: systemPrompt,
+      timestamp: Date.now()
+    };
+    this.maxContextLength = config?.maxContextLength ?? 1e5;
+    this.memoryStrategy = config?.memoryStrategy ?? "truncate";
+    this.model = config?.model;
+  }
+  /** 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.
+   * Handles both CodeAgent (observation-based) and ToolUseAgent (tool_call-based) patterns.
+   */
+  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.toolCalls && step.toolCalls.length > 0) {
+            messages.push({
+              role: "assistant",
+              content: step.modelOutputMessage?.content ?? null,
+              toolCalls: step.toolCalls
+            });
+            if (step.toolResults) {
+              for (const result of step.toolResults) {
+                messages.push({
+                  role: "tool",
+                  content: result.error ? `Error: ${result.error}` : typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2),
+                  toolCallId: result.toolCallId
+                });
+              }
+            }
+          } else {
+            if (step.modelOutputMessage) {
+              messages.push({
+                role: "assistant",
+                content: step.modelOutputMessage.content
+              });
+            }
+            if (step.observation) {
+              messages.push({
+                role: "user",
+                content: step.observation
+              });
+            }
+            if (step.error && !step.observation) {
+              messages.push({
+                role: "user",
+                content: `Error: ${step.error.message}`
+              });
+            }
+          }
+          break;
+        case "final":
+          break;
+      }
+    }
+    return messages;
+  }
+  /**
+   * Manage context length - truncate or compact if exceeded.
+   */
+  async manageContext() {
+    const messages = this.toMessages();
+    const tokenCount = estimateMessagesTokens(messages);
+    if (tokenCount <= this.maxContextLength) {
+      return;
+    }
+    if (this.memoryStrategy === "truncate") {
+      this.truncateOlderMessages();
+    } else if (this.memoryStrategy === "compact") {
+      await this.compactMessages();
+    }
+  }
+  /**
+   * Truncate older action steps to fit within context.
+   */
+  truncateOlderMessages() {
+    const actionSteps = this.getActionSteps();
+    if (actionSteps.length <= 2) return;
+    const targetTokens = this.maxContextLength * 0.75;
+    let currentTokens = estimateMessagesTokens(this.toMessages());
+    while (currentTokens > targetTokens && this.steps.length > 2) {
+      const idx = this.steps.findIndex((s) => s.type === "action");
+      if (idx === -1) break;
+      this.steps.splice(idx, 1);
+      currentTokens = estimateMessagesTokens(this.toMessages());
+    }
+  }
+  /**
+   * Compact older messages into a summary.
+   */
+  async compactMessages() {
+    if (!this.model) {
+      this.truncateOlderMessages();
+      return;
+    }
+    const actionSteps = this.getActionSteps();
+    if (actionSteps.length <= 2) return;
+    const stepsToSummarize = actionSteps.slice(0, -2);
+    const summaryContent = stepsToSummarize.map((step) => {
+      const parts = [];
+      if (step.modelOutputMessage?.content) {
+        parts.push(`Action: ${step.modelOutputMessage.content.slice(0, 200)}`);
+      }
+      if (step.observation) {
+        parts.push(`Observation: ${step.observation.slice(0, 200)}`);
+      }
+      if (step.toolResults) {
+        for (const r of step.toolResults) {
+          const resultStr = typeof r.result === "string" ? r.result : JSON.stringify(r.result);
+          parts.push(`Tool ${r.toolName}: ${resultStr.slice(0, 200)}`);
+        }
+      }
+      return parts.join("\n");
+    }).join("\n---\n");
+    try {
+      const summaryResponse = await this.model.generate([
+        {
+          role: "system",
+          content: "Summarize the following agent execution history concisely, preserving key findings and results. Be brief but complete."
+        },
+        {
+          role: "user",
+          content: summaryContent
+        }
+      ]);
+      const recentSteps = this.steps.filter(
+        (s) => s.type === "task" || s.type === "final" || s.type === "action" && actionSteps.indexOf(s) >= actionSteps.length - 2
+      );
+      this.steps = [
+        {
+          type: "task",
+          task: `[Context Summary from previous steps]
+${summaryResponse.content}`,
+          timestamp: Date.now()
+        },
+        ...recentSteps
+      ];
+    } catch {
+      this.truncateOlderMessages();
+    }
+  }
+  /** 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 current estimated token count */
+  getEstimatedTokenCount() {
+    return estimateMessagesTokens(this.toMessages());
+  }
+  /** 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/logs");
+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 DEFAULT_MAX_CONTEXT_LENGTH = 1e5;
+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;
+  /** Whether the agent has been initialized at least once */
+  initialized = 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,
+      persistent: config.persistent ?? false,
+      maxContextLength: config.maxContextLength ?? DEFAULT_MAX_CONTEXT_LENGTH,
+      memoryStrategy: config.memoryStrategy ?? "truncate",
+      maxTokens: config.maxTokens,
+      temperature: config.temperature,
+      name: config.name ?? "Agent",
+      onEvent: config.onEvent
+    };
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+  /**
+   * Run the agent on a task.
+   */
+  async run(task, reset = true) {
+    const startTime = Date.now();
+    const shouldReset = !this.config.persistent ? reset || !this.memory : !this.initialized;
+    if (shouldReset) {
+      const systemPrompt = this.initializeSystemPrompt();
+      this.memory = new AgentMemory(systemPrompt, {
+        maxContextLength: this.config.maxContextLength,
+        memoryStrategy: this.config.memoryStrategy,
+        model: this.model
+      });
+      this.currentStep = 0;
+      this.initialized = true;
+    }
+    this.memory.addTask(task);
+    this.isRunning = true;
+    this.emitEvent("agent_start", { task, name: this.config.name });
+    this.logger.header(`Starting ${this.config.name}: ${task.slice(0, 80)}${task.length > 80 ? "..." : ""}`);
+    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);
+        this.emitEvent("agent_step", { step: this.currentStep, maxSteps: 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);
+          this.emitEvent("agent_error", { error: error.message, step: this.currentStep });
+        }
+        await this.memory.manageContext();
+      }
+      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.emitEvent("agent_end", { output: finalOutput, duration, tokenUsage });
+    this.logger.info(`
+Total time: ${(duration / 1e3).toFixed(2)}s`);
+    this.logger.info(`Total tokens: ${tokenUsage.totalTokens}`);
+    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.`
+    });
+    const response = await this.model.generate(messages, {
+      maxTokens: this.config.maxTokens,
+      temperature: this.config.temperature
+    });
+    return response.content;
+  }
+  /** Emit an orchestration event */
+  emitEvent(type, data) {
+    if (this.config.onEvent) {
+      this.config.onEvent({ type, data });
+    }
+  }
+  /** 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);
+  }
+  /** Get agent name */
+  getName() {
+    return this.config.name;
+  }
+  /** Sleep for a specified duration */
+  sleep(ms) {
+    return new Promise((resolve6) => setTimeout(resolve6, 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);
+    }
+  }
+  /**
+   * 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();
+  }
+  /**
+   * Generate an OpenAI-compatible tool definition for function calling.
+   */
+  toOpenAITool() {
+    const properties = {};
+    const required = [];
+    for (const [key, input] of Object.entries(this.inputs)) {
+      const prop = {
+        type: this.typeToJsonSchemaType(input.type),
+        description: input.description
+      };
+      if (input.enum) {
+        prop.enum = input.enum;
+      }
+      if (input.default !== void 0) {
+        prop.default = input.default;
+      }
+      properties[key] = prop;
+      if (input.required !== false) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "function",
+      function: {
+        name: this.name,
+        description: this.description,
+        parameters: {
+          type: "object",
+          properties,
+          ...required.length > 0 && { required }
+        }
+      }
+    };
+  }
+  /**
+   * Convert tool input type to JSON Schema type.
+   */
+  typeToJsonSchemaType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "array":
+        return "array";
+      case "object":
+        return "object";
+      case "any":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  /**
+   * 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
+    };
+  }
+};
+// 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 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 and one code block per inference step. You will be given additional steps to complete your work if it cannot be done safely in one step. Don't try to do everything at once because you need to make sure that your tools returned valid, useful data before going on to make use of that data. In particular, if you are a Manager agent who is invoking Sub-Agents as tools, do not script the entire workflow in one step, make sure that you get to review the work of your subagents at critical points before going on to the next step.
+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().
+9. **Internet Access**: You can use fetch() to get data from the web as needed. However, if you have access to specialized tools for browsing / searching / retrieving information, use those first and fall back to fetch if they don't work
+## 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.`;
+}
+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"],
+        maxTokens: this.config.maxTokens,
+        temperature: this.config.temperature
+      });
+      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"],
+        maxTokens: this.config.maxTokens,
+        temperature: this.config.temperature
+      });
+    }
+  }
+  /**
+   * 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/prompts/toolUseAgent.ts
+function generateToolUseSystemPrompt(variables) {
+  const { tools, customInstructions, hasSubAgents, hasFileTools } = variables;
+  let contentGuidelines = "";
+  if (hasFileTools) {
+    contentGuidelines += `
+## Content Output Guidelines
+When you produce long-form content (reports, articles, analyses, or any output longer than a few paragraphs):
+1. **Save to file**: Use \`write_file\` to save the full content to a descriptively-named file (e.g., \`research_report.md\`, \`analysis_results.md\`).
+2. **Return summary + filename**: In your \`final_answer\`, provide a brief summary of what you produced AND the filename where the full content is saved. Example: "Completed the research report covering X, Y, Z. Full report saved to: research_report.md"
+This ensures managing agents can access your full output via \`read_file\` without it being truncated in message passing.
+`;
+  }
+  if (hasSubAgents) {
+    contentGuidelines += `
+## Working with Sub-Agents
+When you delegate tasks to sub-agents:
+- Sub-agents return a **summary and filename** rather than the full content of long-form outputs.
+- To access the full content a sub-agent produced, use \`read_file\` with the filename they provide.
+- **Do NOT re-invoke a sub-agent to retrieve content it already created.** Instead, read the file directly.
+- When composing your own final output from sub-agent results, read their files as needed and synthesize.
+`;
+  }
+  if (hasSubAgents && hasFileTools) {
+    contentGuidelines += `
+## When You Are Both a Manager and a Sub-Agent
+If you manage sub-agents AND are yourself delegated tasks by a parent agent:
+- Follow the sub-agent content guidelines: save your own long-form output to a file, return summary + filename.
+- Follow the manager guidelines: read sub-agent output files rather than re-calling them.
+`;
+  }
+  return `You are an expert assistant and problem-solving agent. You solve tasks by reasoning step by step and using the tools available to you.
+## How You Work
+You follow a ReAct (Reasoning + Acting) framework:
+1. **Think**: Analyze the current situation and decide what to do next
+2. **Act**: Call one or more tools to perform actions
+3. **Observe**: Review the results of your tool calls
+4. Repeat until you have the final answer
+## Available Tools
+${tools}
+## Rules
+1. **Always use final_answer**: When you have the complete answer, call the \`final_answer\` tool to return it. This is mandatory - you must always end by calling final_answer.
+2. **Think before acting**: Provide your reasoning in the content of your response before making tool calls. This helps track your thought process.
+3. **One logical action per step**: Focus on one logical action per step. You may call multiple tools in a single step if they are independent, but avoid chaining dependent operations without reviewing intermediate results.
+4. **Handle errors gracefully**: If a tool call fails, analyze the error and try a different approach.
+5. **Be concise**: Keep your reasoning brief and focused. Don't over-explain.
+6. **Use the right tool**: Choose the most appropriate tool for each action. Don't try to accomplish something a tool can do through other means.
+${contentGuidelines}
+${customInstructions ? `## Additional Instructions
+${customInstructions}` : ""}
+Now, let's solve the task step by step. Think carefully about what tools to use and in what order.`;
+}
+function formatToolDescriptions(tools) {
+  return tools.map((tool) => {
+    const params = Object.entries(tool.inputs).map(([name, input]) => {
+      const req = input.required !== false ? " (required)" : " (optional)";
+      return `  - ${name}${req}: ${input.description}`;
+    }).join("\n");
+    return `### ${tool.name}
+${tool.description}
+Parameters:
+${params}`;
+  }).join("\n\n");
+}
+// src/agents/ToolUseAgent.ts
+var ToolUseAgent = class extends Agent {
+  parallelToolCalls;
+  constructor(config) {
+    super(config);
+    this.parallelToolCalls = config.parallelToolCalls ?? true;
+    if (!this.tools.has("final_answer")) {
+      this.tools.set("final_answer", new FinalAnswerTool());
+    }
+  }
+  /**
+   * Initialize the system prompt with tool descriptions.
+   */
+  initializeSystemPrompt() {
+    const toolList = Array.from(this.tools.values());
+    const toolDescriptions = formatToolDescriptions(
+      toolList.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputs: t.inputs
+      }))
+    );
+    const toolNames = new Set(Array.from(this.tools.keys()));
+    const hasSubAgents = toolList.some((t) => t.constructor.name === "AgentTool");
+    const hasFileTools = toolNames.has("read_file") || toolNames.has("write_file") || toolNames.has("read") || toolNames.has("write");
+    return generateToolUseSystemPrompt({
+      tools: toolDescriptions,
+      customInstructions: this.config.customInstructions,
+      hasSubAgents,
+      hasFileTools
+    });
+  }
+  /**
+   * Execute a single step: send messages with tool definitions, process tool calls.
+   */
+  async executeStep(memoryStep) {
+    const messages = this.memory.toMessages();
+    memoryStep.modelInputMessages = [...messages];
+    const actionSteps = this.memory.getActionSteps();
+    const prevStep = actionSteps.length >= 2 ? actionSteps[actionSteps.length - 2] : void 0;
+    if (prevStep?.error) {
+      messages.push({
+        role: "user",
+        content: `Your previous action encountered an error: ${prevStep.error.message}
+Please try a different approach.`
+      });
+    }
+    const toolDefinitions = Array.from(this.tools.values()).map((t) => t.toOpenAITool());
+    this.logger.subheader("Agent thinking...");
+    const response = await this.model.generate(messages, {
+      toolDefinitions,
+      maxTokens: this.config.maxTokens,
+      temperature: this.config.temperature
+    });
+    memoryStep.modelOutputMessage = response;
+    memoryStep.tokenUsage = response.tokenUsage;
+    if (response.content && response.content.trim()) {
+      this.logger.reasoning(response.content.trim());
+    }
+    if (!response.toolCalls || response.toolCalls.length === 0) {
+      this.logger.warn("No tool calls in response. Prompting model to use tools.");
+      memoryStep.observation = "You must use tools to complete the task. Please call the appropriate tool(s). When you have the final answer, call the final_answer tool.";
+      return { output: null, isFinalAnswer: false };
+    }
+    memoryStep.toolCalls = response.toolCalls;
+    const toolResults = await this.processToolCalls(response.toolCalls);
+    memoryStep.toolResults = toolResults;
+    for (const result of toolResults) {
+      if (result.toolName === "final_answer") {
+        return { output: result.result, isFinalAnswer: true };
+      }
+    }
+    for (const result of toolResults) {
+      if (result.error) {
+        this.logger.error(`Tool ${result.toolName} failed: ${result.error}`);
+        this.emitEvent("agent_error", { tool: result.toolName, error: result.error });
+      } else {
+        const resultStr = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
+        this.logger.output(`[${result.toolName}]: ${resultStr.slice(0, 500)}${resultStr.length > 500 ? "..." : ""}`);
+        this.emitEvent("agent_observation", { tool: result.toolName, result: resultStr.slice(0, 500) });
+      }
+    }
+    return { output: null, isFinalAnswer: false };
+  }
+  /**
+   * Process tool calls from the model response.
+   */
+  async processToolCalls(toolCalls) {
+    const results = [];
+    const executeTool = async (tc) => {
+      const toolName = tc.function.name;
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        return {
+          toolCallId: tc.id,
+          toolName,
+          result: null,
+          error: `Unknown tool: ${toolName}. Available tools: ${Array.from(this.tools.keys()).join(", ")}`
+        };
+      }
+      let args;
+      try {
+        args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+      } catch {
+        return {
+          toolCallId: tc.id,
+          toolName,
+          result: null,
+          error: `Failed to parse tool arguments: ${tc.function.arguments}`
+        };
+      }
+      this.logger.info(`  Calling tool: ${toolName}(${JSON.stringify(args).slice(0, 100)}...)`);
+      this.emitEvent("agent_tool_call", { tool: toolName, args });
+      try {
+        const result = await tool.call(args);
+        return {
+          toolCallId: tc.id,
+          toolName,
+          result
+        };
+      } catch (error) {
+        return {
+          toolCallId: tc.id,
+          toolName,
+          result: null,
+          error: `Tool execution error: ${error.message}`
+        };
+      }
+    };
+    if (this.parallelToolCalls) {
+      const promises = toolCalls.map((tc) => executeTool(tc));
+      const resolvedResults = await Promise.all(promises);
+      results.push(...resolvedResults);
+    } else {
+      for (const tc of toolCalls) {
+        results.push(await executeTool(tc));
+      }
+    }
+    return results;
+  }
+  /**
+   * Override provideFinalAnswer to use tool calling format.
+   */
+  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 for the task: "${task}". Call the final_answer tool with your response.`
+    });
+    const toolDefinitions = [new FinalAnswerTool().toOpenAITool()];
+    const response = await this.model.generate(messages, {
+      toolDefinitions,
+      maxTokens: this.config.maxTokens,
+      temperature: this.config.temperature
+    });
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      const tc = response.toolCalls[0];
+      try {
+        const args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+        return args.answer;
+      } catch {
+        return response.content;
+      }
+    }
+    return response.content;
+  }
+  /**
+   * Add a tool, which can also be an Agent instance (auto-wraps with AgentTool).
+   */
+  addTool(tool) {
+    super.addTool(tool);
+  }
+};
+// src/tools/AgentTool.ts
+var AgentTool = class extends Tool {
+  name;
+  description;
+  inputs = {
+    task: {
+      type: "string",
+      description: "The task or question to delegate to this agent",
+      required: true
+    }
+  };
+  outputType = "string";
+  agent;
+  additionalContext;
+  returnFullResult;
+  constructor(config) {
+    super();
+    this.agent = config.agent;
+    this.name = config.name ?? "managed_agent";
+    this.additionalContext = config.additionalContext;
+    this.returnFullResult = config.returnFullResult ?? false;
+    this.description = config.description ?? this.generateDescription();
+  }
+  /**
+   * Generate a default description based on the agent's configuration
+   */
+  generateDescription() {
+    return `Delegates a task to a specialized agent.
+This agent can help with complex sub-tasks that require multiple steps.
+Pass a clear, specific task description and the agent will work autonomously to solve it.
+Returns the agent's final answer as a string.`;
+  }
+  /**
+   * Execute the agent with the given task
+   */
+  async execute(args) {
+    let task = args.task;
+    if (this.additionalContext) {
+      task = `${this.additionalContext}
+Task: ${task}`;
+    }
+    const result = await this.agent.run(task, true);
+    if (this.returnFullResult) {
+      return {
+        output: result.output,
+        steps: result.steps.length,
+        duration: result.duration
+      };
+    }
+    const output = result.output;
+    if (typeof output === "string") {
+      return output;
+    }
+    return JSON.stringify(output, null, 2);
+  }
+  /**
+   * Override toCodePrompt to provide a cleaner signature for nested agents
+   */
+  toCodePrompt() {
+    return `
+/**
+ * ${this.description}
+ *
+ * @param task - The task or question to delegate to this specialized agent
+ * @returns The agent's answer as a string
+ */
+async function ${this.name}(task: string): Promise<string> { ... }
+`.trim();
+  }
+};
+// src/models/OpenAIModel.ts
+var import_openai = __toESM(require("openai"));
+// 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 DEFAULT_MODEL_ID = "anthropic/claude-sonnet-4.5";
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_TIMEOUT = 12e4;
+var OpenAIModel = class extends Model {
+  modelId;
+  client;
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+    this.modelId = config.modelId ?? DEFAULT_MODEL_ID;
+    const apiKey = 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: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      defaultHeaders: config.defaultHeaders
+    });
+  }
+  /**
+   * Generate a response from the model (supports tool calling).
+   */
+  async generate(messages, options = {}) {
+    const formattedMessages = this.formatMessages(messages);
+    const requestParams = {
+      model: this.modelId,
+      messages: formattedMessages
+    };
+    const maxTokens = options.maxTokens ?? this.config.maxTokens;
+    if (maxTokens !== void 0) {
+      requestParams.max_tokens = maxTokens;
+    }
+    const temperature = options.temperature ?? this.config.temperature;
+    if (temperature !== void 0) {
+      requestParams.temperature = temperature;
+    }
+    if (options.stopSequences) {
+      requestParams.stop = options.stopSequences;
+    }
+    if (options.toolDefinitions && options.toolDefinitions.length > 0) {
+      requestParams.tools = options.toolDefinitions;
+    } else if (options.tools && options.tools.length > 0) {
+      requestParams.tools = options.tools.map((t) => t.toOpenAITool());
+    }
+    const response = await this.client.chat.completions.create({
+      ...requestParams,
+      model: this.modelId,
+      messages: formattedMessages
+    });
+    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 ?? 0,
+      totalTokens: response.usage.total_tokens
+    } : void 0;
+    const toolCalls = message.tool_calls?.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.function.name,
+        arguments: tc.function.arguments
+      }
+    }));
+    return {
+      role: "assistant",
+      content: message.content ?? "",
+      toolCalls,
+      tokenUsage
+    };
+  }
+  /**
+   * Generate a streaming response from the model.
+   */
+  async *generateStream(messages, options = {}) {
+    const formattedMessages = this.formatMessages(messages);
+    const requestParams = {
+      model: this.modelId,
+      messages: formattedMessages,
+      stream: true
+    };
+    const maxTokens = options.maxTokens ?? this.config.maxTokens;
+    if (maxTokens !== void 0) {
+      requestParams.max_tokens = maxTokens;
+    }
+    const temperature = options.temperature ?? this.config.temperature;
+    if (temperature !== void 0) {
+      requestParams.temperature = temperature;
+    }
+    if (options.stopSequences) {
+      requestParams.stop = options.stopSequences;
+    }
+    const stream = await this.client.chat.completions.create({
+      ...requestParams,
+      model: this.modelId,
+      messages: formattedMessages,
+      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, including tool call/response messages.
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "tool" && msg.toolCallId) {
+        return {
+          role: "tool",
+          content: msg.content ?? "",
+          tool_call_id: msg.toolCallId
+        };
+      }
+      if (msg.role === "tool") {
+        return {
+          role: "user",
+          content: msg.content ?? ""
+        };
+      }
+      if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+        return {
+          role: "assistant",
+          content: msg.content || null,
+          tool_calls: msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.function.name,
+              arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+            }
+          }))
+        };
+      }
+      return {
+        role: msg.role,
+        content: msg.content ?? ""
+      };
+    });
+  }
+};
+// src/tools/ReadFileTool.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var ReadFileTool = class extends Tool {
+  name = "read_file";
+  description = "Read the contents of a file at the specified path. Returns the file content as a string.";
+  inputs = {
+    path: {
+      type: "string",
+      description: "The file path to read (absolute or relative to working directory)",
+      required: true
+    },
+    encoding: {
+      type: "string",
+      description: "File encoding (default: utf-8)",
+      required: false,
+      default: "utf-8"
+    }
+  };
+  outputType = "string";
+  workingDirectory;
+  constructor(config) {
+    super();
+    this.workingDirectory = config?.workingDirectory ?? process.cwd();
+  }
+  async execute(args) {
+    const filePath = args.path;
+    const encoding = args.encoding ?? "utf-8";
+    const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.resolve(this.workingDirectory, filePath);
+    if (!fs3.existsSync(resolvedPath)) {
+      throw new Error(`File not found: ${resolvedPath}`);
+    }
+    const stat = fs3.statSync(resolvedPath);
+    if (stat.isDirectory()) {
+      throw new Error(`Path is a directory, not a file: ${resolvedPath}`);
+    }
+    const content = fs3.readFileSync(resolvedPath, encoding);
+    const maxLength = 1e5;
+    if (content.length > maxLength) {
+      return content.slice(0, maxLength) + `
+[... truncated, file is ${content.length} characters total]`;
+    }
+    return content;
+  }
+};
+// src/tools/WriteFileTool.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var WriteFileTool = class extends Tool {
+  name = "write_file";
+  description = "Write content to a file at the specified path. Creates the file if it does not exist, and creates parent directories as needed. Overwrites existing content by default.";
+  inputs = {
+    path: {
+      type: "string",
+      description: "The file path to write to (absolute or relative to working directory)",
+      required: true
+    },
+    content: {
+      type: "string",
+      description: "The content to write to the file",
+      required: true
+    },
+    append: {
+      type: "boolean",
+      description: "If true, append to the file instead of overwriting (default: false)",
+      required: false,
+      default: false
+    }
+  };
+  outputType = "string";
+  workingDirectory;
+  constructor(config) {
+    super();
+    this.workingDirectory = config?.workingDirectory ?? process.cwd();
+  }
+  async execute(args) {
+    const filePath = args.path;
+    const content = args.content;
+    const append = args.append ?? false;
+    const resolvedPath = path4.isAbsolute(filePath) ? filePath : path4.resolve(this.workingDirectory, filePath);
+    const dir = path4.dirname(resolvedPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    if (append) {
+      fs4.appendFileSync(resolvedPath, content, "utf-8");
+      return `Successfully appended ${content.length} characters to ${resolvedPath}`;
+    } else {
+      fs4.writeFileSync(resolvedPath, content, "utf-8");
+      return `Successfully wrote ${content.length} characters to ${resolvedPath}`;
+    }
+  }
+};
+// src/tools/CurlTool.ts
+var CurlTool = class extends Tool {
+  name = "curl";
+  description = "Make HTTP requests to any URL. Supports GET and POST methods with custom headers and body. Returns the response body as text.";
+  inputs = {
+    url: {
+      type: "string",
+      description: "The URL to request",
+      required: true
+    },
+    method: {
+      type: "string",
+      description: "HTTP method: GET or POST (default: GET)",
+      required: false,
+      default: "GET",
+      enum: ["GET", "POST"]
+    },
+    headers: {
+      type: "object",
+      description: 'Optional HTTP headers as key-value pairs (e.g., {"Content-Type": "application/json"})',
+      required: false
+    },
+    body: {
+      type: "string",
+      description: "Request body for POST requests (typically JSON string)",
+      required: false
+    }
+  };
+  outputType = "string";
+  timeout;
+  constructor(config) {
+    super();
+    this.timeout = config?.timeout ?? 3e4;
+  }
+  async execute(args) {
+    const url = args.url;
+    const method = (args.method ?? "GET").toUpperCase();
+    const headers = args.headers ?? {};
+    const body = args.body;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const fetchOptions = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (method === "POST" && body) {
+        fetchOptions.body = body;
+        if (!headers["Content-Type"] && !headers["content-type"]) {
+          fetchOptions.headers["Content-Type"] = "application/json";
+        }
+      }
+      const response = await fetch(url, fetchOptions);
+      const responseText = await response.text();
+      const statusLine = `HTTP ${response.status} ${response.statusText}`;
+      const maxLength = 5e4;
+      const truncatedBody = responseText.length > maxLength ? responseText.slice(0, maxLength) + `
+[... truncated, response is ${responseText.length} characters total]` : responseText;
+      return `${statusLine}
+${truncatedBody}`;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timed out after ${this.timeout}ms: ${url}`);
+      }
+      throw new Error(`HTTP request failed: ${error.message}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+// src/tools/ExaSearchTool.ts
+var ExaSearchTool = class extends Tool {
+  name = "exa_search";
+  description = "Search the web using Exa.ai semantic search. Returns relevant web pages with titles, URLs, and optionally content snippets. Use this for finding information, research, and fact-checking.";
+  inputs = {
+    query: {
+      type: "string",
+      description: "The search query. Be specific and descriptive for best results.",
+      required: true
+    },
+    numResults: {
+      type: "number",
+      description: "Number of results to return (default: 10, max: 30)",
+      required: false,
+      default: 10
+    },
+    type: {
+      type: "string",
+      description: 'Search type: "auto" (default), "neural" (embeddings-based), or "keyword"',
+      required: false,
+      default: "auto",
+      enum: ["auto", "neural", "keyword"]
+    },
+    category: {
+      type: "string",
+      description: 'Optional category filter: "research paper", "news", "pdf", "github", "tweet", "company", "blog"',
+      required: false
+    },
+    includeDomains: {
+      type: "array",
+      description: 'Only include results from these domains (e.g., ["arxiv.org", "github.com"])',
+      required: false
+    },
+    excludeDomains: {
+      type: "array",
+      description: "Exclude results from these domains",
+      required: false
+    },
+    startPublishedDate: {
+      type: "string",
+      description: 'Filter results published after this ISO 8601 date (e.g., "2024-01-01")',
+      required: false
+    }
+  };
+  outputType = "string";
+  apiKey;
+  constructor(config) {
+    super();
+    this.apiKey = config?.apiKey ?? process.env.EXA_API_KEY ?? "";
+  }
+  async setup() {
+    if (!this.apiKey) {
+      throw new Error("EXA_API_KEY is required. Set it as an environment variable or pass it in the config.");
+    }
+    this.isSetup = true;
+  }
+  async execute(args) {
+    const query = args.query;
+    const numResults = Math.min(args.numResults ?? 10, 30);
+    const type = args.type ?? "auto";
+    const requestBody = {
+      query,
+      numResults,
+      type,
+      text: { maxCharacters: 1e3 }
+    };
+    if (args.category) requestBody.category = args.category;
+    if (args.includeDomains) requestBody.includeDomains = args.includeDomains;
+    if (args.excludeDomains) requestBody.excludeDomains = args.excludeDomains;
+    if (args.startPublishedDate) requestBody.startPublishedDate = args.startPublishedDate;
+    const response = await fetch("https://api.exa.ai/search", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Exa search failed (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.results || data.results.length === 0) {
+      return "No results found for the query.";
+    }
+    const formattedResults = data.results.map((result, i) => {
+      const parts = [`[${i + 1}] ${result.title ?? "Untitled"}`];
+      parts.push(`    URL: ${result.url}`);
+      if (result.publishedDate) parts.push(`    Date: ${result.publishedDate}`);
+      if (result.author) parts.push(`    Author: ${result.author}`);
+      if (result.text) {
+        const snippet = result.text.slice(0, 300).trim();
+        parts.push(`    Snippet: ${snippet}${result.text.length > 300 ? "..." : ""}`);
+      }
+      return parts.join("\n");
+    }).join("\n\n");
+    return `Search results for "${query}" (${data.results.length} results):
+${formattedResults}`;
+  }
+};
+// src/tools/ExaGetContentsTool.ts
+var ExaGetContentsTool = class extends Tool {
+  name = "exa_get_contents";
+  description = "Get the full text content of one or more web pages using Exa.ai. Returns cleaned, readable text extracted from the HTML. Use this to read articles, documentation, or any web page content.";
+  inputs = {
+    urls: {
+      type: "array",
+      description: "Array of URLs to fetch content from (max 10)",
+      required: true
+    },
+    maxCharacters: {
+      type: "number",
+      description: "Maximum characters of content to return per page (default: 10000)",
+      required: false,
+      default: 1e4
+    },
+    livecrawl: {
+      type: "string",
+      description: 'Crawl strategy: "fallback" (use cache, fetch live if unavailable), "always" (always fetch live), "never" (cache only). Default: "fallback"',
+      required: false,
+      default: "fallback",
+      enum: ["fallback", "always", "never"]
+    }
+  };
+  outputType = "string";
+  apiKey;
+  constructor(config) {
+    super();
+    this.apiKey = config?.apiKey ?? process.env.EXA_API_KEY ?? "";
+  }
+  async setup() {
+    if (!this.apiKey) {
+      throw new Error("EXA_API_KEY is required. Set it as an environment variable or pass it in the config.");
+    }
+    this.isSetup = true;
+  }
+  async execute(args) {
+    const urls = args.urls.slice(0, 10);
+    const maxCharacters = args.maxCharacters ?? 1e4;
+    const livecrawl = args.livecrawl ?? "fallback";
+    const requestBody = {
+      urls,
+      text: { maxCharacters },
+      livecrawl
+    };
+    const response = await fetch("https://api.exa.ai/contents", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Exa get contents failed (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.results || data.results.length === 0) {
+      return "No content could be retrieved from the provided URLs.";
+    }
+    const formattedResults = data.results.map((result) => {
+      const parts = [`## ${result.title ?? result.url}`];
+      parts.push(`URL: ${result.url}`);
+      if (result.author) parts.push(`Author: ${result.author}`);
+      if (result.publishedDate) parts.push(`Date: ${result.publishedDate}`);
+      parts.push("");
+      if (result.text) {
+        parts.push(result.text);
+      } else {
+        parts.push("[No text content available]");
+      }
+      return parts.join("\n");
+    }).join("\n\n---\n\n");
+    return formattedResults;
+  }
+};
+// src/tools/ExaResearchTool.ts
+var ExaResearchTool = class extends Tool {
+  name = "exa_research";
+  description = "Perform deep research on a single topic using Exa.ai. Searches for relevant sources, retrieves their content, and finds similar pages for comprehensive coverage. Returns a structured research summary with sources. Use this for thorough research on any topic.";
+  inputs = {
+    topic: {
+      type: "string",
+      description: "The research topic or question to investigate",
+      required: true
+    },
+    numSources: {
+      type: "number",
+      description: "Number of primary sources to retrieve (default: 5, max: 10)",
+      required: false,
+      default: 5
+    },
+    category: {
+      type: "string",
+      description: 'Optional category: "research paper", "news", "blog", "company"',
+      required: false
+    },
+    includeDomains: {
+      type: "array",
+      description: "Only include results from these domains",
+      required: false
+    },
+    startPublishedDate: {
+      type: "string",
+      description: "Only include results published after this date (ISO 8601)",
+      required: false
+    }
+  };
+  outputType = "string";
+  apiKey;
+  constructor(config) {
+    super();
+    this.apiKey = config?.apiKey ?? process.env.EXA_API_KEY ?? "";
+  }
+  async setup() {
+    if (!this.apiKey) {
+      throw new Error("EXA_API_KEY is required. Set it as an environment variable or pass it in the config.");
+    }
+    this.isSetup = true;
+  }
+  async execute(args) {
+    const topic = args.topic;
+    const numSources = Math.min(args.numSources ?? 5, 10);
+    const searchBody = {
+      query: topic,
+      numResults: numSources,
+      type: "auto",
+      text: { maxCharacters: 3e3 }
+    };
+    if (args.category) searchBody.category = args.category;
+    if (args.includeDomains) searchBody.includeDomains = args.includeDomains;
+    if (args.startPublishedDate) searchBody.startPublishedDate = args.startPublishedDate;
+    const searchResponse = await fetch("https://api.exa.ai/search", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(searchBody)
+    });
+    if (!searchResponse.ok) {
+      const errorText = await searchResponse.text();
+      throw new Error(`Exa research search failed (${searchResponse.status}): ${errorText}`);
+    }
+    const searchData = await searchResponse.json();
+    if (!searchData.results || searchData.results.length === 0) {
+      return `No research sources found for topic: "${topic}"`;
+    }
+    let similarResults = [];
+    if (searchData.results.length > 0) {
+      try {
+        const similarBody = {
+          url: searchData.results[0].url,
+          numResults: 3,
+          text: { maxCharacters: 2e3 }
+        };
+        const similarResponse = await fetch("https://api.exa.ai/findSimilar", {
+          method: "POST",
+          headers: {
+            "x-api-key": this.apiKey,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(similarBody)
+        });
+        if (similarResponse.ok) {
+          const similarData = await similarResponse.json();
+          similarResults = similarData.results ?? [];
+        }
+      } catch {
+      }
+    }
+    const allSources = [...searchData.results, ...similarResults];
+    const seenUrls = /* @__PURE__ */ new Set();
+    const uniqueSources = allSources.filter((s) => {
+      if (seenUrls.has(s.url)) return false;
+      seenUrls.add(s.url);
+      return true;
+    });
+    const sections = [];
+    sections.push(`# Research: ${topic}
+`);
+    sections.push(`Found ${uniqueSources.length} sources.
+`);
+    sections.push("## Key Sources\n");
+    for (let i = 0; i < uniqueSources.length; i++) {
+      const source = uniqueSources[i];
+      sections.push(`### ${i + 1}. ${source.title ?? "Untitled"}`);
+      sections.push(`URL: ${source.url}`);
+      if ("publishedDate" in source && source.publishedDate) {
+        sections.push(`Date: ${source.publishedDate}`);
+      }
+      if ("author" in source && source.author) {
+        sections.push(`Author: ${source.author}`);
+      }
+      if (source.text) {
+        sections.push(`
+Content:
+${source.text.slice(0, 2e3)}`);
+      }
+      sections.push("");
+    }
+    sections.push("## Source URLs\n");
+    uniqueSources.forEach((s, i) => {
+      sections.push(`${i + 1}. ${s.url}`);
+    });
+    return sections.join("\n");
+  }
+};
+// src/orchestrator/YAMLLoader.ts
+var TOOL_REGISTRY = {
+  read_file: ReadFileTool,
+  write_file: WriteFileTool,
+  curl: CurlTool,
+  exa_search: ExaSearchTool,
+  exa_get_contents: ExaGetContentsTool,
+  exa_research: ExaResearchTool,
+  final_answer: FinalAnswerTool
+};
+var YAMLLoader = class {
+  customTools = /* @__PURE__ */ new Map();
+  /**
+   * Register a custom tool type for use in YAML definitions.
+   */
+  registerToolType(typeName, toolClass) {
+    this.customTools.set(typeName, toolClass);
+  }
+  /**
+   * Load a workflow from a YAML file path.
+   */
+  loadFromFile(filePath) {
+    const absolutePath = path5.isAbsolute(filePath) ? filePath : path5.resolve(process.cwd(), filePath);
+    if (!fs5.existsSync(absolutePath)) {
+      throw new Error(`Workflow file not found: ${absolutePath}`);
+    }
+    const content = fs5.readFileSync(absolutePath, "utf-8");
+    return this.loadFromString(content);
+  }
+  /**
+   * Load a workflow from a YAML string.
+   */
+  loadFromString(yamlContent) {
+    const definition = import_yaml.default.parse(yamlContent);
+    return this.buildWorkflow(definition);
+  }
+  /**
+   * Build a runnable workflow from a parsed definition.
+   */
+  buildWorkflow(definition) {
+    if (!definition.name) {
+      throw new Error("Workflow must have a name");
+    }
+    if (!definition.entrypoint) {
+      throw new Error("Workflow must have an entrypoint agent");
+    }
+    if (!definition.agents) {
+      throw new Error("Workflow must define at least one agent");
+    }
+    const tools = /* @__PURE__ */ new Map();
+    if (definition.tools) {
+      for (const [name, toolDef] of Object.entries(definition.tools)) {
+        const tool = this.buildTool(name, toolDef.type, toolDef.config);
+        tools.set(name, tool);
+      }
+    }
+    const agents = /* @__PURE__ */ new Map();
+    const agentDefs = definition.agents;
+    const resolved = /* @__PURE__ */ new Set();
+    const maxIterations = Object.keys(agentDefs).length * 2;
+    let iterations = 0;
+    while (resolved.size < Object.keys(agentDefs).length && iterations < maxIterations) {
+      iterations++;
+      for (const [agentName, agentDef] of Object.entries(agentDefs)) {
+        if (resolved.has(agentName)) continue;
+        const agentDeps = agentDef.agents ?? [];
+        const allDepsResolved = agentDeps.every((dep) => resolved.has(dep));
+        if (allDepsResolved) {
+          const agent = this.buildAgent(
+            agentName,
+            agentDef,
+            definition.model,
+            tools,
+            agents,
+            definition.globalMaxContextLength
+          );
+          agents.set(agentName, agent);
+          resolved.add(agentName);
+        }
+      }
+    }
+    if (resolved.size < Object.keys(agentDefs).length) {
+      const unresolved = Object.keys(agentDefs).filter((n) => !resolved.has(n));
+      throw new Error(`Circular or unresolvable agent dependencies: ${unresolved.join(", ")}`);
+    }
+    const entrypointAgent = agents.get(definition.entrypoint);
+    if (!entrypointAgent) {
+      throw new Error(`Entrypoint agent "${definition.entrypoint}" not found in agents`);
+    }
+    return {
+      name: definition.name,
+      description: definition.description,
+      entrypointAgent,
+      agents,
+      tools
+    };
+  }
+  /**
+   * Build a tool instance from a type name and config.
+   */
+  buildTool(name, type, config) {
+    const ToolClass = TOOL_REGISTRY[type] ?? this.customTools.get(type);
+    if (!ToolClass) {
+      throw new Error(`Unknown tool type: ${type}. Available types: ${[...Object.keys(TOOL_REGISTRY), ...this.customTools.keys()].join(", ")}`);
+    }
+    const tool = new ToolClass(config);
+    if (name !== type && name !== tool.name) {
+      Object.defineProperty(tool, "name", { value: name, writable: false });
+    }
+    return tool;
+  }
+  /**
+   * Build an agent instance from a YAML definition.
+   */
+  buildAgent(name, definition, globalModel, availableTools, resolvedAgents, globalMaxContextLength) {
+    const modelConfig = definition.model ?? globalModel;
+    const model = new OpenAIModel({
+      modelId: modelConfig?.modelId,
+      apiKey: modelConfig?.apiKey,
+      baseUrl: modelConfig?.baseUrl,
+      maxTokens: definition.maxTokens ?? modelConfig?.maxTokens,
+      temperature: definition.temperature ?? modelConfig?.temperature,
+      timeout: modelConfig?.timeout
+    });
+    const agentTools = [];
+    if (definition.tools && availableTools) {
+      for (const toolName of definition.tools) {
+        const tool = availableTools.get(toolName);
+        if (tool) {
+          agentTools.push(tool);
+        } else {
+          const ToolClass = TOOL_REGISTRY[toolName] ?? this.customTools.get(toolName);
+          if (ToolClass) {
+            agentTools.push(new ToolClass());
+          } else {
+            throw new Error(`Tool "${toolName}" not found for agent "${name}"`);
+          }
+        }
+      }
+    }
+    if (definition.agents && resolvedAgents) {
+      for (const subAgentName of definition.agents) {
+        const subAgent = resolvedAgents.get(subAgentName);
+        if (!subAgent) {
+          throw new Error(`Sub-agent "${subAgentName}" not found for agent "${name}"`);
+        }
+        agentTools.push(new AgentTool({
+          agent: subAgent,
+          name: subAgentName,
+          description: definition.description ? `Sub-agent: ${subAgentName}` : `Delegate tasks to the ${subAgentName} agent`
+        }));
+      }
+    }
+    const maxContextLength = definition.maxContextLength ?? globalMaxContextLength;
+    if (definition.type === "CodeAgent") {
+      return new CodeAgent({
+        model,
+        tools: agentTools,
+        maxSteps: definition.maxSteps,
+        customInstructions: definition.customInstructions,
+        persistent: definition.persistent,
+        maxContextLength,
+        memoryStrategy: definition.memoryStrategy,
+        maxTokens: definition.maxTokens,
+        temperature: definition.temperature,
+        name
+      });
+    } else {
+      return new ToolUseAgent({
+        model,
+        tools: agentTools,
+        maxSteps: definition.maxSteps,
+        customInstructions: definition.customInstructions,
+        persistent: definition.persistent,
+        maxContextLength,
+        memoryStrategy: definition.memoryStrategy,
+        maxTokens: definition.maxTokens,
+        temperature: definition.temperature,
+        name
+      });
+    }
+  }
+};
+// src/orchestrator/Orchestrator.ts
+var Orchestrator = class {
+  loader;
+  config;
+  activeAgents = /* @__PURE__ */ new Map();
+  eventLog = [];
+  constructor(config = {}) {
+    this.loader = new YAMLLoader();
+    this.config = {
+      verbose: config.verbose ?? true,
+      onEvent: config.onEvent
+    };
+  }
+  /**
+   * Load a workflow from a YAML file.
+   */
+  loadWorkflow(filePath) {
+    const workflow = this.loader.loadFromFile(filePath);
+    this.displayWorkflowInfo(workflow);
+    return workflow;
+  }
+  /**
+   * Load a workflow from YAML string.
+   */
+  loadWorkflowFromString(yamlContent) {
+    const workflow = this.loader.loadFromString(yamlContent);
+    this.displayWorkflowInfo(workflow);
+    return workflow;
+  }
+  /**
+   * Run a loaded workflow with a task.
+   */
+  async runWorkflow(workflow, task) {
+    this.displayRunStart(workflow.name, task);
+    this.instrumentAgent(workflow.entrypointAgent, workflow.entrypointAgent.getName(), 0);
+    for (const [name, agent] of workflow.agents) {
+      if (agent !== workflow.entrypointAgent) {
+        this.instrumentAgent(agent, name, 1);
+      }
+    }
+    try {
+      const result = await workflow.entrypointAgent.run(task);
+      this.displayRunEnd(result);
+      return result;
+    } catch (error) {
+      this.displayError(error);
+      throw error;
+    }
+  }
+  /**
+   * Run a standalone agent with a task.
+   */
+  async runAgent(agent, task) {
+    this.instrumentAgent(agent, agent.getName(), 0);
+    const result = await agent.run(task);
+    return result;
+  }
+  /**
+   * Instrument an agent with orchestrator event tracking.
+   */
+  instrumentAgent(agent, name, depth) {
+    this.activeAgents.set(name, { agent, depth });
+  }
+  /**
+   * Display workflow info at startup.
+   */
+  displayWorkflowInfo(workflow) {
+    if (!this.config.verbose) return;
+    const line = "\u2550".repeat(70);
+    console.log(import_chalk2.default.cyan(line));
+    console.log(import_chalk2.default.cyan.bold(`  Workflow: ${workflow.name}`));
+    if (workflow.description) {
+      console.log(import_chalk2.default.cyan(`  ${workflow.description}`));
+    }
+    console.log(import_chalk2.default.cyan(`  Agents: ${Array.from(workflow.agents.keys()).join(", ")}`));
+    console.log(import_chalk2.default.cyan(`  Tools: ${Array.from(workflow.tools.keys()).join(", ") || "(none defined at workflow level)"}`));
+    console.log(import_chalk2.default.cyan(`  Entrypoint: ${workflow.entrypointAgent.getName()}`));
+    console.log(import_chalk2.default.cyan(line));
+    console.log();
+  }
+  /**
+   * Display run start info.
+   */
+  displayRunStart(workflowName, task) {
+    if (!this.config.verbose) return;
+    console.log(import_chalk2.default.green.bold(`
+\u25B6 Running workflow "${workflowName}"`));
+    console.log(import_chalk2.default.green(`  Task: ${task}`));
+    console.log(import_chalk2.default.gray("\u2500".repeat(70)));
+  }
+  /**
+   * Display run completion info.
+   */
+  displayRunEnd(result) {
+    if (!this.config.verbose) return;
+    console.log(import_chalk2.default.gray("\n" + "\u2500".repeat(70)));
+    console.log(import_chalk2.default.green.bold(`
+\u2705 Workflow complete`));
+    console.log(import_chalk2.default.green(`  Duration: ${(result.duration / 1e3).toFixed(2)}s`));
+    console.log(import_chalk2.default.green(`  Tokens: ${result.tokenUsage.totalTokens}`));
+    console.log(import_chalk2.default.green(`  Steps: ${result.steps.length}`));
+    const outputStr = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
+    console.log(import_chalk2.default.magenta.bold("\n  Final Output:"));
+    const indentedOutput = outputStr.split("\n").map((line) => `  ${line}`).join("\n");
+    console.log(import_chalk2.default.magenta(indentedOutput));
+    console.log();
+  }
+  /**
+   * Display an error.
+   */
+  displayError(error) {
+    if (!this.config.verbose) return;
+    console.error(import_chalk2.default.red.bold(`
+\u274C Workflow failed: ${error.message}`));
+    if (error.stack) {
+      console.error(import_chalk2.default.red.dim(error.stack));
+    }
+  }
+  /**
+   * Log an orchestration event.
+   */
+  logEvent(event) {
+    this.eventLog.push(event);
+    if (this.config.onEvent) {
+      this.config.onEvent(event);
+    }
+  }
+  /**
+   * Get the event log.
+   */
+  getEventLog() {
+    return [...this.eventLog];
+  }
+  /**
+   * Get the YAML loader for registering custom tools.
+   */
+  getLoader() {
+    return this.loader;
+  }
+};
+// src/cli.ts
+import_dotenv.default.config();
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printUsage();
+    process.exit(0);
+  }
+  const command = args[0];
+  if (command === "run") {
+    await runCommand(args.slice(1));
+  } else if (command === "validate") {
+    await validateCommand(args.slice(1));
+  } else {
+    console.error(import_chalk3.default.red(`Unknown command: ${command}`));
+    printUsage();
+    process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(import_chalk3.default.cyan.bold("\nsmol-js CLI - YAML Agent Orchestrator\n"));
+  console.log("Usage:");
+  console.log("  smol-js run <workflow.yaml> [options]     Run a workflow");
+  console.log("  smol-js validate <workflow.yaml>          Validate a workflow file");
+  console.log("");
+  console.log("Options:");
+  console.log("  --task, -t <task>    Task description (prompted if not provided)");
+  console.log("  --quiet, -q          Reduce output verbosity");
+  console.log("  --help, -h           Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log('  smol-js run workflow.yaml --task "Research AI safety"');
+  console.log('  smol-js run research-agent.yaml -t "Write a summary of quantum computing"');
+  console.log("  smol-js validate my-workflow.yaml");
+}
+async function runCommand(args) {
+  if (args.length === 0) {
+    console.error(import_chalk3.default.red("Error: workflow file path required"));
+    process.exit(1);
+  }
+  const filePath = args[0];
+  let task = "";
+  let quiet = false;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--task" || args[i] === "-t") {
+      task = args[i + 1] ?? "";
+      i++;
+    } else if (args[i] === "--quiet" || args[i] === "-q") {
+      quiet = true;
+    }
+  }
+  const resolvedPath = path6.isAbsolute(filePath) ? filePath : path6.resolve(process.cwd(), filePath);
+  if (!fs6.existsSync(resolvedPath)) {
+    console.error(import_chalk3.default.red(`Error: file not found: ${resolvedPath}`));
+    process.exit(1);
+  }
+  if (!task) {
+    task = await promptUser("Enter your task: ");
+    if (!task.trim()) {
+      console.error(import_chalk3.default.red("Error: task cannot be empty"));
+      process.exit(1);
+    }
+  }
+  const orchestrator = new Orchestrator({ verbose: !quiet });
+  try {
+    console.log(import_chalk3.default.gray(`
+Loading workflow from: ${resolvedPath}
+`));
+    const workflow = orchestrator.loadWorkflow(resolvedPath);
+    await orchestrator.runWorkflow(workflow, task);
+    process.exit(0);
+  } catch (error) {
+    console.error(import_chalk3.default.red(`
+Error: ${error.message}`));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+async function validateCommand(args) {
+  if (args.length === 0) {
+    console.error(import_chalk3.default.red("Error: workflow file path required"));
+    process.exit(1);
+  }
+  const filePath = args[0];
+  const resolvedPath = path6.isAbsolute(filePath) ? filePath : path6.resolve(process.cwd(), filePath);
+  if (!fs6.existsSync(resolvedPath)) {
+    console.error(import_chalk3.default.red(`Error: file not found: ${resolvedPath}`));
+    process.exit(1);
+  }
+  const orchestrator = new Orchestrator({ verbose: false });
+  try {
+    const workflow = orchestrator.loadWorkflow(resolvedPath);
+    console.log(import_chalk3.default.green.bold("\u2705 Workflow is valid"));
+    console.log(import_chalk3.default.green(`  Name: ${workflow.name}`));
+    console.log(import_chalk3.default.green(`  Agents: ${Array.from(workflow.agents.keys()).join(", ")}`));
+    console.log(import_chalk3.default.green(`  Tools: ${Array.from(workflow.tools.keys()).join(", ") || "(using defaults)"}`));
+    console.log(import_chalk3.default.green(`  Entrypoint: ${workflow.entrypointAgent.getName()}`));
+    process.exit(0);
+  } catch (error) {
+    console.error(import_chalk3.default.red(`\u274C Validation failed: ${error.message}`));
+    process.exit(1);
+  }
+}
+function promptUser(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve6) => {
+    rl.question(import_chalk3.default.cyan(question), (answer) => {
+      rl.close();
+      resolve6(answer);
+    });
+  });
+}
+main().catch((error) => {
+  console.error(import_chalk3.default.red(`Fatal error: ${error.message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map