Përdorimi i kompjuterit

Mjeti "Përdorimi i Kompjuterit" ju lejon të ndërtoni agjentë kontrolli për shfletues, celular dhe desktop që bashkëveprojnë me detyrat dhe automatizojnë ato. Duke përdorur pamje të ekranit, modeli mund të "shohë" një ekran kompjuteri dhe të "veprojë" duke gjeneruar veprime specifike të ndërfaqes së përdoruesit, si klikimet e miut dhe hyrjet e tastierës. Ngjashëm me thirrjen e funksioneve, do t'ju duhet të zbatoni mjedisin e ekzekutimit në anën e klientit për të marrë dhe ekzekutuar veprimet e "Përdorimit të Kompjuterit".

Gemini 3.5 Flash është modeli i rekomanduar për përdorim në kompjuter dhe prezanton disa aftësi të reja:

• Mbështetje për shumë mjedise: ndërtoni agjentë për mjedise shfletuesi, celulari dhe desktopi .
• Veprime të përmirësuara me qëllime: veprimet përfshijnë një fushë intent që shpjegon arsyetimin e modelit pas çdo hapi.
• Politikat e sigurisë të konfigurueshme: rregulloni sjelljen e sigurisë me kategori dhe mbishkrime të integruara të politikave.
• Zbulim i shpejtë i injektimit: skanim i pamjeve të ekranit me zgjedhje për të zbuluar udhëzime të fshehura kundërshtare.

Me Përdorimin e Kompjuterit, ju mund të ndërtoni agjentë që:

• Automatizoni futjen e përsëritur të të dhënave ose plotësimin e formularëve në faqet e internetit.
• Kryeni testime automatike të aplikacioneve web dhe rrjedhave të përdoruesve
• Kryeni kërkime nëpër faqe të ndryshme interneti (p.sh., mbledhja e informacionit të produktit, çmimeve dhe vlerësimeve nga faqet e tregtisë elektronike për të informuar një blerje)

Ja një shembull minimal i inicializimit të klientit dhe dërgimit të një mesazhi te modeli me mjetin computer_use të aktivizuar për një mjedis shfletuesi:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Search for 'Gemini API' on Google.",
    tools=[{"type": "computer_use", "environment": "browser"}]
)

print(interaction)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const interaction = await ai.interactions.create({
  model: 'gemini-3.5-flash',
  input: "Search for 'Gemini API' on Google.",
  tools: [{ type: "computer_use", environment: "browser" }]
});

console.log(interaction);

Si funksionon përdorimi i kompjuterit

Për të ndërtuar një agjent me modelin e Përdorimit të Kompjuterit, duhet të konfiguroni një cikël të vazhdueshëm midis aplikacionit tuaj dhe API-t. Ja çfarë do të bëjë kodi juaj në secilin hap:

1. Dërgoni një kërkesë te modeli
   • Aplikacioni juaj dërgon një kërkesë API që përmban mjetin e Përdorimit të Kompjuterit, cilësimet e konfigurimit tuaj (si mjedisi i synuar), kërkesën e përdoruesit dhe një pamje të ekranit aktual.
2. Merrni përgjigjen e modelit
   • Modeli analizon ekranin dhe kërkesën, duke kthyer një përgjigje që përfshin një function_call të sugjeruar që përfaqëson një veprim të ndërfaqes së përdoruesit (siç është një klikim, lëvizje me lëvizje ose shtypje tastiere).
   • Për Gemini 3.5 Flash , përgjigjja përfshin gjithashtu një intent arsyetimi që shpjegon pse modeli zgjodhi atë veprim.
   • Për modelet e trashëguara (si p.sh. gemini-2.5-computer-use-preview-10-2025 ), përgjigjja mund të përfshijë një safety_decision nga një sistem i brendshëm sigurie që e klasifikon veprimin si të rregullt/të lejuar, require_confirmation (që kërkon miratimin e përdoruesit) ose të bllokuar.
3. Ekzekutoni veprimin e marrë
   • Nëse veprimi lejohet (ose përdoruesi e konfirmon atë), kodi juaj në anën e klientit analizon function_call , shkallëzon koordinatat e normalizuara që të përputhen me pamjen tuaj dhe ekzekuton veprimin në mjedisin tuaj të synuar duke përdorur mjete automatizimi (siç është Playwright). Nëse veprimi bllokohet, klienti juaj duhet ta ndalojë ekzekutimin ose të trajtojë ndërprerjen.
4. Kap gjendjen e re të mjedisit
   • Pasi veprimi të përfundojë ekzekutimin, aplikacioni juaj kap një pamje të re të ekranit dhe ia dërgon atë modelit në një function_result për të kërkuar hapin tjetër.

Ky proces përsëritet nga hapi 2, duke kërkuar vazhdimisht veprimin tjetër nga modeli derisa detyra të përfundojë ose të ndërpritet.

Si të zbatohet përdorimi i kompjuterit

Përpara se të ndërtoni me mjetin Përdorimi i Kompjuterit, do t'ju duhet të konfiguroni:

• Mjedis i sigurt ekzekutimi: Ekzekutoni agjentin tuaj në një VM ose kontejner të sandboxuar për ta izoluar atë nga sistemi juaj pritës dhe për të kufizuar ndikimin e tij të mundshëm. Implementimi i referencës përfshin një sandbox të bazuar në Docker, gati për përdorim, që mund ta përdorni si pikënisje.
• Trajneri i veprimeve në anën e klientit: Implementoni logjikën në anën e klientit për të ekzekutuar koordinatat, për të shkruar tekst dhe për të marrë pamje të ekranit.

Shembujt më poshtë përdorin një shfletues uebi si mjedis ekzekutimi dhe Playwright si trajtuesin në anën e klientit.

0. Ngritja e Dramaturgut

Së pari, instaloni paketat e nevojshme:

pip install google-genai playwright
playwright install chromium

Pastaj, inicializoni një instancë të shfletuesit Playwright për ta përdorur për ekzekutim:

from playwright.sync_api import sync_playwright

# 1. Configure screen dimensions for the target environment
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# 2. Start the Playwright browser
# In production, utilize a sandboxed environment.
playwright = sync_playwright().start()
# Set headless=False to see the actions performed on your screen
browser = playwright.chromium.launch(headless=False)

# 3. Create a context and page with the specified dimensions
context = browser.new_context(
    viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT}
)
page = context.new_page()

# 4. Navigate to an initial page to start the task
page.goto("https://www.google.com")

# The 'page', 'SCREEN_WIDTH', and 'SCREEN_HEIGHT' variables
# will be used in the steps below.

1. Dërgoni një kërkesë te modeli

Inicializoni bibliotekën e klientit dhe konfiguroni mjetin Përdorimi i Kompjuterit. Vini re se nuk ka nevojë të specifikoni madhësinë e ekranit kur lëshoni një kërkesë; modeli parashikon koordinatat e pikselëve të shkallëzuara në lartësinë dhe gjerësinë e ekranit.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model='gemini-3.5-flash',
    input="Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
    tools=[
        {
            "type": "computer_use",
            "environment": "browser",
            "enable_prompt_injection_detection": True
        }
    ]
)

print(interaction)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const interaction = await ai.interactions.create({
  model: 'gemini-3.5-flash',
  input: "Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
  tools: [
    {
      type: "computer_use",
      environment: "browser",
      enable_prompt_injection_detection: true
    }
  ]
});

console.log(interaction);

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th. Start by navigating directly to flights.google.com",
    "tools": [
      {
        "type": "computer_use",
        "environment": "browser",
        "enable_prompt_injection_detection": true
      }
    ]
  }'

from google import genai

client = genai.Client()

# Specify predefined functions to exclude (optional)
excluded_functions = ["drag_and_drop"]

interaction = client.interactions.create(
    model='gemini-2.5-computer-use-preview-10-2025',
    input="Search for highly rated smart fridges on Google Shopping.",
    tools=[
        {
            "type": "computer_use",
            "environment": "browser",
            "excluded_predefined_functions": excluded_functions
        }
    ]
)

print(interaction)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

// Specify predefined functions to exclude (optional)
const excludedFunctions = ["drag_and_drop"];

const interaction = await ai.interactions.create({
  model: 'gemini-2.5-computer-use-preview-10-2025',
  input: "Search for highly rated smart fridges on Google Shopping.",
  tools: [
    {
      type: "computer_use",
      environment: "browser",
      excluded_predefined_functions: excludedFunctions
    }
  ]
});

console.log(interaction);

2. Merrni përgjigjen e modelit

Modeli i përgjigjes sugjeron një thirrje funksioni. Për Gemini 3.5 Flash , përgjigja përmban një qëllim arsyetimi të përshtatur së bashku me koordinatat. Më poshtë tregohen shembuj të të dy përgjigjeve:

{
  "steps": [
    {
      "type": "function_call",
      "name": "click",
      "arguments": {
        "x": 450,
        "y": 120,
        "intent": "Click the search box to type the destination."
      }
    }
  ]
}

{
  "steps": [
    {
      "type": "model_output",
      "content": [
        {
          "type": "text",
          "text": "I will type the search query into the search bar."
        }
      ]
    },
    {
      "type": "function_call",
      "name": "type_text_at",
      "arguments": {
        "x": 371,
        "y": 470,
        "text": "highly rated smart fridges",
        "press_enter": true
      }
    }
  ]
}

3. Ekzekutoni veprimet e marra

Aplikacioni juaj duhet të analizojë koordinatat e përgjigjes, të ekzekutojë veprimin dhe t'i shkallëzojë ato nga koordinatat e normalizuara 1000x1000.

Kodi më poshtë trajton si komandat e mjeteve të trashëguara ( click_at , type_text_at ) ashtu edhe komandat e përmirësuara të Gemini 3.5 Flash ( click , type ).

from typing import Any, List, Tuple
import time

def denormalize_x(x: int, screen_width: int) -> int:
    """Convert normalized x coordinate (0-1000) to actual pixel coordinate."""
    return int(x / 1000 * screen_width)

def denormalize_y(y: int, screen_height: int) -> int:
    """Convert normalized y coordinate (0-1000) to actual pixel coordinate."""
    return int(y / 1000 * screen_height)

def execute_function_calls(interaction, page, screen_width, screen_height):
    results = []
    function_calls = [
        step for step in interaction.steps if step.type == "function_call"
    ]

    for function_call in function_calls:
        action_result = {}
        fname = function_call.name
        args = function_call.arguments
        print(f"  -> Executing: {fname} (Intent: {args.get('intent', 'N/A')})")

        try:
            if fname in ("open_web_browser", "open_app"):
                pass # Handled / already open
            elif fname in ("click", "click_at", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"):
                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 == "right_click":
                    page.mouse.click(actual_x, actual_y, button="right")
                elif fname == "middle_click":
                    page.mouse.click(actual_x, actual_y, button="middle")
                elif fname == "move":
                    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)

                if actual_x is not None and actual_y is not None:
                    page.mouse.click(actual_x, actual_y)
                # Clear field first
                page.keyboard.press("Meta+A")
                page.keyboard.press("Backspace")
                page.keyboard.type(text)
                if press_enter:
                    page.keyboard.press("Enter")
            elif fname == "navigate":
                page.goto(args["url"])
            elif fname == "go_back":
                page.go_back()
            elif fname == "go_forward":
                page.go_forward()
            elif fname == "wait":
                time.sleep(args.get("seconds", 1))
            else:
                print(f"Warning: Custom or 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, function_call.id, action_result))

    return results

function denormalizeX(x, screenWidth) {
    // Convert normalized x coordinate (0-1000) to actual pixel coordinate.
    return Math.floor((x / 1000) * screenWidth);
}

function denormalizeY(y, screenHeight) {
    // Convert normalized y coordinate (0-1000) to actual pixel coordinate.
    return Math.floor((y / 1000) * screenHeight);
}

async function executeFunctionCalls(interaction, page, screenWidth, screenHeight) {
    const results = [];
    const functionCalls = interaction.steps.filter(step => step.type === "function_call");

    for (const functionCall of functionCalls) {
        const actionResult = {};
        const fname = functionCall.name;
        const args = functionCall.arguments;
        console.log(`  -> Executing: ${fname} (Intent: ${args.intent || 'N/A'})`);

        try {
            if (fname === "open_web_browser" || fname === "open_app") {
                // Handled / already open
            } else if (["click", "click_at", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"].includes(fname)) {
                const actualX = denormalizeX(args.x, screenWidth);
                const actualY = denormalizeY(args.y, screenHeight);

                if (fname === "click" || fname === "click_at") {
                    await page.mouse.click(actualX, actualY);
                } else if (fname === "double_click") {
                    await page.mouse.dblclick(actualX, actualY);
                } else if (fname === "right_click") {
                    await page.mouse.click(actualX, actualY, { button: "right" });
                } else if (fname === "middle_click") {
                    await page.mouse.click(actualX, actualY, { button: "middle" });
                } else if (fname === "move") {
                    await page.mouse.move(actualX, actualY);
                }
            } else if (fname === "type" || fname === "type_text_at") {
                const actualX = args.x !== undefined ? denormalizeX(args.x, screenWidth) : null;
                const actualY = args.y !== undefined ? denormalizeY(args.y, screenHeight) : null;
                const text = args.text;
                const pressEnter = args.press_enter || false;

                if (actualX !== null && actualY !== null) {
                    await page.mouse.click(actualX, actualY);
                }
                // Clear field first
                await page.keyboard.press("Meta+A");
                await page.keyboard.press("Backspace");
                await page.keyboard.type(text);
                if (pressEnter) {
                    await page.keyboard.press("Enter");
                }
            } else if (fname === "navigate") {
                await page.goto(args.url);
            } else if (fname === "go_back") {
                await page.goBack();
            } else if (fname === "go_forward") {
                await page.goForward();
            } else if (fname === "wait") {
                await new Promise(resolve => setTimeout(resolve, (args.seconds || 1) * 1000));
            } else {
                console.log(`Warning: Custom or unhandled function ${fname}`);
            }

            await page.waitForLoadState('load', { timeout: 5000 }).catch(() => {});
            await new Promise(resolve => setTimeout(resolve, 1000));
        } catch (e) {
            console.log(`Error executing ${fname}: ${e}`);
            actionResult.error = e.message;
        }

        results.push([fname, functionCall.id, actionResult]);
    }

    return results;
}

4. Kapni gjendjen e re të mjedisit

Pas ekzekutimit të veprimeve, dërgoni rezultatin e ekzekutimit të funksionit përsëri te modeli në mënyrë që të mund ta përdorë këtë informacion për të gjeneruar veprimin tjetër. Nëse janë ekzekutuar veprime të shumta (thirrje paralele), duhet të dërgoni një function_result për secilin prej tyre në kthesën pasuese të përdoruesit.

import json
import base64

def get_function_responses(page, results):
    screenshot_bytes = page.screenshot(type="png")
    current_url = page.url
    function_responses = []
    for name, call_id, result in results:
        function_responses.append({
            "type": "function_result",
            "name": name,
            "call_id": call_id,
            "result": [
                {
                    "type": "text",
                    "text": json.dumps({"url": current_url, **result})
                },
                {
                    "type": "image",
                    "data": base64.b64encode(screenshot_bytes).decode("utf-8"),
                    "mime_type": "image/png"
                }
            ]
        })
    return function_responses

async function getFunctionResponses(page, results) {
    const screenshotBuffer = await page.screenshot({ type: 'png' });
    const screenshotBase64 = screenshotBuffer.toString('base64');
    const currentUrl = page.url();
    const functionResponses = [];

    for (const [name, callId, result] of results) {
        functionResponses.push({
            type: "function_result",
            name: name,
            call_id: callId,
            result: [
                {
                    type: "text",
                    text: JSON.stringify({ url: currentUrl, ...result })
                },
                {
                    type: "image",
                    data: screenshotBase64,
                    mime_type: "image/png"
                }
            ]
        });
    }
    return functionResponses;
}

Pasi të keni përcaktuar se si të kapni dhe formatoni gjendjen e mjedisit, mund t'i kombinoni të gjitha këto hapa në një cikël të vazhdueshëm ekzekutimi.

Ndërtoni një lak agjentësh

Për të aktivizuar ndërveprimet me shumë hapa, kombinoni katër hapat nga seksioni Si të implementohet Përdorimi i Kompjuterit në një cikël të vetëm. Ky cikël vazhdon të kërkojë veprime dhe t'i transmetojë rezultatet modelit derisa detyra të përfundojë.

Mos harroni ta menaxhoni historikun e bisedës në mënyrë korrekte duke i bashkangjitur si përgjigjet e modelit ashtu edhe përgjigjet e funksionit tuaj historikut në çdo hap.

import time
from typing import Any, List, Tuple
from playwright.sync_api import sync_playwright

from google import genai

client = genai.Client()

# Constants for screen dimensions
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# Setup Playwright
print("Initializing browser...")
playwright = sync_playwright().start()
browser = playwright.chromium.launch(headless=False)
context = browser.new_context(viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT})
page = context.new_page()

# Define helper functions. Copy/paste from steps 3 and 4
# def denormalize_x(...)
# def denormalize_y(...)
# def execute_function_calls(...)
# def get_function_responses(...)

try:
    # Go to initial page
    page.goto("https://ai.google.dev/gemini-api/docs")

    # Take initial screenshot
    initial_screenshot = page.screenshot(type="png")
    USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing."
    print(f"Goal: {USER_PROMPT}")

    # First interaction
    interaction = client.interactions.create(
        model='gemini-3.5-flash',
        input=[
            {"type": "text", "text": USER_PROMPT},
            {"type": "image", "data": base64.b64encode(initial_screenshot).decode("utf-8"), "mime_type": "image/png"}
        ],
        tools=[{
            "type": "computer_use",
            "environment": "browser",
            "enable_prompt_injection_detection": True
        }]
    )

    # Agent Loop
    turn_limit = 5
    for i in range(turn_limit):
        print(f"\n--- Turn {i+1} ---")

        has_function_calls = any(
            step.type == "function_call"
            for step in interaction.steps
        )
        if not has_function_calls:
            text_response = " ".join([
                content_block.text for step in interaction.steps if step.type == "model_output"
                for content_block in step.content if content_block.type == "text"
            ])
            print("Agent finished:", text_response)
            break

        print("Executing actions...")
        results = execute_function_calls(interaction, page, SCREEN_WIDTH, SCREEN_HEIGHT)

        print("Capturing state...")
        function_responses = get_function_responses(page, results)

        # Continue conversation with function responses
        interaction = client.interactions.create(
            model='gemini-3.5-flash',
            previous_interaction_id=interaction.id,
            input=function_responses,
            tools=[{
                "type": "computer_use",
                "environment": "browser",
                "enable_prompt_injection_detection": True
            }]
        )

finally:
    # Cleanup
    print("\nClosing browser...")
    browser.close()
    playwright.stop()

import { chromium } from 'playwright';
import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

// Constants for screen dimensions
const SCREEN_WIDTH = 1440;
const SCREEN_HEIGHT = 900;

console.log("Initializing browser...");
const browser = await chromium.launch({ headless: false });
const context = await browser.newContext({
    viewport: { width: SCREEN_WIDTH, height: SCREEN_HEIGHT }
});
const page = await context.newPage();

// Define helper functions. Copy/paste from steps 3 and 4:
// function denormalizeX(...)
// function denormalizeY(...)
// async function executeFunctionCalls(...)
// async function getFunctionResponses(...)

try {
    // Go to initial page
    await page.goto("https://ai.google.dev/gemini-api/docs");

    // Take initial screenshot
    const initialScreenshotBuffer = await page.screenshot({ type: 'png' });
    const initialScreenshotBase64 = initialScreenshotBuffer.toString('base64');
    const USER_PROMPT = "Go to ai.google.dev/gemini-api/docs and search for pricing.";
    console.log(`Goal: ${USER_PROMPT}`);

    // First interaction
    let interaction = await ai.interactions.create({
        model: 'gemini-3.5-flash',
        input: [
            { type: 'text', text: USER_PROMPT },
            { type: 'image', data: initialScreenshotBase64, mime_type: 'image/png' }
        ],
        tools: [{
            type: 'computer_use',
            environment: 'browser',
            enable_prompt_injection_detection: true
        }]
    });

    // Agent Loop
    const turnLimit = 5;
    for (let i = 0; i < turnLimit; i++) {
        console.log(`\n--- Turn ${i + 1} ---`);

        const hasFunctionCalls = interaction.steps.some(step => step.type === "function_call");
        if (!hasFunctionCalls) {
            const textResponses = [];
            for (const step of interaction.steps) {
                if (step.type === "model_output") {
                    for (const contentBlock of step.content || []) {
                        if (contentBlock.type === "text") {
                            textResponses.push(contentBlock.text);
                        }
                    }
                }
            }
            console.log("Agent finished:", textResponses.join(" "));
            break;
        }

        console.log("Executing actions...");
        const results = await executeFunctionCalls(interaction, page, SCREEN_WIDTH, SCREEN_HEIGHT);

        console.log("Capturing state...");
        const functionResponses = await getFunctionResponses(page, results);

        // Continue conversation with function responses
        interaction = await ai.interactions.create({
            model: 'gemini-3.5-flash',
            previous_interaction_id: interaction.id,
            input: functionResponses,
            tools: [{
                type: 'computer_use',
                environment: 'browser',
                enable_prompt_injection_detection: true
            }]
        });
    }
} finally {
    // Cleanup
    console.log("\nClosing browser...");
    await browser.close();
}

Mjedise të mbështetura (Gemini 3.5 Flash)

Gemini 3.5 Flash mbështet tre mjedise të specifikuara në konfigurimet computer_use :

Mjedisi i shfletuesit ( ENVIRONMENT_BROWSER )

Veprimet e disponueshme në mjetin e shfletuesit:

Mjedisi celular ( ENVIRONMENT_MOBILE )

Veprimet e mjedisit të optimizuar për Android:

Mjedisi i desktopit ( ENVIRONMENT_DESKTOP )

Komandat e kursorit në nivel sistemi operativ në mjediset e desktopit:

Veprimet e Ndërfaqes së Përdoruesit të Mbështetura nga Trashëgimia (Gemini 2.5)

Për modelet e trashëguara ( gemini-2.5-computer-use-preview-10-2025 ), mbështeten veprimet e mëposhtme:

Funksione të personalizuara të përcaktuara nga përdoruesi

Mund ta zgjeroni funksionalitetin e modelit duke përfshirë funksione të personalizuara të përcaktuara nga përdoruesi. Për shembull, në skenarët e njeriut në ciklin (HITL) mund të përjashtoni veprimet e paracaktuara parazgjedhur dhe të regjistroni veprime të personalizuara.

Vegla të personalizuara për Gemini 3.5 Flash

from google import genai

client = genai.Client()

yield_to_user_tool = {
    "type": "function",
    "name": "yield_to_user",
    "description": "Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous.",
    "parameters": {
        "type": "object",
        "properties": {
            "reason": {
                "type": "string",
                "description": "The reason why the agent is yielding control to the human."
            }
        },
        "required": ["reason"]
    }
}

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Click the submit button. If you need a second factor authentication code, ask me.",
    tools=[
        {
            "type": "computer_use",
            "environment": "mobile",
            "excluded_predefined_functions": ["click"]
        },
        yield_to_user_tool
    ]
)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const yieldToUserTool = {
    type: "function",
    name: "yield_to_user",
    description: "Yields control back to the user for assistance or verification when an automated action is unsafe or ambiguous.",
    parameters: {
        type: "object",
        properties: {
            reason: {
                type: "string",
                description: "The reason why the agent is yielding control to the human."
            }
        },
        required: ["reason"]
    }
};

const interaction = await ai.interactions.create({
    model: "gemini-3.5-flash",
    input: "Click the submit button. If you need a second factor authentication code, ask me.",
    tools: [
        {
            type: "computer_use",
            environment: "mobile",
            excluded_predefined_functions: ["click"]
        },
        yieldToUserTool
    ]
});

Gemini 2.5 (Legacy) Pajisje të personalizuara

from google import genai

client = genai.Client()

# Define custom tools here
custom_functions = [...]  # Describe parameters as function declarations

excluded_functions = [
    "open_web_browser",
    "wait_5_seconds",
    "go_back",
    "go_forward",
    "search",
    "navigate",
    "hover_at",
    "scroll_document",
    "key_combination",
    "drag_and_drop",
]

interaction = client.interactions.create(
    model='gemini-2.5-computer-use-preview-10-2025',
    input="Open Chrome, then long-press at 200,400.",
    tools=[
        {
            "type": "computer_use",
            "environment": "browser",
            "excluded_predefined_functions": excluded_functions
        },
        *custom_functions
    ]
)

print(interaction)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

// Define custom tools here
const customFunctions = [...]; // Describe parameters as function declarations

const excludedFunctions = [
    "open_web_browser",
    "wait_5_seconds",
    "go_back",
    "go_forward",
    "search",
    "navigate",
    "hover_at",
    "scroll_document",
    "key_combination",
    "drag_and_drop",
];

const interaction = await ai.interactions.create({
    model: 'gemini-2.5-computer-use-preview-10-2025',
    input: "Open Chrome, then long-press at 200,400.",
    tools: [
        {
            type: "computer_use",
            environment: "browser",
            excluded_predefined_functions: excludedFunctions
        },
        ...customFunctions
    ]
});

console.log(interaction);

Menaxhimi i niveleve të të menduarit (Binjakët 3.5 Flash)

Për agjentët e përdorimit të kompjuterit, mund të konfiguroni nivele të ndryshme të të menduarit për të balancuar cilësinë e veprimit dhe shpejtësinë e ekzekutimit. Nivelet më të ulëta të të menduarit në përgjithësi arrijnë një ekuilibër të mirë për detyrat standarde të automatizimit.

Siguria dhe mbrojtja

Konfigurimi i politikave të sigurisë (Gemini 3.5 Flash)

Modeli Gemini 3.5 Flash përfshin kategori të integruara shërbimesh sigurie që përcaktojnë automatikisht nëse kërkohet konfirmimi i përdoruesit.

Mbivendosjet e sigurisë

Mund të anashkaloni politika të caktuara duke kaluar anashkalime:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Clean up the local folder by archiving old logs.",
    tools=[
        {
            "type": "computer_use",
            "environment": "desktop",
            "safety_policy_overrides": [
                {"category": "DATA_MODIFICATION"}
            ]
        }
    ]
)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const interaction = await ai.interactions.create({
    model: "gemini-3.5-flash",
    input: "Clean up the local folder by archiving old logs.",
    tools: [
        {
            type: "computer_use",
            environment: "desktop",
            safety_policy_overrides: [
                { category: "DATA_MODIFICATION" }
            ]
        }
    ]
});

Zbulimi i menjëhershëm i injektimit (Gemini 3.5 Flash)

Mekanizëm sigurie me zgjedhje që skanon pikselët e pamjes së ekranit për udhëzime të fshehura kundërshtare (p.sh. "Injoro komandat e mëparshme") dhe bllokon ekzekutimin kur zbulohet.

Pranoni vendimin e sigurisë (Trashëgimia Binjakët 2.5)

Për modelet e trashëguara, përgjigjja mund të përfshijë një parametër safety_decision :

{
  "steps": [
    {
      "type": "function_call",
      "name": "click_at",
      "arguments": {
        "x": 60,
        "y": 100,
        "safety_decision": {
          "explanation": "Must check check-box",
          "decision": "require_confirmation"
        }
      }
    }
  ]
}

Nëse safety_decision është require_confirmation , pyet përdoruesin përfundimtar. Nëse përdoruesi konfirmon, cakto safety_acknowledgement në function_result .

def get_safety_confirmation(safety_decision):
    # Prompt user
    return "CONTINUE" # Or TERMINATE

# Inside execute_function_calls:
if 'safety_decision' in function_call.arguments:
    decision = get_safety_confirmation(function_call.arguments['safety_decision'])
    if decision == "TERMINATE":
        break
    extra_fr_fields["safety_acknowledgement"] = True

Praktikat më të mira të sigurisë

Përdorimi i kompjuterit paraqet rreziqe unike sigurie dhe operacionale, pasi një model që vepron në emër të një përdoruesi mund të hasë përmbajtje të pabesueshme në ekrane ose të bëjë gabime në ekzekutimin e veprimeve. Zbatoni praktikat më të mira të mëposhtme për të mbrojtur të dhënat dhe sistemet e përdoruesit:

1. Njeriu-në-Lupë (HITL):

   • Zbatimi i konfirmimit të përdoruesit: Kur përgjigja e sigurisë tregon require_confirmation (ose vendimi i trashëguar i sigurisë e kërkon këtë), kërko nga përdoruesi miratim.

   • Jepni udhëzime të personalizuara sigurie: Zbatoni një udhëzim të personalizuar të sistemit për të përcaktuar dhe zbatuar kufijtë tuaj të sigurisë. Për shembull:

     Python

     from google import genai
     
     client = genai.Client()
     
     system_instruction = """
     ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
     
     This is your first and most important check. If the next required action falls
     into any of the following categories, you MUST stop immediately, and seek the
     user's explicit permission.
     
     **Procedure for Seeking Confirmation:**
     * **For Consequential Actions:** Perform all preparatory steps (e.g., navigating,
       filling out forms, typing a message). You will ask for confirmation **AFTER**
       all necessary information is entered on the screen, but **BEFORE** you perform
       the final, irreversible action (e.g., before clicking "Send", "Submit",
       "Confirm Purchase", "Share").
     * **For Prohibited Actions:** If the action is strictly forbidden (e.g., accepting
       legal terms, solving a CAPTCHA), you must first inform the user about the
       required action and ask for their confirmation to proceed.
     
     **USER_CONFIRMATION Categories:**
     
     *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
         agreeing to any of the following on the user's behalf. You must ask the
         user to confirm before performing these actions.
         *   Terms of Service
         *   Privacy Policies
         *   Cookie consent banners
         *   End User License Agreements (EULAs)
         *   Any other legally significant contracts or agreements.
     *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
         following. You must ask the user to confirm before performing these actions.
         *   CAPTCHAs (of any kind)
         *   Any other anti-robot or human-verification mechanisms, even if you are
             capable.
     *   **Financial Transactions:**
         *   Completing any purchase.
         *   Managing or moving money (e.g., transfers, payments).
         *   Purchasing regulated goods or participating in gambling.
     *   **Sending Communications:**
         *   Sending emails.
         *   Sending messages on any platform (e.g., social media, chat apps).
         *   Posting content on social media or forums.
     *   **Accessing or Modifying Sensitive Information:**
         *   Health, financial, or government records (e.g., medical history, tax
             forms, passport status).
         *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
             account number, credit card number).
     *   **User Data Management:**
         *   Accessing, downloading, or saving files from the web.
         *   Sharing or sending files/data to any third party.
         *   Transferring user data between systems.
     *   **Browser Data Usage:**
         *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
             or saved passwords.
     *   **Security and Identity:**
         *   Logging into any user account.
         *   Any action that involves misrepresentation or impersonation (e.g.,
             creating a fan account, posting as someone else).
     *   **Insurmountable Obstacles:** If you are technically unable to interact with
         a user interface element or are stuck in a loop you cannot resolve, ask the
         user to take over.
     ---
     
     ## **RULE 2: Default Behavior (ACTUATE)**
     
     If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`,
     your default behavior is to **Actuate**.
     
     **Actuation Means:**  You MUST proactively perform all necessary steps to move
     the user's request forward. Continue to actuate until you either complete the
     non-consequential task or encounter a condition defined in Rule 1.
     
     *   **Example 1:** If asked to send money, you will navigate to the payment
         portal, enter the recipient's details, and enter the amount. You will then
         **STOP** as per Rule 1 and ask for confirmation before clicking the final
         "Send" button.
     *   **Example 2:** If asked to post a message, you will navigate to the site,
         open the post composition window, and write the full message. You will then
         **STOP** as per Rule 1 and ask for confirmation before clicking the final
         "Post" button.
     
         After the user has confirmed, remember to get the user's latest screen
         before continuing to perform actions.
     
     # Final Response Guidelines:
     Write final response to the user in the following cases:
     - User confirmation
     - When the task is complete or you have enough information to respond to the user
     """
     
     interaction = client.interactions.create(
         model="gemini-3.5-flash",
         system_instruction=system_instruction,
         input="Prepare a draft but do not send.",
         tools=[{
             "type": "computer_use",
             "environment": "browser"
         }]
     )
     

     JavaScript

     import { GoogleGenAI } from '@google/genai';
     
     const ai = new GoogleGenAI();
     
     const systemInstruction = `
     ## **RULE 1: Seek User Confirmation (USER_CONFIRMATION)**
     
     This is your first and most important check. If the next required action falls
     into any of the following categories, you MUST stop immediately, and seek the
     user's explicit permission.
     
     **Procedure for Seeking Confirmation:**
     * **For Consequential Actions:** Perform all preparatory steps (e.g., navigating,
       filling out forms, typing a message). You will ask for confirmation **AFTER**
       all necessary information is entered on the screen, but **BEFORE** you perform
       the final, irreversible action (e.g., before clicking "Send", "Submit",
       "Confirm Purchase", "Share").
     * **For Prohibited Actions:** If the action is strictly forbidden (e.g., accepting
       legal terms, solving a CAPTCHA), you must first inform the user about the
       required action and ask for their confirmation to proceed.
     
     **USER_CONFIRMATION Categories:**
     
     *   **Consent and Agreements:** You are FORBIDDEN from accepting, selecting, or
         agreeing to any of the following on the user's behalf. You must ask the
         user to confirm before performing these actions.
         *   Terms of Service
         *   Privacy Policies
         *   Cookie consent banners
         *   End User License Agreements (EULAs)
         *   Any other legally significant contracts or agreements.
     *   **Robot Detection:** You MUST NEVER attempt to solve or bypass the
         following. You must ask the user to confirm before performing these actions.
         *   CAPTCHAs (of any kind)
         *   Any other anti-robot or human-verification mechanisms, even if you are
             capable.
     *   **Financial Transactions:**
         *   Completing any purchase.
         *   Managing or moving money (e.g., transfers, payments).
         *   Purchasing regulated goods or participating in gambling.
     *   **Sending Communications:**
         *   Sending emails.
         *   Sending messages on any platform (e.g., social media, chat apps).
         *   Posting content on social media or forums.
     *   **Accessing or Modifying Sensitive Information:**
         *   Health, financial, or government records (e.g., medical history, tax
             forms, passport status).
         *   Revealing or modifying sensitive personal identifiers (e.g., SSN, bank
             account number, credit card number).
     *   **User Data Management:**
         *   Accessing, downloading, or saving files from the web.
         *   Sharing or sending files/data to any third party.
         *   Transferring user data between systems.
     *   **Browser Data Usage:**
         *   Accessing or managing Chrome browsing history, bookmarks, autofill data,
             or saved passwords.
     *   **Security and Identity:**
         *   Logging into any user account.
         *   Any action that involves misrepresentation or impersonation (e.g.,
             creating a fan account, posting as someone else).
     *   **Insurmountable Obstacles:** If you are technically unable to interact with
         a user interface element or are stuck in a loop you cannot resolve, ask the
         user to take over.
     ---
     
     ## **RULE 2: Default Behavior (ACTUATE)**
     
     If an action does **NOT** fall under the conditions for `USER_CONFIRMATION`,
     your default behavior is to **Actuate**.
     
     **Actuation Means:**  You MUST proactively perform all necessary steps to move
     the user's request forward. Continue to actuate until you either complete the
     non-consequential task or encounter a condition defined in Rule 1.
     
     *   **Example 1:** If asked to send money, you will navigate to the payment
         portal, enter the recipient's details, and enter the amount. You will then
         **STOP** as per Rule 1 and ask for confirmation before clicking the final
         "Send" button.
     *   **Example 2:** If asked to post a message, you will navigate to the site,
         open the post composition window, and write the full message. You will then
         **STOP** as per Rule 1 and ask for confirmation before clicking the final
         "Post" button.
     
         After the user has confirmed, remember to get the user's latest screen
         before continuing to perform actions.
     
     # Final Response Guidelines:
     Write final response to the user in the following cases:
     - User confirmation
     - When the task is complete or you have enough information to respond to the user
     `;
     
     const interaction = await ai.interactions.create({
         model: "gemini-3.5-flash",
         system_instruction: systemInstruction,
         input: "Prepare a draft but do not send.",
         tools: [{
             type: "computer_use",
             environment: "browser"
         }]
     });
     

2. Mjedis i sigurt ekzekutimi: Ekzekutoni agjentin tuaj në një mjedis të sigurt, të sandboxuar për të kufizuar ndikimin e tij të mundshëm. Ky mund të jetë një makinë virtuale (VM) e sandboxuar, një kontejner (p.sh., Docker) ose një profil i dedikuar shfletuesi me leje të kufizuara. Shihni implementimin referues të GitHub për udhëzime për konfigurimin e sandbox-it duke përdorur Docker.

3. Pastrimi i të dhënave hyrëse: Pastroni të gjithë tekstin e gjeneruar nga përdoruesi në mesazhe për të zbutur rrezikun e udhëzimeve të paqëllimshme ose injektimit të mesazheve të shpejta. Ky është një shtresë e dobishme sigurie, por jo një zëvendësim për një mjedis të sigurt ekzekutimi.

4. Mbrojtëse të përmbajtjes: Përdorni mbrojtëse dhe API-të e sigurisë së përmbajtjes për të vlerësuar të dhënat e përdoruesit, të dhënat e dhëna dhe të dhënat e mjeteve, si dhe përgjigjet e agjentit për përshtatshmëri, injeksion të shpejtë dhe zbulim të jailbreak-ut.

5. Listat e lejimeve dhe listat e bllokimeve: Implementoni mekanizma filtrimi për të kontrolluar se ku mund të lundrojë modeli dhe çfarë mund të bëjë. Një listë bllokimi e faqeve të internetit të ndaluara është një pikënisje e mirë, ndërsa një listë lejimesh më kufizuese është edhe më e sigurt.

6. Vëzhgueshmëria dhe regjistrimi: Mbani regjistrime të detajuara për debugging, auditim dhe reagim ndaj incidenteve. Klienti juaj duhet të regjistrojë kërkesat, pamjet e ekranit, veprimet e sugjeruara nga modeli ( function_call ), përgjigjet e sigurisë dhe të gjitha veprimet që ekzekutohen përfundimisht nga klienti.

7. Menaxhimi i mjedisit: Sigurohuni që mjedisi GUI të jetë konsistent. Dritaret, njoftimet ose ndryshimet e papritura në paraqitje mund ta ngatërrojnë modelin. Filloni nga një gjendje e njohur dhe e pastër për çdo detyrë të re, nëse është e mundur.

Versionet e modelit

Mund të përdorni kompjuterin me modelet e mëposhtme:

• Gemini 3.5 Flash ( gemini-3.5-flash ): Modeli i rekomanduar për përdorim në kompjuter, që paraqet veprime të efektshme me qëllime, mbështetje për mjediset e shfletuesit, celularit dhe desktopit, politika sigurie të konfigurueshme dhe zbulim të shpejtë të injektimit.
• Pamje paraprake e flashit Gemini 3 ( gemini-3-flash-preview ): Modeli paraprak që mbështet përdorimin e kompjuterit.
• Gemini 2.5 (Paraparje e Trashëgimisë) ( gemini-2.5-computer-use-preview-10-2025 ): Modeli i paraparjes së Trashëgimisë i optimizuar për përdorim të kompjuterëve të bazuar në shfletues.

Çfarë vjen më pas

• Eksperimentoni me përdorimin e kompjuterit në mjedisin demo të Browserbase .
• Shikoni implementimin e referencës për kodin shembull.
• Mësoni rreth mjeteve të tjera të Gemini API:
  • Thirrja e funksionit
  • Bazë me Kërkimin në Google