Het hulpprogramma voor computergebruik gebruiken in Microsoft Foundry Agent Service


Het hulpprogramma voor computergebruik is algemeen beschikbaar en stelt agents in staat om te communiceren met browsers en bureaubladtoepassingen via hun gebruikersinterfaces. Het model interpreteert schermopnamen en stelt acties voor zoals klikken, typen en schuiven. Uw toepassing voert deze acties uit in een geïsoleerde omgeving en retourneert een bijgewerkte schermopname.

Het bijgewerkte hulpprogramma maakt gebruik van een eenvoudigere definitie en ondersteunt een geordende batch acties in elke computeraanroep. U kunt de interactielus in uw toepassing beheren of een ondersteunde SDK-toolset gebruiken met een door de toepassing geleverd stuurprogramma. De ontwikkelaar kan de nieuwste OpenAI-modellen in Foundry gebruiken die ondersteuning bieden voor computergebruik, zoals GPT-6.1 series : gpt-6.1-sol, gpt-6.1-terra ; GPT-6 series : gpt-6-astra, NEW gpt-6-luna, gpt-6-sol, het computer-hulpprogramma configureren en dit koppelen aan de doeltoepassing. Bekijk model- en regionale beschikbaarheid.

De hulpprogramma's die worden ondersteund door het computerhulpprogramma van OpenAI, zijn click, double_click, drag, keypress, move, screenshot, scroll, type en wait.

In dit artikel leert u het volgende:

  • Configureer een agent met de tool voor computergebruik.
  • Voer een geordende batch ui-acties uit en retourneer een schermopname.
  • Goedkeuringsvereisten, uitvoeringslimieten en omgevingsbeperkingen toepassen.
  • Kies een integratiebenadering voor uw toepassing.
  • Migreer vanuit het computer-use-preview model en hulpprogramma.

Waarschuwing

(i) Belangrijk Het hulpprogramma voor computergebruik communiceert namens u met computersystemen en toepassingen en kan onbedoelde acties ondernemen. Testen en bewaken wordt aanbevolen. Transparantienotitie voor Azure OpenAI.

Voorwaarden

Zorg ervoor dat u aan de volgende vereisten voldoet voordat u begint:

  • Een Azure-abonnement en een Microsoft Foundry-project.
  • Een geïmplementeerd model dat ondersteuning biedt voor het computer hulpprogramma in uw geselecteerde regio.
  • Machtiging voor het gebruik van het project, de agent en de modelimplementatie.
  • Een SDK-versie die het uitgebrachte hulpprogrammaschema of een geauthenticeerde REST-client ondersteunt.
  • Een geïsoleerde browser of bureaubladomgeving die uw toepassing kan aansturen.
  • Een actie-uitvoerder en schermafbeeldingsopname-implementatie of een ondersteunde SDK-toolset met een compatibel stuurprogramma.
  • Beleidsregels aan de toepassingszijde voor toegestane acties, bestemmingen, goedkeuringen van gebruikers en uitvoeringslimieten.

Gebruik de deploymentnaam, niet een model-id die wordt aangenomen bij het configureren van de agent. Controleer de beschikbaarheid van het model en de ondersteuning voor Agent Service-hulpprogramma's voor uw implementatie.

Hoe computergebruik werkt

Computergebruik scheidt modelredenering van actie-uitvoering:

  1. Uw toepassing verzendt een taak.
  2. Het model retourneert een computer_call met een schermafbeeldingsaanvraag.
  3. Uw toepassing valideert de aanroep, verzendt de schermopname en controleert of goedkeuring van de gebruiker vereist is.
  4. Uw toepassing voert goedgekeurde acties in de volgorde uit.
  5. Uw toepassing legt de resulterende UI-status vast.
  6. Uw toepassing verzendt een computer_call_output met de overeenkomende call_id en bijgewerkte schermopname.
  7. De cyclus wordt voortgezet totdat de taak is voltooid, de gebruiker deze stopt of een uitvoeringslimiet is bereikt.
User task + initial screenshot
              |
              v
        Foundry agent
              |
              v
    computer_call.actions[]
              |
              v
   Validate and obtain approval
              |
              v
 Execute actions in an isolated environment
              |
              v
      Capture a fresh screenshot
              |
              v
      computer_call_output
              |
              +----------> Foundry agent

Het hulpprogramma richt geen computer in of stuurt niet rechtstreeks een apparaat aan. Uw toepassing blijft verantwoordelijk voor de omgeving, het uitvoeringsbeleid en de actieresultaten.

Hoe wordt facturering geconfigureerd?

De tokens voor elke Responses-aanvraag kunnen kosten met zich meebrengen voor invoer- en uitvoertokens. Schermopnamen tellen als afbeeldingsinvoer. Meer informatie over prijzen, modeltokenlimieten en regio's. Als u gehoste agents gebruikt voor de installatie, zijn de prijzen van de Foundry-agentservice van toepassing.

Het hulpprogramma voor computergebruik configureren

Definieer het hulpprogramma met type ingesteld op computer:

{
  "type": "computer"
}

In tegenstelling tot het preview-hulpprogramma vereist de nieuwe definitie geen display_width, display_height of environment.

Uw uitvoerder moet nog steeds de werkelijke viewport- of bureaubladdimensies kennen. Als u deze eigenschappen uit de definitie van het hulpprogramma verwijdert, neemt dat niet de noodzaak weg om schermopnamen en actiecoördinaten consistent te houden.

Een integratiebenadering kiezen

Approach Wanneer gebruiken Toepassingsverantwoordelijkheden
Native computertool met een lus die door de toepassing wordt beheerd U hebt expliciete controle nodig over elk verzoek, actiebatch en schermopname. Voer acties uit, leg schermopnamen vast, onderhoud de geschiedenis, dwing beleid af en stop de lus.
door de SDK beheerde toolset Een uitgebrachte SDK biedt een compatibele hulpprogrammaset en stuurprogrammacontract. Geef het stuurprogramma op, configureer limieten en goedkeuringshooks en controleer de taakresultaten.

Een door SDK beheerde lus gebruiken

De doel-SDK-ervaring omvat ComputerToolset en BrowserToolset integraties in Python en Node.js, met een door de toepassing geleverde driver, uitvoeringslimieten en een voor-actiehook. Controleer de beschikbaarheid en exacte signaturen in de uitgebrachte SDK voordat u deze namen in code gebruikt.

Configureer het equivalent van:

  • Een driver die ondersteunde acties uitvoert en nieuwe schermopnamen retourneert.
  • Een staplimiet die model-/tooliteraties begrenst.
  • Een pre-action-hook die beleid toepast en pauzeert voor goedkeuring.
  • Een time-out en mechanisme voor gebruikersannulering.
  • Limieten op actieniveau, omdat één modelbeurt verschillende acties kan bevatten.

Een toolset kan orchestratiecode verminderen, maar het vervangt het beleid aan de toepassingszijde niet.

Gebruik voor Python, C#/.NET, TypeScript/JavaScript en Java de bijbehorende releaseopmerkingen voor Foundry SDK en bijgehouden voorbeelden:

Codevoorbeelden

Waarschuwing

Gebruik het hulpprogramma voor computergebruik op virtuele machines zonder toegang tot gevoelige gegevens of kritieke resources.

Schermafbeelding van initialisatie voor het uitvoeren van hulpprogramma's voor computergebruik

In de volgende fragmenten ziet u hoe u een agentversie maakt met de algemene ComputerToolbeschikbaarheid, een eerste aanvraag met een schermopname verzendt en meerdere iteraties (inclusief batchgewijs computer_call.actions) uitvoert om een taak te voltooien. Selecteer Prompt-agents om de AZURE AI Projects SDK te gebruiken om een promptagent aan de serverzijde te maken, of Hosted Agents om het Agent Framework FoundryChatClient te gebruiken om een tijdelijke, in-process agent te maken.

Agents aansturen

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition, ComputerTool

# Import shared helper functions
from computer_use_util import (
    SearchState,
    load_screenshot_assets,
    handle_computer_action_and_take_screenshot,
    print_final_output,
)

"""Main function to demonstrate Computer Use Agent functionality (GA)."""
# Initialize state machine
current_state = SearchState.INITIAL

# Load screenshot assets
try:
    screenshots = load_screenshot_assets()
    print("Successfully loaded screenshot assets")
except FileNotFoundError:
    print("Failed to load required screenshot assets. Use the maintained SDK sample on GitHub to get the helper file and images.")
    exit(1)

Een agentversie maken met het hulpprogramma

# Format: "https://resource_name.services.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
MODEL_DEPLOYMENT_NAME = os.environ.get("COMPUTER_USE_MODEL_DEPLOYMENT_NAME", "gpt-5.4")

project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)

# GA ComputerTool: serializes to {"type": "computer"} with no display size or environment needed
computer_use_tool = ComputerTool()

agent = project.agents.create_version(
    agent_name="ComputerUseAgent",
    definition=PromptAgentDefinition(
        model=MODEL_DEPLOYMENT_NAME,
        instructions="""
        You are a computer automation assistant.

        Be direct and efficient. When you reach the search results page, read and describe the actual search result titles and descriptions you can see.
        """,
        tools=[computer_use_tool],
    ),
    description="Computer automation agent with screen interaction capabilities.",
)
print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

Verzend het eerste verzoek met een schermafbeelding

openai = project.get_openai_client()

# Initial request with screenshot - start with Bing search page
print("Starting computer automation session (initial screenshot: cua_browser_search.png)...")
response = openai.responses.create(
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "I need you to help me search for 'OpenAI news'. Please type 'OpenAI news' and submit the search. Once you see search results, the task is complete.",
                },
                {
                    "type": "input_image",
                    "image_url": screenshots["browser_search"]["url"],
                    "detail": "original",
                },  # Start with Bing search page
            ],
        }
    ],
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    truncation="auto",
)

print(f"Initial response received (ID: {response.id})")

Meerdere iteraties uitvoeren met batchacties

In het GA computer_call hulpprogrammaprotocol stelt elk actions item een gebatchte computer_call.actions lijst beschikbaar (computer_call.action), terwijl het compatibel blijft met enkelvoudige computer. Voer alle acties in de batch op volgorde uit, leg een nieuwe schermopname vast en stuur deze terug in computer_call_output.

max_iterations = 10  # Allow enough iterations for completion
iteration = 0

while True:
    if iteration >= max_iterations:
        print(f"\nReached maximum iterations ({max_iterations}). Stopping.")
        break

    iteration += 1
    print(f"\n--- Iteration {iteration} ---")

    # Check for computer calls in the response
    computer_calls = [item for item in response.output if item.type == "computer_call"]

    if not computer_calls:
        print_final_output(response)
        break

    # Process the first computer call
    computer_call = computer_calls[0]
    call_id = computer_call.call_id

    # GA computer_call returns batched `actions` (fallback to singular `action` if needed)
    actions = getattr(computer_call, "actions", None) or (
        [computer_call.action] if getattr(computer_call, "action", None) else []
    )
    if not actions:
        continue

    # Never execute an action with pending safety checks without user approval.
    safety_checks = getattr(computer_call, "pending_safety_checks", None) or []
    if safety_checks:
        for check in safety_checks:
            print(f"Safety check: {check.code}: {check.message}")
        if input("Approve this action? Type yes to continue: ").lower() != "yes":
            print("Action rejected by the user.")
            break

    print(f"Processing computer call (ID: {call_id}) with {len(actions)} action(s)")

    # Execute each action in the batch and update state/screenshot
    screenshot_info = screenshots["browser_search"]
    for action in actions:
        screenshot_info, current_state = handle_computer_action_and_take_screenshot(
            action, current_state, screenshots
        )

    print(f"Sending action result back to agent (using {screenshot_info['filename']})...")

    # Regular response with just the resulting screenshot
    response = openai.responses.create(
        previous_response_id=response.id,
        input=[
            {
                "call_id": call_id,
                "type": "computer_call_output",
                "acknowledged_safety_checks": safety_checks,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": screenshot_info["url"],
                    "detail": "original",
                },
            }
        ],
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
        truncation="auto",
    )

    print(f"Follow-up response received (ID: {response.id})")

Opschonen

project.agents.delete_version(agent_name=agent.name, agent_version=agent.version)
print("Agent deleted")

Verwachte uitvoer

Successfully loaded screenshot assets
Agent created (id: ..., name: ComputerUseAgent, version: 1)
Starting computer automation session (initial screenshot: cua_browser_search.png)...
Initial response received (ID: ...)

--- Iteration 1 ---
Processing computer call (ID: ...) with 1 action(s)
Executing computer action: type
  Typing text "OpenAI news" - Simulating keyboard input
  -> Action processed: type
Sending action result back to agent (using cua_search_typed.png)...
Follow-up response received (ID: ...)

--- Iteration 2 ---
Processing computer call (ID: ...) with 1 action(s)
Executing computer action: click
  Click at (512, 384) - Simulating click on UI element
  -> Detected click after typing
  -> Action processed: click
Sending action result back to agent (using cua_search_results.png)...
Follow-up response received (ID: ...)

--- Iteration 3 ---
No computer calls found. Agent completed the task:
Final status: completed
Final result: Here are the search results for "OpenAI news":
1. OpenAI - Official News & Announcements (https://openai.com/news)
   Latest updates on GPT models, research breakthroughs, and safety initiatives from OpenAI.
2. OpenAI News - Latest Updates | Reuters
   Breaking coverage of OpenAI product launches, enterprise partnerships, and AI regulation.
Agent deleted

Gehoste agents

In dit voorbeeld wordt gebruikgemaakt van FoundryChatClient uit het Microsoft Agent Framework met het GA-hulpprogramma computer ({"type": "computer"}). Installeer het pakket met pip install agent-framework-foundry aiohttp, stel FOUNDRY_PROJECT_ENDPOINT in (wijs FOUNDRY_MODEL een gpt-6.1-sol implementatie aan) en meld u aan met az login.

import asyncio

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

async def main() -> None:
    agent = Agent(
        client=FoundryChatClient(credential=AzureCliCredential()),
        instructions=(
            "You are a computer automation assistant. Be direct and efficient. "
            "When you reach the search results page, describe the actual result titles you can see."
        ),
        tools=[
            {"type": "computer"}
        ],
    )

    # Replace this with your screenshot capture + action handler loop.
    # See the upstream samples folder for a reference implementation.
    result = await agent.run(
        "Help me search for 'OpenAI news'. Type the query and submit the search."
    )
    print(f"Agent: {result.text}")

if __name__ == "__main__":
    asyncio.run(main())

Verwachte uitvoer

Agent: I searched for "OpenAI news" in the address bar. The top results include articles from OpenAI's blog, TechCrunch, and The Verge ...

Zie de voorbeelden van de Foundry-provider voor een volledige implementatie van een screenshotlus.

Voorbeeld van het gebruik van een agent met het hulpprogramma voor computergebruik

In het volgende C#-codevoorbeeld ziet u hoe u een agent maakt met het GA-hulpprogramma computer ({"type": "computer"}), een eerste aanvraag met een schermopname verzendt en meerdere iteraties uitvoert om een taak te voltooien.

Agents aansturen

Als u wilt dat uw agent het GA-hulpprogramma computer gebruikt, geeft u ModelReaderWriter.Read<ResponseTool>(BinaryData.FromObjectAsJson(new { type = "computer" })) door bij het configureren van DeclarativeAgentDefinition.Tools.

using System;
using System.ClientModel.Primitives;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.Json;
using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI.Responses;

class ComputerUseDemo
{
    // Format: "https://resource_name.services.ai.azure.com/api/projects/project_name"
    private static readonly string ProjectEndpoint =
        Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT") ?? "your_project_endpoint";
    private static readonly string ModelDeploymentName =
        Environment.GetEnvironmentVariable("COMPUTER_USE_MODEL_DEPLOYMENT_NAME") ?? "gpt-5.4";

    // Read image files using `ReadImageFile` method.
    private static BinaryData ReadImageFile(string name, [CallerFilePath] string pth = "")
    {
        var dirName = Path.GetDirectoryName(pth) ?? "";
        return new BinaryData(File.ReadAllBytes(Path.Combine(dirName, name)));
    }

    // Helper method to parse ComputerTool outputs (including batched actions) and respond with new screenshots.
    private static string ProcessComputerUseCall(ComputerCallResponseItem item, string oldScreenshot)
    {
        string currentScreenshot = oldScreenshot;
        foreach (ReadOnlyMemory<byte> actionJson in item.Patch.EnumerateArray("$.actions"u8))
        {
            ComputerCallAction action = ModelReaderWriter.Read<ComputerCallAction>(BinaryData.FromBytes(actionJson));
            switch (action.Kind)
            {
                case ComputerCallActionKind.Type:
                    Console.WriteLine($"  Typing text \"{action.TypeText}\" - Simulating keyboard input");
                    currentScreenshot = "search_typed";
                    break;
                case ComputerCallActionKind.KeyPress:
                    if (action.KeyPressKeyCodes.Contains("Return") || action.KeyPressKeyCodes.Contains("ENTER"))
                    {
                        if (string.Equals(currentScreenshot, "search_typed"))
                        {
                            Console.WriteLine("  -> Detected ENTER key press, when search field was populated, displaying results.");
                            currentScreenshot = "search_results";
                        }
                        else
                        {
                            Console.WriteLine("  -> Detected ENTER key press, on results or unpopulated search, do nothing.");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"  Key press: {string.Join("+", action.KeyPressKeyCodes)} - Simulating key combination");
                    }
                    break;
                case ComputerCallActionKind.Click:
                    Console.WriteLine($"  Click at ({action.ClickCoordinates.Value.X}, {action.ClickCoordinates.Value.Y}) - Simulating click on UI element");
                    if (string.Equals(currentScreenshot, "search_typed"))
                    {
                        Console.WriteLine("  -> Assuming click on Search button when search field was populated, displaying results.");
                        currentScreenshot = "search_results";
                    }
                    else
                    {
                        Console.WriteLine("  -> Assuming click on Search on results or when search was not populated, do nothing.");
                    }
                    break;
                case ComputerCallActionKind.Drag:
                    Console.WriteLine($"  Drag path: {string.Join(" -> ", action.DragPath.Select(p => $"{p.X}, {p.Y}"))} - Simulating drag operation");
                    break;
                case ComputerCallActionKind.Scroll:
                    Console.WriteLine($"  Scroll at ({action.ScrollCoordinates.Value.X}, {action.ScrollCoordinates.Value.Y}) - Simulating scroll action");
                    break;
                case ComputerCallActionKind.Screenshot:
                    Console.WriteLine("  Taking screenshot - Capturing current screen state");
                    break;
                default:
                    break;
            }
            Console.WriteLine($"  -> Action processed: {action.Kind}");
        }

        return currentScreenshot;
    }

    public static void Main()
    {
        // Create project client
        AIProjectClient projectClient = new(endpoint: new Uri(ProjectEndpoint), tokenProvider: new DefaultAzureCredential());

        // Read in three example screenshots and place them into a dictionary.
        Dictionary<string, BinaryData> screenshots = new()
        {
            { "browser_search", ReadImageFile("Assets/cua_browser_search.png") },
            { "search_typed", ReadImageFile("Assets/cua_search_typed.png") },
            { "search_results", ReadImageFile("Assets/cua_search_results.png") },
        };

        // Create a DeclarativeAgentDefinition with the GA ComputerTool ({"type": "computer"}).
        DeclarativeAgentDefinition agentDefinition = new(model: ModelDeploymentName)
        {
            Instructions = "You are a computer automation assistant.\n\n" +
                           "Be direct and efficient. When you reach the search results page, read and describe the actual search result titles and descriptions you can see.",
            Tools =
            {
                ModelReaderWriter.Read<ResponseTool>(BinaryData.FromObjectAsJson(new { type = "computer" })),
            }
        };

        ProjectsAgentVersion agentVersion = projectClient.AgentAdministrationClient.CreateAgentVersion(
            agentName: "myAgent",
            options: new(agentDefinition)
        );
        Console.WriteLine($"Agent created (id: {agentVersion.Id}, name: {agentVersion.Name}, version: {agentVersion.Version})");

        ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(agentVersion.Name);
        CreateResponseOptions responseOptions = new()
        {
            TruncationMode = ResponseTruncationMode.Auto,
            InputItems =
            {
                ResponseItem.CreateUserMessageItem(
                [
                    ResponseContentPart.CreateInputTextPart("I need you to help me search for 'OpenAI news'. Please type 'OpenAI news' and submit the search. Once you see search results, the task is complete."),
                    ResponseContentPart.CreateInputImagePart(imageBytes: screenshots["browser_search"], imageBytesMediaType: "image/png", imageDetailLevel: ResponseImageDetailLevel.High)
                ]),
            },
        };

        Console.WriteLine("Starting computer automation session (initial screenshot: cua_browser_search.png)...");
        bool computerUseCalled = false;
        string currentScreenshot = "browser_search";
        int limitIteration = 10;
        int iteration = 0;
        ResponseResult response;
        do
        {
            response = responseClient.CreateResponse(responseOptions);
            if (iteration == 0)
            {
                Console.WriteLine($"Initial response received (ID: {response.Id})");
            }
            else
            {
                Console.WriteLine($"Follow-up response received (ID: {response.Id})");
            }

            iteration++;
            computerUseCalled = false;
            responseOptions.InputItems.Clear();
            responseOptions.PreviousResponseId = response.Id;

            foreach (ResponseItem responseItem in response.OutputItems)
            {
                if (responseItem is ComputerCallResponseItem computerCall)
                {
                    Console.WriteLine($"--- Iteration {iteration} ---");
                    Console.WriteLine($"Processing computer call (ID: {computerCall.CallId})");
                    if (computerCall.PendingSafetyChecks.Count > 0)
                    {
                        throw new InvalidOperationException(
                            "Pause execution and obtain end-user approval before acknowledging safety checks."
                        );
                    }
                    currentScreenshot = ProcessComputerUseCall(computerCall, currentScreenshot);
                    Console.WriteLine($"Sending action result back to agent (using cua_{currentScreenshot}.png)...");
                    responseOptions.InputItems.Add(
                        ResponseItem.CreateComputerCallOutputItem(
                            callId: computerCall.CallId,
                            output: ComputerCallOutput.CreateScreenshotOutput(
                                screenshotImageBytes: screenshots[currentScreenshot],
                                screenshotImageBytesMediaType: "image/png")));
                    computerUseCalled = true;
                }
            }
            limitIteration--;
        } while (computerUseCalled && limitIteration > 0);

        Console.WriteLine(response.GetOutputText());

        // Clean up resources by deleting Agent.
        projectClient.AgentAdministrationClient.DeleteAgentVersion(agentName: agentVersion.Name, agentVersion: agentVersion.Version);
        Console.WriteLine("Agent deleted");
    }
}

Verwachte uitvoer

Agent created (id: ..., name: myAgent, version: 1)
Starting computer automation session (initial screenshot: cua_browser_search.png)...
Initial response received (ID: ...)
--- Iteration 1 ---
Processing computer call (ID: ...)
  Typing text "OpenAI news" - Simulating keyboard input
  -> Action processed: Type
Sending action result back to agent (using cua_search_typed.png)...
Follow-up response received (ID: ...)
--- Iteration 2 ---
Processing computer call (ID: ...)
  Click at (512, 384) - Simulating click on UI element
  -> Assuming click on Search button when search field was populated, displaying results.
  -> Action processed: Click
Sending action result back to agent (using cua_search_results.png)...
Follow-up response received (ID: ...)
OpenAI news - Latest Updates
Agent deleted

Gehoste agents

In dit voorbeeld wordt het Microsoft Agent Framework gebruikt en wordt AsAIAgent(...) aangeroepen op AIProjectClient met de GA-hulpprogrammadefinitie {"type": "computer"} en de implementatie gpt-5.4. Installeer de pakketten Microsoft.Agents.AI.Foundry en Azure.AI.Projects, stel de AZURE_AI_PROJECT_ENDPOINT en AZURE_AI_COMPUTER_USE_DEPLOYMENT_NAME omgevingsvariabelen in en meld u aan met az login.

using System.ClientModel.Primitives;
using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Microsoft.Extensions.AI;
using OpenAI.Responses;

string endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_COMPUTER_USE_DEPLOYMENT_NAME") ?? "gpt-5.4";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
using IHostedFileClient fileClient = projectClient.GetProjectOpenAIClient().AsIHostedFileClient();

ResponseTool gaComputerTool = ModelReaderWriter.Read<ResponseTool>(BinaryData.FromObjectAsJson(new { type = "computer" }));

AIAgent agent = projectClient.AsAIAgent(
    model: deploymentName,
    name: "ComputerAgent",
    instructions: "You are a computer automation assistant.",
    tools: [gaComputerTool.AsAITool()]);

// Upload pre-captured screenshots that simulate browser state transitions.
// (See the full sample for ComputerUseUtil implementation.)
Dictionary<string, string> screenshots = await ComputerUseUtil.UploadScreenshotAssetsAsync(fileClient);

ChatClientAgentRunOptions runOptions = new()
{
    ChatOptions = new ChatOptions
    {
        RawRepresentationFactory = (_) => new CreateResponseOptions { TruncationMode = ResponseTruncationMode.Auto },
    }
};

ChatMessage message = new(ChatRole.User,
[
    new TextContent("Search for 'OpenAI news'. Type it and submit. Once you see results, the task is complete."),
    new AIContent { RawRepresentation = ResponseContentPart.CreateInputImagePart(imageFileId: screenshots["browser_search"], imageDetailLevel: ResponseImageDetailLevel.High) }
]);

AgentSession session = await agent.CreateSessionAsync();
AgentResponse response = await agent.RunAsync(message, session: session, options: runOptions);

// Loop: parse computer call actions from response, simulate them, return new screenshots.
for (int i = 0; i < 10; i++)
{
    ComputerCallResponseItem? computerCall = response.Messages
        .SelectMany(m => m.Contents)
        .Select(c => c.RawRepresentation as ComputerCallResponseItem)
        .FirstOrDefault(item => item is not null);

    if (computerCall is null) break;

    string fileId = screenshots["browser_search"];
    foreach (ReadOnlyMemory<byte> actionJson in computerCall.Patch.EnumerateArray("$.actions"u8))
    {
        ComputerCallAction action = ModelReaderWriter.Read<ComputerCallAction>(BinaryData.FromBytes(actionJson));
        (_, fileId) = await ComputerUseUtil.GetScreenshotAsync(action, default, screenshots);
    }

    AIContent callOutput = new()
    {
        RawRepresentation = new ComputerCallOutputResponseItem(
            computerCall.CallId,
            output: ComputerCallOutput.CreateScreenshotOutput(screenshotImageFileId: fileId))
    };

    response = await agent.RunAsync([new ChatMessage(ChatRole.User, [callOutput])], session: session, options: runOptions);
}

await ComputerUseUtil.EnsureDeleteScreenshotAssetsAsync(fileClient, screenshots);
Console.WriteLine($"Response: {response.Text}");

Verwachte uitvoer

Response: I searched for "OpenAI news" in the address bar. The top results include articles from OpenAI's blog, TechCrunch, and The Verge ...

Zie Agent_Step15_ComputerUse voor de volledige implementatie van de screenshot-helper en de end-to-end-actielus.

Voorbeeld van het gebruik van een agent met het hulpprogramma voor computergebruik

Het volgende TypeScript-voorbeeld laat zien hoe u een agentversie maakt met het GA-hulpprogramma computer (tools: [{ type: "computer" }]), een eerste verzoek met een schermopname verzendt en meerdere iteraties uitvoert (batchverwerking computerCall.actions met terugval naar computerCall.action).

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import { createInterface } from "node:readline/promises";
import { stdin, stdout } from "node:process";
import {
  SearchState,
  loadScreenshotAssets,
  handleComputerActionAndTakeScreenshot,
  printFinalOutput,
  type ComputerAction,
} from "./computerUseUtil.js";

// Format: "https://resource_name.services.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = process.env["AZURE_AI_PROJECT_ENDPOINT"] || "your_project_endpoint";
const MODEL_DEPLOYMENT_NAME = process.env["COMPUTER_USE_MODEL_DEPLOYMENT_NAME"] || "gpt-5.4";

export async function main(): Promise<void> {
  // Initialize state machine
  let currentState = SearchState.INITIAL;

  // Load screenshot assets
  const screenshots = loadScreenshotAssets();
  console.log("Successfully loaded screenshot assets");

  // Create AI Project client
  const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
  const openai = project.getOpenAIClient();

  console.log("Creating Computer Use Agent...");
  const agent = await project.agents.createVersion("ComputerUseAgent", {
    kind: "prompt" as const,
    model: MODEL_DEPLOYMENT_NAME,
    instructions: `
You are a computer automation assistant.

Be direct and efficient. When you reach the search results page, read and describe the actual search result titles and descriptions you can see.
    `.trim(),
    tools: [
      {
        type: "computer" as const,
      },
    ],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  // Initial request with screenshot - start with Bing search page
  console.log(
    "Starting computer automation session (initial screenshot: cua_browser_search.png)...",
  );
  let response = await openai.responses.create(
    {
      input: [
        {
          role: "user" as const,
          content: [
            {
              type: "input_text",
              text: "I need you to help me search for 'OpenAI news'. Please type 'OpenAI news' and submit the search. Once you see search results, the task is complete.",
            },
            {
              type: "input_image",
              image_url: screenshots.browser_search.url,
              detail: "original" as any,
            },
          ],
        },
      ],
      truncation: "auto",
    },
    {
      body: { agent_reference: { name: agent.name, type: "agent_reference" } },
    },
  );

  console.log(`Initial response received (ID: ${response.id})`);

  // Main interaction loop with deterministic completion
  const maxIterations = 10; // Allow enough iterations for completion
  let iteration = 0;

  while (iteration < maxIterations) {
    iteration++;
    console.log(`\n--- Iteration ${iteration} ---`);

    // Check for computer calls in the response
    const computerCalls = response.output.filter((item) => item.type === "computer_call");

    if (computerCalls.length === 0) {
      printFinalOutput({
        output: response.output,
        status: response.status ?? "",
      });
      break;
    }

    // Process the first computer call
    const computerCall = computerCalls[0] as any;
    const actions: ComputerAction[] =
      computerCall.actions ?? (computerCall.action ? [computerCall.action] : []);
    const callId: string = computerCall.call_id;

    // Never execute an action with pending safety checks without user approval.
    const safetyChecks = computerCall.pending_safety_checks ?? [];
    if (safetyChecks.length > 0) {
      for (const check of safetyChecks) {
        console.warn(`Safety check: ${check.code}: ${check.message}`);
      }
      const prompt = createInterface({ input: stdin, output: stdout });
      const answer = await prompt.question("Approve this action? Type yes to continue: ");
      prompt.close();
      if (answer.toLowerCase() !== "yes") {
        throw new Error("Action rejected by the user.");
      }
    }

    console.log(`Processing computer call (ID: ${callId}) with ${actions.length} action(s)`);

    // Handle all batched actions in order and get the resulting screenshot info
    let screenshotInfo = screenshots.browser_search;
    for (const action of actions) {
      const [nextScreenshot, updatedState] = handleComputerActionAndTakeScreenshot(
        action,
        currentState,
        screenshots,
      );
      screenshotInfo = nextScreenshot;
      currentState = updatedState;
    }

    console.log(`Sending action result back to agent (using ${screenshotInfo.filename})...`);
    // Regular response with just the screenshot
    response = await openai.responses.create(
      {
        previous_response_id: response.id,
        input: [
          {
            call_id: callId,
            type: "computer_call_output",
            acknowledged_safety_checks: safetyChecks,
            output: {
              type: "computer_screenshot",
              image_url: screenshotInfo.url,
            },
          },
        ],
        truncation: "auto",
      },
      {
        body: { agent_reference: { name: agent.name, type: "agent_reference" } },
      },
    );

    console.log(`Follow-up response received (ID: ${response.id})`);
  }

  if (iteration >= maxIterations) {
    console.log(`\nReached maximum iterations (${maxIterations}). Stopping.`);
  }

  // Clean up resources
  console.log("\nCleaning up...");
  await project.agents.deleteVersion(agent.name, agent.version);
  console.log("Agent deleted");

  console.log("\nComputer Use Agent sample completed!");
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Verwachte uitvoer

Successfully loaded screenshot assets
Creating Computer Use Agent...
Agent created (id: ..., name: ComputerUseAgent, version: 1)
Starting computer automation session (initial screenshot: cua_browser_search.png)...
Initial response received (ID: ...)

--- Iteration 1 ---
Processing computer call (ID: ...) with 1 action(s)
Executing computer action: type
  Typing text "OpenAI news" - Simulating keyboard input
  -> Action processed: type
Sending action result back to agent (using cua_search_typed.png)...
Follow-up response received (ID: ...)

--- Iteration 2 ---
Processing computer call (ID: ...) with 1 action(s)
Executing computer action: click
  Click at (512, 384) - Simulating click on UI element
  -> Assuming click on Search button when search field was populated, displaying results.
  -> Action processed: click
Sending action result back to agent (using cua_search_results.png)...
Follow-up response received (ID: ...)

--- Iteration 3 ---
No computer calls found. Agent completed the task:
Final status: completed
Final result: OpenAI news - Latest Updates
Cleaning up...
Agent deleted

Computer Use Agent sample completed!

Computergebruik gebruiken in een Java-agent

Voeg de afhankelijkheid toe aan uw pom.xml:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.9.0</version>
</dependency>

Een agent voor computergebruik maken

In de GA SDK (com.azure.ai.agents.models.ComputerTool), serialiseert new ComputerTool() naar {"type": "computer"} en vereist het geen weergavedimensies of omgevingsargumenten.

import com.azure.ai.agents.AgentsClient;
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.ResponsesClient;
import com.azure.ai.agents.models.AgentReference;
import com.azure.ai.agents.models.AgentVersionDetails;
import com.azure.ai.agents.models.AzureCreateResponseOptions;
import com.azure.ai.agents.models.ComputerTool;
import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

import java.util.Collections;

public class ComputerUseExample {
    // Format: "https://resource_name.services.ai.azure.com/api/projects/project_name"
    private static final String PROJECT_ENDPOINT =
        System.getenv().getOrDefault("FOUNDRY_PROJECT_ENDPOINT", "your_project_endpoint");
    private static final String MODEL_DEPLOYMENT_NAME =
        System.getenv().getOrDefault("AZURE_COMPUTER_USE_MODEL_DEPLOYMENT_NAME", "gpt-5.4");

    public static void main(String[] args) {

        AgentsClientBuilder builder = new AgentsClientBuilder()
            .credential(new DefaultAzureCredentialBuilder().build())
            .endpoint(PROJECT_ENDPOINT);

        AgentsClient agentsClient = builder.buildAgentsClient();
        ResponsesClient responsesClient = builder.buildResponsesClient();

        // Create GA computer tool (serializes to {"type": "computer"})
        ComputerTool tool = new ComputerTool();

        // Create agent with GA computer tool
        PromptAgentDefinition agentDefinition = new PromptAgentDefinition(MODEL_DEPLOYMENT_NAME)
            .setInstructions("You are a computer automation assistant.")
            .setTools(Collections.singletonList(tool));

        AgentVersionDetails agent = agentsClient.createAgentVersion("computer-use-agent", agentDefinition);
        System.out.printf("Agent created: %s (version %s)%n", agent.getName(), agent.getVersion());

        // Create a response with initial prompt
        AgentReference agentReference = new AgentReference(agent.getName())
            .setVersion(agent.getVersion());

        Response response = responsesClient.createAzureResponse(
            new AzureCreateResponseOptions().setAgentReference(agentReference),
            ResponseCreateParams.builder()
                .input("Open the browser and navigate to microsoft.com"));

        System.out.println("Response: " + response.output());

        // The response will contain computer_call items with actions
        // to execute. Process each action in the batch, take screenshots, and
        // send results back using responsesClient.createAzureResponse()
        // with the previousResponseId and computer call output.

        // Clean up
        agentsClient.deleteAgentVersion(agent.getName(), agent.getVersion());
    }
}

Gebruik voor de volledige gesimuleerde lus het onderhouden ComputerUseSync.java-voorbeeld met de bijbehorende ComputerUseUtil.java-helper. De helper koppelt aangevraagde acties (inclusief batchgewijs actions) aan vooraf vastgelegde schermopnamen. Vervang deze simulatie door de actie-uitvoerder van uw toepassing, schermopname en goedkeuringsstroom voor veiligheid.

Computergebruik gebruiken met de REST API

Een toegangstoken ophalen:

export AGENT_TOKEN=$(az account get-access-token --scope "https://ai.azure.com/.default" --query accessToken -o tsv)

Een agent maken met computergebruik

Geef met het GA-hulpprogramma computer"tools": [{"type": "computer"}] en een mainline-modelimplementatie voor computergebruik, zoals "gpt-5.4", op:

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/agents?api-version=v1" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "name": "computer-use-agent",
    "definition": {
      "kind": "prompt",
      "model": "gpt-5.4",
      "instructions": "You are a computer automation assistant.",
      "tools": [
        {
          "type": "computer"
        }
      ]
    }
  }'

Een antwoord genereren

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "agent_reference": {"type": "agent_reference", "name": "computer-use-agent"},
    "input": "Open the browser and navigate to microsoft.com"
  }'

Het antwoord bevat computer_call-uitvoeritems met een batchgewijze actions-array voor uitvoering. Voordat u een actie uitvoert, inspecteer pending_safety_checks. Als de array niet leeg is, pauzeer dan en toon de acties en veiligheidscontroles aan de eindgebruiker. Ga pas door nadat de gebruiker de actie expliciet heeft goedgekeurd.

Actieresultaten verzenden met schermopname

Nadat de gebruiker eventuele openstaande veiligheidscontroles goedkeurt en uw toepassing alle acties in computer_call.actions uitvoert, legt u een schermopname vast en stuurt u deze terug. Neem elke goedgekeurde controle op in acknowledged_safety_checks. Als er geen controles zijn geretourneerd, gebruikt u een lege matrix.

curl -X POST "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -d '{
    "agent_reference": {"type": "agent_reference", "name": "computer-use-agent"},
    "previous_response_id": "<RESPONSE_ID>",
    "input": [
      {
        "type": "computer_call_output",
        "call_id": "<CALL_ID>",
        "acknowledged_safety_checks": [],
        "output": {
          "type": "computer_screenshot",
          "image_url": "data:image/png;base64,<BASE64_SCREENSHOT>",
          "detail": "original"
        }
      }
    ]
  }'

Vervang , <RESPONSE_ID>en <CALL_ID> door <BASE64_SCREENSHOT>waarden uit het vorige antwoord. Herhaal deze cyclus totdat het model een tekstantwoord retourneert in plaats van een computer_call.

Opschonen

curl -X DELETE "$FOUNDRY_PROJECT_ENDPOINT/agents/computer-use-agent?api-version=v1" \
  -H "Authorization: Bearer $AGENT_TOKEN"

Veiligheidscontroles toepassen

Behandel alles dat in de gecontroleerde omgeving wordt weergegeven als niet-vertrouwde invoer. Een webpagina, document, dialoogvenster of melding kan instructies bevatten die conflicteren met de taak van de gebruiker.

Pas deze besturingselementen onafhankelijk van alle door het model geleverde veiligheidscontroles toe:

Control Aanbevolen gedrag
Omgevingsisolatie Gebruik een toegewezen sandbox met inloggegevens met minimale bevoegdheden en geen niet-gerelateerde gegevens of accounts.
Doelbeperkingen Alleen vereiste bestemmingen toestaan. Valideer omleidingen en dwing netwerkbeperkingen af buiten het model.
Actiebeleid Beperk bestandstoegang, klembordgebruik, downloads, uploads en andere mogelijkheden naar de behoeften van de taak.
Goedkeuring voor ingrijpende actie Verkrijg expliciete goedkeuring van gebruikers vóór aankopen, indieningen, verzenden van berichten, destructieve bewerkingen of accountwijzigingen.
Afhandeling van veiligheidscontroles Toon teruggegeven waarschuwingen aan de gebruiker en pauzeer. Bevestig alleen controles die de gebruiker heeft goedgekeurd via het vrijgegeven API-contract.
Gevoelige workflows Vereis actief gebruikerstoezicht en automatiseer niet buiten de goedgekeurde reikwijdte.
Uitvoeringslimieten Begrensde beurten, acties per batch, verstreken tijd en nieuwe pogingen. Annulering doorgeven.
Controlebaarheid Noteer actietypen, beslissingen, mislukkingen en goedkeuringen zonder onnodig gevoelige schermopnamen of getypte waarden te behouden.

Goedkeuring moet de specifieke actie en het verwachte gevolg ervan identificeren. Gebruik geen algemene goedkeuring voor een hele sessie als vervanging voor het controleren van ingrijpende acties.

Voor een batch die een ingrijpende actie bevat, pauzeert u vóór die actie en eventuele afhankelijke acties. Als beleid niet veilig binnen een batch kan worden afgedwongen, stopt u de uitvoering en geeft u de controle terug aan de gebruiker.

Migreren van de previewversie van Computer Use

Belangrijke wijzigingen ten opzichte van het vorige preview-hulpprogramma voor computergebruik Om te migreren vanuit de verouderde preview-integratie, werkt u het model, de definitie van het hulpprogramma en de actie-handler bij:

Categorie Preview-integratie GA-integratie
Model computer-use-preview gpt-6.1-sol, gpt-6-astra, gpt-6.1-terra, gpt-6-luna, gpt-6-sol
Naam van hulpprogramma tools: [{ type: "computer_use_preview", display_width: ..., display_height: ..., environment: ... }] tools: [{ type: "computer" }]
Python SDK-hulpprogramma ComputerUsePreviewTool(display_width=1026, display_height=769, environment="windows") ComputerTool() (from azure.ai.projects.models import ComputerTool)
C#/.NET SDK-hulpprogramma ResponseTool.CreateComputerTool(environment, displayWidth, displayHeight) ModelReaderWriter.Read<ResponseTool>(BinaryData.FromObjectAsJson(new { type = "computer" }))
TypeScript/JS SDK-hulpprogramma { type: "computer_use_preview", display_width: 1026, display_height: 769, environment: "windows" } { type: "computer" }
Java SDK-hulpprogramma new ComputerUsePreviewTool(ComputerEnvironment.WINDOWS, 1026, 769) new ComputerTool() (com.azure.ai.agents.models.ComputerTool)
Actions Eén action op elke computer_call Een gebatchte array actions[] op elk computer_call
Truncatie truncation: "auto" vereist truncation niet nodig

Vervang de definitie van het preview-hulpprogramma:

{
  "type": "computer_use_preview",
  "display_width": 1024,
  "display_height": 768,
  "environment": "windows"
}

Met:

{
  "type": "computer"
}

Werk handlers bij die computer_call.action lezen om in volgorde door computer_call.actions te itereren. Verpak de oude handler niet voor gelijktijdige uitvoering.

Valideer de gemigratiede applicatie

Voordat u overschakelt naar productieverkeer:

  1. Controleer of de vervangende deployment de definitie van het hulpprogramma accepteert.
  2. Voer een specifieke taak uit met een live schermafbeelding en controleer de overeenkomende tooluitvoer.
  3. Test een batch met meerdere acties met focuswijzigingen of navigatie.
  4. Test modificatietoetsen en extra muisknoppen als uw toepassing deze gebruikt.
  5. Test het schalen van schermopnamen, viewportwijzigingen en coördinatenmapping.
  6. Controleer goedkeuring, weigering, annulering, bestemmingsbeperkingen en geretourneerde veiligheidscontroles.
  7. Controleer of een gedeeltelijke batchfout afhankelijke acties tegenhoudt en een foutmelding geeft.
  8. Controleer de actielimieten en beurtlimieten.
  9. Meet het succes van taken, verstreken tijd, beurten en kosten voor representatieve werkstromen.
  10. Verwijder de preview-deployment pas nadat de vervanging is geverifieerd en uw terugdraaiplan dit toestaat.

Batchacties kunnen roundtrips naar het model verminderen. Het werkelijke effect op latentie en kosten is afhankelijk van de taak, implementatie, actie-uitvoerder en de vereiste hoeveelheid validatie.

Afhandeling van veiligheidscontroles

"input":[ 
        { 
            "type": "computer_call_output", 
            "call_id": "<call_id>", 

            "acknowledged_safety_checks": [ 
                { 
                    "id": "<safety_check_id>", 
                    "code": "malicious_instructions", 
                    "message": "We've detected instructions that may cause your application to perform malicious or unauthorized actions. Please acknowledge this warning if you'd like to proceed." 
                } 
            ], 
            "output": { 
                "type": "computer_screenshot", 
                "image_url": "<image_url>" 
            } 
        } 
    ]

Probleemoplossing

Probleem Wat u moet controleren
De API weigert type: "computer". Controleer of het hulpprogramma beschikbaar is in uw release, dat de geselecteerde implementatie dit ondersteunt en dat de SDK/API-versie gebruikmaakt van het nieuwe schema.
Het antwoord bevat geen computer call. Controleer de antwoordstatus, agentconfiguratie, implementatiecompatibiliteit en of de taak interactie met de gebruikersinterface vereist.
Uw handler verwacht action, maar ontvangt actions. Werk de handler voor geordende batches bij. Controleer de compatibiliteit voordat u code deelt tussen preview en bijgewerkte integraties.
Acties richten zich op de verkeerde locatie. Controleer de afmetingen van de schermopname, de grootte van de viewport, het schalen van het bureaublad en eventuele coördinaattransformatie.
Latere acties worden uitgevoerd in het verkeerde venster of veld. Behoud batchvolgorde en controleer de focus en navigatie vóór afhankelijke acties.
De agent vraagt herhaaldelijk schermopnamen aan. Retourneer een actuele screenshot van de werkelijke omgeving en controleer of de uitvoerder de aangevraagde acties heeft toegepast.
Een veiligheidscontrole of goedkeuringsvereiste onderbreekt de uitvoering. Pauzeer, geef de actie en waarschuwing aan de gebruiker weer en hervat alleen via de gedocumenteerde goedkeuringsstroom.
De batch wordt gedeeltelijk uitgevoerd. Stop afhankelijke acties, leg de huidige status vast wanneer dit veilig kan en geef de fout weer. Speel de hele batch niet zomaar opnieuw af.
De lus bereikt de limiet. Rapporteer dat de taak onvolledig is. Verouderde schermopnamen, mislukte acties of onvoldoende limieten onderzoeken voordat u de limiet verhoogt.
Er kan geen SDK-toolset of helper worden geïmporteerd. Controleer de pakketversie en de beschikbaarheid van de release. Gebruik een onderhouden voorbeeld met de vereiste assets in plaats van helpernamen voor alleen preview.

Opschonen

Wanneer de test is voltooid:

  • Verwijder testagentversies en modelimplementaties die u niet meer nodig hebt.
  • Sluit de geïsoleerde uitvoeringsomgeving af of stel deze buiten gebruik.
  • Verwijder tijdelijke schermafbeeldingen en downloads volgens uw bewaarbeleid.
  • Tijdelijke inloggegevens intrekken en testsessies sluiten.

Als in een voorbeeld een agentversie wordt gemaakt, moet u die versie opschonen in plaats van een agent te verwijderen die is gedeeld met andere toepassingen. Opschonen bij mislukking, annulering en succesvolle voltooiing afhandelen.