lobster-cli 0.1.0

package/dist/agent/core.js

@@ -0,0 +1,1013 @@
+// src/agent/core.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/llm/errors.ts
+var InvokeError = class extends Error {
+  type;
+  retryable;
+  rawError;
+  rawResponse;
+  constructor(type, message, opts) {
+    super(message);
+    this.name = "InvokeError";
+    this.type = type;
+    this.retryable = opts?.retryable ?? isRetryable(type);
+    this.rawError = opts?.rawError;
+    this.rawResponse = opts?.rawResponse;
+  }
+};
+function isRetryable(type) {
+  switch (type) {
+    case "NETWORK_ERROR" /* NETWORK_ERROR */:
+    case "RATE_LIMIT" /* RATE_LIMIT */:
+    case "SERVER_ERROR" /* SERVER_ERROR */:
+    case "NO_TOOL_CALL" /* NO_TOOL_CALL */:
+    case "INVALID_TOOL_ARGS" /* INVALID_TOOL_ARGS */:
+    case "TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */:
+    case "UNKNOWN" /* UNKNOWN */:
+      return true;
+    case "AUTH_ERROR" /* AUTH_ERROR */:
+    case "CONTEXT_LENGTH" /* CONTEXT_LENGTH */:
+    case "CONTENT_FILTER" /* CONTENT_FILTER */:
+      return false;
+  }
+}
+
+// src/llm/openai-client.ts
+var OpenAIClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build auth headers based on the provider.
+   * - OpenAI/Gemini/Ollama: Bearer token
+   * - Anthropic: x-api-key header + anthropic-version
+   */
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (!this.config.apiKey) return headers;
+    if (this.config.provider === "anthropic") {
+      headers["x-api-key"] = this.config.apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Build the request body based on provider.
+   * Anthropic Messages API is different from OpenAI chat completions.
+   */
+  buildBody(messages, tools, opts) {
+    if (this.config.provider === "anthropic") {
+      return this.buildAnthropicBody(messages, tools, opts);
+    }
+    const body = {
+      model: this.config.model,
+      messages,
+      temperature: this.config.temperature ?? 0.1
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.parallel_tool_calls = false;
+      if (opts?.toolChoice) {
+        body.tool_choice = typeof opts.toolChoice === "string" ? opts.toolChoice : opts.toolChoice;
+      }
+    }
+    return { url: `${this.config.baseURL}/chat/completions`, body };
+  }
+  /**
+   * Build Anthropic Messages API request.
+   * Converts OpenAI-style messages/tools to Anthropic format.
+   */
+  buildAnthropicBody(messages, tools, opts) {
+    let system;
+    const anthropicMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = msg.content;
+      } else {
+        anthropicMessages.push({
+          role: msg.role === "assistant" ? "assistant" : "user",
+          content: msg.content
+        });
+      }
+    }
+    const body = {
+      model: this.config.model,
+      messages: anthropicMessages,
+      max_tokens: 4096,
+      temperature: this.config.temperature ?? 0.1
+    };
+    if (system) body.system = system;
+    if (tools && tools.length > 0) {
+      body.tools = tools.map((t) => {
+        const fn = t.function;
+        return {
+          name: fn.name,
+          description: fn.description,
+          input_schema: fn.parameters
+        };
+      });
+      if (opts?.toolChoice) {
+        if (typeof opts.toolChoice === "string") {
+          body.tool_choice = opts.toolChoice === "required" ? { type: "any" } : { type: opts.toolChoice };
+        } else {
+          body.tool_choice = { type: "tool", name: opts.toolChoice.function.name };
+        }
+      }
+    }
+    return { url: `${this.config.baseURL}/messages`, body };
+  }
+  /**
+   * Parse Anthropic response into our unified format.
+   */
+  parseAnthropicResponse(json) {
+    const content = json.content;
+    if (!content || !Array.isArray(content)) {
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, "No content in Anthropic response", { rawResponse: json });
+    }
+    let textContent;
+    const toolCalls = [];
+    for (const block of content) {
+      if (block.type === "text") {
+        textContent = block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const usage = json.usage;
+    return {
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      content: textContent,
+      usage: usage ? {
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+      } : void 0
+    };
+  }
+  async chatCompletion(messages, tools, opts) {
+    const { url, body } = this.buildBody(messages, tools, opts);
+    const headers = this.buildHeaders();
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new InvokeError("NETWORK_ERROR" /* NETWORK_ERROR */, `Network error: ${err}`, { rawError: err });
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      if (response.status === 401) {
+        throw new InvokeError("AUTH_ERROR" /* AUTH_ERROR */, `Authentication failed: ${text}`, { retryable: false, rawResponse: text });
+      }
+      if (response.status === 429) {
+        throw new InvokeError("RATE_LIMIT" /* RATE_LIMIT */, `Rate limited: ${text}`, { rawResponse: text });
+      }
+      if (response.status >= 500) {
+        throw new InvokeError("SERVER_ERROR" /* SERVER_ERROR */, `Server error ${response.status}: ${text}`, { rawResponse: text });
+      }
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, `HTTP ${response.status}: ${text}`, { rawResponse: text });
+    }
+    const json = await response.json();
+    if (this.config.provider === "anthropic") {
+      return this.parseAnthropicResponse(json);
+    }
+    const choice = json.choices?.[0];
+    if (!choice) {
+      throw new InvokeError("UNKNOWN" /* UNKNOWN */, "No choices in response", { rawResponse: json });
+    }
+    const message = choice.message;
+    const finishReason = choice.finish_reason;
+    if (finishReason === "content_filter") {
+      throw new InvokeError("CONTENT_FILTER" /* CONTENT_FILTER */, "Content filtered", { retryable: false, rawResponse: json });
+    }
+    if (finishReason === "length") {
+      throw new InvokeError("CONTEXT_LENGTH" /* CONTEXT_LENGTH */, "Context length exceeded", { retryable: false, rawResponse: json });
+    }
+    const usage = json.usage;
+    return {
+      toolCalls: message.tool_calls,
+      content: message.content,
+      usage: usage ? {
+        promptTokens: usage.prompt_tokens ?? 0,
+        completionTokens: usage.completion_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0
+      } : void 0
+    };
+  }
+};
+
+// src/llm/utils.ts
+function zodToJsonSchema(schema) {
+  if ("_def" in schema) {
+    const def = schema._def;
+    const typeName = def.typeName;
+    if (typeName === "ZodObject") {
+      const shape = def.shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        if (!(value._def?.typeName === "ZodOptional")) {
+          required.push(key);
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodString") {
+      const result = { type: "string" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodNumber") {
+      const result = { type: "number" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodBoolean") {
+      const result = { type: "boolean" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    if (typeName === "ZodEnum") {
+      return { type: "string", enum: def.values, ...def.description ? { description: def.description } : {} };
+    }
+    if (typeName === "ZodArray") {
+      return { type: "array", items: zodToJsonSchema(def.type), ...def.description ? { description: def.description } : {} };
+    }
+    if (typeName === "ZodOptional") {
+      return zodToJsonSchema(def.innerType);
+    }
+    if (typeName === "ZodDefault") {
+      const inner = zodToJsonSchema(def.innerType);
+      return { ...inner, default: def.defaultValue() };
+    }
+    if (typeName === "ZodUnion") {
+      return { oneOf: def.options.map((opt) => zodToJsonSchema(opt)) };
+    }
+    if (typeName === "ZodRecord") {
+      return { type: "object", additionalProperties: zodToJsonSchema(def.valueType) };
+    }
+    if (typeName === "ZodLiteral") {
+      return { const: def.value };
+    }
+    if (typeName === "ZodAny") {
+      return {};
+    }
+  }
+  return { type: "string" };
+}
+function zodToOpenAITool(name, description, schema) {
+  return {
+    type: "function",
+    function: {
+      name,
+      description,
+      parameters: zodToJsonSchema(schema)
+    }
+  };
+}
+
+// src/llm/client.ts
+var LLM = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new OpenAIClient({
+      baseURL: config.baseURL,
+      model: config.model,
+      apiKey: config.apiKey,
+      temperature: config.temperature,
+      provider: config.provider
+    });
+  }
+  async invoke(messages, tool, abortSignal) {
+    const openaiTool = zodToOpenAITool(tool.name, tool.description, tool.schema);
+    return this.withRetry(async () => {
+      if (abortSignal?.aborted) throw new Error("Aborted");
+      const response = await this.client.chatCompletion(
+        messages,
+        [openaiTool],
+        { toolChoice: { type: "function", function: { name: tool.name } } }
+      );
+      const toolCall = response.toolCalls?.[0];
+      if (!toolCall) {
+        if (response.content) {
+          const extracted = extractJsonFromString(response.content);
+          if (extracted) {
+            const args2 = typeof extracted === "string" ? JSON.parse(extracted) : extracted;
+            const result2 = await tool.execute(args2);
+            return {
+              toolCall: { name: tool.name, args: args2 },
+              toolResult: result2,
+              usage: response.usage
+            };
+          }
+        }
+        throw new InvokeError("NO_TOOL_CALL" /* NO_TOOL_CALL */, "No tool call in response");
+      }
+      let args;
+      try {
+        args = JSON.parse(toolCall.function.arguments);
+      } catch {
+        try {
+          args = JSON.parse(JSON.parse(toolCall.function.arguments));
+        } catch {
+          throw new InvokeError("INVALID_TOOL_ARGS" /* INVALID_TOOL_ARGS */, `Invalid JSON in tool args: ${toolCall.function.arguments}`);
+        }
+      }
+      let result;
+      try {
+        result = await tool.execute(args);
+      } catch (err) {
+        throw new InvokeError("TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */, `Tool execution failed: ${err}`, { rawError: err });
+      }
+      return {
+        toolCall: { name: tool.name, args },
+        toolResult: result,
+        usage: response.usage
+      };
+    });
+  }
+  async withRetry(fn) {
+    const maxRetries = this.config.maxRetries ?? 3;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (err instanceof InvokeError && !err.retryable) throw err;
+        if (err instanceof Error && err.name === "AbortError") throw err;
+        if (attempt < maxRetries) {
+          await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError;
+  }
+};
+function extractJsonFromString(str) {
+  const start = str.indexOf("{");
+  const end = str.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    return JSON.parse(str.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+
+// src/agent/tools/click.ts
+import { z } from "zod";
+function createClickTool(page) {
+  return {
+    description: "Click on an interactive element by its index number from the page content.",
+    inputSchema: z.object({
+      index: z.number().describe("The index of the element to click")
+    }),
+    execute: async (args) => {
+      await page.click(args.index);
+      return `Clicked element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/type.ts
+import { z as z2 } from "zod";
+function createTypeTool(page) {
+  return {
+    description: "Type text into an input field identified by its index number.",
+    inputSchema: z2.object({
+      index: z2.number().describe("The index of the input element"),
+      text: z2.string().describe("The text to type")
+    }),
+    execute: async (args) => {
+      await page.typeText(args.index, args.text);
+      return `Typed "${args.text}" into element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/scroll.ts
+import { z as z3 } from "zod";
+function createScrollTool(page) {
+  return {
+    description: "Scroll the page in a given direction. Use to reveal more content.",
+    inputSchema: z3.object({
+      direction: z3.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
+      amount: z3.number().optional().describe("Pixels to scroll (default 500)")
+    }),
+    execute: async (args) => {
+      await page.scroll(args.direction, args.amount);
+      return `Scrolled ${args.direction}${args.amount ? ` ${args.amount}px` : ""}`;
+    }
+  };
+}
+
+// src/agent/tools/select.ts
+import { z as z4 } from "zod";
+function createSelectTool(page) {
+  return {
+    description: "Select an option from a dropdown/select element by its index.",
+    inputSchema: z4.object({
+      index: z4.number().describe("The index of the select element"),
+      value: z4.string().describe("The option text or value to select")
+    }),
+    execute: async (args) => {
+      await page.selectOption(args.index, args.value);
+      return `Selected "${args.value}" in element [${args.index}]`;
+    }
+  };
+}
+
+// src/agent/tools/wait.ts
+import { z as z5 } from "zod";
+function createWaitTool() {
+  return {
+    description: "Wait for a specified number of seconds before continuing.",
+    inputSchema: z5.object({
+      seconds: z5.number().min(0.1).max(30).describe("Seconds to wait")
+    }),
+    execute: async (args) => {
+      await new Promise((r) => setTimeout(r, args.seconds * 1e3));
+      return `Waited ${args.seconds} seconds`;
+    }
+  };
+}
+
+// src/agent/tools/done.ts
+import { z as z6 } from "zod";
+function createDoneTool() {
+  return {
+    description: "Signal that the task is complete. Call this when you have finished the task or cannot proceed further.",
+    inputSchema: z6.object({
+      success: z6.boolean().describe("Whether the task was completed successfully"),
+      text: z6.string().describe("Summary of the result or explanation of failure")
+    }),
+    execute: async (args) => {
+      return JSON.stringify({ done: true, success: args.success, text: args.text });
+    }
+  };
+}
+
+// src/agent/tools/ask-user.ts
+import { z as z7 } from "zod";
+import { createInterface } from "readline";
+function createAskUserTool() {
+  return {
+    description: "Ask the user a question when you need clarification or input to proceed.",
+    inputSchema: z7.object({
+      question: z7.string().describe("The question to ask the user")
+    }),
+    execute: async (args) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      return new Promise((resolve) => {
+        rl.question(`
+\u{1F916} Agent asks: ${args.question}
+> `, (answer) => {
+          rl.close();
+          resolve(`User answered: ${answer}`);
+        });
+      });
+    }
+  };
+}
+
+// src/agent/tools/execute-js.ts
+import { z as z8 } from "zod";
+function createExecuteJsTool(page) {
+  return {
+    description: "Execute JavaScript code on the current page. Returns the result.",
+    inputSchema: z8.object({
+      code: z8.string().describe("JavaScript code to execute on the page")
+    }),
+    execute: async (args) => {
+      const result = await page.evaluate(args.code);
+      return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    }
+  };
+}
+
+// src/agent/tools/index.ts
+function createDefaultTools(page) {
+  return {
+    click_element_by_index: createClickTool(page),
+    input_text: createTypeTool(page),
+    scroll: createScrollTool(page),
+    select_dropdown_option: createSelectTool(page),
+    wait: createWaitTool(),
+    done: createDoneTool(),
+    ask_user: createAskUserTool(),
+    execute_javascript: createExecuteJsTool(page)
+  };
+}
+
+// src/agent/macro-tool.ts
+import { z as z9 } from "zod";
+
+// src/agent/auto-fixer.ts
+function normalizeResponse(raw, toolName, availableActions, toolSchemas) {
+  let result = { ...raw };
+  if (result.type === "function" && result.function) {
+    const fn = result.function;
+    if (typeof fn.arguments === "string") {
+      try {
+        result = JSON.parse(fn.arguments);
+      } catch {
+      }
+    } else if (typeof fn.arguments === "object") {
+      result = fn.arguments;
+    }
+  }
+  for (const [key, value] of Object.entries(result)) {
+    if (typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          result[key] = parsed;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!result.action) {
+    for (const actionName of availableActions) {
+      if (actionName in result) {
+        result = {
+          ...result,
+          action: { [actionName]: result[actionName] }
+        };
+        delete result[actionName];
+        break;
+      }
+    }
+  }
+  if (!result.action) {
+    result.action = { wait: { seconds: 1 } };
+  }
+  if (typeof result.action === "string") {
+    if (availableActions.includes(result.action)) {
+      result.action = { [result.action]: {} };
+    } else {
+      result.action = { wait: { seconds: 1 } };
+    }
+  }
+  const action = result.action;
+  for (const [name, input] of Object.entries(action)) {
+    if (typeof input !== "object" || input === null) {
+      if (toolSchemas && toolSchemas[name]) {
+        const schema = toolSchemas[name].inputSchema;
+        const coerced = coercePrimitiveToSchema(input, schema);
+        if (coerced !== null) {
+          action[name] = coerced;
+          continue;
+        }
+      }
+      if (typeof input === "number") {
+        action[name] = { index: input };
+      } else if (typeof input === "string") {
+        action[name] = { text: input };
+      } else {
+        action[name] = {};
+      }
+    }
+    if (toolSchemas && toolSchemas[name] && typeof action[name] === "object") {
+      const schema = toolSchemas[name].inputSchema;
+      const validation = schema.safeParse(action[name]);
+      if (!validation.success) {
+        const fixed = attemptSchemaFix(action[name], schema, validation.error);
+        if (fixed) {
+          action[name] = fixed;
+        }
+      }
+    }
+  }
+  return result;
+}
+function coercePrimitiveToSchema(value, schema) {
+  try {
+    const def = schema._def;
+    if (def?.typeName !== "ZodObject") return null;
+    const shape = def.shape();
+    const keys = Object.keys(shape);
+    const requiredKeys = keys.filter((k) => {
+      const fieldDef = shape[k]?._def;
+      return fieldDef?.typeName !== "ZodOptional";
+    });
+    if (requiredKeys.length === 1) {
+      return { [requiredKeys[0]]: value };
+    }
+    const indexField = keys.find((k) => /index|idx|num|number/i.test(k));
+    if (indexField && typeof value === "number") {
+      return { [indexField]: value };
+    }
+    const textField = keys.find((k) => /text|value|query|code|question|url/i.test(k));
+    if (textField && typeof value === "string") {
+      return { [textField]: value };
+    }
+  } catch {
+  }
+  return null;
+}
+function attemptSchemaFix(input, schema, error) {
+  try {
+    const def = schema._def;
+    if (def?.typeName !== "ZodObject") return null;
+    const shape = def.shape();
+    const expectedKeys = Object.keys(shape);
+    const inputKeys = Object.keys(input);
+    const fixed = { ...input };
+    for (const issue of error.issues) {
+      if (issue.code === "invalid_type" && issue.path.length === 1) {
+        const key = String(issue.path[0]);
+        const val = input[key];
+        if (issue.expected === "number" && typeof val === "string") {
+          const num = Number(val);
+          if (!isNaN(num)) fixed[key] = num;
+        } else if (issue.expected === "string" && typeof val === "number") {
+          fixed[key] = String(val);
+        } else if (issue.expected === "boolean" && typeof val === "string") {
+          fixed[key] = val === "true";
+        }
+      }
+      if (issue.code === "unrecognized_keys") {
+        for (const k of issue.keys || []) {
+          delete fixed[k];
+        }
+      }
+    }
+    const result = schema.safeParse(fixed);
+    if (result.success) return fixed;
+  } catch {
+  }
+  return null;
+}
+
+// src/agent/macro-tool.ts
+function packMacroTool(tools) {
+  const actionSchemas = [];
+  const toolNames = [];
+  for (const [name, tool] of Object.entries(tools)) {
+    toolNames.push(name);
+    actionSchemas.push(
+      z9.object({ [name]: tool.inputSchema }).describe(tool.description)
+    );
+  }
+  const actionSchema = actionSchemas.length === 1 ? actionSchemas[0] : z9.union(actionSchemas);
+  const macroSchema = z9.object({
+    evaluation_previous_goal: z9.string().optional().describe("Evaluate whether the previous goal was achieved"),
+    memory: z9.string().optional().describe("Important information to remember for future steps"),
+    next_goal: z9.string().optional().describe("The next immediate goal to achieve"),
+    action: actionSchema.describe("The action to take")
+  });
+  return {
+    name: "AgentOutput",
+    description: "The agent's output containing reflection and action. Must be called every step.",
+    schema: macroSchema,
+    execute: async (args) => {
+      const normalized = normalizeResponse(args, "AgentOutput", toolNames, tools);
+      const action = normalized.action;
+      const [toolName, toolInput] = Object.entries(action)[0];
+      const tool = tools[toolName];
+      if (!tool) {
+        return `Error: Unknown tool "${toolName}". Available: ${toolNames.join(", ")}`;
+      }
+      try {
+        const result = await tool.execute(toolInput);
+        return result;
+      } catch (err) {
+        return `Error executing ${toolName}: ${err}`;
+      }
+    }
+  };
+}
+
+// src/browser/dom/flat-tree.ts
+function flatTreeToString(tree) {
+  const lines = [];
+  function walk(nodeId, depth) {
+    const node = tree.map[nodeId];
+    if (!node) return;
+    const indent = "	".repeat(depth);
+    if (node.tagName === "#text") {
+      if (node.text) lines.push(`${indent}${node.text}`);
+      return;
+    }
+    const attrs = node.attributes || {};
+    const attrStr = Object.entries(attrs).map(([k, v]) => v === "" ? k : `${k}="${v}"`).join(" ");
+    const prefix = node.highlightIndex !== void 0 ? `[${node.highlightIndex}]` : "";
+    const scrollInfo = node.scrollable ? ` |scroll: ${Math.round(node.scrollable.top)}px up, ${Math.round(node.scrollable.bottom)}px down|` : "";
+    const text = node.text || "";
+    const tag = node.tagName;
+    if (prefix || text || node.children?.length > 0) {
+      const opening = `${indent}${prefix}<${tag}${attrStr ? " " + attrStr : ""}${scrollInfo}>`;
+      if (!node.children?.length || node.children.length === 0 && text) {
+        lines.push(`${opening}${text}</>`);
+      } else {
+        lines.push(`${opening}${text}`);
+        for (const childId of node.children || []) {
+          walk(childId, depth + 1);
+        }
+      }
+    } else {
+      for (const childId of node.children || []) {
+        walk(childId, depth);
+      }
+    }
+  }
+  walk(tree.rootId, 0);
+  return lines.join("\n");
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2717"), msg),
+  debug: (msg) => {
+    if (process.env.LOBSTER_DEBUG) console.log(chalk.gray("\u22EF"), msg);
+  },
+  step: (n, msg) => console.log(chalk.cyan(`[${n}]`), msg),
+  dim: (msg) => console.log(chalk.dim(msg))
+};
+
+// src/agent/core.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var AgentCore = class {
+  page;
+  config;
+  llm;
+  history = [];
+  _status = "idle";
+  listeners = /* @__PURE__ */ new Map();
+  previousElementHashes = /* @__PURE__ */ new Set();
+  totalWaitTime = 0;
+  constructor(page, config) {
+    this.page = page;
+    this.config = config;
+    this.llm = new LLM(config.llm);
+  }
+  // ── Event system ──
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event) {
+    const listeners = this.listeners.get(event.type);
+    if (listeners) {
+      for (const fn of listeners) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+  }
+  get status() {
+    return this._status;
+  }
+  setStatus(newStatus) {
+    const prev = this._status;
+    this._status = newStatus;
+    this.emit({ type: "statuschange", status: newStatus, previousStatus: prev });
+  }
+  pushHistory(event) {
+    this.history.push(event);
+    this.emit({ type: "historychange", history: this.history });
+  }
+  async execute(task, abortSignal) {
+    this.setStatus("running");
+    this.history = [];
+    this.previousElementHashes.clear();
+    this.totalWaitTime = 0;
+    const maxSteps = this.config.maxSteps ?? 40;
+    const stepDelay = this.config.stepDelay ?? 0.4;
+    const tools = {
+      ...createDefaultTools(this.page),
+      ...this.config.customTools || {}
+    };
+    for (const [name, tool] of Object.entries(tools)) {
+      if (tool === null) delete tools[name];
+    }
+    const macroTool = packMacroTool(tools);
+    let systemPrompt;
+    try {
+      systemPrompt = readFileSync(join(__dirname, "prompts", "system.md"), "utf-8");
+    } catch {
+      systemPrompt = "You are an AI web agent that navigates web pages to complete tasks.";
+    }
+    if (this.config.instructions?.system) {
+      systemPrompt += "\n\n" + this.config.instructions.system;
+    }
+    let lastURL = "";
+    for (let step = 1; step <= maxSteps; step++) {
+      if (abortSignal?.aborted) {
+        this.setStatus("error");
+        return { success: false, data: "Aborted", history: this.history };
+      }
+      const browserState = await this.page.browserState().catch(() => ({
+        url: "",
+        title: "",
+        viewportWidth: 0,
+        viewportHeight: 0,
+        pageWidth: 0,
+        pageHeight: 0,
+        scrollX: 0,
+        scrollY: 0,
+        scrollPercent: 0,
+        pixelsAbove: 0,
+        pixelsBelow: 0
+      }));
+      const flatTree = await this.page.flatTree().catch(() => ({ rootId: "", map: {} }));
+      const pageContent = flatTreeToString(flatTree);
+      const currentHashes = /* @__PURE__ */ new Set();
+      let newElementCount = 0;
+      for (const node of Object.values(flatTree.map)) {
+        if (node.isInteractive && node.highlightIndex !== void 0) {
+          const hash = `${node.tagName}:${node.text || ""}:${JSON.stringify(node.attributes || {})}`;
+          currentHashes.add(hash);
+          if (!this.previousElementHashes.has(hash)) {
+            newElementCount++;
+          }
+        }
+      }
+      this.previousElementHashes = currentHashes;
+      const observations = [];
+      if (browserState.url !== lastURL && lastURL) {
+        observations.push(`Navigated to ${browserState.url}`);
+      }
+      lastURL = browserState.url;
+      if (newElementCount > 0 && step > 1) {
+        observations.push(`${newElementCount} new interactive element(s) appeared`);
+      }
+      if (this.totalWaitTime > 3) {
+        observations.push(`Total wait time: ${this.totalWaitTime.toFixed(1)}s \u2014 consider if page is still loading`);
+      }
+      if (step >= maxSteps - 5) {
+        observations.push(`Warning: ${maxSteps - step} steps remaining`);
+      }
+      if (this.config.instructions?.getPageInstructions) {
+        try {
+          const pi = this.config.instructions.getPageInstructions(browserState.url);
+          if (pi) observations.push(`Page instructions: ${pi}`);
+        } catch {
+        }
+      }
+      for (const obs of observations) {
+        this.pushHistory({ type: "observation", message: obs });
+        this.emit({ type: "activity", kind: "observation", message: obs, step });
+      }
+      const userPrompt = assembleUserPrompt(
+        task,
+        pageContent,
+        browserState,
+        this.history,
+        step,
+        maxSteps
+      );
+      const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ];
+      log.step(step, `Thinking... (${browserState.url})`);
+      this.emit({ type: "activity", kind: "thinking", message: `Step ${step}: thinking`, step });
+      if (this.config.onBeforeStep) await this.config.onBeforeStep(step);
+      const startTime = Date.now();
+      let result;
+      try {
+        result = await this.llm.invoke(messages, macroTool, abortSignal);
+      } catch (err) {
+        log.error(`LLM error at step ${step}: ${err}`);
+        this.pushHistory({ type: "error", error: String(err), step });
+        this.emit({ type: "activity", kind: "error", message: String(err), step });
+        continue;
+      }
+      const duration = Date.now() - startTime;
+      const args = result.toolCall.args;
+      const action = args.action || args;
+      const [actionName, actionInput] = Object.entries(action)[0] || ["unknown", {}];
+      this.emit({ type: "activity", kind: "executing", message: actionName, step });
+      if (actionName === "wait") {
+        const secs = actionInput?.seconds || 0;
+        this.totalWaitTime += secs;
+      }
+      const stepEvent = {
+        type: "step",
+        step,
+        reflection: {
+          evaluation_previous_goal: args.evaluation_previous_goal || "",
+          memory: args.memory || "",
+          next_goal: args.next_goal || ""
+        },
+        action: { name: actionName, args: actionInput },
+        output: result.toolResult,
+        duration
+      };
+      this.pushHistory(stepEvent);
+      log.step(step, `Action: ${actionName} \u2192 ${result.toolResult.slice(0, 100)}`);
+      this.emit({ type: "activity", kind: "executed", message: `${actionName}: ${result.toolResult.slice(0, 80)}`, step, duration });
+      if (this.config.onAfterStep) await this.config.onAfterStep(this.history);
+      if (actionName === "done") {
+        try {
+          const doneResult = JSON.parse(result.toolResult);
+          this.setStatus("completed");
+          return { success: doneResult.success, data: doneResult.text || result.toolResult, history: this.history };
+        } catch {
+          this.setStatus("completed");
+          return { success: true, data: result.toolResult, history: this.history };
+        }
+      }
+      if (stepDelay > 0) {
+        await new Promise((r) => setTimeout(r, stepDelay * 1e3));
+      }
+    }
+    this.setStatus("error");
+    return { success: false, data: `Reached maximum steps (${maxSteps})`, history: this.history };
+  }
+};
+function assembleUserPrompt(task, pageContent, state, history, step, maxSteps) {
+  let prompt = `# Task
+${task}
+
+`;
+  prompt += `# Current Page
+`;
+  prompt += `URL: ${state.url}
+`;
+  prompt += `Title: ${state.title}
+`;
+  prompt += `Viewport: ${state.viewportWidth}x${state.viewportHeight} | Page height: ${state.pageHeight}px
+`;
+  prompt += `Scroll: ${state.scrollPercent}%`;
+  if (state.pixelsAbove > 50) prompt += ` | ${state.pixelsAbove}px above`;
+  if (state.pixelsBelow > 50) prompt += ` | ${state.pixelsBelow}px below`;
+  prompt += `
+Step: ${step}/${maxSteps}
+
+`;
+  prompt += `# Browser State
+${pageContent}
+
+`;
+  if (history.length > 0) {
+    prompt += `# History
+`;
+    const recent = history.slice(-10);
+    for (const event of recent) {
+      if (event.type === "step") {
+        const s = event;
+        prompt += `<step_${s.step}>
+`;
+        if (s.reflection) {
+          prompt += `  eval: ${s.reflection.evaluation_previous_goal}
+`;
+          prompt += `  memory: ${s.reflection.memory}
+`;
+          prompt += `  goal: ${s.reflection.next_goal}
+`;
+        }
+        prompt += `  action: ${s.action.name}(${JSON.stringify(s.action.args)})
+`;
+        prompt += `  result: ${s.output.slice(0, 200)}
+`;
+        prompt += `</step_${s.step}>
+`;
+      } else if (event.type === "observation") {
+        prompt += `<sys>${event.message}</sys>
+`;
+      }
+    }
+  }
+  return prompt;
+}
+export {
+  AgentCore
+};
+//# sourceMappingURL=core.js.map