@intuned/browser-use-dev 0.0.0-stage → 0.1.2-dev.0

package/dist/browser-use/tools.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RESULT_TOOL_NAME = exports.NOT_EXECUTED_ERROR = exports.JAVASCRIPT_TOOL_NAME = exports.ActionSequencer = void 0;
+exports.buildTools = buildTools;
+var _ai = require("ai");
+var _ajv = _interopRequireDefault(require("ajv"));
+var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
+var _Logger = require("../common/Logger");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const RESULT_TOOL_NAME = exports.RESULT_TOOL_NAME = "submit_result";
+const JAVASCRIPT_TOOL_NAME = exports.JAVASCRIPT_TOOL_NAME = "execute_javascript";
+const BUILT_IN_TOOL_NAMES = new Set(["click", "double_click", "scroll", "type", "keypress", "wait", "move", "drag", "clear_field", "fill_field", "list_tabs", "screenshot"]);
+const AUTO_SCREENSHOT_TOOLS = new Set(["scroll", "wait"]);
+const pointProps = {
+  x: {
+    type: "number",
+    description: "X coordinate (CSS px)"
+  },
+  y: {
+    type: "number",
+    description: "Y coordinate (CSS px)"
+  }
+};
+const SCROLL_TOOL_DESCRIPTION = ["Scroll the screen in a direction by a number of scroll units, slowly and", "in steps so lazy-loaded content renders instead of being skipped. Pass", "(x, y) to scroll the container under that point (dialog bodies, inner", "panes); otherwise the current mouse position is used. A screenshot is", "taken automatically afterwards. DO NOT use PageUp/PageDown to scroll.", "", "One full page is exactly 8 scroll units high (for the main viewport;", "inner containers depend on their own size).", "- scroll_amount=7 (default mode): explore new pages — scrolls almost a", "  full page while keeping some overlap with the previous view.", "- scroll_amount=1-3 (precision mode): fine-tune position for a specific", "  element or navigate within a small content area.", "- scroll_amount=8+ (speed mode): rapidly traverse long, repetitive pages;", "  scroll back if you overshoot.", "Tip: clear out any modals/popups before scrolling so your vision is clear."].join("\n");
+const toScreenshotModelOutput = output => ({
+  type: "content",
+  value: [{
+    type: "text",
+    text: output.text
+  }, ...(output.screenshot ? [{
+    type: "media",
+    data: output.screenshot,
+    mediaType: "image/png"
+  }] : [])]
+});
+const NOT_EXECUTED_ERROR = exports.NOT_EXECUTED_ERROR = "Not executed: an earlier action in this turn failed. Look at the new screenshot and decide again.";
+class ActionSequencer {
+  tail = Promise.resolve();
+  pending = 0;
+  failed = false;
+  get queued() {
+    return this.pending;
+  }
+  failRemaining() {
+    this.failed = true;
+  }
+  run(fn, {
+    evenAfterFailure = false
+  } = {}) {
+    this.pending += 1;
+    const result = this.tail.then(async () => {
+      if (this.failed && !evenAfterFailure) throw new Error(NOT_EXECUTED_ERROR);
+      try {
+        return await fn();
+      } catch (error) {
+        this.failed = true;
+        throw error;
+      }
+    });
+    this.tail = result.then(() => undefined, () => undefined).then(() => {
+      this.pending -= 1;
+      if (this.pending === 0) this.failed = false;
+    });
+    return result;
+  }
+}
+exports.ActionSequencer = ActionSequencer;
+function actionTool(name, description, parameters, run, computer, sequencer) {
+  const attempt = async args => {
+    try {
+      return {
+        text: await run(args),
+        failed: false
+      };
+    } catch (e) {
+      sequencer.failRemaining();
+      return {
+        text: `Error: ${e instanceof Error ? e.message : String(e)}`,
+        failed: true
+      };
+    }
+  };
+  if (!AUTO_SCREENSHOT_TOOLS.has(name)) {
+    return (0, _ai.tool)({
+      description,
+      inputSchema: (0, _ai.jsonSchema)(parameters),
+      execute: async args => sequencer.run(async () => (await attempt(args)).text)
+    });
+  }
+  return (0, _ai.tool)({
+    description,
+    inputSchema: (0, _ai.jsonSchema)(parameters),
+    execute: async args => sequencer.run(async () => {
+      const {
+        text,
+        failed
+      } = await attempt(args);
+      return failed ? {
+        text
+      } : {
+        text,
+        screenshot: await computer.screenshot()
+      };
+    }),
+    toModelOutput: toScreenshotModelOutput
+  });
+}
+function buildTools(opts) {
+  const {
+    computer,
+    extraTools,
+    outputSchema,
+    onResultCaptured,
+    logSteps = true,
+    enableJavaScriptTool = false
+  } = opts;
+  const sequencer = new ActionSequencer();
+  const tools = {
+    click: actionTool("click", "Click at (x, y). Use click_count 2/3 for double/triple left clicks. " + "Use button 'back'/'forward' for browser navigation, 'wheel' for a " + "scroll click. Downloads and popup tabs triggered by the click are " + "detected and reported in the result.", {
+      type: "object",
+      properties: {
+        ...pointProps,
+        button: {
+          type: "string",
+          enum: ["left", "right", "middle", "back", "forward", "wheel"],
+          description: "Defaults to 'left'."
+        },
+        click_count: {
+          type: "number",
+          enum: [1, 2, 3],
+          description: "Number of clicks (left button only). Defaults to 1."
+        }
+      },
+      required: ["x", "y"],
+      additionalProperties: false
+    }, args => computer.click(args), computer, sequencer),
+    double_click: actionTool("double_click", "Double-click at (x, y).", {
+      type: "object",
+      properties: pointProps,
+      required: ["x", "y"],
+      additionalProperties: false
+    }, args => computer.double_click(args), computer, sequencer),
+    scroll: actionTool("scroll", SCROLL_TOOL_DESCRIPTION, {
+      type: "object",
+      properties: {
+        ...pointProps,
+        scroll_direction: {
+          type: "string",
+          enum: ["up", "down", "left", "right"],
+          description: "The direction to scroll the screen."
+        },
+        scroll_amount: {
+          type: "number",
+          description: "The number of scroll units (8 units ≈ one page)."
+        }
+      },
+      required: ["scroll_direction", "scroll_amount"],
+      additionalProperties: false
+    }, args => computer.scroll(args), computer, sequencer),
+    type: actionTool("type", "Type text at the current focus/cursor position, after whatever is already there. " + "Click the target field first. To replace a field's value use fill_field instead.", {
+      type: "object",
+      properties: {
+        text: {
+          type: "string"
+        }
+      },
+      required: ["text"],
+      additionalProperties: false
+    }, args => computer.type(args), computer, sequencer),
+    keypress: actionTool("keypress", "Press a key combination (e.g. ['ctrl', 'a']). Modifiers are held while " + "the final key is pressed, then released. 'cmd' is the platform's " + "primary shortcut modifier (Cmd on macOS, Ctrl elsewhere), so ['cmd', 'a'] " + "selects all everywhere. A single 'Home'/'End' is converted into a slow scroll to " + "the top/bottom so lazy-loaded content still renders.", {
+      type: "object",
+      properties: {
+        keys: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["keys"],
+      additionalProperties: false
+    }, args => computer.keypress(args), computer, sequencer),
+    wait: actionTool("wait", "Wait for `ms` milliseconds (default 1000) — e.g. to let an animation or a lazy-loaded section finish. " + "Returns a screenshot taken after the pause, so no separate screenshot call is needed.", {
+      type: "object",
+      properties: {
+        ms: {
+          type: "number"
+        }
+      },
+      additionalProperties: false
+    }, args => computer.wait(args), computer, sequencer),
+    move: actionTool("move", "Move the mouse to (x, y) without clicking — e.g. to trigger a hover effect.", {
+      type: "object",
+      properties: pointProps,
+      required: ["x", "y"],
+      additionalProperties: false
+    }, args => computer.move(args), computer, sequencer),
+    drag: actionTool("drag", "Drag the mouse along a path of points, pressed down for the whole path.", {
+      type: "object",
+      properties: {
+        path: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: pointProps,
+            required: ["x", "y"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    }, args => computer.drag(args), computer, sequencer),
+    clear_field: actionTool("clear_field", "Clear a text input: click the field at (x, y), select all its text, and delete it. " + "Use this instead of pressing Backspace repeatedly. The result says whether the field is empty afterwards.", {
+      type: "object",
+      properties: pointProps,
+      required: ["x", "y"],
+      additionalProperties: false
+    }, args => computer.clear_field(args), computer, sequencer),
+    fill_field: actionTool("fill_field", "Set a text field's value in one step: click the field at (x, y), clear whatever it holds, " + "and type `text`. Prefer this over click + clear_field + type. The result reports the value " + "the field holds afterwards, so you can see if the page reformatted it.", {
+      type: "object",
+      properties: {
+        ...pointProps,
+        text: {
+          type: "string"
+        }
+      },
+      required: ["x", "y", "text"],
+      additionalProperties: false
+    }, args => computer.fill_field(args), computer, sequencer),
+    screenshot: (0, _ai.tool)({
+      description: "Take a screenshot of the current page. Call it at the end of a batch of actions, in the " + "same response, to see their result. scroll and wait already return a screenshot.",
+      inputSchema: (0, _ai.jsonSchema)({
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }),
+      execute: async () => sequencer.run(async () => ({
+        text: `CURRENT URL: ${computer.url()}`,
+        screenshot: await computer.screenshot()
+      }), {
+        evenAfterFailure: true
+      }),
+      toModelOutput: toScreenshotModelOutput
+    }),
+    list_tabs: (0, _ai.tool)({
+      description: "List all currently open browser tabs (index, url, title, and is_current " + "for the tab you are acting on). Use this to check whether a popup tab " + "has opened — do NOT use keyboard shortcuts to hunt for tabs.",
+      inputSchema: (0, _ai.jsonSchema)({
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }),
+      execute: async () => computer.list_tabs()
+    })
+  };
+  if (enableJavaScriptTool) {
+    tools[JAVASCRIPT_TOOL_NAME] = (0, _ai.tool)({
+      description: "Execute arbitrary JavaScript in the page. `code` is the body of an " + "async function — use `return <value>` to get a result back, and " + "`await` for async work. Browser events the code triggers (file " + "downloads, popup tabs) are reported in the result; call screenshot " + "if you need to see the page afterwards. An escape hatch for cases " + "the standard actions can't reach — prefer click/type/scroll when " + "they suffice.",
+      inputSchema: (0, _ai.jsonSchema)({
+        type: "object",
+        properties: {
+          code: {
+            type: "string"
+          }
+        },
+        required: ["code"],
+        additionalProperties: false
+      }),
+      execute: async ({
+        code
+      }) => sequencer.run(async () => {
+        let value;
+        let events = [];
+        try {
+          ({
+            value,
+            events
+          } = await computer.executeJavascript(code));
+        } catch (e) {
+          throw new Error(`JavaScript execution failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const valueText = value === undefined ? "undefined" : typeof value === "string" ? value : JSON.stringify(value);
+        return events.length > 0 ? `${valueText}\nEvents:\n${events.join("\n")}` : valueText;
+      })
+    });
+  }
+  for (const extra of extraTools ?? []) {
+    if (tools[extra.name] || extra.name === RESULT_TOOL_NAME || extra.name === JAVASCRIPT_TOOL_NAME) {
+      throw new Error(BUILT_IN_TOOL_NAMES.has(extra.name) ? `browser-use: tool name "${extra.name}" conflicts with a built-in tool` : extra.name === RESULT_TOOL_NAME ? `browser-use: tool name "${RESULT_TOOL_NAME}" is reserved for outputSchema results` : extra.name === JAVASCRIPT_TOOL_NAME ? `browser-use: tool name "${JAVASCRIPT_TOOL_NAME}" is reserved for the JavaScript execution tool` : `browser-use: duplicate tool name "${extra.name}" in tools option`);
+    }
+    tools[extra.name] = (0, _ai.tool)({
+      description: extra.description,
+      inputSchema: (0, _ai.jsonSchema)(extra.parameters),
+      execute: async args => sequencer.run(async () => {
+        if (logSteps) {
+          const argsText = args && Object.keys(args).length > 0 ? JSON.stringify(args) : "";
+          _Logger.logger.info(`[browser-use] tool: ${extra.name}(${argsText})`);
+        }
+        return extra.handler(args);
+      })
+    });
+  }
+  if (outputSchema) {
+    let validate;
+    try {
+      const ajv = new _ajv.default({
+        allErrors: true,
+        strict: false
+      });
+      (0, _ajvFormats.default)(ajv);
+      validate = ajv.compile(outputSchema);
+    } catch (e) {
+      throw new Error(`browser-use: invalid outputSchema: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    tools[RESULT_TOOL_NAME] = (0, _ai.tool)({
+      description: "Submit the FINAL structured result of the task. Call this exactly " + "once, when the task is complete, with values matching the schema.",
+      inputSchema: (0, _ai.jsonSchema)(outputSchema),
+      execute: async args => {
+        if (!validate(args)) {
+          const errors = (validate.errors ?? []).map(err => {
+            const details = err.params && Object.keys(err.params).length > 0 ? ` (${JSON.stringify(err.params)})` : "";
+            return `${err.instancePath || "result"} ${err.message}${details}`;
+          }).join("; ");
+          const message = `the submitted result does not match the required schema: ${errors}. ` + `Fix the result and call ${RESULT_TOOL_NAME} again.`;
+          if (logSteps) _Logger.logger.warn(`[browser-use] rejected structured result: ${message}`);
+          throw new Error(message);
+        }
+        onResultCaptured(args);
+        if (logSteps) _Logger.logger.info(`[browser-use] structured result submitted: ${JSON.stringify(args)}`);
+        return "success";
+      }
+    });
+  }
+  return tools;
+}

package/dist/common/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    const {
+      level,
+      timestamp,
+      message,
+      meta
+    } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+    if (meta === undefined) {
+      process.stderr.write(`${format(date)} [@intuned/browser-use][${levelColor(level)}] ${message}\n`);
+    } else {
+      process.stderr.write(`${format(date)} [@intuned/browser-use][${levelColor(level)}] ${message} ${format(meta)}\n`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/dist/common/Logger/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/common/aiGateway.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createProviderInstance = createProviderInstance;
+exports.detectProvider = detectProvider;
+var _anthropic = require("@ai-sdk/anthropic");
+var _openai = require("@ai-sdk/openai");
+var _google = require("@ai-sdk/google");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function detectProvider(model) {
+  const m = model.toLowerCase();
+  if (m.startsWith("claude")) return "anthropic";
+  if (m.startsWith("gemini")) return "google";
+  if (["gpt", "o1", "o3", "o4"].some(p => m.startsWith(p))) return "openai";
+  throw new Error(`browser-use: unsupported model provider for "${model}"`);
+}
+const ENV_KEYS = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GOOGLE_API_KEY"
+};
+async function resolveGatewayConfig() {
+  try {
+    const runtime = await Promise.resolve().then(() => _interopRequireWildcard(require("@intuned/runtime")));
+    const getAiGatewayConfig = runtime.getAiGatewayConfig;
+    if (typeof getAiGatewayConfig !== "function") {
+      throw new Error("@intuned/runtime does not export getAiGatewayConfig. Please upgrade to a newer version.");
+    }
+    return getAiGatewayConfig();
+  } catch (error) {
+    throw new Error("No API key provided and not running in Intuned context. " + "Please provide an API key or ensure @intuned/runtime is installed and you're running within an Intuned workflow. " + `Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function createProviderInstance(options) {
+  const {
+    model
+  } = options;
+  const provider = detectProvider(model);
+  const apiKey = options.apiKey ?? process.env[ENV_KEYS[provider]];
+  if (apiKey) {
+    switch (provider) {
+      case "openai":
+        return (0, _openai.createOpenAI)({
+          apiKey
+        });
+      case "anthropic":
+        return (0, _anthropic.createAnthropic)({
+          apiKey
+        });
+      case "google":
+        return (0, _google.createGoogleGenerativeAI)({
+          apiKey
+        });
+    }
+  }
+  const gw = await resolveGatewayConfig();
+  switch (provider) {
+    case "openai":
+      return (0, _openai.createOpenAI)({
+        apiKey: gw.apiKey,
+        baseURL: gw.baseUrl
+      });
+    case "anthropic":
+      return (0, _anthropic.createAnthropic)({
+        apiKey: gw.apiKey,
+        baseURL: `${gw.baseUrl}/v1`
+      });
+    case "google":
+      return (0, _google.createGoogleGenerativeAI)({
+        apiKey: gw.apiKey,
+        baseURL: gw.baseUrl
+      });
+  }
+}

package/dist/common/networkSettled.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withNetworkSettled = withNetworkSettled;
+var _Logger = require("./Logger");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+let cachedHelper;
+async function loadWithNetworkSettledWait() {
+  if (cachedHelper !== undefined) return cachedHelper;
+  try {
+    const mod = await Promise.resolve().then(() => _interopRequireWildcard(require("@intuned/browser")));
+    cachedHelper = mod.withNetworkSettledWait ?? null;
+  } catch {
+    cachedHelper = null;
+  }
+  if (cachedHelper === null) {
+    _Logger.logger.debug("[browser-use] @intuned/browser is not installed — falling back to Playwright networkidle waiting after actions");
+  }
+  return cachedHelper;
+}
+async function withNetworkSettled(fn, options) {
+  const helper = await loadWithNetworkSettledWait();
+  if (helper) return helper(fn, options);
+  const result = await fn(options.page);
+  await options.page.waitForLoadState("networkidle", {
+    timeout: options.timeoutInMs
+  }).catch(() => undefined);
+  return result;
+}

package/dist/common/parseCostInCents.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseCostInCents = parseCostInCents;
+function parseCostInCents(headerValue) {
+  if (headerValue == null) return 0;
+  const raw = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+  if (typeof raw !== "string") return 0;
+  const cost = parseFloat(raw);
+  return Number.isFinite(cost) ? cost : 0;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { executeTask, BrowserUseError } from "./browser-use/export";
+
+export type {
+  ExecuteTaskOptions,
+  BrowserUseTurnResult,
+  BrowserUseFunctionTool,
+  BrowserUseFrame,
+} from "./browser-use/export";

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _browserUse = require("./browser-use");
+Object.keys(_browserUse).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _browserUse[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _browserUse[key];
+    }
+  });
+});

package/dist/types/intuned-runtime.d.ts

@@ -0,0 +1,6 @@
+// Type declarations for the optional peer dependency @intuned/runtime.
+// When the package is installed, its actual types are used instead.
+declare module "@intuned/runtime" {
+  export function getExecutionContext(): unknown;
+  export function getAiGatewayConfig(): { baseUrl: string; apiKey: string };
+}

package/package.json

@@ -1,6 +1,85 @@
 {
   "name": "@intuned/browser-use-dev",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.2-dev.0",
+  "description": "Intuned SDK browser-use agent: drive a Playwright page with a vision-capable model",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "browser-use": [
+        "./dist/browser-use/index.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./browser-use": "./dist/browser-use/index.js"
+  },
+  "author": "Intuned Team",
+  "license": "Elastic-2.0",
+  "packageManager": "yarn@4.12.0",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && yarn copy-dts && babel src --out-dir dist --extensions '.ts' --ignore 'src/**/*.d.ts' && node ../scripts/ensure-index-types.js browser-use",
+    "test": "vitest run",
+    "test:dev": "vitest",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "fix": "eslint . --fix",
+    "copy-dts": "copyfiles -u 1 \"src/**/*.d.ts\" dist"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "2.0.91",
+    "@ai-sdk/google": "2.0.85",
+    "@ai-sdk/openai": "2.0.116",
+    "ai": "5.0.222",
+    "ajv": "8.18.0",
+    "ajv-formats": "2.1.1",
+    "chalk": "4.1.2",
+    "dotenv": "^16.3.1",
+    "tslib": "2.6.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.4",
+    "@babel/core": "^7.23.7",
+    "@babel/plugin-transform-export-namespace-from": "^7.24.1",
+    "@babel/preset-env": "^7.23.7",
+    "@babel/preset-typescript": "^7.23.3",
+    "@intuned/browser": "0.1.19",
+    "@types/node": "^24.1.0",
+    "@typescript-eslint/eslint-plugin": "^5.47.1",
+    "@typescript-eslint/parser": "^7.5.0",
+    "copyfiles": "2.4.1",
+    "eslint": "7.32.0",
+    "eslint-plugin-deprecation": "^1.3.3",
+    "eslint-plugin-prettier": "^4.2.1",
+    "playwright": ">=1.46.0 <1.57",
+    "prettier": "^2.8.8",
+    "typescript": "5.4.4",
+    "vite": "^7.3.7",
+    "vitest": "^4.1.11"
+  },
+  "peerDependencies": {
+    "@intuned/browser": "*",
+    "@intuned/runtime": "*",
+    "playwright": ">=1.46.0 <1.62"
+  },
+  "peerDependenciesMeta": {
+    "@intuned/browser": {
+      "optional": true
+    },
+    "@intuned/runtime": {
+      "optional": true
+    }
+  },
+  "resolutions": {
+    "js-yaml": "3.15.2",
+    "fast-uri": "3.1.8",
+    "uuid": "11.1.1",
+    "nanoid": "3.3.18",
+    "esbuild": "0.28.2",
+    "vite": "7.3.7"
+  }
 }