Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
remove read long content action
Saurav Panda73d64d7bb59e
diff --git a/browser_use/filesystem/file_system.py b/browser_use/filesystem/file_system.pyindex a3be9a8f8..49946a1ea 100644--- a/browser_use/filesystem/file_system.py+++ b/browser_use/filesystem/file_system.py@@ -648,7 +648,7 @@ class FileSystem:truncation_note = (f'\n\n[Showing {len(pages_included)} of {num_pages} pages. 'f'Skipped pages: {skipped[:10]}{"..." if len(skipped) > 10 else ""}. '- f'Use read_long_content with a specific goal to find relevant sections.]'+ f'Use extract with start_from_char to read further into the file.]')else:truncation_note = ''diff --git a/browser_use/tools/service.py b/browser_use/tools/service.pyindex 5e0a40b30..25f12590d 100644--- a/browser_use/tools/service.py+++ b/browser_use/tools/service.py@@ -47,7 +47,6 @@ from browser_use.tools.views import (InputTextAction,NavigateAction,NoParamsAction,- ReadContentAction,SaveAsPdfAction,ScreenshotAction,ScrollAction,@@ -1696,275 +1695,6 @@ You will be given a query and the markdown of a webpage that has been filtered tinclude_extracted_content_only_once=True,)- # Intelligent content reading-- @self.registry.action(- 'Intelligently read long content to find specific information. Works on current page (source="page") or files. For large content, uses search to identify relevant sections. Best for long articles, documents, or any content where you know what you are looking for.',- param_model=ReadContentAction,- )- async def read_long_content(- params: ReadContentAction,- browser_session: BrowserSession,- page_extraction_llm: BaseChatModel,- available_file_paths: list[str],- ):- import re-- from browser_use.llm.messages import UserMessage-- goal = params.goal- context = params.context- source = params.source- max_chars = 50000-- async def extract_search_terms(goal: str, context: str) -> list[str]:- """Use LLM to extract search terms from goal."""- prompt = f"""Extract 3-5 key search terms from this goal that would help find relevant sections.-Return only the terms, one per line, no numbering or bullets.--Goal: {goal}--Context: {context}"""- response = await page_extraction_llm.ainvoke([UserMessage(content=prompt)])- return [term.strip() for term in response.completion.strip().split('\n') if term.strip()][:5]-- def search_text(content: str, pattern: str, context_chars: int = 100) -> list[dict]:- """Search content for pattern, return matches with positions."""- try:- regex = re.compile(pattern, re.IGNORECASE)- except re.error:- regex = re.compile(re.escape(pattern), re.IGNORECASE)-- matches = []- for match in regex.finditer(content):- start = max(0, match.start() - context_chars)- end = min(len(content), match.end() + context_chars)- matches.append(- {- 'position': match.start(),- 'snippet': content[start:end],- }- )- return matches-- def chunk_content(content: str, chunk_size: int = 2000) -> list[dict]:- """Split content into chunks with positions."""- chunks = []- for i in range(0, len(content), chunk_size):- chunks.append(- {- 'start': i,- 'end': min(i + chunk_size, len(content)),- 'text': content[i : i + chunk_size],- }- )- return chunks-- try:- if source.lower() == 'page':- # Read from current webpage- from browser_use.dom.markdown_extractor import extract_clean_markdown-- # Clear DOM cache and wait for page to settle before extracting- if browser_session._dom_watchdog:- browser_session._dom_watchdog.clear_cache()-- wait_time = browser_session.browser_profile.wait_for_network_idle_page_load_time- await asyncio.sleep(wait_time)-- content, _ = await extract_clean_markdown(browser_session=browser_session, extract_links=False)- source_name = 'current page'-- if not content:- return ActionResult(- extracted_content='Error: No page content available',- long_term_memory='Failed to read page: no content',- )-- else:- # Read from file- file_path = source-- # Validate file path against whitelist (available_file_paths + downloaded files)- allowed_paths = set(available_file_paths or [])- allowed_paths.update(browser_session.downloaded_files)- if file_path not in allowed_paths:- return ActionResult(- extracted_content=f'Error: File path not in available_file_paths: {file_path}. '- f'The user must add this path to available_file_paths when creating the Agent.',- long_term_memory=f'Failed to read: file path not allowed: {file_path}',- )-- if not os.path.exists(file_path):- return ActionResult(- extracted_content=f'Error: File not found: {file_path}',- long_term_memory='Failed to read: file not found',- )-- ext = os.path.splitext(file_path)[1].lower()- source_name = os.path.basename(file_path)-- if ext == '.pdf':- # Read PDF directly using pypdf- import pypdf-- reader = pypdf.PdfReader(file_path)- num_pages = len(reader.pages)-- # Extract all page text- page_texts: list[str] = []- total_chars = 0- for page in reader.pages:- text = page.extract_text() or ''- page_texts.append(text)- total_chars += len(text)-- # If PDF is small enough, return it all- if total_chars <= max_chars:- content_parts = []- for i, text in enumerate(page_texts, 1):- if text.strip():- content_parts.append(f'--- Page {i} ---\n{text}')- content = '\n\n'.join(content_parts)-- memory = f'Read {source_name} ({num_pages} pages, {total_chars:,} chars) for goal: {goal[:50]}'- logger.info(f'π {memory}')- return ActionResult(- extracted_content=f'PDF: {source_name} ({num_pages} pages)\n\n{content}',- long_term_memory=memory,- include_extracted_content_only_once=True,- )-- # PDF too large - use intelligent extraction- logger.info(f'PDF has {total_chars:,} chars across {num_pages} pages, using intelligent extraction')-- # Extract search terms from goal- search_terms = await extract_search_terms(goal, context)-- # Search and score pages by relevance- page_scores: dict[int, int] = {} # 1-indexed page -> score- for term in search_terms:- try:- term_pattern = re.compile(re.escape(term), re.IGNORECASE)- except re.error:- continue- for i, text in enumerate(page_texts, 1):- if term_pattern.search(text):- page_scores[i] = page_scores.get(i, 0) + 1-- # Select pages: always include page 1, then most relevant- pages_to_read = [1]- sorted_pages = sorted(page_scores.items(), key=lambda x: -x[1])- for page_num, _ in sorted_pages:- if page_num not in pages_to_read:- pages_to_read.append(page_num)-- # Build result respecting char limit, truncating pages if needed- content_parts = []- chars_used = 0- pages_included = []- for page_num in sorted(set(pages_to_read)):- text = page_texts[page_num - 1]- page_header = f'--- Page {page_num} ---\n'- remaining = max_chars - chars_used- if remaining < len(page_header) + 50:- break # no room for meaningful content- page_content = page_header + text- if len(page_content) > remaining:- page_content = page_content[: remaining - len('\n[...truncated]')] + '\n[...truncated]'- content_parts.append(page_content)- chars_used += len(page_content)- pages_included.append(page_num)-- content = '\n\n'.join(content_parts)- memory = f'Read {source_name} ({len(pages_included)} relevant pages of {num_pages}) for goal: {goal[:50]}'- logger.info(f'π {memory}')- return ActionResult(- extracted_content=f'PDF: {source_name} ({num_pages} pages, showing {len(pages_included)} relevant)\n\n{content}',- long_term_memory=memory,- include_extracted_content_only_once=True,- )-- else:- # Text file- async with await anyio.open_file(file_path, 'r', encoding='utf-8', errors='ignore') as f:- content = await f.read()-- # Check if content fits in budget- if len(content) <= max_chars:- memory = f'Read {source_name} ({len(content):,} chars) for goal: {goal[:50]}'- logger.info(f'π {memory}')- return ActionResult(- extracted_content=f'Content from {source_name} ({len(content):,} chars):\n\n{content}',- long_term_memory=memory,- include_extracted_content_only_once=True,- )-- # Content too large - use intelligent extraction- logger.info(f'Content has {len(content):,} chars, using intelligent extraction')-- # Extract search terms from goal- search_terms = await extract_search_terms(goal, context)-- # Search for each term and score chunks- chunks = chunk_content(content, chunk_size=2000)- chunk_scores: dict[int, int] = {} # chunk index -> relevance score-- for term in search_terms:- matches = search_text(content, term)- for match in matches:- # Find which chunk this match belongs to- for i, chunk in enumerate(chunks):- if chunk['start'] <= match['position'] < chunk['end']:- chunk_scores[i] = chunk_scores.get(i, 0) + 1- break-- if not chunk_scores:- # No matches - return first max_chars- truncated = content[:max_chars]- memory = f'Read {source_name} (truncated to {max_chars:,} chars, no matches for search terms)'- logger.info(f'π {memory}')- return ActionResult(- extracted_content=f'Content from {source_name} (first {max_chars:,} of {len(content):,} chars):\n\n{truncated}',- long_term_memory=memory,- include_extracted_content_only_once=True,- )-- # Sort chunks by relevance and collect most relevant ones- sorted_chunks = sorted(chunk_scores.items(), key=lambda x: -x[1])-- # Always include first chunk for context- selected_indices = {0} # Start with first chunk- for chunk_idx, _ in sorted_chunks:- selected_indices.add(chunk_idx)-- # Build result from selected chunks in order- result_parts = []- total_chars = 0- for i in sorted(selected_indices):- chunk = chunks[i]- if total_chars + len(chunk['text']) > max_chars:- break- if i > 0 and (i - 1) not in selected_indices:- result_parts.append('\n[...]\n') # Indicate gap- result_parts.append(chunk['text'])- total_chars += len(chunk['text'])-- result_content = ''.join(result_parts)- memory = f'Read {source_name} ({len(selected_indices)} relevant sections of {len(chunks)}) for goal: {goal[:50]}'- logger.info(f'π {memory}')-- return ActionResult(- extracted_content=f'Content from {source_name} (relevant sections, {total_chars:,} of {len(content):,} chars):\n\n{result_content}',- long_term_memory=memory,- include_extracted_content_only_once=True,- )-- except Exception as e:- error_msg = f'Error reading content: {str(e)}'- logger.error(error_msg)- return ActionResult(extracted_content=error_msg, long_term_memory=error_msg)-@self.registry.action("""Execute browser JavaScript. Best practice: wrap in IIFE (function(){...})() with try-catch for safety. Use ONLY browser APIs (document, window, DOM). NO Node.js APIs (fs, require, process). Example: (function(){try{const el=document.querySelector('#id');return el?el.value:'not found'}catch(e){return 'Error: '+e.message}})() Avoid comments. Use for hover, drag, zoom, custom selectors, extract/filter links, or analysing page structure. IMPORTANT: Shadow DOM elements with [index] markers can be clicked directly with click(index) β do NOT use evaluate() to click them. Only use evaluate for shadow DOM elements that are NOT indexed. Limit output size.""",terminates_sequence=True,diff --git a/browser_use/tools/views.py b/browser_use/tools/views.pyindex a8102ecf9..8274bea19 100644--- a/browser_use/tools/views.py+++ b/browser_use/tools/views.py@@ -159,17 +159,6 @@ class SaveAsPdfAction(BaseModel):)-class ReadContentAction(BaseModel):- """Action for intelligent reading of long content."""-- goal: str = Field(description='What to look for or extract from the content')- source: str = Field(- default='page',- description='What to read: "page" for current webpage, or a file path',- )- context: str = Field(default='', description='Additional context about the task')--class GetDropdownOptionsAction(BaseModel):index: int