Antigravity 智能体
Antigravity 智能体是 Gemini API 上的通用托管智能体。一次 API 调用即可为您提供一个智能体,它可以在您自己的安全 Linux 沙箱(由 Google 托管)内推理、执行代码、管理文件并浏览网页。
它由 Gemini 4 Hydrogen 构建,并使用与 Antigravity IDE 相同的线束。您可以使用以下命令配置底层 Gemini 模型 agent_config。可以通过 Interactions API 和 Google AI Studio.
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
interaction = client.interactions.create(
agent="antigravity-preview-09-2026",
input="Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
environment="remote",
)
print(interaction.output_text)
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-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);
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-09-2026",
"input": "Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
"environment": "remote"
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Read Hacker News, summarize the top 10 stories, and save the results as a PDF."))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interaction.outputText().orElse(""));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Read Hacker News, summarize the top 10 stories, and save the results as a PDF."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
功能 #
每个调用都可以配置一个 Linux 沙箱并启动一个工具使用循环。 智能体计划、行动、观察结果并重复直到任务完成。
- 代码执行: 运行 Bash、Python 和 Node.js 命令。安装软件包、运行测试、构建应用程序。
- 文件管理: 读取、写入、编辑、搜索和列出沙箱中的文件。文件在交互过程中持续存在。
- 网络访问: Google 搜索和 URL 获取数据。
- 上下文压缩: 自动上下文压缩(在 ~135k token 时触发)支持长时间运行、多轮会话,而不会丢失上下文或达到 token 限制。
请参阅 快速入门 用于多轮使用和流式传输。
支持的工具 #
默认情况下,智能体可以访问 code_execution, google_search, 和 url_context。当您指定时,文件系统工具会自动启用 environment 参数。您还可以定义 自定义功能 将智能体连接到您自己的 API 和工具。您只需要指定 tools 自定义或限制默认设置或添加自定义功能时的参数。
| 工具 | 类型值 | 说明 |
|---|---|---|
| 代码执行 | code_execution | 使用 stdout/stderr 捕获运行 shell 命令(bash、Python、Node)。 |
| Google 搜索 | google_search | 搜索公共网络。 |
| URL上下文 | url_context | 获取并阅读网页。 |
| 文件系统 | (通过启用 environment) | 读取、写入、编辑、搜索和列出沙箱中的文件。当您设置时,系统会自动启用这些工具 environment. |
| 自定义功能 | function | 定义智能体可以请求执行的自定义函数。参见 函数调用. |
| 远程 MCP 服务器 | mcp_server | 将外部 Model Context Protocol (MCP) 服务器注册为工具。参见 MCP 服务器. |
您可以拦截并验证 code_execution 和 filesystem 使用同步在远程沙箱内直接执行工具 钩子.
要将智能体限制为特定工具,请仅传递您需要的工具:
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
interaction = client.interactions.create(
agent="antigravity-preview-09-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)
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-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);
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-09-2026",
"input": "Search for the latest AI research papers on reasoning and summarize them.",
"environment": "remote",
"tools": [
{"type": "google_search"},
{"type": "url_context"}
]
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.GoogleSearch;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.URLContext;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Search for the latest AI research papers on reasoning and summarize them."))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.tools(List.of(
GoogleSearch.builder().build(),
URLContext.builder().build()
))
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interaction.outputText().orElse(""));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Search for the latest AI research papers on reasoning and summarize them."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
Tools: []interactions.Tool{
interactions.NewTool(interactions.GoogleSearch{}),
interactions.NewTool(interactions.URLContext{}),
},
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
多模态输入 #
Antigravity 智能体支持多模态输入。目前,仅 text 和 image 支持输入。图像必须作为内联 Base64 编码字符串提供(data).
import base64
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
with open("path/to/chart.png", "rb") as f:
image_bytes = f.read()
interaction_inline = client.interactions.create(
agent="antigravity-preview-09-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",
)
import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const base64Image = fs.readFileSync("path/to/chart.png", { encoding: "base64" });
const interactionInline = await client.interactions.create({
agent: "antigravity-preview-09-2026",
input: [
{ type: "text", text: "Analyze this chart and summarize the trends." },
{
type: "image",
data: base64Image,
mime_type: "image/png",
},
],
environment: "remote",
}, { timeout: 300000 });
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-09-2026\",
\"input\": [
{\"type\": \"text\", \"text\": \"Analyze this chart and summarize the trends.\"},
{
\"type\": \"image\",
\"mime_type\": \"image/png\",
\"data\": \"$BASE64_IMAGE\"
}
],
\"environment\": \"remote\"
}"
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.List;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
byte[] imageBytes = Files.readAllBytes(Paths.get("path/to/chart.png"));
String base64Image = Base64.getEncoder().encodeToString(imageBytes);
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.ofContent(List.of(
TextContent.builder().text("Analyze this chart and summarize the trends.").build(),
ImageContent.builder()
.data(base64Image)
.mimeType(ImageContentMimeType.IMAGE_PNG)
.build()
)))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.build();
Interaction interactionInline = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interactionInline.outputText().orElse(""));
package main
import (
"context"
"encoding/base64"
"fmt"
"log"
"os"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
imageBytes, err := os.ReadFile("path/to/chart.png")
if err != nil {
log.Fatal(err)
}
base64Image := base64.StdEncoding.EncodeToString(imageBytes)
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput([]interactions.Content{
interactions.NewContent(interactions.TextContent{
Text: "Analyze this chart and summarize the trends.",
}),
interactions.NewContent(interactions.ImageContent{
Data: genai.Ptr(base64Image),
MimeType: interactions.ImageContentMimeTypeImagePng.ToPointer(),
}),
}),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
函数调用 #
函数调用允许您通过定义智能体可以调用的自定义工具将 Antigravity 智能体连接到外部 API 和数据库。有关一般概念,请参见 Gemini API 函数调用.
以下示例演示了 2 转弯交互。 智能体首先请求自定义 get_weather 函数调用,客户端第二轮执行并返回结果。
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
# 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-09-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_to_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-09-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}")
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
// 1. Call the agent with the custom tool (Turn 1)
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-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",
description: "The city and country, e.g. San Francisco, USA",
},
},
required: ["location"],
},
},
],
}, { timeout: 300000 });
if (interaction.status === "requires_action") {
// Find function calls that do not have a matching function result.
// Filesystem tools (like write_to_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];
if (fcStep.type === "function_call") {
console.log(`Function to call: ${fcStep.name} (ID: ${fcStep.id})`);
// 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-09-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}`);
}
# 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-09-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-09-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\"
}
}
]
}"
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CodeExecution;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Function;
import com.google.genai.gaos.models.interactions.FunctionCallStep;
import com.google.genai.gaos.models.interactions.FunctionResultStep;
import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionStatus;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Step;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
// 1. Define the custom function
Function getWeatherTool = Function.builder()
.name("get_weather")
.description("Gets the current weather for a given location.")
.parameters(Map.of(
"type", "object",
"properties", Map.of(
"location", Map.of(
"type", "string",
"description", "The city and country, e.g. San Francisco, USA"
)
),
"required", List.of("location")
))
.build();
// 2. Call the agent with the custom tool (Turn 1)
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("What is the weather in Tokyo?"))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.tools(List.of(
CodeExecution.builder().build(), // Enable default code execution
getWeatherTool // Add custom function
))
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
// Check if the agent requested a function call
if (interaction.status().orElse(null) == InteractionStatus.REQUIRES_ACTION) {
// Find function calls that do not have a matching function result.
List<Step> steps = interaction.steps().orElse(List.of());
Set<String> executedCalls = steps.stream()
.filter(step -> step instanceof FunctionResultStep)
.map(step -> ((FunctionResultStep) step).callId().orElse(""))
.collect(Collectors.toSet());
List<FunctionCallStep> pendingCalls = steps.stream()
.filter(step -> step instanceof FunctionCallStep)
.map(step -> (FunctionCallStep) step)
.filter(fc -> !executedCalls.contains(fc.id().orElse("")))
.collect(Collectors.toList());
if (!pendingCalls.isEmpty()) {
FunctionCallStep fcStep = pendingCalls.get(0);
System.out.println("Function to call: " + fcStep.name().orElse("") + " (ID: " + fcStep.id().orElse("") + ")");
System.out.println("Arguments: " + fcStep.arguments().orElse(Map.of()));
// 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
FunctionResultStep resultStep = FunctionResultStep.builder()
.name(fcStep.name().orElse(""))
.callId(fcStep.id().orElse(""))
.result(FunctionResultStepResultUnion.of("{\"temperature\": 23, \"unit\": \"celsius\"}"))
.build();
CreateAgentInteraction followupParams = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.previousInteractionId(interaction.id().orElse(""))
.environment(CreateAgentInteractionEnvironment.of(interaction.environmentId().orElse("")))
.input(InteractionsInput.ofStep(List.of(resultStep)))
.build();
Interaction finalInteraction = client.interactions.create(CreateInteractionRequestBody.of(followupParams)).interaction().get();
System.out.println(finalInteraction.outputText().orElse(""));
// Output: The current weather in Tokyo, Japan is 23°C (Celsius).
} else {
System.out.println("No pending function calls.");
}
} else {
System.out.println("Interaction completed with status: " + interaction.status().orElse(null));
}
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
// 1. Define the custom function
getWeatherTool := interactions.NewTool(interactions.Function{
Name: genai.Ptr("get_weather"),
Description: genai.Ptr("Gets the current weather for a given location."),
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"location": map[string]any{
"type": "string",
"description": "The city and country, e.g. San Francisco, USA",
},
},
"required": []string{"location"},
},
})
// 2. Call the agent with the custom tool (Turn 1)
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("What is the weather in Tokyo?"),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
Tools: []interactions.Tool{
interactions.NewTool(interactions.CodeExecution{}), // Enable default code execution
getWeatherTool, // Add custom function
},
}),
})
if err != nil {
log.Fatal(err)
}
interaction := res.Interaction
// Check if the agent requested a function call
if interaction.Status == interactions.InteractionStatusRequiresAction {
executedCalls := make(map[string]bool)
for _, step := range interaction.Steps {
if fr := step.FunctionResultStep; fr != nil {
executedCalls[fr.CallID] = true
}
}
var pendingCalls []*interactions.FunctionCallStep
for _, step := range interaction.Steps {
if fc := step.FunctionCallStep; fc != nil && !executedCalls[fc.ID] {
pendingCalls = append(pendingCalls, fc)
}
}
if len(pendingCalls) > 0 {
fcStep := pendingCalls[0]
fmt.Printf("Function to call: %s (ID: %s)\n", fcStep.Name, fcStep.ID)
fmt.Printf("Arguments: %v\n", fcStep.Arguments)
// 3. Execute the function locally (simulated get_weather()) and send the result back (Turn 2)
resultStep := interactions.FunctionResultStep{
Name: genai.Ptr(fcStep.Name),
CallID: fcStep.ID,
Result: interactions.NewFunctionResultStepResultUnion(`{"temperature": 23, "unit": "celsius"}`),
}
followupRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
PreviousInteractionID: interaction.ID,
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(*interaction.EnvironmentID)),
Input: interactions.NewInteractionsInput([]interactions.Step{
interactions.NewStep(resultStep),
}),
}),
})
if err != nil {
log.Fatal(err)
}
if followupRes.Interaction.OutputText != nil {
fmt.Println(*followupRes.Interaction.OutputText)
}
} else {
fmt.Println("No pending function calls.")
}
} else {
fmt.Printf("Interaction completed with status: %s\n", interaction.Status)
}
}
MCP 服务器 #
您可以通过注册远程Model Context Protocol(MCP)服务器将Antigravity 智能体连接到外部工具。 智能体通过可流式 HTTP 支持远程 MCP 服务器。
注册MCP服务器时,必须在 tools 数组:
| 领域 | 类型 | 必填 | 说明 |
|---|---|---|---|
type | 字符串 | 是的 | 必须是 "mcp_server". |
name | 字符串 | 是的 | 服务器的唯一标识符。必须严格为小写字母和字母数字(匹配 ^[a-z0-9_-]+$). |
url | 字符串 | 是的 | 远程 MCP 服务器的端点 URL。 |
headers | 对象 | 否 | 与请求一起发送的自定义标头(例如身份验证)。 |
allowed_tools | 数组 | 否 | 允许执行的工具名称列表。如果省略,则允许使用所有工具。 |
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
# Register a remote HTTP MCP server
interaction = client.interactions.create(
agent="antigravity-preview-09-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)
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-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);
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-09-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"
}]
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.MCPServer;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
// Register a remote HTTP MCP server
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("What is the weather in Tokyo?"))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.tools(List.of(
MCPServer.builder()
.name("weather") // Must be lowercase
.url("https://gemini-api-demos.uc.r.appspot.com/mcp")
.build()
))
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interaction.outputText().orElse(""));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
// Register a remote HTTP MCP server
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("What is the weather in Tokyo?"),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
Tools: []interactions.Tool{
interactions.NewTool(interactions.MCPServer{
Name: genai.Ptr("weather"), // Must be lowercase
URL: genai.Ptr("https://gemini-api-demos.uc.r.appspot.com/mcp"),
}),
},
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
选型 #
对于 antigravity-preview-09-2026,默认模型是 Gemini 4 Hydrogen (gemini-4-hydrogen)。如果你省略 agent_config,智能体默认为 gemini-4-hydrogen.
您可以使用以下命令配置底层 Gemini 模型 agent_config 优化速度、成本或推理能力。例如,设置 model 到 Gemini 4 Carbon (gemini-4-carbon)对于复杂的软件工程和推理任务:
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
interaction = client.interactions.create(
agent="antigravity-preview-09-2026",
input="Summarize the key differences between functional and object-oriented programming.",
environment="remote",
agent_config={
"type": "antigravity",
"model": "gemini-4-carbon",
},
)
print(interaction.output_text)
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-2026",
input: "Summarize the key differences between functional and object-oriented programming.",
environment: "remote",
agent_config: {
type: "antigravity",
model: "gemini-4-carbon",
},
}, { timeout: 300000 });
console.log(interaction.output_text);
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-09-2026",
"input": "Summarize the key differences between functional and object-oriented programming.",
"environment": "remote",
"agent_config": {
"type": "antigravity",
"model": "gemini-4-carbon"
}
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Summarize the key differences between functional and object-oriented programming."))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.agentConfig(
AntigravityAgentConfig.builder()
.model("gemini-4-carbon")
.build()
)
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println(interaction.outputText().orElse(""));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Summarize the key differences between functional and object-oriented programming."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
Model: genai.Ptr("gemini-4-carbon"),
})),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputText != nil {
fmt.Println(*res.Interaction.OutputText)
}
}
支持的值 agent_config.model 是:
| 模型 | 价值在 agent_config.model | 说明 |
|---|---|---|
| Gemini 4 Hydrogen (默认) | gemini-4-hydrogen | 默认 Gemini 4 模型为日常编码和智能体工作流程带来了尖端智能、速度和效率。 |
| Gemini 4 Carbon | gemini-4-carbon | 适用于复杂软件工程、深度问题解决和长期智能体任务的最强大的前沿推理模型。 |
| Gemini 4 Argon | gemini-4-argon | 我们高效的 Gemini 4 前沿推理模型,与相比,可提供更快的响应和更低的 token 每回合支出 Gemini 4 Carbon 跨越软件工程和智能体任务。 |
| Gemini 3.8 Flash | gemini-3.8-flash | 用于推理、编码和工具使用的平衡 Gemini 3.8 Flash 模型。 |
| Gemini 3.6 Flash | gemini-3.6-flash | 适用于一般智能体工作流程的平衡 Flash 模型。 |
| Gemini 3.5 Flash-Lite | gemini-3.5-flash-lite | 针对低延迟和成本敏感任务进行了优化的轻量级模型。 |
创建托管智能体时 agents.create,您可以通过传递以完全相同的方式配置模型 base_agent 和 agent_config。请注意,对于使用以下命令创建的托管智能体,您无法在交互时覆盖模型 agents.create。该模型被锁定为创建智能体时设置的内容。这确保了可预测的工具调用行为、一致的调试以及遵守安全边界。
定制智能体 #
您可以通过自定义其指令、工具和环境来扩展 Antigravity 智能体。 智能体支持文件系统本机的自定义方法:您可以挂载文件,例如 AGENTS.md 有关说明和技能,请参见 .agents/skills/ 直接进入沙箱,或在交互时内联传递配置。您可以内联迭代您的配置,然后在准备好后将其保存为托管智能体。
有关如何构建自定义智能体的完整详细信息,请参阅 建筑托管智能体.
后台执行 #
涉及多步骤推理、代码执行或文件操作的智能体任务可能需要几分钟才能完成。使用 background=True 异步运行交互。 API 立即返回一个交互 ID,您可以轮询该 ID,直到状态变为 completed 或 failed.
import time
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
# 1. Start the interaction in the background
interaction = client.interactions.create(
agent="antigravity-preview-09-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}")
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-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}`);
}
# 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-09-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"
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionStatus;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
// 1. Start the interaction in the background
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Run a complex analysis on the repository."))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.background(true)
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println("Interaction started in background: " + interaction.id().orElse(""));
// 2. Poll for completion
while (interaction.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
Thread.sleep(5000);
interaction = client.interactions.get(new GetInteractionByIdRequest(interaction.id().orElse(""))).interaction().get();
}
if (interaction.status().orElse(null) == InteractionStatus.COMPLETED) {
System.out.println(interaction.outputText().orElse(""));
} else {
System.out.println("Finished with status: " + interaction.status().orElse(null));
}
package main
import (
"context"
"fmt"
"log"
"time"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
// 1. Start the interaction in the background
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Run a complex analysis on the repository."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
Background: genai.Ptr(true),
}),
})
if err != nil {
log.Fatal(err)
}
interaction := res.Interaction
fmt.Printf("Interaction started in background: %s\n", *interaction.ID)
// 2. Poll for completion
for interaction.Status == interactions.InteractionStatusInProgress {
time.Sleep(5 * time.Second)
getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
ID: *interaction.ID,
})
if err != nil {
log.Fatal(err)
}
interaction = getRes.Interaction
}
if interaction.Status == interactions.InteractionStatusCompleted {
if interaction.OutputText != nil {
fmt.Println(*interaction.OutputText)
}
} else {
fmt.Printf("Finished with status: %s\n", interaction.Status)
}
}
后台执行需要 store=True,这是默认值。有关后台执行期间的实时进度更新,请参阅 流媒体后台交互.
您可以使用以下命令取消正在运行的后台交互 cancel 方法。
client.interactions.cancel(id="INTERACTION_ID")
await client.interactions.cancel("INTERACTION_ID");
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions/INTERACTION_ID:cancel" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
client.interactions.cancel("INTERACTION_ID");
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
_, err = client.Interactions.Cancel(ctx, operations.CancelInteractionByIDRequest{
ID: "INTERACTION_ID",
})
if err != nil {
log.Fatal(err)
}
}
多轮后台执行
当后台交互涉及有状态工具(例如沙箱中的代码执行)时,请使用 environment_id 从已完成的交互到在同一环境中继续。这可确保智能体从中断处继续,所有文件和状态完好无损。
import time
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
# First turn: run a task in the background
interaction = client.interactions.create(
agent="antigravity-preview-09-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-09-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)
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
// First turn: run a task in the background
let interaction = await client.interactions.create({
agent: "antigravity-preview-09-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-09-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);
# 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-09-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-09-2026\",
\"input\": \"Fix any failing tests and re-run them.\",
\"previous_interaction_id\": \"$INTERACTION_ID\",
\"environment\": \"$ENVIRONMENT_ID\",
\"background\": true
}"
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionStatus;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
// First turn: run a task in the background
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Clone https://github.com/google/generative-ai-python and run its tests."))
.environment(CreateAgentInteractionEnvironment.of("remote"))
.background(true)
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
while (interaction.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
Thread.sleep(5000);
interaction = client.interactions.get(new GetInteractionByIdRequest(interaction.id().orElse(""))).interaction().get();
}
// Second turn: continue in the same environment
CreateAgentInteraction followupParams = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Fix any failing tests and re-run them."))
.previousInteractionId(interaction.id().orElse(""))
.environment(CreateAgentInteractionEnvironment.of(interaction.environmentId().orElse("")))
.background(true)
.build();
Interaction followup = client.interactions.create(CreateInteractionRequestBody.of(followupParams)).interaction().get();
while (followup.status().orElse(null) == InteractionStatus.IN_PROGRESS) {
Thread.sleep(5000);
followup = client.interactions.get(new GetInteractionByIdRequest(followup.id().orElse(""))).interaction().get();
}
System.out.println(followup.outputText().orElse(""));
package main
import (
"context"
"fmt"
"log"
"time"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
// First turn: run a task in the background
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Clone https://github.com/google/generative-ai-python and run its tests."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment("remote")),
Background: genai.Ptr(true),
}),
})
if err != nil {
log.Fatal(err)
}
interaction := res.Interaction
for interaction.Status == interactions.InteractionStatusInProgress {
time.Sleep(5 * time.Second)
getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
ID: *interaction.ID,
})
if err != nil {
log.Fatal(err)
}
interaction = getRes.Interaction
}
// Second turn: continue in the same environment
followupRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Fix any failing tests and re-run them."),
PreviousInteractionID: interaction.ID,
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(*interaction.EnvironmentID)),
Background: genai.Ptr(true),
}),
})
if err != nil {
log.Fatal(err)
}
followup := followupRes.Interaction
for followup.Status == interactions.InteractionStatusInProgress {
time.Sleep(5 * time.Second)
getRes, err := client.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
ID: *followup.ID,
})
if err != nil {
log.Fatal(err)
}
followup = getRes.Interaction
}
if followup.OutputText != nil {
fmt.Println(*followup.OutputText)
}
}
环境 #
每个调用都会创建或重用一个 Linux 沙箱。的 environment 参数采用三种形式:
| 形式 | 说明 |
|---|---|
"remote" | 使用默认设置配置新的沙箱。 |
"env_abc123" | 按 ID 重用现有环境,保留所有文件和状态。 |
{...} | 满 EnvironmentConfig 具有自定义源和网络规则。 |
参见 环境 有关源(Git、GCS、内联)、网络、生命周期和资源限制的详细信息。
触发器 #
触发器允许您安排智能体按照 cron 计划自动运行。触发器将智能体、环境、提示和计划绑定到无需手动干预即可触发的持久资源中。每次执行都会重用相同的环境,因此一次运行中创建的文件会保留下来,并且对下一次运行可见。
创建触发器#
通过指定 cron 计划、时区和交互配置来创建触发器。触发器开始于 active 状态并将在下一个匹配的 cron 时间触发。保存返回的 id 管理后续调用中的触发器。
由于触发器按计划无人值守地运行,因此请引用存储的 凭证 而不是内联 token。出口代理会在每次运行时解析它,并且您无需触摸触发器即可轮换机密。内联 transform 规则在这里也起作用,它们只需要您在值发生变化时更新触发器。
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
trigger = client.triggers.create(
schedule="0 9 * * *",
time_zone="America/Argentina/Buenos_Aires",
display_name="issue-solver",
interaction={
"agent": "antigravity-preview-09-2026",
"input": "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/.",
"environment": {
"type": "remote",
"network": {
"allowlist": [
{
"domain": "api.github.com",
"credential": "github-production",
},
{"domain": "github.com"},
]
},
},
},
)
print(f"Trigger created: {trigger.id}")
print(f"Next run: {trigger.next_run_time}")
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const trigger = await client.triggers.create({
schedule: "0 9 * * *",
time_zone: "America/Argentina/Buenos_Aires",
display_name: "issue-solver",
interaction: {
agent: "antigravity-preview-09-2026",
input: [{
type: "text",
text: "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/.",
}],
environment: {
type: "remote",
network: {
allowlist: [
{
domain: "api.github.com",
credential: "github-production",
},
{ domain: "github.com" },
],
},
},
},
});
console.log(`Trigger created: ${trigger.id}`);
console.log(`Next run: ${trigger.next_run_time}`);
curl -X POST "https://generativelanguage.googleapis.com/v1beta/triggers" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
"schedule": "0 9 * * *",
"time_zone": "America/Argentina/Buenos_Aires",
"display_name": "issue-solver",
"interaction": {
"agent": "antigravity-preview-09-2026",
"input": [{"type": "text", "text": "Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled accepted, skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."}],
"environment": {
"type": "remote",
"network": {
"allowlist": [
{
"domain": "api.github.com",
"credential": "github-production"
},
{"domain": "github.com"}
]
}
}
}
}'
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.Allowlist;
import com.google.genai.gaos.models.interactions.AllowlistEntry;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Environment;
import com.google.genai.gaos.models.interactions.EnvironmentNetworkEgressAllowlist;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Network;
import com.google.genai.gaos.models.interactions.Transform;
import com.google.genai.gaos.models.shared.Security;
import com.google.genai.gaos.models.triggers.Trigger;
import com.google.genai.gaos.models.triggers.TriggerCreateParams;
import java.util.List;
import java.util.Map;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
Environment env = Environment.builder()
.network(Network.of(
EnvironmentNetworkEgressAllowlist.builder()
.allowlist(Allowlist.of(List.of(
AllowlistEntry.builder()
.domain("api.github.com")
.transform(Transform.of(Map.of(
"Authorization", "Bearer ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)))
.build(),
AllowlistEntry.builder()
.domain("github.com")
.build()
)))
.build()
))
.build();
CreateAgentInteraction interactionTemplate = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."))
.environment(CreateAgentInteractionEnvironment.of(env))
.build();
TriggerCreateParams params = TriggerCreateParams.builder()
.schedule("0 9 * * *")
.timeZone("America/Argentina/Buenos_Aires")
.displayName("issue-solver")
.interaction(interactionTemplate)
.build();
Trigger trigger = client.triggers().create(params).trigger().get();
System.out.println("Trigger created: " + trigger.id().orElse(""));
System.out.println("Next run: " + trigger.nextRunTime().orElse(null));
package main
import (
"context"
"fmt"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
"google.golang.org/genai/interactions/models/triggers"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
env := interactions.Environment{
Network: genai.Ptr(interactions.NewNetwork(interactions.EnvironmentNetworkEgressAllowlist{
Allowlist: genai.Ptr(interactions.NewAllowlist([]interactions.AllowlistEntry{
{
Domain: "api.github.com",
Transform: genai.Ptr(interactions.NewTransform(map[string]string{
"Authorization": "Bearer ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
})),
},
{
Domain: "github.com",
},
})),
})),
}
interactionTemplate := interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Review open PRs in my-org/my-app for new comments and address feedback. Close issues whose PRs were merged. Then check for new issues labeled 'accepted', skip any already tracked in /workspace/solved-issues/, fix the rest, and open a PR for each. Save reports to /workspace/solved-issues/."),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(env)),
}
res, err := sdk.Triggers.Create(ctx, operations.CreateTriggerRequest{
Body: triggers.TriggerCreateParams{
Schedule: "0 9 * * *",
TimeZone: "America/Argentina/Buenos_Aires",
DisplayName: genai.Ptr("issue-solver"),
Interaction: interactionTemplate,
},
})
if err != nil {
log.Fatal(err)
}
trigger := res.Trigger
fmt.Printf("Trigger created: %s\n", trigger.ID)
fmt.Printf("Next run: %v\n", trigger.NextRunTime)
}
该 CreateTrigger 请求接受以下字段:
| 领域 | 类型 | 必填 | 说明 |
|---|---|---|---|
schedule | 字符串 | 是的 | Cron 表达式(例如, 0 * * * * 每小时, 0 9 * * 1-5 工作日早上)。 |
time_zone | 字符串 | 是的 | IANA 时区(例如, UTC, America/Argentina/Buenos_Aires). |
display_name | 字符串 | 否 | 触发器的人类可读名称。 |
max_consecutive_failures | 整数 | 否 | 触发器自动暂停之前的最大失败次数。默认值:5. |
execution_timeout_seconds | 整数 | 否 | 每次执行的超时时间(以秒为单位)。默认值:600. |
interaction | 对象 | 是的 | A CreateInteractionRequest 定义智能体、输入、工具和环境。 |
响应包括以下关键字段:
| 领域 | 类型 | 说明 |
|---|---|---|
id | 字符串 | 触发器的唯一标识符。在所有后续操作中都使用它。 |
status | 字符串 | 当前状态: active, paused, 或 disabled. |
next_run_time | 字符串 | 下一个计划执行的 ISO 8601 时间戳。 |
consecutive_failure_count | 整数 | 自上次成功执行以来连续执行失败的次数。 |
列出触发器#
检索与您的项目关联的所有触发器。
triggers = client.triggers.list()
for trigger in triggers.triggers:
print(f"{trigger.id}: {trigger.display_name} ({trigger.status})")
const triggers = await client.triggers.list();
for (const trigger of triggers.triggers) {
console.log(`${trigger.id}: ${trigger.display_name} (${trigger.status})`);
}
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.shared.Security;
import com.google.genai.gaos.models.triggers.Trigger;
import java.util.List;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
List<Trigger> triggers = client.triggers().listDirect().listTriggersResponse().get().triggers().orElse(List.of());
for (Trigger trigger : triggers) {
System.out.println(trigger.id().orElse("") + ": " + trigger.displayName().orElse("") + " (" + trigger.status().orElse(null) + ")");
}
package main
import (
"context"
"fmt"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
res, err := sdk.Triggers.List(ctx, operations.ListTriggersRequest{})
if err != nil {
log.Fatal(err)
}
if res.ListTriggersResponse != nil {
for _, trigger := range res.ListTriggersResponse.Triggers {
fmt.Printf("%s: %s (%v)\n", trigger.ID, *trigger.GetDisplayName(), trigger.Status)
}
}
}
获取触发器#
获取单个触发器的完整配置和当前状态。
trigger = client.triggers.get(id="TRIGGER_ID")
print(f"Schedule: {trigger.schedule}")
print(f"Next run: {trigger.next_run_time}")
const trigger = await client.triggers.get("TRIGGER_ID");
console.log(`Schedule: ${trigger.schedule}`);
console.log(`Next run: ${trigger.next_run_time}`);
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.shared.Security;
import com.google.genai.gaos.models.triggers.Trigger;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
Trigger trigger = client.triggers().get("TRIGGER_ID").trigger().get();
System.out.println("Schedule: " + trigger.schedule().orElse(""));
System.out.println("Next run: " + trigger.nextRunTime().orElse(null));
package main
import (
"context"
"fmt"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
res, err := sdk.Triggers.Get(ctx, operations.GetTriggerRequest{
ID: "TRIGGER_ID",
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Schedule: %s\n", res.Trigger.Schedule)
fmt.Printf("Next run: %v\n", res.Trigger.NextRunTime)
}
暂停和恢复#
您可以暂停触发器以停止计划的执行,然后恢复触发器以重新激活计划。暂停不影响手动执行。
# Pause
client.triggers.update(id="TRIGGER_ID", status="paused")
# Resume
client.triggers.update(id="TRIGGER_ID", status="active")
// Pause
await client.triggers.update("TRIGGER_ID", { status: "paused" });
// Resume
await client.triggers.update("TRIGGER_ID", { status: "active" });
# Pause
curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{"status": "paused"}'
# Resume
curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{"status": "active"}'
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.shared.Security;
import com.google.genai.gaos.models.triggers.TriggerUpdate;
import com.google.genai.gaos.models.triggers.TriggerUpdateStatus;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
// Pause
client.triggers().update("TRIGGER_ID", TriggerUpdate.builder().status(TriggerUpdateStatus.PAUSED).build());
// Resume
client.triggers().update("TRIGGER_ID", TriggerUpdate.builder().status(TriggerUpdateStatus.ACTIVE).build());
package main
import (
"context"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
"google.golang.org/genai/interactions/models/triggers"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
// Pause
_, err := sdk.Triggers.Update(ctx, operations.UpdateTriggerRequest{
ID: "TRIGGER_ID",
Body: triggers.TriggerUpdate{
Status: triggers.TriggerUpdateStatusPaused.ToPointer(),
},
})
if err != nil {
log.Fatal(err)
}
// Resume
_, err = sdk.Triggers.Update(ctx, operations.UpdateTriggerRequest{
ID: "TRIGGER_ID",
Body: triggers.TriggerUpdate{
Status: triggers.TriggerUpdateStatusActive.ToPointer(),
},
})
if err != nil {
log.Fatal(err)
}
}
删除触发器#
永久移除触发器。过去的执行历史不会被删除。
client.triggers.delete(id="TRIGGER_ID")
await client.triggers.delete("TRIGGER_ID");
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.shared.Security;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
client.triggers().delete("TRIGGER_ID");
package main
import (
"context"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
_, err := sdk.Triggers.Delete(ctx, operations.DeleteTriggerRequest{
ID: "TRIGGER_ID",
})
if err != nil {
log.Fatal(err)
}
}
立即运行触发器#
按需触发触发器,无需等待下一个计划时间。即使触发器暂停,此操作也有效。
client.triggers.run(trigger_id="TRIGGER_ID")
await client.triggers.run("TRIGGER_ID");
curl -X POST "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.shared.Security;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
client.triggers().run("TRIGGER_ID");
package main
import (
"context"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
_, err := sdk.Triggers.Run(ctx, operations.RunTriggerRequest{
TriggerID: "TRIGGER_ID",
})
if err != nil {
log.Fatal(err)
}
}
列出执行次数#
查看触发器的执行历史记录。每个执行包括一个 status、时间戳、 interaction_id 您可以用来获取完整的交互输出,以及 environment_id 确认所有运行共享同一个沙箱。
executions = client.triggers.list_executions(trigger_id="TRIGGER_ID")
for ex in executions.trigger_executions:
print(f"{ex.id}: {ex.status} ({ex.start_time} - {ex.end_time})")
# Fetch the full interaction for an execution
interaction = client.interactions.get(id=ex.interaction_id)
print(interaction.output_text)
const executions = await client.triggers.listExecutions("TRIGGER_ID");
for (const ex of executions.trigger_executions) {
console.log(`${ex.id}: ${ex.status} (${ex.start_time} - ${ex.end_time})`);
}
// Fetch the full interaction for an execution
const interaction = await client.interactions.get(ex.interaction_id);
console.log(interaction.output_text);
curl -X GET "https://generativelanguage.googleapis.com/v1beta/triggers/TRIGGER_ID/executions" \
-H "x-goog-api-key: $GEMINI_API_KEY"
import com.google.genai.gaos.GenAI;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.operations.GetInteractionByIdRequest;
import com.google.genai.gaos.models.shared.Security;
import com.google.genai.gaos.models.triggers.TriggerExecution;
import java.util.List;
GenAI client = GenAI.builder()
.security(Security.builder().apiKey(System.getenv("GEMINI_API_KEY")).build())
.build();
List<TriggerExecution> executions = client.triggers().listExecutions("TRIGGER_ID")
.listTriggerExecutionsResponse().get()
.triggerExecutions().orElse(List.of());
for (TriggerExecution ex : executions) {
System.out.println(ex.id().orElse("") + ": " + ex.status().orElse(null)
+ " (" + ex.startTime().orElse(null) + " - " + ex.endTime().orElse(null) + ")");
// Fetch the full interaction for an execution
if (ex.interactionId().isPresent()) {
Interaction interaction = client.interactions().get(new GetInteractionByIdRequest(ex.interactionId().get())).interaction().get();
System.out.println(interaction.outputText().orElse(""));
}
}
package main
import (
"context"
"fmt"
"log"
"os"
"google.golang.org/genai"
interactionssdk "google.golang.org/genai/interactions"
"google.golang.org/genai/interactions/models/components"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
sdk := interactionssdk.New(interactionssdk.WithSecurity(components.Security{
APIKey: genai.Ptr(os.Getenv("GEMINI_API_KEY")),
}))
res, err := sdk.Triggers.ListExecutions(ctx, operations.ListTriggerExecutionsRequest{
TriggerID: "TRIGGER_ID",
})
if err != nil {
log.Fatal(err)
}
if res.ListTriggerExecutionsResponse != nil {
for _, ex := range res.ListTriggerExecutionsResponse.TriggerExecutions {
fmt.Printf("%s: %v (%v - %v)\n", ex.ID, ex.Status, ex.StartTime, ex.EndTime)
// Fetch the full interaction for an execution
if ex.InteractionID != nil {
intRes, err := sdk.Interactions.Get(ctx, operations.GetInteractionByIDRequest{
ID: *ex.InteractionID,
})
if err != nil {
log.Fatal(err)
}
if intRes.Interaction.OutputText != nil {
fmt.Println(*intRes.Interaction.OutputText)
}
}
}
}
}
供货情况和定价 #
Antigravity 智能体可通过以下方式预览 Interactions API 在 Google AI Studio 和 Gemini API 中,适用于免费层和付费层项目。
定价遵循 现收现付模式 基于底层 Gemini 模型 token 和智能体使用的工具。与产生单个输出的标准聊天请求不同,Antigravity 交互是一个智能体工作流程。单个请求会触发推理、工具执行、代码运行和文件管理的自主循环。免费套餐项目包括免费速率限制和使用配额。
Antigravity 交互运行多轮自主循环,并且可能消耗大量 token。套装 预算控制 根据您的要求限制 token 使用。您还可以通过以下方式实时监控进度 上交所流媒体,或取消正在运行的请求。
预算控制 #
除了 选型, 设置 max_total_tokens 里面 agent_config (与 "type": "antigravity")来限制一次交互可以消耗的token(输入+输出+思考)的总数。缓存的 token 不计入此限制。当智能体达到限制时,交互停止并返回 status: "incomplete"。该限制是尽力而为:实际使用量可能会稍微超出该限制,具体取决于智能体在步骤之间检查预算的时间。
设置交互请求的预算 agent_config 旁边 agent 和 input.
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
interaction = client.interactions.create(
agent="antigravity-preview-09-2026",
input="Analyze the dataset in /workspace/data.csv and generate a summary report.",
agent_config={
"type": "antigravity",
"max_total_tokens": 50000
},
environment={
"type": "remote",
"sources": [
{
"type": "inline",
"target": "/workspace/data.csv",
"content": "id,name,value\n1,alpha,100\n2,beta,200\n",
}
],
}
)
print(f"Status: {interaction.status}") # "incomplete" if budget was hit
print(f"Tokens used: {interaction.usage.total_tokens}")
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ httpOptions: { apiVersion: "v1beta" } });
const interaction = await client.interactions.create({
agent: "antigravity-preview-09-2026",
input: "Analyze the dataset in /workspace/data.csv and generate a summary report.",
agent_config: {
type: "antigravity",
max_total_tokens: "50000"
},
environment: {
type: "remote",
sources: [
{
type: "inline",
target: "/workspace/data.csv",
content: "id,name,value\n1,alpha,100\n2,beta,200\n",
},
],
},
});
console.log(`Status: ${interaction.status}`);
console.log(`Tokens used: ${interaction.usage?.total_tokens}`);
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-09-2026",
"input": "Analyze the dataset in /workspace/data.csv and generate a summary report.",
"agent_config": {
"type": "antigravity",
"max_total_tokens": 50000
},
"environment": {
"type": "remote",
"sources": [
{
"type": "inline",
"target": "/workspace/data.csv",
"content": "id,name,value\n1,alpha,100\n2,beta,200\n"
}
]
}
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Environment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Source;
import com.google.genai.gaos.models.interactions.SourceType;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
Environment env = Environment.builder()
.sources(List.of(
Source.builder()
.type(SourceType.INLINE)
.target("/workspace/data.csv")
.content("id,name,value\n1,alpha,100\n2,beta,200\n")
.build()
))
.build();
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("Analyze the dataset in /workspace/data.csv and generate a summary report."))
.agentConfig(
AntigravityAgentConfig.builder()
.maxTotalTokens("50000")
.build()
)
.environment(CreateAgentInteractionEnvironment.of(env))
.build();
Interaction interaction = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println("Status: " + interaction.status().orElse(null)); // "incomplete" if budget was hit
interaction.usage().ifPresent(usage -> System.out.println("Tokens used: " + usage.totalTokens().orElse(0)));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
env := interactions.Environment{
Sources: []interactions.Source{
{
Type: interactions.SourceTypeInline.ToPointer(),
Target: genai.Ptr("/workspace/data.csv"),
Content: genai.Ptr("id,name,value\n1,alpha,100\n2,beta,200\n"),
},
},
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("Analyze the dataset in /workspace/data.csv and generate a summary report."),
AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
MaxTotalTokens: genai.Ptr(int64(50000)),
})),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(env)),
}),
})
if err != nil {
log.Fatal(err)
}
interaction := res.Interaction
fmt.Printf("Status: %s\n", interaction.Status) // "incomplete" if budget was hit
if interaction.Usage != nil && interaction.Usage.TotalTokens != nil {
fmt.Printf("Tokens used: %d\n", *interaction.Usage.TotalTokens)
}
}
继续不完整的交互 #
当交互返回时 status: "incomplete",智能体的工作和上下文被保留。发送引用原始交互的新交互 id 和 environment_id 从中断的地方继续。新的互动有自己的特色 max_total_tokens 预算。
# Continue from where the agent stopped
continuation = client.interactions.create(
agent="antigravity-preview-09-2026",
input="continue",
previous_interaction_id=interaction.id,
environment=interaction.environment_id,
agent_config={
"type": "antigravity",
"max_total_tokens": 50000
}
)
print(f"Status: {continuation.status}")
const continuation = await client.interactions.create({
agent: "antigravity-preview-09-2026",
input: "continue",
previous_interaction_id: interaction.id,
environment: interaction.environment_id,
agent_config: {
type: "antigravity",
max_total_tokens: "50000"
}
});
console.log(`Status: ${continuation.status}`);
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-09-2026",
"input": "continue",
"previous_interaction_id": "INTERACTION_ID",
"environment": "ENVIRONMENT_ID",
"agent_config": {
"type": "antigravity",
"max_total_tokens": 50000
}
}'
import com.google.genai.Client;
import com.google.genai.types.HttpOptions;
import com.google.genai.gaos.models.interactions.AgentOption;
import com.google.genai.gaos.models.interactions.AntigravityAgentConfig;
import com.google.genai.gaos.models.interactions.CreateAgentInteraction;
import com.google.genai.gaos.models.interactions.CreateAgentInteractionEnvironment;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = Client.builder().httpOptions(HttpOptions.builder().apiVersion("v1beta").build()).build();
String interactionId = "INTERACTION_ID";
String environmentId = "ENVIRONMENT_ID";
// Continue from where the agent stopped
CreateAgentInteraction params = CreateAgentInteraction.builder()
.agent(AgentOption.of("antigravity-preview-09-2026"))
.input(InteractionsInput.of("continue"))
.previousInteractionId(interactionId)
.environment(CreateAgentInteractionEnvironment.of(environmentId))
.agentConfig(
AntigravityAgentConfig.builder()
.maxTotalTokens("50000")
.build()
)
.build();
Interaction continuation = client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
System.out.println("Status: " + continuation.status().orElse(null));
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"}})
if err != nil {
log.Fatal(err)
}
interactionID := "INTERACTION_ID"
environmentID := "ENVIRONMENT_ID"
// Continue from where the agent stopped
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
Agent: interactions.AgentOption("antigravity-preview-09-2026"),
Input: interactions.NewInteractionsInput("continue"),
PreviousInteractionID: genai.Ptr(interactionID),
Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(environmentID)),
AgentConfig: genai.Ptr(interactions.NewCreateAgentInteractionAgentConfig(interactions.AntigravityAgentConfig{
MaxTotalTokens: genai.Ptr(int64(50000)),
})),
}),
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Status: %s\n", res.Interaction.Status)
}
预计费用#
成本因任务复杂性而异。 智能体自主确定需要多少工具调用、代码执行和文件操作。以下估计基于运行。
| 任务类别 | 输入 token | 输出 token | 典型成本 |
|---|---|---|---|
| 研究与信息综合 | 100k–500k | 10k–40k | $0.30–$1.00 |
| 文档和内容生成 | 100k–500k | 15k–50k | $0.30–$1.30 |
| 流程与系统设计 | 100k–400k | 10k–30k | $0.25–$0.80 |
| 数据处理与分析 | 300k–3M | 30k–150k | $0.70–$3.25 |
输入 token 的 50–70% 通常会被缓存。具有许多工具调用的复杂智能体工作流程可以在单次交互中累积 3–5 百万 token,成本高达 ~$5.
环境计算 (CPU、内存、沙箱执行)是 未计费 在预览期间。
限制 #
- 预览状态: Antigravity、智能体和 Interactions API。功能和架构可能会发生变化。
- 不支持的生成配置: 不支持以下参数并返回 400 错误:
temperature,top_p,top_k,stop_sequences,max_output_tokens. - 结构化输出: Antigravity 智能体不支持结构化输出。
- 不可用的工具:
file_search,computer_use, 和google_maps尚不支持。 - 远程 MCP 限制: 不支持服务器发送事件 (SSE) 传输(使用 Streamable HTTP)。另外,服务器
name必须严格为小写字母和字母数字(使用大写字母会触发通用400 Bad Request错误)。 - 文件系统工具: 目前没有文件系统工具。它是
environment. - 店铺要求: 智能体执行使用
background=True需要store=True. - 仅有状态函数调用: 函数调用仅在有状态模式下受支持。你必须使用
previous_interaction_id继续转弯;不支持手动重建历史记录(无状态模式)。 - 不支持的多模态类型。 目前不支持音频、视频和文档输入。仅允许文本和图像。
后续步骤 #
- 快速入门:多轮对话和流媒体。
- 建筑定制智能体:自定义指令、技能,并保存智能体。
- 环境:沙箱配置、来源、网络。
- 钩子:在沙箱内强制执行安全门和副作用验证。
- Deep Research 智能体:长期研究任务。
- Interactions API:底层 API。