@harperfast/agent 0.12.1 → 0.13.1

package/dist/agent.js

@@ -282,9 +282,9 @@ var HarperProcess = class {
     this.stopTailingLogs();
   }
   getAndClearLogs() {
-    const logs = this.logs;
+    const logs2 = this.logs;
     this.logs = [];
-    return logs.join("");
+    return logs2.join("");
   }
 };
 var harperProcess = new HarperProcess();
@@ -702,10 +702,275 @@ function sayHi() {
   );
 }
 
-// tools/files/applyPatchTool.ts
+// tools/browser/browserClickTool.ts
+import { tool } from "@openai/agents";
+import { z } from "zod";
+
+// tools/browser/browserManager.ts
+var browser = null;
+var page = null;
+var logs = [];
+async function getBrowser() {
+  if (!browser) {
+    let puppeteer;
+    try {
+      puppeteer = await import("puppeteer");
+    } catch {
+      throw new Error(
+        "Puppeteer is not installed. Browser tools require puppeteer. Please install it with `npm install puppeteer`."
+      );
+    }
+    browser = await puppeteer.default.launch({
+      headless: false,
+      defaultViewport: null
+    });
+  }
+  return browser;
+}
+async function getPage() {
+  if (!page) {
+    const b = await getBrowser();
+    const pages = await b.pages();
+    if (pages.length > 0) {
+      page = pages[0];
+    } else {
+      page = await b.newPage();
+    }
+    page.on("console", (msg) => {
+      logs.push(`[${msg.type()}] ${msg.text()}`);
+    });
+    page.on("pageerror", (err) => {
+      logs.push(`[error] ${err.message || err}`);
+    });
+  }
+  return page;
+}
+function getBrowserLogs() {
+  return logs;
+}
+function clearBrowserLogs() {
+  logs.length = 0;
+}
+async function closeBrowser() {
+  if (browser) {
+    await browser.close();
+    browser = null;
+    page = null;
+  }
+}
+
+// tools/browser/browserClickTool.ts
+var ToolParameters = z.object({
+  selector: z.string().describe("The CSS selector of the element to click."),
+  button: z.enum(["left", "right", "middle"]).default("left").describe("The button to use for the click."),
+  clickCount: z.number().default(1).describe("The number of times to click.")
+});
+async function execute({ selector, button, clickCount }) {
+  try {
+    const page2 = await getPage();
+    await page2.click(selector, { button, clickCount });
+    return `Successfully clicked on ${selector}`;
+  } catch (error) {
+    return `Error clicking on ${selector}: ${error}`;
+  }
+}
+var browserClickTool = tool({
+  name: "browser_click",
+  description: "Clicks on an element specified by a CSS selector.",
+  parameters: ToolParameters,
+  execute
+});
+
+// tools/browser/browserCloseTool.ts
 import { tool as tool2 } from "@openai/agents";
-import chalk7 from "chalk";
 import { z as z2 } from "zod";
+var ToolParameters2 = z2.object({});
+async function execute2() {
+  try {
+    await closeBrowser();
+    return "Browser closed successfully.";
+  } catch (error) {
+    return `Error closing browser: ${error}`;
+  }
+}
+var browserCloseTool = tool2({
+  name: "browser_close",
+  description: "Closes the browser instance.",
+  parameters: ToolParameters2,
+  execute: execute2
+});
+
+// tools/browser/browserEvaluateTool.ts
+import { tool as tool3 } from "@openai/agents";
+import { z as z3 } from "zod";
+var ToolParameters3 = z3.object({
+  script: z3.string().describe("The JavaScript to evaluate in the context of the page.")
+});
+async function execute3({ script }) {
+  try {
+    const page2 = await getPage();
+    const result = await page2.evaluate(script);
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    return `Error evaluating script: ${error}`;
+  }
+}
+var browserEvaluateTool = tool3({
+  name: "browser_evaluate",
+  description: "Evaluates JavaScript in the context of the current page.",
+  parameters: ToolParameters3,
+  execute: execute3
+});
+
+// tools/browser/browserGetContentTool.ts
+import { tool as tool4 } from "@openai/agents";
+import { z as z4 } from "zod";
+var ToolParameters4 = z4.object({
+  type: z4.enum(["html", "text"]).default("html").describe("The type of content to retrieve (html or text).")
+});
+async function execute4({ type }) {
+  try {
+    const page2 = await getPage();
+    if (type === "text") {
+      return await page2.evaluate(() => document.body.innerText);
+    }
+    return await page2.content();
+  } catch (error) {
+    return `Error getting content: ${error}`;
+  }
+}
+var browserGetContentTool = tool4({
+  name: "browser_get_content",
+  description: "Gets the content (HTML or text) of the current page.",
+  parameters: ToolParameters4,
+  execute: execute4
+});
+
+// tools/browser/browserGetLogsTool.ts
+import { tool as tool5 } from "@openai/agents";
+import { z as z5 } from "zod";
+var ToolParameters5 = z5.object({
+  clear: z5.boolean().default(false).describe("Whether to clear the logs after reading them.")
+});
+async function execute5({ clear }) {
+  const logs2 = getBrowserLogs();
+  const result = logs2.length > 0 ? logs2.join("\n") : "No logs found.";
+  if (clear) {
+    clearBrowserLogs();
+  }
+  return result;
+}
+var browserGetLogsTool = tool5({
+  name: "browser_get_logs",
+  description: "Returns the console logs from the browser.",
+  parameters: ToolParameters5,
+  execute: execute5
+});
+
+// tools/browser/browserIsElementPresentTool.ts
+import { tool as tool6 } from "@openai/agents";
+import { z as z6 } from "zod";
+var ToolParameters6 = z6.object({
+  selector: z6.string().describe("The CSS selector of the element to check for presence.")
+});
+async function execute6({ selector }) {
+  try {
+    const page2 = await getPage();
+    const element = await page2.$(selector);
+    return element !== null ? `Element ${selector} is present.` : `Element ${selector} is not present.`;
+  } catch (error) {
+    return `Error checking for element ${selector}: ${error}`;
+  }
+}
+var browserIsElementPresentTool = tool6({
+  name: "browser_is_element_present",
+  description: "Checks if an element is present on the page.",
+  parameters: ToolParameters6,
+  execute: execute6
+});
+
+// tools/browser/browserNavigateTool.ts
+import { tool as tool7 } from "@openai/agents";
+import { z as z7 } from "zod";
+var ToolParameters7 = z7.object({
+  url: z7.string().describe("The URL to navigate to."),
+  waitUntil: z7.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"]).default("load").describe("When to consider navigation succeeded.")
+});
+async function execute7({ url, waitUntil }) {
+  try {
+    const page2 = await getPage();
+    await page2.goto(url, { waitUntil });
+    return `Successfully navigated to ${url}`;
+  } catch (error) {
+    return `Error navigating to ${url}: ${error}`;
+  }
+}
+var browserNavigateTool = tool7({
+  name: "browser_navigate",
+  description: "Navigates the browser to a specified URL.",
+  parameters: ToolParameters7,
+  execute: execute7
+});
+
+// tools/browser/browserScreenshotTool.ts
+import { tool as tool8 } from "@openai/agents";
+import { z as z8 } from "zod";
+var ToolParameters8 = z8.object({
+  fullPage: z8.boolean().default(false).describe("Whether to take a screenshot of the full scrollable page.")
+});
+async function execute8({ fullPage }) {
+  try {
+    const page2 = await getPage();
+    const screenshot = await page2.screenshot({
+      encoding: "base64",
+      type: "jpeg",
+      quality: 80,
+      fullPage
+    });
+    return {
+      type: "image",
+      image: `data:image/jpeg;base64,${screenshot}`,
+      detail: "auto"
+    };
+  } catch (error) {
+    return `Error taking screenshot: ${error}`;
+  }
+}
+var browserScreenshotTool = tool8({
+  name: "browser_screenshot",
+  description: "Takes a screenshot of the current page.",
+  parameters: ToolParameters8,
+  execute: execute8
+});
+
+// tools/browser/browserTypeTool.ts
+import { tool as tool9 } from "@openai/agents";
+import { z as z9 } from "zod";
+var ToolParameters9 = z9.object({
+  selector: z9.string().describe("The CSS selector of the element to type into."),
+  text: z9.string().describe("The text to type into the element."),
+  delay: z9.number().default(0).describe("Delay between key presses in milliseconds.")
+});
+async function execute9({ selector, text, delay }) {
+  try {
+    const page2 = await getPage();
+    await page2.type(selector, text, { delay });
+    return `Successfully typed into ${selector}`;
+  } catch (error) {
+    return `Error typing into ${selector}: ${error}`;
+  }
+}
+var browserTypeTool = tool9({
+  name: "browser_type",
+  description: "Types text into an element specified by a CSS selector.",
+  parameters: ToolParameters9,
+  execute: execute9
+});
+
+// tools/files/applyPatchTool.ts
+import { tool as tool11 } from "@openai/agents";
+import chalk7 from "chalk";
+import { z as z11 } from "zod";
 
 // utils/files/printDiff.ts
 import chalk5 from "chalk";
@@ -746,11 +1011,11 @@ function getEnv(newKey, oldKey) {
 }
 
 // tools/harper/getHarperSkillTool.ts
-import { tool } from "@openai/agents";
+import { tool as tool10 } from "@openai/agents";
 import { readdirSync, readFileSync as readFileSync3 } from "fs";
 import { createRequire } from "module";
 import { dirname, join as join6 } from "path";
-import { z } from "zod";
+import { z as z10 } from "zod";
 var createHarper = dirname(createRequire(import.meta.url).resolve("create-harper"));
 var agentsMarkdown = join6(
   createHarper,
@@ -763,16 +1028,16 @@ var skillsDir = join6(
 );
 var skillLinkRegex = /\[[^\]]+]\(skills\/([^)]+)\.md\)/g;
 var skills = getSkills();
-var ToolParameters = z.object({
-  skill: z.enum(skills.length > 0 ? skills : ["none"]).describe(
+var ToolParameters10 = z10.object({
+  skill: z10.enum(skills.length > 0 ? skills : ["none"]).describe(
     "The name of the skill to retrieve."
   )
 });
-var getHarperSkillTool = tool({
-  name: "getHarperSkill",
+var getHarperSkillTool = tool10({
+  name: "get_harper_skill",
   description: getSkillsDescription(),
-  parameters: ToolParameters,
-  execute
+  parameters: ToolParameters10,
+  execute: execute10
 });
 function getSkillsDescription() {
   try {
@@ -788,7 +1053,7 @@ function getSkills() {
     return [];
   }
 }
-async function execute({ skill }) {
+async function execute10({ skill }) {
   if (skill === "none") {
     return "No skills found.";
   }
@@ -933,10 +1198,10 @@ var WorkspaceEditor = class {
 };
 
 // tools/files/applyPatchTool.ts
-var ApplyPatchParameters = z2.object({
-  type: z2.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
-  path: z2.string().describe("The path to the file to operate on."),
-  diff: z2.string().optional().default("").describe(
+var ApplyPatchParameters = z11.object({
+  type: z11.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
+  path: z11.string().describe("The path to the file to operate on."),
+  diff: z11.string().optional().default("").describe(
     'The diff to apply. For create_file, every line must start with "+". For update_file, use a headerless unified diff format (start sections with "@@", and use "+", "-", or " " for lines). Do not include markers like "*** Begin Patch" or "*** Add File:".'
   )
 });
@@ -1011,7 +1276,7 @@ ${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
   }
 }
 function createApplyPatchTool() {
-  return tool2({
+  return tool11({
     name: "apply_patch",
     description: "Applies a patch (create, update, or delete a file) to the workspace.",
     parameters: ApplyPatchParameters,
@@ -1020,7 +1285,7 @@ function createApplyPatchTool() {
       try {
         const needed = await requiredSkillForOperation(operation.path, operation.type);
         if (needed) {
-          const content = await execute({ skill: needed });
+          const content = await execute10({ skill: needed });
           return { status: "completed", output: content };
         }
         switch (operation.type) {
@@ -1048,13 +1313,13 @@ function createApplyPatchTool() {
 }
 
 // tools/files/changeCwdTool.ts
-import { tool as tool3 } from "@openai/agents";
+import { tool as tool12 } from "@openai/agents";
 import { statSync } from "fs";
-import { z as z3 } from "zod";
-var ToolParameters2 = z3.object({
-  path: z3.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
+import { z as z12 } from "zod";
+var ToolParameters11 = z12.object({
+  path: z12.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
 });
-async function execute2({ path: path8 }) {
+async function execute11({ path: path8 }) {
   try {
     const target = resolvePath(trackedState.cwd, path8);
     const stat = statSync(target);
@@ -1081,27 +1346,27 @@ I strongly suggest you use these newfound skills!`;
     return `Failed to change directory: ${err.message}`;
   }
 }
-var changeCwdTool = tool3({
-  name: "changeCwd",
+var changeCwdTool = tool12({
+  name: "change_cwd",
   description: "Changes the current working directory for subsequent tools. Accepts absolute or relative paths.",
-  parameters: ToolParameters2,
-  execute: execute2
+  parameters: ToolParameters11,
+  execute: execute11
 });
 
 // tools/files/egrepTool.ts
-import { tool as tool4 } from "@openai/agents";
+import { tool as tool13 } from "@openai/agents";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { z as z4 } from "zod";
+import { z as z13 } from "zod";
 var execFileAsync = promisify(execFile);
-var ToolParameters3 = z4.object({
-  path: z4.string().describe("The path to start the search from."),
-  pattern: z4.string().describe("The pattern to search")
+var ToolParameters12 = z13.object({
+  path: z13.string().describe("The path to start the search from."),
+  pattern: z13.string().describe("The pattern to search")
 });
-var egrepTool = tool4({
+var egrepTool = tool13({
   name: "egrep",
   description: "File pattern searcher.",
-  parameters: ToolParameters3,
+  parameters: ToolParameters12,
   async execute({ path: searchPath, pattern }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1127,21 +1392,21 @@ var egrepTool = tool4({
 });
 
 // tools/files/findTool.ts
-import { tool as tool5 } from "@openai/agents";
+import { tool as tool14 } from "@openai/agents";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { z as z5 } from "zod";
+import { z as z14 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
-var ToolParameters4 = z5.object({
-  path: z5.string().describe("The path to start the search from."),
-  iname: z5.string().describe(
+var ToolParameters13 = z14.object({
+  path: z14.string().describe("The path to start the search from."),
+  iname: z14.string().describe(
     "Case insensitive, true if the last component of the pathname being examined matches pattern.  Special shell pattern matching characters (\u201C[\u201D, \u201C]\u201D, \u201C*\u201D, and \u201C?\u201D) may be used as part of pattern.  These characters may be matched explicitly by escaping them with a backslash (\u201C\\\u201D)."
   )
 });
-var findTool = tool5({
+var findTool = tool14({
   name: "find",
   description: "Walk a file hierarchy.",
-  parameters: ToolParameters4,
+  parameters: ToolParameters13,
   async execute({ path: searchPath, iname }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1154,17 +1419,17 @@ var findTool = tool5({
 });
 
 // tools/files/readDirTool.ts
-import { tool as tool6 } from "@openai/agents";
+import { tool as tool15 } from "@openai/agents";
 import { readdir } from "fs/promises";
 import path5 from "path";
-import { z as z6 } from "zod";
-var ToolParameters5 = z6.object({
-  directoryName: z6.string().describe("The name of the directory to read.")
+import { z as z15 } from "zod";
+var ToolParameters14 = z15.object({
+  directoryName: z15.string().describe("The name of the directory to read.")
 });
-var readDirTool = tool6({
-  name: "readDir",
+var readDirTool = tool15({
+  name: "read_dir",
   description: "Lists the files in a directory.",
-  parameters: ToolParameters5,
+  parameters: ToolParameters14,
   async execute({ directoryName }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, directoryName);
@@ -1177,51 +1442,70 @@ var readDirTool = tool6({
 });
 
 // tools/files/readFileTool.ts
-import { tool as tool7 } from "@openai/agents";
+import { tool as tool16 } from "@openai/agents";
 import { readFile } from "fs/promises";
-import { z as z7 } from "zod";
-var ToolParameters6 = z7.object({
-  fileName: z7.string().describe("The name of the file to read.")
+import { extname } from "path";
+import { z as z16 } from "zod";
+var ToolParameters15 = z16.object({
+  fileName: z16.string().describe("The name of the file to read.")
 });
-var readFileTool = tool7({
-  name: "readFile",
-  description: "Reads the contents of a specified file.",
-  parameters: ToolParameters6,
-  async execute({ fileName }) {
-    try {
-      const normalized = String(fileName).replace(/\\/g, "/");
-      const m = normalized.match(/(?:^|\/)skills\/([A-Za-z0-9_-]+)\.md(?:$|[?#])/);
-      if (m && m[1]) {
-        trackedState.session?.addSkillRead?.(m[1]);
-      }
-      const resolvedPath = resolvePath(trackedState.cwd, fileName);
-      return readFile(resolvedPath, "utf8");
-    } catch (error) {
-      return `Error reading file: ${error}`;
+var IMAGE_EXTENSIONS = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp"
+};
+async function execute12({ fileName }) {
+  try {
+    const normalized = String(fileName).replace(/\\/g, "/");
+    const m = normalized.match(/(?:^|\/)skills\/([A-Za-z0-9_-]+)\.md(?:$|[?#])/);
+    if (m && m[1]) {
+      trackedState.session?.addSkillRead?.(m[1]);
+    }
+    const resolvedPath = resolvePath(trackedState.cwd, fileName);
+    const ext = extname(resolvedPath).toLowerCase();
+    if (IMAGE_EXTENSIONS[ext]) {
+      const buffer = await readFile(resolvedPath);
+      return {
+        type: "image",
+        image: `data:${IMAGE_EXTENSIONS[ext]};base64,${buffer.toString("base64")}`,
+        detail: "auto"
+      };
     }
+    return await readFile(resolvedPath, "utf8");
+  } catch (error) {
+    return `Error reading file: ${error}`;
   }
+}
+var readFileTool = tool16({
+  name: "read_file",
+  description: "Reads the contents of a specified file. If the file is an image, it returns a structured image object.",
+  parameters: ToolParameters15,
+  execute: execute12
 });
 
 // tools/general/codeInterpreterTool.ts
-import { tool as tool8 } from "@openai/agents";
+import { tool as tool17 } from "@openai/agents";
 import chalk8 from "chalk";
 import { exec } from "child_process";
 import { unlink, writeFile as writeFile2 } from "fs/promises";
 import path6 from "path";
 import { promisify as promisify3 } from "util";
-import { z as z8 } from "zod";
+import { z as z17 } from "zod";
 var execAsync = promisify3(exec);
-var CodeInterpreterParameters = z8.object({
-  code: z8.string().describe("The code to execute."),
-  language: z8.enum(["python", "javascript"]).optional().default("python").describe(
+var CodeInterpreterParameters = z17.object({
+  code: z17.string().describe("The code to execute."),
+  language: z17.enum(["python", "javascript"]).optional().default("python").describe(
     "The programming language of the code."
   )
 });
-var codeInterpreterTool = tool8({
+var codeInterpreterTool = tool17({
   name: "code_interpreter",
   description: "Executes Python or JavaScript code in a local environment. This is useful for data analysis, complex calculations, and more. All code will be executed in the current workspace.",
   parameters: CodeInterpreterParameters,
-  execute: execute3,
+  execute: execute13,
   needsApproval: needsApproval2
 });
 async function needsApproval2(runContext, { code, language }, callId) {
@@ -1243,7 +1527,7 @@ ${chalk8.bold.bgYellow.black(` Code interpreter (${language}) approval required:
   }
   return !autoApproved;
 }
-async function execute3({ code, language }) {
+async function execute13({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
   const interpreter = language === "javascript" ? "node" : "python3";
   const tempFile = path6.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
@@ -1265,8 +1549,8 @@ STDERR: ${error.stderr || ""}`;
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-import { tool as tool9 } from "@openai/agents";
-import { z as z9 } from "zod";
+import { tool as tool18 } from "@openai/agents";
+import { z as z18 } from "zod";
 
 // utils/files/updateEnv.ts
 import { existsSync as existsSync6 } from "fs";
@@ -1293,11 +1577,11 @@ async function updateEnv(key, value) {
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-var SetInterpreterAutoApproveParameters = z9.object({
-  autoApprove: z9.boolean()
+var SetInterpreterAutoApproveParameters = z18.object({
+  autoApprove: z18.boolean()
 });
-var setInterpreterAutoApproveTool = tool9({
-  name: "setInterpreterAutoApproveTool",
+var setInterpreterAutoApproveTool = tool18({
+  name: "set_interpreter_auto_approve",
   description: "Enable or disable automatic approval for code interpreter by setting HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER=1 or 0 in .env and current process.",
   parameters: SetInterpreterAutoApproveParameters,
   needsApproval: async (_runContext, { autoApprove }) => {
@@ -1319,13 +1603,13 @@ var setInterpreterAutoApproveTool = tool9({
 });
 
 // tools/general/setPatchAutoApproveTool.ts
-import { tool as tool10 } from "@openai/agents";
-import { z as z10 } from "zod";
-var SetPatchAutoApproveParameters = z10.object({
-  autoApprove: z10.boolean()
+import { tool as tool19 } from "@openai/agents";
+import { z as z19 } from "zod";
+var SetPatchAutoApproveParameters = z19.object({
+  autoApprove: z19.boolean()
 });
-var setPatchAutoApproveTool = tool10({
-  name: "setPatchAutoApproveTool",
+var setPatchAutoApproveTool = tool19({
+  name: "set_patch_auto_approve",
   description: "Enable or disable automatic approval for patch commands by setting HARPER_AGENT_AUTO_APPROVE_PATCHES=1 or 0 in .env and current process.",
   parameters: SetPatchAutoApproveParameters,
   needsApproval: async (_runContext, { autoApprove }) => {
@@ -1347,13 +1631,13 @@ var setPatchAutoApproveTool = tool10({
 });
 
 // tools/general/setShellAutoApproveTool.ts
-import { tool as tool11 } from "@openai/agents";
-import { z as z11 } from "zod";
-var SetShellAutoApproveParameters = z11.object({
-  autoApprove: z11.boolean()
+import { tool as tool20 } from "@openai/agents";
+import { z as z20 } from "zod";
+var SetShellAutoApproveParameters = z20.object({
+  autoApprove: z20.boolean()
 });
-var setShellAutoApproveTool = tool11({
-  name: "setShellAutoApproveTool",
+var setShellAutoApproveTool = tool20({
+  name: "set_shell_auto_approve",
   description: "Enable or disable automatic approval for shell commands by setting HARPER_AGENT_AUTO_APPROVE_SHELL=1 or 0 in .env and current process.",
   parameters: SetShellAutoApproveParameters,
   needsApproval: async (_runContext, { autoApprove }) => {
@@ -1375,9 +1659,9 @@ var setShellAutoApproveTool = tool11({
 });
 
 // tools/general/shellTool.ts
-import { tool as tool12 } from "@openai/agents";
+import { tool as tool21 } from "@openai/agents";
 import chalk9 from "chalk";
-import { z as z12 } from "zod";
+import { z as z21 } from "zod";
 
 // utils/files/mentionsIgnoredPath.ts
 function mentionsIgnoredPath(command) {
@@ -1489,13 +1773,13 @@ var LocalShell = class {
 };
 
 // tools/general/shellTool.ts
-var ShellParameters = z12.object({
-  commands: z12.array(z12.string()).describe("The commands to execute.")
+var ShellParameters = z21.object({
+  commands: z21.array(z21.string()).describe("The commands to execute.")
 });
 var shell = new LocalShell();
-var shellTool = tool12({
-  name: "shellToolForCommandsWithoutABetterTool",
-  description: "Executes shell commands.",
+var shellTool = tool21({
+  name: "shell",
+  description: "Executes shell commands. Only use when we do not have a better tool.",
   parameters: ShellParameters,
   execute: async ({ commands }) => {
     const result = await shell.run({ commands });
@@ -1550,16 +1834,16 @@ TIMEOUT`;
 });
 
 // tools/git/gitAddTool.ts
-import { tool as tool13 } from "@openai/agents";
+import { tool as tool22 } from "@openai/agents";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { z as z13 } from "zod";
+import { z as z22 } from "zod";
 var execFileAsync3 = promisify5(execFile3);
-var GitAddParameters = z13.object({
-  files: z13.array(z13.string()).describe("The files to add. If not provided, all changes will be added.")
+var GitAddParameters = z22.object({
+  files: z22.array(z22.string()).describe("The files to add. If not provided, all changes will be added.")
 });
-var gitAddTool = tool13({
-  name: "gitAddTool",
+var gitAddTool = tool22({
+  name: "git_add",
   description: "Add file contents to the index.",
   parameters: GitAddParameters,
   async execute({ files }) {
@@ -1579,17 +1863,17 @@ var gitAddTool = tool13({
 });
 
 // tools/git/gitBranchTool.ts
-import { tool as tool14 } from "@openai/agents";
+import { tool as tool23 } from "@openai/agents";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify6 } from "util";
-import { z as z14 } from "zod";
+import { z as z23 } from "zod";
 var execFileAsync4 = promisify6(execFile4);
-var GitBranchParameters = z14.object({
-  branchName: z14.string().describe("The name of the branch to create or switch to."),
-  create: z14.boolean().optional().default(false).describe("Whether to create a new branch.")
+var GitBranchParameters = z23.object({
+  branchName: z23.string().describe("The name of the branch to create or switch to."),
+  create: z23.boolean().optional().default(false).describe("Whether to create a new branch.")
 });
-var gitBranchTool = tool14({
-  name: "gitBranchTool",
+var gitBranchTool = tool23({
+  name: "git_branch",
   description: "Create or switch to a git branch.",
   parameters: GitBranchParameters,
   needsApproval: true,
@@ -1605,19 +1889,19 @@ var gitBranchTool = tool14({
 });
 
 // tools/git/gitCommitTool.ts
-import { tool as tool15 } from "@openai/agents";
+import { tool as tool24 } from "@openai/agents";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify7 } from "util";
-import { z as z15 } from "zod";
+import { z as z24 } from "zod";
 var execFileAsync5 = promisify7(execFile5);
-var GitCommitParameters = z15.object({
-  message: z15.string().describe("The commit message."),
-  addAll: z15.boolean().optional().default(false).describe(
+var GitCommitParameters = z24.object({
+  message: z24.string().describe("The commit message."),
+  addAll: z24.boolean().optional().default(false).describe(
     "Whether to add all changes before committing (git commit -am)."
   )
 });
-var gitCommitTool = tool15({
-  name: "gitCommitTool",
+var gitCommitTool = tool24({
+  name: "git_commit",
   description: "Commit changes to the repository.",
   parameters: GitCommitParameters,
   async execute({ message, addAll }) {
@@ -1632,17 +1916,17 @@ var gitCommitTool = tool15({
 });
 
 // tools/git/gitLogTool.ts
-import { tool as tool16 } from "@openai/agents";
+import { tool as tool25 } from "@openai/agents";
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify8 } from "util";
-import { z as z16 } from "zod";
+import { z as z25 } from "zod";
 var execFileAsync6 = promisify8(execFile6);
-var GitLogParameters = z16.object({
-  count: z16.number().optional().default(10).describe("Number of commits to show."),
-  oneline: z16.boolean().optional().default(true).describe("Whether to show log in oneline format.")
+var GitLogParameters = z25.object({
+  count: z25.number().optional().default(10).describe("Number of commits to show."),
+  oneline: z25.boolean().optional().default(true).describe("Whether to show log in oneline format.")
 });
-var gitLogTool = tool16({
-  name: "gitLogTool",
+var gitLogTool = tool25({
+  name: "git_log",
   description: "Show commit logs.",
   parameters: GitLogParameters,
   async execute({ count, oneline }) {
@@ -1660,18 +1944,18 @@ var gitLogTool = tool16({
 });
 
 // tools/git/gitStashTool.ts
-import { tool as tool17 } from "@openai/agents";
+import { tool as tool26 } from "@openai/agents";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify9 } from "util";
-import { z as z17 } from "zod";
+import { z as z26 } from "zod";
 var execFileAsync7 = promisify9(execFile7);
 var allowedActions = ["push", "pop", "apply", "list"];
-var GitStashParameters = z17.object({
-  action: z17.string().describe("The stash action to perform: " + allowedActions.join(", ")),
-  message: z17.string().describe("A message for the stash change.")
+var GitStashParameters = z26.object({
+  action: z26.string().describe("The stash action to perform: " + allowedActions.join(", ")),
+  message: z26.string().describe("A message for the stash change.")
 });
-var gitStashTool = tool17({
-  name: "gitStashTool",
+var gitStashTool = tool26({
+  name: "git_stash",
   description: "Stash changes or apply a stash.",
   parameters: GitStashParameters,
   async execute({ action, message }) {
@@ -1692,16 +1976,16 @@ var gitStashTool = tool17({
 });
 
 // tools/git/gitStatusTool.ts
-import { tool as tool18 } from "@openai/agents";
+import { tool as tool27 } from "@openai/agents";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify10 } from "util";
-import { z as z18 } from "zod";
+import { z as z27 } from "zod";
 var execFileAsync8 = promisify10(execFile8);
-var GitStatusParameters = z18.object({
-  short: z18.boolean().optional().default(false).describe("Whether to show the status in short format.")
+var GitStatusParameters = z27.object({
+  short: z27.boolean().optional().default(false).describe("Whether to show the status in short format.")
 });
-var gitStatusTool = tool18({
-  name: "gitStatusTool",
+var gitStatusTool = tool27({
+  name: "git_status",
   description: "Show the working tree status.",
   parameters: GitStatusParameters,
   async execute({ short }) {
@@ -1719,18 +2003,18 @@ var gitStatusTool = tool18({
 });
 
 // tools/git/gitWorkspaceTool.ts
-import { tool as tool19 } from "@openai/agents";
+import { tool as tool28 } from "@openai/agents";
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify11 } from "util";
-import { z as z19 } from "zod";
+import { z as z28 } from "zod";
 var execFileAsync9 = promisify11(execFile9);
-var GitWorkspaceParameters = z19.object({
-  path: z19.string().describe("The path where the new workspace (worktree) should be created."),
-  branchName: z19.string().describe("The name of the branch to use in the new workspace."),
-  createBranch: z19.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
+var GitWorkspaceParameters = z28.object({
+  path: z28.string().describe("The path where the new workspace (worktree) should be created."),
+  branchName: z28.string().describe("The name of the branch to use in the new workspace."),
+  createBranch: z28.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
 });
-var gitWorkspaceTool = tool19({
-  name: "gitWorkspaceTool",
+var gitWorkspaceTool = tool28({
+  name: "git_workspace",
   description: "Create a new workspace (git worktree) for parallel work.",
   parameters: GitWorkspaceParameters,
   async execute({ path: workspacePath, branchName, createBranch }) {
@@ -1746,13 +2030,13 @@ var gitWorkspaceTool = tool19({
 });
 
 // tools/harper/checkHarperStatusTool.ts
-import { tool as tool20 } from "@openai/agents";
-import { z as z20 } from "zod";
-var ToolParameters7 = z20.object({});
-var checkHarperStatusTool = tool20({
-  name: "checkHarperStatusTool",
+import { tool as tool29 } from "@openai/agents";
+import { z as z29 } from "zod";
+var ToolParameters16 = z29.object({});
+var checkHarperStatusTool = tool29({
+  name: "check_harper_status",
   description: "Checks if a Harper application is currently running.",
-  parameters: ToolParameters7,
+  parameters: ToolParameters16,
   async execute() {
     if (harperProcess.running) {
       return "A Harper application is currently running.";
@@ -1763,10 +2047,10 @@ var checkHarperStatusTool = tool20({
 });
 
 // tools/harper/createNewHarperApplicationTool.ts
-import { tool as tool21 } from "@openai/agents";
+import { tool as tool30 } from "@openai/agents";
 import { execSync as execSync3 } from "child_process";
 import path7 from "path";
-import { z as z21 } from "zod";
+import { z as z30 } from "zod";
 
 // utils/package/buildHarperCreateCommand.ts
 function buildCreateCommand(pm, appName, template) {
@@ -1816,11 +2100,11 @@ var PM_DISPLAY = {
 };
 
 // tools/harper/createNewHarperApplicationTool.ts
-var ToolParameters8 = z21.object({
-  directoryName: z21.string().describe("The name of the directory to create the application in."),
-  template: z21.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
+var ToolParameters17 = z30.object({
+  directoryName: z30.string().describe("The name of the directory to create the application in."),
+  template: z30.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
 });
-async function execute4({ directoryName, template }) {
+async function execute14({ directoryName, template }) {
   const currentCwd = trackedState.cwd;
   const resolvedPath = resolvePath(currentCwd, directoryName);
   const isCurrentDir = resolvedPath === currentCwd;
@@ -1837,7 +2121,7 @@ async function execute4({ directoryName, template }) {
     });
     console.log(`Initializing new Git repository in ${resolvedPath}...`);
     execSync3("git init", { cwd: resolvedPath, stdio: "ignore" });
-    const switchedDir = await execute2({ path: resolvedPath });
+    const switchedDir = await execute11({ path: resolvedPath });
     return `Successfully created a new Harper application in '${resolvedPath}' using template '${template}' with a matching Git repository initialized.  Use the readDir and readFile tools to inspect the contents of the application. ${switchedDir}.`;
   } catch (error) {
     let errorMsg = `Error creating new Harper application: ${error.message}`;
@@ -1850,28 +2134,28 @@ ${error.stdout}`;
     return errorMsg;
   }
 }
-var createNewHarperApplicationTool = tool21({
-  name: "createNewHarperApplicationTool",
+var createNewHarperApplicationTool = tool30({
+  name: "create_new_harper_application",
   description: "Creates a new Harper application using the best available package manager (yarn/pnpm/bun/deno, falling back to npm).",
-  parameters: ToolParameters8,
-  execute: execute4
+  parameters: ToolParameters17,
+  execute: execute14
 });
 
 // tools/harper/getHarperConfigSchemaTool.ts
-import { tool as tool22 } from "@openai/agents";
+import { tool as tool31 } from "@openai/agents";
 import { readFile as readFile3 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname2, join as join8 } from "path";
-import { z as z22 } from "zod";
-var ToolParameters9 = z22.object({
-  schemaType: z22.enum(["app", "root"]).describe(
+import { z as z31 } from "zod";
+var ToolParameters18 = z31.object({
+  schemaType: z31.enum(["app", "root"]).describe(
     'The type of configuration schema to retrieve: "app" for application configuration or "root" for root Harper configuration.'
   )
 });
-var getHarperConfigSchemaTool = tool22({
-  name: "getHarperConfigSchemaTool",
+var getHarperConfigSchemaTool = tool31({
+  name: "get_harper_config_schema",
   description: "Returns the JSON schema for HarperDB configuration files (either app or root), which describes the config.yaml or harperdb-config.yaml files.",
-  parameters: ToolParameters9,
+  parameters: ToolParameters18,
   async execute({ schemaType }) {
     try {
       return await readFile3(
@@ -1888,13 +2172,13 @@ var getHarperConfigSchemaTool = tool22({
 });
 
 // tools/harper/getHarperResourceInterfaceTool.ts
-import { tool as tool23 } from "@openai/agents";
+import { tool as tool32 } from "@openai/agents";
 import { readFile as readFile4 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { dirname as dirname3, join as join9 } from "path";
-import { z as z23 } from "zod";
-var ToolParameters10 = z23.object({
-  resourceFile: z23.enum([
+import { z as z32 } from "zod";
+var ToolParameters19 = z32.object({
+  resourceFile: z32.enum([
     "ResourceInterfaceV2",
     "ResourceInterface",
     "Table",
@@ -1904,10 +2188,10 @@ var ToolParameters10 = z23.object({
     "The resource-related definition file to read. Defaults to ResourceInterfaceV2."
   ).default("ResourceInterfaceV2")
 });
-var getHarperResourceInterfaceTool = tool23({
-  name: "getHarperResourceInterfaceTool",
+var getHarperResourceInterfaceTool = tool32({
+  name: "get_harper_resource_interface",
   description: "Reads HarperDB resource interface and class definitions (like ResourceInterfaceV2.d.ts) to understand how resources and tables are structured.",
-  parameters: ToolParameters10,
+  parameters: ToolParameters19,
   async execute({ resourceFile }) {
     try {
       return await readFile4(
@@ -1925,16 +2209,16 @@ var getHarperResourceInterfaceTool = tool23({
 });
 
 // tools/harper/getHarperSchemaGraphQLTool.ts
-import { tool as tool24 } from "@openai/agents";
+import { tool as tool33 } from "@openai/agents";
 import { readFile as readFile5 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname4, join as join10 } from "path";
-import { z as z24 } from "zod";
-var ToolParameters11 = z24.object({});
-var getHarperSchemaGraphQLTool = tool24({
-  name: "getHarperSchemaGraphQLTool",
+import { z as z33 } from "zod";
+var ToolParameters20 = z33.object({});
+var getHarperSchemaGraphQLTool = tool33({
+  name: "get_harper_schema_graphql",
   description: "Returns the GraphQL schema for HarperDB schema files, which define the structure of HarperDB database tables.",
-  parameters: ToolParameters11,
+  parameters: ToolParameters20,
   async execute() {
     try {
       return await readFile5(
@@ -1951,24 +2235,24 @@ var getHarperSchemaGraphQLTool = tool24({
 });
 
 // tools/harper/hitHarperAPITool.ts
-import { tool as tool25 } from "@openai/agents";
-import { z as z25 } from "zod";
-var ToolParameters12 = z25.object({
-  method: z25.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
+import { tool as tool34 } from "@openai/agents";
+import { z as z34 } from "zod";
+var ToolParameters21 = z34.object({
+  method: z34.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
     'The HTTP method to use, defaults to "get". Notably, POST and PUT require the full body be sent.'
   ),
-  path: z25.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
-  port: z25.number().optional().default(harperProcess.httpPort).describe(
+  path: z34.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
+  port: z34.number().optional().default(harperProcess.httpPort).describe(
     "The port to fetch from localhost (defaults to the running Harper port)."
   ),
-  body: z25.string().optional().default("").describe("An optional JSON string body to send along with the request.")
+  body: z34.string().optional().default("").describe("An optional JSON string body to send along with the request.")
 });
-var hitHarperAPITool = tool25({
-  name: "hitHarperAPITool",
+var hitHarperAPITool = tool34({
+  name: "hit_harper_api",
   description: "Performs a request against the running Harper API. Use /openapi to look up Harper APIs.",
-  parameters: ToolParameters12,
+  parameters: ToolParameters21,
   needsApproval: async (runContext, input, callId) => {
-    if (callId && runContext.isToolApproved({ toolName: "hitHarperAPITool", callId })) {
+    if (callId && runContext.isToolApproved({ toolName: "hit_harper_api", callId })) {
       return false;
     }
     if (input.method === "DELETE") {
@@ -2003,57 +2287,21 @@ var hitHarperAPITool = tool25({
   }
 });
 
-// tools/harper/openHarperInBrowserTool.ts
-import { tool as tool26 } from "@openai/agents";
-import spawn2 from "cross-spawn";
-import { platform } from "os";
-import { z as z26 } from "zod";
-var alreadyOpened = false;
-var ToolParameters13 = z26.object({});
-var openHarperInBrowserTool = tool26({
-  name: "openHarperInBrowserTool",
-  description: "Opens the running Harper app in the user's browser.",
-  parameters: ToolParameters13,
-  async execute() {
-    try {
-      if (alreadyOpened) {
-        return `Browser is already open.`;
-      }
-      if (!harperProcess.running) {
-        return `Error: No Harper application is currently running.`;
-      }
-      const url = `http://localhost:${harperProcess.httpPort}/`;
-      const p = platform();
-      if (p === "darwin") {
-        spawn2("open", [url]);
-      } else if (p === "win32") {
-        spawn2("start", ["", url]);
-      } else {
-        spawn2("xdg-open", [url]);
-      }
-      alreadyOpened = true;
-      return `Successfully opened '${url}' in the browser.`;
-    } catch (error) {
-      return `Error opening browser: ${error}`;
-    }
-  }
-});
-
 // tools/harper/readHarperLogsTool.ts
-import { tool as tool27 } from "@openai/agents";
-import { z as z27 } from "zod";
-var ToolParameters14 = z27.object({});
-var readHarperLogsTool = tool27({
-  name: "readHarperLogsTool",
+import { tool as tool35 } from "@openai/agents";
+import { z as z35 } from "zod";
+var ToolParameters22 = z35.object({});
+var readHarperLogsTool = tool35({
+  name: "read_harper_logs",
   description: "Reads the most recent console logs of a started Harper app and clears them so that subsequent reads will only show new logs.",
-  parameters: ToolParameters14,
+  parameters: ToolParameters22,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
     }
     try {
-      const logs = harperProcess.getAndClearLogs();
-      return logs || "No logs available yet.";
+      const logs2 = harperProcess.getAndClearLogs();
+      return logs2 || "No logs available yet.";
     } catch (error) {
       return `Error reading Harper application logs: ${error}`;
     }
@@ -2061,10 +2309,10 @@ var readHarperLogsTool = tool27({
 });
 
 // tools/harper/startHarperTool.ts
-import { tool as tool28 } from "@openai/agents";
+import { tool as tool36 } from "@openai/agents";
 import { existsSync as existsSync7 } from "fs";
 import { basename, resolve } from "path";
-import { z as z28 } from "zod";
+import { z as z36 } from "zod";
 
 // utils/promises/sleep.ts
 function sleep(ms) {
@@ -2072,13 +2320,13 @@ function sleep(ms) {
 }
 
 // tools/harper/startHarperTool.ts
-var ToolParameters15 = z28.object({
-  directoryName: z28.string().describe("The name of the directory that the Harper app is in.")
+var ToolParameters23 = z36.object({
+  directoryName: z36.string().describe("The name of the directory that the Harper app is in.")
 });
-var startHarperTool = tool28({
-  name: "startHarperTool",
-  description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, openHarperInBrowserTool, etc).",
-  parameters: ToolParameters15,
+var startHarperTool = tool36({
+  name: "start_harper",
+  description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, etc).",
+  parameters: ToolParameters23,
   async execute({ directoryName }) {
     if (isIgnored(directoryName)) {
       return `Error: Target directory ${directoryName} is restricted by .aiignore`;
@@ -2097,9 +2345,9 @@ var startHarperTool = tool28({
       }
       harperProcess.start(effectiveDirectory);
       await sleep(5e3);
-      const logs = harperProcess.getAndClearLogs();
+      const logs2 = harperProcess.getAndClearLogs();
       return `Successfully started Harper application with auto-reload in '${effectiveDirectory}' with initial logs:
-${logs}`;
+${logs2}`;
     } catch (error) {
       return `Error: failed to start Harper application: ${error}`;
     }
@@ -2107,13 +2355,13 @@ ${logs}`;
 });
 
 // tools/harper/stopHarperTool.ts
-import { tool as tool29 } from "@openai/agents";
-import { z as z29 } from "zod";
-var ToolParameters16 = z29.object({});
-var stopHarperTool = tool29({
-  name: "stopHarperTool",
+import { tool as tool37 } from "@openai/agents";
+import { z as z37 } from "zod";
+var ToolParameters24 = z37.object({});
+var stopHarperTool = tool37({
+  name: "stop_harper",
   description: "Stops all previously started Harper app background process.",
-  parameters: ToolParameters16,
+  parameters: ToolParameters24,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
@@ -2130,6 +2378,15 @@ var stopHarperTool = tool29({
 // tools/factory.ts
 function createTools() {
   return [
+    browserClickTool,
+    browserCloseTool,
+    browserEvaluateTool,
+    browserGetContentTool,
+    browserGetLogsTool,
+    browserIsElementPresentTool,
+    browserNavigateTool,
+    browserScreenshotTool,
+    browserTypeTool,
     changeCwdTool,
     checkHarperStatusTool,
     codeInterpreterTool,
@@ -2149,7 +2406,6 @@ function createTools() {
     gitStatusTool,
     gitWorkspaceTool,
     hitHarperAPITool,
-    openHarperInBrowserTool,
     readDirTool,
     readFileTool,
     readHarperLogsTool,
@@ -2164,7 +2420,7 @@ function createTools() {
 
 // utils/package/checkForUpdate.ts
 import chalk10 from "chalk";
-import spawn3 from "cross-spawn";
+import spawn2 from "cross-spawn";
 
 // utils/package/getLatestVersion.ts
 async function getLatestVersion(packageName) {
@@ -2224,7 +2480,7 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
 `);
       let isGlobal = false;
       try {
-        const globalRootResult = spawn3.sync("npm", ["root", "-g"], {
+        const globalRootResult = spawn2.sync("npm", ["root", "-g"], {
           encoding: "utf8"
         });
         const globalRoot = globalRootResult.stdout?.trim();
@@ -2234,15 +2490,15 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
       } catch {
       }
       if (isGlobal) {
-        spawn3.sync("npm", ["install", "-g", `${packageName}@latest`], {
+        spawn2.sync("npm", ["install", "-g", `${packageName}@latest`], {
           stdio: "inherit"
         });
-        const result2 = spawn3.sync("harper-agent", process.argv.slice(2), {
+        const result2 = spawn2.sync("harper-agent", process.argv.slice(2), {
           stdio: "inherit"
         });
         process.exit(result2.status ?? 0);
       }
-      const lsResult = spawn3.sync("npm", ["cache", "npx", "ls", packageName], {
+      const lsResult = spawn2.sync("npm", ["cache", "npx", "ls", packageName], {
         encoding: "utf8"
       });
       if (lsResult.stdout) {
@@ -2251,12 +2507,12 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
           return pkgPart && pkgPart.trim().startsWith(`${packageName}@`);
         }).map((line) => line.split(":")[0].trim());
         if (keys.length > 0) {
-          spawn3.sync("npm", ["cache", "npx", "rm", ...keys], {
+          spawn2.sync("npm", ["cache", "npx", "rm", ...keys], {
             stdio: "inherit"
           });
         }
       }
-      const result = spawn3.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], {
+      const result = spawn2.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], {
         stdio: "inherit"
       });
       process.exit(result.status ?? 0);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@harperfast/agent",
 	"description": "AI to help you with Harper app management",
-	"version": "0.12.1",
+	"version": "0.13.1",
 	"main": "dist/agent.js",
 	"repository": "github:HarperFast/harper-agent",
 	"bugs": {
@@ -9,9 +9,9 @@
 	},
 	"homepage": "https://github.com/harperfast",
 	"scripts": {
-		"dev": "tsup agent.ts --format esm --clean --dts --watch",
+		"dev": "tsup agent.ts --format esm --clean --dts --watch --external puppeteer",
 		"link": "npm run build && npm link",
-		"build": "tsup agent.ts --format esm --clean --dts",
+		"build": "tsup agent.ts --format esm --clean --dts --external puppeteer",
 		"commitlint": "commitlint --edit",
 		"start": "node ./dist/agent.js",
 		"lint": "oxlint --format stylish .",
@@ -42,19 +42,22 @@
 	"license": "None",
 	"type": "module",
 	"dependencies": {
-		"@ai-sdk/anthropic": "^3.0.36",
-		"@ai-sdk/google": "^3.0.20",
-		"@ai-sdk/openai": "^3.0.25",
-		"@openai/agents": "^0.4.5",
-		"@openai/agents-extensions": "^0.4.5",
-		"ai": "^6.0.69",
+		"@ai-sdk/anthropic": "^3.0.41",
+		"@ai-sdk/google": "^3.0.24",
+		"@ai-sdk/openai": "^3.0.26",
+		"@openai/agents": "^0.4.6",
+		"@openai/agents-extensions": "^0.4.6",
+		"ai": "^6.0.79",
 		"chalk": "^5.6.2",
-		"create-harper": "^0.12.0",
+		"create-harper": "^0.12.4",
 		"cross-spawn": "^7.0.6",
-		"dotenv": "^17.2.3",
-		"ollama-ai-provider-v2": "^3.0.3",
+		"dotenv": "^17.2.4",
+		"ollama-ai-provider-v2": "^3.3.0",
 		"zod": "^4.3.6"
 	},
+	"optionalDependencies": {
+		"puppeteer": "^24.37.2"
+	},
 	"devDependencies": {
 		"@commitlint/cli": "^20.4.1",
 		"@commitlint/config-conventional": "^20.4.1",
@@ -69,7 +72,7 @@
 		"conventional-changelog-conventionalcommits": "^9.1.0",
 		"dprint": "^0.51.1",
 		"express": "^5.2.1",
-		"harperdb": "^4.7.17",
+		"harperdb": "^4.7.19",
 		"hono": "^4.11.9",
 		"husky": "^9.1.7",
 		"oxlint": "^1.43.0",