Korzystanie z komputera

Model i narzędzie Gemini 2.5 Computer Use Preview umożliwiają tworzenie agentów sterujących przeglądarką, którzy wchodzą w interakcje z użytkownikiem i automatyzują zadania. Model Computer Use może „widzieć” ekran komputera na podstawie zrzutów ekranu i „działać”, generując określone działania interfejsu, takie jak kliknięcia myszą i wpisywanie tekstu na klawiaturze. Podobnie jak w przypadku wywoływania funkcji musisz napisać kod aplikacji po stronie klienta, aby odbierać i wykonywać działania związane z korzystaniem z komputera.

Za pomocą funkcji Korzystanie z komputera możesz tworzyć agentów, którzy:

• automatyzować powtarzające się wprowadzanie danych lub wypełnianie formularzy w witrynach;
• Przeprowadzanie automatycznych testów aplikacji internetowych i ścieżek użytkowników
• prowadzić badania w różnych witrynach (np. zbierać informacje o produktach, cenach i opiniach w witrynach e-commerce, aby podjąć decyzję o zakupie);

Najłatwiej przetestować model Gemini do użytku na komputerze za pomocą implementacji referencyjnej lub środowiska demonstracyjnego Browserbase.

Jak działa funkcja Korzystanie z komputera

Aby utworzyć agenta sterującego przeglądarką za pomocą modelu Computer Use, zaimplementuj pętlę agenta, która wykonuje te czynności:

1. Wysyłanie żądania do modelu

   • Dodaj do żądania interfejsu API narzędzie Computer Use i opcjonalnie dowolne funkcje niestandardowe zdefiniowane przez użytkownika lub wykluczone funkcje.
   • Przekaż modelowi Computer Use prośbę użytkownika i zrzut ekranu przedstawiający bieżący stan interfejsu GUI.

2. Otrzymywanie odpowiedzi modelu

   • Model Computer Use analizuje prośbę użytkownika i zrzut ekranu oraz generuje odpowiedź, która zawiera sugerowany function_call reprezentujący działanie interfejsu (np. „click at coordinate (x,y)” lub „type 'text'”). Opis wszystkich działań w interfejsie obsługiwanych przez model Computer Use znajdziesz w sekcji Obsługiwane działania.
   • Odpowiedź interfejsu API może też zawierać safety_decision z wewnętrznego systemu bezpieczeństwa, który sprawdza proponowane działanie modelu. Ten kod safety_decision klasyfikuje działanie jako:
     • Zwykłe / dozwolone: działanie jest uznawane za bezpieczne. Może to też oznaczać brak symbolu safety_decision.
     • Wymaga potwierdzenia (require_confirmation): model ma wykonać działanie, które może być ryzykowne (np. kliknięcie banera z prośbą o zgodę na stosowanie plików cookie).

3. Wykonaj otrzymane działanie

   • Kod po stronie klienta otrzymuje wartość function_call i wszelkie towarzyszące jej safety_decision.
     • Zwykłe / dozwolone: jeśli symbol safety_decision wskazuje, że działanie jest zwykłe / dozwolone (lub jeśli nie ma symbolu safety_decision), kod po stronie klienta może wykonać określone działanie function_call w środowisku docelowym (np. w przeglądarce internetowej).
     • Wymaga potwierdzenia: jeśli safety_decision wskazuje, że wymaga potwierdzenia, aplikacja musi poprosić użytkownika o potwierdzenie przed wykonaniem function_call. Jeśli użytkownik potwierdzi, wykonaj działanie. Jeśli użytkownik odmówi, nie wykonuj działania.

4. Zapisz stan nowego środowiska

   • Jeśli działanie zostało wykonane, klient robi nowy zrzut ekranu interfejsu GUI i aktualnego adresu URL, aby wysłać go z powrotem do modelu Computer Use w ramach function_response.
   • Jeśli działanie zostało zablokowane przez system bezpieczeństwa lub użytkownik odmówił potwierdzenia, aplikacja może wysłać do modelu inną formę opinii lub zakończyć interakcję.

Proces powtarza się od kroku 2. Model Computer Use używa nowego zrzutu ekranu i bieżącego celu, aby zasugerować następne działanie. Pętla jest kontynuowana, dopóki zadanie nie zostanie wykonane, nie wystąpi błąd lub proces nie zostanie zakończony (np. z powodu odpowiedzi zabezpieczającej „blokuj” lub decyzji użytkownika).

Jak wdrożyć funkcję Korzystanie z komputera

Zanim zaczniesz korzystać z modelu i narzędzia Computer Use, musisz skonfigurować te elementy:

• Bezpieczne środowisko wykonawcze: ze względów bezpieczeństwa agenta korzystającego z komputera należy uruchamiać w bezpiecznym i kontrolowanym środowisku (np. w piaskownicy, maszynie wirtualnej, kontenerze lub dedykowanym profilu przeglądarki z ograniczonymi uprawnieniami).
• Obsługa działań po stronie klienta: musisz wdrożyć logikę po stronie klienta, aby wykonywać działania generowane przez model i robić zrzuty ekranu środowiska po każdym działaniu.

Przykłady w tej sekcji używają przeglądarki jako środowiska wykonawczego i Playwright jako modułu obsługi działań po stronie klienta. Aby uruchomić te przykłady, musisz zainstalować niezbędne zależności i zainicjować instancję przeglądarki 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.
    

Przykładowy kod rozszerzający funkcje na środowisko Androida znajdziesz w sekcji Korzystanie z niestandardowych funkcji zdefiniowanych przez użytkownika.

1. Wysyłanie żądania do modelu

Dodaj narzędzie Computer Use do żądania API i wyślij prompt do modelu Computer Use, który zawiera cel użytkownika i początkowy zrzut ekranu GUI. Musisz używać modelu Gemini Computer Use, gemini-2.5-computer-use-preview-10-2025. Jeśli spróbujesz użyć narzędzia Computer Use z innym modelem, pojawi się błąd.

Opcjonalnie możesz też dodać te parametry:

• Wykluczone działania: jeśli na liście obsługiwanych działań interfejsu znajdują się działania, których model nie powinien wykonywać, określ je jako excluded_predefined_functions.
• Funkcje zdefiniowane przez użytkownika: oprócz narzędzia do korzystania z komputera możesz uwzględnić niestandardowe funkcje zdefiniowane przez użytkownika.

Pamiętaj, że podczas wysyłania żądania nie musisz określać rozmiaru wyświetlacza. Model przewiduje współrzędne pikseli przeskalowane do wysokości i szerokości ekranu.

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)

Przykład użycia funkcji niestandardowych znajdziesz w artykule Korzystanie z niestandardowych funkcji zdefiniowanych przez użytkownika.

2. Otrzymywanie odpowiedzi modelu

Model Computer Use odpowie jednym lub kilkoma symbolami FunctionCalls, jeśli uzna, że do wykonania zadania potrzebne są działania w interfejsie. Używanie komputera obsługuje równoległe wywoływanie funkcji, co oznacza, że model może zwracać wiele działań w ramach jednej tury.

Oto przykładowa odpowiedź modelu.

{
  "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. wykonywać otrzymane działania,

Kod aplikacji musi przeanalizować odpowiedź modelu, wykonać działania i zebrać wyniki.

Poniższy przykładowy kod wyodrębnia wywołania funkcji z odpowiedzi modelu Computer Use i tłumaczy je na działania, które można wykonać za pomocą Playwright. Model zwraca znormalizowane współrzędne (0–999) niezależnie od wymiarów obrazu wejściowego, więc częścią procesu tłumaczenia jest przekształcenie tych znormalizowanych współrzędnych z powrotem na rzeczywiste wartości pikseli.

Zalecany rozmiar ekranu do korzystania z modelu Computer Use to (1440, 900). Model będzie działać w dowolnej rozdzielczości, ale może to wpłynąć na jakość wyników.

Ten przykład zawiera tylko implementację 3 najczęstszych działań w interfejsie: open_web_browser, click_at i type_text_at. W przypadku zastosowań produkcyjnych musisz wdrożyć wszystkie inne działania interfejsu z listy Obsługiwane działania, chyba że wyraźnie dodasz je jako 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

# Execute function calls
candidate = response.candidates[0]
results = execute_function_calls(response.candidates[0], page, SCREEN_WIDTH, SCREEN_HEIGHT)

4. Przechwytywanie nowego stanu środowiska

Po wykonaniu działań wyślij wynik wykonania funkcji z powrotem do modelu, aby mógł on wykorzystać te informacje do wygenerowania następnego działania. Jeśli wykonano kilka działań (wywołań równoległych), w kolejnej turze użytkownika musisz wysłać FunctionResponse dla każdego z nich.

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

# Capture state and return to model
function_responses = get_function_responses(page, results)
user_feedback_content = Content(
    role="user",
    parts=[Part(function_response=fr) for fr in function_responses])

# Append this feedback to the 'contents' history list for the next API call.
contents.append(user_feedback_content)

Tworzenie pętli agenta

Aby włączyć interakcje wieloetapowe, połącz w pętlę 4 kroki z sekcji Jak wdrożyć korzystanie z komputera. Pamiętaj, aby prawidłowo zarządzać historią rozmów, dołączając zarówno odpowiedzi modelu, jak i odpowiedzi funkcji.

Aby uruchomić ten przykładowy kod, musisz:

• Zainstaluj niezbędne zależności Playwright.

• Zdefiniuj funkcje pomocnicze z kroków (3) Wykonaj otrzymane działania i (4) Zarejestruj nowy stan środowiska.

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()

Korzystanie z niestandardowych funkcji zdefiniowanych przez użytkownika

Opcjonalnie możesz dołączyć do żądania niestandardowe funkcje zdefiniowane przez użytkownika, aby rozszerzyć funkcjonalność modelu. Poniższy przykład dostosowuje model i narzędzie Computer Use do zastosowań mobilnych, uwzględniając niestandardowe działania zdefiniowane przez użytkownika, takie jak open_app, long_press_at i go_home, a wykluczając działania specyficzne dla przeglądarki. Model może inteligentnie wywoływać te funkcje niestandardowe wraz ze standardowymi działaniami interfejsu, aby wykonywać zadania w środowiskach innych niż przeglądarka.

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)

Obsługiwane działania w interfejsie

Model Computer Use może wysyłać żądania wykonania tych działań w interfejsie za pomocą elementu FunctionCall. Kod po stronie klienta musi implementować logikę wykonywania tych działań. Przykłady znajdziesz w implementacji referencyjnej.

Bezpieczeństwo

Potwierdzenie decyzji dotyczącej bezpieczeństwa

W zależności od działania odpowiedź modelu może też zawierać symbol safety_decision z wewnętrznego systemu bezpieczeństwa, który sprawdza proponowane działanie modelu.

{
  "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"
            }
          }
        }
      }
    ]
  }
}

Jeśli wartość parametru safety_decision to require_confirmation, musisz poprosić użytkownika o potwierdzenie przed wykonaniem działania. Zgodnie z warunkami korzystania z usługi nie możesz pomijać próśb o potwierdzenie przez człowieka.

Ten przykładowy kod prosi użytkownika o potwierdzenie przed wykonaniem działania. Jeśli użytkownik nie potwierdzi działania, pętla zostanie zakończona. Jeśli użytkownik potwierdzi działanie, zostanie ono wykonane, a pole safety_acknowledgement zostanie oznaczone jako 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 ...

Jeśli użytkownik potwierdzi, musisz umieścić potwierdzenie bezpieczeństwa w 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
                )
             )
           ]
         )
       )

Sprawdzone metody ochrony bezpieczeństwa

Interfejs Computer Use API jest nowym interfejsem API i wiąże się z nowymi zagrożeniami, o których deweloperzy powinni pamiętać:

• Niezaufane treści i oszustwa: aby osiągnąć cel użytkownika, model może korzystać z niezaufanych źródeł informacji i instrukcji wyświetlanych na ekranie. Jeśli na przykład celem użytkownika jest zakup Pixela, a model natrafi na oszustwo typu „Bezpłatny Pixel za wypełnienie ankiety”, istnieje pewne prawdopodobieństwo, że model wypełni ankietę.
• Sporadyczne niezamierzone działania: model może błędnie zinterpretować cel użytkownika lub treść strony internetowej, co spowoduje podjęcie nieprawidłowych działań, takich jak kliknięcie niewłaściwego przycisku lub wypełnienie niewłaściwego formularza. Może to prowadzić do niepowodzenia zadań lub eksfiltracji danych.
• Naruszenia zasad: funkcje interfejsu API mogą być wykorzystywane, celowo lub nie, do działań, które naruszają zasady Google (zasady dotyczące niedozwolonych zastosowań generatywnej AI i Dodatkowe warunki korzystania z Gemini API). Dotyczy to działań, które mogą zakłócać integralność systemu, zagrażać bezpieczeństwu, omijać środki bezpieczeństwa, sterować urządzeniami medycznymi itp.

Aby ograniczyć te zagrożenia, możesz wdrożyć te środki bezpieczeństwa i sprawdzone metody:

1. Proces z udziałem człowieka:

   • Wdrożenie potwierdzenia przez użytkownika: gdy odpowiedź dotycząca bezpieczeństwa wskazuje na require_confirmation, przed wykonaniem działania musisz wdrożyć potwierdzenie przez użytkownika. Przykładowy kod znajdziesz w sekcji Potwierdzanie decyzji dotyczącej bezpieczeństwa.

   • Podaj niestandardowe instrukcje dotyczące bezpieczeństwa: oprócz wbudowanych kontroli potwierdzenia przez użytkownika deweloperzy mogą opcjonalnie dodać niestandardową instrukcję systemową, która wymusza ich własne zasady bezpieczeństwa, aby blokować określone działania modelu lub wymagać potwierdzenia przez użytkownika, zanim model podejmie określone nieodwracalne działania o wysokim ryzyku. Oto przykład niestandardowej instrukcji dotyczącej bezpieczeństwa, którą możesz uwzględnić podczas interakcji z modelem.

     Przykładowe instrukcje bezpieczeństwa

     Ustaw własne reguły bezpieczeństwa jako instrukcję systemową:

         ## **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. Bezpieczne środowisko wykonawcze: uruchamiaj agenta w bezpiecznym środowisku w piaskownicy, aby ograniczyć jego potencjalny wpływ (np. odizolowanej maszyny wirtualnej, kontenera (np. Docker) lub dedykowany profil przeglądarki z ograniczonymi uprawnieniami.

3. Czyszczenie danych wejściowych: czyść cały tekst wygenerowany przez użytkowników w promptach, aby zmniejszyć ryzyko niezamierzonych instrukcji lub wstrzykiwania promptów. Jest to przydatna warstwa zabezpieczeń, ale nie zastępuje bezpiecznego środowiska wykonawczego.

4. Ograniczenia dotyczące treści: używaj ograniczeń i interfejsów API bezpieczeństwa treści, aby oceniać dane wejściowe użytkownika, dane wejściowe i wyjściowe narzędzia oraz odpowiedź agenta pod kątem odpowiedniości, wstrzykiwania promptów i wykrywania jailbreaku.

5. Listy dozwolonych i zablokowanych: wdróż mechanizmy filtrowania, aby kontrolować, gdzie model może się poruszać i co może robić. Dobrym punktem wyjścia jest lista zablokowanych zabronionych witryn, a jeszcze bezpieczniejsza jest bardziej restrykcyjna lista dozwolonych.

6. Obserwacja i rejestrowanie: prowadź szczegółowe dzienniki na potrzeby debugowania, kontroli i reagowania na incydenty. Klient powinien rejestrować prompty, zrzuty ekranu, sugerowane przez model działania (function_call), odpowiedzi związane z bezpieczeństwem i wszystkie działania ostatecznie wykonywane przez klienta.

7. Zarządzanie środowiskiem: zapewnij spójność środowiska GUI. Nieoczekiwane wyskakujące okienka, powiadomienia lub zmiany układu mogą wprowadzić model w błąd. W miarę możliwości zaczynaj każde nowe zadanie od znanego, czystego stanu.

Wersje modelu

Co dalej?

• Wypróbuj funkcję Computer Use w środowisku demonstracyjnym Browserbase.
• Przykładowy kod znajdziesz w implementacji referencyjnej.
• Dowiedz się więcej o innych narzędziach Gemini API:
  • Wywoływanie funkcji
  • Grounding z użyciem wyszukiwarki Google