@lydia-agent/core 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -33,6 +33,8 @@ __export(index_exports, {
   Agent: () => Agent,
   AnthropicProvider: () => AnthropicProvider,
   BasicStrategyGate: () => BasicStrategyGate,
+  BrowserAutomationManager: () => BrowserAutomationManager,
+  BrowserServer: () => BrowserServer,
   COMPUTER_USE_ERROR_CODES: () => COMPUTER_USE_ERROR_CODES,
   ComputerUseSessionOrchestrator: () => ComputerUseSessionOrchestrator,
   ConfigLoader: () => ConfigLoader,
@@ -105,6 +107,8 @@ __export(index_exports, {
   ToolResultContentSchema: () => ToolResultContentSchema,
   ToolUseContentSchema: () => ToolUseContentSchema,
   assessRisk: () => assessRisk,
+  createBrowserToolError: () => createBrowserToolError,
+  createDefaultBrowserRuntimeConfig: () => createDefaultBrowserRuntimeConfig,
   createLLMFromConfig: () => createLLMFromConfig,
   getSkillContent: () => getSkillContent,
   hasContent: () => hasContent,
@@ -112,12 +116,13 @@ __export(index_exports, {
   isComputerUseErrorCode: () => isComputerUseErrorCode,
   isDynamicSkill: () => isDynamicSkill,
   listCanonicalComputerUseActions: () => listCanonicalComputerUseActions,
+  normalizeBrowserRuntimeError: () => normalizeBrowserRuntimeError,
   normalizeComputerUseError: () => normalizeComputerUseError,
   resolveCanonicalComputerUseToolName: () => resolveCanonicalComputerUseToolName
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_post_ace0071d99dc9ba490e13d092e298186/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -1519,6 +1524,17 @@ var ConfigSchema = import_zod5.z.object({
     checkpointTtlHours: import_zod5.z.number().default(24),
     observationFrameTtlHours: import_zod5.z.number().default(24 * 7)
   }).default({}),
+  browser: import_zod5.z.object({
+    enabled: import_zod5.z.boolean().default(true),
+    mode: import_zod5.z.enum(["auto", "cdp", "headless", "remote"]).default("auto"),
+    cdpPort: import_zod5.z.number().int().positive().default(9222),
+    remoteUrl: import_zod5.z.string().default(""),
+    chromePath: import_zod5.z.string().default(""),
+    launchHostBrowser: import_zod5.z.boolean().default(false),
+    navigationTimeoutMs: import_zod5.z.number().positive().default(3e4),
+    actionTimeoutMs: import_zod5.z.number().positive().default(1e4),
+    downloadDir: import_zod5.z.string().default("")
+  }).default({}),
   skills: import_zod5.z.object({
     /** Maximum number of skills whose full content is injected into the prompt (default: 3) */
     matchTopK: import_zod5.z.number().default(3),
@@ -1582,6 +1598,10 @@ var ConfigLoader = class {
         ...current.memory || {},
         ...partial.memory
       },
+      browser: {
+        ...current.browser || {},
+        ...partial.browser
+      },
       skills: {
         ...current.skills || {},
         ...partial.skills
@@ -3412,8 +3432,8 @@ var InteractionServer = class extends import_node_events3.EventEmitter {
         prompt: args.prompt
       };
       this.emit("request", interaction);
-      const responseText = await new Promise((resolve6) => {
-        this.pendingInteractions.set(id, resolve6);
+      const responseText = await new Promise((resolve7) => {
+        this.pendingInteractions.set(id, resolve7);
       });
       return {
         content: [{ type: "text", text: responseText }]
@@ -3432,6 +3452,616 @@ var InteractionServer = class extends import_node_events3.EventEmitter {
   }
 };
 
+// src/mcp/servers/browser.ts
+var import_server6 = require("@modelcontextprotocol/sdk/server/index.js");
+var import_types8 = require("@modelcontextprotocol/sdk/types.js");
+
+// src/browser/manager.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
+var import_node_child_process2 = require("child_process");
+var import_playwright = require("playwright");
+function createBrowserToolError(code, message, retryable = true) {
+  const error = new Error(`${code}: ${message}`);
+  error.code = code;
+  error.retryable = retryable;
+  return error;
+}
+function createDefaultBrowserRuntimeConfig(partial = {}) {
+  return {
+    enabled: partial.enabled ?? true,
+    mode: partial.mode ?? "auto",
+    cdpPort: partial.cdpPort ?? 9222,
+    remoteUrl: partial.remoteUrl ?? "",
+    chromePath: partial.chromePath ?? "",
+    launchHostBrowser: partial.launchHostBrowser ?? false,
+    navigationTimeoutMs: partial.navigationTimeoutMs ?? 3e4,
+    actionTimeoutMs: partial.actionTimeoutMs ?? 1e4,
+    downloadDir: partial.downloadDir || (0, import_node_path2.join)(process.cwd(), ".lydia-artifacts", "browser-downloads")
+  };
+}
+var BrowserAutomationManager = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  browser = null;
+  resolvedMode = null;
+  attemptedHostLaunch = false;
+  constructor(config = {}) {
+    this.config = createDefaultBrowserRuntimeConfig(config);
+  }
+  getResolvedMode() {
+    return this.resolvedMode;
+  }
+  async navigate(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const response = await page.goto(args.url, {
+      waitUntil: args.waitUntil ?? "domcontentloaded",
+      timeout: args.timeoutMs ?? this.config.navigationTimeoutMs
+    });
+    return {
+      text: `Navigated to ${page.url()} (${await page.title() || "untitled"}) [mode=${this.getResolvedMode() || "unknown"} status=${response?.status() ?? "n/a"}]`,
+      metadata: {
+        url: page.url(),
+        title: await page.title(),
+        status: response?.status() ?? null,
+        mode: this.getResolvedMode()
+      }
+    };
+  }
+  async click(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const locator = page.locator(args.selector).first();
+    await locator.waitFor({ state: "visible", timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    await locator.click({ timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    return {
+      text: `Clicked ${args.selector} on ${page.url()}`,
+      metadata: { url: page.url(), selector: args.selector, mode: this.getResolvedMode() }
+    };
+  }
+  async type(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const locator = page.locator(args.selector).first();
+    await locator.waitFor({ state: "visible", timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    if (args.clearExisting !== false) {
+      await locator.fill("", { timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    }
+    await locator.fill(args.text, { timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    return {
+      text: `Typed into ${args.selector} on ${page.url()}`,
+      metadata: { url: page.url(), selector: args.selector, length: args.text.length }
+    };
+  }
+  async select(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const values = Array.isArray(args.value) ? args.value : [args.value];
+    await page.locator(args.selector).first().selectOption(values, {
+      timeout: args.timeoutMs ?? this.config.actionTimeoutMs
+    });
+    return {
+      text: `Selected ${values.join(", ")} in ${args.selector} on ${page.url()}`,
+      metadata: { url: page.url(), selector: args.selector, values }
+    };
+  }
+  async waitFor(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const state = args.state ?? "visible";
+    await page.locator(args.selector).first().waitFor({
+      state,
+      timeout: args.timeoutMs ?? this.config.actionTimeoutMs
+    });
+    return {
+      text: `Wait condition satisfied for ${args.selector} (${state}) on ${page.url()}`,
+      metadata: { url: page.url(), selector: args.selector, state }
+    };
+  }
+  async extractText(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const locator = page.locator(args.selector).first();
+    await locator.waitFor({ state: "attached", timeout: args.timeoutMs ?? this.config.actionTimeoutMs });
+    const text = (await locator.innerText({ timeout: args.timeoutMs ?? this.config.actionTimeoutMs })).trim();
+    return {
+      text: text || `[empty text at ${args.selector}]`,
+      metadata: { url: page.url(), selector: args.selector }
+    };
+  }
+  async screenshot(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const buffer = await page.screenshot({
+      fullPage: args.fullPage ?? true,
+      timeout: args.timeoutMs ?? this.config.navigationTimeoutMs,
+      type: "png"
+    });
+    return {
+      text: `Captured screenshot for ${page.url()} [mode=${this.getResolvedMode() || "unknown"}]`,
+      imageBase64: buffer.toString("base64"),
+      mediaType: "image/png",
+      metadata: { url: page.url(), fullPage: args.fullPage ?? true }
+    };
+  }
+  async download(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    if (!args.selector && !args.url) {
+      throw createBrowserToolError("DOWNLOAD_FAILED", 'Either "selector" or "url" is required.', false);
+    }
+    const timeout = args.timeoutMs ?? this.config.navigationTimeoutMs;
+    const downloadPromise = page.waitForEvent("download", { timeout });
+    if (args.selector) {
+      await page.locator(args.selector).first().click({ timeout });
+    } else if (args.url) {
+      await page.goto(args.url, { waitUntil: "commit", timeout });
+    }
+    const download = await downloadPromise;
+    const downloadPath = await this.saveDownload(download, args.saveAs);
+    return {
+      text: `Downloaded artifact to ${downloadPath}`,
+      downloadPath,
+      metadata: { url: page.url(), suggestedFilename: download.suggestedFilename() }
+    };
+  }
+  async upload(sessionId, args) {
+    const page = await this.getPage(sessionId);
+    const locator = page.locator(args.selector).first();
+    await locator.setInputFiles((0, import_node_path2.resolve)(args.path), {
+      timeout: args.timeoutMs ?? this.config.actionTimeoutMs
+    });
+    return {
+      text: `Uploaded ${(0, import_node_path2.resolve)(args.path)} into ${args.selector}`,
+      artifactPath: (0, import_node_path2.resolve)(args.path),
+      metadata: { url: page.url(), selector: args.selector, path: (0, import_node_path2.resolve)(args.path) }
+    };
+  }
+  async closeSession(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      return {
+        text: `Session ${sessionId} already closed`,
+        metadata: { sessionId, mode: this.getResolvedMode() }
+      };
+    }
+    try {
+      if (!state.page.isClosed()) {
+        await state.page.close();
+      }
+      if (state.ownsContext) {
+        await state.context.close();
+      }
+    } finally {
+      this.sessions.delete(sessionId);
+    }
+    return {
+      text: `Closed browser session ${sessionId}`,
+      metadata: { sessionId, mode: this.getResolvedMode() }
+    };
+  }
+  async dispose() {
+    const ids = Array.from(this.sessions.keys());
+    for (const sessionId of ids) {
+      await this.closeSession(sessionId);
+    }
+    if (this.browser) {
+      await this.browser.close();
+    }
+    this.browser = null;
+    this.resolvedMode = null;
+  }
+  async getPage(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing && !existing.page.isClosed()) {
+      return existing.page;
+    }
+    const browser = await this.ensureBrowser();
+    const mode = this.resolvedMode;
+    if (!mode) {
+      throw createBrowserToolError("CAPABILITY_UNAVAILABLE", "Browser mode could not be resolved.", false);
+    }
+    let context;
+    let ownsContext = true;
+    if (mode === "cdp") {
+      context = browser.contexts()[0] || await browser.newContext({ acceptDownloads: true });
+      ownsContext = false;
+    } else {
+      context = await browser.newContext({ acceptDownloads: true });
+    }
+    const page = await context.newPage();
+    const session = {
+      sessionId,
+      page,
+      context,
+      ownsContext
+    };
+    this.sessions.set(sessionId, session);
+    return page;
+  }
+  async ensureBrowser() {
+    if (!this.config.enabled) {
+      throw createBrowserToolError("CAPABILITY_UNAVAILABLE", "Browser automation is disabled in config.", false);
+    }
+    if (this.browser) return this.browser;
+    const desiredMode = this.config.mode;
+    if (desiredMode === "cdp") {
+      this.browser = await this.connectCdpOrThrow();
+      this.resolvedMode = "cdp";
+      return this.browser;
+    }
+    if (desiredMode === "remote") {
+      this.browser = await this.connectRemoteOrThrow();
+      this.resolvedMode = "remote";
+      return this.browser;
+    }
+    if (desiredMode === "headless") {
+      this.browser = await this.connectHeadless();
+      this.resolvedMode = "headless";
+      return this.browser;
+    }
+    try {
+      this.browser = await this.connectCdpOrThrow();
+      this.resolvedMode = "cdp";
+      return this.browser;
+    } catch {
+    }
+    if (this.config.remoteUrl) {
+      try {
+        this.browser = await this.connectRemoteOrThrow();
+        this.resolvedMode = "remote";
+        return this.browser;
+      } catch {
+      }
+    }
+    this.browser = await this.connectHeadless();
+    this.resolvedMode = "headless";
+    return this.browser;
+  }
+  async connectCdpOrThrow() {
+    const url = `http://127.0.0.1:${this.config.cdpPort}`;
+    const reachable = await this.isCdpReachable(url);
+    if (!reachable && this.config.launchHostBrowser && !this.attemptedHostLaunch) {
+      this.launchHostChrome();
+      this.attemptedHostLaunch = true;
+      await sleep(1500);
+    }
+    const reachableAfterLaunch = await this.isCdpReachable(url);
+    if (!reachableAfterLaunch) {
+      throw createBrowserToolError(
+        "CAPABILITY_UNAVAILABLE",
+        `CDP endpoint ${url} is not reachable.`,
+        false
+      );
+    }
+    return import_playwright.chromium.connectOverCDP(url);
+  }
+  async connectRemoteOrThrow() {
+    if (!this.config.remoteUrl) {
+      throw createBrowserToolError("CAPABILITY_UNAVAILABLE", "Remote browser URL is not configured.", false);
+    }
+    return import_playwright.chromium.connectOverCDP(this.config.remoteUrl);
+  }
+  async connectHeadless() {
+    return import_playwright.chromium.launch({
+      headless: true,
+      args: ["--disable-dev-shm-usage", "--no-sandbox"]
+    });
+  }
+  async isCdpReachable(baseUrl) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 1500);
+      try {
+        const response = await fetch(`${baseUrl}/json/version`, {
+          signal: controller.signal
+        });
+        return response.ok;
+      } finally {
+        clearTimeout(timeout);
+      }
+    } catch {
+      return false;
+    }
+  }
+  launchHostChrome() {
+    const binary = this.resolveChromeBinary();
+    if (!binary) {
+      throw createBrowserToolError(
+        "CAPABILITY_UNAVAILABLE",
+        "CDP launch requested but no Chrome executable could be resolved.",
+        false
+      );
+    }
+    const userDataDir = (0, import_node_path2.join)(process.cwd(), ".lydia-artifacts", "chrome-profile");
+    const args = [
+      `--remote-debugging-port=${this.config.cdpPort}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      `--user-data-dir=${userDataDir}`
+    ];
+    (0, import_node_child_process2.spawn)(binary, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    }).unref();
+  }
+  resolveChromeBinary() {
+    if (this.config.chromePath) {
+      return this.config.chromePath;
+    }
+    const os10 = (0, import_node_os2.platform)();
+    if (os10 === "win32") {
+      return "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe";
+    }
+    if (os10 === "darwin") {
+      return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+    }
+    return "google-chrome";
+  }
+  async saveDownload(download, requestedPath) {
+    const filename = requestedPath ? (0, import_node_path2.resolve)(requestedPath) : (0, import_node_path2.resolve)(this.config.downloadDir, `${Date.now().toString(36)}-${download.suggestedFilename()}`);
+    await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(filename), { recursive: true });
+    await download.saveAs(filename);
+    return filename;
+  }
+};
+function normalizeBrowserRuntimeError(error) {
+  if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    const message = error.message || "Unknown browser error";
+    const lowered = message.toLowerCase();
+    if (lowered.includes("timeout")) {
+      return createBrowserToolError("BROWSER_TIMEOUT", message, true);
+    }
+    if (lowered.includes("not found") || lowered.includes("waiting for locator")) {
+      return createBrowserToolError("ELEMENT_NOT_FOUND", message, true);
+    }
+    if (lowered.includes("not visible") || lowered.includes("not enabled") || lowered.includes("intercept")) {
+      return createBrowserToolError("ELEMENT_NOT_INTERACTABLE", message, true);
+    }
+    if (lowered.includes("net::") || lowered.includes("navigation")) {
+      return createBrowserToolError("NAVIGATION_BLOCKED", message, true);
+    }
+    if (lowered.includes("download")) {
+      return createBrowserToolError("DOWNLOAD_FAILED", message, true);
+    }
+    if (lowered.includes("upload") || lowered.includes("input files")) {
+      return createBrowserToolError("UPLOAD_FAILED", message, true);
+    }
+    if (lowered.includes("target page, context or browser has been closed")) {
+      return createBrowserToolError("SESSION_CLOSED", message, true);
+    }
+    if (lowered.includes("executable") || lowered.includes("playwright")) {
+      return createBrowserToolError("CAPABILITY_UNAVAILABLE", message, false);
+    }
+    return createBrowserToolError("UNKNOWN", message, true);
+  }
+  return createBrowserToolError("UNKNOWN", String(error), true);
+}
+function sleep(ms) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+
+// src/mcp/servers/browser.ts
+var SESSION_ARG = "__lydiaSessionId";
+var BrowserServer = class {
+  server;
+  runtime;
+  constructor(config = {}, runtime = new BrowserAutomationManager(createDefaultBrowserRuntimeConfig(config))) {
+    this.runtime = runtime;
+    this.server = new import_server6.Server(
+      {
+        name: "internal-browser",
+        version: "0.1.2"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  async closeSession(sessionId) {
+    if (!sessionId) return;
+    await this.runtime.closeSession(sessionId);
+  }
+  async dispose() {
+    await this.runtime.dispose();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(import_types8.ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "browser_navigate",
+          description: "Navigate the current browser session to a URL.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              url: { type: "string", description: "Destination URL" },
+              waitUntil: {
+                type: "string",
+                enum: ["load", "domcontentloaded", "networkidle", "commit"],
+                description: "Navigation completion condition"
+              },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["url"]
+          }
+        },
+        {
+          name: "browser_click",
+          description: "Click an element in the current page by selector.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector for the target element" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector"]
+          }
+        },
+        {
+          name: "browser_type",
+          description: "Type text into an element in the current page.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector for the target input" },
+              text: { type: "string", description: "Text to enter" },
+              clearExisting: { type: "boolean", description: "Clear existing value before typing" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector", "text"]
+          }
+        },
+        {
+          name: "browser_select",
+          description: "Select one or more values from a select element.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector for the select element" },
+              value: {
+                oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+                description: "Value or list of values to select"
+              },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector", "value"]
+          }
+        },
+        {
+          name: "browser_wait_for",
+          description: "Wait for a selector to reach a state.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector to wait for" },
+              state: {
+                type: "string",
+                enum: ["attached", "detached", "visible", "hidden"],
+                description: "Target element state"
+              },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector"]
+          }
+        },
+        {
+          name: "browser_extract_text",
+          description: "Extract visible text from an element.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector for the text source" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector"]
+          }
+        },
+        {
+          name: "browser_screenshot",
+          description: "Capture a screenshot of the current page.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              fullPage: { type: "boolean", description: "Capture the full page instead of only the viewport" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            }
+          }
+        },
+        {
+          name: "browser_download",
+          description: "Download a browser artifact from a URL or via a click action.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "Selector to click to trigger a download" },
+              url: { type: "string", description: "Direct download URL" },
+              saveAs: { type: "string", description: "Optional output path override" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            }
+          }
+        },
+        {
+          name: "browser_upload",
+          description: "Upload a local file into a file input element.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              selector: { type: "string", description: "CSS selector for the file input" },
+              path: { type: "string", description: "Absolute or relative local file path" },
+              timeoutMs: { type: "number", description: "Optional timeout override in milliseconds" }
+            },
+            required: ["selector", "path"]
+          }
+        },
+        {
+          name: "browser_close",
+          description: "Close the current Lydia browser session.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(import_types8.CallToolRequestSchema, async (request) => {
+      const rawArgs = request.params.arguments || {};
+      const sessionId = typeof rawArgs[SESSION_ARG] === "string" && rawArgs[SESSION_ARG] ? rawArgs[SESSION_ARG] : "default";
+      const args = Object.fromEntries(
+        Object.entries(rawArgs).filter(([key]) => key !== SESSION_ARG)
+      );
+      try {
+        switch (request.params.name) {
+          case "browser_navigate":
+            return this.ok(await this.runtime.navigate(sessionId, args));
+          case "browser_click":
+            return this.ok(await this.runtime.click(sessionId, args));
+          case "browser_type":
+            return this.ok(await this.runtime.type(sessionId, args));
+          case "browser_select":
+            return this.ok(await this.runtime.select(sessionId, args));
+          case "browser_wait_for":
+            return this.ok(await this.runtime.waitFor(sessionId, args));
+          case "browser_extract_text":
+            return this.ok(await this.runtime.extractText(sessionId, args));
+          case "browser_screenshot":
+            return this.ok(await this.runtime.screenshot(sessionId, args));
+          case "browser_download":
+            return this.ok(await this.runtime.download(sessionId, args));
+          case "browser_upload":
+            return this.ok(await this.runtime.upload(sessionId, args));
+          case "browser_close":
+            return this.ok(await this.runtime.closeSession(sessionId));
+          default:
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+      } catch (error) {
+        const normalized = normalizeBrowserRuntimeError(error);
+        return {
+          content: [{ type: "text", text: normalized.message }],
+          isError: true
+        };
+      }
+    });
+  }
+  ok(result) {
+    const content = [{ type: "text", text: result.text }];
+    if (result.imageBase64 && result.mediaType) {
+      content.push({
+        type: "image",
+        data: result.imageBase64,
+        mimeType: result.mediaType
+      });
+    }
+    return {
+      content,
+      artifactPath: result.artifactPath,
+      downloadPath: result.downloadPath,
+      metadata: result.metadata
+    };
+  }
+};
+
 // src/mcp/client.ts
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
@@ -3555,9 +4185,12 @@ var McpCanonicalCapabilityAdapter = class {
           blocks.push({ type: "text", text: contentBlock.text });
           continue;
         }
-        if (contentBlock?.type === "image" && contentBlock.source?.type === "base64" && typeof contentBlock.source.media_type === "string" && typeof contentBlock.source.data === "string") {
-          const mediaType = contentBlock.source.media_type;
-          const base64Data = contentBlock.source.data;
+        if (contentBlock?.type === "image") {
+          const mediaType = typeof contentBlock.source?.media_type === "string" ? contentBlock.source.media_type : typeof contentBlock.mimeType === "string" ? contentBlock.mimeType : void 0;
+          const base64Data = typeof contentBlock.source?.data === "string" ? contentBlock.source.data : typeof contentBlock.data === "string" ? contentBlock.data : void 0;
+          if (!mediaType || !base64Data) {
+            continue;
+          }
           const dataRef = base64Data.length <= this.maxInlineImageBase64Length ? `data:${mediaType};base64,${base64Data}` : `inline://image/${mediaType}/${base64Data.length}`;
           blocks.push({
             type: "image",
@@ -5606,6 +6239,7 @@ var Agent = class extends import_node_events5.EventEmitter {
   currentTaskCreatedAt;
   // Centralized built-in server descriptors keep MCP wiring declarative.
   builtinServerSpecs = [];
+  browserServer;
   options;
   computerUseAdapter;
   computerUseOrchestrator;
@@ -5705,6 +6339,13 @@ var Agent = class extends import_node_events5.EventEmitter {
       { id: "internal-fs", create: () => new FileSystemServer().server },
       { id: "internal-git", create: () => new GitServer().server }
     ];
+    if (config.browser?.enabled !== false) {
+      this.browserServer = new BrowserServer(config.browser);
+      this.builtinServerSpecs.push({
+        id: "internal-browser",
+        create: () => this.browserServer.server
+      });
+    }
     await this.connectBuiltinServers();
     await this.connectExternalMcpServers(config.mcpServers);
     this.isInitialized = true;
@@ -5938,6 +6579,7 @@ ${planGuidance}` : baseSystemPrompt;
     } catch {
     }
     if (this.computerUseSessionId) {
+      await this.closeBrowserAutomationSession(this.computerUseSessionId);
       const terminalCheckpoint = this.computerUseOrchestrator.endSession(this.computerUseSessionId);
       if (terminalCheckpoint) {
         this.memoryManager.upsertComputerUseSessionSummary({
@@ -6043,6 +6685,7 @@ ${planGuidance}` : baseSystemPrompt;
     } catch {
     }
     if (this.computerUseSessionId) {
+      await this.closeBrowserAutomationSession(this.computerUseSessionId);
       const terminalCheckpoint = this.computerUseOrchestrator.endSession(this.computerUseSessionId);
       if (terminalCheckpoint) {
         this.memoryManager.upsertComputerUseSessionSummary({
@@ -6627,7 +7270,10 @@ ${steps.join("\n")}`;
         action,
         adapter: this.computerUseAdapter,
         toolName,
-        invokeTool: async (resolvedToolName, resolvedArgs) => await this.mcpClientManager.callTool(resolvedToolName, resolvedArgs)
+        invokeTool: async (resolvedToolName, resolvedArgs) => await this.mcpClientManager.callTool(
+          resolvedToolName,
+          this.attachInternalBrowserSessionArg(resolvedToolName, sessionId, resolvedArgs)
+        )
       });
       this.memoryManager.recordObservationFrame(this.currentTaskId, dispatchResult.frame);
       this.memoryManager.upsertComputerUseSessionSummary({
@@ -6667,6 +7313,23 @@ ${steps.join("\n")}`;
     }
     return void 0;
   }
+  attachInternalBrowserSessionArg(toolName, sessionId, args) {
+    const toolInfo = this.mcpClientManager.getToolInfo(toolName);
+    if (!toolInfo || toolInfo.serverId !== "internal-browser") {
+      return args;
+    }
+    return {
+      ...args,
+      __lydiaSessionId: sessionId
+    };
+  }
+  async closeBrowserAutomationSession(sessionId) {
+    if (!sessionId || !this.browserServer) return;
+    try {
+      await this.browserServer.closeSession(sessionId);
+    } catch {
+    }
+  }
   inferComputerUseDomain(canonicalAction) {
     return canonicalAction.startsWith("desktop_") ? "desktop" : "browser";
   }
@@ -6709,13 +7372,18 @@ ${steps.join("\n")}`;
         normalized.push({ type: "text", text: block.text });
         continue;
       }
-      if (block?.type === "image" && block.source?.type === "base64" && typeof block.source.media_type === "string" && typeof block.source.data === "string") {
+      if (block?.type === "image") {
+        const mediaType = typeof block.source?.media_type === "string" ? block.source.media_type : typeof block.mimeType === "string" ? block.mimeType : void 0;
+        const data = typeof block.source?.data === "string" ? block.source.data : typeof block.data === "string" ? block.data : void 0;
+        if (!mediaType || !data) {
+          continue;
+        }
         normalized.push({
           type: "image",
           source: {
             type: "base64",
-            media_type: block.source.media_type,
-            data: block.source.data
+            media_type: mediaType,
+            data
           }
         });
       }
@@ -6829,7 +7497,7 @@ ${steps.join("\n")}`;
     return msg.includes("rate limit") || msg.includes("429") || msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504") || msg.includes("timeout") || msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("network") || msg.includes("fetch failed");
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve7) => setTimeout(resolve7, ms));
   }
   // ─── Interaction ──────────────────────────────────────────────────────
   resolveInteraction(id, response) {
@@ -8018,6 +8686,8 @@ async function createLLMFromConfig(options) {
   Agent,
   AnthropicProvider,
   BasicStrategyGate,
+  BrowserAutomationManager,
+  BrowserServer,
   COMPUTER_USE_ERROR_CODES,
   ComputerUseSessionOrchestrator,
   ConfigLoader,
@@ -8090,6 +8760,8 @@ async function createLLMFromConfig(options) {
   ToolResultContentSchema,
   ToolUseContentSchema,
   assessRisk,
+  createBrowserToolError,
+  createDefaultBrowserRuntimeConfig,
   createLLMFromConfig,
   getSkillContent,
   hasContent,
@@ -8097,6 +8769,7 @@ async function createLLMFromConfig(options) {
   isComputerUseErrorCode,
   isDynamicSkill,
   listCanonicalComputerUseActions,
+  normalizeBrowserRuntimeError,
   normalizeComputerUseError,
   resolveCanonicalComputerUseToolName
 });