Use any model

curl https://www.orgo.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $ORGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "computer_id": "'"$COMPUTER_ID"'",
    "messages": [{"role": "user", "content": "Open Chrome and search for AI news"}]
  }'

x = int(fn_args["x"] / 1000 * 1280)
y = int(fn_args["y"] / 1000 * 720)

import os

import anthropic
import requests
from orgo import Computer

API = "https://www.orgo.ai/api"
HEADERS = {"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"}


def screenshot_base64(computer):
    """The screen as base64 PNG, straight from the API."""
    response = requests.get(
        f"{API}/computers/{computer.computer_id}/screenshot",
        params={"response_format": "base64"},
        headers=HEADERS,
    )
    response.raise_for_status()
    return response.json()["image"]


def scroll(computer, x, y, direction, amount):
    """Scroll at (x, y). Orgo scrolls up or down only."""
    if direction not in ("up", "down"):
        raise ValueError(f"Unsupported scroll direction: {direction}")
    response = requests.post(
        f"{API}/computers/{computer.computer_id}/scroll",
        json={"x": x, "y": y, "direction": direction, "amount": amount},
        headers=HEADERS,
    )
    response.raise_for_status()


# Pass a size: SDKs before 0.0.47 default to 2 GB, which the API rejects.
computer = Computer(ram=4, cpu=1)
client = anthropic.Anthropic()

messages = [{"role": "user", "content": "Open Chrome and search for AI news"}]

tools = [
    {"type": "computer_toolset_20260801"},
    {"type": "bash_20250124", "name": "bash"},
]

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=8192,
    tools=tools,
    messages=messages,
)

# Claude can return several member calls per turn. Run them in order.
for block in response.content:
    if block.type != "tool_use":
        continue

    if block.name == "bash":
        output = computer.bash(block.input["command"])
    elif getattr(block, "toolset_name", None) == "computer":
        if block.name == "screenshot":
            image = screenshot_base64(computer)
            # Return as a tool_result with a base64 image
        elif block.name == "left_click":
            computer.left_click(*block.input["coordinate"])
        elif block.name == "type":
            computer.type(block.input["text"])
        elif block.name == "key":
            computer.key(block.input["text"])
        elif block.name == "scroll":
            scroll(computer, *block.input["coordinate"], block.input["scroll_direction"], block.input["scroll_amount"])

computer.destroy()

import os

import requests
from openai import OpenAI
from orgo import Computer

API = "https://www.orgo.ai/api"
HEADERS = {"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"}


def scroll(computer, x, y, direction, amount):
    """Scroll at (x, y). Orgo scrolls up or down only."""
    if direction not in ("up", "down"):
        raise ValueError(f"Unsupported scroll direction: {direction}")
    response = requests.post(
        f"{API}/computers/{computer.computer_id}/scroll",
        json={"x": x, "y": y, "direction": direction, "amount": amount},
        headers=HEADERS,
    )
    response.raise_for_status()


# Pass a size: SDKs before 0.0.47 default to 2 GB, which the API rejects.
computer = Computer(ram=4, cpu=1)
client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    tools=[{"type": "computer"}],
    input="Open Chrome and search for AI news",
)

# Process computer_call actions, in order
for item in response.output:
    if item.type != "computer_call":
        continue
    for action in item.actions:
        if action.type == "click":
            computer.left_click(action.x, action.y)
        elif action.type == "double_click":
            computer.double_click(action.x, action.y)
        elif action.type == "type":
            computer.type(action.text)
        elif action.type == "keypress":
            # Orgo presses keys with xdotool, which expects X keysym names.
            # The OpenAI guide below maps the rest, such as the arrow keys.
            names = {"ENTER": "Return", "ESC": "Escape", "SPACE": "space", "TAB": "Tab", "BACKSPACE": "BackSpace"}
            computer.key("+".join(names.get(k.upper(), k.lower()) for k in action.keys))
        elif action.type == "scroll":
            scroll_y = getattr(action, "scroll_y", 0)
            scroll(computer, action.x, action.y, "down" if scroll_y > 0 else "up", max(1, abs(scroll_y) // 100))

computer.destroy()

import base64
import io
import os

import requests
from google import genai
from orgo import Computer
from PIL import Image

# Pass a size: SDKs before 0.0.47 default to 2 GB, which the API rejects.
computer = Computer(ram=4, cpu=1)
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")


def get_screenshot_png(computer: Computer) -> str:
    """Fetch the screenshot as base64 and re-encode it as PNG, to match image/png."""
    response = requests.get(
        f"https://www.orgo.ai/api/computers/{computer.computer_id}/screenshot",
        params={"response_format": "base64"},
        headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
    )
    response.raise_for_status()
    image = Image.open(io.BytesIO(base64.b64decode(response.json()["image"])))
    png_buffer = io.BytesIO()
    image.save(png_buffer, format="PNG")
    return base64.b64encode(png_buffer.getvalue()).decode("utf-8")


screenshot_png = get_screenshot_png(computer)

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "text", "text": "Open Chrome and search for AI news"},
        {"type": "image", "data": screenshot_png, "mime_type": "image/png"},
    ],
    tools=[{
        "type": "computer_use",
        "environment": "desktop",
        "enable_prompt_injection_detection": True,
    }],
)

# Coordinates are normalized 0-999, so scale them to the screen
for step in interaction.steps:
    if step.type != "function_call":
        continue
    args = step.arguments
    if step.name == "click":
        computer.left_click(int(args["x"] / 1000 * 1280), int(args["y"] / 1000 * 720))
    elif step.name == "type":
        computer.type(args["text"])

computer.destroy()