הכלי של Gemini לשימוש במחשב מאפשר לכם ליצור סוכני בקרה לדפדפן, לנייד ולמחשב, שמקיימים אינטראקציה עם ממשקי משתמש גרפיים (GUI) ומבצעים בהם משימות באופן אוטומטי. כשהתכונה "שימוש במחשב" מופעלת, המודל משתמש בצילומי מסך כדי לצפות במסך ולפעול על ידי יצירת פעולות ספציפיות בממשק המשתמש, כמו קליקים בעכבר, גלילה וקלט מהמקלדת.
Gemini תומך בכמה יכולות מתקדמות של שימוש במחשב:
- תמיכה בסביבות מרובות: פיתוח נציגים לסביבות של דפדפנים, מכשירים ניידים ומחשבים.
- פעולות יעילות עם כוונות: הפעולות כוללות שדה
intentשמסביר את הסיבה של המודל לכל שלב. - מדיניות בטיחות ניתנת להגדרה: אפשר לשנות את התנהגות הבטיחות באמצעות קטגוריות מדיניות מובנות ושינויים ידניים.
- גלאי החדרת פרומפטים: סריקת צילומי מסך כדי לזהות הוראות נסתרות שמיועדות לפגוע במערכת. אתם יכולים להפעיל את התכונה הזו אם אתם רוצים.
אתם יכולים להשתמש בתכונה "שימוש במחשב" כדי ליצור סוכנים שיכולים:
- אוטומציה של הזנת נתונים או מילוי טפסים שחוזרים על עצמם באתרים ובאפליקציות למחשב.
- לבצע בדיקות אוטומטיות של מסלולי משתמשים באינטרנט, בנייד ובמחשב.
- לנווט באתרים ובאפליקציות כדי לאסוף מידע (לדוגמה, להשוות בין פרטי מוצרים, מחירים וביקורות).
- לעזור למשתמשים לבצע רצפים של פעולות בכמה שלבים באפליקציות שונות.
הנושאים במדריך:
- איך פועלת התכונה "שימוש במחשב"
- איך מפעילים את השימוש במחשב
- איך מגדירים את הסביבה, שולחים בקשות, מקבלים תשובות ויוצרים לולאות סוכנים
- סביבות נתמכות ופונקציות בהתאמה אישית
- אילו פעולות נתמכות במחשב
- תמיכה בנושאי בטיחות ואבטחה
- Pricing
בדומה לקריאה להפעלת פונקציות, צריך לכתוב את קוד האפליקציה בצד הלקוח כדי לקבל את בקשת הפעלת הפונקציה של השימוש במחשב ולבצע את הפעולות המתאימות.
המדריך הזה מבוסס על ההנחה שאתם משתמשים ב-Google Gen AI SDK ל-Python ומכירים את Playwright API.
הטמעת העזר לשימוש במחשב זמינה ב-GitHub.
מודלים נתמכים
התכונה "שימוש במחשב" נתמכת במודלים הבאים:
לחצו כדי להרחיב את רשימת המודלים הנתמכים
איך פועלת התכונה "שימוש במחשב"
במקום ליצור תשובות טקסט, התכונה "שימוש במחשב" קובעת מתי לבצע פעולות ספציפיות בממשק המשתמש, כמו קליקים בעכבר, ומחזירה את הפרמטרים הנדרשים לביצוע הפעולות האלה. אתם צריכים לכתוב את קוד האפליקציה בצד הלקוח כדי לקבל את function_call של השימוש במחשב ולבצע את הפעולות המתאימות.
האינטראקציות של השימוש במחשב מתבצעות בתהליך של לולאת סוכן:
שליחת בקשה למודל
- מוסיפים את השימוש במחשב (ואם רוצים, גם כלים נוספים) לבקשת ה-API.
- שולחים למודל הנחיה עם הבקשה של המשתמש וצילום מסך שמייצג את המצב הנוכחי של ממשק המשתמש הגרפי.
קבלת התשובה מהמודל
- המודל מנתח את בקשת המשתמש ואת צילום המסך, ויוצר תשובה שכוללת הצעה ל-
function_callשמייצג פעולה בממשק המשתמש (לדוגמה, "לחיצה בקואורדינטה (x,y)" או "הקלדת 'טקסט'"). רשימה של כל הפעולות שאפשר לבצע באמצעות המודל מופיעה בקטע פעולות נתמכות. - התגובה מה-API עשויה לכלול גם
safety_decisionממערכת בטיחות פנימית שבדקה את הפעולה שהמודל הציע. הפעולה הזו מסווגת את הפעולה כ:safety_decision- רגילה או מותרת: הפעולה נחשבת בטוחה. יכול להיות גם שלא יופיע
safety_decision. - נדרש אישור: המודל עומד לבצע פעולה שעלולה להיות מסוכנת (לדוגמה, לחיצה על "אישור באנר של קובצי Cookie").
- רגילה או מותרת: הפעולה נחשבת בטוחה. יכול להיות גם שלא יופיע
- המודל מנתח את בקשת המשתמש ואת צילום המסך, ויוצר תשובה שכוללת הצעה ל-
ביצוע הפעולה שהתקבלה
- הקוד בצד הלקוח מקבל את ה-
function_callואת כל ה-safety_decisionהנלווים. - אם הערך של
safety_decisionמציין שהפעולה רגילה או מותרת (או אם אין ערך שלsafety_decision), הקוד בצד הלקוח יכול להריץ את ה-function_callשצוין בסביבת היעד (למשל דפדפן אינטרנט). - אם השדה
safety_decisionמציין שנדרש אישור, האפליקציה צריכה לבקש אישור ממשתמש הקצה לפני ביצוע ה-function_call. אם המשתמש מאשר, ממשיכים בביצוע הפעולה. אם המשתמש לא מסכים, אל תבצעו את הפעולה.
- הקוד בצד הלקוח מקבל את ה-
תיעוד המצב של הסביבה החדשה
- אם הפעולה בוצעה, הלקוח מצלם צילום מסך חדש של ממשק המשתמש הגרפי ושל כתובת ה-URL הנוכחית כדי לשלוח אותם בחזרה למודל כחלק מ-
function_response. - אם פעולה נחסמה על ידי מערכת הבטיחות או שהמשתמש לא אישר אותה, האפליקציה יכולה לשלוח למודל משוב מסוג אחר או לסיים את האינטראקציה.
- אם הפעולה בוצעה, הלקוח מצלם צילום מסך חדש של ממשק המשתמש הגרפי ושל כתובת ה-URL הנוכחית כדי לשלוח אותם בחזרה למודל כחלק מ-
בקשה חדשה נשלחת למודל עם המצב המעודכן. התהליך חוזר על עצמו משלב 2, כשהמודל משתמש בצילום המסך החדש (אם הוא סופק) והמטרה המתמשכת היא להציע את הפעולה הבאה. הלולאה נמשכת עד שהמשימה מסתיימת, מתרחשת שגיאה או שהתהליך מסתיים (לדוגמה, אם התשובה נחסמת על ידי מסנני בטיחות או החלטת משתמש).
התרשים הבא ממחיש איך פועל השימוש במחשב:
הפעלת השימוש במחשב
כדי להפעיל את השימוש במחשב, ודאו שהאפליקציה משתמשת באחד מהמודלים הנתמכים, והוסיפו את השימוש במחשב לרשימת הכלים המופעלים:
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" } } ] }'
הגדרת סביבת ההפעלה
לפני שמתחילים לפתח עם הכלי לשימוש במחשב, צריך להגדיר:
- סביבת הרצה מאובטחת: מריצים את הנציג במכונה וירטואלית (VM) או בקונטיינר (כמו Docker) בארגז חול (sandbox) כדי לבודד אותו מהמערכת המארחת.
- רכיב לטיפול בפעולות בצד הלקוח: הטמעת לוגיקה בצד הלקוח כדי לבצע לחיצות עכבר, הקשות במקלדת וצילומי מסך.
קודם מתקינים את ה-SDK ואת יחסי התלות של הדפדפן, ואז מגדירים את הסביבה:
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
בשלב הבא, מפעילים מכונה של דפדפן Playwright עם מידות מפורשות של אזור התצוגה, כדי שהקואורדינטות המנורמלות (0-1000) יותאמו בצורה מדויקת:
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")
שליחת בקשה
אחרי שמגדירים את הכלי לשימוש במחשב, שולחים למודל הנחיה שכוללת את המטרה של המשתמש וצילום מסך ראשוני של ממשק המשתמש הגרפי.
אפשר גם להוסיף את הפרטים הבאים:
- פעולות מוחרגות: אם יש פעולות ברשימת הפעולות הנתמכות בממשק המשתמש שאתם לא רוצים שהמודל יבצע, ציינו את הפעולות האלה ב-
excluded_predefined_functions. - פונקציות בהגדרת המשתמש (UDF): יכול להיות שתרצו לכלול פונקציות בהתאמה אישית בהגדרת המשתמש, בנוסף לשימוש במחשב.
הקוד לדוגמה הבא מפעיל את השימוש במחשב ושולח את הבקשה למודל:
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)
אפשר גם לכלול פונקציות בהגדרת המשתמש (UDF) כדי להרחיב את הפונקציונליות של המודל. בקטע Gemini 3.5 Flash ואילך ותרחישים לדוגמה בנייד או במחשב מוסבר איך להגדיר את השימוש במחשב לתרחישים לדוגמה בנייד על ידי הוספת פעולות כמו open_app, long_press_at ו-go_home, תוך החרגת פעולות ספציפיות לדפדפן.
קבלת תשובות
המודל מגיב עם FunctionCalls אחד או יותר אם הוא קובע שנדרשות פעולות בממשק המשתמש או פונקציות בהגדרת המשתמש כדי להשלים את המשימה. קוד האפליקציה צריך לנתח את הפעולות האלה, להריץ אותן ולאסוף את התוצאות.
התכונה "שימוש במחשב" תומכת בקריאה להפעלת פונקציות במקביל, כלומר המודל יכול להחזיר כמה פעולות בלתי תלויות בפנייה אחת.
במודלים מ-Gemini 3.5 Flash והלאה, כל פעולה כוללת ארגומנט intent שמסביר את הנימוק של המודל לשלב הזה:
{ "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." } } } ] } }
בהתאם לפעולה, התגובה מה-API עשויה גם להחזיר safety_decision בתוך הארגומנטים של בקשה להפעלת פונקציה:
{ "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" } } } } ] } }
ביצוע פעולות שהתקבלו
אחרי שמקבלים תשובה, מנתחים את ה-function_call, משנים את קנה המידה של הקואורדינטות מהרשת המנורמלת של 0-1000 לממדי הפיקסלים בפועל של אזור התצוגה, ומבצעים את הפעולה:
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
אם הערך של safety_decision שמוחזר הוא require_confirmation, צריך לבקש מהמשתמש לאשר לפני שממשיכים בביצוע הפעולה. בהתאם לתנאים ולהגבלות, אסור לעקוף בקשות לאישור אנושי.
תיעוד המצב החדש
אחרי ביצוע הפעולות, אורזים את התוצאה של כל פעולה ואת צילום המסך המעודכן ב-FunctionResponse כדי להחזיר למודל:
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, )
יצירת לולאת סוכן
שלבו את השלבים האלה בלולאה מקצה לקצה שחוזרת על עצמה באופן רציף בין המודל לסביבת ההפעלה:
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 או גרסה חדשה יותר ותרחישי שימוש בנייד או במחשב
במחשב אפשר להגדיר סביבות לנייד (ENVIRONMENT_MOBILE), למחשב (ENVIRONMENT_DESKTOP) או לדפדפן (ENVIRONMENT_BROWSER). ערך ברירת המחדל הוא ENVIRONMENT_BROWSER.
הדוגמאות הבאות ממחישות איך להגדיר את סביבת ההרצה לשימוש במחשב עם Gemini 3.5 Flash או גרסה חדשה יותר:
API בארכיטקטורת REST
לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:
- PROJECT_ID: מזהה הפרויקט.
ה-method של ה-HTTP וכתובת ה-URL:
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
תוכן בקשת JSON:
{
"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"
}
}
]
}
כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:
אמורים לקבל קוד סטטוס של הצלחה (2xx) ותגובה ריקה.
Python
בדוגמה הבאה נדרשת גרסה 2.7.0 ומעלה של python-genai.
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
),
)
)
פונקציות מותאמות אישית בהגדרת המשתמש (UDF)
אתם יכולים להרחיב את הפונקציונליות של המודל על ידי שילוב של computer_use עם פונקציות מותאמות אישית בהגדרת המשתמש (function_declarations). לדוגמה, בתרחישים של האדם שבתהליך (HITL), אתם יכולים להחריג פעולות ספציפיות שהוגדרו מראש באמצעות excluded_predefined_functions ולרשום פונקציית yield_to_user מותאמת אישית, כדי שהנציג יוכל להחזיר את השליטה לאדם כשהוא נתקל בהנחיות לאימות דו-שלבי או במסכים לא ברורים:
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)
פעולות נתמכות
הכלי לשימוש במחשב מאפשר למודל לבקש לבצע את הפעולות הבאות באמצעות FunctionCall. הקוד בצד הלקוח צריך להטמיע את לוגיקת הביצוע של הפעולות האלה. לדוגמאות, עיינו בהטמעה לדוגמה. בטבלה הבאה מפורטות הפעולות שנתמכות בסביבת הדפדפן.
למודלים Gemini 3 Flash ו-Gemini 3.5 Flash או למודלים מתקדמים יותר יש קבוצות שמות שונות של FunctionCall.
Gemini 3.5 Flash או גרסה חדשה יותר
Gemini 3.5 Flash: יש לכם גישה לקבוצות שונות של קריאות לפונקציות, בהתאם לסביבה שבחרתם:סביבת הדפדפן
| שם הפקודה | תיאור | ארגומנטים (בקריאה להפעלת פונקציה) |
|---|---|---|
click |
לחיצה שמאלית בקואורדינטה שצוינה. |
y: int (0-999)x: int (0-999)intent: str
|
double_click |
לחיצה כפולה בקואורדינטה שצוינה. |
y: int (0-999)x: int (0-999)intent: str
|
triple_click |
לחיצה משולשת בקואורדינטה שצוינה. |
y: int (0-999)x: int (0-999)intent: str
|
middle_click |
לחיצה על הלחצן האמצעי בקואורדינטה שצוינה. |
y: int (0-999)x: int (0-999)intent: str
|
right_click |
לחיצה ימנית בקואורדינטה שצוינה. |
y: int (0-999)x: int (0-999)intent: str
|
mouse_down |
לוחצים לחיצה ארוכה על כפתור העכבר בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
mouse_up |
משחררת את כפתור העכבר בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
move |
העברת הסמן למיקום שצוין. |
y: int (0-999)x: int (0-999)intent: str
|
type |
הקלדת טקסט (אפשרות ללחיצה על x, y קודם). |
y: int (0-999, אופציונלי)x: int (0-999, אופציונלי)text: strpress_enter: bool (אופציונלי, ברירת המחדל היא false)intent: str
|
drag_and_drop |
גרירת פריט מ-(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 |
ממתינה למספר השניות שצוין. |
seconds: int (אופציונלי, ברירת המחדל היא 1)intent: str
|
press_key |
לחיצה על המקש שצוין ושחרור שלו. |
key: strintent: str
|
key_down |
לחיצה ארוכה על המקש שצוין. |
key: strintent: str
|
key_up |
שחרור המקש שצוין. |
key: strintent: str
|
hotkey |
לחיצה על שילוב המקשים שצוין. |
keys: List[str]intent: str
|
take_screenshot |
הפונקציה מחזירה צילום מסך של המסך הנוכחי. | intent: str |
scroll |
גלילה למעלה, למטה, שמאלה או ימינה בקואורדינטה לפי מרחק בפיקסלים. |
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 |
הפעולה הזו תפתח את דפדפן האינטרנט. | intent: str |
navigate |
הדפדפן מנווט ישירות לכתובת ה-URL שצוינה. |
url: strintent: str
|
go_back |
חזרה לדף האינטרנט הקודם בהיסטוריית הגלישה של הדפדפן. | intent: str |
go_forward |
מעבר לדף האינטרנט הבא בהיסטוריית הגלישה של הדפדפן. | intent: str |
סביבה לנייד
| שם הפקודה | תיאור | ארגומנטים (בקריאה להפעלת פונקציה) |
|---|---|---|
open_app |
פתיחת אפליקציה לפי השם שלה. | intent: str |
click |
לחיצה שמאלית בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
list_apps |
מציגה את האפליקציות שזמינות במכשיר, ומחזירה את השמות שלהן ואת שמות החבילות שלהן. | intent: str |
wait |
ממתינה למספר השניות שצוין. |
intent: strseconds: int(אופציונלי, ברירת המחדל היא 1)
|
go_back |
חזרה לדף האינטרנט הקודם בהיסטוריית הדפדפן. | intent: str |
type |
הקלדת טקסט. |
text: strintent: strpress_enter: bool(אופציונלי, ברירת המחדל היא false)
|
drag_and_drop |
גרירת פריט מ-start_y ומ-start_x אל end_y ואל 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 |
לחיצה ארוכה על קואורדינטה ספציפית של y (0-999), x (0-999) במסך. |
y: int (0-999)x: int (0-999)intent: strseconds: int (אופציונלי, ברירת המחדל היא 2)
|
press_key |
לחיצה על המקש שצוין ושחרור שלו. |
key: strintent: str
|
take_screenshot |
הפונקציה מחזירה צילום מסך של המסך הנוכחי. | intent: str |
סביבת שולחן העבודה
| שם הפקודה | תיאור | ארגומנטים (בקריאה להפעלת פונקציה) |
|---|---|---|
click |
לחיצה שמאלית בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
double_click |
לחיצה כפולה על הקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
triple_click |
לחיצה משולשת על הקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
middle_click |
לחיצה על הלחצן האמצעי בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
right_click |
לחיצה ימנית על הקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
mouse_down |
לוחצים לחיצה ארוכה על כפתור העכבר בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
mouse_up |
משחררת את כפתור העכבר בקואורדינטה. |
y: int (0-999)x: int (0-999)intent: str
|
move |
העברת הסמן למיקום שצוין. |
y: int (0-999)x: int (0-999)intent: str
|
type |
הקלדת טקסט. |
text: strintent: strpress_enter: bool(אופציונלי, ברירת המחדל היא false)
|
drag_and_drop |
גורר פריט מ-start_y ומ-start_x אל end_y ואל 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 |
ממתינים למספר השניות שצוין. |
intent: strseconds: int(אופציונלי, ברירת המחדל היא 1)
|
press_key |
לחיצה על המקש שצוין ושחרור שלו. |
key: strintent: str
|
key_down |
לחיצה ארוכה על המקש שצוין. |
key: strintent: str
|
key_up |
שחרור המקש שצוין. |
key: strintent: str
|
hotkey |
לחיצה על שילוב המקשים שצוין. |
keys: List[str]intent: str
|
take_screenshot |
הפונקציה מחזירה צילום מסך של המסך הנוכחי. | intent: str |
scroll |
גלילה למעלה, למטה, שמאלה או ימינה בקואורדינטה לפי מרחק בפיקסלים. |
y: int (0-999)x: int (0-999)direction: str ("up", "down", "left", "right")intent: strmagnitude_in_pixels: int (0-999, אופציונלי, ברירת המחדל היא 300)
|
Gemini 3 Flash
| שם הפקודה | תיאור | ארגומנטים (בקריאה להפעלת פונקציה) | דוגמה לבקשה להפעלת פונקציה |
|---|---|---|---|
| open_web_browser | הפעולה הזו תפתח את דפדפן האינטרנט. | ללא | {"name": "open_web_browser", "args": {}} |
| wait_5_seconds | השהיית ההפעלה למשך 5 שניות כדי לאפשר לתוכן דינמי להיטען או לאנימציות להסתיים. | ללא | {"name": "wait_5_seconds", "args": {}} |
| go_back | מעבר לדף הקודם בהיסטוריה של הדפדפן. | ללא | {"name": "go_back", "args": {}} |
| go_forward | מעבר לדף הבא בהיסטוריה של הדפדפן. | ללא | {"name": "go_forward", "args": {}} |
| search | מעבר לדף הבית של מנוע החיפוש שמוגדר כברירת מחדל (לדוגמה, Google). הכלי הזה שימושי כשרוצים להתחיל משימת חיפוש חדשה. | ללא | {"name": "search", "args": {}} |
| navigate | הדפדפן מנווט ישירות לכתובת ה-URL שצוינה. | url: str |
{"name": "navigate", "args": {"url": "https://www.wikipedia.org"}}
|
| click_at | לחיצה על קואורדינטה ספציפית בדף האינטרנט. ערכי ה-X וה-Y מבוססים על רשת של 1,000x1,000 ומותאמים לממדי המסך. | y: int (0-999), x: int (0-999) |
{"name": "click_at", "args": {"y": 300, "x": 500}}
|
| hover_at | 521963309 העברת העכבר מעל קואורדינטה ספציפית בדף האינטרנט. הפעולה הזו שימושית כדי להציג תפריטי משנה. הערכים של x ו-y מבוססים על רשת של 1,000x1,000. | y: int (0-999) x: int (0-999) |
{"name": "hover_at", "args": {"y": 150, "x": 250}}
|
| type_text_at | הקלדת טקסט בקואורדינטה ספציפית. כברירת מחדל, הפעולה מנקה את השדה קודם ולוחצת על ENTER אחרי ההקלדה, אבל אפשר להשבית את האפשרויות האלה. x ו-y מבוססים על רשת של 1000x1000. |
y: int (0-999), x: int (0-999),
text: str, press_enter: bool (אופציונלי,
ברירת המחדל היא True), clear_before_typing: bool (אופציונלי,
ברירת המחדל היא True)
|
{"name": "type_text_at", "args": {"y": 250, "x": 400,
"text": "search query", "press_enter": false}}
|
| key_combination | לחיצה על מקשים או על שילובים של מקשים, כמו "Control+C" או "Enter". התכונה הזו שימושית להפעלת פעולות (כמו שליחת טופס באמצעות Enter) או פעולות בלוח. |
keys: מחרוזת (לדוגמה, "enter", "control+c"). רשימה מלאה של המפתחות המותרים מופיעה במאמרי העזרה של ה-API)
|
{"name": "key_combination", "args": {"keys":
"Control+A"}}
|
| scroll_document | גלילה של כל דף האינטרנט "למעלה", "למטה", "שמאלה" או "ימינה". | direction: מחרוזת ("up", "down", "left" או "right") |
{"name": "scroll_document", "args": {"direction": "down"}}
|
| scroll_at | גלילה של רכיב או אזור ספציפי בקואורדינטה (x, y) בכיוון שצוין ובמידה מסוימת. הקואורדינטות והגודל (ברירת המחדל היא 800) מבוססים על רשת של 1,000x1,000. |
y: מספר שלם (0-999), x: מספר שלם (0-999),
direction: מחרוזת ("up", "down", "left", "right"),
magnitude: מספר שלם (0-999, אופציונלי, ברירת המחדל היא 800)
|
{"name": "scroll_at", "args": {"y": 500, "x": 500,
"direction": "down", "magnitude": 400}}
|
| drag_and_drop | גוררת רכיב מקואורדינטת התחלה (x, y) ומשחררת אותו בקואורדינטת יעד (destination_x, destination_y). כל הקואורדינטות מבוססות על רשת של 1,000x1,000. |
y: מספר שלם (0-999), x: מספר שלם (0-999),
destination_y: מספר שלם (0-999),
destination_x: מספר שלם (0-999)
|
{"name": "drag_and_drop", "args": {"y": 100, "x": 100,
"destination_y": 500, "destination_x": 500}}
|
בטיחות ואבטחה
בקטע הזה מתוארים אמצעי ההגנה שקיימים בכלי לשימוש במחשב כדי לשפר את השליטה של המשתמשים ואת הבטיחות. בנוסף, מתוארות שיטות מומלצות לצמצום סיכונים חדשים שהכלי עלול להציג.
אישור ההחלטה בנושא בטיחות
בהתאם לפעולה, התשובה מהמודל עשויה לכלול safety_decision ממערכת בטיחות פנימית. ההחלטה הזו מאמתת את הפעולה שהכלי הציע כדי לשמור על הבטיחות.
{
"content": {
"parts": [
{
"text": "I have evaluated step 2. It seems Google detected unusual traffic and is asking me to verify I'm not a robot. I need to click the 'I'm not a robot' checkbox located near the top left (y=98, x=95)."
},
{
"function_call": {
"name": "click_at",
"args": {
"x": 60,
"y": 100,
"safety_decision": {
"explanation": "I have encountered a CAPTCHA challenge that requires interaction. I need you to complete the challenge by clicking the 'I'm not a robot' checkbox and any subsequent verification steps.",
"decision": "require_confirmation"
}
}
}
}
]
}
}
אם הערך של safety_decision הוא require_confirmation, חובה לבקש ממשתמש הקצה לאשר את הפעולה לפני שממשיכים בביצוע שלה.
דוגמת הקוד הבאה מבקשת אישור ממשתמש הקצה לפני ביצוע הפעולה. אם המשתמש לא מאשר את הפעולה, הלולאה מסתיימת. אם המשתמש מאשר את הפעולה, היא מבוצעת והשדה safety_acknowledgement מסומן כ-True.
import termcolor
def get_safety_confirmation(safety_decision):
"""Prompt user for confirmation when safety check is triggered."""
termcolor.cprint("Safety service requires explicit confirmation!", color="red")
print(safety_decision["explanation"])
decision = ""
while decision.lower() not in ("y", "n", "ye", "yes", "no"):
decision = input("Do you wish to proceed? [Y]es/[N]o\n")
if decision.lower() in ("n", "no"):
return "TERMINATE"
return "CONTINUE"
def execute_function_calls(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 ...
אם המשתמש מאשר, צריך לכלול את אישור הבטיחות ב-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
)
)
]
)
)
גלאי החדרת פרומפטים
התכונה "שימוש במחשב" ב-Gemini 3.5 Flash ואילך תומכת במנגנון אבטחה מתקדם לזיהוי מתקפות של החדרת פרומפטים. כשהתכונה הזו מופעלת, היא בודקת אם צילום מסך שצורף עלול לגרום למתקפת החדרת פרומפטים. אפשר להגדיר את התכונה הזו בהגדרות של השימוש במחשב. ערך ברירת המחדל הוא false.
הדוגמאות הבאות ממחישות איך להפעיל את ההגדרה של השימוש במחשב כדי להפעיל את גלאי החדרת הפרומפטים:
API בארכיטקטורת REST
לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:
- PROJECT_ID: מזהה הפרויקט.
ה-method של ה-HTTP וכתובת ה-URL:
POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
תוכן בקשת JSON:
{
"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
}
}
]
}
כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:
אמורים לקבל קוד סטטוס של הצלחה (2xx) ותגובה ריקה.
Python
בדוגמה הבאה נדרשת גרסה 2.7.0 ומעלה של python-genai.
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
),
)
)
שיטות מומלצות לשמירה על האבטחה
השימוש במחשב כרוך בסיכונים שהמפתחים צריכים להיות מודעים להם:
- תוכן לא מהימן ותרמיות: כשהמודל מנסה להשיג את המטרה של המשתמש, הוא עלול להסתמך על מקורות מידע והוראות לא מהימנים מהמסך.
- פעולות לא מכוונות מדי פעם: המודל עלול לפרש באופן שגוי את המטרה של המשתמש או את התוכן של דף האינטרנט, ולבצע פעולות שגויות כמו לחיצה על הכפתור הלא נכון או מילוי הטופס הלא נכון.
- הפרות מדיניות: יכול להיות שהיכולות של ה-API יופנו לפעילויות שמפירות את התנאים והמדיניות של Google, כמו עקיפת CAPTCHA או פגיעה בתקינות המערכת.
כדי להתמודד עם הסיכונים האלה, כדאי ליישם את אמצעי הבטיחות והשיטות המומלצות הבאים:
- האדם שבתהליך (HITL):
- הטמעת אישור משתמש: כשהתגובה של בדיקת הבטיחות היא
require_confirmation, צריך להטמיע אישור משתמש לפני הביצוע. - הוראות בטיחות מותאמות אישית: בנוסף לבדיקות המובנות לאישור המשתמש, המפתחים יכולים להוסיף הוראות מערכת מותאמות אישית שאוכפות את מדיניות הבטיחות שלהם. ההוראות האלה יכולות לחסום פעולות מסוימות של המודל או לדרוש אישור מהמשתמש לפני שהמודל מבצע פעולות מסוימות שהן בלתי הפיכות ובעלות סיכון גבוה.
אפשר ללחוץ כאן כדי לראות דוגמה להוראה מותאמת אישית למערכת הבטיחות
## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)** This is your first and most important check. If the next required action falls into any of the following categories, you MUST stop immediately, and seek the user's explicit permission. **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.
- הטמעת אישור משתמש: כשהתגובה של בדיקת הבטיחות היא
- סביבת הרצה מאובטחת: מריצים את הנציג בסביבה מאובטחת של ארגז חול (sandbox) כדי להגביל את ההשפעה הפוטנציאלית שלו (לדוגמה, מכונה וירטואלית (VM) בארגז חול, קונטיינר (כמו Docker) או פרופיל דפדפן ייעודי עם הרשאות מוגבלות).
- הסרת תוכן זדוני או רגיש מהקלט: כדי להפחית את הסיכון להוראות לא מכוונות או להחדרת פרומפטים, הסירו תוכן זדוני או רגיש מכל הטקסט שנוצר על ידי משתמשים בפרומפטים. זו שכבת אבטחה מועילה, אבל היא לא תחליף לסביבת הפעלה מאובטחת.
- מעקות בטיחות לתוכן: השתמשו במעקות בטיחות ובממשקי API לבטיחות תוכן (כמו Model Armor) כדי להעריך את הקלט של המשתמשים, את הקלט והפלט של הכלים לקליטת נתונים ואת התשובות של הסוכן, כדי לוודא שהם הולמים, ולזהות החדרת פרומפטים ופריצות.
- רשימות היתרים ורשימות חסימה: הטמיעו מנגנוני סינון כדי לקבוע לאן המודל יכול לנווט ומה הוא יכול לעשות. רשימת חסימה של אתרים אסורים היא נקודת התחלה טובה, אבל רשימת היתרים מגבילה יותר היא אפילו יותר מאובטחת.
- ניראות ורישום ביומן: ניהול יומנים מפורטים לניפוי באגים, לביקורת ולתגובה לאירועים. הלקוח צריך לתעד הנחיות, צילומי מסך, פעולות שהמודל הציע (
function_call), תגובות שקשורות לבטיחות וכל הפעולות שהלקוח ביצע בסופו של דבר. - ניהול הסביבה: ודאו שסביבת ה-GUI עקבית. חלונות קופצים לא צפויים, התראות מערכת או שינויים בפריסה עלולים לבלבל את המודל. אם אפשר, התחילו כל משימה חדשה ממצב מוכר ונקי.
אישורים של האדם שבתהליך (HITL)
אישורים של האדם שבתהליך (HITL) הם תהליך שבו מבקשים אישור מהמשתמש לפני שמבצעים פעולה שהמודל הציע. התהליך הזה נדרש כשהמודל לא יכול לבצע פעולה בגלל חששות שקשורים לבטיחות.
הכלי לשימוש במחשב של Gemini מספק את המנגנונים הבאים לשליטה באישורי HITL:
- ברמת המפתח: המפתחים יכולים להגדיר אם לאכוף את כל אישורי ה-HITL שמוגדרים כברירת מחדל, או רק חלק מהם.
- ברמת הארגון: אדמינים של הארגון יכולים ליצור מדיניות ברמת הארגון שמונעת ממפתחים בודדים להשבית חלק מאישורי ה-HITL או את כולם. המדיניות הזו מחליפה את כל ההגדרות ברמת המפתח.
שינוי אישורי HITL
אפשר לשנות את אישורי ברירת המחדל הבאים של HITL:
-
FINANCIAL_TRANSACTIONS: השלמת השלב האחרון של עסקה פיננסית (כמו תשלומים, העברות כספים, ביצוע הוראה כספית, התחלה או שינוי של מינוי או השלמת הזמנה). -
SENSITIVE_DATA_MODIFICATION: שינוי של מידע רגיש, כמו רשומות רפואיות, פיננסיות או ממשלתיות. COMMUNICATION_TOOL: גישה לכלי תקשורת או שימוש בהם כדי לשלוח, לשתף, לפרסם או להעביר תקשורת בדרך אחרת.-
ACCOUNT_CREATION: אינטראקציה עם תהליכי רישום או הרשמה שיוצרים או מקצים חשבונות משתמשים או חשבונות שירות חדשים. -
DATA_MODIFICATION: שינוי, ניהול, שיתוף, אחסון, שליחה או מחיקה של נתונים או קבצים בדפדפן. -
USER_CONSENT_MANAGEMENT: אינטראקציה עם תיבות דו-שיח או באנרים לבקשת הסכמה מהמשתמשים על ידי קבלת החלטה. -
LEGAL_TERMS_AND_AGREEMENTS: אינטראקציה עם תיבות דו-שיח של הסכמים מחייבים מבחינה משפטית, כמו אישור התנאים וההגבלות, תיבות דו-שיח של מדיניות פרטיות או הודעות משפטיות.
אפשר לשנות את כל האישורים האלה של HITL או חלק מהם, על ידי הוספה שלהם לשדה disabled_safety_policies בהגדרות של השימוש במחשב:
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"
]
}
]
}יצירת מדיניות ארגונית
אם אתם אדמינים בארגון, אתם יכולים ליצור מדיניות ברמת הארגון באמצעות שירות מדיניות הארגון, שמונעת ממפתחים בודדים להשבית חלק מאישורי ה-HITL או את כולם. המדיניות הזו מחליפה את כל ההגדרות ברמת המפתח.
אפשר ליצור מדיניות באמצעות מסוףGoogle Cloud או באמצעות Google Cloud CLI.
מזהה המגבלה הוא vertexai.configurableComputerUseToolSafetyPolicies.
יכול להיות שיעברו עד 60 דקות עד שהשינויים במדיניות הארגון יתעדכנו.
במאמר יצירת מדיניות ארגונית מוסבר איך יוצרים ומנהלים מדיניות ארגונית.
תמחור
התמחור של השימוש במחשב זהה לתעריפים של Gemini, והוא משתמש באותם מק"טים. כדי לפצל את עלויות השימוש במחשב, השתמשו בתוויות מטא-נתונים בהתאמה אישית. למידע נוסף על שימוש בתוויות מטא-נתונים בהתאמה אישית למעקב אחרי עלויות, קראו את המאמר תוויות מטא-נתונים בהתאמה אישית.