Mit dem Tool für die Computernutzung von Gemini können Sie Browser-, Mobil- und Desktop-Steuerungs-Agents erstellen, die mit grafischen Benutzeroberflächen (GUIs) interagieren und Aufgaben automatisieren. Wenn die Computernutzung aktiviert ist, verwendet das Modell Screenshots, um den Bildschirm zu beobachten und bestimmte UI-Aktionen wie Mausklicks, Scrollen und Tastatureingaben zu generieren.
Gemini unterstützt mehrere erweiterte Funktionen für die Computernutzung:
- Unterstützung für mehrere Umgebungen: Erstellen Sie Agenten für Browser-, Mobil- und Desktop-Umgebungen.
- Optimierte Aktionen mit Intents: Aktionen enthalten ein
intent-Feld, in dem die Begründung des Modells für jeden Schritt erläutert wird. - Konfigurierbare Sicherheitsrichtlinien: Sie können das Sicherheitsverhalten mit integrierten Richtlinienkategorien und Überschreibungen optimieren.
- Prompt-Injection-Erkennung: Screenshot-Scans, um versteckte schädliche Anweisungen zu erkennen.
Mit der Computernutzung können Sie Agenten erstellen, die Folgendes können:
- Automatisieren Sie wiederkehrende Dateneingaben oder das Ausfüllen von Formularen auf Websites und in Desktopanwendungen.
- Führen Sie automatisierte Tests von Web-, Mobil- und Desktop-User-Flows durch.
- Websites und Anwendungen durchsuchen, um Informationen zu finden (z. B. Produktinformationen, Preise und Rezensionen vergleichen)
- Nutzer durch Ausführen mehrstufiger Aktionssequenzen in verschiedenen Anwendungen unterstützen.
In diesem Leitfaden werden die folgenden Themen behandelt:
- So funktioniert die Computernutzung
- Computernutzung aktivieren
- Umgebung einrichten, Anfragen senden, Antworten empfangen und Agentenschleifen erstellen
- Unterstützte Umgebungen und benutzerdefinierte Funktionen
- Welche Computeraktionen werden unterstützt?
- Support für Sicherheit
- Preise
Ähnlich wie bei Funktionsaufrufen müssen Sie den clientseitigen Anwendungscode schreiben, um den Funktionsaufruf für die Computernutzung zu empfangen und die entsprechenden Aktionen auszuführen.
In diesem Leitfaden wird davon ausgegangen, dass Sie das Google Gen AI SDK for Python verwenden und mit der Playwright API vertraut sind.
Die Referenzimplementierung für die Computernutzung finden Sie auf GitHub.
Unterstützte Modelle
Die Computernutzung wird für die folgenden Modelle unterstützt:
Klicken, um unterstützte Modelle einzublenden
So funktioniert die Computernutzung
Anstatt Textantworten zu generieren, bestimmt die Computernutzung, wann bestimmte UI-Aktionen wie Mausklicks ausgeführt werden sollen, und gibt die erforderlichen Parameter zurück, um diese Aktionen auszuführen. Sie müssen den clientseitigen Anwendungscode schreiben, um die function_call für die Computernutzung zu empfangen und die entsprechenden Aktionen auszuführen.
Interaktionen bei der Computernutzung folgen einem Agentenschleifenprozess:
Anfrage an das Modell senden
- Fügen Sie Ihrer API-Anfrage die Computernutzung (und optional weitere Tools) hinzu.
- Senden Sie einen Prompt mit der Nutzeranfrage und einem Screenshot, der den aktuellen Status der GUI darstellt, an das Modell.
Modellantwort erhalten
- Das Modell analysiert die Nutzeranfrage und den Screenshot und generiert eine Antwort, die einen vorgeschlagenen
function_callenthält, der eine UI-Aktion darstellt (z. B. „Klicken Sie auf die Koordinaten (x,y)“ oder „Geben Sie ‚Text‘ ein“). Eine Liste aller Aktionen, die Sie mit dem Modell verwenden können, finden Sie unter Unterstützte Aktionen. - Die API-Antwort kann auch eine
safety_decisionvon einem internen Sicherheitssystem enthalten, das die vorgeschlagene Aktion des Modells geprüft hat. In diesem Fall wird die Aktion vonsafety_decisionso klassifiziert:- Regulär oder zulässig: Die Aktion gilt als sicher. Dies kann auch durch das Fehlen von
safety_decisiondargestellt werden. - Bestätigung erforderlich: Das Modell ist im Begriff, eine Aktion auszuführen, die riskant sein könnte (z. B. das Klicken auf ein Cookie-Banner).
- Regulär oder zulässig: Die Aktion gilt als sicher. Dies kann auch durch das Fehlen von
- Das Modell analysiert die Nutzeranfrage und den Screenshot und generiert eine Antwort, die einen vorgeschlagenen
Empfangene Aktion ausführen
- Ihr clientseitiger Code empfängt die
function_callund alle zugehörigensafety_decision. - Wenn der
safety_decisionregulär oder zulässig ist (oder wenn keinsafety_decisionvorhanden ist), kann der clientseitige Code die angegebenefunction_callin der Zielumgebung (z. B. einem Webbrowser) ausführen. - Wenn die
safety_decisioneine erforderliche Bestätigung angibt, muss Ihre Anwendung den Endnutzer zur Bestätigung auffordern, bevor diefunction_callausgeführt wird. Wenn der Nutzer bestätigt, fahre mit der Ausführung der Aktion fort. Wenn der Nutzer die Aktion ablehnt, führe sie nicht aus.
- Ihr clientseitiger Code empfängt die
Neuen Umgebungsstatus erfassen
- Wenn die Aktion ausgeführt wurde, erstellt Ihr Client einen neuen Screenshot der GUI und der aktuellen URL, um sie als Teil einer
function_responsean das Modell zurückzusenden. - Wenn eine Aktion vom Sicherheitssystem blockiert oder vom Nutzer nicht bestätigt wurde, kann Ihre Anwendung eine andere Art von Feedback an das Modell senden oder die Interaktion beenden.
- Wenn die Aktion ausgeführt wurde, erstellt Ihr Client einen neuen Screenshot der GUI und der aktuellen URL, um sie als Teil einer
Eine neue Anfrage wird mit dem aktualisierten Status an das Modell gesendet. Der Prozess wird ab Schritt 2 wiederholt. Das Modell verwendet den neuen Screenshot (falls vorhanden) und das laufende Ziel, um die nächste Aktion vorzuschlagen. Die Schleife wird fortgesetzt, bis die Aufgabe abgeschlossen ist, ein Fehler auftritt oder der Prozess beendet wird (z. B. wenn eine Antwort durch Sicherheitsfilter oder eine Nutzerentscheidung blockiert wird).
Das folgende Diagramm veranschaulicht, wie die Computernutzung funktioniert:
Computernutzung aktivieren
Wenn Sie die Computernutzung aktivieren möchten, muss Ihre Anwendung eines der unterstützten Modelle verwenden. Fügen Sie die Computernutzung dann der Liste der aktivierten Tools hinzu:
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);
REST API
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" } } ] }'
Ausführungsumgebung einrichten
Bevor Sie mit dem Tool zur Computernutzung entwickeln, müssen Sie Folgendes einrichten:
- Sichere Ausführungsumgebung: Führen Sie Ihren Agenten in einer Sandbox-VM oder einem Sandbox-Container (z. B. Docker) aus, um ihn von Ihrem Hostsystem zu isolieren.
- Einen clientseitigen Aktions-Handler: Implementieren Sie eine Clientlogik, um Mausklicks, Tastatureingaben und Screenshots auszuführen.
Installieren Sie zuerst das SDK und die Browserabhängigkeiten und konfigurieren Sie dann Ihre Umgebung:
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
Initialisieren Sie als Nächstes eine Playwright-Browserinstanz mit expliziten Darstellungsbereichsdimensionen, damit normalisierte Koordinaten (0–1000) genau skaliert werden:
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")
Anfrage senden
Nachdem Sie das Tool zur Computernutzung konfiguriert haben, senden Sie einen Prompt an das Modell, der das Ziel des Nutzers und einen ersten Screenshot der GUI enthält.
Optional können Sie auch Folgendes hinzufügen:
- Ausgeschlossene Aktionen: Wenn es Aktionen aus der Liste der unterstützten UI-Aktionen gibt, die das Modell nicht ausführen soll, geben Sie diese Aktionen in der
excluded_predefined_functionsan. - Benutzerdefinierte Funktionen: Sie können zusätzlich zur Computernutzung benutzerdefinierte Funktionen einbinden.
Im folgenden Beispielcode wird die Computernutzung aktiviert und die Anfrage an das Modell gesendet:
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)
Sie können auch benutzerdefinierte Funktionen einbinden, um die Funktionalität des Modells zu erweitern. Informationen dazu, wie Sie die Computernutzung für mobile Anwendungsfälle konfigurieren können, indem Sie Aktionen wie open_app, long_press_at und go_home hinzufügen und browserspezifische Aktionen ausschließen, finden Sie unter Gemini 3.5 Flash oder höher und Anwendungsfälle für Mobilgeräte oder Computer.
Antworten erhalten
Das Modell antwortet mit einem oder mehreren FunctionCalls, wenn es feststellt, dass UI-Aktionen oder benutzerdefinierte Funktionen erforderlich sind, um die Aufgabe abzuschließen. Ihr Anwendungscode muss diese Aktionen parsen, ausführen und die Ergebnisse erfassen.
Die Computernutzung unterstützt parallele Funktionsaufrufe. Das bedeutet, dass das Modell in einem einzigen Durchgang mehrere unabhängige Aktionen zurückgeben kann.
Bei Gemini 3.5 Flash und höheren Modellen enthält jede Aktion ein intent-Argument, das die Begründung des Modells für diesen Schritt erklärt:
{ "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." } } } ] } }
Je nach Aktion kann die API-Antwort auch ein safety_decision in den Argumenten des Funktionsaufrufs zurückgeben:
{ "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" } } } } ] } }
Empfangene Aktionen ausführen
Nachdem Sie eine Antwort erhalten haben, parsen Sie die function_call, skalieren Sie die Koordinaten vom normalisierten 0–1000-Raster auf die tatsächlichen Pixelabmessungen des Darstellungsbereichs und führen Sie die Aktion aus:
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
Wenn der zurückgegebene safety_decision-Wert require_confirmation ist, müssen Sie den Nutzer um Bestätigung bitten, bevor Sie die Aktion ausführen. Gemäß den Nutzungsbedingungen ist es nicht gestattet, Anfragen zur Bestätigung durch einen Menschen zu umgehen.
Neuen Status erfassen
Nachdem die Aktionen ausgeführt wurden, werden die einzelnen Aktionsergebnisse und der aktualisierte Screenshot in einem FunctionResponse-Objekt verpackt, das an das Modell zurückgegeben wird:
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, )
Agentenschleife erstellen
Kombinieren Sie diese Schritte zu einer End-to-End-Schleife, die kontinuierlich zwischen dem Modell und der Ausführungsumgebung iteriert:
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 oder höher und Anwendungsfälle für Mobilgeräte oder Computer
Die Computernutzung unterstützt das Festlegen von mobilen (ENVIRONMENT_MOBILE), Desktop- (ENVIRONMENT_DESKTOP) oder Browser-Umgebungen (ENVIRONMENT_BROWSER). Der Standardwert ist ENVIRONMENT_BROWSER.
In den folgenden Beispielen wird gezeigt, wie Sie die Ausführungsumgebung für die Computernutzung mit Gemini 3.5 Flash oder höher konfigurieren:
REST API
Ersetzen Sie diese Werte in den folgenden Anfragedaten:
- PROJECT_ID: Ihre Projekt-ID.
HTTP-Methode und URL:
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
JSON-Text anfordern:
{
"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"
}
}
]
}
Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:
Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.
Python
Für das folgende Beispiel ist python-genai Version 2.7.0 oder höher erforderlich.
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
),
)
)
Benutzerdefinierte Funktionen
Sie können die Funktionalität des Modells erweitern, indem Sie computer_use mit benutzerdefinierten Funktionen (function_declarations) kombinieren. In Human-in-the-Loop-Szenarien (HITL) können Sie beispielsweise bestimmte vordefinierte Aktionen mit excluded_predefined_functions ausschließen und eine benutzerdefinierte yield_to_user-Funktion registrieren, damit der Agent die Kontrolle an einen Menschen zurückgeben kann, wenn er auf 2FA-Aufforderungen oder mehrdeutige Bildschirme stößt:
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)
Unterstützte Aktionen
Mit dem Tool zur Computernutzung kann das Modell die folgenden Aktionen über einen FunctionCall anfordern. Ihr clientseitiger Code muss die Ausführungslogik für diese Aktionen implementieren. Beispiele finden Sie in der Referenzimplementierung. In der folgenden Tabelle sind die unterstützten Aktionen für die Browserumgebung aufgeführt.
Gemini 3 Flash und Gemini 3.5 Flash oder höher haben andere FunctionCall-Namen.
Gemini 3.5 Flash oder höher
Gemini 3.5 Flash: Je nach ausgewählter Umgebung haben Sie Zugriff auf verschiedene Funktionsaufrufe:Browserumgebung
| Befehlsname | Beschreibung | Argumente (im Funktionsaufruf) |
|---|---|---|
click |
Klickt mit der linken Maustaste auf die angegebene Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
double_click |
Doppelklickt auf die angegebene Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
triple_click |
Führt einen Dreifachklick an der angegebenen Koordinate aus. |
y: int (0–999)x: int (0–999)intent: str
|
middle_click |
Klickt mit der mittleren Maustaste auf die angegebene Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
right_click |
Rechtsklickt auf die angegebene Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
mouse_down |
Hält die Maustaste an der Koordinate gedrückt. |
y: int (0–999)x: int (0–999)intent: str
|
mouse_up |
Lässt die Maustaste an der Koordinate los. |
y: int (0–999)x: int (0–999)intent: str
|
move |
Der Cursor wird an die angegebene Position bewegt. |
y: int (0–999)x: int (0–999)intent: str
|
type |
Gibt Text ein (optional wird zuerst auf x, y geklickt). |
y: int (0–999, optional)x: int (0–999, optional)text: strpress_enter: bool (optional, Standardwert: false)intent: str
|
drag_and_drop |
Zieht ein Element von (start_x, start_y) nach (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 |
Wartet die angegebene Anzahl von Sekunden. |
seconds: int (optional, Standardwert: 1)intent: str
|
press_key |
Drückt die angegebene Taste und lässt sie wieder los. |
key: strintent: str
|
key_down |
Drückt die angegebene Taste und hält sie gedrückt. |
key: strintent: str
|
key_up |
Gibt die angegebene Taste frei. |
key: strintent: str
|
hotkey |
Drückt die angegebene Tastenkombination. |
keys: List[str]intent: str
|
take_screenshot |
Gibt einen Screenshot des aktuellen Bildschirms zurück. | intent: str |
scroll |
Scrollt an einer Koordinate um eine Pixelentfernung nach oben, unten, links oder rechts. |
y: int (0-999)x: int (0-999)direction: str ("up", "down", "left", "right")magnitude_in_pixels: int (0-999, Optional, default 300)intent: str
|
open_web_browser |
Öffnet den Webbrowser. | intent: str |
navigate |
Leitet den Browser direkt zur angegebenen URL weiter. |
url: strintent: str
|
go_back |
Zurück zur vorherigen Webseite im Browserverlauf. | intent: str |
go_forward |
Navigiert im Browserverlauf zur nächsten Webseite. | intent: str |
Mobile Umgebung
| Befehlsname | Beschreibung | Argumente (im Funktionsaufruf) |
|---|---|---|
open_app |
Öffnet eine Anwendung anhand ihres Namens. | intent: str |
click |
Klickt mit der linken Maustaste auf die Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
list_apps |
Listet die auf dem Gerät verfügbaren Anwendungen auf und gibt deren Namen und Paketnamen zurück. | intent: str |
wait |
Wartet die angegebene Anzahl von Sekunden. |
intent: strseconds: int(optional, Standardwert: 1)
|
go_back |
Kehrt zur vorherigen Webseite im Browserverlauf zurück. | intent: str |
type |
Gibt Text ein. |
text: strintent: strpress_enter: bool(Optional, Standardwert: false)
|
drag_and_drop |
Zieht ein Element von start_y und start_x zu end_y und 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 |
Führt ein langes Drücken an einer bestimmten y- (0–999) und x-Koordinate (0–999) auf dem Bildschirm aus. |
y: int (0–999)x: int (0–999)intent: strseconds: int (optional, Standardwert: 2)
|
press_key |
Drückt die angegebene Taste und lässt sie wieder los. |
key: strintent: str
|
take_screenshot |
Gibt einen Screenshot des aktuellen Bildschirms zurück. | intent: str |
Desktopumgebung
| Befehlsname | Beschreibung | Argumente (im Funktionsaufruf) |
|---|---|---|
click |
Klickt mit der linken Maustaste auf die Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
double_click |
Doppelklickt auf die Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
triple_click |
Dreifachklicks an der Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
middle_click |
Klickt mit der mittleren Maustaste auf die Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
right_click |
Klickt mit der rechten Maustaste auf die Koordinate. |
y: int (0–999)x: int (0–999)intent: str
|
mouse_down |
Hält die Maustaste an der Koordinate gedrückt. |
y: int (0–999)x: int (0–999)intent: str
|
mouse_up |
Lässt die Maustaste an der Koordinate los. |
y: int (0–999)x: int (0–999)intent: str
|
move |
Bewegt den Cursor an die angegebene Position. |
y: int (0–999)x: int (0–999)intent: str
|
type |
Gibt Text ein. |
text: strintent: strpress_enter: bool(Optional, default false)
|
drag_and_drop |
Zieht ein Element von start_y und start_x zu end_y und 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 |
Warten Sie die angegebene Anzahl von Sekunden. |
intent: strseconds: int(optional, Standardwert: 1)
|
press_key |
Drückt die angegebene Taste und lässt sie wieder los. |
key: strintent: str
|
key_down |
Drückt die angegebene Taste und hält sie gedrückt. |
key: strintent: str
|
key_up |
Gibt die angegebene Taste frei. |
key: strintent: str
|
hotkey |
Drückt die angegebene Tastenkombination. |
keys: List[str]intent: str
|
take_screenshot |
Gibt einen Screenshot des aktuellen Bildschirms zurück. | intent: str |
scroll |
Scrollt an einer Koordinate um einen Pixelabstand nach oben, unten, links oder rechts. |
y: int (0-999)x: int (0-999)direction: str ("up", "down", "left", "right")intent: strmagnitude_in_pixels: int (0-999, optional, Standardwert 300)
|
Gemini 3 Flash
| Befehlsname | Beschreibung | Argumente (im Funktionsaufruf) | Beispiel für einen Funktionsaufruf |
|---|---|---|---|
| open_web_browser | Öffnet den Webbrowser. | Keine | {"name": "open_web_browser", "args": {}} |
| wait_5_seconds | Pausiert die Ausführung für 5 Sekunden, damit dynamische Inhalte geladen oder Animationen abgeschlossen werden können. | Keine | {"name": "wait_5_seconds", "args": {}} |
| go_back | Ruft die vorherige Seite im Browserverlauf auf. | Keine | {"name": "go_back", "args": {}} |
| go_forward | Navigiert zur nächsten Seite im Browserverlauf. | Keine | {"name": "go_forward", "args": {}} |
| search | Ruft die Startseite der Standardsuchmaschine auf (z. B. Google). Nützlich, um eine neue Suchaufgabe zu starten. | Keine | {"name": "search", "args": {}} |
| navigate | Leitet den Browser direkt zur angegebenen URL weiter. | url: str |
{"name": "navigate", "args": {"url": "https://www.wikipedia.org"}}
|
| click_at | Klickt auf eine bestimmte Koordinate auf der Webseite. Die x- und y-Werte basieren auf einem 1000x1000-Raster und werden auf die Bildschirmabmessungen skaliert. | y: int (0–999), x: int (0–999) |
{"name": "click_at", "args": {"y": 300, "x": 500}}
|
| hover_at | 521963309 Bewegt den Mauszeiger auf eine bestimmte Koordinate auf der Webseite. Nützlich zum Einblenden von Untermenüs. x und y basieren auf einem 1000x1000-Raster. | y: int (0–999) x: int (0–999) |
{"name": "hover_at", "args": {"y": 150, "x": 250}}
|
| type_text_at | Gibt Text an einer bestimmten Koordinate ein. Standardmäßig wird das Feld zuerst gelöscht und nach der Eingabe die Eingabetaste gedrückt. Diese Optionen können jedoch deaktiviert werden. x und y basieren auf einem 1000x1000-Raster. |
y: int (0-999), x: int (0-999),
text: str, press_enter: bool (Optional,
Standardwert True), clear_before_typing: bool (Optional,
Standardwert True)
|
{"name": "type_text_at", "args": {"y": 250, "x": 400,
"text": "search query", "press_enter": false}}
|
| key_combination | Drückt Tastaturtasten oder Tastenkombinationen wie „Strg + C“ oder „Eingabe“. Nützlich zum Auslösen von Aktionen (z. B. Senden eines Formulars mit der Eingabetaste) oder für Vorgänge in der Zwischenablage. |
keys: str (z. B. „enter“, „control+c“). Eine vollständige Liste der zulässigen Schlüssel finden Sie in der API-Referenz.
|
{"name": "key_combination", "args": {"keys":
"Control+A"}}
|
| scroll_document | Scrollt die gesamte Webseite nach oben, unten, links oder rechts. | direction: str ("up", "down", "left" oder "right") |
{"name": "scroll_document", "args": {"direction": "down"}}
|
| scroll_at | Scrollt ein bestimmtes Element oder einen bestimmten Bereich an der Koordinate (x, y) in die angegebene Richtung um einen bestimmten Betrag. Koordinaten und Größe (Standardwert 800) basieren auf einem 1000x1000-Raster. |
y: int (0–999), x: int (0–999),
direction: str ("up", "down", "left", "right"),
magnitude: int (0–999, optional, Standardwert 800)
|
{"name": "scroll_at", "args": {"y": 500, "x": 500,
"direction": "down", "magnitude": 400}}
|
| drag_and_drop | Zieht ein Element von einer Startkoordinate (x, y) und legt es an einer Zielkoordinate (destination_x, destination_y) ab. Alle Koordinaten basieren auf einem 1000 x 1000-Raster. |
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}}
|
Sicherheit
In diesem Abschnitt werden die Sicherheitsmaßnahmen beschrieben, die das Tool zur Computernutzung bietet, um die Nutzerkontrolle und die Sicherheit zu verbessern. Außerdem werden Best Practices zur Minimierung potenzieller neuer Risiken beschrieben, die das Tool mit sich bringen könnte.
Sicherheitsentscheidung bestätigen
Je nach Aktion kann die Antwort des Modells einen safety_decision von einem internen Sicherheitssystem enthalten. Mit dieser Entscheidung wird die vom Tool vorgeschlagene Aktion auf Sicherheit überprüft.
{
"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"
}
}
}
}
]
}
}
Wenn der safety_decision require_confirmation ist, müssen Sie den Endnutzer um Bestätigung bitten, bevor Sie die Aktion ausführen.
Im folgenden Codebeispiel wird der Endnutzer vor dem Ausführen der Aktion um Bestätigung gebeten. Wenn der Nutzer die Aktion nicht bestätigt, wird die Schleife beendet. Wenn der Nutzer die Aktion bestätigt, wird sie ausgeführt und das Feld safety_acknowledgement wird als True markiert.
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 ...
Wenn der Nutzer die Bestätigung erteilt, müssen Sie die Sicherheitsbestätigung in Ihre FunctionResponse aufnehmen.
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
)
)
]
)
)
Erkennung von Prompt Injection
Die Computernutzung in Gemini 3.5 Flash oder höher unterstützt einen erweiterten Sicherheitsmechanismus, um Prompt-Injection-Angriffe zu erkennen. Wenn diese Funktion aktiviert ist, wird geprüft, ob ein enthaltener Screenshot das Potenzial hat, einen Prompt-Injection-Angriff auszulösen. Sie können diese Funktion in der Konfiguration für die Computernutzung festlegen. Der Standardwert ist false.
In den folgenden Beispielen wird gezeigt, wie Sie die Konfiguration für die Computernutzung aktivieren, um die Prompt-Injection-Erkennung zu aktivieren:
REST API
Ersetzen Sie diese Werte in den folgenden Anfragedaten:
- PROJECT_ID: Ihre Projekt-ID.
HTTP-Methode und URL:
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
JSON-Text anfordern:
{
"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
}
}
]
}
Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:
Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.
Python
Für das folgende Beispiel ist python-genai Version 2.7.0 oder höher erforderlich.
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
),
)
)
Best Practices für die Sicherheit
Die Nutzung von Computern birgt Risiken, die Entwickler beachten sollten:
- Nicht vertrauenswürdige Inhalte und Betrug: Wenn das Modell versucht, das Ziel des Nutzers zu erreichen, kann es sich auf nicht vertrauenswürdige Informationsquellen und Anweisungen auf dem Bildschirm verlassen.
- Gelegentliche unbeabsichtigte Aktionen: Das Modell kann das Ziel eines Nutzers oder den Inhalt einer Webseite falsch interpretieren, was zu falschen Aktionen wie dem Klicken auf die falsche Schaltfläche oder dem Ausfüllen des falschen Formulars führen kann.
- Richtlinienverstöße: Die Funktionen der API könnten für Aktivitäten verwendet werden, die gegen die Nutzungsbedingungen und Richtlinien von Google verstoßen, z. B. das Umgehen von CAPTCHAs oder das Beeinträchtigen der Systemintegrität.
Um diese Risiken zu minimieren, sollten Sie die folgenden Sicherheitsmaßnahmen und Best Practices implementieren:
- Human-in-the-Loop (HITL):
- Nutzerbestätigung implementieren: Wenn die Sicherheitsantwort
require_confirmationangibt, müssen Sie vor der Ausführung eine Nutzerbestätigung implementieren. - Benutzerdefinierte Sicherheitsanweisungen bereitstellen: Zusätzlich zu den integrierten Bestätigungsprüfungen durch Nutzer können Entwickler optional eine benutzerdefinierte Systemanweisung hinzufügen, die ihre eigenen Sicherheitsrichtlinien durchsetzt. Damit können sie entweder bestimmte Modellaktionen blockieren oder eine Bestätigung durch Nutzer anfordern, bevor das Modell bestimmte risikoreiche, unumkehrbare Aktionen ausführt.
Klicken Sie hier, um ein Beispiel für eine benutzerdefinierte Systemanweisung für die Sicherheit aufzurufen.
## **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.
- Nutzerbestätigung implementieren: Wenn die Sicherheitsantwort
- Sichere Ausführungsumgebung: Führen Sie Ihren Agenten in einer sicheren Sandbox-Umgebung aus, um seine potenziellen Auswirkungen zu begrenzen (z. B. eine Sandbox-VM, ein Container wie Docker oder ein dediziertes Browserprofil mit eingeschränkten Berechtigungen).
- Eingabebereinigung: Bereinigen Sie alle von Nutzern generierten Texte in Prompts, um das Risiko unbeabsichtigter Anweisungen oder Prompt Injections zu minimieren. Dies ist eine hilfreiche Sicherheitsebene, aber kein Ersatz für eine sichere Ausführungsumgebung.
- Inhaltsschutz: Verwenden Sie Schutzmaßnahmen und APIs für die Inhaltssicherheit (z. B. Model Armor), um Nutzereingaben, Tooleingaben und -ausgaben sowie die Antworten des KI-Agenten auf Angemessenheit, Prompt Injection und Jailbreaking zu prüfen.
- Zulassungs- und Sperrlisten: Implementieren Sie Filtermechanismen, um zu steuern, wohin das Modell navigieren und was es tun kann. Eine Sperrliste mit verbotenen Websites ist ein guter Ausgangspunkt, während eine restriktivere Zulassungsliste noch sicherer ist.
- Beobachtbarkeit und Logging: Führen Sie detaillierte Logs für die Fehlerbehebung, Audits und die Incident Response. Ihr Client sollte Prompts, Screenshots, vom Modell vorgeschlagene Aktionen (
function_call), Sicherheitsantworten und alle letztendlich vom Client ausgeführten Aktionen protokollieren. - Umgebungsverwaltung: Sorgen Sie für eine konsistente GUI-Umgebung. Unerwartete Pop-ups, Systembenachrichtigungen oder Layoutverschiebungen können das Modell verwirren. Beginnen Sie nach Möglichkeit jede neue Aufgabe mit einem bekannten, sauberen Zustand.
Human-in-the-Loop-Bestätigungen (HITL)
Human-in-the-Loop-Bestätigungen (HITL) sind der Prozess, bei dem eine Nutzerbestätigung eingeholt wird, bevor eine vom Modell vorgeschlagene Aktion ausgeführt wird. Dieser Prozess ist erforderlich, wenn das Modell eine Aktion aus Sicherheitsgründen nicht ausführen kann.
Das Tool zur Computernutzung von Gemini bietet die folgenden Mechanismen zur Steuerung von HITL-Bestätigungen:
- Auf Entwicklerebene: Entwickler können konfigurieren, ob einige oder alle Standard-HITL-Bestätigungen erzwungen werden.
- Auf Organisationsebene: Administratoren der Organisation können eine Richtlinie auf Organisationsebene erstellen, die verhindert, dass einzelne Entwickler einige oder alle HITL-Bestätigungen deaktivieren. Diese Richtlinie überschreibt alle Einstellungen auf Entwicklerebene.
HITL-Bestätigungen überschreiben
Sie können die folgenden HITL-Standardbestätigungen überschreiben:
FINANCIAL_TRANSACTIONS: Abschluss des letzten Schritts einer Finanztransaktion (z. B. Zahlungen, Überweisungen, Zahlungsanweisungen, Starten oder Ändern eines Abos oder Abschluss einer Reservierung).SENSITIVE_DATA_MODIFICATION: Änderung vertraulicher Informationen, z. B. Gesundheits-, Finanz- oder Behördendaten.COMMUNICATION_TOOL: Zugriff auf oder Nutzung von Kommunikationstools zum Senden, Teilen, Posten oder anderweitigen Übertragen von Mitteilungen.ACCOUNT_CREATION: Interaktion mit Registrierungs- oder Anmeldeabläufen, bei denen neue Nutzer- oder Dienstkonten erstellt oder bereitgestellt werden.DATA_MODIFICATION: Änderung, Verwaltung, Freigabe, Speicherung, Übermittlung oder Löschung von Browserdaten oder -dateien.USER_CONSENT_MANAGEMENT: Interaktion mit Dialogen oder Bannern zur Nutzereinwilligung durch Treffen einer Entscheidung.LEGAL_TERMS_AND_AGREEMENTS: Interaktion mit Dialogfeldern für rechtsverbindliche Vereinbarungen, z. B. zur Annahme von Nutzungsbedingungen, Dialogfeldern für Datenschutzerklärungen oder rechtlichen Hinweisen.
Sie können alle diese HITL-Bestätigungen überschreiben, indem Sie sie im Feld disabled_safety_policies der Konfiguration für die Computernutzung auflisten:
Python
GenerateContent API
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,
)Interactions API
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
GenerateContent API
{
"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"
]
}
}
]
}Interactions API
{
"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"
]
}
]
}Organisationsrichtlinien erstellen
Wenn Sie ein Administrator der Organisation sind, können Sie mit dem Organisationsrichtliniendienst eine Richtlinie auf Organisationsebene erstellen, die verhindert, dass einzelne Entwickler einige oder alle HITL-Bestätigungen deaktivieren. Diese Richtlinie hat Vorrang vor allen Einstellungen auf Entwicklerebene.
Sie können eine Richtlinie entweder mit der Google Cloud Console oder mit der Google Cloud CLI erstellen.
Die Einschränkungs-ID lautet vertexai.configurableComputerUseToolSafetyPolicies.
Es kann bis zu einer Stunde dauern, bis Änderungen an Organisationsrichtlinien wirksam werden.
Ausführliche Informationen zum Erstellen und Verwalten von Organisationsrichtlinien finden Sie unter Organisationsrichtlinien erstellen.
Preise
Die Computernutzung wird zu denselben Preisen wie Gemini abgerechnet und verwendet dieselben SKUs. Verwenden Sie benutzerdefinierte Metadatenlabels, um die Kosten für die Computernutzung aufzuteilen. Weitere Informationen zur Verwendung benutzerdefinierter Metadatenlabels für das Kostenmonitoring finden Sie unter Benutzerdefinierte Metadatenlabels.