chore: import upstream snapshot with attribution

examples/cloud/02_fast_mode_gemini.py

@@ -0,0 +1,265 @@
+"""
+Cloud Example 2: Ultra-Fast Mode with Gemini Flash ⚡
+====================================================
+
+This example demonstrates the fastest and most cost-effective configuration:
+- Gemini 2.5 Flash model ($0.01 per step)
+- No proxy (faster execution, but no captcha solving)
+- No element highlighting (better performance)
+- Optimized viewport size
+- Maximum speed configuration
+
+Perfect for: Quick content generation, humor tasks, fast web scraping
+
+Cost: ~$0.03 (1 task + 2-3 steps with Gemini Flash)
+Speed: 2-3x faster than default configuration
+Fun Factor: 💯 (Creates hilarious tech commentary)
+"""
+
+import argparse
+import os
+import time
+from typing import Any
+
+import requests
+from requests.exceptions import RequestException
+
+# Configuration
+API_KEY = os.getenv('BROWSER_USE_API_KEY')
+if not API_KEY:
+	raise ValueError(
+		'Please set BROWSER_USE_API_KEY environment variable. You can also create an API key at https://cloud.browser-use.com/new-api-key'
+	)
+
+BASE_URL = os.getenv('BROWSER_USE_BASE_URL', 'https://api.browser-use.com/api/v1')
+TIMEOUT = int(os.getenv('BROWSER_USE_TIMEOUT', '30'))
+HEADERS = {'Authorization': f'Bearer {API_KEY}', 'Content-Type': 'application/json'}
+
+
+def _request_with_retry(method: str, url: str, **kwargs) -> requests.Response:
+	"""Make HTTP request with timeout and retry logic."""
+	kwargs.setdefault('timeout', TIMEOUT)
+
+	for attempt in range(3):
+		try:
+			response = requests.request(method, url, **kwargs)
+			response.raise_for_status()
+			return response
+		except RequestException as e:
+			if attempt == 2:  # Last attempt
+				raise
+			sleep_time = 2**attempt
+			print(f'⚠️  Request failed (attempt {attempt + 1}/3), retrying in {sleep_time}s: {e}')
+			time.sleep(sleep_time)
+
+	raise RuntimeError('Unexpected error in retry logic')
+
+
+def create_fast_task(instructions: str) -> str:
+	"""
+	Create a browser automation task optimized for speed and cost.
+
+	Args:
+	    instructions: Natural language description of what the agent should do
+
+	Returns:
+	    task_id: Unique identifier for the created task
+	"""
+	print(f'⚡ Creating FAST task: {instructions}')
+
+	# Ultra-fast configuration
+	payload = {
+		'task': instructions,
+		# Model: Fastest and cheapest
+		'llm_model': 'gemini-2.5-flash',
+		# Performance optimizations
+		'use_proxy': False,  # No proxy = faster execution
+		'highlight_elements': False,  # No highlighting = better performance
+		'use_adblock': True,  # Block ads for faster loading
+		# Viewport optimization (smaller = faster)
+		'browser_viewport_width': 1024,
+		'browser_viewport_height': 768,
+		# Cost control
+		'max_agent_steps': 25,  # Reasonable limit for fast tasks
+		# Enable sharing for viewing execution
+		'enable_public_share': True,  # Get shareable URLs
+		# Optional: Speed up with domain restrictions
+		# "allowed_domains": ["google.com", "*.google.com"]
+	}
+
+	response = _request_with_retry('post', f'{BASE_URL}/run-task', headers=HEADERS, json=payload)
+
+	task_id = response.json()['id']
+	print(f'✅ Fast task created with ID: {task_id}')
+	print('⚡ Configuration: Gemini Flash + No Proxy + No Highlighting')
+	return task_id
+
+
+def monitor_fast_task(task_id: str) -> dict[str, Any]:
+	"""
+	Monitor task with optimized polling for fast execution.
+
+	Args:
+	    task_id: The task to monitor
+
+	Returns:
+	    Complete task details with output
+	"""
+	print(f'🚀 Fast monitoring task {task_id}...')
+
+	start_time = time.time()
+	step_count = 0
+	last_step_time = start_time
+
+	# Faster polling for quick tasks
+	poll_interval = 1  # Check every second for fast tasks
+
+	while True:
+		response = _request_with_retry('get', f'{BASE_URL}/task/{task_id}', headers=HEADERS)
+		details = response.json()
+		status = details['status']
+
+		# Show progress with timing
+		current_steps = len(details.get('steps', []))
+		elapsed = time.time() - start_time
+
+		# Build status message
+		if current_steps > step_count:
+			step_time = time.time() - last_step_time
+			last_step_time = time.time()
+			step_count = current_steps
+			step_msg = f'🔥 Step {current_steps} | ⚡ {step_time:.1f}s | Total: {elapsed:.1f}s'
+		else:
+			if status == 'running':
+				step_msg = f'🚀 Step {current_steps} | ⏱️  {elapsed:.1f}s | Fast processing...'
+			else:
+				step_msg = f'🚀 Step {current_steps} | ⏱️  {elapsed:.1f}s | Status: {status}'
+
+		# Clear line and show progress
+		print(f'\r{step_msg:<80}', end='', flush=True)
+
+		# Check completion
+		if status == 'finished':
+			total_time = time.time() - start_time
+			if current_steps > 0:
+				avg_msg = f'⚡ Average: {total_time / current_steps:.1f}s per step'
+			else:
+				avg_msg = '⚡ No steps recorded'
+			print(f'\r🏁 Task completed in {total_time:.1f}s! {avg_msg}' + ' ' * 20)
+			return details
+
+		elif status in ['failed', 'stopped']:
+			print(f'\r❌ Task {status} after {elapsed:.1f}s' + ' ' * 30)
+			return details
+
+		time.sleep(poll_interval)
+
+
+def run_speed_comparison():
+	"""Run multiple tasks to compare speed vs accuracy."""
+	print('\n🏃‍♂️ Speed Comparison Demo')
+	print('=' * 40)
+
+	tasks = [
+		'Go to ProductHunt and roast the top product like a sarcastic tech reviewer',
+		'Visit Reddit r/ProgrammerHumor and summarize the top post as a dramatic news story',
+		"Check GitHub trending and write a conspiracy theory about why everyone's switching to Rust",
+	]
+
+	results = []
+
+	for i, task in enumerate(tasks, 1):
+		print(f'\n📝 Fast Task {i}/{len(tasks)}')
+		print(f'Task: {task}')
+
+		start = time.time()
+		task_id = create_fast_task(task)
+		result = monitor_fast_task(task_id)
+		end = time.time()
+
+		results.append(
+			{
+				'task': task,
+				'duration': end - start,
+				'steps': len(result.get('steps', [])),
+				'status': result['status'],
+				'output': result.get('output', '')[:100] + '...' if result.get('output') else 'No output',
+			}
+		)
+
+	# Summary
+	print('\n📊 Speed Summary')
+	print('=' * 50)
+	total_time = sum(r['duration'] for r in results)
+	total_steps = sum(r['steps'] for r in results)
+
+	for i, result in enumerate(results, 1):
+		print(f'Task {i}: {result["duration"]:.1f}s ({result["steps"]} steps) - {result["status"]}')
+
+	print(f'\n⚡ Total time: {total_time:.1f}s')
+	print(f'🔥 Average per task: {total_time / len(results):.1f}s')
+	if total_steps > 0:
+		print(f'💨 Average per step: {total_time / total_steps:.1f}s')
+	else:
+		print('💨 Average per step: N/A (no steps recorded)')
+
+
+def main():
+	"""Demonstrate ultra-fast cloud automation."""
+	print('⚡ Browser Use Cloud - Ultra-Fast Mode with Gemini Flash')
+	print('=' * 60)
+
+	print('🎯 Configuration Benefits:')
+	print('• Gemini Flash: $0.01 per step (cheapest)')
+	print('• No proxy: 30% faster execution')
+	print('• No highlighting: Better performance')
+	print('• Optimized viewport: Faster rendering')
+
+	try:
+		# Single fast task
+		print('\n🚀 Single Fast Task Demo')
+		print('-' * 30)
+
+		task = """
+        Go to Hacker News (news.ycombinator.com) and get the top 3 articles from the front page.
+
+        Then, write a funny tech news segment in the style of Fireship YouTube channel:
+        - Be sarcastic and witty about tech trends
+        - Use developer humor and memes
+        - Make fun of common programming struggles
+        - Include phrases like "And yes, it runs on JavaScript" or "Plot twist: it's written in Rust"
+        - Keep it under 250 words but make it entertaining
+        - Structure it like a news anchor delivering breaking tech news
+
+        Make each story sound dramatic but also hilarious, like you're reporting on the most important events in human history.
+        """
+		task_id = create_fast_task(task)
+		result = monitor_fast_task(task_id)
+
+		print(f'\n📊 Result: {result.get("output", "No output")}')
+
+		# Show execution URLs
+		if result.get('live_url'):
+			print(f'\n🔗 Live Preview: {result["live_url"]}')
+		if result.get('public_share_url'):
+			print(f'🌐 Share URL: {result["public_share_url"]}')
+		elif result.get('share_url'):
+			print(f'🌐 Share URL: {result["share_url"]}')
+
+		# Optional: Run speed comparison with --compare flag
+		parser = argparse.ArgumentParser(description='Fast mode demo with Gemini Flash')
+		parser.add_argument('--compare', action='store_true', help='Run speed comparison with 3 tasks')
+		args = parser.parse_args()
+
+		if args.compare:
+			print('\n🏃‍♂️ Running speed comparison...')
+			run_speed_comparison()
+
+	except requests.exceptions.RequestException as e:
+		print(f'❌ API Error: {e}')
+	except Exception as e:
+		print(f'❌ Error: {e}')
+
+
+if __name__ == '__main__':
+	main()