Utilisation d'un ordinateur

Le modèle et l'outil Gemini 2.5 Computer Use Preview vous permettent de créer des agents de contrôle du navigateur qui interagissent avec les tâches et les automatisent. À l'aide de captures d'écran, le modèle d'utilisation de l'ordinateur peut "voir" un écran d'ordinateur et "agir" en générant des actions d'interface utilisateur spécifiques, comme des clics de souris et des saisies au clavier. Comme pour l'appel de fonction, vous devez écrire le code de l'application côté client pour recevoir et exécuter les actions d'utilisation de l'ordinateur.

Avec l'utilisation de l'ordinateur, vous pouvez créer des agents qui :

• Automatisez la saisie de données répétitives ou le remplissage de formulaires sur les sites Web.
• Effectuer des tests automatisés des applications Web et des parcours utilisateur
• Effectuer des recherches sur différents sites Web (par exemple, recueillir des informations sur les produits, les prix et les avis sur les sites d'e-commerce pour prendre une décision d'achat)

Le moyen le plus simple de tester le modèle Gemini Computer Use est d'utiliser l'implémentation de référence ou l'environnement de démonstration Browserbase.

Fonctionnement de l'utilisation d'un ordinateur

Pour créer un agent de contrôle du navigateur avec le modèle d'utilisation de l'ordinateur, implémentez une boucle d'agent qui effectue les opérations suivantes :

1. Envoyer une requête au modèle

   • Ajoutez l'outil d'utilisation de l'ordinateur et, éventuellement, des fonctions personnalisées ou exclues à votre requête API.
   • Fournissez au modèle d'utilisation de l'ordinateur la requête de l'utilisateur et une capture d'écran représentant l'état actuel de l'interface utilisateur graphique.

2. Recevoir la réponse du modèle

   • Le modèle d'utilisation de l'ordinateur analyse la requête et la capture d'écran de l'utilisateur, puis génère une réponse qui inclut une function_call suggérée représentant une action d'interface utilisateur (par exemple, "click at coordinate (x,y)" ou "type 'text'"). Pour obtenir la description de toutes les actions d'interface utilisateur compatibles avec le modèle Computer Use, consultez Actions compatibles.
   • La réponse de l'API peut également inclure un safety_decision provenant d'un système de sécurité interne qui vérifie l'action proposée par le modèle. Ce safety_decision classe l'action comme suit :
     • Normale / Autorisée : l'action est considérée comme sûre. Cela peut également être représenté par l'absence de safety_decision.
     • Nécessite une confirmation (require_confirmation) : le modèle est sur le point d'effectuer une action potentiellement risquée (par exemple, cliquer sur une bannière "Accepter les cookies").

3. Exécuter l'action reçue

   • Votre code côté client reçoit le function_call et tout safety_decision associé.
     • Régulier / Autorisé : si safety_decision indique "Régulier/Autorisé" (ou si aucun safety_decision n'est présent), votre code côté client peut exécuter le function_call spécifié dans votre environnement cible (par exemple, un navigateur Web).
     • Confirmation requise : si safety_decision indique qu'une confirmation est requise, votre application doit demander à l'utilisateur final de confirmer avant d'exécuter function_call. Si l'utilisateur confirme, exécutez l'action. Si l'utilisateur refuse, n'exécutez pas l'action.

4. Capturer l'état du nouvel environnement

   • Si l'action a été exécutée, votre client capture une nouvelle capture d'écran de l'interface utilisateur graphique et l'URL actuelle pour les renvoyer au modèle d'utilisation de l'ordinateur dans le cadre d'un function_response.
   • Si une action a été bloquée par le système de sécurité ou si l'utilisateur a refusé de la confirmer, votre application peut envoyer une autre forme de commentaires au modèle ou mettre fin à l'interaction.

Ce processus se répète à partir de l'étape 2 avec le modèle d'utilisation de l'ordinateur, en utilisant la nouvelle capture d'écran et l'objectif en cours pour suggérer la prochaine action. La boucle se poursuit jusqu'à ce que la tâche soit terminée, qu'une erreur se produise ou que le processus soit arrêté (par exemple, en raison d'une réponse de sécurité "bloquer" ou d'une décision de l'utilisateur).

Implémenter l'utilisation de l'ordinateur

Avant de créer des applications avec le modèle et l'outil d'utilisation de l'ordinateur, vous devez configurer les éléments suivants :

• Environnement d'exécution sécurisé : pour des raisons de sécurité, vous devez exécuter votre agent d'utilisation de l'ordinateur dans un environnement sécurisé et contrôlé (par exemple, une machine virtuelle en bac à sable, un conteneur ou un profil de navigateur dédié avec des autorisations limitées).
• Gestionnaire d'actions côté client : vous devrez implémenter une logique côté client pour exécuter les actions générées par le modèle et capturer des captures d'écran de l'environnement après chaque action.

Les exemples de cette section utilisent un navigateur comme environnement d'exécution et Playwright comme gestionnaire d'actions côté client. Pour exécuter ces exemples, vous devez installer les dépendances nécessaires et initialiser une instance de navigateur 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.
    

Un exemple de code pour l'extension à un environnement Android est inclus dans la section Utiliser des fonctions personnalisées définies par l'utilisateur.

1. Envoyer une requête au modèle

Ajoutez l'outil Computer Use à votre requête d'API et envoyez une invite au modèle Computer Use qui inclut l'objectif de l'utilisateur et une capture d'écran initiale de l'interface utilisateur graphique. Vous devez utiliser le modèle Gemini Computer Use, gemini-2.5-computer-use-preview-10-2025. Si vous essayez d'utiliser l'outil Utilisation de l'ordinateur avec un autre modèle, une erreur s'affiche.

Vous pouvez également ajouter les paramètres facultatifs suivants :

• Actions exclues : si certaines actions de la liste des actions d'UI acceptées ne doivent pas être effectuées par le modèle, spécifiez-les comme excluded_predefined_functions.
• Fonctions définies par l'utilisateur : en plus de l'outil Utilisation de l'ordinateur, vous pouvez inclure des fonctions définies par l'utilisateur personnalisées.

Notez qu'il n'est pas nécessaire de spécifier la taille d'affichage lors de l'envoi d'une requête. Le modèle prédit les coordonnées en pixels mises à l'échelle de la hauteur et de la largeur de l'écran.

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)

Pour obtenir un exemple avec des fonctions personnalisées, consultez Utiliser des fonctions définies par l'utilisateur personnalisées.

2. Recevoir la réponse du modèle

Le modèle d'utilisation de l'ordinateur répondra avec un ou plusieurs FunctionCalls s'il détermine que des actions d'interface utilisateur sont nécessaires pour accomplir la tâche. L'utilisation de l'ordinateur est compatible avec l'appel de fonction parallèle, ce qui signifie que le modèle peut renvoyer plusieurs actions en un seul tour.

Voici un exemple de réponse du modèle.

{
  "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. Exécuter les actions reçues

Le code de votre application doit analyser la réponse du modèle, exécuter les actions et collecter les résultats.

L'exemple de code ci-dessous extrait les appels de fonction de la réponse du modèle d'utilisation de l'ordinateur et les traduit en actions pouvant être exécutées avec Playwright. Le modèle génère des coordonnées normalisées (0 à 999), quelles que soient les dimensions de l'image d'entrée. Une partie de l'étape de traduction consiste donc à reconvertir ces coordonnées normalisées en valeurs de pixels réelles.

La taille d'écran recommandée pour une utilisation avec le modèle "Utilisation de l'ordinateur" est (1440, 900). Le modèle fonctionnera avec n'importe quelle résolution, mais la qualité des résultats peut être affectée.

Cet exemple n'inclut que l'implémentation des trois actions d'UI les plus courantes : open_web_browser, click_at et type_text_at. Pour les cas d'utilisation en production, vous devrez implémenter toutes les autres actions d'UI de la liste Actions acceptées, sauf si vous les ajoutez explicitement en tant que 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. Comprendre l'état du nouvel environnement

Après avoir exécuté les actions, renvoyez le résultat de l'exécution de la fonction au modèle afin qu'il puisse utiliser ces informations pour générer l'action suivante. Si plusieurs actions (appels parallèles) ont été exécutées, vous devez envoyer un FunctionResponse pour chacune d'elles lors du tour de l'utilisateur suivant.

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)

Créer une boucle d'agent

Pour activer les interactions en plusieurs étapes, combinez les quatre étapes de la section Implémenter l'utilisation de l'ordinateur dans une boucle. N'oubliez pas de gérer correctement l'historique des conversations en ajoutant les réponses du modèle et vos réponses de fonction.

Pour exécuter cet exemple de code, vous devez :

• Installez les dépendances Playwright nécessaires.

• Définissez les fonctions d'assistance des étapes (3) Exécuter les actions reçues et (4) Capturer le nouvel état de l'environnement.

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

Utiliser des fonctions définies par l'utilisateur personnalisées

Vous pouvez éventuellement inclure des fonctions personnalisées définies par l'utilisateur dans votre requête pour étendre les fonctionnalités du modèle. L'exemple ci-dessous adapte le modèle et l'outil d'utilisation de l'ordinateur aux cas d'utilisation mobiles en incluant des actions personnalisées définies par l'utilisateur, telles que open_app, long_press_at et go_home, tout en excluant les actions spécifiques au navigateur. Le modèle peut appeler intelligemment ces fonctions personnalisées en plus des actions d'interface utilisateur standards pour effectuer des tâches dans des environnements autres que le navigateur.

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)

Actions d'UI compatibles

Le modèle d'utilisation de l'ordinateur peut demander les actions d'UI suivantes via un FunctionCall. Votre code côté client doit implémenter la logique d'exécution de ces actions. Pour obtenir des exemples, consultez l'implémentation de référence.

Protection et sécurité

Confirmer la décision de sécurité

Selon l'action, la réponse du modèle peut également inclure un safety_decision provenant d'un système de sécurité interne qui vérifie l'action proposée par le modèle.

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

Si safety_decision est défini sur require_confirmation, vous devez demander à l'utilisateur final de confirmer avant d'exécuter l'action. Conformément aux Conditions d'utilisation, vous n'êtes pas autorisé à contourner les demandes de confirmation humaine.

Cet exemple de code demande à l'utilisateur final de confirmer l'action avant de l'exécuter. Si l'utilisateur ne confirme pas l'action, la boucle se termine. Si l'utilisateur confirme l'action, celle-ci est exécutée et le champ safety_acknowledgement est marqué comme 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 ...

Si l'utilisateur confirme, vous devez inclure la confirmation de sécurité dans votre 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
                )
             )
           ]
         )
       )

Bonnes pratiques concernant la sécurité

L'API Computer Use est une nouvelle API qui présente de nouveaux risques dont les développeurs doivent être conscients :

• Contenus non fiables et escroqueries : pour atteindre l'objectif de l'utilisateur, le modèle peut s'appuyer sur des sources d'informations et des instructions non fiables provenant de l'écran. Par exemple, si l'objectif de l'utilisateur est d'acheter un téléphone Pixel et que le modèle rencontre une arnaque "Pixel sans frais si vous répondez à une enquête", il y a une chance que le modèle réponde à l'enquête.
• Actions involontaires occasionnelles : le modèle peut mal interpréter l'objectif d'un utilisateur ou le contenu d'une page Web, ce qui l'amène à effectuer des actions incorrectes, comme cliquer sur le mauvais bouton ou remplir le mauvais formulaire. Cela peut entraîner l'échec de tâches ou l'exfiltration de données.
• Non-respect des règles : les fonctionnalités de l'API peuvent être orientées, intentionnellement ou non, vers des activités qui enfreignent les règles de Google (Règlement sur les utilisations interdites de l'IA générative et les Conditions d'utilisation supplémentaires de l'API Gemini). Cela inclut les actions qui pourraient nuire à l'intégrité d'un système, compromettre la sécurité, contourner les mesures de sécurité, contrôler des dispositifs médicaux, etc.

Pour faire face à ces risques, vous pouvez mettre en œuvre les mesures de sécurité et les bonnes pratiques suivantes :

1. Human-in-the-loop (HITL) :

   • Implémentez la confirmation de l'utilisateur : lorsque la réponse de sécurité indique require_confirmation, vous devez implémenter la confirmation de l'utilisateur avant l'exécution. Pour obtenir un exemple de code, consultez Confirmer la décision de sécurité.

   • Fournir des consignes de sécurité personnalisées : en plus des vérifications de confirmation de l'utilisateur intégrées, les développeurs peuvent éventuellement ajouter une instruction système personnalisée qui applique leurs propres règles de sécurité, soit pour bloquer certaines actions du modèle, soit pour exiger la confirmation de l'utilisateur avant que le modèle n'effectue certaines actions irréversibles à fort enjeu. Voici un exemple d'instruction de système de sécurité personnalisé que vous pouvez inclure lorsque vous interagissez avec le modèle.

     Exemples d'instructions de sécurité

     Définissez vos règles de sécurité personnalisées comme instruction système :

         ## **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. Environnement d'exécution sécurisé : exécutez votre agent dans un environnement sécurisé de type bac à sable pour limiter son impact potentiel (par exemple, Une machine virtuelle (VM) sandboxée, un conteneur (par exemple, Docker) ou un profil de navigateur dédié avec des autorisations limitées).

3. Assainissement des entrées : assainissez tout le texte généré par les utilisateurs dans les prompts pour réduire le risque d'instructions involontaires ou d'injection de prompts. Il s'agit d'une couche de sécurité utile, mais elle ne remplace pas un environnement d'exécution sécurisé.

4. Garde-fous pour le contenu : utilisez des garde-fous et des API de sécurité du contenu pour évaluer la pertinence des entrées utilisateur, des entrées et sorties d'outils, et des réponses d'un agent, ainsi que pour détecter les injections de code et les tentatives de jailbreak.

5. Listes d'autorisation et de blocage : implémentez des mécanismes de filtrage pour contrôler les sites que le modèle peut consulter et les actions qu'il peut effectuer. Une liste de blocage des sites Web interdits est un bon point de départ, mais une liste d'autorisation plus restrictive est encore plus sécurisée.

6. Observabilité et journalisation : conservez des journaux détaillés pour le débogage, l'audit et la réponse aux incidents. Votre client doit consigner les requêtes, les captures d'écran, les actions suggérées par le modèle (function_call), les réponses liées à la sécurité et toutes les actions finalement exécutées par le client.

7. Gestion de l'environnement : assurez-vous que l'environnement de l'interface utilisateur graphique est cohérent. Les pop-ups, les notifications ou les modifications de mise en page inattendus peuvent dérouter le modèle. Si possible, commencez chaque nouvelle tâche à partir d'un état propre et connu.

Versions de modèle

Étape suivante

• Testez l'utilisation de l'ordinateur dans l'environnement de démonstration Browserbase.
• Consultez l'implémentation de référence pour obtenir un exemple de code.
• Découvrez d'autres outils de l'API Gemini :
  • Appel de fonction
  • Ancrage avec la recherche Google