@samrahimi/smol-js 0.7.0 → 0.7.2

package/dist/index.mjs

@@ -724,7 +724,7 @@ Total time: ${(duration / 1e3).toFixed(2)}s`);
   }
   /** Sleep for a specified duration */
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve7) => setTimeout(resolve7, ms));
   }
 };
 
@@ -1393,12 +1393,12 @@ var UserInputTool = class extends Tool {
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       rl.question(`
 [Agent asks]: ${question}
 Your response: `, (answer) => {
         rl.close();
-        resolve6(answer);
+        resolve7(answer);
       });
     });
   }
@@ -2040,6 +2040,369 @@ Please try a different approach.`
   }
 };
 
+// src/agents/TerminalAgent.ts
+import { execSync } from "child_process";
+
+// src/prompts/terminalAgent.ts
+function generateTerminalAgentSystemPrompt(variables) {
+  const { customInstructions, hasSubAgents, subAgentDescriptions } = variables;
+  let delegationSection = "";
+  if (hasSubAgents) {
+    delegationSection = `
+## Delegation to Sub-Agents
+
+You can delegate tasks to specialized sub-agents when terminal commands alone
+are not sufficient. Available sub-agents:
+
+${subAgentDescriptions}
+
+To delegate, call the sub-agent tool with a clear task description. Wait for
+its result before continuing. Sub-agents handle their own tool calls internally.
+`;
+  }
+  return `You are a terminal operations agent running on macOS. You accomplish tasks
+by reasoning about what shell commands to run and executing them one or more at
+a time.
+
+## How You Work
+
+You follow a ReAct (Reasoning + Acting) loop:
+1. **Think**: Analyze the task and decide what commands to run next.
+2. **Act**: Emit one or more shell commands inside a fenced code block.
+3. **Observe**: Review the command output (stdout, stderr, exit code) that the
+   framework feeds back to you.
+4. Repeat until the task is complete, then signal your final answer (see below).
+
+## Emitting Commands
+
+Place your shell commands inside a fenced sh code block. You may include
+multiple commands separated by newlines. Each command is executed
+sequentially in its own shell invocation on the user's macOS terminal:
+
+\`\`\`sh
+echo "hello"
+\`\`\`
+
+\`\`\`sh
+ls -la ~/Documents
+pwd
+\`\`\`
+
+**Important**: Each code block is treated as a batch. Commands within a single
+block run sequentially. The output of the entire block is returned as one
+observation. If you need to inspect intermediate output before proceeding,
+use separate blocks across steps.
+
+## Rules
+
+1. **Safety first**: Before running anything destructive (rm, mv on important
+   files, format commands, etc.), explain what you are about to do in your
+   reasoning so the user can read it during the 5-second delay and abort with
+   Ctrl+C if needed.
+
+2. **Signalling completion**: When the task is done, do NOT emit any more
+   \`\`\`sh blocks. Instead, write your summary on a line that starts with
+   the exact marker:
+
+   FINAL_ANSWER: <your summary here>
+
+   Everything after "FINAL_ANSWER: " (including multiple lines) is captured
+   as your final answer. This is how you tell the framework you are finished.
+
+3. **Handle errors**: If a command fails (non-zero exit code or stderr output),
+   analyze what went wrong and try a corrective approach. Do not repeat the
+   exact same command.
+
+4. **Be explicit about paths**: Use absolute paths or \`cd\` explicitly. Do not
+   assume the working directory persists between steps (it does not).
+
+5. **macOS conventions**: Use macOS / BSD variants of commands (e.g. \`gstat\`
+   may not exist; use \`stat\` with the right flags). Prefer Homebrew paths
+   (\`/opt/homebrew/bin\`) for installed tools. Use \`sw_vers\` for OS info.
+
+6. **Prefer streaming-friendly commands**: Avoid commands that buffer all output
+   until completion. Prefer tools that print as they go.
+
+7. **No interactive prompts**: Do not run commands that wait for user input
+   (e.g. \`ssh\` without key auth, interactive installers). If a command would
+   prompt, pass flags to make it non-interactive or use \`yes |\` piping.
+${delegationSection}
+${customInstructions ? `## Additional Instructions
+
+${customInstructions}` : ""}
+
+Begin. Think about the task, then emit your first shell command(s).`;
+}
+
+// src/agents/TerminalAgent.ts
+var SH_BLOCK_REGEX = /```(?:sh|bash|shell|zsh)\n([\s\S]*?)```/g;
+var THOUGHT_REGEX2 = /(?:Thought|Reasoning|Think):\s*([\s\S]*?)(?=```|FINAL_ANSWER:|$)/i;
+var FINAL_ANSWER_MARKER = /^FINAL_ANSWER:\s*([\s\S]*)$/m;
+var NEWLINE = "\n";
+var TerminalAgent = class extends Agent {
+  commandDelay;
+  maxOutputLength;
+  constructor(config) {
+    super({ ...config, verboseLevel: 2 /* DEBUG */ });
+    this.commandDelay = config.commandDelay ?? 5;
+    this.maxOutputLength = config.maxOutputLength ?? 8e3;
+    const keepTools = /* @__PURE__ */ new Map();
+    for (const [name, tool] of this.tools) {
+      if (tool.constructor.name === "AgentTool") {
+        keepTools.set(name, tool);
+      }
+    }
+    this.tools = keepTools;
+    if (!this.tools.has("final_answer")) {
+      this.tools.set("final_answer", new FinalAnswerTool());
+    }
+  }
+  /**
+   * Build the system prompt. Includes delegation info if sub-agents are present.
+   */
+  initializeSystemPrompt() {
+    const agentTools = Array.from(this.tools.values()).filter(
+      (t) => t.constructor.name === "AgentTool"
+    );
+    const hasSubAgents = agentTools.length > 0;
+    const subAgentDescriptions = agentTools.map((t) => `- **${t.name}**: ${t.description}`).join("\n");
+    return generateTerminalAgentSystemPrompt({
+      customInstructions: this.config.customInstructions,
+      hasSubAgents,
+      subAgentDescriptions
+    });
+  }
+  /**
+   * Execute one step of the ReAct loop:
+   *   1. Send messages to LLM (with tool defs for final_answer / delegation)
+   *   2. Extract reasoning and ```sh blocks from the response
+   *   3. If tool calls present (final_answer or delegation), process them
+   *   4. Otherwise execute shell commands with the pre-execution delay
+   *   5. Feed stdout/stderr/exit-code back as observation
+   */
+  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 delegationTools = Array.from(this.tools.values()).filter((t) => t.constructor.name === "AgentTool");
+    const toolDefinitions = delegationTools.map((t) => t.toOpenAITool());
+    this.logger.subheader("Agent thinking...");
+    const response = await this.generateResponse(messages, toolDefinitions);
+    memoryStep.modelOutputMessage = response;
+    memoryStep.tokenUsage = response.tokenUsage;
+    const content = response.content ?? "";
+    const thoughtMatch = content.match(THOUGHT_REGEX2);
+    if (thoughtMatch) {
+      this.logger.reasoning(thoughtMatch[1].trim());
+      this.emitEvent("agent_thinking", { step: this.currentStep, content: thoughtMatch[1].trim() });
+    }
+    const finalMatch = content.match(FINAL_ANSWER_MARKER);
+    if (finalMatch) {
+      const answer = finalMatch[1].trim();
+      this.logger.finalAnswer(answer);
+      return { output: answer, isFinalAnswer: true };
+    }
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      memoryStep.toolCalls = response.toolCalls;
+      const results = await this.processToolCalls(response.toolCalls);
+      memoryStep.toolResults = results;
+      for (const result of results) {
+        if (result.error) {
+          this.logger.error(`Tool ${result.toolName} failed: ${result.error}`);
+        } else {
+          const str = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
+          this.logger.output(`[${result.toolName}]: ${str.slice(0, 500)}${str.length > 500 ? "..." : ""}`);
+        }
+      }
+      const obs = results.map((r) => r.error ? `[${r.toolName}] Error: ${r.error}` : `[${r.toolName}] Result: ${typeof r.result === "string" ? r.result : JSON.stringify(r.result)}`).join("\n");
+      memoryStep.observation = `Observation:
+${obs}`;
+      return { output: null, isFinalAnswer: false };
+    }
+    const blocks = [];
+    let match;
+    const regex = new RegExp(SH_BLOCK_REGEX.source, "g");
+    while ((match = regex.exec(content)) !== null) {
+      blocks.push(match[1].trim());
+    }
+    if (blocks.length === 0) {
+      this.logger.warn("No shell commands or tool calls in response.");
+      memoryStep.observation = "No shell command block was found in your response. Emit commands inside a ```sh code block, or call final_answer if the task is complete.";
+      return { output: null, isFinalAnswer: false };
+    }
+    const allCommands = blocks.join("\n---\n");
+    this.logger.code(allCommands, "sh");
+    this.emitEvent("agent_observation", {
+      step: this.currentStep,
+      observation: `Pending commands:
+${allCommands}`
+    });
+    this.logger.waiting(this.commandDelay);
+    await this.sleep(this.commandDelay * 1e3);
+    const observations = [];
+    let hitError = false;
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      const commands = block.split(NEWLINE).filter((l) => l.trim() && !l.trim().startsWith("#"));
+      this.logger.subheader(`Executing command block ${blocks.length > 1 ? `${i + 1}/${blocks.length}` : ""}...`);
+      for (const cmd of commands) {
+        this.logger.info(`  $ ${cmd}`);
+        const result = this.runCommand(cmd);
+        if (result.stdout) {
+          this.logger.logs(result.stdout);
+        }
+        if (result.stderr) {
+          this.logger.error(`stderr: ${result.stderr}`);
+        }
+        observations.push(
+          `$ ${cmd}
+` + (result.stdout ? `stdout:
+${result.stdout}` : "") + (result.stderr ? `stderr:
+${result.stderr}` : "") + `exit code: ${result.exitCode}`
+        );
+        if (result.exitCode !== 0) {
+          hitError = true;
+          break;
+        }
+      }
+      if (hitError) break;
+    }
+    const observation = observations.join("\n\n");
+    memoryStep.observation = `Observation:
+${observation}`;
+    if (hitError) {
+      memoryStep.error = new Error("Command exited with non-zero status. See observation for details.");
+    }
+    return { output: observation, isFinalAnswer: false };
+  }
+  /**
+   * Run a single shell command, capture stdout/stderr, return structured result.
+   */
+  runCommand(cmd) {
+    try {
+      const stdout = execSync(cmd, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: "/bin/zsh",
+        timeout: 12e4,
+        // 2-minute per-command timeout
+        maxBuffer: 50 * 1024 * 1024
+        // 50 MB
+      });
+      return { stdout: this.truncateOutput(stdout), stderr: "", exitCode: 0 };
+    } catch (err) {
+      const e = err;
+      return {
+        stdout: this.truncateOutput(e.stdout ?? ""),
+        stderr: this.truncateOutput(e.stderr ?? e.message),
+        exitCode: e.status ?? 1
+      };
+    }
+  }
+  /**
+   * Truncate long output, preserving head and tail so context stays useful.
+   */
+  truncateOutput(output) {
+    if (output.length <= this.maxOutputLength) return output;
+    const half = Math.floor(this.maxOutputLength / 2);
+    const head = output.slice(0, half);
+    const tail = output.slice(output.length - half);
+    const omitted = output.length - this.maxOutputLength;
+    return `${head}
+
+... [${omitted} characters omitted] ...
+
+${tail}`;
+  }
+  /**
+   * Generate response, with streaming if available.
+   */
+  async generateResponse(messages, toolDefinitions) {
+    if (this.config.streamOutputs && this.model.supportsStreaming() && this.model.generateStream) {
+      let fullContent = "";
+      const generator = this.model.generateStream(messages, {
+        toolDefinitions,
+        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 };
+    }
+    return this.model.generate(messages, {
+      toolDefinitions,
+      maxTokens: this.config.maxTokens,
+      temperature: this.config.temperature
+    });
+  }
+  /**
+   * Process tool calls (final_answer or AgentTool delegation).
+   */
+  async processToolCalls(toolCalls) {
+    const results = [];
+    for (const tc of toolCalls) {
+      const toolName = tc.function.name;
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        results.push({ toolCallId: tc.id, toolName, result: null, error: `Unknown tool: ${toolName}` });
+        continue;
+      }
+      let args;
+      try {
+        args = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+      } catch {
+        results.push({ toolCallId: tc.id, toolName, result: null, error: "Failed to parse tool arguments" });
+        continue;
+      }
+      this.logger.info(`  Calling tool: ${toolName}(${JSON.stringify(args).slice(0, 100)}...)`);
+      this.emitEvent("agent_tool_call", { step: this.currentStep, toolCallId: tc.id, toolName, arguments: args });
+      try {
+        const result = await tool.call(args);
+        this.emitEvent("agent_tool_result", { step: this.currentStep, toolCallId: tc.id, toolName, result, duration: 0 });
+        results.push({ toolCallId: tc.id, toolName, result });
+      } catch (error) {
+        const msg = `Tool execution error: ${error.message}`;
+        this.emitEvent("agent_tool_result", { step: this.currentStep, toolCallId: tc.id, toolName, result: null, error: msg, duration: 0 });
+        results.push({ toolCallId: tc.id, toolName, result: null, error: msg });
+      }
+    }
+    return results;
+  }
+  /**
+   * Override: force final answer via tool call format when max steps hit.
+   */
+  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) {
+      try {
+        const args = typeof response.toolCalls[0].function.arguments === "string" ? JSON.parse(response.toolCalls[0].function.arguments) : response.toolCalls[0].function.arguments;
+        return args.answer;
+      } catch {
+        return response.content;
+      }
+    }
+    return response.content;
+  }
+};
+
 // src/models/Model.ts
 var Model = class {
   /**
@@ -2727,7 +3090,7 @@ var ExaResearchTool = class extends Tool {
     while (Date.now() - startTime < this.maxPollTime) {
       attempts++;
       if (attempts > 1) {
-        await new Promise((resolve6) => setTimeout(resolve6, this.pollInterval));
+        await new Promise((resolve7) => setTimeout(resolve7, this.pollInterval));
       }
       const statusResponse = await fetch(`https://api.exa.ai/research/v1/${researchId}`, {
         method: "GET",
@@ -2780,9 +3143,10 @@ var ExaResearchTool = class extends Tool {
 
 // src/tools/ProxyTool.ts
 import { spawn } from "child_process";
+import * as path6 from "path";
 
 // src/utils/bunInstaller.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import * as path5 from "path";
 import * as fs5 from "fs";
 import * as os3 from "os";
@@ -2803,7 +3167,7 @@ async function ensureBunAvailable() {
     "\n[smol-js] Bun is required to run custom tools but was not found. Installing Bun automatically...\n"
   );
   try {
-    execSync("curl --proto =https --tlsv1.2 -sSf https://bun.sh | bash", {
+    execSync2("curl --proto =https --tlsv1.2 -sSf https://bun.sh | bash", {
       stdio: "inherit",
       shell: "/bin/bash",
       env: { ...process.env, HOME: os3.homedir() }
@@ -2828,7 +3192,7 @@ Details: ${err.message}`
 function whichBun() {
   try {
     const cmd = process.platform === "win32" ? "where bun" : "which bun";
-    const result = execSync(cmd, { encoding: "utf8", stdio: "pipe" }).trim();
+    const result = execSync2(cmd, { encoding: "utf8", stdio: "pipe" }).trim();
     const first = result.split("\n")[0]?.trim();
     if (first && fs5.existsSync(first)) return first;
     return null;
@@ -2838,10 +3202,12 @@ function whichBun() {
 }
 
 // src/tools/ProxyTool.ts
-var TOOL_OUTPUT_PREFIX = "[TOOL_OUTPUT]";
 var TOOL_RESULT_PREFIX = "[TOOL_RESULT]";
 var TOOL_ERROR_PREFIX = "[TOOL_ERROR]";
 var DEFAULT_TOOL_TIMEOUT_MS = 6e4;
+function resolveHarnessPath() {
+  return path6.resolve(__dirname, "..", "toolHarness.ts");
+}
 var ProxyTool = class extends Tool {
   name;
   description;
@@ -2850,6 +3216,7 @@ var ProxyTool = class extends Tool {
   toolPath;
   timeout;
   bunPath = null;
+  harnessPath = null;
   constructor(config) {
     super();
     this.name = config.name;
@@ -2860,23 +3227,25 @@ var ProxyTool = class extends Tool {
     this.timeout = config.timeout ?? DEFAULT_TOOL_TIMEOUT_MS;
   }
   /**
-   * Ensure Bun is available before first invocation.
+   * Ensure Bun is available and locate the harness before first invocation.
    */
   async setup() {
     this.bunPath = await ensureBunAvailable();
+    this.harnessPath = resolveHarnessPath();
     this.isSetup = true;
   }
   /**
-   * Spawn the tool in a Bun child process, pass serialized args via CLI,
-   * stream stdout back as log lines, and parse the final result.
+   * Spawn the harness in a Bun child process. The harness imports the tool,
+   * calls execute(args), and writes the protocol lines. Any console.log from
+   * the tool flows through stdout as plain lines.
    */
   async execute(args) {
-    if (!this.bunPath) {
+    if (!this.bunPath || !this.harnessPath) {
       await this.setup();
     }
     const serializedArgs = JSON.stringify(args);
-    return new Promise((resolve6, reject) => {
-      const child = spawn(this.bunPath, ["run", this.toolPath, serializedArgs], {
+    return new Promise((resolve7, reject) => {
+      const child = spawn(this.bunPath, ["run", this.harnessPath, this.toolPath, serializedArgs], {
         stdio: ["pipe", "pipe", "pipe"],
         env: { ...process.env }
       });
@@ -2941,12 +3310,12 @@ ${logBuffer.join("\n")}
 [Tool result]
 `;
             if (typeof result === "string") {
-              resolve6(logPrefix + result);
+              resolve7(logPrefix + result);
             } else {
-              resolve6({ logs: logBuffer.join("\n"), result });
+              resolve7({ logs: logBuffer.join("\n"), result });
             }
           } else {
-            resolve6(result);
+            resolve7(result);
           }
           return;
         }
@@ -2956,7 +3325,7 @@ ${logBuffer.join("\n")}
             `Custom tool "${this.name}" exited with code ${code}. Output: ${combined || "(none)"}`
           ));
         } else {
-          resolve6(combined || `Tool "${this.name}" produced no output.`);
+          resolve7(combined || `Tool "${this.name}" produced no output.`);
         }
       });
       child.on("error", (err) => {
@@ -2967,7 +3336,7 @@ ${logBuffer.join("\n")}
       });
     });
   }
-  // --- internal line parser ---
+  // --- line parser: protocol is spoken by harness, interpreted here ---
   processLine(line, handlers) {
     const trimmed = line.trimEnd();
     if (!trimmed) return;
@@ -2980,8 +3349,6 @@ ${logBuffer.join("\n")}
       }
     } else if (trimmed.startsWith(TOOL_ERROR_PREFIX)) {
       handlers.onError(trimmed.slice(TOOL_ERROR_PREFIX.length).trim());
-    } else if (trimmed.startsWith(TOOL_OUTPUT_PREFIX)) {
-      handlers.onOutput(trimmed.slice(TOOL_OUTPUT_PREFIX.length).trim());
     } else {
       handlers.onOutput(trimmed);
     }
@@ -2990,7 +3357,7 @@ ${logBuffer.join("\n")}
 
 // src/tools/CustomToolScanner.ts
 import * as fs6 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 var METADATA_REGEX = /export\s+const\s+TOOL_METADATA\s*=\s*(\{[\s\S]*?\});\s*$/m;
 function scanCustomTools(folderPath) {
   if (!fs6.existsSync(folderPath)) {
@@ -3002,10 +3369,10 @@ function scanCustomTools(folderPath) {
   const discovered = [];
   for (const entry of entries) {
     if (entry.isDirectory()) continue;
-    const ext = path6.extname(entry.name).toLowerCase();
+    const ext = path7.extname(entry.name).toLowerCase();
     if (ext !== ".ts" && ext !== ".js") continue;
-    const filePath = path6.resolve(folderPath, entry.name);
-    const baseName = path6.basename(entry.name, ext);
+    const filePath = path7.resolve(folderPath, entry.name);
+    const baseName = path7.basename(entry.name, ext);
     let metadata;
     try {
       metadata = extractMetadata(filePath);
@@ -3073,7 +3440,7 @@ function loadCustomTools(folderPath) {
 
 // src/orchestrator/YAMLLoader.ts
 import * as fs7 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 import YAML from "yaml";
 var TOOL_REGISTRY = {
   read_file: ReadFileTool,
@@ -3105,7 +3472,7 @@ var YAMLLoader = class {
    * Load a workflow from a YAML file path.
    */
   loadFromFile(filePath) {
-    const absolutePath = path7.isAbsolute(filePath) ? filePath : path7.resolve(process.cwd(), filePath);
+    const absolutePath = path8.isAbsolute(filePath) ? filePath : path8.resolve(process.cwd(), filePath);
     if (!fs7.existsSync(absolutePath)) {
       throw new Error(`Workflow file not found: ${absolutePath}`);
     }
@@ -3249,32 +3616,24 @@ var YAMLLoader = class {
       }
     }
     const maxContextLength = definition.maxContextLength ?? globalMaxContextLength;
+    const sharedConfig = {
+      model,
+      tools: agentTools,
+      maxSteps: definition.maxSteps,
+      customInstructions: definition.customInstructions,
+      persistent: definition.persistent,
+      maxContextLength,
+      memoryStrategy: definition.memoryStrategy,
+      maxTokens: definition.maxTokens,
+      temperature: definition.temperature,
+      name
+    };
     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
-      });
+      return new CodeAgent(sharedConfig);
+    } else if (definition.type === "TerminalAgent") {
+      return new TerminalAgent(sharedConfig);
     } 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
-      });
+      return new ToolUseAgent(sharedConfig);
     }
   }
 };
@@ -3673,6 +4032,7 @@ export {
   Orchestrator,
   ProxyTool,
   ReadFileTool,
+  TerminalAgent,
   Tool,
   ToolUseAgent,
   UserInputTool,