L'outil d'utilisation de l'ordinateur de Gemini vous permet de créer des agents de contrôle pour navigateur, mobile et ordinateur qui interagissent avec les interfaces utilisateur graphiques (IUG) et automatisent les tâches. Lorsque l'utilisation de l'ordinateur est activée, le modèle utilise des captures d'écran pour observer l'écran et agir en générant des actions d'interface utilisateur spécifiques, telles que des clics de souris, des défilements et des entrées au clavier.
Gemini est compatible avec plusieurs fonctionnalités avancées d'utilisation de l'ordinateur :
- Compatibilité multi-environnement : créez des agents pour les environnements de navigateur, mobiles et de bureau.
- Actions simplifiées avec des intents : les actions incluent un champ
intentexpliquant le raisonnement du modèle derrière chaque étape. - Règles de sécurité configurables : affinez le comportement de sécurité grâce à des catégories de règles et des forçages intégrés.
- Détection d'injection de prompt : analyse des captures d'écran (sur activation) pour détecter les instructions contradictoires cachées.
Vous pouvez utiliser l'utilisation de l'ordinateur pour créer des agents capables de :
- Automatisez la saisie répétitive de données ou le remplissage de formulaires sur les sites Web et dans les applications de bureau.
- Effectuez des tests automatisés des parcours utilisateur sur le Web, sur mobile et sur ordinateur.
- Parcourir des sites Web et des applications pour recueillir des informations (par exemple, comparer des informations produit, des prix et des avis)
- Aider les utilisateurs en effectuant des séquences d'actions en plusieurs étapes dans différentes applications.
Ce guide couvre les points suivants :
- Fonctionnement de l'utilisation de l'ordinateur
- Activer l'utilisation d'un ordinateur
- Configurer votre environnement, envoyer des requêtes, recevoir des réponses et créer des boucles d'agent
- Environnements et fonctions personnalisées compatibles
- Quelles sont les actions compatibles sur ordinateur ?
- Assistance pour la sécurité
- Tarifs
Comme pour l'appel de fonction, vous devez écrire le code de l'application côté client pour recevoir l'appel de fonction d'utilisation de l'ordinateur et exécuter les actions correspondantes.
Ce guide part du principe que vous utilisez le SDK Google Gen AI pour Python et que vous connaissez l'API Playwright.
Vous trouverez l'implémentation de référence pour l'utilisation de l'ordinateur sur GitHub.
Modèles compatibles
L'utilisation de l'ordinateur est compatible avec les modèles suivants :
Cliquez pour développer la liste des modèles compatibles
Fonctionnement de l'utilisation de l'ordinateur
Au lieu de générer des réponses textuelles, l'utilisation de l'ordinateur détermine quand effectuer des actions d'UI spécifiques, comme des clics de souris, et renvoie les paramètres nécessaires pour exécuter ces actions. Vous devez écrire le code de l'application côté client pour recevoir l'function_call d'utilisation de l'ordinateur et exécuter les actions correspondantes.
Les interactions d'utilisation de l'ordinateur suivent un processus de boucle agentique :
Envoyer une requête au modèle
- Ajoutez l'utilisation de l'ordinateur (et éventuellement d'autres outils) à votre requête API.
- Envoyez une requête au modèle avec la demande de l'utilisateur et une capture d'écran représentant l'état actuel de l'IUG.
Recevoir la réponse du modèle
- Le modèle analyse la requête de l'utilisateur et la capture d'écran, puis génère une réponse qui inclut un
function_callsuggéré représentant une action d'interface utilisateur (par exemple, "cliquer sur les coordonnées (x,y)" ou "saisir 'texte'"). Consultez Actions compatibles pour obtenir la liste de toutes les actions que vous pouvez utiliser avec le modèle. - La réponse de l'API peut également inclure un
safety_decisionprovenant d'un système de sécurité interne qui a vérifié l'action proposée par le modèle. Cesafety_decisionclasse l'action comme suit :- Normal ou autorisé : l'action est considérée comme sûre. Cela peut également être représenté par l'absence de
safety_decision. - Confirmation requise : le modèle est sur le point d'effectuer une action qui peut être risquée (par exemple, cliquer sur une bannière "Accepter les cookies").
- Normal ou autorisé : l'action est considérée comme sûre. Cela peut également être représenté par l'absence de
- Le modèle analyse la requête de l'utilisateur et la capture d'écran, puis génère une réponse qui inclut un
Exécuter l'action reçue
- Votre code côté client reçoit le
function_callet tous lessafety_decisionassociés. - Si
safety_decisionindique "regular" ou "allowed" (ou si aucunsafety_decisionn'est présent), votre code côté client peut exécuter lefunction_callspécifié dans votre environnement cible (tel qu'un navigateur Web). - Si
safety_decisionindique qu'une confirmation est requise, votre application doit demander à l'utilisateur final de confirmer avant d'exécuterfunction_call. Si l'utilisateur confirme, exécutez l'action. Si l'utilisateur refuse, n'exécutez pas l'action.
- Votre code côté client reçoit le
Capturer l'état du nouvel environnement
- Si l'action a été exécutée, votre client capture une nouvelle capture d'écran de l'IUG et l'URL actuelle à renvoyer au modèle 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 un autre type de feedback au modèle ou mettre fin à l'interaction.
- Si l'action a été exécutée, votre client capture une nouvelle capture d'écran de l'IUG et l'URL actuelle à renvoyer au modèle dans le cadre d'un
Une nouvelle requête est envoyée au modèle avec l'état mis à jour. Le processus se répète à partir de l'étape 2, le modèle utilisant la nouvelle capture d'écran (si elle est fournie) et l'objectif en cours pour suggérer l'action suivante. La boucle se poursuit jusqu'à ce que la tâche soit terminée, qu'une erreur se produise ou que le processus soit interrompu (par exemple, si une réponse est bloquée par des filtres de sécurité ou une décision de l'utilisateur).
Le schéma suivant illustre le fonctionnement de l'utilisation de l'ordinateur :
Activer l'utilisation d'un ordinateur
Pour activer l'utilisation de l'ordinateur, assurez-vous que votre application utilise l'un des modèles compatibles, puis ajoutez l'utilisation de l'ordinateur à votre liste d'outils activés :
Python
from google import genai from google.genai import types from google.genai.types import Content, Part client = genai.Client( enterprise=True, project="PROJECT_ID", location="global", ) # Add computer use to the list of tools generate_content_config = types.GenerateContentConfig( tools=[ types.Tool( computer_use=types.ComputerUse( environment=types.Environment.ENVIRONMENT_BROWSER, ) ), ] ) contents = [ Content( role="user", parts=[ Part(text="Go to google.com and search for 'weather in New York'"), ], ) ] response = client.models.generate_content( model="gemini-3.8-flash", contents=contents, config=generate_content_config, ) print(response)
Node.js
import { GoogleGenAI, Environment } from '@google/genai'; const ai = new GoogleGenAI({ enterprise: true, project: 'PROJECT_ID', location: 'global', }); const response = await ai.models.generateContent({ model: 'gemini-3.8-flash', contents: "Go to google.com and search for 'weather in New York'", config: { tools: [ { computerUse: { environment: Environment.ENVIRONMENT_BROWSER, }, }, ], }, }); console.log(response);
API REST
curl -X POST "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.8-flash:generateContent" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "Content-Type: application/json" \ -d '{ "contents": [ { "role": "user", "parts": [ { "text": "Go to google.com and search for '\''weather in New York'\''" } ] } ], "tools": [ { "computer_use": { "environment": "ENVIRONMENT_BROWSER" } } ] }'
Configurer votre environnement d'exécution
Avant de créer avec l'outil d'utilisation de l'ordinateur, configurez les éléments suivants :
- Un environnement d'exécution sécurisé : exécutez votre agent dans une machine virtuelle (VM) ou un conteneur (comme Docker) en bac à sable pour l'isoler de votre système hôte.
- Un gestionnaire d'actions côté client : implémentez une logique client pour exécuter les clics de souris, les frappes au clavier et la capture d'écran.
Commencez par installer le SDK et les dépendances du navigateur, puis configurez votre environnement :
pip install --upgrade google-genai playwright termcolor playwright install chromium export GOOGLE_CLOUD_PROJECT="PROJECT_ID" export GOOGLE_CLOUD_LOCATION="global" export GOOGLE_GENAI_USE_ENTERPRISE=True
Ensuite, initialisez une instance de navigateur Playwright avec des dimensions de fenêtre d'affichage explicites afin que les coordonnées normalisées (0-1000) soient mises à l'échelle avec précision :
from playwright.sync_api import sync_playwright SCREEN_WIDTH = 1440 SCREEN_HEIGHT = 900 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() page.goto("https://www.google.com")
Envoyer une requête
Après avoir configuré l'outil d'utilisation de l'ordinateur, envoyez au modèle une requête incluant l'objectif de l'utilisateur et une capture d'écran initiale de l'IUG.
Vous pouvez également ajouter les éléments suivants :
- Actions exclues : si vous ne souhaitez pas que le modèle effectue certaines actions de la liste des actions d'interface utilisateur compatibles, spécifiez-les dans
excluded_predefined_functions. - Fonctions définies par l'utilisateur : vous pouvez inclure des fonctions personnalisées définies par l'utilisateur en plus de l'utilisation de l'ordinateur.
L'exemple de code suivant active l'utilisation de l'ordinateur et envoie la requête au modèle :
Python
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"] # Configuration for computer use with browser environment 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 (need to defined above) # types.Tool( # function_declarations=custom_functions # ) ], ) # Create the content with user message contents: list[Content] = [ 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-3.8-flash', contents=contents, config=generate_content_config, ) # Print the response output print(response.text)
Vous pouvez également inclure des fonctions personnalisées définies par l'utilisateur pour étendre les fonctionnalités du modèle. Consultez Gemini 3.5 Flash ou version ultérieure et cas d'utilisation sur mobile ou ordinateur pour savoir comment configurer l'utilisation de l'ordinateur pour les cas d'utilisation sur mobile en ajoutant des actions telles que open_app, long_press_at et go_home tout en excluant les actions spécifiques au navigateur.
Recevoir les réponses
Le modèle répond avec un ou plusieurs FunctionCalls s'il détermine que des actions d'UI ou des fonctions définies par l'utilisateur sont nécessaires pour effectuer la tâche. Le code de votre application doit analyser ces actions, les exécuter et collecter les résultats.
L'utilisation de l'ordinateur est compatible avec l'appel de fonction en parallèle, ce qui signifie que le modèle peut renvoyer plusieurs actions indépendantes en un seul tour.
Pour Gemini 3.5 Flash et les modèles ultérieurs, chaque action inclut un argument intent expliquant le raisonnement du modèle derrière cette étape :
{ "content": { "parts": [ { "function_call": { "name": "type", "args": { "x": 450, "y": 320, "text": "smart fridge touchscreen 2 doors 25 cu ft under $4000", "press_enter": true, "intent": "Type the search query into the Google search box and submit." } } } ] } }
Selon l'action, la réponse de l'API peut également renvoyer un safety_decision dans les arguments de l'appel de fonction :
{ "content": { "parts": [ { "function_call": { "name": "click", "args": { "x": 60, "y": 100, "intent": "Click the 'I'm not a robot' verification checkbox.", "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" } } } } ] } }
Exécuter les actions reçues
Après avoir reçu une réponse, analysez le function_call, mettez à l'échelle les coordonnées de la grille normalisée 0-1 000 aux dimensions réelles des pixels de la fenêtre d'affichage, puis exécutez l'action :
import time
from typing import Any, Dict, List, Tuple
import termcolor
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 get_safety_confirmation(safety_decision: Dict[str, Any]) -> str:
"""Prompt user for confirmation when safety check is triggered."""
termcolor.cprint("Safety service requires explicit confirmation!", color="red")
print(safety_decision.get("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(
response, page, screen_width: int, screen_height: int
) -> List[Tuple[str, Dict[str, Any]]]:
"""Extract and execute modern and legacy function calls from Gemini response."""
candidate = response.candidates[0]
function_calls = []
thoughts = []
for part in candidate.content.parts:
if hasattr(part, "function_call") and part.function_call:
function_calls.append(part.function_call)
elif hasattr(part, "text") and part.text:
thoughts.append(part.text)
if thoughts:
print(f"Model Reasoning: {' '.join(thoughts)}")
results: List[Tuple[str, Dict[str, Any]]] = []
for function_call in function_calls:
fname = function_call.name
args = function_call.args or {}
action_result: Dict[str, Any] = {}
print(f" -> Executing: {fname} (Intent: {args.get('intent', 'N/A')})")
# Check for safety decision before executing
if "safety_decision" in args:
decision = get_safety_confirmation(args["safety_decision"])
if decision == "TERMINATE":
print("Terminating agent loop")
break
action_result["safety_acknowledgement"] = "true"
try:
if fname in ("open_web_browser", "open_app", "take_screenshot"):
pass
elif fname in (
"click",
"click_at",
"double_click",
"triple_click",
"middle_click",
"right_click",
"mouse_down",
"mouse_up",
"move",
"hover_at",
):
actual_x = denormalize_x(args["x"], screen_width)
actual_y = denormalize_y(args["y"], screen_height)
if fname in ("click", "click_at"):
page.mouse.click(actual_x, actual_y)
elif fname == "double_click":
page.mouse.dblclick(actual_x, actual_y)
elif fname == "triple_click":
page.mouse.click(actual_x, actual_y, click_count=3)
elif fname == "middle_click":
page.mouse.click(actual_x, actual_y, button="middle")
elif fname == "right_click":
page.mouse.click(actual_x, actual_y, button="right")
elif fname == "mouse_down":
page.mouse.move(actual_x, actual_y)
page.mouse.down()
elif fname == "mouse_up":
page.mouse.move(actual_x, actual_y)
page.mouse.up()
elif fname in ("move", "hover_at"):
page.mouse.move(actual_x, actual_y)
elif fname in ("type", "type_text_at"):
actual_x = denormalize_x(args["x"], screen_width) if "x" in args else None
actual_y = denormalize_y(args["y"], screen_height) if "y" in args else None
text = args["text"]
press_enter = args.get("press_enter", False)
clear_before_typing = args.get("clear_before_typing", True)
if actual_x is not None and actual_y is not None:
page.mouse.click(actual_x, actual_y)
time.sleep(0.1)
if clear_before_typing:
page.keyboard.press("ControlOrMeta+A")
page.keyboard.press("Backspace")
page.keyboard.type(text)
if press_enter:
page.keyboard.press("Enter")
elif fname in ("scroll", "scroll_at", "scroll_document"):
if "x" in args and "y" in args:
page.mouse.move(denormalize_x(args["x"], screen_width), denormalize_y(args["y"], screen_height))
direction = args.get("direction", "down")
magnitude = args.get("magnitude_in_pixels", args.get("magnitude", 300))
dx, dy = 0, 0
if direction == "down":
dy = magnitude
elif direction == "up":
dy = -magnitude
elif direction == "right":
dx = magnitude
elif direction == "left":
dx = -magnitude
page.mouse.wheel(dx, dy)
elif fname == "drag_and_drop":
start_x = denormalize_x(args.get("start_x", args.get("x", 0)), screen_width)
start_y = denormalize_y(args.get("start_y", args.get("y", 0)), screen_height)
end_x = denormalize_x(args.get("end_x", args.get("destination_x", 0)), screen_width)
end_y = denormalize_y(args.get("end_y", args.get("destination_y", 0)), screen_height)
page.mouse.move(start_x, start_y)
page.mouse.down()
page.mouse.move(end_x, end_y)
page.mouse.up()
elif fname == "press_key":
page.keyboard.press(args["key"])
elif fname == "key_down":
page.keyboard.down(args["key"])
elif fname == "key_up":
page.keyboard.up(args["key"])
elif fname == "hotkey":
page.keyboard.press("+".join(args.get("keys", [])))
elif fname == "key_combination":
page.keyboard.press(args["keys"])
elif fname == "navigate":
page.goto(args["url"])
elif fname == "search":
page.goto("https://www.google.com")
elif fname == "go_back":
page.go_back()
elif fname == "go_forward":
page.go_forward()
elif fname in ("wait", "wait_5_seconds"):
time.sleep(5 if fname == "wait_5_seconds" else args.get("seconds", 1))
else:
action_result["warning"] = f"unhandled_function: {fname}"
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
Si la valeur safety_decision renvoyée est require_confirmation, vous devez demander à l'utilisateur 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.
Capturer le nouvel état
Après avoir exécuté les actions, empaquetez chaque résultat d'action et capture d'écran mise à jour dans un FunctionResponse à renvoyer au modèle :
from google.genai import types from google.genai.types import Content, FunctionResponse, Part def get_function_responses( page, results: List[Tuple[str, Dict[str, Any]]] ) -> Content: """Capture screenshot and URL and package them as FunctionResponses.""" screenshot = page.screenshot(type="png") current_url = page.url function_response_parts = [] for name, action_result in results: function_response_parts.append( Part( function_response=FunctionResponse( name=name, response={ "url": current_url, **action_result, }, parts=[ types.FunctionResponsePart( inline_data=types.FunctionResponseBlob( mime_type="image/png", data=screenshot, ) ) ], ) ) ) return Content( role="user", parts=function_response_parts, )
Créer une boucle d'agent
Combinez ces étapes dans une boucle de bout en bout qui effectue une itération continue entre le modèle et l'environnement d'exécution :
Python
from google import genai from google.genai import types from google.genai.types import Content, Part from playwright.sync_api import sync_playwright def has_function_calls(response) -> bool: """Check if model response contains any function calls.""" candidate = response.candidates[0] return any( hasattr(part, "function_call") and part.function_call for part in candidate.content.parts ) def main(): client = genai.Client( enterprise=True, project="PROJECT_ID", location="global", ) generate_content_config = types.GenerateContentConfig( tools=[ types.Tool( computer_use=types.ComputerUse( environment=types.Environment.ENVIRONMENT_BROWSER, enable_prompt_injection_detection=True, ) ) ], ) screen_width, screen_height = 1440, 900 with sync_playwright() as p: browser = p.chromium.launch(headless=False) context = browser.new_context( viewport={"width": screen_width, "height": screen_height} ) page = context.new_page() page.goto("https://www.google.com") initial_screenshot = page.screenshot(type="png") contents: list[Content] = [ Content( role="user", parts=[ Part(text="Search for flights from San Francisco to Honolulu departing June 30 and returning July 6."), Part.from_bytes(data=initial_screenshot, mime_type="image/png"), ], ) ] # Agent loop: iterate until model provides a final text response for iteration in range(10): print(f"\n--- Iteration {iteration + 1} ---") response = client.models.generate_content( model="gemini-3.8-flash", contents=contents, config=generate_content_config, ) contents.append(response.candidates[0].content) if not has_function_calls(response): print(f"FINAL RESPONSE:\n{response.text}") break results = execute_function_calls(response, page, screen_width, screen_height) if not results: break user_feedback_content = get_function_responses(page, results) contents.append(user_feedback_content) browser.close() if __name__ == "__main__": main()
Gemini 3.5 Flash ou version ultérieure, et cas d'utilisation sur mobile ou ordinateur
L'utilisation de l'ordinateur permet de définir des environnements mobiles (ENVIRONMENT_MOBILE), de bureau (ENVIRONMENT_DESKTOP) ou de navigateur (ENVIRONMENT_BROWSER). La valeur par défaut est ENVIRONMENT_BROWSER.
Les exemples suivants montrent comment configurer l'environnement d'exécution pour l'utilisation de l'ordinateur avec Gemini 3.5 Flash ou version ultérieure :
API REST
Avant d'utiliser les données de requête, effectuez les remplacements suivants :
- PROJECT_ID : ID du projet.
Méthode HTTP et URL :
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
Corps JSON de la requête :
{
"contents": [
{
"role": "user",
"parts": {
"text": "find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th. start by navigating directly to flights.google.com"
}
}
],
"generation_config": {
"candidateCount": 1
},
"tools": [
{
"computer_use": {
"environment": "ENVIRONMENT_BROWSER"
}
}
]
}
Pour envoyer votre requête, développez l'une des options suivantes :
Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.
Python
L'exemple suivant nécessite python-genai version 2.7.0 ou ultérieure.
from google import genai
from google.genai.types import (
Part,
GenerateContentConfig,
Content,
Tool,
ComputerUse,
Environment,
ThinkingConfig,
)
client = genai.Client()
response = client.models.generate_content(
model="gemini-3.6-flash",
contents=[
Content(
role="user",
parts=[
Part(text="find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th"),
],
)
],
config=GenerateContentConfig(
temperature=1,
top_p=0.95,
top_k=40,
max_output_tokens=8192,
tools=[
Tool(
computer_use=ComputerUse(
environment=Environment.ENVIRONMENT_MOBILE
),
),
],
thinking_config=ThinkingConfig(
include_thoughts=True
),
)
)
Fonctions définies par l'utilisateur personnalisées
Vous pouvez étendre les fonctionnalités du modèle en combinant computer_use avec des fonctions définies par l'utilisateur (function_declarations). Par exemple, dans les scénarios human-in-the-loop (avec intervention humaine), vous pouvez exclure des actions prédéfinies spécifiques à l'aide de excluded_predefined_functions et enregistrer une fonction yield_to_user personnalisée afin que l'agent puisse redonner le contrôle à un humain lorsqu'il rencontre des invites d'A2F ou des écrans ambigus :
Python
from google import genai from google.genai import types from google.genai.types import Content, Part client = genai.Client() def yield_to_user(reason: str) -> dict[str, str]: """Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous. Args: reason: The reason why the agent is yielding control to the human. """ return {"status": "yielded", "reason": reason} generate_content_config = types.GenerateContentConfig( tools=[ types.Tool( computer_use=types.ComputerUse( environment=types.Environment.ENVIRONMENT_BROWSER, excluded_predefined_functions=["drag_and_drop"], ) ), types.Tool( function_declarations=[ types.FunctionDeclaration.from_callable( client=client, callable=yield_to_user ) ] ), ] ) response = client.models.generate_content( model="gemini-3.8-flash", contents=[ Content( role="user", parts=[ Part( text="Click the submit button. If you need a second-factor authentication code, ask me." ), ], ) ], config=generate_content_config, ) print(response)
Action compatible
L'outil d'utilisation de l'ordinateur permet au modèle de demander les actions suivantes à l'aide d'un FunctionCall. Votre code côté client doit implémenter la logique d'exécution de ces actions. Consultez l'implémentation de référence pour obtenir des exemples. Le tableau suivant présente les actions compatibles avec l'environnement du navigateur.
Les modèles Gemini 3 Flash et Gemini 3.5 Flash ou ultérieurs ont des ensembles de noms FunctionCall différents.
Gemini 3.5 Flash ou version ultérieure
Gemini 3.5 Flash : vous avez accès à différents ensembles d'appels de fonction en fonction de l'environnement que vous sélectionnez :Environnement du navigateur
| Nom de la commande | Description | Arguments (dans l'appel de fonction) |
|---|---|---|
click |
Effectue un clic gauche aux coordonnées spécifiées. |
y : int (0-999)x : int (0-999)intent : str
|
double_click |
Double-clique sur les coordonnées spécifiées. |
y : int (0-999)x : int (0-999)intent : str
|
triple_click |
Effectue un triple clic aux coordonnées spécifiées. |
y : int (0-999)x : int (0-999)intent : str
|
middle_click |
Effectue un clic du milieu aux coordonnées spécifiées. |
y : int (0-999)x : int (0-999)intent : str
|
right_click |
Effectue un clic droit aux coordonnées spécifiées. |
y : int (0-999)x : int (0-999)intent : str
|
mouse_down |
Appuie de manière prolongée sur le bouton de la souris au niveau des coordonnées. |
y : int (0-999)x : int (0-999)intent : str
|
mouse_up |
Relâche le bouton de la souris aux coordonnées indiquées. |
y : int (0-999)x : int (0-999)intent : str
|
move |
Déplace le curseur à la position spécifiée. |
y : int (0-999)x : int (0-999)intent : str
|
type |
Saisit du texte (en cliquant éventuellement d'abord sur x, y). |
y : int (0-999, facultatif)x : int (0-999, facultatif)text : strpress_enter : bool (facultatif, valeur par défaut : false)intent : str
|
drag_and_drop |
Fait glisser un élément de (start_x, start_y) à (end_x, end_y). |
start_y : int (0-999)start_x : int (0-999)end_y : int (0-999)end_x : int (0-999)intent : str
|
wait |
Attend le nombre de secondes spécifié. |
seconds : int (facultatif, valeur par défaut : 1)intent : str
|
press_key |
Appuie sur la touche spécifiée, puis la relâche. |
key : strintent : str
|
key_down |
Appuie de manière prolongée sur la touche spécifiée. |
key : strintent : str
|
key_up |
Relâche la touche spécifiée. |
key : strintent : str
|
hotkey |
Appuie sur la combinaison de touches spécifiée. |
keys : List[str]intent : str
|
take_screenshot |
Renvoie une capture de l'écran actuel. | intent : str |
scroll |
Fait défiler l'écran vers le haut, le bas, la gauche ou la droite à une coordonnée selon une distance en pixels. |
y : int (0-999)x : int (0-999)direction : str ("up", "down", "left", "right")magnitude_in_pixels : int (0-999, facultatif, valeur par défaut : 300)intent : str
|
open_web_browser |
Ouvre le navigateur Web. | intent : str |
navigate |
Accède directement à l'URL spécifiée dans le navigateur. |
url : strintent : str
|
go_back |
Retourne à la page Web précédente dans l'historique de navigation. | intent : str |
go_forward |
Accède à la page Web suivante dans l'historique de navigation du navigateur. | intent : str |
Environnement mobile
| Nom de la commande | Description | Arguments (dans l'appel de fonction) |
|---|---|---|
open_app |
Ouvre une application par son nom. | intent: str |
click |
Effectue un clic gauche aux coordonnées indiquées. |
y : int (0-999)x : int (0-999)intent : str
|
list_apps |
Répertorie les applications disponibles sur l'appareil, en renvoyant leurs noms et leurs noms de package. | intent : str |
wait |
Attend le nombre de secondes spécifié. |
intent : strseconds : int(facultatif, valeur par défaut : 1)
|
go_back |
Permet de revenir à la page Web précédente dans l'historique du navigateur. | intent : str |
type |
Saisit du texte. |
text : strintent : strpress_enter : bool(facultatif, "false" par défaut)
|
drag_and_drop |
Fait glisser l'élément de start_y et start_x vers end_y et end_x |
start_y : int (0-999)start_x : int (0-999)end_y : int (0-999)end_x : int (0-999)intent : str
|
long_press |
Effectue un appui de manière prolongée sur des coordonnées y (0-999) et x (0-999) spécifiques de l'écran. |
y : int (0-999)x : int (0-999)intent : strseconds : int (facultatif, valeur par défaut : 2)
|
press_key |
Appuie sur la touche spécifiée, puis la relâche. |
key : strintent : str
|
take_screenshot |
Renvoie une capture de l'écran actuel. | intent : str |
Environnement de bureau
| Nom de la commande | Description | Arguments (dans l'appel de fonction) |
|---|---|---|
click |
Effectue un clic gauche aux coordonnées indiquées. |
y : int (0-999)x : int (0-999)intent : str
|
double_click |
Double-clique sur les coordonnées. |
y : int (0-999)x : int (0-999)intent : str
|
triple_click |
Triple-clique sur les coordonnées. |
y : int (0-999)x : int (0-999)intent : str
|
middle_click |
Effectue un clic avec le bouton du milieu aux coordonnées indiquées. |
y : int (0-999)x : int (0-999)intent : str
|
right_click |
Effectue un clic droit sur les coordonnées. |
y : int (0-999)x : int (0-999)intent : str
|
mouse_down |
Appuie de manière prolongée sur le bouton de la souris au niveau des coordonnées. |
y : int (0-999)x : int (0-999)intent : str
|
mouse_up |
Relâche le bouton de la souris aux coordonnées indiquées. |
y : int (0-999)x : int (0-999)intent : str
|
move |
Placez le curseur à la position spécifiée. |
y : int (0-999)x : int (0-999)intent : str
|
type |
Saisit du texte. |
text : strintent : strpress_enter : bool(facultatif, "false" par défaut)
|
drag_and_drop |
Fait glisser l'élément de start_y et start_x vers end_y et end_x. |
start_y : int (0-999)start_x : int (0-999)end_y : int (0-999)end_x : int (0-999)intent : str
|
wait |
Attendez le nombre de secondes spécifié. |
intent : strseconds : int(facultatif, valeur par défaut : 1)
|
press_key |
Appuie sur la touche spécifiée, puis la relâche. |
key : strintent : str
|
key_down |
Appuie de manière prolongée sur la touche spécifiée. |
key : strintent : str
|
key_up |
Relâche la touche spécifiée. |
key : strintent : str
|
hotkey |
Appuie sur la combinaison de touches spécifiée. |
keys : List[str]intent : str
|
take_screenshot |
Renvoie une capture de l'écran actuel. | intent : str |
scroll |
Fait défiler l'écran vers le haut, le bas, la gauche ou la droite à une coordonnée selon une distance en pixels. |
y : int (0-999)x : int (0-999)direction : str ("up", "down", "left", "right")intent : strmagnitude_in_pixels : int (0-999, facultatif, valeur par défaut : 300)
|
Gemini 3 Flash
| Nom de la commande | Description | Arguments (dans l'appel de fonction) | Exemple d'appel de fonction |
|---|---|---|---|
| open_web_browser | Ouvre le navigateur Web. | Aucun | {"name": "open_web_browser", "args": {}} |
| wait_5_seconds | Met en pause l'exécution pendant cinq secondes pour permettre le chargement du contenu dynamique ou la fin des animations. | Aucun | {"name": "wait_5_seconds", "args": {}} |
| go_back | Accède à la page précédente de l'historique du navigateur. | Aucun | {"name": "go_back", "args": {}} |
| go_forward | Accède à la page suivante de l'historique du navigateur. | Aucun | {"name": "go_forward", "args": {}} |
| search | Accéder à la page d'accueil du moteur de recherche par défaut (par exemple, Google) Utile pour lancer une nouvelle tâche de recherche. | Aucun | {"name": "search", "args": {}} |
| navigate | Accède directement à l'URL spécifiée dans le navigateur. | url : str |
{"name": "navigate", "args": {"url": "https://www.wikipedia.org"}}
|
| click_at | Clique sur une coordonnée spécifique de la page Web. Les valeurs x et y sont basées sur une grille de 1 000 x 1 000 et sont adaptées aux dimensions de l'écran. | y : int (0-999), x : int (0-999) |
{"name": "click_at", "args": {"y": 300, "x": 500}}
|
| hover_at | 521963309 Passe la souris sur une coordonnée spécifique de la page Web. Utile pour afficher des sous-menus. x et y sont basés sur une grille de 1 000 x 1 000. | y : int (0-999) x : int (0-999) |
{"name": "hover_at", "args": {"y": 150, "x": 250}}
|
| type_text_at | Saisit du texte à une coordonnée spécifique. Par défaut, le champ est d'abord effacé, puis la touche ENTRÉE est enfoncée après la saisie, mais ces options peuvent être désactivées. x et y sont basés sur une grille de 1 000 x 1 000. |
y : int (0-999), x : int (0-999), text : str, press_enter : bool (facultatif, True par défaut), clear_before_typing : bool (facultatif, True par défaut)
|
{"name": "type_text_at", "args": {"y": 250, "x": 400,
"text": "search query", "press_enter": false}}
|
| key_combination | Appuie sur des touches ou des combinaisons de touches du clavier, comme "Ctrl+C" ou "Entrée". Utile pour déclencher des actions (comme l'envoi d'un formulaire avec "Entrée") ou des opérations de presse-papiers. |
keys : str (par exemple, "enter", "control+c"). (consultez la documentation de référence de l'API pour obtenir la liste complète des clés autorisées)
|
{"name": "key_combination", "args": {"keys":
"Control+A"}}
|
| scroll_document | Fait défiler l'intégralité de la page Web vers le haut, le bas, la gauche ou la droite. | direction : str ("up", "down", "left" ou "right") |
{"name": "scroll_document", "args": {"direction": "down"}}
|
| scroll_at | Fait défiler un élément ou une zone spécifique aux coordonnées (x, y) dans la direction spécifiée selon une certaine amplitude. Les coordonnées et l'amplitude (800 par défaut) sont basées sur une grille de 1 000 x 1 000. |
y : int (0-999), x : int (0-999),
direction : str ("up", "down", "left", "right"),
magnitude : int (0-999, facultatif, valeur par défaut : 800)
|
{"name": "scroll_at", "args": {"y": 500, "x": 500,
"direction": "down", "magnitude": 400}}
|
| drag_and_drop | Fait glisser un élément d'une coordonnée de départ (x, y) et le dépose à une coordonnée de destination (destination_x, destination_y). Toutes les coordonnées sont basées sur une grille de 1 000 x 1 000. |
y : int (0-999), x : int (0-999), destination_y : int (0-999), destination_x : int (0-999)
|
{"name": "drag_and_drop", "args": {"y": 100, "x": 100,
"destination_y": 500, "destination_x": 500}}
|
Sécurité
Cette section décrit les mesures de protection mises en place par l'outil d'utilisation de l'ordinateur pour améliorer le contrôle de l'utilisateur et renforcer la sécurité. Il décrit également les bonnes pratiques pour atténuer les nouveaux risques potentiels que l'outil pourrait présenter.
Prendre connaissance de la décision de sécurité
Selon l'action, la réponse du modèle peut inclure un safety_decision provenant d'un système de sécurité interne. Cette décision vérifie la sécurité de l'action proposée par l'outil.
{
"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 la valeur de safety_decision est require_confirmation, vous devez demander à l'utilisateur final de confirmer avant de procéder à l'exécution de l'action.
L'exemple de code suivant demande à l'utilisateur final de confirmer avant d'exécuter l'action. 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(response, page, screen_width: int, screen_height: int):
# ... 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
)
)
]
)
)
Détection de l'injection de requêtes
L'utilisation de l'ordinateur dans Gemini 3.5 Flash ou version ultérieure est compatible avec un mécanisme de sécurité avancé permettant de détecter les attaques par injection de prompt. Lorsqu'elle est activée, cette fonctionnalité vérifie si une capture d'écran incluse est susceptible d'introduire une attaque par injection de prompt. Vous pouvez définir cette fonctionnalité dans la configuration de l'utilisation de l'ordinateur. La valeur par défaut est false.
Les exemples suivants montrent comment activer la configuration de l'utilisation de l'ordinateur pour activer la détection d'injection de prompt :
API REST
Avant d'utiliser les données de requête, effectuez les remplacements suivants :
- PROJECT_ID : ID du projet.
Méthode HTTP et URL :
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
Corps JSON de la requête :
{
"contents": [
{
"role": "user",
"parts": {
"text": "find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th. start by navigating directly to flights.google.com"
}
}
],
"generation_config": {
"candidateCount": 1
},
"tools": [
{
"computer_use": {
"environment": "ENVIRONMENT_BROWSER",
"enable_prompt_injection_detection": true
}
}
]
}
Pour envoyer votre requête, développez l'une des options suivantes :
Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.
Python
L'exemple suivant nécessite python-genai version 2.7.0 ou ultérieure.
from google import genai
from google.genai.types import (
Part,
GenerateContentConfig,
Content,
Tool,
ComputerUse,
Environment,
ThinkingConfig,
)
client = genai.Client()
response = client.models.generate_content(
model="gemini-3.6-flash",
contents=[
Content(
role="user",
parts=[
Part(text="find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th"),
],
)
],
config=GenerateContentConfig(
temperature=1,
top_p=0.95,
top_k=40,
max_output_tokens=8192,
tools=[
Tool(
computer_use=ComputerUse(
environment=Environment.ENVIRONMENT_MOBILE,
enable_prompt_injection_detection=True
),
),
],
thinking_config=ThinkingConfig(
include_thoughts=True
),
)
)
Bonnes pratiques concernant la sécurité
L'utilisation d'ordinateurs présente des risques dont les développeurs doivent être conscients :
- Contenu non fiable et escroqueries : lorsque le modèle tente d'atteindre l'objectif de l'utilisateur, il peut s'appuyer sur des sources d'informations et des instructions non fiables à l'écran.
- 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.
- Non-respect des règles : les fonctionnalités de l'API peuvent être utilisées pour des activités qui ne respectent pas les conditions d'utilisation et les règles de Google, comme le contournement des CAPTCHA ou la compromission de l'intégrité du système.
Pour limiter ces risques, vous devez mettre en œuvre les mesures de sécurité et les bonnes pratiques suivantes :
- Human-in-the-loop (avec intervention humaine, HITL) :
- Implémenter 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. - Fournir des instructions 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.
Cliquez pour afficher un exemple d'instruction système de sécurité personnalisée
## **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. **USER_CONFIRMATION Categories:** * **Consent and Agreements:** Terms of Service, Privacy Policies, Cookie banners. * **Robot Detection:** CAPTCHAs of any kind. * **Financial Transactions:** Completing purchases or moving funds. * **Sending Communications:** Emails, forum posts, or chat messages. * **Accessing/Modifying Sensitive Information:** Healthcare, financial, or ID records. * **User Data Management:** Downloading files, transferring user data. * **Browser Data Usage:** Chrome history, bookmarks, autofill passwords. * **Security and Identity:** Logging into accounts or impersonation. ## **RULE 2: Default Behavior (ACTUATE)** If an action does NOT fall under USER_CONFIRMATION, proactively perform all necessary steps to move the user's request forward.
- Implémenter la confirmation de l'utilisateur : lorsque la réponse de sécurité indique
- Environnement d'exécution sécurisé : exécutez votre agent dans un environnement sécurisé et isolé pour limiter son impact potentiel (par exemple, une machine virtuelle (VM) isolée, un conteneur (comme Docker) ou un profil de navigateur dédié avec des autorisations limitées).
- Nettoyage des entrées : nettoyez tout le texte généré par l'utilisateur dans les prompts pour limiter le risque d'instructions involontaires ou d'injection de prompt. Il s'agit d'une couche de sécurité utile, mais qui ne remplace pas un environnement d'exécution sécurisé.
- Garde-fous de contenu : utilisez des garde-fous et des API de sécurité du contenu (comme Model Armor) pour évaluer les entrées utilisateur, les entrées et sorties d'outils, ainsi que les réponses de l'agent afin de détecter les contenus inappropriés, les injections de prompt et les jailbreaks.
- Listes d'autorisation et listes de blocage : implémentez des mécanismes de filtrage pour contrôler où le modèle peut naviguer et ce qu'il peut faire. Une liste de blocage des sites Web interdits est un bon point de départ, tandis qu'une liste d'autorisation plus restrictive est encore plus sécurisée.
- 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 de sécurité et toutes les actions finalement exécutées par le client. - Gestion de l'environnement : assurez-vous que l'environnement de l'IUG est cohérent. Les pop-ups, les notifications système ou les changements de mise en page inattendus peuvent perturber le modèle. Dans la mesure du possible, commencez chaque nouvelle tâche à partir d'un état propre et connu.
Confirmations human-in-the-loop (avec intervention humaine)
Les confirmations human-in-the-loop (avec intervention humaine) consistent à demander la confirmation de l'utilisateur avant d'exécuter une action suggérée par le modèle. Ce processus est nécessaire lorsque le modèle ne peut pas effectuer une action pour des raisons de sécurité.
L'outil d'utilisation de l'ordinateur de Gemini fournit les mécanismes suivants pour contrôler les confirmations HITL :
- Au niveau du développeur : les développeurs peuvent configurer l'application de certaines ou de toutes les confirmations HITL par défaut.
- Au niveau de l'organisation : les administrateurs de l'organisation peuvent créer une règle au niveau de l'organisation qui empêche les développeurs de désactiver certaines ou toutes les confirmations HITL. Cette règle remplace tous les paramètres au niveau du développeur.
Ignorer les confirmations HITL
Vous pouvez ignorer les confirmations HITL par défaut suivantes :
FINANCIAL_TRANSACTIONS: finalisation de la dernière étape d'une transaction financière (par exemple, paiements, virements de fonds, ordre de paiement, démarrage ou modification d'un abonnement, ou finalisation d'une réservation).SENSITIVE_DATA_MODIFICATION: modification d'informations sensibles, telles que des dossiers médicaux, financiers ou administratifs.COMMUNICATION_TOOL: accès à des outils de communication ou utilisation de ces outils pour envoyer, partager, publier ou transmettre des communications.ACCOUNT_CREATION: interaction avec les flux d'enregistrement ou d'inscription qui créent ou provisionnent de nouveaux comptes utilisateur ou de service.DATA_MODIFICATION: modification, gestion, partage, stockage, envoi ou suppression de données ou de fichiers du navigateur.USER_CONSENT_MANAGEMENT: interaction avec les boîtes de dialogue de recueil du consentement ou les bannières de consentement utilisateur en prenant une décision.LEGAL_TERMS_AND_AGREEMENTS: interaction avec des boîtes de dialogue d'accord juridiquement contraignant, telles que l'acceptation des conditions d'utilisation, les boîtes de dialogue de règles de confidentialité ou les mentions légales.
Vous pouvez ignorer une ou toutes ces confirmations HITL en les listant dans le champ disabled_safety_policies de la configuration de l'utilisation de l'ordinateur :
Python
API GenerateContent
generate_content_config = genai.types.GenerateContentConfig(
tools=[
types.Tool(
computer_use=types.ComputerUse(
environment=types.Environment.ENVIRONMENT_MOBILE,
disabled_safety_policies=[
types.SafetyPolicy.FINANCIAL_TRANSACTIONS,
types.SafetyPolicy.COMMUNICATION_TOOL,
]
)
),
],
)
contents = [
types.Content(
role="user",
parts=[
types.Part(text="Open the Maps app and find the nearest coffee shop."),
],
)
]
response = client.models.generate_content(
model='gemini-3.5-flash',
contents=contents,
config=generate_content_config,
)API Interactions
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model='gemini-3.5-flash',
input='Open the Maps app and find the nearest coffee shop.',
tools=[
{
'type': 'computer_use',
'environment': 'mobile',
'disabled_safety_policies': [
'financial_transactions',
'communication_tool',
],
}
]
)REST
API GenerateContent
{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Open the Maps app and find the nearest coffee shop."
}
]
}
],
"tools": [
{
"computer_use": {
"environment": "ENVIRONMENT_MOBILE",
"disabled_safety_policies" : [
"FINANCIAL_TRANSACTIONS",
"COMMUNICATION_TOOL"
]
}
}
]
}API Interactions
{
"model": "gemini-3.5-flash",
"input": "Open the Maps app and find the nearest coffee shop.",
"tools": [
{
"type": "computer_use",
"environment": "mobile",
"disabled_safety_policies": [
"financial_transactions",
"communication_tool"
]
}
]
}Créer des règles d'administration
Si vous êtes administrateur d'une organisation, vous pouvez créer une règle au niveau de l'organisation à l'aide du service de règles d'administration qui empêche les développeurs de désactiver certaines ou toutes les confirmations HITL. Cette règle remplace tous les paramètres au niveau du développeur.
Vous pouvez créer une règle à l'aide de la consoleGoogle Cloud ou de Google Cloud CLI.
L'ID de la contrainte est vertexai.configurableComputerUseToolSafetyPolicies.
La propagation des modifications apportées aux règles d'administration peut prendre jusqu'à une heure.
Pour en savoir plus sur la création et la gestion des règles d'administration, consultez Créer des règles d'administration.
Tarifs
L'utilisation de l'ordinateur est facturée aux mêmes tarifs que Gemini et utilise les mêmes SKU. Pour répartir les coûts d'utilisation des ordinateurs, utilisez des libellés de métadonnées personnalisés. Pour en savoir plus sur l'utilisation d'étiquettes de métadonnées personnalisées pour la surveillance des coûts, consultez Étiquettes de métadonnées personnalisées.