Agente Antigravity

L'agente Antigravity è un agente gestito per uso generico sull'API Gemini. Una singola chiamata API ti fornisce un agente che ragiona, esegue codice, gestisce file e naviga sul web all'interno della tua sandbox Linux sicura, ospitata da Google.

È basato su Gemini 3.5 Flash e utilizza lo stesso harness dell'IDE Antigravity. Disponibile tramite l'API Interactions e Google AI Studio.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    environment="remote",
)

print(interaction.output_text)

JavaScript

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    environment: "remote",
}, { timeout: 300000 });

console.log(interaction.output_text);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-05-2026",
    "input": "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    "environment": "remote"
}'

Funzionalità

Ogni chiamata può eseguire il provisioning di una sandbox Linux e avviare un loop di utilizzo degli strumenti. L'agente pianifica, agisce, osserva i risultati e ripete l'operazione finché l'attività non è completata.

  • Esecuzione del codice: esegui comandi Bash, Python e Node.js. Installa pacchetti, esegui test, crea app.
  • Gestione dei file: leggi, scrivi, modifica, cerca ed elenca i file nella sandbox. I file vengono mantenuti tra le interazioni.
  • Accesso web: Ricerca Google e recupero di URL per i dati.
  • Compattazione del contesto: compattazione automatica del contesto (attivata a circa 135.000 token) per supportare sessioni multi-turno di lunga durata senza perdere il contesto o raggiungere i limiti di token.

Consulta la Guida rapida per l'utilizzo multi-turno e lo streaming.

Strumenti supportati

Per impostazione predefinita, l'agente ha accesso a code_execution, google_search e url_context. Gli strumenti del filesystem vengono attivati automaticamente quando specifichi il parametro environment. Puoi anche definire funzioni personalizzate per connettere l'agente alle tue API e ai tuoi strumenti. Devi specificare il parametro tools solo quando personalizzi o limiti l'insieme predefinito o quando aggiungi funzioni personalizzate.

Strumento Valore del tipo Descrizione
Esecuzione del codice code_execution Esegui comandi della shell (bash, Python, Node) con acquisizione di stdout/stderr.
Ricerca Google google_search Cerca sul web pubblico.
Contesto URL url_context Recupera e leggi le pagine web.
Filesystem (attivato tramite environment) Leggi, scrivi, modifica, cerca ed elenca i file nella sandbox. Nessun tipo di strumento separato; attivato automaticamente quando è impostato environment.
Funzioni personalizzate function Definisci le funzioni personalizzate che l'agente può richiedere di eseguire. Consulta Chiamata di funzione.
Server MCP remoto mcp_server Registra i server Model Context Protocol (MCP) esterni come strumenti. Consulta Server MCP.

Per limitare l'agente a strumenti specifici, trasmetti solo quelli di cui hai bisogno:

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Search for the latest AI research papers on reasoning and summarize them.",
    environment="remote",
    tools=[
        {"type": "google_search"},
        {"type": "url_context"},
    ],
)

print(interaction.output_text)

JavaScript

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "Search for the latest AI research papers on reasoning and summarize them.",
    environment: "remote",
    tools: [
        { type: "google_search" },
        { type: "url_context" },
    ],
}, { timeout: 300000 });

console.log(interaction.output_text);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-05-2026",
    "input": "Search for the latest AI research papers on reasoning and summarize them.",
    "environment": "remote",
    "tools": [
        {"type": "google_search"},
        {"type": "url_context"}
    ]
}'

Input multimodale

L'agente Antigravity supporta gli input multimodali. Al momento sono supportati solo gli input text e image. Le immagini devono essere fornite come stringhe con codifica base64 in linea (data).

Python

import base64
from google import genai

client = genai.Client()

with open("path/to/chart.png", "rb") as f:
    image_bytes = f.read()

interaction_inline = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input=[
        {"type": "text", "text": "Analyze this chart and summarize the trends."},
        {
            "type": "image",
            "data": base64.b64encode(image_bytes).decode("utf-8"),
            "mime_type": "image/png",
        },
    ],
    environment="remote",
)

JavaScript


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

import * as fs from "node:fs";

const client = new GoogleGenAI({});
const base64Image = fs.readFileSync("path/to/chart.png", { encoding: "base64" });

const interactionInline = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: [
        { type: "text", text: "Analyze this chart and summarize the trends." },
        {
            type: "image",
            data: base64Image,
            mime_type: "image/png",
        },
    ],
    environment: "remote",
}, { timeout: 300000 });

REST

BASE64_IMAGE=$(base64 -w0 /path/to/chart.png)

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d "{
    \"agent\": \"antigravity-preview-05-2026\",
    \"input\": [
        {\"type\": \"text\", \"text\": \"Analyze this chart and summarize the trends.\"},
        {
            \"type\": \"image\",
            \"mime_type\": \"image/png\",
            \"data\": \"$BASE64_IMAGE\"
        }
    ],
    \"environment\": \"remote\"
}"

Chiamata di funzione

La chiamata di funzione ti consente di connettere l'agente Antigravity ad API e database esterni definendo strumenti personalizzati che l'agente può richiamare. Per i concetti generali, consulta Chiamata di funzione con l'API Gemini.

L'esempio seguente mostra un'interazione a 2 turni. Nel primo turno, l'agente richiede una chiamata di funzione get_weather personalizzata, che il client esegue e restituisce il risultato nel secondo turno.

Python

from google import genai

client = genai.Client()

# 1. Define the custom function
get_weather_tool = {
    "type": "function",
    "name": "get_weather",
    "description": "Gets the current weather for a given location.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "The city and country, e.g. San Francisco, USA",
            }
        },
        "required": ["location"],
    },
}

# 2. Call the agent with the custom tool (Turn 1)
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="What is the weather in Tokyo?",
    environment="remote",
    tools=[
        {"type": "code_execution"},  # Enable default code execution
        get_weather_tool,            # Add custom function
    ],
)

# Check if the agent requested a function call
if interaction.status == "requires_action":
    # Find function calls that do not have a matching function result.
    # Filesystem tools (like write_file) are also represented as function calls
    # but are executed automatically by the environment.
    executed_calls = {step.call_id for step in interaction.steps if step.type == "function_result"}
    pending_calls = [step for step in interaction.steps if step.type == "function_call" and step.id not in executed_calls]

    if pending_calls:
        fc_step = pending_calls[0]
        print(f"Function to call: {fc_step.name} (ID: {fc_step.id})")
        print(f"Arguments: {fc_step.arguments}")

        # 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
        function_result = {
            "temperature": 23,
            "unit": "celsius"
        }

        final_interaction = client.interactions.create(
            agent="antigravity-preview-05-2026",
            previous_interaction_id=interaction.id,  # Reference the interaction ID
            environment=interaction.environment_id,
            input=[
                {
                    "type": "function_result",
                    "name": fc_step.name,
                    "call_id": fc_step.id,
                    "result": function_result,
                }
            ],
        )

        print(final_interaction.output_text)
        # Output: The current weather in Tokyo, Japan is 23°C (Celsius).
    else:
        print("No pending function calls.")
else:
    print(f"Interaction completed with status: {interaction.status}")

JavaScript

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

const client = new GoogleGenAI({});

// 1. Define the custom function
const get_weather_tool = {
  type: "function",
  name: "get_weather",
  description: "Gets the current weather for a given location.",
  parameters: {
    type: "object",
    properties: {
      location: {
        type: "string",
        description: "The city and country, e.g. San Francisco, USA",
      },
    },
    required: ["location"],
  },
};

// 2. Call the agent with the custom tool (Turn 1)
const interaction = await client.interactions.create({
  agent: "antigravity-preview-05-2026",
  input: "What is the weather in Tokyo?",
  environment: "remote",
  tools: [
    { type: "code_execution" },
    get_weather_tool,
  ],
}, { timeout: 300000 });

if (interaction.status === "requires_action") {
  // Find function calls that do not have a matching function result.
  // Filesystem tools (like write_file) are also represented as function calls
  // but are executed automatically by the environment.
  const executedCalls = new Set(
    interaction.steps
      .filter(s => s.type === "function_result")
      .map(s => s.call_id)
  );
  const pendingCalls = interaction.steps.filter(
    s => s.type === "function_call" && !executedCalls.has(s.id)
  );

  if (pendingCalls.length > 0) {
    const fcStep = pendingCalls[0];
    console.log(`Function to call: ${fcStep.name} (ID: ${fcStep.id})`);

    // 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
    const functionResult = {
      temperature: 23,
      unit: "celsius"
    };

    const finalInteraction = await client.interactions.create({
      agent: "antigravity-preview-05-2026",
      previous_interaction_id: interaction.id, // Reference the interaction ID
      environment: interaction.environment_id,
      input: [
        {
          type: "function_result",
          name: fcStep.name,
          call_id: fcStep.id,
          result: functionResult,
        }
      ],
    }, { timeout: 300000 });

    console.log(finalInteraction.output_text);
  } else {
    console.log("No pending function calls.");
  }
} else {
  console.log(`Interaction completed with status: ${interaction.status}`);
}

REST

# 1. Turn 1: Request function call
RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
      "agent": "antigravity-preview-05-2026",
      "input": "What is the weather in Tokyo?",
      "environment": "remote",
      "tools": [
          {"type": "code_execution"},
          {
              "type": "function",
              "name": "get_weather",
              "description": "Gets the current weather for a given location.",
              "parameters": {
                  "type": "object",
                  "properties": {
                      "location": {"type": "string"}
                  },
                  "required": ["location"]
              }
          }
      ]
  }')

# Extract interaction ID, environment ID, and call ID (requires jq)
INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')
ENVIRONMENT_ID=$(echo $RESPONSE | jq -r '.environment_id')
CALL_ID=$(echo $RESPONSE | jq -r '.steps[] | select(.type=="function_call") | .id')

# 2. Turn 2: Send function result back using variables
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d "{
      \"agent\": \"antigravity-preview-05-2026\",
      \"previous_interaction_id\": \"$INTERACTION_ID\",
      \"environment\": \"$ENVIRONMENT_ID\",
      \"input\": [
          {
              \"type\": \"function_result\",
              \"name\": \"get_weather\",
              \"call_id\": \"$CALL_ID\",
              \"result\": {
                  \"temperature\": 23,
                  \"unit\": \"celsius\"
              }
          }
      ]
  }"

Server MCP

Puoi connettere l'agente Antigravity a strumenti esterni registrando server Model Context Protocol (MCP) remoti. L'agente supporta i server MCP remoti tramite HTTP con streaming.

Quando registri un server MCP, devi specificare i seguenti campi nell'array tools:

Campo Tipo Obbligatorio Descrizione
type stringa Sì Deve essere "mcp_server".
name stringa Sì Un identificatore univoco per il server. Deve essere composto da caratteri alfanumerici e minuscoli (corrispondenti a ^[a-z0-9_-]+$).
url stringa Sì L'URL dell'endpoint del server MCP remoto.
headers oggetto No Intestazioni personalizzate (ad es. autenticazione) inviate con le richieste.
allowed_tools matrice No Elenco dei nomi degli strumenti che possono essere eseguiti. Se omesso, tutti gli strumenti sono consentiti.

Python

from google import genai

client = genai.Client()

# Register a remote HTTP MCP server
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="What is the weather in Tokyo?",
    environment="remote",
    tools=[{
        "type": "mcp_server",
        "name": "weather", # Must be lowercase
        "url": "https://gemini-api-demos.uc.r.appspot.com/mcp"
    }]
)

print(interaction.output_text)

JavaScript

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "What is the weather in Tokyo?",
    environment: "remote",
    tools: [{
        type: "mcp_server",
        name: "weather", // Must be lowercase
        url: "https://gemini-api-demos.uc.r.appspot.com/mcp"
    }]
}, { timeout: 300000 });

console.log(interaction.output_text);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
      "agent": "antigravity-preview-05-2026",
      "input": "What is the weather in Tokyo?",
      "environment": "remote",
      "tools": [{
          "type": "mcp_server",
          "name": "weather",
          "url": "https://gemini-api-demos.uc.r.appspot.com/mcp"
      }]
  }'

Personalizzare l'agente

Puoi estendere l'agente Antigravity personalizzando le istruzioni, gli strumenti e l'ambiente. L'agente supporta un approccio di personalizzazione nativo del filesystem: puoi montare file come AGENTS.md per istruzioni e competenze in .agents/skills/ direttamente nella sandbox o trasmettere la configurazione in linea al momento dell'interazione. Puoi iterare sulla configurazione in linea e poi salvarla come agente gestito quando è tutto pronto.

Per informazioni dettagliate su come creare agenti personalizzati, consulta Creare agenti gestiti.

Esecuzione in background

Le attività dell'agente che comportano ragionamento multi-step, esecuzione di codice o operazioni sui file possono richiedere alcuni minuti. Utilizza background=True per eseguire l'interazione in modo asincrono. L'API restituisce immediatamente un ID interazione che devi eseguire tramite polling finché lo stato non è completed o failed.

Python

import time
from google import genai

client = genai.Client()

# 1. Start the interaction in the background
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Run a complex analysis on the repository.",
    environment="remote",
    background=True,
)

print(f"Interaction started in background: {interaction.id}")

# 2. Poll for completion
while interaction.status == "in_progress":
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

if interaction.status == "completed":
    print(interaction.output_text)
else:
    print(f"Finished with status: {interaction.status}")

JavaScript

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "Run a complex analysis on the repository.",
    environment: "remote",
    background: true,
});

console.log(`Interaction started in background: ${interaction.id}`);

let result = interaction;
while (result.status === "in_progress") {
    await new Promise(resolve => setTimeout(resolve, 5000));
    result = await client.interactions.get(interaction.id);
}

if (result.status === "completed") {
    console.log(result.output_text);
} else {
    console.log(`Finished with status: ${result.status}`);
}

REST

# 1. Start the interaction in the background
RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -d '{
      "agent": "antigravity-preview-05-2026",
      "input": "Run a complex analysis on the repository.",
      "environment": "remote",
      "background": true
  }')

INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')

# 2. Poll for results (repeat until status is "completed")
curl -s -X GET "https://generativelanguage.googleapis.com/v1beta/interactions/$INTERACTION_ID" \
  -H "x-goog-api-key: $GEMINI_API_KEY"

L'esecuzione in background richiede store=True, che è il valore predefinito. Per gli aggiornamenti in tempo reale sullo stato di avanzamento durante l'esecuzione in background, consulta Interazioni in background con streaming.

Puoi annullare un'interazione in background in esecuzione utilizzando il metodo cancel.

Python

client.interactions.cancel(id="INTERACTION_ID")

JavaScript

await client.interactions.cancel({ id: "INTERACTION_ID" });

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions/INTERACTION_ID:cancel" \
  -H "x-goog-api-key: $GEMINI_API_KEY"

Multi-turno con esecuzione in background

Quando un'interazione in background coinvolge strumenti con stato (come l'esecuzione di codice in una sandbox), utilizza environment_id dall'interazione completata per continuare nello stesso ambiente. In questo modo, l'agente riprende da dove aveva interrotto con tutti i file e lo stato intatti.

Python

import time
from google import genai

client = genai.Client()

# First turn: run a task in the background
interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Clone https://github.com/google/generative-ai-python and run its tests.",
    environment="remote",
    background=True,
)

while interaction.status == "in_progress":
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Second turn: continue in the same environment
followup = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Fix any failing tests and re-run them.",
    previous_interaction_id=interaction.id,
    environment=interaction.environment_id,
    background=True,
)

while followup.status == "in_progress":
    time.sleep(5)
    followup = client.interactions.get(id=followup.id)

print(followup.output_text)

JavaScript

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

const client = new GoogleGenAI({});

// First turn: run a task in the background
let interaction = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "Clone https://github.com/google/generative-ai-python and run its tests.",
    environment: "remote",
    background: true,
});

while (interaction.status === "in_progress") {
    await new Promise(resolve => setTimeout(resolve, 5000));
    interaction = await client.interactions.get(interaction.id);
}

// Second turn: continue in the same environment
let followup = await client.interactions.create({
    agent: "antigravity-preview-05-2026",
    input: "Fix any failing tests and re-run them.",
    previous_interaction_id: interaction.id,
    environment: interaction.environment_id,
    background: true,
});

while (followup.status === "in_progress") {
    await new Promise(resolve => setTimeout(resolve, 5000));
    followup = await client.interactions.get(followup.id);
}

console.log(followup.output_text);

REST

# 1. Start first interaction in the background
RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -d '{
      "agent": "antigravity-preview-05-2026",
      "input": "Clone https://github.com/google/generative-ai-python and run its tests.",
      "environment": "remote",
      "background": true
  }')

INTERACTION_ID=$(echo $RESPONSE | jq -r '.id')

# 2. Poll until completed (repeat until status is "completed")
RESULT=$(curl -s -X GET "https://generativelanguage.googleapis.com/v1beta/interactions/$INTERACTION_ID" \
  -H "x-goog-api-key: $GEMINI_API_KEY")

ENVIRONMENT_ID=$(echo $RESULT | jq -r '.environment_id')

# 3. Continue in the same environment
curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -d "{
      \"agent\": \"antigravity-preview-05-2026\",
      \"input\": \"Fix any failing tests and re-run them.\",
      \"previous_interaction_id\": \"$INTERACTION_ID\",
      \"environment\": \"$ENVIRONMENT_ID\",
      \"background\": true
  }"

Ambienti

Ogni chiamata crea o riutilizza una sandbox Linux. Il parametro environment assume tre forme:

Postura Descrizione
"remote" Esegui il provisioning di una nuova sandbox con le impostazioni predefinite.
"env_abc123" Riutilizza un ambiente esistente per ID, conservando tutti i file e lo stato.
{...} EnvironmentConfig completo con origini personalizzate e regole di rete.

Per informazioni dettagliate su origini (Git, GCS, in linea), networking, ciclo di vita e limiti delle risorse, consulta Ambienti.

Disponibilità e prezzi

L'agente Antigravity è disponibile in anteprima tramite l'API Interactions in Google AI Studio e l'API Gemini.

I prezzi seguono un modello con pagamento a consumo basato sui token del modello Gemini sottostante e sugli strumenti utilizzati dall'agente. A differenza di una richiesta di chat standard che produce un singolo output, un'interazione Antigravity è un workflow agentico. Una singola richiesta attiva un loop autonomo di ragionamento, esecuzione di strumenti, esecuzione di codice e gestione dei file.

Costi stimati

I costi variano in base alla complessità dell'attività. L'agente determina autonomamente il numero di chiamate di strumenti, esecuzioni di codice e operazioni sui file necessari. Le seguenti stime si basano sulle esecuzioni.

Categoria di attività Token di input Token di output Costo tipico
Ricerca e sintesi delle informazioni 100.000-500.000 10.000-40.000 0,30-1,00 $
Generazione di documenti e contenuti 100.000-500.000 15.000-50.000 0,30-1,30 $
Progettazione di processi e sistemi 100.000-400.000 10.000-30.000 0,25-0,80 $
Elaborazione e analisi dei dati 300.000-3.000.000 30.000-150.000 0,70-3,25 $

In genere, il 50-70% dei token di input viene memorizzato nella cache. I workflow agentici complessi con molte chiamate di strumenti possono accumulare 3-5 milioni di token in una singola interazione, con costi fino a circa 5 $.

Il calcolo dell'ambiente (CPU, memoria, esecuzione della sandbox) non viene fatturato durante il periodo di anteprima.

Limitazioni

  • Stato di anteprima: l'agente Antigravity e l'API Interactions. Le funzionalità e gli schemi possono cambiare.
  • Configurazione di generazione non supportata: i seguenti parametri non sono supportati e restituiscono un errore 400: temperature, top_p, top_k, stop_sequences, max_output_tokens.
  • Output strutturato: l'agente Antigravity non supporta gli output strutturati.
  • Strumenti non disponibili: file_search, computer_use e google_maps non sono ancora supportati.
  • Limitazioni MCP remote: il trasporto Server-Sent Events (SSE) non è supportato (utilizza HTTP con streaming). Inoltre, il name del server deve essere composto da caratteri alfanumerici e minuscoli (l'utilizzo di lettere maiuscole attiva un errore generico 400 Bad Request).
  • Strumento del filesystem: al momento non è disponibile uno strumento del filesystem. Fa parte di environment.
  • Requisito di archiviazione: l'esecuzione dell'agente utilizzando background=True richiede store=True.
  • Chiamata di funzione solo con stato: la chiamata di funzione è supportata solo in modalità con stato. Devi utilizzare previous_interaction_id per continuare il turno; la ricostruzione manuale della cronologia (modalità senza stato) non è supportata.
  • Tipi multimodali non supportati. Al momento, gli input audio, video e di documenti non sono supportati. Sono consentiti solo testo e immagini.

Passaggi successivi