Category: Uncategorised

import { Agent } from 'browser-use';
import { ChatOpenAI } from 'browser-use/llm/openai';

async function main() {
  const llm = new ChatOpenAI({
    model: 'gpt-4',
    apiKey: process.env.OPENAI_API_KEY,
  });

  const agent = new Agent({
    task: 'Go to google.com and search for "TypeScript browser automation"',
    llm,
  });

  const history = await agent.run();

  console.log(`Task completed in ${history.history.length} steps`);

  // Access the browser session
  const browserSession = agent.browser_session;
  const currentPage = await browserSession.get_current_page();
  console.log('Final URL:', currentPage?.url());
}

main();

import { Agent, Controller, ActionResult } from 'browser-use';
import { ChatOpenAI } from 'browser-use/llm/openai';
import { z } from 'zod';

const controller = new Controller();

controller.registry.action('Extract product info from the current page', {
  param_model: z.object({
    include_price: z.boolean().default(true),
    include_reviews: z.boolean().default(false),
  }),
})(async function extract_product_info(params, { page }) {
  const productData = await page.evaluate(() => ({
    title: document.querySelector('h1')?.textContent ?? null,
    price: document.querySelector('.price')?.textContent ?? null,
  }));

  return new ActionResult({
    extracted_content: JSON.stringify({ ...productData, ...params }),
    include_in_memory: true,
  });
});

const agent = new Agent({
  task: 'Open product page and extract product info',
  llm: new ChatOpenAI({
    model: 'gpt-4o',
    apiKey: process.env.OPENAI_API_KEY,
  }),
  controller,
});

const history = await agent.run(10);
console.log(history.final_result());

import { Agent } from 'browser-use';
import { ChatGoogle } from 'browser-use/llm/google';

const llm = new ChatGoogle('gemini-2.5-flash');

const agent = new Agent({
  task: 'Describe what you see on this page and identify main visual elements',
  llm,
  use_vision: true,
  vision_detail_level: 'high', // 'auto' | 'low' | 'high'
});

const history = await agent.run(5);

import { Controller, ActionResult } from 'browser-use';
import { z } from 'zod';

const controller = new Controller();

controller.registry.action('Extract product information', {
  param_model: z.object({
    include_price: z.boolean().default(true),
    include_reviews: z.boolean().default(false),
  }),
})(async function extract_product_info(params, { page }) {
  const productData = await page.evaluate(() => ({
    title: document.querySelector('h1')?.textContent ?? null,
    price: document.querySelector('.price')?.textContent ?? null,
  }));

  return new ActionResult({
    extracted_content: JSON.stringify({ ...productData, ...params }),
    include_in_memory: true,
  });
});

import { Agent } from 'browser-use';
import { ChatOpenAI } from 'browser-use/llm/openai';

const agent = new Agent({
  task: 'Download the PDF and extract text from page 1',
  llm: new ChatOpenAI(),
  file_system_path: './agent-workspace',
});

// FileSystem actions are available:
// - read_file: Read file contents (supports PDF)
// - write_file: Write content to file
// - replace_file_str: Replace text in file

import { BrowserProfile, BrowserSession } from 'browser-use';

const profile = new BrowserProfile({
  window_size: { width: 1920, height: 1080 },
  disable_security: false,
  headless: true,
  chromium_sandbox: true, // Keep enabled by default in production
  args: ['--disable-blink-features=AutomationControlled'],
  wait_for_network_idle_page_load_time: 3, // seconds
  allowed_domains: ['example.com', '*.google.com'],
  cookies_file: './cookies.json',
  downloads_path: './downloads',
  highlight_elements: false, // Visual debugging
  viewport_expansion: 0, // Expand viewport for element detection
});

const browserSession = new BrowserSession({
  browser_profile: profile,
});

await browserSession.start();

import { MCPController } from 'browser-use';

const mcpController = new MCPController();

// Add MCP server
await mcpController.addServer('my-server', 'npx', [
  '-y',
  '@modelcontextprotocol/server-filesystem',
  '/path/to/data',
]);

// MCP tools are automatically available to the agent
const tools = await mcpController.listAllTools();
console.log('Available MCP tools:', tools);

import { GmailService } from 'browser-use';

// Gmail actions are automatically available:
// - get_recent_emails: Fetch recent emails
// - send_email: Send email via Gmail API

const agent = new Agent({
  task: 'Check my last 5 emails and summarize them',
  llm: new ChatOpenAI(),
  // Gmail credentials loaded from config files (or explicit GmailService options)
});

interface AgentOptions {
  // Vision/multimodal
  use_vision?: boolean;
  vision_detail_level?: 'low' | 'high' | 'auto';

  // Error handling
  max_failures?: number; // default: 3
  retry_delay?: number; // seconds, default: 10
  max_actions_per_step?: number; // default: 10

  // Persistence / output
  save_conversation_path?: string | null;
  file_system_path?: string | null;
  validate_output?: boolean;
  include_attributes?: string[];

  // Runtime limits (seconds)
  llm_timeout?: number; // default: 60
  step_timeout?: number; // default: 180
}

// Max step count is configured per run call:
await agent.run(100);

import { ChatOpenAI } from 'browser-use/llm/openai';

const llm = new ChatOpenAI({
  model: 'gpt-4o', // or 'gpt-4', 'gpt-3.5-turbo'
  apiKey: process.env.OPENAI_API_KEY,
  temperature: 0.1,
  maxTokens: 4096,
});

import { ChatAnthropic } from 'browser-use/llm/anthropic';

const llm = new ChatAnthropic({
  model: 'claude-3-5-sonnet-20241022', // or other Claude models
  apiKey: process.env.ANTHROPIC_API_KEY,
  temperature: 0.1,
});

import { ChatGoogle } from 'browser-use/llm/google';

const llm = new ChatGoogle('gemini-2.5-flash');
// Configure GOOGLE_API_KEY in env. Optional:
// GOOGLE_API_BASE_URL / GOOGLE_API_VERSION

import { ChatAnthropicBedrock } from 'browser-use/llm/aws';

const llm = new ChatAnthropicBedrock({
  model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
  region: 'us-east-1',
  max_tokens: 4096,
});

import { ChatAzure } from 'browser-use/llm/azure';

const llm = new ChatAzure('gpt-4o');
// Configure AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_VERSION in env.

import { ChatDeepSeek } from 'browser-use/llm/deepseek';

const llm = new ChatDeepSeek('deepseek-chat');

import { ChatGroq } from 'browser-use/llm/groq';

const llm = new ChatGroq('mixtral-8x7b-32768');

import { ChatOllama } from 'browser-use/llm/ollama';

const llm = new ChatOllama('llama3.1', 'http://localhost:11434');

import { ChatOpenRouter } from 'browser-use/llm/openrouter';

const llm = new ChatOpenRouter('anthropic/claude-3-opus');

import { Agent, AgentError } from 'browser-use';

try {
  const agent = new Agent({ task: 'Your task', llm });
  const history = await agent.run(10); // max 10 steps

  // Check completion status
  const lastStep = history.history[history.history.length - 1];
  if (lastStep?.result.is_done) {
    console.log('Task completed:', lastStep.result.extracted_content);
  } else {
    console.log('Task incomplete after max steps');
  }
} catch (error) {
  if (error instanceof AgentError) {
    console.error('Agent error:', error.message);
    console.error('Failed at step:', error.step);
  } else {
    console.error('Unexpected error:', error);
  }
}

import { TokenCost } from 'browser-use';

const agent = new Agent({ task: 'Your task', llm });
const history = await agent.run();

// Get token statistics
const stats = history.stats();
console.log(
  'Total tokens:',
  stats.total_input_tokens + stats.total_output_tokens
);
console.log('Steps:', stats.n_steps);

// Calculate cost (if pricing data available)
const cost = TokenCost.calculate(history);
console.log('Estimated cost: $', cost.toFixed(4));

import { create_history_gif } from 'browser-use';

const history = await agent.run();

await create_history_gif('My automation task', history, {
  output_path: 'agent-history.gif',
  duration: 3000, // ms per frame
  show_goals: true,
  show_task: true,
  show_logo: false,
});

console.log('Created agent-history.gif');

import { observe, observe_debug } from 'browser-use';

// Automatic tracing (if LMNR_API_KEY set)
// All agent operations are automatically traced

// Custom debug observations
@observe_debug({ name: 'my_custom_operation' })
async function myFunction() {
  // Function execution is logged and timed
}