from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=False,
        chromium_sandbox=True,
        env={},
        args=[
            "--disable-extensions",
            "--disable-file-system"
        ]
    )
    page = browser.new_page()
    page.set_viewport_size({"width": 1024, "height": 768})
    page.goto("<https://bing.com>")
    
    page.wait_for_timeout(10000)

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI()

response = client.responses.create(
    model="computer-use-preview",
    tools=[{
        "type": "computer_use_preview",
        "display_width": 1024,
        "display_height": 768,
        "environment": "browser"  # other possible values: "mac", "windows", "ubuntu"
    }],
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Check the latest OpenAI news on bing.com."
                }
            ]
        }
    ],
    reasoning={
        "summary": "concise",
    },
    truncation="auto"
)

print(response.output)

{
    "ResponseComputerToolCall": {
        "id": "cu_68d1e0746ee881939f997cb435893ba10e7707dd36830812",
        "action": {
            "type": "screenshot"
        },
        "call_id": "call_Gd9Y9G86Om9ofrPuPV8ijBh5",
        "pending_safety_checks": [],
        "status": "completed",
        "type": "computer_call"
    }
}

import base64
import time

def get_screenshot(page):
    """Capture and encode screenshot"""
    screenshot_bytes = page.screenshot()
    screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
    return screenshot_base64

def handle_model_action(browser, page, action):
    """Execute different types of actions in the browser"""
    action_type = action.get("type")

    if action_type == "click":
        x, y = action.get("x"), action.get("y")
        page.mouse.click(x, y)
        time.sleep(1)  # Allow page to respond

    elif action_type == "type":
        text = action.get("text")
        page.keyboard.type(text, delay=100)  # Simulate natural typing

    elif action_type == "key":
        key = action.get("text")
        page.keyboard.press(key)
        time.sleep(0.5)

    elif action_type == "scroll":
        direction = action.get("direction", "down")
        amount = action.get("amount", 300)
        page.mouse.wheel(0, amount if direction == "down" else -amount)

    elif action_type == "cursor_position":
        x, y = action.get("x"), action.get("y")
        page.mouse.move(x, y)

def computer_use_loop(browser, page, response):
    """Execute the core agent loop until task completion or failure"""

    while True:
        # Extract computer calls from response
        computer_calls = [
            item for item in response.output
            if item.type == "computer_call"
        ]

        # If no computer calls, we're done
        if not computer_calls:
            print("No more computer calls. Output from model:")
            for item in response.output:
                print(item)
            break

        # We expect at most one computer call per response
        computer_call = computer_calls[0]
        last_call_id = computer_call.call_id
        action = computer_call.action

        # Perform the action in Playwright
        page = handle_model_action(browser, page, action)
        time.sleep(1)

        # Send screenshot back to the model
        screenshot_bytes = get_screenshot(page)
        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")

        # Handle safety checks if present
        pending_safety_checks = getattr(
            computer_call,
            "pending_safety_checks",
            []
        ) or []

        acknowledged_safety_checks = [
            {"id": sc.id} for sc in pending_safety_checks
        ]

        if acknowledged_safety_checks:
            print("Acknowledging safety checks:", acknowledged_safety_checks)

        # Make next API call with updated state
        response = client.responses.create(
            model="computer-use-preview",
            previous_response_id=response.id,
            tools=tools,
            input=[{
                "call_id": last_call_id,
                "type": "computer_call_output",
                "output": {
                    "type": "input_image",
                    "image_url": f"data:image/png;base64,{screenshot_base64}"
                }
            }],
            truncation="auto"
        )

        print("Response:", response.output)

    return response

def weather_agent(location="Port Sanilac, Michigan"):
    """Complete example: Weather lookup agent"""

    # Initialize browser
    playwright, browser, page = launch_browser()

    try:
        # Initialize agent with task
        client, initial_response = initialize_agent(
            f"What's the weather like in {location}?"
        )

        # Store tools configuration for loop
        global tools
        tools = [{
            "type": "computer_use_preview",
            "display_width": 1024,
            "display_height": 768,
            "environment": "browser"
        }]

        # Run the agent loop
        final_response = computer_use_loop(browser, page, initial_response)

        # Extract and display result
        for item in final_response.output:
            if hasattr(item, 'content'):
                print(f"\\nWeather Result: {item.content}")

    except Exception as e:
        print(f"Error occurred: {e}")
        raise
    finally:
        browser.close()
        playwright.stop()

# Run the agent
if __name__ == "__main__":
    weather_agent()

def job_search_agent(job_title="Android developer", location="Detroit, MI"):
    """Search for jobs on job boards"""

    playwright, browser, page = launch_browser()

    try:
        # Navigate directly to Dice.com
        page.goto("<https://www.dice.com>")
        page.wait_for_timeout(2000)

        # Construct detailed instructions
        instructions = f"""I want you to identify open job positions for an {job_title} in {location}.

Please:
1. Enter '{job_title}' in the job title field
2. Enter '{location}' in the location field
3. Click search
4. Look through the results
5. Provide a summary of what jobs are available"""

        client, initial_response = initialize_agent(instructions)

        # Set up tools
        global tools
        tools = [{
            "type": "computer_use_preview",
            "display_width": 1024,
            "display_height": 768,
            "environment": "browser"
        }]

        # Run agent loop
        final_response = computer_use_loop(browser, page, initial_response)

        # Display results
        for item in final_response.output:
            if hasattr(item, 'content'):
                print(f"\\nJob Search Results:\\n{item.content}")

    except Exception as e:
        print(f"Error during job search: {e}")
        raise
    finally:
        browser.close()
        playwright.stop()

# Run the agent
if __name__ == "__main__":
    job_search_agent()

def fill_contact_form(url, name, email, message):
    """
    Automated contact form completion agent

    Args:
        url: Target form URL
        name: Name to enter
        email: Email address
        message: Message content
    """

    playwright, browser, page = launch_browser()

    try:
        # Navigate to form
        print(f"Navigating to {url}...")
        page.goto(url)
        page.wait_for_load_state('networkidle')

        # Construct detailed instructions
        instructions = f"""Fill out the contact form on this page with the following information:

Name: {name}
Email: {email}
Message: {message}

After filling out all fields, submit the form.
If you're asked for confirmation before submitting, please proceed with submission."""

        # Initialize agent
        client, initial_response = initialize_agent(instructions)

        # Set up tools
        global tools, client as global_client
        global_client = client
        tools = [{
            "type": "computer_use_preview",
            "display_width": 1024,
            "display_height": 768,
            "environment": "browser"
        }]

        # Run agent loop with form-specific handling
        final_response = computer_use_loop_with_form_submission(
            browser,
            page,
            initial_response
        )

        return final_response

    except Exception as e:
        print(f"Error during form filling: {e}")
        raise
    finally:
        browser.close()
        playwright.stop()

def _asks_to_submit(text):
    """Check if the agent is asking for permission to submit"""
    if not text:
        return False

    text_lower = text.lower()
    confirmation_phrases = [
        "should i submit",
        "shall i proceed",
        "would you like me to",
        "should i go ahead",
        "ready to submit",
        "go ahead and submit"
    ]

    return any(phrase in text_lower for phrase in confirmation_phrases)

def computer_use_loop_with_form_submission(browser, page, response):
    """Enhanced loop that handles form submission confirmations"""

    while True:
        # Extract computer calls
        computer_calls = [
            item for item in response.output
            if item.type == "computer_call"
        ]

        # Check if we're done OR if model is asking for confirmation
        if not computer_calls:
            # Check the output text for submission questions
            out_text = getattr(response, "output_text", "") or ""

            if _asks_to_submit(out_text):
                # Auto-confirm inside the loop and continue
                print("Model asked for confirmation; auto-confirming: 'Yes, submit the form now.'")
                response = global_client.responses.create(
                    model="computer-use-preview",
                    previous_response_id=response.id,
                    tools=tools,
                    input=[{
                        "role": "user",
                        "content": "Yes, submit the form now."
                    }],
                    truncation="auto"
                )
                # Loop back to process the next computer_call (the actual submit)
                continue
            else:
                # Truly done - print the model's final output and break
                print("No more computer calls. Output from model:")
                for item in response.output:
                    print(item)
                break

        # Process the computer call
        computer_call = computer_calls[0]
        last_call_id = computer_call.call_id
        action = computer_call.action

        # Perform the action
        page = handle_model_action(browser, page, action)
        time.sleep(1)

        # Capture screenshot
        screenshot_bytes = get_screenshot(page)
        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")

        # Acknowledge any safety checks on THIS call
        pending_safety_checks = getattr(computer_call, "pending_safety_checks", []) or []
        acknowledged_safety_checks = [{"id": sc.id} for sc in pending_safety_checks]
        if acknowledged_safety_checks:
            print("Acknowledging safety checks:", acknowledged_safety_checks)

        # Make next API call
        response = global_client.responses.create(
            model="computer-use-preview",
            previous_response_id=response.id,
            tools=tools,
            input=[{
                "call_id": last_call_id,
                "type": "computer_call_output",
                "output": {
                    "type": "input_image",
                    "image_url": f"data:image/png;base64,{screenshot_base64}"
                }
            }],
            truncation="auto"
        )

        print("Response:", response.output)

    return response

# Example usage
if __name__ == "__main__":
    fill_contact_form(
        url="<https://www.riis.com/contact>",
        name="Godfrey Nolan",
        email="godfrey@riis.com",
        message="Hello from the OpenAI meetup"
    )

from playwright.sync_api import sync_playwright
from openai import OpenAI
from dotenv import load_dotenv
import os
import base64
import time

# Global variables for loop
tools = None
global_client = None

def launch_browser():
    """Initialize browser with standardized configuration"""
    playwright = sync_playwright().start()
    browser = playwright.chromium.launch(
        headless=False,
        chromium_sandbox=True,
        env={},
        args=["--disable-extensions", "--disable-file-system"]
    )
    page = browser.new_page()
    page.set_viewport_size({"width": 1024, "height": 768})
    page.goto("<https://www.bing.com>")
    page.wait_for_timeout(10000)
    return playwright, browser, page

def get_screenshot(page):
    """Capture and encode screenshot"""
    screenshot_bytes = page.screenshot()
    return base64.b64encode(screenshot_bytes).decode("utf-8")

def handle_model_action(browser, page, action):
    """Execute actions in the browser"""
    action_type = action.get("type")

    if action_type == "click":
        x, y = action.get("x"), action.get("y")
        page.mouse.click(x, y)
        time.sleep(1)
    elif action_type == "type":
        text = action.get("text")
        page.keyboard.type(text, delay=100)
    elif action_type == "key":
        key = action.get("text")
        page.keyboard.press(key)
        time.sleep(0.5)
    elif action_type == "scroll":
        direction = action.get("direction", "down")
        amount = action.get("amount", 300)
        page.mouse.wheel(0, amount if direction == "down" else -amount)
    elif action_type == "cursor_position":
        x, y = action.get("x"), action.get("y")
        page.mouse.move(x, y)

    return page

def initialize_agent(task_description):
    """Send initial task to OpenAI Computer Use Agent"""
    load_dotenv()
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    response = client.responses.create(
        model="computer-use-preview",
        tools=[{
            "type": "computer_use_preview",
            "display_width": 1024,
            "display_height": 768,
            "environment": "browser"
        }],
        input=[{
            "role": "user",
            "content": [{
                "type": "input_text",
                "text": task_description
            }]
        }],
        reasoning={"summary": "concise"},
        truncation="auto"
    )

    return client, response

def _asks_to_submit(text):
    """Check if agent is asking for submission permission"""
    if not text:
        return False
    text_lower = text.lower()
    return any(phrase in text_lower for phrase in [
        "should i submit", "shall i proceed", "would you like me to",
        "should i go ahead", "ready to submit"
    ])

def computer_use_loop(browser, page, response):
    """Execute the core agent loop"""
    global tools, global_client

    while True:
        computer_calls = [
            item for item in response.output
            if item.type == "computer_call"
        ]

        if not computer_calls:
            out_text = getattr(response, "output_text", "") or ""
            if _asks_to_submit(out_text):
                print("Auto-confirming submission...")
                response = global_client.responses.create(
                    model="computer-use-preview",
                    previous_response_id=response.id,
                    tools=tools,
                    input=[{"role": "user", "content": "Yes, submit the form now."}],
                    truncation="auto"
                )
                continue
            else:
                print("Task completed!")
                for item in response.output:
                    print(item)
                break

        computer_call = computer_calls[0]
        action = computer_call.action

        page = handle_model_action(browser, page, action)
        time.sleep(1)

        screenshot_base64 = get_screenshot(page)

        pending_safety_checks = getattr(computer_call, "pending_safety_checks", []) or []
        acknowledged_safety_checks = [{"id": sc.id} for sc in pending_safety_checks]
        if acknowledged_safety_checks:
            print("Acknowledging safety checks:", acknowledged_safety_checks)

        response = global_client.responses.create(
            model="computer-use-preview",
            previous_response_id=response.id,
            tools=tools,
            input=[{
                "call_id": computer_call.call_id,
                "type": "computer_call_output",
                "output": {
                    "type": "input_image",
                    "image_url": f"data:image/png;base64,{screenshot_base64}"
                }
            }],
            truncation="auto"
        )

    return response

def main():
    """Main execution function"""
    global tools, global_client

    playwright, browser, page = launch_browser()

    try:
        # Choose your task
        task = "What's the weather like in Port Sanilac, Michigan?"
        # task = "Find Android developer jobs in Detroit, Michigan"
        # task = "Fill out the contact form at <https://www.riis.com/contact> with name: Godfrey Nolan, email: godfrey@riis.com, message: Hello from the OpenAI meetup. Then submit the form."

        client, initial_response = initialize_agent(task)
        global_client = client

        tools = [{
            "type": "computer_use_preview",
            "display_width": 1024,
            "display_height": 768,
            "environment": "browser"
        }]

        computer_use_loop(browser, page, initial_response)

    except Exception as e:
        print(f"Error: {e}")
        raise
    finally:
        browser.close()
        playwright.stop()

if __name__ == "__main__":
    main()