Использование компьютера

Модель и инструмент Gemini 2.5 Computer Use Preview позволяют создавать агенты управления браузером, которые взаимодействуют с задачами и автоматизируют их. Используя снимки экрана, модель Computer Use может «видеть» экран компьютера и «действовать», генерируя определённые действия пользовательского интерфейса, такие как щелчки мыши и ввод с клавиатуры. Аналогично вызову функций, необходимо написать код клиентского приложения для получения и выполнения действий Computer Use.

Используя Computer Use, вы можете создавать агенты, которые:

• Автоматизируйте повторяющийся ввод данных или заполнение форм на веб-сайтах.
• Выполнять автоматизированное тестирование веб-приложений и пользовательских потоков
• Проведение исследований на различных веб-сайтах (например, сбор информации о продуктах, ценах и обзорах с сайтов электронной коммерции для информирования о покупке)

Самый простой способ протестировать модель использования компьютера Gemini — использовать эталонную реализацию или демонстрационную среду Browserbase .

Как работает использование компьютера

Чтобы создать агент управления браузером с моделью использования компьютера, реализуйте цикл агента, который выполняет следующие действия:

1. Отправить запрос модели

   • Добавьте инструмент «Использование компьютера» и, при необходимости, любые пользовательские функции или исключенные функции в ваш запрос API.
   • Предоставьте модели «Использование компьютера» запрос пользователя и снимок экрана, отображающий текущее состояние графического интерфейса.

2. Получите модель ответа

   • Модель «Использование компьютера» анализирует запрос пользователя и снимок экрана и генерирует ответ, включающий рекомендуемый function_call , представляющий действие пользовательского интерфейса (например, «щёлкнуть по точке с координатами (x, y)» или «ввести текст»). Описание всех действий пользовательского интерфейса, поддерживаемых моделью «Использование компьютера», см. в разделе «Поддерживаемые действия ».
   • Ответ API может также включать решение safety_decision от внутренней системы безопасности, которая проверяет предлагаемое моделью действие. Это safety_decision классифицирует действие следующим образом:
     • Обычный / разрешённый: действие считается безопасным. Это также может быть отражено отсутствием параметра safety_decision .
     • Требует подтверждения ( require_confirmation ): Модель собирается выполнить действие, которое может быть рискованным (например, нажать на баннер «принять cookie»).

3. Выполнить полученное действие

   • Ваш клиентский код получает function_call и любое сопутствующее safety_decision .
     • Обычный / разрешенный: Если safety_decision указывает на обычный / разрешенный (или если safety_decision отсутствует), ваш клиентский код может выполнить указанный function_call в целевой среде (например, веб-браузере).
     • Требуется подтверждение: если параметр safety_decision указывает, что требуется подтверждение, ваше приложение должно запросить у конечного пользователя подтверждение перед выполнением function_call . Если пользователь подтверждает, продолжить выполнение действия. Если пользователь отклоняет действие, не выполнять действие.

4. Зафиксируйте новое состояние среды

   • Если действие выполнено, ваш клиент делает новый снимок экрана графического интерфейса и текущего URL-адреса для отправки обратно в модель использования компьютера как часть function_response .
   • Если действие заблокировано системой безопасности или отклонено пользователем, ваше приложение может отправить модели другую форму обратной связи или завершить взаимодействие.

Этот процесс повторяется с шага 2, но модель «Использование компьютера» использует новый снимок экрана и текущую цель, чтобы предложить следующее действие. Цикл продолжается до завершения задачи, возникновения ошибки или завершения процесса (например, из-за аварийной ситуации «блокировки» или решения пользователя).

Как реализовать использование компьютера

Перед началом работы с использованием модели и инструмента «Использование компьютера» вам необходимо настроить следующее:

• Безопасная среда выполнения: по соображениям безопасности следует запускать агент Computer Use в безопасной и контролируемой среде (например, в изолированной виртуальной машине, контейнере или выделенном профиле браузера с ограниченными разрешениями).
• Обработчик действий на стороне клиента: вам потребуется реализовать логику на стороне клиента для выполнения действий, сгенерированных моделью, и делать снимки экрана окружающей среды после каждого действия.

В примерах в этом разделе браузер используется в качестве среды выполнения, а Playwright — в качестве обработчика действий на стороне клиента. Для запуска этих примеров необходимо установить необходимые зависимости и инициализировать экземпляр браузера Playwright.

    pip install google-genai playwright
    playwright install chromium
    

    from playwright.sync_api import sync_playwright

    # 1. Configure screen dimensions for the target environment
    SCREEN_WIDTH = 1440
    SCREEN_HEIGHT = 900

    # 2. Start the Playwright browser
    # In production, utilize a sandboxed environment.
    playwright = sync_playwright().start()
    # Set headless=False to see the actions performed on your screen
    browser = playwright.chromium.launch(headless=False)

    # 3. Create a context and page with the specified dimensions
    context = browser.new_context(
        viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT}
    )
    page = context.new_page()

    # 4. Navigate to an initial page to start the task
    page.goto("https://www.google.com")

    # The 'page', 'SCREEN_WIDTH', and 'SCREEN_HEIGHT' variables
    # will be used in the steps below.
    

Пример кода для расширения на среду Android включен в раздел Использование пользовательских функций .

1. Отправить запрос модели

Добавьте инструмент «Использование компьютера» в свой API-запрос и отправьте запрос в модель «Использование компьютера», включающий цель пользователя и начальный снимок экрана графического интерфейса. Необходимо использовать модель «Использование компьютера» Gemini, gemini-2.5-computer-use-preview-10-2025 . При попытке использовать инструмент «Использование компьютера» с другой моделью возникнет ошибка.

При желании вы также можете добавить следующие параметры:

• Исключенные действия: если в списке поддерживаемых действий пользовательского интерфейса есть какие-либо действия, которые вы не хотите, чтобы модель выполняла, укажите эти действия как excluded_predefined_functions .
• Пользовательские функции: В дополнение к инструменту «Использование компьютера» вы можете захотеть включить пользовательские функции.

Обратите внимание, что при формировании запроса нет необходимости указывать размер дисплея; модель прогнозирует координаты пикселей, масштабированные по высоте и ширине экрана.

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

# Specify predefined functions to exclude (optional)
excluded_functions = ["drag_and_drop"]

generate_content_config = genai.types.GenerateContentConfig(
    tools=[
        # 1. Computer Use tool with browser environment
        types.Tool(
            computer_use=types.ComputerUse(
                environment=types.Environment.ENVIRONMENT_BROWSER,
                # Optional: Exclude specific predefined functions
                excluded_predefined_functions=excluded_functions
                )
              ),
        # 2. Optional: Custom user-defined functions
        #types.Tool(
          # function_declarations=custom_functions
          #   )
          ],
  )

# Create the content with user message
contents=[
    Content(
        role="user",
        parts=[
            Part(text="Search for highly rated smart fridges with touchscreen, 2 doors, around 25 cu ft, priced below 4000 dollars on Google Shopping. Create a bulleted list of the 3 cheapest options in the format of name, description, price in an easy-to-read layout."),
            # Optional: include a screenshot of the initial state
            #Part.from_bytes(
                #data=screenshot_image_bytes,
                #mime_type='image/png',
            #),
        ],
    )
]

# Generate content with the configured settings
response = client.models.generate_content(
    model='gemini-2.5-computer-use-preview-10-2025',
    contents=contents,
    config=generate_content_config,
)

# Print the response output
print(response)

Пример использования пользовательских функций см. в разделе Использование пользовательских функций .

2. Получите модель ответа

Модель «Использование компьютера» ответит одним или несколькими FunctionCalls , если определит, что для выполнения задачи необходимы действия пользовательского интерфейса. Модель «Использование компьютера» поддерживает параллельный вызов функций, то есть модель может возвращать несколько действий за один ход.

Вот пример модели ответа.

{
  "content": {
    "parts": [
      {
        "text": "I will type the search query into the search bar. The search bar is in the center of the page."
      },
      {
        "function_call": {
          "name": "type_text_at",
          "args": {
            "x": 371,
            "y": 470,
            "text": "highly rated smart fridges with touchscreen, 2 doors, around 25 cu ft, priced below 4000 dollars on Google Shopping",
            "press_enter": true
          }
        }
      }
    ]
  }
}

3. Выполнить полученные действия.

Код вашего приложения должен анализировать ответ модели, выполнять действия и собирать результаты.

Приведённый ниже пример кода извлекает вызовы функций из ответа модели «Использование компьютера» и преобразует их в действия, которые можно выполнить с помощью Playwright. Модель выводит нормализованные координаты (0–999) независимо от размеров входного изображения, поэтому часть этапа преобразования заключается в преобразовании этих нормализованных координат обратно в фактические значения пикселей.

Рекомендуемый размер экрана для модели «Использование компьютера» — 1440, 900. Модель работает с любым разрешением, хотя это может повлиять на качество результатов.

Обратите внимание, что этот пример включает реализацию только трёх наиболее распространённых действий пользовательского интерфейса: open_web_browser , click_at и type_text_at . Для использования в производственной среде вам потребуется реализовать все остальные действия пользовательского интерфейса из списка поддерживаемых действий , если только вы явно не добавите их как excluded_predefined_functions .

from typing import Any, List, Tuple
import time

def denormalize_x(x: int, screen_width: int) -> int:
    """Convert normalized x coordinate (0-1000) to actual pixel coordinate."""
    return int(x / 1000 * screen_width)

def denormalize_y(y: int, screen_height: int) -> int:
    """Convert normalized y coordinate (0-1000) to actual pixel coordinate."""
    return int(y / 1000 * screen_height)

def execute_function_calls(candidate, page, screen_width, screen_height):
    results = []
    function_calls = []
    for part in candidate.content.parts:
        if part.function_call:
            function_calls.append(part.function_call)

    for function_call in function_calls:
        action_result = {}
        fname = function_call.name
        args = function_call.args
        print(f"  -> Executing: {fname}")

        try:
            if fname == "open_web_browser":
                pass # Already open
            elif fname == "click_at":
                actual_x = denormalize_x(args["x"], screen_width)
                actual_y = denormalize_y(args["y"], screen_height)
                page.mouse.click(actual_x, actual_y)
            elif fname == "type_text_at":
                actual_x = denormalize_x(args["x"], screen_width)
                actual_y = denormalize_y(args["y"], screen_height)
                text = args["text"]
                press_enter = args.get("press_enter", False)

                page.mouse.click(actual_x, actual_y)
                # Simple clear (Command+A, Backspace for Mac)
                page.keyboard.press("Meta+A")
                page.keyboard.press("Backspace")
                page.keyboard.type(text)
                if press_enter:
                    page.keyboard.press("Enter")
            else:
                print(f"Warning: Unimplemented or custom function {fname}")

            # Wait for potential navigations/renders
            page.wait_for_load_state(timeout=5000)
            time.sleep(1)

        except Exception as e:
            print(f"Error executing {fname}: {e}")
            action_result = {"error": str(e)}

        results.append((fname, action_result))

    return results

4. Зафиксируйте новое состояние среды.

После выполнения действий отправьте результат выполнения функции обратно в модель, чтобы она могла использовать эту информацию для генерации следующего действия. Если было выполнено несколько действий (параллельных вызовов), необходимо отправить FunctionResponse для каждого из них в следующем шаге пользователя.

def get_function_responses(page, results):
    screenshot_bytes = page.screenshot(type="png")
    current_url = page.url
    function_responses = []
    for name, result in results:
        response_data = {"url": current_url}
        response_data.update(result)
        function_responses.append(
            types.FunctionResponse(
                name=name,
                response=response_data,
                parts=[types.FunctionResponsePart(
                        inline_data=types.FunctionResponseBlob(
                            mime_type="image/png",
                            data=screenshot_bytes))
                ]
            )
        )
    return function_responses

Создайте агентский цикл

Чтобы реализовать многошаговое взаимодействие, объедините четыре шага из раздела «Как реализовать использование компьютера» в цикл. Не забывайте правильно управлять историей разговора, добавляя как ответы модели, так и ответы вашей функции.

Чтобы запустить этот пример кода вам необходимо:

• Установите необходимые зависимости Playwright .

• Определите вспомогательные функции из шагов (3) Выполните полученные действия и (4) Зафиксируйте новое состояние среды .

import time
from typing import Any, List, Tuple
from playwright.sync_api import sync_playwright

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

# Constants for screen dimensions
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# Setup Playwright
print("Initializing browser...")
playwright = sync_playwright().start()
browser = playwright.chromium.launch(headless=False)
context = browser.new_context(viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT})
page = context.new_page()

# Define helper functions. Copy/paste from steps 3 and 4
# def denormalize_x(...)
# def denormalize_y(...)
# def execute_function_calls(...)
# def get_function_responses(...)

try:
    # Go to initial page
    page.goto("https://ai.google.dev/gemini-api/docs")

    # Configure the model (From Step 1)
    config = types.GenerateContentConfig(
        tools=[types.Tool(computer_use=types.ComputerUse(
            environment=types.Environment.ENVIRONMENT_BROWSER
        ))],
        thinking_config=types.ThinkingConfig(include_thoughts=True),
    )

    # Initialize history
    initial_screenshot = page.screenshot(type="png")
    USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing."
    print(f"Goal: {USER_PROMPT}")

    contents = [
        Content(role="user", parts=[
            Part(text=USER_PROMPT),
            Part.from_bytes(data=initial_screenshot, mime_type='image/png')
        ])
    ]

    # Agent Loop
    turn_limit = 5
    for i in range(turn_limit):
        print(f"\n--- Turn {i+1} ---")
        print("Thinking...")
        response = client.models.generate_content(
            model='gemini-2.5-computer-use-preview-10-2025',
            contents=contents,
            config=config,
        )

        candidate = response.candidates[0]
        contents.append(candidate.content)

        has_function_calls = any(part.function_call for part in candidate.content.parts)
        if not has_function_calls:
            text_response = " ".join([part.text for part in candidate.content.parts if part.text])
            print("Agent finished:", text_response)
            break

        print("Executing actions...")
        results = execute_function_calls(candidate, page, SCREEN_WIDTH, SCREEN_HEIGHT)

        print("Capturing state...")
        function_responses = get_function_responses(page, results)

        contents.append(
            Content(role="user", parts=[Part(function_response=fr) for fr in function_responses])
        )

finally:
    # Cleanup
    print("\nClosing browser...")
    browser.close()
    playwright.stop()

Использование пользовательских функций

При желании вы можете включить в запрос пользовательские функции для расширения функциональности модели. В примере ниже модель и инструмент «Использование компьютера» адаптированы для мобильных приложений, включая пользовательские действия, такие как open_app , long_press_at и go_home , исключая при этом действия, специфичные для браузера. Модель может интеллектуально вызывать эти пользовательские функции наряду со стандартными действиями пользовательского интерфейса для выполнения задач в средах, отличных от браузера.

from typing import Optional, Dict, Any

from google import genai
from google.genai import types
from google.genai.types import Content, Part

client = genai.Client()

SYSTEM_PROMPT = """You are operating an Android phone. Today's date is October 15, 2023, so ignore any other date provided.
* To provide an answer to the user, *do not use any tools* and output your answer on a separate line. IMPORTANT: Do not add any formatting or additional punctuation/text, just output the answer by itself after two empty lines.
* Make sure you scroll down to see everything before deciding something isn't available.
* You can open an app from anywhere. The icon doesn't have to currently be on screen.
* Unless explicitly told otherwise, make sure to save any changes you make.
* If text is cut off or incomplete, scroll or click into the element to get the full text before providing an answer.
* IMPORTANT: Complete the given task EXACTLY as stated. DO NOT make any assumptions that completing a similar task is correct.  If you can't find what you're looking for, SCROLL to find it.
* If you want to edit some text, ONLY USE THE `type` tool. Do not use the onscreen keyboard.
* Quick settings shouldn't be used to change settings. Use the Settings app instead.
* The given task may already be completed. If so, there is no need to do anything.
"""

def open_app(app_name: str, intent: Optional[str] = None) -> Dict[str, Any]:
    """Opens an app by name.

    Args:
        app_name: Name of the app to open (any string).
        intent: Optional deep-link or action to pass when launching, if the app supports it.

    Returns:
        JSON payload acknowledging the request (app name and optional intent).
    """
    return {"status": "requested_open", "app_name": app_name, "intent": intent}

def long_press_at(x: int, y: int) -> Dict[str, int]:
    """Long-press at a specific screen coordinate.

    Args:
        x: X coordinate (absolute), scaled to the device screen width (pixels).
        y: Y coordinate (absolute), scaled to the device screen height (pixels).

    Returns:
        Object with the coordinates pressed and the duration used.
    """
    return {"x": x, "y": y}

def go_home() -> Dict[str, str]:
    """Navigates to the device home screen.

    Returns:
        A small acknowledgment payload.
    """
    return {"status": "home_requested"}

#  Build function declarations
CUSTOM_FUNCTION_DECLARATIONS = [
    types.FunctionDeclaration.from_callable(client=client, callable=open_app),
    types.FunctionDeclaration.from_callable(client=client, callable=long_press_at),
    types.FunctionDeclaration.from_callable(client=client, callable=go_home),
]

#Exclude browser functions
EXCLUDED_PREDEFINED_FUNCTIONS = [
    "open_web_browser",
    "search",
    "navigate",
    "hover_at",
    "scroll_document",
    "go_forward",
    "key_combination",
    "drag_and_drop",
]

#Utility function to construct a GenerateContentConfig
def make_generate_content_config() -> genai.types.GenerateContentConfig:
    """Return a fixed GenerateContentConfig with Computer Use + custom functions."""
    return genai.types.GenerateContentConfig(
        system_instruction=SYSTEM_PROMPT,
        tools=[
            types.Tool(
                computer_use=types.ComputerUse(
                    environment=types.Environment.ENVIRONMENT_BROWSER,
                    excluded_predefined_functions=EXCLUDED_PREDEFINED_FUNCTIONS,
                )
            ),
            types.Tool(function_declarations=CUSTOM_FUNCTION_DECLARATIONS),
        ],
    )

# Create the content with user message
contents: list[Content] = [
    Content(
        role="user",
        parts=[
            # text instruction
            Part(text="Open Chrome, then long-press at 200,400."),
            # optional screenshot attachment
            Part.from_bytes(
                data=screenshot_image_bytes,
                mime_type="image/png",
            ),
        ],
    )
]

# Build your fixed config (from helper)
config = make_generate_content_config()

# Generate content with the configured settings
response = client.models.generate_content(
        model='gemini-2.5-computer-use-preview-10-2025',
        contents=contents,
        config=config,
    )

print(response)

Поддерживаемые действия пользовательского интерфейса

Модель Computer Use может запрашивать следующие действия пользовательского интерфейса через FunctionCall . Клиентский код должен реализовывать логику выполнения этих действий. Примеры см. в справочной реализации .

Безопасность и защищенность

Подтвердить решение по безопасности

В зависимости от действия, ответ модели может также включать в себя решение safety_decision от внутренней системы безопасности, которая проверяет предлагаемое моделью действие.

{
  "content": {
    "parts": [
      {
        "text": "I have evaluated step 2. It seems Google detected unusual traffic and is asking me to verify I'm not a robot. I need to click the 'I'm not a robot' checkbox located near the top left (y=98, x=95).",
      },
      {
        "function_call": {
          "name": "click_at",
          "args": {
            "x": 60,
            "y": 100,
            "safety_decision": {
              "explanation": "I have encountered a CAPTCHA challenge that requires interaction. I need you to complete the challenge by clicking the 'I'm not a robot' checkbox and any subsequent verification steps.",
              "decision": "require_confirmation"
            }
          }
        }
      }
    ]
  }
}

Если параметр safety_decision равен require_confirmation , необходимо запросить подтверждение у конечного пользователя, прежде чем продолжить выполнение действия. Согласно условиям обслуживания , обходить запросы на подтверждение от человека запрещено.

Этот пример кода запрашивает у конечного пользователя подтверждение перед выполнением действия. Если пользователь не подтверждает действие, цикл завершается. Если пользователь подтверждает действие, действие выполняется, и поле safety_acknowledgement помечается как True .

import termcolor

def get_safety_confirmation(safety_decision):
    """Prompt user for confirmation when safety check is triggered."""
    termcolor.cprint("Safety service requires explicit confirmation!", color="red")
    print(safety_decision["explanation"])

    decision = ""
    while decision.lower() not in ("y", "n", "ye", "yes", "no"):
        decision = input("Do you wish to proceed? [Y]es/[N]o\n")

    if decision.lower() in ("n", "no"):
        return "TERMINATE"
    return "CONTINUE"

def execute_function_calls(candidate, page, screen_width, screen_height):

    # ... Extract function calls from response ...

    for function_call in function_calls:
        extra_fr_fields = {}

        # Check for safety decision
        if 'safety_decision' in function_call.args:
            decision = get_safety_confirmation(function_call.args['safety_decision'])
            if decision == "TERMINATE":
                print("Terminating agent loop")
                break
            extra_fr_fields["safety_acknowledgement"] = "true" # Safety acknowledgement

        # ... Execute function call and append to results ...

Если пользователь подтверждает, вы должны включить подтверждение безопасности в свой FunctionResponse .

function_response_parts.append(
    FunctionResponse(
        name=name,
        response={"url": current_url,
                  **extra_fr_fields},  # Include safety acknowledgement
        parts=[
            types.FunctionResponsePart(
                inline_data=types.FunctionResponseBlob(
                    mime_type="image/png", data=screenshot
                )
             )
           ]
         )
       )

Лучшие практики безопасности

Computer Use API — это новый API, который несет в себе новые риски, о которых разработчикам следует помнить:

• Недостоверный контент и мошенничество: стремясь достичь цели пользователя, модель может полагаться на недостоверные источники информации и инструкции на экране. Например, если цель пользователя — купить телефон Pixel, и модель сталкивается с мошенничеством «Pixel бесплатно при прохождении опроса», есть вероятность, что модель его пройдёт.
• Случайные непреднамеренные действия: модель может неверно интерпретировать цель пользователя или содержимое веб-страницы, что приводит к выполнению неверных действий, например, нажатию не той кнопки или заполнению не той формы. Это может привести к сбою задач или утечке данных.
• Нарушения политики: Возможности API могут быть направлены, как преднамеренно, так и непреднамеренно, на действия, нарушающие политику Google ( Политику запрещенного использования Gen AI и Дополнительные условия обслуживания API Gemini) . Сюда входят действия, которые могут нарушить целостность системы, поставить под угрозу безопасность, обойти меры безопасности, управлять медицинскими устройствами и т. д.

Для устранения этих рисков вы можете реализовать следующие меры безопасности и передовые практики:

1. Человек в контуре управления (HITL):

   • Реализуйте подтверждение пользователем: если в ответе безопасности указано require_confirmation , необходимо реализовать подтверждение пользователем перед выполнением. Пример кода см. в разделе « Подтверждение решения о безопасности» .

   • Предоставьте пользовательские инструкции безопасности: Помимо встроенных проверок подтверждения пользователя, разработчики могут при необходимости добавить пользовательскую системную инструкцию , которая будет применять их собственные политики безопасности, блокируя определённые действия модели или требуя подтверждения пользователя перед выполнением моделью определённых необратимых действий с высоким риском. Вот пример пользовательской системной инструкции безопасности, которую вы можете включить при взаимодействии с моделью.

     Примеры инструкций по технике безопасности

     Установите собственные правила безопасности в качестве системной инструкции:

         ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
     
         This is your first and most important check. If the next required action falls
         into any of the following categories, you MUST stop immediately, and seek the
         user's explicit permission.
     
         **Procedure for Seeking Confirmation:**  * **For Consequential Actions:**
         Perform all preparatory steps (e.g., navigating, filling out forms, typing a
         message). You will ask for confirmation **AFTER** all necessary information is
         entered on the screen, but **BEFORE** you perform the final, irreversible action
         (e.g., before clicking "Send", "Submit", "Confirm Purchase", "Share").  * **For
         Prohibited Actions:** If the action is strictly forbidden (e.g., accepting legal
         terms, solving a CAPTCHA), you must first inform the user about the required
         action and ask for their confirmation to proceed.
     
         **USER_CONFIRMATION Categories:**
     
         *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
             agreeing to any of the following on the user's behalf. You must ask the
             user to confirm before performing these actions.
             *   Terms of Service
             *   Privacy Policies
             *   Cookie consent banners
             *   End User License Agreements (EULAs)
             *   Any other legally significant contracts or agreements.
         *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
             following. You must ask the user to confirm before performing these actions.
         *   CAPTCHAs (of any kind)
             *   Any other anti-robot or human-verification mechanisms, even if you are
                 capable.
         *   **Financial Transactions:**
             *   Completing any purchase.
             *   Managing or moving money (e.g., transfers, payments).
             *   Purchasing regulated goods or participating in gambling.
         *   **Sending Communications:**
             *   Sending emails.
             *   Sending messages on any platform (e.g., social media, chat apps).
             *   Posting content on social media or forums.
         *   **Accessing or Modifying Sensitive Information:**
             *   Health, financial, or government records (e.g., medical history, tax
                 forms, passport status).
             *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
                 account number, credit card number).
         *   **User Data Management:**
             *   Accessing, downloading, or saving files from the web.
             *   Sharing or sending files/data to any third party.
             *   Transferring user data between systems.
         *   **Browser Data Usage:**
             *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
                 or saved passwords.
         *   **Security and Identity:**
             *   Logging into any user account.
             *   Any action that involves misrepresentation or impersonation (e.g.,
                 creating a fan account, posting as someone else).
         *   **Insurmountable Obstacles:** If you are technically unable to interact with
             a user interface element or are stuck in a loop you cannot resolve, ask the
             user to take over.
         ---
     
         ## **RULE 2: Default Behavior (ACTUATE)**
     
         If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`,
         your default behavior is to **Actuate**.
     
         **Actuation Means:**  You MUST proactively perform all necessary steps to move
         the user's request forward. Continue to actuate until you either complete the
         non-consequential task or encounter a condition defined in Rule 1.
     
         *   **Example 1:** If asked to send money, you will navigate to the payment
             portal, enter the recipient's details, and enter the amount. You will then
             **STOP** as per Rule 1 and ask for confirmation before clicking the final
             "Send" button.
         *   **Example 2:** If asked to post a message, you will navigate to the site,
             open the post composition window, and write the full message. You will then
             **STOP** as per Rule 1 and ask for confirmation before clicking the final
             "Post" button.
     
             After the user has confirmed, remember to get the user's latest screen
             before continuing to perform actions.
     
         # Final Response Guidelines:
         Write final response to the user in the following cases:
         - User confirmation
         - When the task is complete or you have enough information to respond to the user
         

2. Безопасная среда выполнения: запустите свой агент в безопасной изолированной среде, чтобы ограничить его потенциальное воздействие (например, изолированная виртуальная машина (VM), контейнер (например, Docker) или выделенный профиль браузера с ограниченными разрешениями).

3. Очистка ввода: Очистка всего пользовательского текста в подсказках для снижения риска непреднамеренного ввода инструкций или внедрения подсказок. Это полезный уровень безопасности, но не замена безопасной среде выполнения.

4. Защитные барьеры для контента: используйте API-интерфейсы защитных барьеров и безопасности контента для оценки ввода данных пользователем, ввода и вывода инструментов, реакции агента на уместность, быстрого внедрения и обнаружения джейлбрейка.

5. Списки разрешённых и заблокированных сайтов: реализуйте механизмы фильтрации, чтобы контролировать, куда может перемещаться модель и что она может делать. Список заблокированных веб-сайтов — хорошая отправная точка, но более строгий список заблокированных сайтов ещё более безопасен.

6. Наблюдаемость и ведение журнала: ведите подробные журналы для отладки, аудита и реагирования на инциденты. Ваш клиент должен регистрировать запросы, снимки экрана, действия, предлагаемые моделью (function_call), меры безопасности и все действия, выполняемые клиентом.

7. Управление средой: Обеспечьте единообразие графического интерфейса. Неожиданные всплывающие окна, уведомления или изменения макета могут сбить модель с толку. По возможности начинайте с известного, чистого состояния для каждой новой задачи.

Версии модели

Что дальше?

• Поэкспериментируйте с использованием компьютера в демонстрационной среде Browserbase .
• Ознакомьтесь с примером реализации кода.
• Узнайте о других инструментах API Gemini:
  • Вызов функции
  • Заземление с помощью поиска Google