Penggunaan komputer

Untuk melihat contoh Pengantar Penggunaan Komputer dengan Gemini, jalankan notebook "Pengantar Penggunaan Komputer dengan Gemini" di salah satu lingkungan berikut:

Buka di Colab | Buka di Colab Enterprise | Buka di Agent Platform Workbench | Lihat di GitHub

Alat penggunaan komputer Gemini memungkinkan Anda membangun agen kontrol browser, seluler, dan desktop yang berinteraksi dengan dan mengotomatiskan tugas di seluruh antarmuka pengguna grafis (GUI). Jika penggunaan komputer diaktifkan, model akan menggunakan screenshot untuk mengamati layar dan bertindak dengan menghasilkan tindakan UI tertentu seperti klik mouse, scroll, dan input keyboard.

Gemini mendukung beberapa kemampuan penggunaan komputer tingkat lanjut:

• Dukungan multi-lingkungan: Bangun agen untuk lingkungan browser, seluler, dan desktop.
• Tindakan yang disederhanakan dengan intent: Tindakan menyertakan kolom intent yang menjelaskan alasan model di balik setiap langkah.
• Kebijakan keamanan yang dapat dikonfigurasi: Sesuaikan perilaku keamanan dengan kategori dan penggantian kebijakan bawaan.
• Deteksi prompt injection: Pemindaian screenshot yang diaktifkan untuk mendeteksi petunjuk adversarial tersembunyi.

Anda dapat memanfaatkan penggunaan komputer untuk membangun agen yang dapat:

• Mengotomatiskan entri data atau pengisian formulir berulang di seluruh situs dan aplikasi desktop.
• Melakukan pengujian otomatis terhadap alur pengguna web, seluler, dan desktop.
• Menjelajahi situs dan aplikasi untuk mengumpulkan riset (misalnya, membandingkan informasi produk, harga, dan ulasan).
• Membantu pengguna dengan melakukan urutan tindakan multilangkah di berbagai aplikasi.

Panduan ini membahas:

• Cara kerja penggunaan komputer
• Cara mengaktifkan penggunaan komputer
• Cara menyiapkan lingkungan, mengirim permintaan, menerima respons, dan membangun agent loop
• Lingkungan dan fungsi kustom yang didukung
• Tindakan komputer yang didukung
• Dukungan keselamatan dan keamanan
• Harga

Serupa dengan panggilan fungsi, Anda perlu menulis kode aplikasi sisi klien untuk menerima panggilan fungsi penggunaan komputer dan menjalankan tindakan yang sesuai.

Panduan ini mengasumsikan bahwa Anda menggunakan Google Gen AI SDK for Python dan sudah memahami Playwright API.

Anda dapat menemukan implementasi referensi untuk penggunaan komputer di GitHub.

Model yang didukung

Penggunaan komputer didukung dalam model berikut:

Klik untuk meluaskan model yang didukung

• Gemini Robotics ER 2 pratinjau
• Gemini 4 Argon
• Gemini 3.8 Flash
• Gemini 3.7 Flash
• Gemini 3.6 Flash
• Gemini 3.5 Flash-Lite
• Gemini 3.5 Flash
• Gemini 3 Flash pratinjau

Cara kerja penggunaan komputer

Alih-alih menghasilkan respons teks, penggunaan komputer menentukan kapan harus mengambil tindakan UI tertentu seperti klik mouse, dan menampilkan parameter yang diperlukan untuk menjalankan tindakan ini. Anda perlu menulis kode aplikasi sisi klien untuk menerima function_call penggunaan komputer dan menjalankan tindakan yang sesuai.

Interaksi penggunaan komputer mengikuti proses loop agentic:

1. Mengirim permintaan ke model

   • Tambahkan penggunaan komputer (dan alat tambahan lainnya jika perlu) ke permintaan API Anda.
   • Mengirim perintah ke model dengan permintaan pengguna dan screenshot yang mewakili status GUI saat ini.

2. Menerima respons model

   • Model menganalisis permintaan pengguna dan screenshot, serta menghasilkan respons yang menyertakan function_call yang disarankan yang mewakili tindakan UI (misalnya, "klik pada koordinat (x,y)" atau "ketik 'teks'"). Lihat Tindakan yang didukung untuk mengetahui daftar semua tindakan yang dapat Anda gunakan dengan model.
   • Respons API juga dapat menyertakan safety_decision dari sistem keamanan internal yang telah memeriksa tindakan yang diusulkan model. safety_decision ini mengklasifikasikan tindakan sebagai:
     • Reguler atau diizinkan: Tindakan ini dianggap aman. Hal ini juga dapat ditunjukkan dengan tidak adanya safety_decision.
     • Memerlukan konfirmasi: Model akan melakukan tindakan yang mungkin berisiko (misalnya, mengklik "terima banner cookie").

3. Menjalankan tindakan yang diterima

   • Kode sisi klien Anda menerima function_call dan safety_decision yang menyertainya.
   • Jika safety_decision menunjukkan reguler atau diizinkan (atau jika tidak ada safety_decision), kode sisi klien Anda dapat menjalankan function_call yang ditentukan di lingkungan target Anda (seperti browser web).
   • Jika safety_decision menunjukkan konfirmasi yang diperlukan, aplikasi Anda harus meminta konfirmasi kepada pengguna akhir sebelum menjalankan function_call. Jika pengguna mengonfirmasi, lanjutkan untuk menjalankan tindakan. Jika pengguna menolak, jangan jalankan tindakan.

4. Merekam status lingkungan baru

   • Jika tindakan telah dijalankan, klien Anda akan mengambil screenshot baru GUI dan URL saat ini untuk dikirim kembali ke model sebagai bagian dari function_response.
   • Jika suatu tindakan diblokir oleh sistem keamanan atau ditolak konfirmasinya oleh pengguna, aplikasi Anda mungkin akan mengirimkan bentuk masukan yang berbeda ke model atau mengakhiri interaksi.

Permintaan baru dikirim ke model dengan status yang diperbarui. Proses ini berulang dari langkah 2, dengan model menggunakan screenshot baru (jika disediakan) dan sasaran yang sedang berlangsung untuk menyarankan tindakan berikutnya. Loop berlanjut hingga tugas selesai, terjadi error, atau proses dihentikan (misalnya, jika respons diblokir oleh filter keamanan atau keputusan pengguna).

Diagram berikut mengilustrasikan cara kerja penggunaan komputer:

Mengaktifkan penggunaan komputer

Untuk mengaktifkan penggunaan komputer, pastikan aplikasi Anda menggunakan salah satu model yang didukung, dan tambahkan penggunaan komputer ke daftar alat yang diaktifkan:

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

Menyiapkan lingkungan eksekusi

Sebelum membangun dengan alat penggunaan komputer, siapkan:

• Lingkungan eksekusi yang aman: Jalankan agen Anda di virtual machine (VM) atau container (seperti Docker) yang di-sandbox untuk mengisolasinya dari sistem host Anda.
• Pengendali tindakan sisi klien: Terapkan logika klien untuk menjalankan klik mouse, penekanan keyboard, dan pengambilan screenshot.

Pertama, instal dependensi SDK dan browser, lalu konfigurasi lingkungan Anda:

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

Selanjutnya, lakukan inisialisasi instance browser Playwright dengan dimensi area pandang eksplisit agar koordinat yang dinormalisasi (0–1000) diskalakan secara akurat:

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

Mengirim permintaan

Setelah mengonfigurasi alat penggunaan komputer, kirim perintah ke model yang menyertakan sasaran pengguna dan screenshot awal GUI.

Anda juga dapat menambahkan hal berikut secara opsional:

• Tindakan yang dikecualikan: Jika ada tindakan dari daftar tindakan UI yang didukung yang tidak ingin Anda lakukan pada model, tentukan tindakan ini di excluded_predefined_functions.
• Fungsi yang ditentukan pengguna: Anda mungkin ingin menyertakan fungsi kustom yang ditentukan pengguna selain penggunaan komputer.

Kode contoh berikut mengaktifkan penggunaan komputer dan mengirimkan permintaan ke model:

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)
      

Anda juga dapat menyertakan fungsi kustom yang ditentukan pengguna untuk memperluas fungsionalitas model. Lihat Gemini 3.5 Flash atau yang lebih baru dan kasus penggunaan seluler atau desktop untuk mengetahui informasi tentang cara mengonfigurasi penggunaan komputer untuk kasus penggunaan seluler dengan menambahkan tindakan seperti open_app, long_press_at, dan go_home sambil mengecualikan tindakan khusus browser.

Menerima respons

Model akan merespons dengan satu atau beberapa FunctionCalls jika menentukan bahwa tindakan UI atau fungsi yang ditentukan pengguna diperlukan untuk menyelesaikan tugas. Kode aplikasi Anda perlu mengurai tindakan ini, menjalankannya, dan mengumpulkan hasilnya. Penggunaan komputer mendukung pemanggilan fungsi paralel, yang berarti model dapat menampilkan beberapa tindakan independen dalam satu giliran.

Untuk model Gemini 3.5 Flash dan yang lebih baru, setiap tindakan menyertakan argumen intent yang menjelaskan penalaran model di balik langkah tersebut:

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

Bergantung pada tindakannya, respons API mungkin juga menampilkan safety_decision di dalam argumen panggilan fungsi:

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

Menjalankan tindakan yang diterima

Setelah menerima respons, uraikan function_call, skalakan koordinat dari petak 0–1000 yang dinormalisasi ke dimensi piksel area pandang yang sebenarnya, dan jalankan tindakan:

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

Jika safety_decision yang ditampilkan adalah require_confirmation, Anda harus meminta pengguna untuk mengonfirmasi sebelum melanjutkan eksekusi tindakan. Sesuai dengan persyaratan layanan, Anda tidak diizinkan untuk mengabaikan permintaan konfirmasi manusia.

Merekam status baru

Setelah menjalankan tindakan, kemas setiap hasil tindakan dan screenshot yang diperbarui ke dalam FunctionResponse untuk ditampilkan ke model:

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

Membangun agent loop

Gabungkan langkah-langkah ini ke dalam loop menyeluruh yang terus melakukan iterasi antara model dan lingkungan eksekusi:

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 atau yang lebih baru dan kasus penggunaan seluler atau desktop

Penggunaan komputer mendukung setelan lingkungan seluler (ENVIRONMENT_MOBILE), desktop (ENVIRONMENT_DESKTOP), atau browser (ENVIRONMENT_BROWSER). Defaultnya adalah ENVIRONMENT_BROWSER.

Contoh berikut menunjukkan cara mengonfigurasi lingkungan eksekusi untuk penggunaan komputer dengan Gemini 3.5 Flash atau yang lebih baru:

REST API

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

• PROJECT_ID: Project ID Anda.

Metode HTTP dan URL:

POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent

Meminta isi 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"
      }
    }
  ]
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

curl -X POST \
     -H "Authorization: Bearer TOKEN" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent"

PowerShell (Windows)

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$headers = @{ "Authorization" = "Bearer TOKEN" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent" | Select-Object -Expand Content

Anda akan menerima kode status yang berhasil (2xx) dan respons kosong.

Python

Contoh berikut memerlukan python-genai versi 2.7.0 atau yang lebih baru.

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

Fungsi yang ditentukan pengguna (UDF) kustom

Anda dapat memperluas fungsi model dengan menggabungkan computer_use dengan fungsi yang ditentukan pengguna (UDF) (function_declarations). Misalnya, dalam skenario human-in-the-loop (HITL), Anda dapat mengecualikan tindakan standar tertentu menggunakan excluded_predefined_functions dan mendaftarkan fungsi yield_to_user kustom sehingga agen dapat mengembalikan kontrol kepada manusia saat menemukan perintah 2FA atau layar yang ambigu:

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)
      

Tindakan yang didukung

Alat penggunaan komputer memungkinkan model meminta tindakan berikut menggunakan FunctionCall. Kode sisi klien Anda harus menerapkan logika eksekusi untuk tindakan ini. Lihat contoh implementasi referensi. Tabel berikut berisi tindakan yang didukung untuk lingkungan browser. Model Gemini 3 Flash dan Gemini 3.5 Flash atau yang lebih baru memiliki set nama FunctionCall yang berbeda.

Gemini 3.5 Flash atau yang lebih baru

Gemini 3.5 Flash: Anda memiliki akses ke berbagai set panggilan fungsi, bergantung pada lingkungan yang Anda pilih:

Lingkungan browser

Nama perintah	Deskripsi	Argumen (dalam Panggilan Fungsi)
click	Klik kiri pada koordinat yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
double_click	Mengklik dua kali pada koordinat yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
triple_click	Klik tiga kali pada koordinat yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
middle_click	Klik tengah pada koordinat yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
right_click	Mengklik kanan pada koordinat yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
mouse_down	Menekan lama tombol mouse pada koordinat.	y: int (0-999) x: int (0-999) intent: str
mouse_up	Melepaskan tombol mouse pada koordinat.	y: int (0-999) x: int (0-999) intent: str
move	Memindahkan kursor ke posisi yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
type	Mengetik teks (secara opsional mengklik x, y terlebih dahulu).	y: int (0-999, Opsional) x: int (0-999, Opsional) text: str press_enter: bool (Opsional, default false) intent: str
drag_and_drop	Menarik item dari (start_x, start_y) ke (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	Menunggu selama jumlah detik yang ditentukan.	seconds: int (Opsional, default 1) intent: str
press_key	Menekan tombol yang ditentukan dan melepaskannya.	key: str intent: str
key_down	Menekan dan menahan tombol yang ditentukan.	key: str intent: str
key_up	Melepaskan tombol yang ditentukan.	key: str intent: str
hotkey	Menekan kombinasi tombol yang ditentukan.	keys: List[str] intent: str
take_screenshot	Menampilkan screenshot layar saat ini.	intent: str
scroll	Men-scroll ke atas, bawah, kiri, atau kanan pada koordinat dengan jarak piksel.	y: int (0-999) x: int (0-999) direction: str ("up", "down", "left", "right") magnitude_in_pixels: int (0-999, Opsional, default 300) intent: str
open_web_browser	Membuka browser web.	intent: str
navigate	Mengarahkan browser langsung ke URL yang ditentukan.	url: str intent: str
go_back	Kembali ke halaman web sebelumnya di histori penjelajahan.	intent: str
go_forward	Menavigasi maju ke halaman web berikutnya dalam histori penjelajahan browser.	intent: str

Lingkungan seluler

Nama perintah	Deskripsi	Argumen (dalam Panggilan Fungsi)
open_app	Membuka aplikasi berdasarkan namanya.	intent: str
click	Klik kiri pada koordinat.	y: int (0-999) x: int (0-999) intent: str
list_apps	Mencantumkan aplikasi yang tersedia di perangkat, menampilkan nama dan nama paketnya.	intent: str
wait	Menunggu selama jumlah detik yang ditentukan.	intent: str seconds: int(Opsional, default 1)
go_back	Kembali ke halaman web sebelumnya di histori browser.	intent: str
type	Mengetik teks.	text: str intent: str press_enter: bool(Opsional, default false)
drag_and_drop	Menarik item dari start_y dan start_x ke end_y dan 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	Melakukan penekanan lama pada koordinat y (0-999), x (0-999) tertentu di layar.	y: int (0-999) x: int (0-999) intent: str seconds: int (Opsional, default 2)
press_key	Menekan tombol yang ditentukan, lalu melepaskannya.	key: str intent: str
take_screenshot	Menampilkan screenshot layar saat ini.	intent: str

Lingkungan desktop

Nama perintah	Deskripsi	Argumen (dalam Panggilan Fungsi)
click	Klik kiri pada koordinat.	y: int (0-999) x: int (0-999) intent: str
double_click	Klik dua kali pada koordinat.	y: int (0-999) x: int (0-999) intent: str
triple_click	Klik tiga kali pada koordinat.	y: int (0-999) x: int (0-999) intent: str
middle_click	Klik tengah pada koordinat.	y: int (0-999) x: int (0-999) intent: str
right_click	Klik kanan pada koordinat.	y: int (0-999) x: int (0-999) intent: str
mouse_down	Menekan lama tombol mouse pada koordinat.	y: int (0-999) x: int (0-999) intent: str
mouse_up	Melepaskan tombol mouse pada koordinat.	y: int (0-999) x: int (0-999) intent: str
move	Memindahkan kursor ke posisi yang ditentukan.	y: int (0-999) x: int (0-999) intent: str
type	Mengetik teks.	text: str intent: str press_enter: bool(Opsional, default false)
drag_and_drop	Menarik item dari start_y dan start_x ke end_y dan 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	Tunggu selama jumlah detik yang ditentukan.	intent: str seconds: int(Opsional, default 1)
press_key	Menekan tombol yang ditentukan dan melepaskannya.	key: str intent: str
key_down	Menekan dan menahan tombol yang ditentukan.	key: str intent: str
key_up	Melepaskan tombol yang ditentukan.	key: str intent: str
hotkey	Menekan kombinasi tombol yang ditentukan.	keys: List[str] intent: str
take_screenshot	Menampilkan screenshot layar saat ini.	intent: str
scroll	Men-scroll ke atas, bawah, kiri, atau kanan pada koordinat dengan jarak piksel.	y: int (0-999) x: int (0-999) direction: str ("up", "down", "left", "right") intent: str magnitude_in_pixels: int (0-999, Opsional, default 300)

Gemini 3 Flash

Command Name	Deskripsi	Argumen (dalam Panggilan Fungsi)	Contoh Panggilan Fungsi
open_web_browser	Membuka browser web.	Tidak ada	{"name": "open_web_browser", "args": {}}
wait_5_seconds	Menjeda eksekusi selama 5 detik untuk memungkinkan konten dinamis dimuat atau animasi selesai.	Tidak ada	{"name": "wait_5_seconds", "args": {}}
go_back	Membuka halaman sebelumnya di histori browser.	Tidak ada	{"name": "go_back", "args": {}}
go_forward	Membuka halaman berikutnya dalam histori browser.	Tidak ada	{"name": "go_forward", "args": {}}
search	Membuka halaman beranda mesin telusur default (misalnya, Google). Berguna untuk memulai tugas penelusuran baru.	Tidak ada	{"name": "search", "args": {}}
navigate	Mengarahkan browser langsung ke URL yang ditentukan.	url: str	{"name": "navigate", "args": {"url": "https://www.wikipedia.org"}}
click_at	Mengklik koordinat tertentu di halaman web. Nilai x dan y didasarkan pada petak 1000x1000 dan diskalakan ke dimensi layar.	y: int (0-999), x: int (0-999)	{"name": "click_at", "args": {"y": 300, "x": 500}}
hover_at	521963309 Mengarahkan kursor mouse ke koordinat tertentu di halaman web. Berguna untuk menampilkan sub-menu. x dan y didasarkan pada petak 1000x1000.	y: int (0-999) x: int (0-999)	{"name": "hover_at", "args": {"y": 150, "x": 250}}
type_text_at	Mengetik teks pada koordinat tertentu, secara default menghapus kolom terlebih dahulu dan menekan ENTER setelah mengetik, tetapi tindakan ini dapat dinonaktifkan. x dan y didasarkan pada petak 1000x1000.	y: int (0-999), x: int (0-999), text: str, press_enter: bool (Opsional, default True), clear_before_typing: bool (Opsional, default True)	{"name": "type_text_at", "args": {"y": 250, "x": 400, "text": "search query", "press_enter": false}}
key_combination	Menekan tombol atau kombinasi keyboard, seperti "Control+C" atau "Enter". Berguna untuk memicu tindakan (seperti mengirimkan formulir dengan "Enter") atau operasi papan klip.	keys: str (misalnya, 'enter', 'control+c'. Lihat referensi API untuk mengetahui daftar lengkap kunci yang diizinkan)	{"name": "key_combination", "args": {"keys": "Control+A"}}
scroll_document	Men-scroll seluruh halaman web "ke atas", "ke bawah", "ke kiri", atau "ke kanan".	direction: str ("up", "down", "left", atau "right")	{"name": "scroll_document", "args": {"direction": "down"}}
scroll_at	Men-scroll elemen atau area tertentu pada koordinat (x, y) ke arah yang ditentukan dengan besaran tertentu. Koordinat dan magnitudo (default 800) didasarkan pada petak 1000x1000.	y: int (0-999), x: int (0-999), direction: str ("up", "down", "left", "right"), magnitude: int (0-999, Opsional, default 800)	{"name": "scroll_at", "args": {"y": 500, "x": 500, "direction": "down", "magnitude": 400}}
drag_and_drop	Menarik elemen dari koordinat awal (x, y) dan melepaskannya di koordinat tujuan (destination_x, destination_y). Semua koordinat didasarkan pada petak 1000x1000.	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}}

Keselamatan dan keamanan

Bagian ini menjelaskan pengamanan yang dimiliki alat penggunaan komputer untuk meningkatkan kontrol pengguna dan meningkatkan keamanan. Panduan ini juga menjelaskan praktik terbaik untuk mengurangi potensi risiko baru yang mungkin ditimbulkan oleh alat tersebut.

Mengonfirmasi keputusan keselamatan

Bergantung pada tindakan, respons dari model mungkin menyertakan safety_decision dari sistem keamanan internal. Keputusan ini memverifikasi tindakan yang diusulkan oleh alat untuk keamanan.

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

Jika safety_decision adalah require_confirmation, Anda harus meminta konfirmasi pengguna akhir sebelum melanjutkan eksekusi tindakan.

Contoh kode berikut meminta konfirmasi pengguna akhir sebelum menjalankan tindakan. Jika pengguna tidak mengonfirmasi tindakan, loop akan dihentikan. Jika pengguna mengonfirmasi tindakan, tindakan akan dijalankan dan kolom safety_acknowledgement akan ditandai sebagai 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 ...

Jika pengguna mengonfirmasi, Anda harus menyertakan konfirmasi keselamatan dalam FunctionResponse Anda.

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

Deteksi injeksi perintah

Penggunaan komputer di Gemini 3.5 Flash atau yang lebih baru mendukung mekanisme keamanan lanjutan untuk mendeteksi serangan injeksi perintah. Jika diaktifkan, fitur ini akan memeriksa apakah screenshot yang disertakan berpotensi menimbulkan serangan injeksi perintah. Anda dapat menyetel fitur ini di konfigurasi penggunaan komputer. Nilai defaultnya adalah false.

Contoh berikut menunjukkan cara mengaktifkan konfigurasi penggunaan komputer untuk mengaktifkan deteksi injeksi perintah:

REST API

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

• PROJECT_ID: Project ID Anda.

Metode HTTP dan URL:

POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent

Meminta isi 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
      }
    }
  ]
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

curl -X POST \
     -H "Authorization: Bearer TOKEN" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent"

PowerShell (Windows)

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$headers = @{ "Authorization" = "Bearer TOKEN" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent" | Select-Object -Expand Content

Anda akan menerima kode status yang berhasil (2xx) dan respons kosong.

Python

Contoh berikut memerlukan python-genai versi 2.7.0 atau yang lebih baru.

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

Praktik terbaik keamanan

Penggunaan komputer menimbulkan risiko yang harus diperhatikan oleh developer:

• Konten tidak tepercaya & scam: Saat mencoba mencapai sasaran pengguna, model mungkin mengandalkan sumber informasi dan petunjuk yang tidak tepercaya dari layar.
• Tindakan yang terkadang tidak diinginkan: Model dapat salah menafsirkan sasaran pengguna atau konten halaman web, sehingga menyebabkan model melakukan tindakan yang salah seperti mengklik tombol yang salah atau mengisi formulir yang salah.
• Pelanggaran kebijakan: Kemampuan API dapat diarahkan ke aktivitas yang melanggar persyaratan dan kebijakan Google, seperti mengabaikan CAPTCHA atau membahayakan integritas sistem.

Untuk mengatasi risiko ini, Anda harus menerapkan langkah-langkah keamanan dan praktik terbaik berikut:

1. Human-in-the-loop (HITL):
   • Terapkan konfirmasi pengguna: Jika respons keamanan menunjukkan require_confirmation, Anda harus menerapkan konfirmasi pengguna sebelum eksekusi.
   • Memberikan petunjuk keamanan kustom: Selain pemeriksaan konfirmasi pengguna bawaan, developer dapat menambahkan petunjuk sistem kustom yang menerapkan kebijakan keamanan mereka sendiri, baik untuk memblokir tindakan model tertentu atau mewajibkan konfirmasi pengguna sebelum model melakukan tindakan tertentu yang berisiko tinggi dan tidak dapat dibatalkan.

   Klik untuk melihat contoh petunjuk sistem keamanan kustom

   ## **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.
       

2. Lingkungan eksekusi yang aman: Jalankan agen Anda di lingkungan yang aman dan di-sandbox untuk membatasi potensi dampaknya (misalnya, virtual machine (VM) yang di-sandbox, container (seperti Docker), atau profil browser khusus dengan izin terbatas).
3. Sanitasi input: Bersihkan semua teks buatan pengguna dalam perintah untuk mengurangi risiko petunjuk yang tidak diinginkan atau injeksi perintah. Ini adalah lapisan keamanan yang berguna, tetapi bukan pengganti lingkungan eksekusi yang aman.
4. Pembatasan konten: Gunakan pembatasan dan Content Safety API (seperti Model Armor) untuk mengevaluasi input pengguna, Input Tools dan output, serta respons agen untuk kesesuaian, injeksi perintah, dan deteksi jailbreak.
5. Daftar yang diizinkan dan daftar yang tidak diizinkan: Terapkan mekanisme pemfilteran untuk mengontrol ke mana model dapat membuka dan apa yang dapat dilakukannya. Daftar yang tidak diizinkan untuk situs yang dilarang adalah titik awal yang baik, sedangkan daftar yang diizinkan yang lebih ketat bahkan lebih aman.
6. Kemampuan observasi dan logging: Mempertahankan log mendetail untuk proses debug, audit, dan respons insiden. Klien Anda harus mencatat perintah, screenshot, tindakan yang disarankan model (function_call), respons keamanan, dan semua tindakan yang pada akhirnya dijalankan oleh klien.
7. Pengelolaan lingkungan: Pastikan lingkungan GUI konsisten. Pop-up, notifikasi sistem, atau pergeseran tata letak yang tidak terduga dapat membingungkan model. Mulai dari status yang diketahui dan bersih untuk setiap tugas baru jika memungkinkan.

Konfirmasi human-in-the-loop (HITL)

Catatan: Fitur ini hanya tersedia untuk model Gemini 3.5 Flash dan yang lebih baru.

Konfirmasi human-in-the-loop (HITL) adalah proses meminta konfirmasi pengguna sebelum menjalankan tindakan yang disarankan model. Proses ini diperlukan saat model tidak dapat melakukan tindakan karena masalah keamanan.

Alat penggunaan komputer Gemini menyediakan mekanisme berikut untuk mengontrol konfirmasi HITL:

• Di tingkat developer: Developer dapat mengonfigurasi apakah beberapa atau semua konfirmasi HITL default diterapkan atau tidak.
• Di tingkat organisasi: Administrator organisasi dapat membuat kebijakan tingkat organisasi yang mencegah masing-masing developer menonaktifkan beberapa atau semua konfirmasi HITL. Kebijakan ini menggantikan setelan tingkat developer apa pun.

Mengganti konfirmasi HITL

Anda dapat mengganti konfirmasi HITL default berikut:

• FINANCIAL_TRANSACTIONS: Penyelesaian langkah terakhir transaksi keuangan (seperti pembayaran, transfer dana, melakukan wesel, memulai atau mengubah langganan, atau menyelesaikan reservasi).
• SENSITIVE_DATA_MODIFICATION: Perubahan informasi sensitif, seperti catatan layanan kesehatan, keuangan, atau pemerintah.
• COMMUNICATION_TOOL: Akses untuk atau penggunaan alat komunikasi untuk mengirim, membagikan, memposting, atau mentransmisikan komunikasi.
• ACCOUNT_CREATION: Interaksi dengan alur pendaftaran atau login yang membuat atau menyediakan akun pengguna atau layanan baru.
• DATA_MODIFICATION: Modifikasi, pengelolaan, pembagian, penyimpanan, pengiriman, atau penghapusan data atau file browser.
• USER_CONSENT_MANAGEMENT: Interaksi dengan dialog atau banner izin pengguna dengan membuat keputusan.
• LEGAL_TERMS_AND_AGREEMENTS: Interaksi dengan dialog perjanjian yang mengikat secara hukum, seperti penerimaan persyaratan layanan, dialog kebijakan privasi, atau pemberitahuan hukum.

Anda dapat mengganti salah satu atau semua konfirmasi HITL ini dengan mencantumkannya dalam kolom disabled_safety_policies pada konfigurasi penggunaan komputer:

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

Membuat kebijakan organisasi

Jika Anda adalah administrator organisasi, Anda dapat membuat kebijakan tingkat organisasi menggunakan Organization Policy Service yang mencegah developer individu menonaktifkan beberapa atau semua konfirmasi HITL. Kebijakan ini menggantikan setelan tingkat developer apa pun.

Anda dapat membuat kebijakan menggunakan konsolGoogle Cloud atau menggunakan Google Cloud CLI. ID batasan adalah vertexai.configurableComputerUseToolSafetyPolicies. Perubahan kebijakan organisasi dapat memerlukan waktu hingga satu jam untuk diterapkan.

Untuk mengetahui detail selengkapnya tentang cara membuat dan mengelola kebijakan organisasi, lihat Membuat kebijakan organisasi.

Harga

Penggunaan komputer dikenai harga yang sama dengan Gemini dan menggunakan SKU yang sama. Untuk membagi biaya penggunaan komputer, gunakan label metadata kustom. Untuk mengetahui informasi selengkapnya tentang penggunaan label metadata kustom untuk pemantauan biaya, lihat Label metadata kustom.