Gemini 4 Argon ya está disponible. Pruébalo.

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Generating content

La API de Gemini admite la generación de contenido con imágenes, audio, código, herramientas y mucho más. Para obtener detalles sobre cada una de estas funciones, sigue leyendo y consulta el código de muestra centrado en tareas o lee las guías completas.

Método: models.generateContent

Genera una respuesta del modelo a partir de un GenerateContentRequest de entrada. Consulta la guía de generación de texto para obtener información detallada sobre el uso. Las capacidades de entrada difieren entre los modelos, incluidos los modelos ajustados. Consulta la guía de modelos y la guía de ajuste para obtener más detalles.

Extremo

post https://generativelanguage.googleapis.com/v1beta/{model=models/*}:generateContent

Parámetros de ruta

model string

Obligatorio. Es el nombre del Model que se usará para generar la finalización.

Formato: models/{model}. Toma la forma models/{model}.

Cuerpo de la solicitud

El cuerpo de la solicitud contiene datos con la siguiente estructura:

Campos

contents[] object (Content)

Obligatorio. El contenido de la conversación actual con el modelo.

Para consultas de un solo turno, esta es una instancia única. Para las consultas de varios turnos, como chat, este es un campo repetido que contiene el historial de conversaciones y la solicitud más reciente.

tools[] object (Tool)

Opcional. Es una lista de Tools que el Model puede usar para generar la siguiente respuesta.

Una Tool es un fragmento de código que permite que el sistema interactúe con sistemas externos para realizar una acción, o un conjunto de acciones, fuera del conocimiento y del alcance del Model. Los Tool admitidos son Function y codeExecution. Consulta las guías de Llamada a funciones y de Ejecución de código para obtener más información.

toolConfig object (ToolConfig)

Opcional. Configuración de la herramienta para cualquier Tool especificado en la solicitud. Consulta la guía de llamada a funciones para ver un ejemplo de uso.

safetySettings[] object (SafetySetting)

Opcional. Es una lista de instancias de SafetySetting únicas para bloquear contenido no seguro.

Esto se aplicará de manera forzosa en GenerateContentRequest.contents y GenerateContentResponse.candidates. No debe haber más de un parámetro de configuración para cada tipo de SafetyCategory. La API bloqueará cualquier contenido y respuesta que no cumpla con los umbrales establecidos por estos parámetros de configuración. Esta lista anula la configuración predeterminada de cada SafetyCategory especificado en safetySettings. Si no hay un SafetySetting para un SafetyCategory determinado que se proporciona en la lista, la API usará el parámetro de configuración de seguridad predeterminado para esa categoría. Se admiten las categorías de daño HARM_CATEGORY_HATE_SPEECH, HARM_CATEGORY_SEXUALLY_EXPLICIT, HARM_CATEGORY_DANGEROUS_CONTENT, HARM_CATEGORY_HARASSMENT, HARM_CATEGORY_CIVIC_INTEGRITY y HARM_CATEGORY_JAILBREAK. Consulta la guía para obtener información detallada sobre los parámetros de configuración de seguridad disponibles. Consulta también la Guía de seguridad para aprender a incorporar consideraciones de seguridad en tus aplicaciones de IA.

continuationToken string (bytes format)

Opcional. Es un token de continuación opaco que se usa para reanudar la generación a partir de una respuesta anterior de models.generateContent o models.streamGenerateContent que se detuvo con finishReason establecido en CONTINUATION. Ten en cuenta que contents es obligatorio y debe replicar de forma idéntica la instrucción y el historial de conversaciones de la solicitud inicial cuando se proporciona un token de continuación en una solicitud.

String codificada en base64.

labels map (key: string, value: string)

Opcional. Son etiquetas con metadatos definidos por el usuario para la solicitud.

Opcional. Las etiquetas deben cumplir con los requisitos estándar de las etiquetas unificadas de Cloud: - Las claves de etiquetas deben comenzar con una letra. - Las claves y los valores de etiquetas no pueden tener más de 63 caracteres (puntos de código Unicode) y solo pueden contener letras en minúscula, caracteres numéricos, guiones bajos y guiones. - Se permite el uso de caracteres internacionales.

Uso: - Identificadores de seguridad de los agregadores: Usa la clave safety_identifier (p.ej., {"safety_identifier": "user_session_123"})

Un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

systemInstruction object (Content)

Opcional. Instrucciones del sistema establecidas por el desarrollador. Por el momento, solo texto.

generationConfig object (GenerationConfig)

Opcional. Son las opciones de configuración para la generación y los resultados del modelo.

cachedContent string

Opcional. Es el nombre del contenido almacenado en caché que se usará como contexto para entregar la predicción. Formato: cachedContents/{cachedContent}

serviceTier enum (ServiceTier)

Opcional. Es el nivel de servicio de la solicitud.

store boolean

Opcional. Configura el comportamiento de registro para una solicitud determinada. Si se establece, tiene prioridad sobre la configuración de registro a nivel del proyecto.

Ejemplo de solicitud

Texto

Python

from google import genai

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Write a story about a magic backpack.",
)
print(response.text)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: 'Write a story about a magic backpack.',
});
console.log(response.text);text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
contents := []*genai.Content{
	genai.NewContentFromText("Write a story about a magic backpack.", genai.RoleUser),
}
response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
printResponse(response)text_generation.go

Almeja

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[{"text": "Write a story about a magic backpack."}]
        }]
       }' 2> /dev/nulltext_generation.sh

Java

Client client = new Client();

GenerateContentResponse response =
    client.models.generateContent(
        "gemini-3.8-flash", "Write a story about a magic backpack.", null);

System.out.println(response.text());TextGeneration.java

Imagen

Python

from google import genai
import PIL.Image

client = genai.Client()
organ = PIL.Image.open(media / "organ.jpg")
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=["Tell me about this instrument", organ],
)
print(response.text)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const organ = await ai.files.upload({
  file: path.join(media, 'organ.jpg'),
});

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: [
    createUserContent([
      'Tell me about this instrument',
      createPartFromUri(organ.uri, organ.mimeType)
    ]),
  ],
});
console.log(response.text);text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "organ.jpg"),
	&genai.UploadFileConfig{
		MIMEType: "image/jpeg",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromText("Tell me about this instrument"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
printResponse(response)text_generation.go

Almeja

# Use a temporary file to hold the base64 encoded image data
TEMP_B64=$(mktemp)
trap 'rm -f "$TEMP_B64"' EXIT
base64 $B64FLAGS $IMG_PATH > "$TEMP_B64"

# Use a temporary file to hold the JSON payload
TEMP_JSON=$(mktemp)
trap 'rm -f "$TEMP_JSON"' EXIT

cat > "$TEMP_JSON" << EOF
{
  "contents": [{
    "parts":[
      {"text": "Tell me about this instrument"},
      {
        "inline_data": {
          "mime_type":"image/jpeg",
          "data": "$(cat "$TEMP_B64")"
        }
      }
    ]
  }]
}
EOF

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d "@$TEMP_JSON" 2> /dev/nulltext_generation.sh

Java

Client client = new Client();

String path = media_path + "organ.jpg";
byte[] imageData = Files.readAllBytes(Paths.get(path));

Content content =
    Content.fromParts(
        Part.fromText("Tell me about this instrument."),
        Part.fromBytes(imageData, "image/jpeg"));

GenerateContentResponse response =
    client.models.generateContent("gemini-3.8-flash", content, null);

System.out.println(response.text());TextGeneration.java

Audio

Python

from google import genai

client = genai.Client()
sample_audio = client.files.upload(file=media / "sample.mp3")
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=["Give me a summary of this audio file.", sample_audio],
)
print(response.text)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const audio = await ai.files.upload({
  file: path.join(media, 'sample.mp3'),
});

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: [
    createUserContent([
      'Give me a summary of this audio file.',
      createPartFromUri(audio.uri, audio.mimeType),
    ]),
  ],
});
console.log(response.text);text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "sample.mp3"),
	&genai.UploadFileConfig{
		MIMEType: "audio/mpeg",
	},
)
if err != nil {
	log.Fatal(err)
}

parts := []*genai.Part{
	genai.NewPartFromText("Give me a summary of this audio file."),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
printResponse(response)text_generation.go

Almeja

# Use File API to upload audio data to API request.
MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
DISPLAY_NAME=AUDIO

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Please describe this file."},
          {"file_data":{"mime_type": "audio/mpeg", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.jsontext_generation.sh

Video

Python

from google import genai
import time

client = genai.Client()
# Video clip (CC BY 3.0) from https://peach.blender.org/download/
myfile = client.files.upload(file=media / "Big_Buck_Bunny.mp4")
print(f"{myfile=}")

# Poll until the video file is completely processed (state becomes ACTIVE).
while not myfile.state or myfile.state.name != "ACTIVE":
  print("Processing video...")
  print("File state:", myfile.state)
  time.sleep(5)
  myfile = client.files.get(name=myfile.name)

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=[myfile, "Describe this video clip"]
)
print(f"{response.text=}")text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

let video = await ai.files.upload({
  file: path.join(media, 'Big_Buck_Bunny.mp4'),
});

// Poll until the video file is completely processed (state becomes ACTIVE).
while (!video.state || video.state.toString() !== 'ACTIVE') {
  console.log('Processing video...');
  console.log('File state: ', video.state);
  await sleep(5000);
  video = await ai.files.get({name: video.name});
}

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: [
    createUserContent([
      'Describe this video clip',
      createPartFromUri(video.uri, video.mimeType),
    ]),
  ],
});
console.log(response.text);text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"),
	&genai.UploadFileConfig{
		MIMEType: "video/mp4",
	},
)
if err != nil {
	log.Fatal(err)
}

// Poll until the video file is completely processed (state becomes ACTIVE).
for file.State == genai.FileStateUnspecified || file.State != genai.FileStateActive {
	fmt.Println("Processing video...")
	fmt.Println("File state:", file.State)
	time.Sleep(5 * time.Second)

	file, err = client.Files.Get(ctx, file.Name, nil)
	if err != nil {
		log.Fatal(err)
	}
}

parts := []*genai.Part{
	genai.NewPartFromText("Describe this video clip"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
printResponse(response)text_generation.go

Almeja

# Use File API to upload audio data to API request.
MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
DISPLAY_NAME=VIDEO

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D "${tmp_header_file}" \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

state=$(jq ".file.state" file_info.json)
echo state=$state

name=$(jq ".file.name" file_info.json)
echo name=$name

while [[ "($state)" = *"PROCESSING"* ]];
do
  echo "Processing video..."
  sleep 5
  # Get the file of interest to check state
  curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
  state=$(jq ".file.state" file_info.json)
done

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions."},
          {"file_data":{"mime_type": "video/mp4", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.jsontext_generation.sh

PDF

Python

from google import genai

client = genai.Client()
sample_pdf = client.files.upload(file=media / "test.pdf")
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=["Give me a summary of this document:", sample_pdf],
)
print(f"{response.text=}")text_generation.py

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "test.pdf"),
	&genai.UploadFileConfig{
		MIMEType: "application/pdf",
	},
)
if err != nil {
	log.Fatal(err)
}

parts := []*genai.Part{
	genai.NewPartFromText("Give me a summary of this document:"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
printResponse(response)text_generation.go

Almeja

MIME_TYPE=$(file -b --mime-type "${PDF_PATH}")
NUM_BYTES=$(wc -c < "${PDF_PATH}")
DISPLAY_NAME=TEXT


echo $MIME_TYPE
tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${PDF_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Can you add a few more lines to this poem?"},
          {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.jsontext_generation.sh

Chat

Python

from google import genai
from google.genai import types

client = genai.Client()
# Pass initial history using the "history" argument
chat = client.chats.create(
    model="gemini-3.8-flash",
    history=[
        types.Content(role="user", parts=[types.Part(text="Hello")]),
        types.Content(
            role="model",
            parts=[
                types.Part(
                    text="Great to meet you. What would you like to know?"
                )
            ],
        ),
    ],
)
response = chat.send_message(message="I have 2 dogs in my house.")
print(response.text)
response = chat.send_message(message="How many paws are in my house?")
print(response.text)chat.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const chat = ai.chats.create({
  model: 'gemini-3.8-flash',
  history: [
    {
      role: 'user',
      parts: [{text: 'Hello'}],
    },
    {
      role: 'model',
      parts: [{text: 'Great to meet you. What would you like to know?'}],
    },
  ],
});

const response1 = await chat.sendMessage({
  message: 'I have 2 dogs in my house.',
});
console.log('Chat response 1:', response1.text);

const response2 = await chat.sendMessage({
  message: 'How many paws are in my house?',
});
console.log('Chat response 2:', response2.text);chat.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

// Pass initial history using the History field.
history := []*genai.Content{
	genai.NewContentFromText("Hello", genai.RoleUser),
	genai.NewContentFromText("Great to meet you. What would you like to know?", genai.RoleModel),
}

chat, err := client.Chats.Create(ctx, "gemini-3.8-flash", nil, history)
if err != nil {
	log.Fatal(err)
}

firstResp, err := chat.SendMessage(ctx, genai.Part{Text: "I have 2 dogs in my house."})
if err != nil {
	log.Fatal(err)
}
fmt.Println(firstResp.Text())

secondResp, err := chat.SendMessage(ctx, genai.Part{Text: "How many paws are in my house?"})
if err != nil {
	log.Fatal(err)
}
fmt.Println(secondResp.Text())chat.go

Almeja

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Hello"}]},
        {"role": "model",
         "parts":[{
           "text": "Great to meet you. What would you like to know?"}]},
        {"role":"user",
         "parts":[{
           "text": "I have two dogs in my house. How many paws are in my house?"}]},
      ]
    }' 2> /dev/null | grep "text"chat.sh

Java

Client client = new Client();

Content userContent = Content.fromParts(Part.fromText("Hello"));
Content modelContent =
    Content.builder()
        .role("model")
        .parts(
            Collections.singletonList(
                Part.fromText("Great to meet you. What would you like to know?")))
        .build();

Chat chat =
    client.chats.create(
        "gemini-3.8-flash",
        GenerateContentConfig.builder()
            .systemInstruction(userContent)
            .systemInstruction(modelContent)
            .build());

GenerateContentResponse response1 = chat.sendMessage("I have 2 dogs in my house.");
System.out.println(response1.text());

GenerateContentResponse response2 = chat.sendMessage("How many paws are in my house?");
System.out.println(response2.text());
ChatSession.java

Caché

Python

from google import genai
from google.genai import types

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-3.8-flash"

cache = client.caches.create(
    model=model_name,
    config=types.CreateCachedContentConfig(
        contents=[document],
        system_instruction="You are an expert analyzing transcripts.",
    ),
)
print(cache)

response = client.models.generate_content(
    model=model_name,
    contents="Please summarize this transcript",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const filePath = path.join(media, 'a11.txt');
const document = await ai.files.upload({
  file: filePath,
  config: {mimeType: 'text/plain'},
});
console.log('Uploaded file name:', document.name);
const modelName = 'gemini-3.8-flash';

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: 'You are an expert analyzing transcripts.',
  },
});
console.log('Cache created:', cache);

const response = await ai.models.generateContent({
  model: modelName,
  contents: 'Please summarize this transcript',
  config: {cachedContent: cache.name},
});
console.log('Response text:', response.text);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-3.8-flash"
document, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "a11.txt"),
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents: contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache created:")
fmt.Println(cache)

// Use the cache for generating content.
response, err := client.Models.GenerateContent(
	ctx,
	modelName,
	genai.Text("Please summarize this transcript"),
	&genai.GenerateContentConfig{
		CachedContent: cache.Name,
	},
)
if err != nil {
	log.Fatal(err)
}
printResponse(response)cache.go

Modelo ajustado

Python

# With Gemini 2 we're launching a new SDK. See the following doc for details.
# https://ai.google.dev/gemini-api/docs/migrateREADME.md

Modo JSON

Python

from google import genai
from google.genai import types
from typing_extensions import TypedDict

class Recipe(TypedDict):
  recipe_name: str
  ingredients: list[str]

client = genai.Client()
result = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="List a few popular cookie recipes.",
    config=types.GenerateContentConfig(
        response_mime_type="application/json", response_schema=list[Recipe]
    ),
)
print(result)controlled_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: 'List a few popular cookie recipes.',
  config: {
    responseMimeType: 'application/json',
    responseSchema: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          recipeName: {type: 'string'},
          ingredients: {type: 'array', items: {type: 'string'}},
        },
        required: ['recipeName', 'ingredients'],
      },
    },
  },
});
console.log(response.text);controlled_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

schema := &genai.Schema{
	Type: genai.TypeArray,
	Items: &genai.Schema{
		Type: genai.TypeObject,
		Properties: map[string]*genai.Schema{
			"recipe_name": {Type: genai.TypeString},
			"ingredients": {
				Type:  genai.TypeArray,
				Items: &genai.Schema{Type: genai.TypeString},
			},
		},
		Required: []string{"recipe_name"},
	},
}

config := &genai.GenerateContentConfig{
	ResponseMIMEType: "application/json",
	ResponseSchema:   schema,
}

response, err := client.Models.GenerateContent(
	ctx,
	"gemini-3.8-flash",
	genai.Text("List a few popular cookie recipes."),
	config,
)
if err != nil {
	log.Fatal(err)
}
printResponse(response)controlled_generation.go

Almeja

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [{
      "parts":[
        {"text": "List 5 popular cookie recipes"}
        ]
    }],
    "generationConfig": {
        "response_mime_type": "application/json",
        "response_schema": {
          "type": "ARRAY",
          "items": {
            "type": "OBJECT",
            "properties": {
              "recipe_name": {"type":"STRING"},
            }
          }
        }
    }
}' 2> /dev/null | headcontrolled_generation.sh

Java

Client client = new Client();

Schema recipeSchema =
    Schema.builder()
        .type(Array.class.getSimpleName())
        .items(
            Schema.builder()
                .type(Object.class.getSimpleName())
                .properties(
                    Map.of(
                        "recipe_name",
                        Schema.builder().type(String.class.getSimpleName()).build(),
                        "ingredients",
                        Schema.builder()
                            .type(Array.class.getSimpleName())
                            .items(Schema.builder().type(String.class.getSimpleName()).build())
                            .build()))
                .required(List.of("recipe_name", "ingredients"))
                .build())
        .build();

GenerateContentConfig config =
    GenerateContentConfig.builder()
        .responseMimeType("application/json")
        .responseSchema(recipeSchema)
        .build();

GenerateContentResponse response =
    client.models.generateContent(
        "gemini-3.8-flash", "List a few popular cookie recipes.", config);

System.out.println(response.text());ControlledGeneration.java

Ejecución de código

Python

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=(
        "Write and execute code that calculates the sum of the first 50"
        " prime numbers. Ensure that only the executable code and its"
        " resulting output are generated."
    ),
)
# Each part may contain text, executable code, or an execution result.
for part in response.candidates[0].content.parts:
  print(part, "\n")

print("-" * 80)
# The .text accessor concatenates the parts into a markdown-formatted text.
print("\n", response.text)code_execution.py

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

response, err := client.Models.GenerateContent(
	ctx,
	"gemini-3.8-flash",
	genai.Text(
		`Write and execute code that calculates the sum of the first 50 prime numbers.
		 Ensure that only the executable code and its resulting output are generated.`,
	),
	&genai.GenerateContentConfig{},
)
if err != nil {
	log.Fatal(err)
}

// Print the response.
printResponse(response)

fmt.Println("--------------------------------------------------------------------------------")
fmt.Println(response.Text())code_execution.go

Java

Client client = new Client();

String prompt =
    """
    Write and execute code that calculates the sum of the first 50 prime numbers.
    Ensure that only the executable code and its resulting output are generated.
    """;

GenerateContentResponse response =
    client.models.generateContent("gemini-3.8-flash", prompt, null);

for (Part part : response.candidates().get().getFirst().content().get().parts().get()) {
  System.out.println(part + "\n");
}

System.out.println("-".repeat(80));
System.out.println(response.text());CodeExecution.java

Llamadas a funciones

Python

from google import genai
from google.genai import types

client = genai.Client()

def add(a: float, b: float) -> float:
  """returns a + b."""
  return a + b

def subtract(a: float, b: float) -> float:
  """returns a - b."""
  return a - b

def multiply(a: float, b: float) -> float:
  """returns a * b."""
  return a * b

def divide(a: float, b: float) -> float:
  """returns a / b."""
  return a / b

# Create a chat session; function calling (via tools) is enabled in the config.
chat = client.chats.create(
    model="gemini-3.8-flash",
    config=types.GenerateContentConfig(
        tools=[add, subtract, multiply, divide]
    ),
)
response = chat.send_message(
    message=(
        "I have 57 cats, each owns 44 mittens, how many mittens is that in"
        " total?"
    )
)
print(response.text)function_calling.py

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
modelName := "gemini-3.8-flash"

// Create the function declarations for arithmetic operations.
addDeclaration := createArithmeticToolDeclaration("addNumbers", "Return the result of adding two numbers.")
subtractDeclaration := createArithmeticToolDeclaration("subtractNumbers", "Return the result of subtracting the second number from the first.")
multiplyDeclaration := createArithmeticToolDeclaration("multiplyNumbers", "Return the product of two numbers.")
divideDeclaration := createArithmeticToolDeclaration("divideNumbers", "Return the quotient of dividing the first number by the second.")

// Group the function declarations as a tool.
tools := []*genai.Tool{
	{
		FunctionDeclarations: []*genai.FunctionDeclaration{
			addDeclaration,
			subtractDeclaration,
			multiplyDeclaration,
			divideDeclaration,
		},
	},
}

// Create the content prompt.
contents := []*genai.Content{
	genai.NewContentFromText(
		"I have 57 cats, each owns 44 mittens, how many mittens is that in total?", genai.RoleUser,
	),
}

// Set up the generate content configuration with function calling enabled.
config := &genai.GenerateContentConfig{
	Tools: tools,
	ToolConfig: &genai.ToolConfig{
		FunctionCallingConfig: &genai.FunctionCallingConfig{
			// The mode equivalent to FunctionCallingConfigMode.ANY in JS.
			Mode: genai.FunctionCallingConfigModeAny,
		},
	},
}

genContentResp, err := client.Models.GenerateContent(ctx, modelName, contents, config)
if err != nil {
	log.Fatal(err)
}

// Assume the response includes a list of function calls.
if len(genContentResp.FunctionCalls()) == 0 {
	log.Println("No function call returned from the AI.")
	return nil
}
functionCall := genContentResp.FunctionCalls()[0]
log.Printf("Function call: %+v\n", functionCall)

// Marshal the Args map into JSON bytes.
argsMap, err := json.Marshal(functionCall.Args)
if err != nil {
	log.Fatal(err)
}

// Unmarshal the JSON bytes into the ArithmeticArgs struct.
var args ArithmeticArgs
if err := json.Unmarshal(argsMap, &args); err != nil {
	log.Fatal(err)
}

// Map the function name to the actual arithmetic function.
var result float64
switch functionCall.Name {
case "addNumbers":
	result = add(args.FirstParam, args.SecondParam)
case "subtractNumbers":
	result = subtract(args.FirstParam, args.SecondParam)
case "multiplyNumbers":
	result = multiply(args.FirstParam, args.SecondParam)
case "divideNumbers":
	result = divide(args.FirstParam, args.SecondParam)
default:
	return fmt.Errorf("unimplemented function: %s", functionCall.Name)
}
log.Printf("Function result: %v\n", result)

// Prepare the final result message as content.
resultContents := []*genai.Content{
	genai.NewContentFromText("The final result is "+fmt.Sprintf("%v", result), genai.RoleUser),
}

// Use GenerateContent to send the final result.
finalResponse, err := client.Models.GenerateContent(ctx, modelName, resultContents, &genai.GenerateContentConfig{})
if err != nil {
	log.Fatal(err)
}

printResponse(finalResponse)function_calling.go

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

/**
 * The add function returns the sum of two numbers.
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function add(a, b) {
  return a + b;
}

/**
 * The subtract function returns the difference (a - b).
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function subtract(a, b) {
  return a - b;
}

/**
 * The multiply function returns the product of two numbers.
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function multiply(a, b) {
  return a * b;
}

/**
 * The divide function returns the quotient of a divided by b.
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function divide(a, b) {
  return a / b;
}

const addDeclaration = {
  name: 'addNumbers',
  parameters: {
    type: 'object',
    description: 'Return the result of adding two numbers.',
    properties: {
      firstParam: {
        type: 'number',
        description:
            'The first parameter which can be an integer or a floating point number.',
      },
      secondParam: {
        type: 'number',
        description:
            'The second parameter which can be an integer or a floating point number.',
      },
    },
    required: ['firstParam', 'secondParam'],
  },
};

const subtractDeclaration = {
  name: 'subtractNumbers',
  parameters: {
    type: 'object',
    description:
        'Return the result of subtracting the second number from the first.',
    properties: {
      firstParam: {
        type: 'number',
        description: 'The first parameter.',
      },
      secondParam: {
        type: 'number',
        description: 'The second parameter.',
      },
    },
    required: ['firstParam', 'secondParam'],
  },
};

const multiplyDeclaration = {
  name: 'multiplyNumbers',
  parameters: {
    type: 'object',
    description: 'Return the product of two numbers.',
    properties: {
      firstParam: {
        type: 'number',
        description: 'The first parameter.',
      },
      secondParam: {
        type: 'number',
        description: 'The second parameter.',
      },
    },
    required: ['firstParam', 'secondParam'],
  },
};

const divideDeclaration = {
  name: 'divideNumbers',
  parameters: {
    type: 'object',
    description:
        'Return the quotient of dividing the first number by the second.',
    properties: {
      firstParam: {
        type: 'number',
        description: 'The first parameter.',
      },
      secondParam: {
        type: 'number',
        description: 'The second parameter.',
      },
    },
    required: ['firstParam', 'secondParam'],
  },
};

// Step 1: Call generateContent with function calling enabled.
const generateContentResponse = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents:
      'I have 57 cats, each owns 44 mittens, how many mittens is that in total?',
  config: {
    toolConfig: {
      functionCallingConfig: {
        mode: FunctionCallingConfigMode.ANY,
      },
    },
    tools: [
      {
        functionDeclarations: [
          addDeclaration,
          subtractDeclaration,
          multiplyDeclaration,
          divideDeclaration,
        ],
      },
    ],
  },
});

// Step 2: Extract the function call.(
// Assuming the response contains a 'functionCalls' array.
const functionCall = generateContentResponse.functionCalls &&
    generateContentResponse.functionCalls[0];
console.log(functionCall);

// Parse the arguments.
const args = functionCall.args;
// Expected args format: { firstParam: number, secondParam: number }

// Step 3: Invoke the actual function based on the function name.
const functionMapping = {
  addNumbers: add,
  subtractNumbers: subtract,
  multiplyNumbers: multiply,
  divideNumbers: divide,
};
const func = functionMapping[functionCall.name];
if (!func) {
  console.error('Unimplemented error:', functionCall.name);
  return generateContentResponse;
}
const resultValue = func(args.firstParam, args.secondParam);
console.log('Function result:', resultValue);

// Step 4: Use the chat API to send the result as the final answer.
const chat = ai.chats.create({model: 'gemini-3.8-flash'});
const chatResponse = await chat.sendMessage({
  message: 'The final result is ' + resultValue,
});
console.log(chatResponse.text);function_calling.js

Almeja


cat > tools.json << EOF
{
  "function_declarations": [
    {
      "name": "enable_lights",
      "description": "Turn on the lighting system."
    },
    {
      "name": "set_light_color",
      "description": "Set the light color. Lights must be enabled for this to work.",
      "parameters": {
        "type": "object",
        "properties": {
          "rgb_hex": {
            "type": "string",
            "description": "The light color as a 6-digit hex string, e.g. ff0000 for red."
          }
        },
        "required": [
          "rgb_hex"
        ]
      }
    },
    {
      "name": "stop_lights",
      "description": "Turn off the lighting system."
    }
  ]
} 
EOF

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d @<(echo '
  {
    "system_instruction": {
      "parts": {
        "text": "You are a helpful lighting system bot. You can turn lights on and off, and you can set the color. Do not perform any other tasks."
      }
    },
    "tools": ['$(cat tools.json)'],

    "tool_config": {
      "function_calling_config": {"mode": "auto"}
    },

    "contents": {
      "role": "user",
      "parts": {
        "text": "Turn on the lights please."
      }
    }
  }
') 2>/dev/null |sed -n '/"content"/,/"finishReason"/p'function_calling.sh

Java

Client client = new Client();

FunctionDeclaration addFunction =
    FunctionDeclaration.builder()
        .name("addNumbers")
        .parameters(
            Schema.builder()
                .type("object")
                .properties(
                    Map.of(
                        "firstParam",
                            Schema.builder().type("number").description("First number").build(),
                        "secondParam",
                            Schema.builder()
                                .type("number")
                                .description("Second number")
                                .build()))
                .required(Arrays.asList("firstParam", "secondParam"))
                .build())
        .build();

FunctionDeclaration subtractFunction =
    FunctionDeclaration.builder()
        .name("subtractNumbers")
        .parameters(
            Schema.builder()
                .type("object")
                .properties(
                    Map.of(
                        "firstParam",
                            Schema.builder().type("number").description("First number").build(),
                        "secondParam",
                            Schema.builder()
                                .type("number")
                                .description("Second number")
                                .build()))
                .required(Arrays.asList("firstParam", "secondParam"))
                .build())
        .build();

FunctionDeclaration multiplyFunction =
    FunctionDeclaration.builder()
        .name("multiplyNumbers")
        .parameters(
            Schema.builder()
                .type("object")
                .properties(
                    Map.of(
                        "firstParam",
                            Schema.builder().type("number").description("First number").build(),
                        "secondParam",
                            Schema.builder()
                                .type("number")
                                .description("Second number")
                                .build()))
                .required(Arrays.asList("firstParam", "secondParam"))
                .build())
        .build();

FunctionDeclaration divideFunction =
    FunctionDeclaration.builder()
        .name("divideNumbers")
        .parameters(
            Schema.builder()
                .type("object")
                .properties(
                    Map.of(
                        "firstParam",
                            Schema.builder().type("number").description("First number").build(),
                        "secondParam",
                            Schema.builder()
                                .type("number")
                                .description("Second number")
                                .build()))
                .required(Arrays.asList("firstParam", "secondParam"))
                .build())
        .build();

GenerateContentConfig config =
    GenerateContentConfig.builder()
        .toolConfig(
            ToolConfig.builder()
                .functionCallingConfig(FunctionCallingConfig.builder().mode("ANY").build())
                .build())
        .tools(
            Collections.singletonList(
                Tool.builder()
                    .functionDeclarations(
                        Arrays.asList(
                            addFunction, subtractFunction, divideFunction, multiplyFunction))
                    .build()))
        .build();

GenerateContentResponse response =
    client.models.generateContent(
        "gemini-3.8-flash",
        "I have 57 cats, each owns 44 mittens, how many mittens is that in total?",
        config);

if (response.functionCalls() == null || response.functionCalls().isEmpty()) {
  System.err.println("No function call received");
  return null;
}

var functionCall = response.functionCalls().getFirst();
String functionName = functionCall.name().get();
var arguments = functionCall.args();

Map<String, BiFunction<Double, Double, Double>> functionMapping = new HashMap<>();
functionMapping.put("addNumbers", (a, b) -> a + b);
functionMapping.put("subtractNumbers", (a, b) -> a - b);
functionMapping.put("multiplyNumbers", (a, b) -> a * b);
functionMapping.put("divideNumbers", (a, b) -> b != 0 ? a / b : Double.NaN);

BiFunction<Double, Double, Double> function = functionMapping.get(functionName);

Number firstParam = (Number) arguments.get().get("firstParam");
Number secondParam = (Number) arguments.get().get("secondParam");
Double result = function.apply(firstParam.doubleValue(), secondParam.doubleValue());

System.out.println(result);FunctionCalling.java

Configuración de generación

Python

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Tell me a story about a magic backpack.",
    config=types.GenerateContentConfig(
        candidate_count=1,
        stop_sequences=["x"],
        max_output_tokens=20,
        temperature=1.0,
    ),
)
print(response.text)configure_model_parameters.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: 'Tell me a story about a magic backpack.',
  config: {
    candidateCount: 1,
    stopSequences: ['x'],
    maxOutputTokens: 20,
    temperature: 1.0,
  },
});

console.log(response.text);configure_model_parameters.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

// Create local variables for parameters.
candidateCount := int32(1)
maxOutputTokens := int32(20)
temperature := float32(1.0)

response, err := client.Models.GenerateContent(
	ctx,
	"gemini-3.8-flash",
	genai.Text("Tell me a story about a magic backpack."),
	&genai.GenerateContentConfig{
		CandidateCount:  candidateCount,
		StopSequences:   []string{"x"},
		MaxOutputTokens: maxOutputTokens,
		Temperature:     &temperature,
	},
)
if err != nil {
	log.Fatal(err)
}

printResponse(response)configure_model_parameters.go

Almeja

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
        "contents": [{
            "parts":[
                {"text": "Explain how AI works"}
            ]
        }],
        "generationConfig": {
            "stopSequences": [
                "Title"
            ],
            "temperature": 1.0,
            "maxOutputTokens": 800,
            "topP": 0.8,
            "topK": 10
        }
    }'  2> /dev/null | grep "text"configure_model_parameters.sh

Java

Client client = new Client();

GenerateContentConfig config =
    GenerateContentConfig.builder()
        .candidateCount(1)
        .stopSequences(List.of("x"))
        .maxOutputTokens(20)
        .temperature(1.0F)
        .build();

GenerateContentResponse response =
    client.models.generateContent(
        "gemini-3.8-flash", "Tell me a story about a magic backpack.", config);

System.out.println(response.text());ConfigureModelParameters.java

Configuración de seguridad

Python

from google import genai
from google.genai import types

client = genai.Client()
unsafe_prompt = (
    "I support Martians Soccer Club and I think Jupiterians Football Club"
    " sucks! Write a ironic phrase about them including expletives."
)
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=unsafe_prompt,
    config=types.GenerateContentConfig(
        safety_settings=[
            types.SafetySetting(
                category="HARM_CATEGORY_HATE_SPEECH",
                threshold="BLOCK_MEDIUM_AND_ABOVE",
            ),
            types.SafetySetting(
                category="HARM_CATEGORY_HARASSMENT",
                threshold="BLOCK_ONLY_HIGH",
            ),
        ]
    ),
)
try:
  print(response.text)
except Exception:
  print("No information generated by the model.")

print(response.candidates[0].safety_ratings)safety_settings.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const unsafePrompt =
    'I support Martians Soccer Club and I think Jupiterians Football Club sucks! Write a ironic phrase about them including expletives.';

const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: unsafePrompt,
  config: {
    safetySettings: [
      {
        category: 'HARM_CATEGORY_HATE_SPEECH',
        threshold: 'BLOCK_MEDIUM_AND_ABOVE',
      },
      {
        category: 'HARM_CATEGORY_HARASSMENT',
        threshold: 'BLOCK_ONLY_HIGH',
      },
    ],
  },
});

try {
  console.log('Generated text:', response.text);
} catch (error) {
  console.log('No information generated by the model.');
}
console.log('Safety ratings:', response.candidates[0].safetyRatings);safety_settings.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

unsafePrompt := "I support Martians Soccer Club and I think Jupiterians Football Club sucks! " +
	"Write a ironic phrase about them including expletives."

config := &genai.GenerateContentConfig{
	SafetySettings: []*genai.SafetySetting{
		{
			Category:  "HARM_CATEGORY_HATE_SPEECH",
			Threshold: "BLOCK_MEDIUM_AND_ABOVE",
		},
		{
			Category:  "HARM_CATEGORY_HARASSMENT",
			Threshold: "BLOCK_ONLY_HIGH",
		},
	},
}
contents := []*genai.Content{
	genai.NewContentFromText(unsafePrompt, genai.RoleUser),
}
response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, config)
if err != nil {
	log.Fatal(err)
}

// Print the generated text.
text := response.Text()
fmt.Println("Generated text:", text)

// Print the and safety ratings from the first candidate.
if len(response.Candidates) > 0 {
	fmt.Println("Finish reason:", response.Candidates[0].FinishReason)
	safetyRatings, err := json.MarshalIndent(response.Candidates[0].SafetyRatings, "", "  ")
	if err != nil {
		return err
	}
	fmt.Println("Safety ratings:", string(safetyRatings))
} else {
	fmt.Println("No candidate returned.")
}safety_settings.go

Almeja

echo '{
    "safetySettings": [
        {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_ONLY_HIGH"},
        {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"}
    ],
    "contents": [{
        "parts":[{
            "text": "'I support Martians Soccer Club and I think Jupiterians Football Club sucks! Write a ironic phrase about them.'"}]}]}' > request.json

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d @request.json 2> /dev/nullsafety_settings.sh

Java

Client client = new Client();

String unsafePrompt =
    """
     I support Martians Soccer Club and I think Jupiterians Football Club sucks!
     Write a ironic phrase about them including expletives.
    """;

GenerateContentConfig config =
    GenerateContentConfig.builder()
        .safetySettings(
            Arrays.asList(
                SafetySetting.builder()
                    .category("HARM_CATEGORY_HATE_SPEECH")
                    .threshold("BLOCK_MEDIUM_AND_ABOVE")
                    .build(),
                SafetySetting.builder()
                    .category("HARM_CATEGORY_HARASSMENT")
                    .threshold("BLOCK_ONLY_HIGH")
                    .build()))
        .build();

GenerateContentResponse response =
    client.models.generateContent("gemini-3.8-flash", unsafePrompt, config);

try {
  System.out.println(response.text());
} catch (Exception e) {
  System.out.println("No information generated by the model");
}

System.out.println(response.candidates().get().getFirst().safetyRatings());SafetySettings.java

Instrucción del sistema

Python

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Good morning! How are you?",
    config=types.GenerateContentConfig(
        system_instruction="You are a cat. Your name is Neko."
    ),
)
print(response.text)system_instruction.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const response = await ai.models.generateContent({
  model: 'gemini-3.8-flash',
  contents: 'Good morning! How are you?',
  config: {
    systemInstruction: 'You are a cat. Your name is Neko.',
  },
});
console.log(response.text);system_instruction.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

// Construct the user message contents.
contents := []*genai.Content{
	genai.NewContentFromText("Good morning! How are you?", genai.RoleUser),
}

// Set the system instruction as a *genai.Content.
config := &genai.GenerateContentConfig{
	SystemInstruction: genai.NewContentFromText("You are a cat. Your name is Neko.", genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, config)
if err != nil {
	log.Fatal(err)
}
printResponse(response)system_instruction.go

Almeja

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{ "system_instruction": {
    "parts":
      { "text": "You are a cat. Your name is Neko."}},
    "contents": {
      "parts": {
        "text": "Hello there"}}}'system_instruction.sh

Java

Client client = new Client();

Part textPart = Part.builder().text("You are a cat. Your name is Neko.").build();

Content content = Content.builder().role("system").parts(ImmutableList.of(textPart)).build();

GenerateContentConfig config =
    GenerateContentConfig.builder().systemInstruction(content).build();

GenerateContentResponse response =
    client.models.generateContent("gemini-3.8-flash", "Good morning! How are you?", config);

System.out.println(response.text());SystemInstruction.java

Cuerpo de la respuesta

Si se ejecuta de forma correcta, el cuerpo de la respuesta contiene una instancia de GenerateContentResponse.

Método: models.streamGenerateContent

Extremo
Parámetros de ruta
Cuerpo de la solicitud
- Representación JSON
Cuerpo de la respuesta
Permisos de autorización
Ejemplo de solicitud
- Texto
- Imagen
- Audio
- Video
- PDF
- Chat

Genera una respuesta transmitida del modelo a partir de un GenerateContentRequest de entrada.

Extremo

post https://generativelanguage.googleapis.com/v1beta/{model=models/*}:streamGenerateContent

Parámetros de ruta

model string

Obligatorio. Es el nombre del Model que se usará para generar la finalización.

Formato: models/{model}. Toma la forma models/{model}.

Cuerpo de la solicitud

El cuerpo de la solicitud contiene datos con la siguiente estructura:

Campos

contents[] object (Content)

Obligatorio. El contenido de la conversación actual con el modelo.

tools[] object (Tool)

Opcional. Es una lista de Tools que el Model puede usar para generar la siguiente respuesta.

toolConfig object (ToolConfig)

Opcional. Configuración de la herramienta para cualquier Tool especificado en la solicitud. Consulta la guía de llamada a funciones para ver un ejemplo de uso.

safetySettings[] object (SafetySetting)

Opcional. Es una lista de instancias de SafetySetting únicas para bloquear contenido no seguro.

continuationToken string (bytes format)

String codificada en base64.

labels map (key: string, value: string)

Opcional. Son etiquetas con metadatos definidos por el usuario para la solicitud.

Uso: - Identificadores de seguridad de los agregadores: Usa la clave safety_identifier (p.ej., {"safety_identifier": "user_session_123"})

Un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

systemInstruction object (Content)

Opcional. Instrucciones del sistema establecidas por el desarrollador. Por el momento, solo texto.

generationConfig object (GenerationConfig)

Opcional. Son las opciones de configuración para la generación y los resultados del modelo.

cachedContent string

Opcional. Es el nombre del contenido almacenado en caché que se usará como contexto para entregar la predicción. Formato: cachedContents/{cachedContent}

serviceTier enum (ServiceTier)

Opcional. Es el nivel de servicio de la solicitud.

store boolean

Opcional. Configura el comportamiento de registro para una solicitud determinada. Si se establece, tiene prioridad sobre la configuración de registro a nivel del proyecto.

Ejemplo de solicitud

Texto

Python

from google import genai

client = genai.Client()
response = client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents="Write a story about a magic backpack.",
)
for chunk in response:
  print(chunk.text)
  print("_" * 80)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const response = await ai.models.generateContentStream({
  model: 'gemini-3.8-flash',
  contents: 'Write a story about a magic backpack.',
});
let text = '';
for await (const chunk of response) {
  console.log(chunk.text);
  text += chunk.text;
}text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
contents := []*genai.Content{
	genai.NewContentFromText("Write a story about a magic backpack.", genai.RoleUser),
}
for response, err := range client.Models.GenerateContentStream(
	ctx,
	"gemini-3.8-flash",
	contents,
	nil,
) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(response.Candidates[0].Content.Parts[0].Text)
}text_generation.go

Almeja

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=${GEMINI_API_KEY}" \
        -H 'Content-Type: application/json' \
        --no-buffer \
        -d '{ "contents":[{"parts":[{"text": "Write a story about a magic backpack."}]}]}'text_generation.sh

Java

Client client = new Client();

ResponseStream<GenerateContentResponse> responseStream =
    client.models.generateContentStream(
        "gemini-3.8-flash", "Write a story about a magic backpack.", null);

StringBuilder response = new StringBuilder();
for (GenerateContentResponse res : responseStream) {
  System.out.print(res.text());
  response.append(res.text());
}

responseStream.close();TextGeneration.java

Imagen

Python

from google import genai
import PIL.Image

client = genai.Client()
organ = PIL.Image.open(media / "organ.jpg")
response = client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents=["Tell me about this instrument", organ],
)
for chunk in response:
  print(chunk.text)
  print("_" * 80)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

const organ = await ai.files.upload({
  file: path.join(media, 'organ.jpg'),
});

const response = await ai.models.generateContentStream({
  model: 'gemini-3.8-flash',
  contents: [
    createUserContent([
      'Tell me about this instrument',
      createPartFromUri(organ.uri, organ.mimeType)
    ]),
  ],
});
let text = '';
for await (const chunk of response) {
  console.log(chunk.text);
  text += chunk.text;
}text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "organ.jpg"),
	&genai.UploadFileConfig{
		MIMEType: "image/jpeg",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromText("Tell me about this instrument"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
for response, err := range client.Models.GenerateContentStream(
	ctx,
	"gemini-3.8-flash",
	contents,
	nil,
) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(response.Candidates[0].Content.Parts[0].Text)
}text_generation.go

Almeja

cat > "$TEMP_JSON" << EOF
{
  "contents": [{
    "parts":[
      {"text": "Tell me about this instrument"},
      {
        "inline_data": {
          "mime_type":"image/jpeg",
          "data": "$(cat "$TEMP_B64")"
        }
      }
    ]
  }]
}
EOF

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d "@$TEMP_JSON" 2> /dev/nulltext_generation.sh

Java

Client client = new Client();

String path = media_path + "organ.jpg";
byte[] imageData = Files.readAllBytes(Paths.get(path));

Content content =
    Content.fromParts(
        Part.fromText("Tell me about this instrument."),
        Part.fromBytes(imageData, "image/jpeg"));

ResponseStream<GenerateContentResponse> responseStream =
    client.models.generateContentStream("gemini-3.8-flash", content, null);

StringBuilder response = new StringBuilder();
for (GenerateContentResponse res : responseStream) {
  System.out.print(res.text());
  response.append(res.text());
}

responseStream.close();TextGeneration.java

Audio

Python

from google import genai

client = genai.Client()
sample_audio = client.files.upload(file=media / "sample.mp3")
response = client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents=["Give me a summary of this audio file.", sample_audio],
)
for chunk in response:
  print(chunk.text)
  print("_" * 80)text_generation.py

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "sample.mp3"),
	&genai.UploadFileConfig{
		MIMEType: "audio/mpeg",
	},
)
if err != nil {
	log.Fatal(err)
}

parts := []*genai.Part{
	genai.NewPartFromText("Give me a summary of this audio file."),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

for result, err := range client.Models.GenerateContentStream(
	ctx,
	"gemini-3.8-flash",
	contents,
	nil,
) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(result.Candidates[0].Content.Parts[0].Text)
}text_generation.go

Almeja

# Use File API to upload audio data to API request.
MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
DISPLAY_NAME=AUDIO

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Please describe this file."},
          {"file_data":{"mime_type": "audio/mpeg", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echotext_generation.sh

Video

Python

from google import genai
import time

client = genai.Client()
# Video clip (CC BY 3.0) from https://peach.blender.org/download/
myfile = client.files.upload(file=media / "Big_Buck_Bunny.mp4")
print(f"{myfile=}")

# Poll until the video file is completely processed (state becomes ACTIVE).
while not myfile.state or myfile.state.name != "ACTIVE":
  print("Processing video...")
  print("File state:", myfile.state)
  time.sleep(5)
  myfile = client.files.get(name=myfile.name)

response = client.models.generate_content_stream(
    model="gemini-3.8-flash", contents=[myfile, "Describe this video clip"]
)
for chunk in response:
  print(chunk.text)
  print("_" * 80)text_generation.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});

let video = await ai.files.upload({
  file: path.join(media, 'Big_Buck_Bunny.mp4'),
});

// Poll until the video file is completely processed (state becomes ACTIVE).
while (!video.state || video.state.toString() !== 'ACTIVE') {
  console.log('Processing video...');
  console.log('File state: ', video.state);
  await sleep(5000);
  video = await ai.files.get({name: video.name});
}

const response = await ai.models.generateContentStream({
  model: 'gemini-3.8-flash',
  contents: [
    createUserContent([
      'Describe this video clip',
      createPartFromUri(video.uri, video.mimeType),
    ]),
  ],
});
let text = '';
for await (const chunk of response) {
  console.log(chunk.text);
  text += chunk.text;
}text_generation.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"),
	&genai.UploadFileConfig{
		MIMEType: "video/mp4",
	},
)
if err != nil {
	log.Fatal(err)
}

// Poll until the video file is completely processed (state becomes ACTIVE).
for file.State == genai.FileStateUnspecified || file.State != genai.FileStateActive {
	fmt.Println("Processing video...")
	fmt.Println("File state:", file.State)
	time.Sleep(5 * time.Second)

	file, err = client.Files.Get(ctx, file.Name, nil)
	if err != nil {
		log.Fatal(err)
	}
}

parts := []*genai.Part{
	genai.NewPartFromText("Describe this video clip"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

for result, err := range client.Models.GenerateContentStream(
	ctx,
	"gemini-3.8-flash",
	contents,
	nil,
) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(result.Candidates[0].Content.Parts[0].Text)
}text_generation.go

Almeja

# Use File API to upload audio data to API request.
MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
DISPLAY_NAME=VIDEO_PATH

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

state=$(jq ".file.state" file_info.json)
echo state=$state

while [[ "($state)" = *"PROCESSING"* ]];
do
  echo "Processing video..."
  sleep 5
  # Get the file of interest to check state
  curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
  state=$(jq ".file.state" file_info.json)
done

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Please describe this file."},
          {"file_data":{"mime_type": "video/mp4", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echotext_generation.sh

PDF

Python

from google import genai

client = genai.Client()
sample_pdf = client.files.upload(file=media / "test.pdf")
response = client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents=["Give me a summary of this document:", sample_pdf],
)

for chunk in response:
  print(chunk.text)
  print("_" * 80)text_generation.py

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

file, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "test.pdf"),
	&genai.UploadFileConfig{
		MIMEType: "application/pdf",
	},
)
if err != nil {
	log.Fatal(err)
}

parts := []*genai.Part{
	genai.NewPartFromText("Give me a summary of this document:"),
	genai.NewPartFromURI(file.URI, file.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

for result, err := range client.Models.GenerateContentStream(
	ctx,
	"gemini-3.8-flash",
	contents,
	nil,
) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(result.Candidates[0].Content.Parts[0].Text)
}text_generation.go

Almeja

MIME_TYPE=$(file -b --mime-type "${PDF_PATH}")
NUM_BYTES=$(wc -c < "${PDF_PATH}")
DISPLAY_NAME=TEXT


echo $MIME_TYPE
tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${PDF_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Can you add a few more lines to this poem?"},
          {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echotext_generation.sh

Chat

Python

from google import genai
from google.genai import types

client = genai.Client()
chat = client.chats.create(
    model="gemini-3.8-flash",
    history=[
        types.Content(role="user", parts=[types.Part(text="Hello")]),
        types.Content(
            role="model",
            parts=[
                types.Part(
                    text="Great to meet you. What would you like to know?"
                )
            ],
        ),
    ],
)
response = chat.send_message_stream(message="I have 2 dogs in my house.")
for chunk in response:
  print(chunk.text)
  print("_" * 80)
response = chat.send_message_stream(
    message="How many paws are in my house?"
)
for chunk in response:
  print(chunk.text)
  print("_" * 80)

print(chat.get_history())chat.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({apiKey: process.env.GEMINI_API_KEY});
const chat = ai.chats.create({
  model: 'gemini-3.8-flash',
  history: [
    {
      role: 'user',
      parts: [{text: 'Hello'}],
    },
    {
      role: 'model',
      parts: [{text: 'Great to meet you. What would you like to know?'}],
    },
  ],
});

console.log('Streaming response for first message:');
const stream1 = await chat.sendMessageStream({
  message: 'I have 2 dogs in my house.',
});
for await (const chunk of stream1) {
  console.log(chunk.text);
  console.log('_'.repeat(80));
}

console.log('Streaming response for second message:');
const stream2 = await chat.sendMessageStream({
  message: 'How many paws are in my house?',
});
for await (const chunk of stream2) {
  console.log(chunk.text);
  console.log('_'.repeat(80));
}

console.log(chat.getHistory());chat.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

history := []*genai.Content{
	genai.NewContentFromText("Hello", genai.RoleUser),
	genai.NewContentFromText("Great to meet you. What would you like to know?", genai.RoleModel),
}
chat, err := client.Chats.Create(ctx, "gemini-3.8-flash", nil, history)
if err != nil {
	log.Fatal(err)
}

for chunk, err := range chat.SendMessageStream(ctx, genai.Part{Text: "I have 2 dogs in my house."}) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(chunk.Text())
	fmt.Println(strings.Repeat("_", 64))
}

for chunk, err := range chat.SendMessageStream(ctx, genai.Part{Text: "How many paws are in my house?"}) {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(chunk.Text())
	fmt.Println(strings.Repeat("_", 64))
}

fmt.Println(chat.History(false))chat.go

Almeja

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Hello"}]},
        {"role": "model",
         "parts":[{
           "text": "Great to meet you. What would you like to know?"}]},
        {"role":"user",
         "parts":[{
           "text": "I have two dogs in my house. How many paws are in my house?"}]},
      ]
    }' 2> /dev/null | grep "text"chat.sh

Cuerpo de la respuesta

Si se ejecuta correctamente, el cuerpo de la respuesta contiene un flujo de instancias de GenerateContentResponse.

Es la respuesta del modelo que admite varias respuestas candidatas.

Las calificaciones de seguridad y el filtrado de contenido se informan tanto para la instrucción en GenerateContentResponse.prompt_feedback como para cada candidato en finishReason y en safetyRatings. La API: - Devuelve todos los candidatos solicitados o ninguno de ellos - No devuelve ningún candidato solo si hubo algún problema con la instrucción (verifica promptFeedback) - Informa comentarios sobre cada candidato en finishReason y safetyRatings.

Campos

candidates[] object (Candidate)

Son las respuestas candidatas del modelo.

promptFeedback object (PromptFeedback)

Devuelve los comentarios de la instrucción relacionados con los filtros de contenido.

usageMetadata object (UsageMetadata)

Solo salida. Metadatos sobre el uso de tokens de las solicitudes de generación.

modelVersion string

Solo salida. La versión del modelo que se usó para generar la respuesta.

responseId string

Solo salida. responseId se usa para identificar cada respuesta.

modelStatus object (ModelStatus)

Solo salida. Es el estado actual de este modelo.

Representación JSON

Representación JSON
{ "candidates": [ { object (`Candidate`) } ], "promptFeedback": { object (`PromptFeedback`) }, "usageMetadata": { object (`UsageMetadata`) }, "modelVersion": string, "responseId": string, "modelStatus": { object (`ModelStatus`) } }

{
  "candidates": [
    {
      object (Candidate)
    }
  ],
  "promptFeedback": {
    object (PromptFeedback)
  },
  "usageMetadata": {
    object (UsageMetadata)
  },
  "modelVersion": string,
  "responseId": string,
  "modelStatus": {
    object (ModelStatus)
  }
}

PromptFeedback

Es un conjunto de metadatos de comentarios que especificó la instrucción en GenerateContentRequest.content.

Campos

blockReason enum (BlockReason)

Opcional. Si se establece, se bloqueó la instrucción y no se devuelven candidatos. Reformula la instrucción.

safetyRatings[] object (SafetyRating)

Calificaciones de seguridad de la instrucción. Hay, como máximo, una calificación por categoría.

Representación JSON
{ "blockReason": enum (`BlockReason`), "safetyRatings": [ { object (`SafetyRating`) } ] }

BlockReason

Especifica el motivo por el que se bloqueó la instrucción.

Enums
`BLOCK_REASON_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`SAFETY`	Se bloqueó la instrucción por motivos de seguridad. Inspecciona `safetyRatings` para comprender qué categoría de seguridad lo bloqueó.
`OTHER`	Se bloqueó la instrucción por motivos desconocidos.
`BLOCKLIST`	Se bloqueó la instrucción debido a los términos que se incluyen en la lista de términos bloqueados.
`PROHIBITED_CONTENT`	Se bloqueó la instrucción debido a contenido prohibido.
`IMAGE_SAFETY`	Se bloquearon los candidatos debido a contenido no seguro en la generación de imágenes.

UsageMetadata

Son los metadatos sobre el uso de tokens de la solicitud de generación.

Campos

promptTokenCount integer

Es la cantidad de tokens en la instrucción. Cuando se establece cachedContent, este sigue siendo el tamaño total efectivo de la instrucción, lo que significa que incluye la cantidad de tokens en el contenido almacenado en caché.

cachedContentTokenCount integer

Cantidad de tokens en la parte almacenada en caché de la instrucción (el contenido almacenado en caché)

candidatesTokenCount integer

Es la cantidad total de tokens en todos los candidatos de respuesta generados.

toolUsePromptTokenCount integer

Solo salida. Es la cantidad de tokens presentes en las instrucciones de uso de herramientas.

thoughtsTokenCount integer

Solo salida. Es la cantidad de tokens de pensamientos para los modelos de razonamiento.

totalTokenCount integer

Es el recuento total de tokens para la solicitud de generación (instrucción + instrucción de uso de herramientas + pensamientos + candidatos de respuesta).

promptTokensDetails[] object (ModalityTokenCount)

Solo salida. Es la lista de modalidades que se procesaron en la entrada de la solicitud.

cacheTokensDetails[] object (ModalityTokenCount)

Solo salida. Es la lista de modalidades del contenido almacenado en caché en la entrada de la solicitud.

candidatesTokensDetails[] object (ModalityTokenCount)

Solo salida. Es la lista de modalidades que se devolvieron en la respuesta.

toolUsePromptTokensDetails[] object (ModalityTokenCount)

Solo salida. Es la lista de modalidades que se procesaron para las entradas de solicitud de uso de herramientas.

serviceTier enum (ServiceTier)

Solo salida. Es el nivel de servicio de la solicitud.

Representación JSON

Representación JSON
{ "promptTokenCount": integer, "cachedContentTokenCount": integer, "candidatesTokenCount": integer, "toolUsePromptTokenCount": integer, "thoughtsTokenCount": integer, "totalTokenCount": integer, "promptTokensDetails": [ { object (`ModalityTokenCount`) } ], "cacheTokensDetails": [ { object (`ModalityTokenCount`) } ], "candidatesTokensDetails": [ { object (`ModalityTokenCount`) } ], "toolUsePromptTokensDetails": [ { object (`ModalityTokenCount`) } ], "serviceTier": enum (`ServiceTier`) }

{
  "promptTokenCount": integer,
  "cachedContentTokenCount": integer,
  "candidatesTokenCount": integer,
  "toolUsePromptTokenCount": integer,
  "thoughtsTokenCount": integer,
  "totalTokenCount": integer,
  "promptTokensDetails": [
    {
      object (ModalityTokenCount)
    }
  ],
  "cacheTokensDetails": [
    {
      object (ModalityTokenCount)
    }
  ],
  "candidatesTokensDetails": [
    {
      object (ModalityTokenCount)
    }
  ],
  "toolUsePromptTokensDetails": [
    {
      object (ModalityTokenCount)
    }
  ],
  "serviceTier": enum (ServiceTier)
}

ModelStatus

Es el estado del modelo subyacente. Se usa para indicar la etapa del modelo subyacente y el tiempo de retiro, si corresponde.

Campos

modelStage enum (ModelStage)

Es la etapa del modelo subyacente.

retirementTime string (Timestamp format)

Es la hora en la que se retirará el modelo.

Usa el formato RFC 3339, en el que el resultado generado siempre usará la normalización Z y los dígitos fraccionarios 0, 3, 6 o 9. También se aceptan otras compensaciones que no sean “Z”. Ejemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

message string

Es un mensaje en el que se explica el estado del modelo.

Representación JSON
{ "modelStage": enum (`ModelStage`), "retirementTime": string, "message": string }

ModelStage

Define la etapa del modelo subyacente.

Enums
`MODEL_STAGE_UNSPECIFIED`	Indica que no se especificó la etapa del modelo.
`UNSTABLE_EXPERIMENTAL`	El modelo subyacente está sujeto a muchos ajustes. Este elemento es obsoleto.
`EXPERIMENTAL`	Los modelos en esta etapa son solo para fines experimentales.
`PREVIEW`	Los modelos en esta etapa son más maduros que los modelos experimentales.
`STABLE`	Los modelos en esta etapa se consideran estables y listos para su uso en producción.
`LEGACY`	Si el modelo se encuentra en esta etapa, significa que está en proceso de quedar obsoleto en un futuro cercano. Solo los clientes existentes pueden usar este modelo.
`DEPRECATED`	Los modelos en esta etapa están obsoletos. No se pueden usar estos modelos. Este elemento es obsoleto.
`RETIRED`	Los modelos en esta etapa se retiran. No se pueden usar estos modelos.

Candidato

Representación JSON
FinishReason
GroundingAttribution
- Representación JSON
AttributionSourceId
- Representación JSON
GroundingPassageId
- Representación JSON
SemanticRetrieverChunk
- Representación JSON
GroundingMetadata
- Representación JSON
SearchEntryPoint
- Representación JSON
GroundingChunk
- Representación JSON
Web
- Representación JSON
Imagen
- Representación JSON
RetrievedContext
- Representación JSON
CustomMetadata
- Representación JSON
StringList
- Representación JSON
Maps
- Representación JSON
PlaceAnswerSources
- Representación JSON
ReviewSnippet
- Representación JSON
GroundingSupport
- Representación JSON
Segmento
- Representación JSON
RetrievalMetadata
- Representación JSON
LogprobsResult
- Representación JSON
TopCandidates
- Representación JSON
Candidato
- Representación JSON
UrlContextMetadata
- Representación JSON
UrlMetadata
- Representación JSON
UrlRetrievalStatus

Es un candidato de respuesta generado a partir del modelo.

Campos

content object (Content)

Solo salida. Es el contenido generado que devuelve el modelo.

finishReason enum (FinishReason)

Opcional. Solo salida. El motivo por el que el modelo dejó de generar tokens.

Si está vacío, el modelo no dejó de generar tokens.

safetyRatings[] object (SafetyRating)

Es la lista de calificaciones de seguridad de un candidato de respuesta.

Hay, como máximo, una calificación por categoría.

citationMetadata object (CitationMetadata)

Solo salida. Información de citas para el candidato generado por el modelo.

Este campo se puede propagar con información de recitación para cualquier texto incluido en content. Estos son pasajes que se "recitan" a partir de material protegido por derechos de autor en los datos de entrenamiento del LLM de base.

tokenCount integer

Solo salida. Es el recuento de tokens de este candidato.

groundingAttributions[] object (GroundingAttribution)

Solo salida. Es la información de atribución de las fuentes que contribuyeron a una respuesta fundamentada.

Este campo se propaga para las llamadas GenerateAnswer.

groundingMetadata object (GroundingMetadata)

Solo salida. Son los metadatos de fundamentación del candidato.

Este campo se propaga para las llamadas GenerateContent.

avgLogprobs number

Solo salida. Puntuación promedio de probabilidad logarítmica del candidato.

logprobsResult object (LogprobsResult)

Solo salida. Puntuaciones de log-verosimilitud para los tokens de respuesta y los tokens principales

urlContextMetadata object (UrlContextMetadata)

Solo salida. Son los metadatos relacionados con la herramienta de recuperación de contexto de URL.

continuationToken string (bytes format)

Un token de continuación opaco opcional que se devuelve cuando finishReason es CONTINUATION. Los clientes pueden pasar este token en un GenerateContentRequest posterior para continuar con la generación.

String codificada en base64.

index integer

Solo salida. Es el índice del candidato en la lista de candidatos de respuesta.

finishMessage string

Opcional. Solo salida. Detalla el motivo por el que el modelo dejó de generar tokens. Este campo solo se completa cuando se establece finishReason.

Representación JSON

Representación JSON
{ "content": { object (`Content`) }, "finishReason": enum (`FinishReason`), "safetyRatings": [ { object (`SafetyRating`) } ], "citationMetadata": { object (`CitationMetadata`) }, "tokenCount": integer, "groundingAttributions": [ { object (`GroundingAttribution`) } ], "groundingMetadata": { object (`GroundingMetadata`) }, "avgLogprobs": number, "logprobsResult": { object (`LogprobsResult`) }, "urlContextMetadata": { object (`UrlContextMetadata`) }, "continuationToken": string, "index": integer, "finishMessage": string }

{
  "content": {
    object (Content)
  },
  "finishReason": enum (FinishReason),
  "safetyRatings": [
    {
      object (SafetyRating)
    }
  ],
  "citationMetadata": {
    object (CitationMetadata)
  },
  "tokenCount": integer,
  "groundingAttributions": [
    {
      object (GroundingAttribution)
    }
  ],
  "groundingMetadata": {
    object (GroundingMetadata)
  },
  "avgLogprobs": number,
  "logprobsResult": {
    object (LogprobsResult)
  },
  "urlContextMetadata": {
    object (UrlContextMetadata)
  },
  "continuationToken": string,
  "index": integer,
  "finishMessage": string
}

FinishReason

Define el motivo por el que el modelo dejó de generar tokens.

Enums
`FINISH_REASON_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`STOP`	Punto de detención natural del modelo o secuencia de detención proporcionada.
`MAX_TOKENS`	Se alcanzó la cantidad máxima de tokens especificada en la solicitud.
`SAFETY`	El contenido de la respuesta candidata se marcó por motivos de seguridad.
`RECITATION`	El contenido de la respuesta candidata se marcó por motivos de recitación.
`LANGUAGE`	Se marcó el contenido de la respuesta candidata por usar un idioma no admitido.
`OTHER`	Motivo desconocido.
`BLOCKLIST`	La generación de tokens se detuvo porque el contenido incluye términos prohibidos.
`PROHIBITED_CONTENT`	Se detuvo la generación de tokens porque podría contener contenido prohibido.
`SPII`	La generación de tokens se detuvo porque el contenido podría incluir información de identificación personal sensible (IIPS).
`MALFORMED_FUNCTION_CALL`	La llamada a función que generó el modelo no es válida.
`IMAGE_SAFETY`	La generación de tokens se detuvo porque las imágenes generadas contienen incumplimientos de seguridad.
`IMAGE_PROHIBITED_CONTENT`	Se detuvo la generación de imágenes porque las imágenes creadas con tecnología generativa tienen otro contenido prohibido.
`IMAGE_OTHER`	La generación de imágenes se detuvo debido a otro problema diverso.
`NO_IMAGE`	Se esperaba que el modelo generara una imagen, pero no se generó ninguna.
`IMAGE_RECITATION`	Se detuvo la generación de imágenes debido a una recitación.
`UNEXPECTED_TOOL_CALL`	El modelo generó una llamada a una herramienta, pero no se habilitaron herramientas en la solicitud.
`TOO_MANY_TOOL_CALLS`	El modelo llamó a demasiadas herramientas de forma consecutiva, por lo que el sistema salió de la ejecución.
`MISSING_THOUGHT_SIGNATURE`	Falta al menos una firma de pensamiento en la solicitud.
`MALFORMED_RESPONSE`	Finalizó debido a una respuesta con errores de formato.
`ESCALATION`	La solicitud se filtró por una regla de derivación.
`PUP_LIMITED_DISABLED`	Indica que se detuvo la generación de tokens porque la cuenta de usuario está limitada o inhabilitada debido a incumplimientos de la Política de Uso Prohibido (PUP).
`CONTINUATION`	La generación de tokens se detuvo porque la respuesta alcanzó el límite de tokens por solicitud, pero la generación aún no se completó. La respuesta del modelo se puede continuar a través de una solicitud posterior con el `continuationToken` que se muestra. Ten en cuenta que el `maxOutputTokens` es acumulativo en los saltos de continuación y se debe aumentar o omitir de forma monótona.

GroundingAttribution

Atribución de una fuente que contribuyó a una respuesta.

Campos

sourceId object (AttributionSourceId)

Solo salida. Es el identificador de la fuente que contribuye a esta atribución.

content object (Content)

Contenido de la fuente de fundamentación que compone esta atribución.

Representación JSON
{ "sourceId": { object (`AttributionSourceId`) }, "content": { object (`Content`) } }

AttributionSourceId

Es el identificador de la fuente que contribuye a esta atribución.

Campos

source Union type

La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

groundingPassage object (GroundingPassageId)

Es el identificador de un pasaje intercalado.

semanticRetrieverChunk object (SemanticRetrieverChunk)

Es el identificador de un Chunk recuperado a través del recuperador semántico.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ // source "groundingPassage": { object (`GroundingPassageId`) }, "semanticRetrieverChunk": { object (`SemanticRetrieverChunk`) } // Union type }

GroundingPassageId

Es el identificador de una parte dentro de un GroundingPassage.

Campos

passageId string

Solo salida. Es el ID del pasaje que coincide con el GroundingPassage.id del GenerateAnswerRequest.

partIndex integer

Solo salida. Es el índice de la parte dentro del GroundingPassage.content de GenerateAnswerRequest.

Representación JSON
{ "passageId": string, "partIndex": integer }

SemanticRetrieverChunk

Identificador de un Chunk recuperado a través del recuperador semántico especificado en GenerateAnswerRequest con SemanticRetrieverConfig.

Campos

source string

Solo salida. Nombre de la fuente que coincide con el SemanticRetrieverConfig.source de la solicitud. Por ejemplo: corpora/123 o corpora/123/documents/abc

chunk string

Solo salida. Es el nombre del Chunk que contiene el texto atribuido. Ejemplo: corpora/123/documents/abc/chunks/xyz

Representación JSON
{ "source": string, "chunk": string }

GroundingMetadata

Son los metadatos que se devuelven al cliente cuando se habilita la fundamentación.

Campos

groundingChunks[] object (GroundingChunk)

Lista de referencias de respaldo recuperadas de la fuente de fundamentación especificada. Cuando se transmite, solo contiene los fragmentos de fundamentación que no se incluyeron en los metadatos de fundamentación de las respuestas anteriores.

groundingSupports[] object (GroundingSupport)

Lista de compatibilidad con la fundamentación.

webSearchQueries[] string

Consultas de búsqueda web para la búsqueda web de seguimiento.

imageSearchQueries[] string

Son las consultas de búsqueda con imágenes que se usan para la fundamentación.

searchEntryPoint object (SearchEntryPoint)

Opcional. Entrada de la Búsqueda de Google para las búsquedas web de seguimiento.

retrievalMetadata object (RetrievalMetadata)

Son los metadatos relacionados con la recuperación en el flujo de fundamentación.

googleMapsWidgetContextToken string

Opcional. Es el nombre del recurso del token de contexto del widget de Google Maps que se puede usar con el widget PlacesContextElement para renderizar datos contextuales. Solo se completa en caso de que esté habilitada la fundamentación con Google Maps.

Representación JSON

Representación JSON
{ "groundingChunks": [ { object (`GroundingChunk`) } ], "groundingSupports": [ { object (`GroundingSupport`) } ], "webSearchQueries": [ string ], "imageSearchQueries": [ string ], "searchEntryPoint": { object (`SearchEntryPoint`) }, "retrievalMetadata": { object (`RetrievalMetadata`) }, "googleMapsWidgetContextToken": string }

{
  "groundingChunks": [
    {
      object (GroundingChunk)
    }
  ],
  "groundingSupports": [
    {
      object (GroundingSupport)
    }
  ],
  "webSearchQueries": [
    string
  ],
  "imageSearchQueries": [
    string
  ],
  "searchEntryPoint": {
    object (SearchEntryPoint)
  },
  "retrievalMetadata": {
    object (RetrievalMetadata)
  },
  "googleMapsWidgetContextToken": string
}

SearchEntryPoint

Punto de entrada de la Búsqueda de Google.

Campos

renderedContent string

Opcional. Es un fragmento de contenido web que se puede incorporar en una página web o en una vista web de una app.

sdkBlob string (bytes format)

Opcional. Es un JSON codificado en Base64 que representa un array de tuplas <término de búsqueda, URL de búsqueda>.

String codificada en base64.

Representación JSON
{ "renderedContent": string, "sdkBlob": string }

GroundingChunk

Un GroundingChunk representa un segmento de evidencia de respaldo que fundamenta la respuesta del modelo. Puede ser un fragmento de la Web, un contexto recuperado de un archivo o información de Google Maps.

Campos

chunk_type Union type

Es el tipo de fragmento. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

web object (Web)

Fragmento de fundamentación de la Web.

image object (Image)

Opcional. Fragmento de fundamentación de la búsqueda de imágenes.

retrievedContext object (RetrievedContext)

Opcional. Es el fragmento de fundamentación del contexto que recuperó la herramienta de búsqueda de archivos.

maps object (Maps)

Opcional. Es el fragmento de fundamentación de Google Maps.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ // chunk_type "web": { object (`Web`) }, "image": { object (`Image`) }, "retrievedContext": { object (`RetrievedContext`) }, "maps": { object (`Maps`) } // Union type }

Web

Fragmento de la Web.

Campos

uri string

Solo salida. Referencia de URI del fragmento.

title string

Solo salida. Es el título del fragmento.

Representación JSON
{ "uri": string, "title": string }

Imagen

Fragmento de la búsqueda de imágenes.

Campos

sourceUri string

Es el URI de la página web para la atribución.

imageUri string

Es la URL del recurso de imagen.

title string

Es el título de la página web de la que proviene la imagen.

domain string

Es el dominio raíz de la página web de la que proviene la imagen, p.ej., "example.com".

Representación JSON
{ "sourceUri": string, "imageUri": string, "title": string, "domain": string }

RetrievedContext

Es el fragmento del contexto que recuperó la herramienta de búsqueda de archivos.

Campos

customMetadata[] object (CustomMetadata)

Opcional. Son los metadatos proporcionados por el usuario sobre el contexto recuperado.

uri string

Opcional. Es la referencia de URI del documento de recuperación semántica.

title string

Opcional. Es el título del documento.

text string

Opcional. Texto del fragmento.

fileSearchStore string

Opcional. Nombre del FileSearchStore que contiene el documento. Ejemplo: fileSearchStores/123

pageNumber integer

Opcional. Es el número de página del contexto recuperado, si corresponde.

mediaId string

Opcional. Es el nombre del recurso de BLOB de contenido multimedia para los resultados de la búsqueda de archivos multimodales. Formato: fileSearchStores/{file_search_store_id}/media/{blobId}

Representación JSON
{ "customMetadata": [ { object (`CustomMetadata`) } ], "uri": string, "title": string, "text": string, "fileSearchStore": string, "pageNumber": integer, "mediaId": string }

CustomMetadata

Metadatos proporcionados por el usuario sobre el GroundingFact.

Campos

key string

La clave de los metadatos.

value Union type

Es el valor de los metadatos. Puede ser una cadena, una lista de cadenas o un número. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

stringValue string

Opcional. Es el valor de cadena de los metadatos.

stringListValue object (StringList)

Opcional. Es una lista de valores de cadena para los metadatos.

numericValue number

Opcional. Es el valor numérico de los metadatos. El rango esperado para este valor depende del key específico que se use.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ "key": string, // value "stringValue": string, "stringListValue": { object (`StringList`) }, "numericValue": number // Union type }

StringList

Es una lista de valores de cadena.

Campos

values[] string

Son los valores de cadena de la lista.

Representación JSON
{ "values": [ string ] }

Maps

Un fragmento de fundamentación de Google Maps. Un fragmento de Maps corresponde a un solo lugar.

Campos

uri string

Es la referencia de URI del lugar.

title string

Es el título del lugar.

text string

Es la descripción de texto de la respuesta del lugar.

placeId string

Es el ID del lugar, en formato places/{placeId}. Un usuario puede usar este ID para buscar ese lugar.

placeAnswerSources object (PlaceAnswerSources)

Son fuentes que proporcionan respuestas sobre las características de un lugar determinado en Google Maps.

Representación JSON
{ "uri": string, "title": string, "text": string, "placeId": string, "placeAnswerSources": { object (`PlaceAnswerSources`) } }

PlaceAnswerSources

Es una colección de fuentes que proporcionan respuestas sobre las características de un lugar determinado en Google Maps. Cada mensaje de PlaceAnswerSources corresponde a un lugar específico en Google Maps. La herramienta de Google Maps usó estas fuentes para responder preguntas sobre las características del lugar (p. ej., "¿el Bar Foo tiene Wi-Fi?" o "¿Foo Bar es accesible para personas en silla de ruedas?"). Actualmente, solo admitimos fragmentos de opiniones como fuentes.

Campos

reviewSnippets[] object (ReviewSnippet)

Son fragmentos de opiniones que se usan para generar respuestas sobre las características de un lugar determinado en Google Maps.

Representación JSON
{ "reviewSnippets": [ { object (`ReviewSnippet`) } ] }

ReviewSnippet

Encapsula un fragmento de una opinión de un usuario que responde una pregunta sobre las características de un lugar específico en Google Maps.

Campos

reviewId string

Es el ID del fragmento de opinión.

googleMapsUri string

Es un vínculo que corresponde a la opinión del usuario en Google Maps.

title string

Es el título de la opinión.

Representación JSON
{ "reviewId": string, "googleMapsUri": string, "title": string }

GroundingSupport

Asistencia para la fundamentación.

Campos

groundingChunkIndices[] integer

Opcional. Es una lista de índices (en "grounding_chunk" en response.candidate.grounding_metadata) que especifica las citas asociadas con la afirmación. Por ejemplo, [1,3,4] significa que grounding_chunk[1], grounding_chunk[3] y grounding_chunk[4] son el contenido recuperado que se atribuye a la afirmación. Si la respuesta es de transmisión, los groundingChunkIndices se refieren a los índices de todas las respuestas. Es responsabilidad del cliente acumular los fragmentos de fundamentación de todas las respuestas (manteniendo el mismo orden).

confidenceScores[] number

Opcional. Es la puntuación de confianza de las referencias de respaldo. Varía entre 0 y 1. 1 es el más confiable. Esta lista debe tener el mismo tamaño que groundingChunkIndices.

renderedParts[] integer

Solo salida. Índices en el campo parts del contenido del candidato. Estos índices especifican qué partes renderizadas están asociadas con esta fuente de respaldo.

segment object (Segment)

Es el segmento del contenido al que pertenece esta asistencia.

Representación JSON
{ "groundingChunkIndices": [ integer ], "confidenceScores": [ number ], "renderedParts": [ integer ], "segment": { object (`Segment`) } }

Segmentar

Es el segmento del contenido.

Campos

partIndex integer

Es el índice de un objeto Part dentro de su objeto Content superior.

startIndex integer

Es el índice de inicio en la parte determinada, medido en bytes. Es el desplazamiento desde el inicio de la parte, inclusive, que comienza en cero.

endIndex integer

Es el índice final en la parte determinada, medido en bytes. Es el desplazamiento desde el inicio de la parte, exclusivo, que comienza en cero.

text string

Es el texto correspondiente al segmento de la respuesta.

Representación JSON
{ "partIndex": integer, "startIndex": integer, "endIndex": integer, "text": string }

RetrievalMetadata

Son los metadatos relacionados con la recuperación en el flujo de fundamentación.

Campos

googleSearchDynamicRetrievalScore number

Opcional. Es la puntuación que indica la probabilidad de que la información de la Búsqueda de Google pueda ayudar a responder la instrucción. La puntuación se encuentra en el rango [0, 1], en el que 0 es el menos probable y 1 es el más probable. Esta puntuación solo se completa cuando se habilitan la fundamentación de la Búsqueda de Google y la recuperación dinámica. Se comparará con el umbral para determinar si se debe activar la Búsqueda de Google.

Representación JSON
{ "googleSearchDynamicRetrievalScore": number }

LogprobsResult

Resultado de Logprobs

Campos

topCandidates[] object (TopCandidates)

Longitud = cantidad total de pasos de decodificación.

chosenCandidates[] object (Candidate)

Longitud = cantidad total de pasos de decodificación. Los candidatos elegidos pueden o no estar en topCandidates.

logProbabilitySum number

Suma de las probabilidades de registro de todos los tokens.

Representación JSON
{ "topCandidates": [ { object (`TopCandidates`) } ], "chosenCandidates": [ { object (`Candidate`) } ], "logProbabilitySum": number }

TopCandidates

Son los candidatos con las probabilidades de registro más altas en cada paso de decodificación.

Campos

candidates[] object (Candidate)

Se ordenan por probabilidad de registro en orden descendente.

Representación JSON
{ "candidates": [ { object (`Candidate`) } ] }

Candidato

Es el candidato para el token y la puntuación de logprobs.

Campos

token string

Es el valor de la cadena de token del candidato.

tokenId integer

Es el valor del ID del token del candidato.

logProbability number

Es la probabilidad logarítmica del candidato.

Representación JSON
{ "token": string, "tokenId": integer, "logProbability": number }

UrlContextMetadata

Son los metadatos relacionados con la herramienta de recuperación de contexto de URL.

Campos

urlMetadata[] object (UrlMetadata)

Es la lista de contextos de URL.

Representación JSON
{ "urlMetadata": [ { object (`UrlMetadata`) } ] }

UrlMetadata

Contexto de la recuperación de una sola URL.

Campos

retrievedUrl string

Es la URL que recuperó la herramienta.

urlRetrievalStatus enum (UrlRetrievalStatus)

Es el estado de la recuperación de la URL.

Representación JSON
{ "retrievedUrl": string, "urlRetrievalStatus": enum (`UrlRetrievalStatus`) }

UrlRetrievalStatus

Es el estado de la recuperación de la URL.

Enums
`URL_RETRIEVAL_STATUS_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`URL_RETRIEVAL_STATUS_SUCCESS`	La recuperación de la URL se realizó correctamente.
`URL_RETRIEVAL_STATUS_ERROR`	No se pudo recuperar la URL debido a un error.
`URL_RETRIEVAL_STATUS_PAYWALL`	No se pudo recuperar la URL porque el contenido está protegido por un muro de pago.
`URL_RETRIEVAL_STATUS_UNSAFE`	No se pudo recuperar la URL porque el contenido no es seguro.

CitationMetadata

Representación JSON
CitationSource
- Representación JSON

Es una colección de atribuciones de fuentes para un contenido.

Campos

citationSources[] object (CitationSource)

Citas de fuentes para una respuesta específica.

Representación JSON
{ "citationSources": [ { object (`CitationSource`) } ] }

CitationSource

Una cita de una fuente para una parte de una respuesta específica.

Campos

startIndex integer

Opcional. Es el inicio del segmento de la respuesta que se atribuye a esta fuente.

El índice indica el inicio del segmento, medido en bytes.

endIndex integer

Opcional. Es el final del segmento atribuido, exclusivo.

uri string

Opcional. Es el URI que se atribuye como fuente de una parte del texto.

license string

Opcional. Es la licencia del proyecto de GitHub que se atribuye como fuente del segmento.

La información de la licencia es obligatoria para las citas de código.

Representación JSON
{ "startIndex": integer, "endIndex": integer, "uri": string, "license": string }

HarmCategory

Es la categoría de una clasificación.

Estas categorías abarcan varios tipos de daños que los desarrolladores pueden querer ajustar.

Enums
`HARM_CATEGORY_UNSPECIFIED`	No se especifica la categoría.
`HARM_CATEGORY_DEROGATORY`	PaLM: Comentarios negativos o dañinos que se orientan a la identidad o los atributos protegidos. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_TOXICITY`	PaLM: Contenido obsceno, grosero o irrespetuoso. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_VIOLENCE`	PaLM: Describe situaciones que representen violencia contra una persona o un grupo, o descripciones generales de imágenes sangrientas. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_SEXUAL`	PaLM: Incluye referencias a actos sexuales o a otro contenido obsceno. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_MEDICAL`	PaLM: Promueve consejos médicos no verificados. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_DANGEROUS`	PaLM: Contenido peligroso que promueve, facilita o fomenta actividades perjudiciales. OBSOLETO: Categoría solo para PaLM, no compatible con los modelos de Gemini. Este elemento es obsoleto.
`HARM_CATEGORY_HARASSMENT`	Gemini: Contenido de hostigamiento
`HARM_CATEGORY_HATE_SPEECH`	Gemini: Incitación al odio o a la violencia y contenido relacionado.
`HARM_CATEGORY_SEXUALLY_EXPLICIT`	Gemini: Contenido sexual explícito.
`HARM_CATEGORY_DANGEROUS_CONTENT`	Gemini: Contenido peligroso
`HARM_CATEGORY_CIVIC_INTEGRITY`	Gemini: Contenido que se puede usar para dañar la integridad cívica. OBSOLETO: En su lugar, usa enableEnhancedCivicAnswers. Este elemento es obsoleto.
`HARM_CATEGORY_JAILBREAK`	Gemini: Instrucciones que intentan eludir o subvertir las normas de seguridad del modelo (intentos de jailbreak).

ModalityTokenCount

Representación JSON
Modalidad

Representa la información de recuento de tokens para una sola modalidad.

Campos

modality enum (Modality)

Es la modalidad asociada con este recuento de tokens.

tokenCount integer

Cantidad de tokens.

Representación JSON
{ "modality": enum (`Modality`), "tokenCount": integer }

Modalidad

Modalidad de Content Part

Enums
`MODALITY_UNSPECIFIED`	Modalidad sin especificar.
`TEXT`	Texto sin formato
`IMAGE`	Imagen.
`VIDEO`	Video.
`AUDIO`	Audio.
`DOCUMENT`	Documento, p.ej., PDF.

SafetyRating

Representación JSON
HarmProbability

Es la clasificación de seguridad de un contenido.

La calificación de seguridad contiene la categoría de daño y el nivel de probabilidad de daño en esa categoría para un fragmento de contenido. El contenido se clasifica por seguridad en varias categorías de daño, y aquí se incluye la probabilidad de la clasificación del daño.

Campos

category enum (HarmCategory)

Obligatorio. Es la categoría de esta calificación.

probability enum (HarmProbability)

Obligatorio. La probabilidad de daño de este contenido.

blocked boolean

¿Se bloqueó este contenido debido a esta clasificación?

Representación JSON
{ "category": enum (`HarmCategory`), "probability": enum (`HarmProbability`), "blocked": boolean }

HarmProbability

La probabilidad de que un fragmento de contenido sea dañino.

El sistema de clasificación indica la probabilidad de que el contenido no sea seguro. Esto no indica la gravedad del daño de un contenido.

Enums
`HARM_PROBABILITY_UNSPECIFIED`	La probabilidad no se especifica.
`NEGLIGIBLE`	El contenido tiene una probabilidad insignificante de no ser seguro.
`LOW`	El contenido tiene pocas probabilidades de no ser seguro.
`MEDIUM`	El contenido tiene una probabilidad media de no ser seguro.
`HIGH`	El contenido tiene una alta probabilidad de no ser seguro.

SafetySetting

Representación JSON
HarmBlockThreshold

Es el parámetro de configuración de seguridad que afecta el comportamiento de bloqueo de seguridad.

Pasar un parámetro de configuración de seguridad para una categoría cambia la probabilidad permitida de que se bloquee el contenido.

Campos

category enum (HarmCategory)

Obligatorio. Es la categoría de este parámetro de configuración.

threshold enum (HarmBlockThreshold)

Obligatorio. Controla el umbral de probabilidad en el que se bloquea el daño.

Representación JSON
{ "category": enum (`HarmCategory`), "threshold": enum (`HarmBlockThreshold`) }

HarmBlockThreshold

Bloquea el contenido a partir de una probabilidad de daño especificada.

Enums
`HARM_BLOCK_THRESHOLD_UNSPECIFIED`	No se especifica el umbral.
`BLOCK_LOW_AND_ABOVE`	Se permitirá el contenido con la clasificación NEGLIGIBLE.
`BLOCK_MEDIUM_AND_ABOVE`	Se permitirá el contenido con las etiquetas INSIGNIFICANTE y BAJO.
`BLOCK_ONLY_HIGH`	Se permitirá el contenido con las etiquetas NEGLIGIBLE, LOW y MEDIUM.
`BLOCK_NONE`	Se permitirá todo el contenido.
`OFF`	Desactiva el filtro de seguridad.

ServiceTier

Es el nivel de servicio de la solicitud.

Enums
`unspecified`	Es el nivel de servicio predeterminado, que es estándar.
`standard`	Nivel de servicio estándar.
`flex`	Nivel de servicio Flex.
`priority`	Nivel de servicio prioritario

Contenido

Es el tipo de datos estructurados base que incluye contenido de varias partes de un mensaje.

Un Content incluye un campo role que designa al productor del Content y un campo parts que contiene datos de varias partes que incluyen el contenido del turno del mensaje.

Campos

parts[] object (Part)

Parts ordenados que constituyen un solo mensaje. Las partes pueden tener diferentes tipos de MIME.

role string

Opcional. Es el productor del contenido. Debe ser "user" o "model".

Es útil para configurar conversaciones de varios turnos; de lo contrario, se puede dejar en blanco o sin configurar.

Representación JSON
{ "parts": [ { object (`Part`) } ], "role": string }

Pieza

Un tipo de datos que contiene contenido multimedia que forma parte de un mensaje Content de varias partes.

Un Part consta de datos que tienen un tipo de datos asociado. Un Part solo puede contener uno de los tipos aceptados en Part.data.

Un Part debe tener un tipo de MIME de IANA fijo que identifique el tipo y el subtipo del contenido multimedia si el campo inlineData se completa con bytes sin procesar.

Campos

thought boolean

Opcional. Indica si la parte es un pensamiento del modelo.

thoughtSignature string (bytes format)

Opcional. Es una firma opaca para el pensamiento, de modo que se pueda reutilizar en solicitudes posteriores.

String codificada en base64.

partMetadata object (Struct format)

Son los metadatos personalizados asociados con la parte. Es posible que los agentes que usan genai.Part como representación de contenido deban hacer un seguimiento de la información adicional. Por ejemplo, puede ser el nombre de un archivo o una fuente de donde se origina la parte, o una forma de multiplexar varios flujos de partes.

mediaResolution object (MediaResolution)

Opcional. Es la resolución del contenido multimedia de entrada.

mediaProcessing enum (MediaProcessing)

Opcional. Cómo el modelo procesa el contenido multimedia de esta parte para comprenderlo. Solo es significativo para las partes de video (inlineData o fileData con MIME de video). Las partes que no son de video ignoran este campo.

audioTranscription object (AudioTranscription)

Opcional. Transcripción de audio (entrada o salida). Esto solo se establece cuando esta parte contiene datos de audio.

speechMetadata object (SpeechMetadata)

Opcional. Son metadatos que se aplican a partes de texto para personalizar cómo se deben pronunciar o sintetizar, como especificar la identidad del interlocutor o el estilo de habla.

data Union type

La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

text string

Texto intercalado.

inlineData object (Blob)

Bytes de contenido multimedia intercalados.

functionCall object (FunctionCall)

Un FunctionCall predicho que muestra el modelo que contiene una cadena que representa el FunctionDeclaration.name con los argumentos y sus valores.

functionResponse object (FunctionResponse)

La salida del resultado de una FunctionCall que contiene una cadena que representa el FunctionDeclaration.name y un objeto JSON estructurado que contiene cualquier resultado de la función se usa como contexto para el modelo.

fileData object (FileData)

Datos basados en URI.

executableCode object (ExecutableCode)

Es el código generado por el modelo que se debe ejecutar.

codeExecutionResult object (CodeExecutionResult)

Es el resultado de ejecutar ExecutableCode.

toolCall object (ToolCall)

Llamada a herramienta del servidor. Este campo se completa cuando el modelo predice una invocación de herramienta que se debe ejecutar en el servidor. Se espera que el cliente devuelva este mensaje a la API.

toolResponse object (ToolResponse)

Es el resultado de una ejecución de ToolCall del servidor. El cliente completa este campo con los resultados de la ejecución del ToolCall correspondiente.

Fin de los campos mutuamente excluyentes.

metadata Union type

Controla el procesamiento previo adicional de los datos. Establece este parámetro cuando inline_data o file_data estén presentes para configurar el procesamiento previo de medios estáticos por parte. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

videoMetadata object (VideoMetadata)

Opcional. Metadatos del video. Los metadatos solo se deben especificar mientras los datos de video se presentan en inlineData o fileData.

Fin de los campos mutuamente excluyentes.

Representación JSON

Representación JSON
{ "thought": boolean, "thoughtSignature": string, "partMetadata": { object }, "mediaResolution": { object (`MediaResolution`) }, "mediaProcessing": enum (`MediaProcessing`), "audioTranscription": { object (`AudioTranscription`) }, "speechMetadata": { object (`SpeechMetadata`) }, // data "text": string, "inlineData": { object (`Blob`) }, "functionCall": { object (`FunctionCall`) }, "functionResponse": { object (`FunctionResponse`) }, "fileData": { object (`FileData`) }, "executableCode": { object (`ExecutableCode`) }, "codeExecutionResult": { object (`CodeExecutionResult`) }, "toolCall": { object (`ToolCall`) }, "toolResponse": { object (`ToolResponse`) } // Union type // metadata "videoMetadata": { object (`VideoMetadata`) } // Union type }

{
  "thought": boolean,
  "thoughtSignature": string,
  "partMetadata": {
    object
  },
  "mediaResolution": {
    object (MediaResolution)
  },
  "mediaProcessing": enum (MediaProcessing),
  "audioTranscription": {
    object (AudioTranscription)
  },
  "speechMetadata": {
    object (SpeechMetadata)
  },

  // data
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  },
  "toolCall": {
    object (ToolCall)
  },
  "toolResponse": {
    object (ToolResponse)
  }
  // Union type

  // metadata
  "videoMetadata": {
    object (VideoMetadata)
  }
  // Union type
}

BLOB

Bytes de contenido multimedia sin procesar.

El texto no se debe enviar como bytes sin procesar. Usa el campo "text".

Campos

mimeType string

Es el tipo de MIME estándar de IANA de los datos de origen. Ejemplos de tipos admitidos: - Imágenes: image/png, image/jpeg, image/jpg, image/webp, image/heic, image/heif, image/gif, image/avif - Audio: audio/*, video/audio/s16le, video/audio/wav - Video: video/* - Texto: text/plain, text/html, text/css, text/javascript, text/x-typescript, text/csv, text/markdown, text/x-python, text/xml, text/rtf, video/text/timestamp - Aplicaciones: application/x-javascript, application/x-typescript, application/x-python-code, application/json, application/x-ipynb+json, application/rtf, application/pdf Para obtener más contexto, consulta Formatos de archivo admitidos. //

data string (bytes format)

Bytes sin procesar para formatos multimedia.

String codificada en base64.

displayName string

Opcional. Especifica el nombre que se usa para hacer referencia a este BLOB en el modelo (p.ej., "my_blob.png"). Se usa como identificador de referencia del BLOB cuando verbalizationMode se establece en REFERENCE_ONLY.

Representación JSON
{ "mimeType": string, "data": string, "displayName": string }

FunctionCall

Un FunctionCall predicho que muestra el modelo que contiene una cadena que representa el FunctionDeclaration.name con los argumentos y sus valores.

Campos

id string

Opcional. Es el identificador único de la llamada a función. Si se completa, el cliente ejecutará el functionCall y devolverá la respuesta con el id coincidente.

name string

Obligatorio. El nombre de la función a la que se llamará. Debe tener caracteres de la A a la Z (mayúsculas o minúsculas), o números del 0 al 9, o contener guiones bajos y guiones, con una longitud máxima de 128.

args object (Struct format)

Opcional. Los parámetros y valores de la función en formato de objeto JSON

Representación JSON
{ "id": string, "name": string, "args": { object } }

FunctionResponse

El resultado de una FunctionCall que contiene una cadena que representa el FunctionDeclaration.name y un objeto JSON estructurado que contiene cualquier resultado de la función se usa como contexto para el modelo. Esto debería contener el resultado de un FunctionCall basado en la predicción del modelo.

Campos

id string

Opcional. Es el identificador de la llamada a función para la que se genera esta respuesta. El cliente lo propaga para que coincida con la llamada a función id correspondiente.

name string

response object (Struct format)

Obligatorio. La respuesta de la función en formato de objeto JSON. Los emisores pueden usar cualquier clave que elijan que se ajuste a la sintaxis de la función para devolver el resultado de la función, p.ej., "output", "result", etc. En particular, si la llamada a función no se ejecutó, la respuesta puede tener una clave "error" para devolver detalles del error al modelo.

Se puede incluir contenido multimedia con un subobjeto que contenga una sola clave "$ref" cuyo valor sea el inlineData.display_name de un FunctionResponsePart que contenga el contenido multimedia. Consulta https://ai.google.dev/gemini-api/docs/function-calling#multimodal.

parts[] object (FunctionResponsePart)

Opcional. Es el objeto Parts ordenado que constituye una respuesta de función. Es posible que las diferentes partes tengan distintos tipos de MIME de IANA.

willContinue boolean

Opcional. Indica que la llamada a función continúa y que se devolverán más respuestas, lo que convierte la llamada a función en un generador. Solo se aplica a las llamadas a funciones NON_BLOCKING; de lo contrario, se ignora. Si se establece como falso, no se considerarán las respuestas futuras. Se permite devolver un response vacío con willContinue=False para indicar que finalizó la llamada a función. Esto puede activar la generación del modelo. Para evitar que se active la generación y finalizar la llamada a función, también establece scheduling en SILENT.

scheduling enum (Scheduling)

Opcional. Especifica cómo se debe programar la respuesta en la conversación. Solo se aplica a las llamadas a funciones NON_BLOCKING; de lo contrario, se ignora. La configuración predeterminada es WHEN_IDLE.

Representación JSON
{ "id": string, "name": string, "response": { object }, "parts": [ { object (`FunctionResponsePart`) } ], "willContinue": boolean, "scheduling": enum (`Scheduling`) }

FunctionResponsePart

Un tipo de datos que contiene contenido multimedia que forma parte de un mensaje FunctionResponse.

Un FunctionResponsePart consta de datos que tienen un tipo de datos asociado. Un FunctionResponsePart solo puede contener uno de los tipos aceptados en FunctionResponsePart.data.

Un FunctionResponsePart debe tener un tipo de MIME de IANA fijo que identifique el tipo y el subtipo del contenido multimedia si el campo inlineData se completa con bytes sin procesar.

Campos

data Union type

Son los datos de la parte de la respuesta de la función. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

inlineData object (FunctionResponseBlob)

Bytes de contenido multimedia intercalados.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ // data "inlineData": { object (`FunctionResponseBlob`) } // Union type }

FunctionResponseBlob

Son los bytes de contenido multimedia sin procesar para la respuesta de la función.

El texto no se debe enviar como bytes sin procesar. Usa el campo "FunctionResponse.response".

Campos

mimeType string

Es el tipo de MIME estándar de IANA de los datos de origen. Ejemplos: - image/png - image/jpeg Si se proporciona un tipo de MIME no admitido, se devolverá un error. Para obtener una lista completa de los tipos admitidos, consulta Formatos de archivo admitidos.

data string (bytes format)

Bytes sin procesar para formatos multimedia.

String codificada en base64.

Representación JSON
{ "mimeType": string, "data": string }

Programación

Especifica cómo se debe programar la respuesta en la conversación.

Enums
`SCHEDULING_UNSPECIFIED`	Este valor no se usa.
`SILENT`	Solo agrega el resultado al contexto de la conversación, no interrumpas ni actives la generación.
`WHEN_IDLE`	Agrega el resultado al contexto de la conversación y solicita que se genere el resultado sin interrumpir la generación en curso.
`INTERRUPT`	Agrega el resultado al contexto de la conversación, interrumpe la generación en curso y solicita que se genere el resultado.

FileData

Datos basados en URI.

Campos

mimeType string

Opcional. Es el tipo de MIME estándar de IANA de los datos de origen.

fileUri string

Obligatorio. URI.

displayName string

Opcional. Especifica el nombre que se usa para hacer referencia a este archivo en el modelo (p.ej., "my_file.pdf"). Se usa como identificador de referencia de archivo cuando verbalizationMode se establece en REFERENCE_ONLY.

Representación JSON


{
  "mimeType": string,
  "fileUri": string,
  "displayName": string
}

ExecutableCode

Es el código que genera el modelo y que se debe ejecutar, y el resultado que se devuelve al modelo.

Solo se genera cuando se usa la herramienta CodeExecution, en la que el código se ejecutará automáticamente y también se generará un CodeExecutionResult correspondiente.

Campos

id string

Opcional. Es el identificador único de la parte de ExecutableCode. El servidor devuelve el CodeExecutionResult con el id coincidente.

language enum (Language)

Obligatorio. Es el lenguaje de programación de code.

code string

Obligatorio. Es el código que se ejecutará.

Representación JSON
{ "id": string, "language": enum (`Language`), "code": string }

Idioma

Lenguajes de programación admitidos para el código generado.

Enums
`LANGUAGE_UNSPECIFIED`	Idioma no especificado. No se debe usar este valor.
`PYTHON`	Python >= 3.10, con numpy y simpy disponibles. Python es el lenguaje predeterminado.

CodeExecutionResult

Es el resultado de ejecutar ExecutableCode.

Se genera solo cuando se usa la herramienta CodeExecution.

Campos

id string

Opcional. Es el identificador de la parte de ExecutableCode a la que corresponde este resultado. Solo se completa si el ExecutableCode correspondiente tiene un ID.

outcome enum (Outcome)

Obligatorio. Es el resultado de la ejecución del código.

output string

Opcional. Contiene stdout cuando la ejecución de código se realiza correctamente; de lo contrario, contiene stderr o alguna otra descripción.

Representación JSON
{ "id": string, "outcome": enum (`Outcome`), "output": string }

Resultado

Es la enumeración de los posibles resultados de la ejecución del código.

Enums
`OUTCOME_UNSPECIFIED`	Indica que no se especificó el estado. No se debe usar este valor.
`OUTCOME_OK`	La ejecución de código se completó correctamente. `output` contiene el stdout, si lo hay.
`OUTCOME_FAILED`	Error en la ejecución de código. `output` contiene stderr y stdout, si los hay.
`OUTCOME_DEADLINE_EXCEEDED`	La ejecución de código se ejecutó durante demasiado tiempo y se canceló. Puede haber o no un `output` parcial presente.

ToolCall

Un ToolCall previsto del servidor que devuelve el modelo. Este mensaje contiene información sobre una herramienta que el modelo desea invocar. NO se espera que el cliente ejecute este ToolCall. En su lugar, el cliente debe pasar este ToolCall de vuelta a la API en un turno posterior dentro de un mensaje Content, junto con el ToolResponse correspondiente.

Campos

id string

Opcional. Es el identificador único de la llamada a la herramienta. El servidor devuelve la respuesta de la herramienta con el id coincidente.

toolName string

Opcional. Es el nombre de la herramienta a la que se llamó.

toolType enum (ToolType)

Obligatorio. Es el tipo de herramienta a la que se llamó.

args object (Struct format)

Opcional. Son los argumentos de la llamada a la herramienta. Ejemplo: {"arg1" : "value1", "arg2" : "value2" , ...}

Representación JSON
{ "id": string, "toolName": string, "toolType": enum (`ToolType`), "args": { object } }

ToolType

Es el tipo de herramienta en la llamada a función.

Enums
`TOOL_TYPE_UNSPECIFIED`	Tipo de herramienta no especificado.
`GOOGLE_SEARCH_WEB`	Herramienta de Búsqueda de Google, se asigna a Tool.google_search.search_types.web_search.
`GOOGLE_SEARCH_IMAGE`	Herramienta de búsqueda de imágenes, se asigna a Tool.google_search.search_types.image_search.
`URL_CONTEXT`	Herramienta de contexto de URL, se asigna a Tool.url_context.
`GOOGLE_MAPS`	La herramienta de Google Maps se asigna a Tool.google_maps.
`FILE_SEARCH`	Herramienta de búsqueda de archivos, se asigna a Tool.file_search.

ToolResponse

Es el resultado de una ejecución de ToolCall del servidor. Este mensaje contiene los resultados de una invocación de herramienta que inició un ToolCall del modelo. El cliente debe pasar este ToolResponse de vuelta a la API en un turno posterior dentro de un mensaje Content, junto con el ToolCall correspondiente.

Campos

id string

Opcional. Es el identificador de la llamada a la herramienta para la que se genera esta respuesta.

toolType enum (ToolType)

Obligatorio. Es el tipo de herramienta a la que se llamó, que coincide con el toolType en el ToolCall correspondiente.

response object (Struct format)

Opcional. La respuesta de la herramienta.

Representación JSON
{ "id": string, "toolType": enum (`ToolType`), "response": { object } }

VideoMetadata

Los metadatos describen el contenido del video de entrada. Establece este parámetro en Part.video_metadata o FunctionResponsePart.video_metadata cuando inlineData o fileData contengan video para configurar el procesamiento previo estático del video (como el recorte de tiempo, la velocidad de fotogramas, el recuento máximo de fotogramas o las capas de contenido extraídas).

Campos

startOffset string (Duration format)

Opcional. El desplazamiento inicial del video.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

endOffset string (Duration format)

Opcional. El desplazamiento final del video.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

fps number

Opcional. Es la velocidad de fotogramas del video que se envía al modelo. Si no se especifica, el valor predeterminado será 1.0. El rango de FPS es (0.0, 24.0].

Representación JSON
{ "startOffset": string, "endOffset": string, "fps": number }

MediaResolution

Es la resolución de contenido multimedia para la asignación de token.

Campos

value Union type

Es el nivel de resolución de contenido multimedia. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

level enum (Level)

Es la calidad de asignación de token que se usa para el contenido multimedia determinado. para obtener asistencia con la API de Gemini.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ // value "level": enum (`Level`) // Union type }

Nivel

Es el nivel de resolución de contenido multimedia.

Enums
`MEDIA_RESOLUTION_UNSPECIFIED`	No se estableció la resolución de contenido multimedia.
`MEDIA_RESOLUTION_LOW`	La resolución de contenido multimedia se estableció en baja.
`MEDIA_RESOLUTION_MEDIUM`	Se estableció la resolución de contenido multimedia en media.
`MEDIA_RESOLUTION_HIGH`	Se estableció la resolución de contenido multimedia en alta.
`MEDIA_RESOLUTION_ULTRA_HIGH`	Se estableció la resolución de contenido multimedia en ultraalta.

MediaProcessing

Cómo el modelo procesa el contenido multimedia de entrada para comprenderlo.

Enums
`MEDIA_PROCESSING_UNSPECIFIED`	La configuración predeterminada es el procesamiento específico del modelo.
`STATIC`	Extracción de fotogramas con tarifa fija. Todos los fotogramas colocados en contexto.
`AGENTIC`	Navegación dinámica basada en modelos Se recomienda para la mayoría de los casos de uso.

AudioTranscription

Es la transcripción de una parte de audio. En el caso del audio con varios interlocutores, cada segmento de interlocutor es una Part independiente con su propia AudioTranscription que lleva la speakerLabel.

Campos

text string

Obligatorio. Es el texto de la transcripción de este segmento de audio.

speakerLabel string

Opcional. Es una etiqueta que identifica al interlocutor de este segmento de audio (p.ej., "spk_1", "spk_2"). Está presente cuando se establece la identificación de interlocutores.

words[] object (WordInfo)

Opcional. Transcripciones detalladas a nivel de palabra y detalles de tiempo. Está presente cuando se establece wordTimestamp.

Representación JSON
{ "text": string, "speakerLabel": string, "words": [ { object (`WordInfo`) } ] }

WordInfo

Información sobre una sola palabra reconocida.

Campos

word string

Obligatorio. Transcripción de la palabra.

startOffset string (Duration format)

Opcional. Es el desplazamiento inicial en el tiempo de la palabra en relación con el inicio del audio.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

endOffset string (Duration format)

Opcional. Es el desplazamiento final en el tiempo de la palabra en relación con el inicio del audio.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

Representación JSON
{ "word": string, "startOffset": string, "endOffset": string }

SpeechMetadata

Son los metadatos de voz para las partes de text.

Campos

speaker string

Opcional. Nombre opcional del interlocutor para la síntesis de varios interlocutores.

style string

Opcional. Instrucción de estilo opcional para la síntesis de voz.

Representación JSON
{ "speaker": string, "style": string }

Entorno

Representación JSON
Estado

Es un entorno de ejecución para un agente.

Campos

id string

Obligatorio. Solo salida. Es el ID del entorno.

sources[] object (Source)

Son las fuentes que se activarán en el entorno.

created string

Solo salida. Es la hora en que se creó el entorno en formato ISO 8601 (AAAA-MM-DDThh:mm:ssZ).

updated string

Solo salida. Es la hora en la que se actualizó el entorno por última vez en formato ISO 8601 (AAAA-MM-DDThh:mm:ssZ).

lastAccessed string

Solo salida. Es la hora a la que se accedió por última vez al entorno en formato ISO 8601 (AAAA-MM-DDThh:mm:ssZ).

status enum (Status)

Solo salida. Es el estado del contenedor del entorno.

fileCount string (int64 format)

Solo salida. Es la cantidad de archivos en el entorno, solo de salida.

sizeBytes string (int64 format)

Solo salida. Es el tamaño total de los archivos del entorno en bytes, solo de salida.

network Union type

Es la configuración de red del entorno. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

networkAllowlist object (EnvironmentNetworkEgressAllowlist)

Permite solo dominios específicos.

networkMode enum (NetworkMode)

Es el modo de salida de red.

Fin de los campos mutuamente excluyentes.

Representación JSON

{
  "id": string,
  "sources": [
    {
      object (Source)
    }
  ],
  "created": string,
  "updated": string,
  "lastAccessed": string,
  "status": enum (Status),
  "fileCount": string,
  "sizeBytes": string,

  // network
  "networkAllowlist": {
    object (EnvironmentNetworkEgressAllowlist)
  },
  "networkMode": enum (NetworkMode)
  // Union type
}

Estado

Es el estado del entorno.

Enums
`STATUS_UNSPECIFIED`
`ACTIVE`
`EXPIRED`

NetworkMode

Es el modo de salida de red para las configuraciones que no están en la lista de entidades permitidas.

Enums
`NETWORK_MODE_UNSPECIFIED`	Valor predeterminado. No se utiliza.
`DISABLED`	Se bloquea toda la salida de red.

Esquema

Representación JSON
Tipo

El objeto Schema permite definir los tipos de datos de entrada y salida. Estos tipos pueden ser objetos, pero también primitivas y arrays. Representa un subconjunto selecto de un objeto de esquema de OpenAPI 3.0.

Campos

type enum (Type)

Obligatorio. Tipo de datos.

format string

Opcional. El formato de los datos. Se permite cualquier valor, pero la mayoría no activa ninguna funcionalidad especial.

title string

Opcional. Es el título del esquema.

description string

Opcional. Es una breve descripción del parámetro. Esto podría contener ejemplos de uso. La descripción del parámetro puede tener el formato de Markdown.

nullable boolean

Opcional. Indica si el valor puede ser nulo.

enum[] string

Opcional. Valores posibles del elemento de Type.STRING con formato de enumeración. Por ejemplo, podemos definir una dirección de enumeración de la siguiente forma : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

maxItems string (int64 format)

Opcional. Es la cantidad máxima de elementos para Type.ARRAY.

minItems string (int64 format)

Opcional. Es la cantidad mínima de elementos para Type.ARRAY.

properties map (key: string, value: object (Schema))

Opcional. Propiedades de Type.OBJECT.

Un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

Opcional. Propiedades obligatorias de Type.OBJECT.

minProperties string (int64 format)

Opcional. Es la cantidad mínima de propiedades para Type.OBJECT.

maxProperties string (int64 format)

Opcional. Es la cantidad máxima de propiedades para Type.OBJECT.

minLength string (int64 format)

Opcional. CAMPOS DEL ESQUEMA PARA EL TIPO STRING Longitud mínima del Type.STRING

maxLength string (int64 format)

Opcional. Longitud máxima de Type.STRING

pattern string

Opcional. Es el patrón de Type.STRING para restringir una cadena a una expresión regular.

example value (Value format)

Opcional. Ejemplo del objeto. Solo se completará cuando el objeto sea la raíz.

anyOf[] object (Schema)

Opcional. El valor se debe validar con cualquiera (uno o más) de los subesquemas de la lista.

propertyOrdering[] string

Opcional. Es el orden de las propiedades. No es un campo estándar en la especificación de OpenAPI. Se usa para determinar el orden de las propiedades en la respuesta.

default value (Value format)

Opcional. Es el valor predeterminado del campo. Según el esquema JSON, este campo está destinado a los generadores de documentación y no afecta la validación. Por lo tanto, se incluye aquí y se ignora para que los desarrolladores que envían esquemas con un campo default no reciban errores de campo desconocido.

items object (Schema)

Opcional. Esquema de los elementos de Type.ARRAY.

minimum number

Opcional. CAMPOS DE ESQUEMA PARA LOS TIPOS INTEGER y NUMBER Valor mínimo de Type.INTEGER y Type.NUMBER

maximum number

Opcional. Valor máximo de Type.INTEGER y Type.NUMBER

Representación JSON

{
  "type": enum (Type),
  "format": string,
  "title": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "minProperties": string,
  "maxProperties": string,
  "minLength": string,
  "maxLength": string,
  "pattern": string,
  "example": value,
  "anyOf": [
    {
      object (Schema)
    }
  ],
  "propertyOrdering": [
    string
  ],
  "default": value,
  "items": {
    object (Schema)
  },
  "minimum": number,
  "maximum": number
}

Tipo

Type contiene la lista de tipos de datos de OpenAPI, como se define en https://spec.openapis.org/oas/v3.0.3#data-types

Enums
`TYPE_UNSPECIFIED`	No se especificó, no se debe usar.
`STRING`	Tipo de cadena.
`NUMBER`	Es el tipo de número.
`INTEGER`	Tipo de número entero.
`BOOLEAN`	Tipo booleano.
`ARRAY`	Es el tipo de array.
`OBJECT`	Es el tipo de objeto.
`NULL`	Tipo nulo.

Herramienta

Son los detalles de la herramienta que el modelo puede usar para generar la respuesta.

Campos

functionDeclarations[] object (FunctionDeclaration)

Opcional. Es una lista de FunctionDeclarations disponibles para el modelo que se pueden usar para la llamada a funciones.

El modelo o sistema no ejecuta la función. En su lugar, la función definida se puede devolver como un FunctionCall con argumentos al cliente para su ejecución. El modelo puede decidir llamar a un subconjunto de estas funciones completando FunctionCall en la respuesta. El siguiente turno de conversación puede contener un FunctionResponse con el contexto de generación de "función" Content.role para el siguiente turno del modelo.

googleSearchRetrieval object (GoogleSearchRetrieval)

Opcional. Es una herramienta de recuperación que funciona con la Búsqueda de Google.

codeExecution object (CodeExecution)

Opcional. Permite que el modelo ejecute código como parte de la generación.

googleSearch object (GoogleSearch)

Opcional. Tipo de herramienta GoogleSearch. Es la herramienta para admitir la Búsqueda de Google en el modelo. Con la tecnología de Google

computerUse object (ComputerUse)

Opcional. Herramienta para ayudar al modelo a interactuar directamente con la computadora. Si está habilitada, propaga automáticamente las declaraciones de funciones específicas para el uso de la computadora.

urlContext object (UrlContext)

Opcional. Herramienta para admitir la recuperación del contexto de URL.

fileSearch object (FileSearch)

Opcional. Tipo de herramienta FileSearch. Herramienta para recuperar conocimiento de los corpus de recuperación semántica.

mcpServers[] object (McpServer)

Opcional. Servidores de MCP a los que se conectará.

googleMaps object (GoogleMaps)

Opcional. Es una herramienta que permite fundamentar la respuesta del modelo con un contexto geoespacial relacionado con la consulta del usuario.

Representación JSON

{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  },
  "computerUse": {
    object (ComputerUse)
  },
  "urlContext": {
    object (UrlContext)
  },
  "fileSearch": {
    object (FileSearch)
  },
  "mcpServers": [
    {
      object (McpServer)
    }
  ],
  "googleMaps": {
    object (GoogleMaps)
  }
}

FunctionDeclaration

Es la representación estructurada de una declaración de función según lo definido por la especificación de OpenAPI 3.03. En esta declaración, se incluyen el nombre y los parámetros de la función. Esta FunctionDeclaration es una representación de un bloque de código que el modelo puede usar como Tool y que el cliente puede ejecutar.

Campos

name string

Obligatorio. Es el nombre de la función. Debe tener caracteres de la A a la Z (mayúsculas o minúsculas), o números del 0 al 9, o contener guiones bajos, dos puntos, puntos y guiones, con una longitud máxima de 128.

description string

Obligatorio. Una breve descripción de la función.

behavior enum (Behavior)

Opcional. Especifica el comportamiento de la función. Actualmente, solo se admite con el método BidiGenerateContent.

parameters object (Schema)

Opcional. Describe los parámetros de esta función. Refleja la clave de cadena del objeto de parámetro de Open API 3.03: el nombre del parámetro. Los nombres de los parámetros distinguen mayúsculas de minúsculas. Valor del esquema: Es el esquema que define el tipo que se usa para el parámetro.

parametersJsonSchema value (Value format)

Opcional. Describe los parámetros de la función en formato de esquema JSON. El esquema debe describir un objeto en el que las propiedades sean los parámetros de la función. Por ejemplo:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "additionalProperties": false,
  "required": ["name", "age"],
  "propertyOrdering": ["name", "age"]
}

Este campo es mutuamente exclusivo con parameters.

response object (Schema)

Opcional. Describe el resultado de esta función en formato de esquema JSON. Refleja el objeto de respuesta de Open API 3.03. El esquema define el tipo que se usa para el valor de respuesta de la función.

responseJsonSchema value (Value format)

Opcional. Describe el resultado de esta función en formato de esquema JSON. El valor especificado por el esquema es el valor de respuesta de la función.

Este campo es mutuamente exclusivo con response.

Representación JSON

{
  "name": string,
  "description": string,
  "behavior": enum (Behavior),
  "parameters": {
    object (Schema)
  },
  "parametersJsonSchema": value,
  "response": {
    object (Schema)
  },
  "responseJsonSchema": value
}

Comportamiento

Define el comportamiento de la función. La configuración predeterminada es BLOCKING.

Enums
`UNSPECIFIED`	Este valor no se usa.
`BLOCKING`	Si se establece, el sistema esperará a recibir la respuesta de la función antes de continuar con la conversación.
`NON_BLOCKING`	Si se establece, el sistema no esperará a recibir la respuesta de la función. En cambio, intentará controlar las respuestas de las funciones a medida que estén disponibles, a la vez que mantiene la conversación entre el usuario y el modelo.

GoogleSearchRetrieval

Herramienta para recuperar datos web públicos para la fundamentación, con la tecnología de Google.

Campos

dynamicRetrievalConfig object (DynamicRetrievalConfig)

Especifica la configuración de recuperación dinámica para la fuente determinada.

Representación JSON
{ "dynamicRetrievalConfig": { object (`DynamicRetrievalConfig`) } }

DynamicRetrievalConfig

Describe las opciones para personalizar la recuperación dinámica.

Campos

mode enum (Mode)

Es el modo del predictor que se usará en la recuperación dinámica.

dynamicThreshold number

Es el umbral que se usará en la recuperación dinámica. Si no se establece, se usa un valor predeterminado del sistema.

Representación JSON
{ "mode": enum (`Mode`), "dynamicThreshold": number }

Modo

Es el modo del predictor que se usará en la recuperación dinámica.

Enums
`MODE_UNSPECIFIED`	Activa siempre la recuperación.
`MODE_DYNAMIC`	Ejecuta la recuperación solo cuando el sistema decida que es necesario.

CodeExecution

Este tipo no tiene campos.

Es una herramienta que ejecuta el código generado por el modelo y le devuelve el resultado automáticamente.

Consulta también ExecutableCode y CodeExecutionResult, que solo se generan cuando se usa esta herramienta.

GoogleSearch

Tipo de herramienta GoogleSearch. Herramienta para admitir la Búsqueda de Google en Model. Con la tecnología de Google

Campos

timeRangeFilter object (Interval)

Opcional. Filtra los resultados de la búsqueda para un período específico. Si los clientes establecen una hora de inicio, deben establecer una hora de finalización (y viceversa).

searchTypes object (SearchTypes)

Opcional. Es el conjunto de tipos de búsqueda que se habilitarán. Si no se establece, la búsqueda web se habilita de forma predeterminada.

Representación JSON
{ "timeRangeFilter": { object (`Interval`) }, "searchTypes": { object (`SearchTypes`) } }

Intervalo

Representa un intervalo de tiempo, codificado como una marca de tiempo de inicio (inclusiva) y una marca de tiempo de finalización (exclusiva).

El inicio debe ser menor o igual que el final. Cuando el inicio es igual al final, el intervalo está vacío (no coincide con ninguna hora). Cuando no se especifican el inicio ni el final, el intervalo coincide con cualquier hora.

Campos

startTime string (Timestamp format)

Opcional. Es el inicio inclusivo del intervalo.

Si se especifica, la marca de tiempo que coincida con este intervalo deberá ser igual o posterior al inicio.

Usa el formato RFC 3339, en el que el resultado generado siempre estará normalizada a Z y usa 0, 3, 6 o 9 dígitos fraccionarios. También se aceptan otras compensaciones que no sean “Z”. Ejemplos: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

endTime string (Timestamp format)

Opcional. Es el final exclusivo del intervalo.

Si se especifica, la marca de tiempo que coincida con este intervalo deberá ser anterior al final.

Representación JSON
{ "startTime": string, "endTime": string }

SearchTypes

Son los diferentes tipos de búsqueda que se pueden habilitar en la herramienta GoogleSearch.

Campos

webSearch object (WebSearch)

Opcional. Habilita la búsqueda web. Solo se devuelven resultados de texto.

imageSearch object (ImageSearch)

Opcional. Habilita la búsqueda con imágenes. Se devuelven los bytes de la imagen.

Representación JSON
{ "webSearch": { object (`WebSearch`) }, "imageSearch": { object (`ImageSearch`) } }

WebSearch

Este tipo no tiene campos.

Búsqueda web estándar para la fundamentación y los parámetros de configuración relacionados.

ImageSearch

Este tipo no tiene campos.

Búsqueda de imágenes para la fundamentación y los parámetros de configuración relacionados.

ComputerUse

Tipo de herramienta de uso de la computadora.

Campos

environment enum (Environment)

Obligatorio. El entorno que se opera.

excludedPredefinedFunctions[] string

Opcional. De forma predeterminada, las funciones predefinidas se incluyen en la llamada final al modelo. Algunos de ellos se pueden excluir de forma explícita para que no se incluyan automáticamente. Esto puede tener dos propósitos: 1. Usar un espacio de acciones más restringido o diferente 2. Mejorar las definiciones o instrucciones de las funciones predefinidas

enablePromptInjectionDetection boolean

Opcional. Indica si se debe habilitar la verificación de detección de inyección de instrucciones en la solicitud de uso de la computadora.

disabledSafetyPolicies[] enum (SafetyPolicy)

Opcional. Inhabilitar las políticas de seguridad para el uso de computadoras

Representación JSON
{ "environment": enum (`Environment`), "excludedPredefinedFunctions": [ string ], "enablePromptInjectionDetection": boolean, "disabledSafetyPolicies": [ enum (`SafetyPolicy`) ] }

Entorno

Representa el entorno que se está operando, como un navegador web.

Enums
`ENVIRONMENT_UNSPECIFIED`	El valor predeterminado es browser.
`ENVIRONMENT_BROWSER`	Funciona en un navegador web.
`ENVIRONMENT_MOBILE`	Funciona en un entorno móvil.
`ENVIRONMENT_DESKTOP`	Funciona en un entorno de escritorio.

SafetyPolicy

Políticas de seguridad predefinidas para el uso de computadoras.

Enums
`SAFETY_POLICY_UNSPECIFIED`	Política de seguridad sin especificar.
`FINANCIAL_TRANSACTIONS`	Política de seguridad para transacciones financieras.
`SENSITIVE_DATA_MODIFICATION`	Política de seguridad para la modificación de datos sensibles.
`COMMUNICATION_TOOL`	Política de seguridad para las herramientas de comunicación (p. ej., Gmail, Chat y Meet)
`ACCOUNT_CREATION`	Política de seguridad para la creación de cuentas.
`DATA_MODIFICATION`	Política de seguridad para la modificación de datos.
`USER_CONSENT_MANAGEMENT`	Política de seguridad para la administración del consentimiento del usuario.
`LEGAL_TERMS_AND_AGREEMENTS`	Política de seguridad para términos y acuerdos legales.

UrlContext

Este tipo no tiene campos.

Herramienta para admitir la recuperación del contexto de URL.

FileSearch

La herramienta FileSearch que recupera conocimiento de los corpus de Semantic Retrieval. Los archivos se importan a los corpus de recuperación semántica con la API de ImportFile.

Campos

fileSearchStoreNames[] string

Obligatorio. Son los nombres de los fileSearchStores de los que se recuperarán los datos. Ejemplo: fileSearchStores/my-file-search-store-123

metadataFilter string

Opcional. Es el filtro de metadatos que se aplicará a los documentos y fragmentos de recuperación semántica.

topK integer

Opcional. Es la cantidad de fragmentos de recuperación semántica que se recuperarán.

Representación JSON
{ "fileSearchStoreNames": [ string ], "metadataFilter": string, "topK": integer }

McpServer

Un MCPServer es un servidor al que el modelo puede llamar para realizar acciones. Es un servidor que implementa el protocolo de MCP.

Campos

name string

Es el nombre del MCPServer.

transport Union type

Es el transporte que se usará para conectarse al MCPServer. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

streamableHttpTransport object (StreamableHttpTransport)

Un transporte que puede transmitir solicitudes y respuestas HTTP.

Fin de los campos mutuamente excluyentes.

Representación JSON
{ "name": string, // transport "streamableHttpTransport": { object (`StreamableHttpTransport`) } // Union type }

StreamableHttpTransport

Un transporte que puede transmitir solicitudes y respuestas HTTP.

Campos

url string

Es la URL completa del extremo de MCPServer. Ejemplo: "https://api.example.com/mcp"

headers map (key: string, value: string)

Opcional: Campos para encabezados de autenticación, tiempos de espera, etc., si es necesario.

Un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

timeout string (Duration format)

Es el tiempo de espera de HTTP para las operaciones normales.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

sseReadTimeout string (Duration format)

Es el tiempo de espera para las operaciones de lectura de SSE.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".

terminateOnClose boolean

Indica si se debe cerrar la sesión del cliente cuando se cierra el transporte.

Representación JSON
{ "url": string, "headers": { string: string, ... }, "timeout": string, "sseReadTimeout": string, "terminateOnClose": boolean }

GoogleMaps

La herramienta de Google Maps que proporciona contexto geoespacial para la consulta del usuario.

Campos

enableWidget boolean

Opcional. Indica si se debe devolver un token de contexto de widget en el GroundingMetadata de la respuesta. Los desarrolladores pueden usar el token de contexto del widget para renderizar un widget de Google Maps con contexto geoespacial relacionado con los lugares a los que hace referencia el modelo en la respuesta.

Representación JSON
{ "enableWidget": boolean }

Recurso de REST: auth_tokens

Recurso: AuthToken
- Representación JSON
BidiGenerateContentSetup
- Representación JSON
GenerationConfig
- Representación JSON
Modalidad
SpeechConfig
- Representación JSON
VoiceConfig
- Representación JSON
PrebuiltVoiceConfig
- Representación JSON
MultiSpeakerVoiceConfig
- Representación JSON
SpeakerVoiceConfig
- Representación JSON
ThinkingConfig
- Representación JSON
ThinkingLevel
ImageConfig
- Representación JSON
MediaResolution
ResponseFormatConfig
- Representación JSON
TextResponseFormat
- Representación JSON
MimeType
AudioResponseFormat
- Representación JSON
MimeType
Entrega
ImageResponseFormat
- Representación JSON
MimeType
Entrega
AspectRatio
ImageSize
TranslationConfig
- Representación JSON
AudioTranscriptionConfig
- Representación JSON
LanguageAuto
LanguageHints
- Representación JSON
Modo
RealtimeInputConfig
- Representación JSON
AutomaticActivityDetection
- Representación JSON
StartSensitivity
EndSensitivity
ActivityHandling
TurnCoverage
SessionResumptionConfig
- Representación JSON
ContextWindowCompressionConfig
- Representación JSON
SlidingWindow
- Representación JSON
HistoryConfig
- Representación JSON
Métodos

Recurso: AuthToken

Es una solicitud para crear un token de autenticación efímero.

Campos

name string

Solo salida. Es el identificador. El token en sí.

expireTime string (Timestamp format)

Opcional. Solo entrada. Inmutable. Es un tiempo opcional después del cual, cuando se use el token resultante, se rechazarán los mensajes en las sesiones de BidiGenerateContent. (Gemini puede cerrar la sesión de forma preventiva después de este tiempo).

Si no se establece, el valor predeterminado es de 30 minutos en el futuro. Si se establece, este valor debe ser inferior a 20 horas en el futuro.

newSessionExpireTime string (Timestamp format)

Opcional. Solo entrada. Inmutable. Es el tiempo después del cual se rechazarán las nuevas sesiones de la API de Live que usen el token resultante de esta solicitud.

Si no se establece, el valor predeterminado es de 60 segundos en el futuro. Si se establece, este valor debe ser inferior a 20 horas en el futuro.

fieldMask string (FieldMask format)

Opcional. Solo entrada. Inmutable. Si fieldMask está vacío y bidiGenerateContentSetup no está presente, el mensaje BidiGenerateContentSetup efectivo se toma de la conexión de la API de Live.

Si fieldMask está vacío y bidiGenerateContentSetup está presente, el mensaje BidiGenerateContentSetup efectivo se toma por completo de bidiGenerateContentSetup en esta solicitud. Se ignora el mensaje de configuración de la conexión de la API de Live.

Si fieldMask no está vacío, los campos correspondientes de bidiGenerateContentSetup reemplazarán los campos del mensaje de configuración en la conexión de la API de Live.

Esta es una lista separada por comas de los nombres de campos totalmente calificados. Ejemplo: "user.displayName,photo".

config Union type

Es la configuración específica del método para el token resultante. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

bidiGenerateContentSetup object (BidiGenerateContentSetup)

Opcional. Solo entrada. Inmutable. Configuración específica de BidiGenerateContent.

Fin de los campos mutuamente excluyentes.

uses integer

Opcional. Solo entrada. Inmutable. Es la cantidad de veces que se puede usar el token. Si este valor es cero, no se aplica ningún límite. Reanudar una sesión de la API de Live no cuenta como un uso. Si no se especifica, el valor predeterminado es 1.

Representación JSON

{
  "name": string,
  "expireTime": string,
  "newSessionExpireTime": string,
  "fieldMask": string,

  // config
  "bidiGenerateContentSetup": {
    object (BidiGenerateContentSetup)
  }
  // Union type
  "uses": integer
}

BidiGenerateContentSetup

Mensaje que se enviará en el primer (y solo en el primer) BidiGenerateContentClientMessage. Contiene la configuración que se aplicará durante la RPC de transmisión.

Los clientes deben esperar un mensaje BidiGenerateContentSetupComplete antes de enviar mensajes adicionales.

Campos

model string

Obligatorio. Es el nombre del recurso del modelo. Esto sirve como ID para que lo use el modelo.

Formato: models/{model}

generationConfig object (GenerationConfig)

Opcional. Es la configuración de generación.

No se admiten los siguientes campos:

responseLogprobs
responseMimeType
logprobs
responseSchema
responseJsonSchema
stop_sequence
skipResponseCache
routing_config
audio_timestamp

systemInstruction object (Content)

Opcional. Las instrucciones del sistema que proporcionó el usuario para el modelo.

Nota: Solo se debe usar texto en las partes y el contenido en cada parte debe encontrarse en un párrafo separado.

tools[] object (Tool)

Opcional. Es una lista de Tools que el modelo puede usar para generar la siguiente respuesta.

Un Tool es un fragmento de código que permite que el sistema interactúe con sistemas externos para realizar una acción, o un conjunto de acciones, fuera del conocimiento y del alcance del modelo.

realtimeInputConfig object (RealtimeInputConfig)

Opcional. Configura el manejo de la entrada en tiempo real.

sessionResumption object (SessionResumptionConfig)

Opcional. Configura el mecanismo de reanudación de la sesión.

Si se incluye, el servidor enviará SessionResumptionUpdate mensajes.

contextWindowCompression object (ContextWindowCompressionConfig)

Opcional. Configura un mecanismo de compresión de la ventana de contexto.

Si se incluye, el servidor reducirá automáticamente el tamaño del contexto cuando supere la longitud configurada.

inputAudioTranscription object (AudioTranscriptionConfig)

Opcional. Si se establece, habilita la transcripción de la entrada de voz. La transcripción se alinea con el idioma del audio de entrada, si está configurado.

outputAudioTranscription object (AudioTranscriptionConfig)

Opcional. Si se establece, habilita la transcripción de la salida de audio del modelo. La transcripción se alinea con el código de idioma especificado para el audio de salida, si está configurado.

historyConfig object (HistoryConfig)

Opcional. Configura el intercambio de historial entre el cliente y el servidor.

labels map (key: string, value: string)

Opcional. Son etiquetas con metadatos definidos por el usuario para la solicitud.

Uso: - Identificadores de seguridad de los agregadores: Usa la clave safety_identifier (p.ej., {"safety_identifier": "user_session_123"})

Un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

Representación JSON

{
  "model": string,
  "generationConfig": {
    object (GenerationConfig)
  },
  "systemInstruction": {
    object (Content)
  },
  "tools": [
    {
      object (Tool)
    }
  ],
  "realtimeInputConfig": {
    object (RealtimeInputConfig)
  },
  "sessionResumption": {
    object (SessionResumptionConfig)
  },
  "contextWindowCompression": {
    object (ContextWindowCompressionConfig)
  },
  "inputAudioTranscription": {
    object (AudioTranscriptionConfig)
  },
  "outputAudioTranscription": {
    object (AudioTranscriptionConfig)
  },
  "historyConfig": {
    object (HistoryConfig)
  },
  "labels": {
    string: string,
    ...
  }
}

GenerationConfig

Son las opciones de configuración para la generación y los resultados del modelo. No todos los parámetros se pueden configurar para cada modelo.

Campos

stopSequences[] string

Opcional. Es el conjunto de secuencias de caracteres (hasta 5) que detendrán la generación de resultados. Si se especifica, la API se detendrá en la primera aparición de un stop_sequence. La secuencia de detención no se incluirá como parte de la respuesta.

responseMimeType string

Opcional. Es el tipo de MIME del texto candidato generado. Los tipos de MIME admitidos son los siguientes: text/plain: (predeterminado) Salida de texto. application/json: Es la respuesta JSON en los candidatos de respuesta. text/x.enum: ENUM como una respuesta de cadena en los candidatos de respuesta. Consulta los documentos para obtener una lista de todos los tipos de MIME de texto admitidos.

responseSchema
(deprecated)

object (Schema)

Opcional. Esquema de salida del texto candidato generado. Los esquemas deben ser un subconjunto del esquema de OpenAPI y pueden ser objetos, primitivas o arrays.

Si se establece, también se debe establecer un responseMimeType compatible. Tipos de MIME compatibles: application/json: Esquema para la respuesta JSON. Consulta la guía de generación de texto JSON para obtener más detalles.

Obsoleta. Usa responseFormat en su lugar.

_responseJsonSchema
(deprecated)

value (Value format)

Opcional. Esquema de salida de la respuesta generada. Esta es una alternativa a responseSchema que acepta el esquema JSON.

Si se establece, se debe omitir responseSchema, pero se requiere responseMimeType.

Si bien se puede enviar el esquema JSON completo, no se admiten todas las funciones. Específicamente, solo se admiten las siguientes propiedades:

$id
$defs
$ref
$anchor
type
format
title
description
enum (para cadenas y números)
items
prefixItems
minItems
maxItems
minimum
maximum
anyOf
oneOf (se interpreta de la misma manera que anyOf)
properties
additionalProperties
required

También se puede establecer la propiedad no estándar propertyOrdering.

Las referencias cíclicas se desenrollan en un grado limitado y, por lo tanto, solo se pueden usar dentro de propiedades no obligatorias. (Las propiedades que admiten valores nulos no son suficientes). Si se establece $ref en un subesquema, no se puede establecer ninguna otra propiedad, excepto las que comienzan como $.

Obsoleta. Usa responseFormat en su lugar.

responseJsonSchema value (Value format)

Opcional. Un detalle interno. Usa responseJsonSchema en lugar de este campo.

responseModalities[] enum (Modality)

Opcional. Son las modalidades solicitadas de la respuesta. Representa el conjunto de modalidades que el modelo puede devolver y que se deben esperar en la respuesta. Esta es una coincidencia exacta con las modalidades de la respuesta.

Un modelo puede tener varias combinaciones de modalidades compatibles. Si las modalidades solicitadas no coinciden con ninguna de las combinaciones admitidas, se devolverá un error.

Una lista vacía equivale a solicitar solo texto.

candidateCount integer

Opcional. Es la cantidad de respuestas generadas que se devolverán. Si no se configura, el valor predeterminado será 1. Ten en cuenta que esto no funciona para los modelos de la generación anterior (familia Gemini 1.0).

maxOutputTokens integer

Opcional. Es la cantidad máxima de tokens que se incluirán en un candidato de respuesta.

Nota: El valor predeterminado varía según el modelo. Consulta el atributo Model.output_token_limit de Model que devuelve la función getModel.

temperature number

Opcional. Controla la aleatoriedad del resultado.

Nota: El valor predeterminado varía según el modelo. Consulta el atributo Model.temperature de Model que devuelve la función getModel.

Los valores pueden variar de [0.0, 2.0].

Este campo ya no se admite y se ignora de forma silenciosa en Gemini 3.6 Flash y modelos más recientes.

topP number

Opcional. La probabilidad acumulativa máxima de los tokens que se deben considerar cuando se realiza el muestreo.

El modelo usa un muestreo combinado de Top-K y Top-P (núcleo).

Los tokens se ordenan según las probabilidades asignadas para que solo se consideren los más probables. El muestreo Top-k limita directamente la cantidad máxima de tokens que se deben considerar, mientras que el muestreo de núcleo limita la cantidad de tokens según la probabilidad acumulativa.

Nota: El valor predeterminado varía según el Model y se especifica con el atributo Model.top_p que devuelve la función getModel. Un atributo topK vacío indica que el modelo no aplica el muestreo top-k y no permite establecer topK en las solicitudes.

Este campo ya no se admite y se ignora de forma silenciosa en Gemini 3.6 Flash y modelos más recientes.

topK integer

Opcional. Es la cantidad máxima de tokens que se deben tener en cuenta cuando se realiza el muestreo.

Los modelos de Gemini usan el muestreo Top-p (núcleo) o una combinación de muestreo Top-k y de núcleo. El muestreo de Top-k considera el conjunto de tokens más probables de topK. Los modelos que se ejecutan con muestreo de núcleo no permiten el parámetro de configuración topK.

Este campo ya no se admite y se ignora de forma silenciosa en Gemini 3.6 Flash y modelos más recientes.

seed integer

Opcional. Es el valor inicial que se usa en la decodificación. Si no se establece, la solicitud usa un valor de inicialización generado de forma aleatoria.

presencePenalty number

Opcional. Es la penalización de presencia que se aplica a las logprobs del siguiente token si este ya se vio en la respuesta.

Esta penalización es binaria (activada o desactivada) y no depende de la cantidad de veces que se use el token (después de la primera vez). Usa frequencyPenalty para una penalización que aumenta con cada uso.

Una penalización positiva desalentará el uso de tokens que ya se usaron en la respuesta, lo que aumentará el vocabulario.

Una penalización negativa fomentará el uso de tokens que ya se usaron en la respuesta, lo que disminuirá el vocabulario.

frequencyPenalty number

Opcional. Es la penalización de frecuencia que se aplica a las probabilidades logarítmicas del siguiente token, multiplicada por la cantidad de veces que se vio cada token en la respuesta hasta el momento.

Una penalización positiva desalentará el uso de tokens que ya se usaron, de forma proporcional a la cantidad de veces que se usó el token: cuanto más se use un token, más difícil será para el modelo volver a usarlo, lo que aumentará el vocabulario de las respuestas.

Precaución: Una penalización negativa alentará al modelo a reutilizar tokens de forma proporcional a la cantidad de veces que se usó el token. Los valores negativos pequeños reducirán el vocabulario de una respuesta. Los valores negativos más grandes harán que el modelo comience a repetir un token común hasta que alcance el límite de maxOutputTokens.

responseLogprobs boolean

Opcional. Si se establece como verdadero, se exportan los resultados de logprobs en la respuesta.

logprobs integer

Opcional. Solo es válido si responseLogprobs=True. Esto establece la cantidad de logprobs principales, incluido el candidato elegido, que se devolverán en cada paso de decodificación en Candidate.logprobs_result. El número debe estar en el rango de [0, 20].

enableEnhancedCivicAnswers boolean

Opcional. Habilita las respuestas cívicas mejoradas. Es posible que no esté disponible para todos los modelos.

speechConfig object (SpeechConfig)

Opcional. Es la configuración de la generación de voz.

thinkingConfig object (ThinkingConfig)

Opcional. Es la configuración de las funciones de pensamiento. Se devolverá un error si se establece este campo para los modelos que no admiten el razonamiento.

imageConfig object (ImageConfig)

Opcional. Es la configuración para la generación de imágenes. Se devolverá un error si se establece este campo para los modelos que no admiten estas opciones de configuración.

mediaResolution enum (MediaResolution)

Opcional. Si se especifica, se usará la resolución de contenido multimedia indicada.

enableAffectiveDialog boolean

Opcional. Si se habilita, el modelo detectará emociones y adaptará sus respuestas según corresponda.

responseFormat object (ResponseFormatConfig)

Opcional. Es la configuración del formato de salida de la respuesta. Permite especificar la configuración de salida por modalidad (texto, audio, imagen) en una estructura plana.

translationConfig object (TranslationConfig)

Opcional. Configuración para la traducción.

audioTranscriptionConfig object (AudioTranscriptionConfig)

Opcional. Es la configuración para la transcripción de audio (reconocimiento de voz).

Representación JSON

{
  "stopSequences": [
    string
  ],
  "responseMimeType": string,
  "responseSchema": {
    object (Schema)
  },
  "_responseJsonSchema": value,
  "responseJsonSchema": value,
  "responseModalities": [
    enum (Modality)
  ],
  "candidateCount": integer,
  "maxOutputTokens": integer,
  "temperature": number,
  "topP": number,
  "topK": integer,
  "seed": integer,
  "presencePenalty": number,
  "frequencyPenalty": number,
  "responseLogprobs": boolean,
  "logprobs": integer,
  "enableEnhancedCivicAnswers": boolean,
  "speechConfig": {
    object (SpeechConfig)
  },
  "thinkingConfig": {
    object (ThinkingConfig)
  },
  "imageConfig": {
    object (ImageConfig)
  },
  "mediaResolution": enum (MediaResolution),
  "enableAffectiveDialog": boolean,
  "responseFormat": {
    object (ResponseFormatConfig)
  },
  "translationConfig": {
    object (TranslationConfig)
  },
  "audioTranscriptionConfig": {
    object (AudioTranscriptionConfig)
  }
}

Modalidad

Son las modalidades admitidas de la respuesta.

Enums
`MODALITY_UNSPECIFIED`	Valor predeterminado
`TEXT`	Indica que el modelo debe devolver texto.
`IMAGE`	Indica que el modelo debe devolver imágenes.
`AUDIO`	Indica que el modelo debe devolver audio.

SpeechConfig

Es la configuración para la generación y transcripción de voz.

Campos

voiceConfig object (VoiceConfig)

Es la configuración en caso de salida de una sola voz.

multiSpeakerVoiceConfig object (MultiSpeakerVoiceConfig)

Opcional. La configuración de varios bocinas. Es mutuamente excluyente con el campo voiceConfig.

languageCode string

Opcional. Es el código de idioma BCP-47 de IETF que el usuario configuró para que use la app. Se usa para el reconocimiento y la síntesis de voz.

Los valores válidos son: de-DE, en-AU, en-GB, en-IN, en-US, es-US, fr-FR, hi-IN, pt-BR, ar-XA, es-ES, fr-CA, id-ID, it-IT, ja-JP, tr-TR, vi-VN, bn-IN, gu-IN, kn-IN, ml-IN, mr-IN, ta-IN, te-IN, nl-NL, ko-KR, cmn-CN, pl-PL, ru-RU y th-TH.

Representación JSON
{ "voiceConfig": { object (`VoiceConfig`) }, "multiSpeakerVoiceConfig": { object (`MultiSpeakerVoiceConfig`) }, "languageCode": string }

VoiceConfig

Es la configuración de la voz que se usará.

Campos

voice_config Union type

Es la configuración que usará la bocina. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

prebuiltVoiceConfig object (PrebuiltVoiceConfig)

Es la configuración de la voz precompilada que se usará.

voice string

Opcional. Es el identificador de la persona que habla para la síntesis. Los formatos admitidos son los siguientes:

Es el nombre de la bocina para las voces precompiladas (por ejemplo, Orus o Kore).
ID de voz para las voces almacenadas (por ejemplo, voice_xxx).
Clave de replicación de voz (por ejemplo, voicekey_xxx).

Fin de los campos mutuamente excluyentes.

Representación JSON
{ // voice_config "prebuiltVoiceConfig": { object (`PrebuiltVoiceConfig`) }, "voice": string // Union type }

PrebuiltVoiceConfig

Es la configuración de la voz precompilada que se usará.

Campos

voiceName string

Opcional. Es el nombre de la voz predeterminada que se usará.

Representación JSON
{ "voiceName": string }

MultiSpeakerVoiceConfig

La configuración de varios bocinas.

Campos

speakerVoiceConfigs[] object (SpeakerVoiceConfig)

Obligatorio. Todas las voces de bocina habilitadas

Representación JSON
{ "speakerVoiceConfigs": [ { object (`SpeakerVoiceConfig`) } ] }

SpeakerVoiceConfig

Es la configuración de una sola bocina en un sistema de varias bocinas.

Campos

speaker string

Obligatorio. Es el nombre de la bocina que se usará. Debe ser la misma que en la instrucción.

voiceConfig object (VoiceConfig)

Obligatorio. Es la configuración de la voz que se usará.

Representación JSON
{ "speaker": string, "voiceConfig": { object (`VoiceConfig`) } }

ThinkingConfig

Es la configuración de las funciones de pensamiento.

Campos

includeThoughts boolean

Indica si se deben incluir pensamientos en la respuesta. Si es verdadero, los pensamientos se devuelven solo cuando están disponibles.

thinkingBudget integer

Es la cantidad de tokens de razonamiento que debe generar el modelo.

thinkingLevel enum (ThinkingLevel)

Opcional. Controla la profundidad máxima del proceso de razonamiento interno del modelo antes de que produzca una respuesta. El valor predeterminado depende del modelo. Consulta la guía de niveles de pensamiento para obtener más detalles. Se recomienda para los modelos de Gemini 3 o versiones posteriores. Si se usa con modelos anteriores, se produce un error.

Representación JSON
{ "includeThoughts": boolean, "thinkingBudget": integer, "thinkingLevel": enum (`ThinkingLevel`) }

ThinkingLevel

Permite que el usuario especifique cuánto pensar con un enum en lugar de un presupuesto de números enteros.

Enums
`THINKING_LEVEL_UNSPECIFIED`	Valor predeterminado
`MINIMAL`	No requiere pensar mucho.
`LOW`	Nivel de razonamiento bajo.
`MEDIUM`	Nivel de razonamiento medio.
`HIGH`	Nivel de razonamiento alto.

ImageConfig

Configuración de las funciones de generación de imágenes.

Campos

aspectRatio string

Opcional. Es la relación de aspecto de la imagen que se generará. Relaciones de aspecto admitidas: 1:1, 1:4, 4:1, 1:8, 8:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9 o 21:9.

Si no se especifica, el modelo elegirá una relación de aspecto predeterminada según las imágenes de referencia proporcionadas.

imageSize string

Opcional. Especifica el tamaño de las imágenes generadas. Los valores admitidos son 512, 1K, 2K y 4K. Si no se especifica, el modelo usará el valor predeterminado 1K.

Representación JSON
{ "aspectRatio": string, "imageSize": string }

MediaResolution

Es la resolución del contenido multimedia de entrada.

Enums
`MEDIA_RESOLUTION_UNSPECIFIED`	No se estableció la resolución de contenido multimedia.
`MEDIA_RESOLUTION_LOW`	La resolución de contenido multimedia se estableció en baja (64 tokens).
`MEDIA_RESOLUTION_MEDIUM`	La resolución de contenido multimedia se estableció en media (256 tokens).
`MEDIA_RESOLUTION_HIGH`	La resolución de los medios se establece en alta (reencuadre con zoom con 256 tokens).

ResponseFormatConfig

Es la configuración del formato de salida de la respuesta. Este es un objeto plano en el que cada subcampo opcional configura una modalidad de salida específica.

Campos

text object (TextResponseFormat)

Opcional. Es la configuración del formato de salida de texto.

audio object (AudioResponseFormat)

Opcional. Es la configuración del formato de salida de audio.

image object (ImageResponseFormat)

Opcional. Es la configuración del formato de salida de la imagen.

Representación JSON
{ "text": { object (`TextResponseFormat`) }, "audio": { object (`AudioResponseFormat`) }, "image": { object (`ImageResponseFormat`) } }

TextResponseFormat

Configuración del formato de salida de texto.

Campos

mimeType enum (MimeType)

Opcional. Es el tipo de MIME de la salida de texto.

schema value (Value format)

Opcional. Es el esquema JSON al que debe ajustarse el resultado. Solo se aplica cuando mimeType es APPLICATION_JSON.

Representación JSON
{ "mimeType": enum (`MimeType`), "schema": value }

MimeType

Tipos de MIME admitidos para el resultado de texto.

Enums
`MIME_TYPE_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`APPLICATION_JSON`	Es el formato de salida JSON.
`TEXT_PLAIN`	Formato de salida de texto sin formato.

AudioResponseFormat

Es la configuración del formato de salida de audio.

Campos

mimeType enum (MimeType)

Opcional. Es el tipo de MIME de la salida de audio.

delivery enum (Delivery)

Opcional. Es el modo de entrega de la salida de audio.

sampleRate integer

Opcional. Es la tasa de muestreo en Hz.

bitRate integer

Opcional. Es la tasa de bits en bits por segundo (bps). Solo se aplica a los formatos comprimidos (MP3 y Opus).

Representación JSON
{ "mimeType": enum (`MimeType`), "delivery": enum (`Delivery`), "sampleRate": integer, "bitRate": integer }

MimeType

Son los tipos de MIME admitidos para la salida de audio.

Enums
`MIME_TYPE_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`AUDIO_MP3`	Formato de audio MP3
`AUDIO_OGG_OPUS`	Formato de audio OGG Opus
`AUDIO_L16`	Es el formato de audio PCM sin procesar (L16).
`AUDIO_WAV`	Formato de audio WAV
`AUDIO_ALAW`	Formato de audio de ley A.
`AUDIO_MULAW`	Formato de audio mu-law.

Entrega

Es el modo de entrega de la salida de audio.

Enums
`DELIVERY_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`INLINE`	Los datos de audio se devuelven intercalados en la respuesta.
`URI`	Los datos de audio se devuelven como un URI.

ImageResponseFormat

Es la configuración del formato de salida de la imagen.

Campos

mimeType enum (MimeType)

Opcional. Es el tipo de MIME de la imagen de salida.

delivery enum (Delivery)

Opcional. Es el modo de publicación para el resultado de la imagen.

aspectRatio enum (AspectRatio)

Opcional. Es la relación de aspecto de la imagen de salida.

imageSize enum (ImageSize)

Opcional. Es el tamaño de la imagen de salida.

Representación JSON
{ "mimeType": enum (`MimeType`), "delivery": enum (`Delivery`), "aspectRatio": enum (`AspectRatio`), "imageSize": enum (`ImageSize`) }

MimeType

Son los tipos de MIME admitidos para el resultado de la imagen.

Enums
`MIME_TYPE_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`IMAGE_JPEG`	Formato de imagen JPEG.

Entrega

Es el modo de entrega para el resultado de la imagen.

Enums
`DELIVERY_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`INLINE`	Los datos de la imagen se devuelven intercalados en la respuesta.
`URI`	Los datos de la imagen se devuelven como un URI.

AspectRatio

Son las relaciones de aspecto compatibles para el resultado de la imagen.

Enums
`ASPECT_RATIO_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`ASPECT_RATIO_ONE_BY_ONE`	Relación de aspecto de 1:1
`ASPECT_RATIO_TWO_BY_THREE`	Relación de aspecto de 2:3
`ASPECT_RATIO_THREE_BY_TWO`	Relación de aspecto de 3:2
`ASPECT_RATIO_THREE_BY_FOUR`	Relación de aspecto de 3:4
`ASPECT_RATIO_FOUR_BY_THREE`	Relación de aspecto de 4:3
`ASPECT_RATIO_FOUR_BY_FIVE`	Relación de aspecto de 4:5
`ASPECT_RATIO_FIVE_BY_FOUR`	Relación de aspecto de 5:4
`ASPECT_RATIO_NINE_BY_SIXTEEN`	Relación de aspecto de 9:16
`ASPECT_RATIO_SIXTEEN_BY_NINE`	Relación de aspecto de 16:9
`ASPECT_RATIO_TWENTY_ONE_BY_NINE`	Relación de aspecto de 21:9
`ASPECT_RATIO_ONE_BY_EIGHT`	Relación de aspecto de 1:8.
`ASPECT_RATIO_EIGHT_BY_ONE`	Relación de aspecto de 8:1.
`ASPECT_RATIO_ONE_BY_FOUR`	Relación de aspecto de 1:4
`ASPECT_RATIO_FOUR_BY_ONE`	Relación de aspecto de 4:1.

ImageSize

Son los tamaños de imagen admitidos para la salida de imagen.

Enums
`IMAGE_SIZE_UNSPECIFIED`	Valor predeterminado Este valor no se usa.
`IMAGE_SIZE_FIVE_TWELVE`	Tamaño de imagen de 512 px
`IMAGE_SIZE_ONE_K`	Tamaño de imagen de 1K.
`IMAGE_SIZE_TWO_K`	Tamaño de imagen de 2K
`IMAGE_SIZE_FOUR_K`	Tamaño de imagen de 4K.

TranslationConfig

Es la configuración de las funciones de traducción.

Campos

targetLanguageCode string

Obligatorio. Es el idioma de destino de la traducción. Los valores admitidos son los códigos de idioma BCP-47 (p.ej., "en", "es", "fr").

echoTargetLanguage boolean

Opcional. Si es verdadero, el modelo generará audio cuando se hable el idioma de destino; en esencia, repetirá la entrada. Si es falso, no produciremos audio para el idioma de destino.

Representación JSON
{ "targetLanguageCode": string, "echoTargetLanguage": boolean }

AudioTranscriptionConfig

Es la configuración de la transcripción de audio.

Campos

languageCodes[] string

Opcional. Son códigos de idioma BCP-47 que proporcionan sugerencias sobre los idiomas presentes en el audio. Si se omite o se deja vacío, se establece de forma predeterminada en la detección automática de idioma.

adaptationPhrases[]
(deprecated)

string

Opcional. Es una lista de frases que se usan para la adaptación de voz, que personaliza el modelo de ASR para mejorar el reconocimiento de estos términos específicos.

customVocabulary[] string

Opcional. Es una lista de frases de vocabulario personalizadas para sesgar el modelo de reconocimiento de voz hacia el reconocimiento de términos específicos (nombres de productos, nombres propios y jerga).

wordTimestamp boolean

Opcional. Configura la generación de marcas de tiempo a nivel de palabra.

diarization boolean

Opcional. Configura la identificación de interlocutores.

mode enum (Mode)

Opcional. Configura el modo de transcripción. Valores admitidos: VERBATIM, SMART. Si no se especifica, se establece de forma predeterminada como transcripción VERBATIM. En el modo SMART, el modelo realiza la eliminación de disfluencias (quita muletillas, repeticiones y comienzos en falso), una limpieza gramatical ligera, un formato automático (párrafos, viñetas y listas numeradas) y ediciones menores del usuario (autocorrecciones intercaladas). Las marcas de tiempo y la identificación de interlocutores no son compatibles con el modo SMART.

language_config Union type

Obsoleto: Usa language_codes de nivel superior en su lugar. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

languageAuto
(deprecated)

object (LanguageAuto)

Opcional. El modelo detectará el idioma automáticamente.

languageHints
(deprecated)

object (LanguageHints)

Opcional. Especifica uno o más idiomas en el audio.

Fin de los campos mutuamente excluyentes.

Representación JSON

{
  "languageCodes": [
    string
  ],
  "adaptationPhrases": [
    string
  ],
  "customVocabulary": [
    string
  ],
  "wordTimestamp": boolean,
  "diarization": boolean,
  "mode": enum (Mode),

  // language_config
  "languageAuto": {
    object (LanguageAuto)
  },
  "languageHints": {
    object (LanguageHints)
  }
  // Union type
}

LanguageAuto

Este tipo no tiene campos.

Indica que el idioma del audio se debe detectar automáticamente.

LanguageHints

Proporciona sugerencias al modelo sobre los posibles idiomas presentes en el audio.

Campos

languageCodes[]
(deprecated)

string

Obligatorio. Códigos de idioma BCP-47.

Representación JSON
{ "languageCodes": [ string ] }

Modo

Modo de transcripción

Enums
`MODE_UNSPECIFIED`	Modo de transcripción no especificado.
`VERBATIM`	Modo de transcripción literal.
`SMART`	Modo de transcripción inteligente.

RealtimeInputConfig

Configura el comportamiento de entrada en tiempo real en BidiGenerateContent.

Campos

automaticActivityDetection object (AutomaticActivityDetection)

Opcional. Si no se establece, la detección automática de actividad se habilita de forma predeterminada. Si la detección automática de voz está inhabilitada, el cliente debe enviar indicadores de actividad.

activityHandling enum (ActivityHandling)

Opcional. Define el efecto que tiene la actividad.

turnCoverage enum (TurnCoverage)

Opcional. Define qué entrada se incluye en el turno del usuario.

interimTranscriptTimestampEnabled boolean

Opcional. Configura las marcas de tiempo de la transcripción provisional.

Representación JSON

{
  "automaticActivityDetection": {
    object (AutomaticActivityDetection)
  },
  "activityHandling": enum (ActivityHandling),
  "turnCoverage": enum (TurnCoverage),
  "interimTranscriptTimestampEnabled": boolean
}

AutomaticActivityDetection

Configura la detección automática de actividad.

Campos

disabled boolean

Opcional. Si se habilita (configuración predeterminada), la entrada de voz y texto detectada se cuenta como actividad. Si se inhabilita, el cliente debe enviar indicadores de actividad.

startOfSpeechSensitivity enum (StartSensitivity)

Opcional. Determina la probabilidad de que se detecte voz.

prefixPaddingMs integer

Opcional. Es la duración requerida de la voz detectada antes de que se confirme el inicio de la voz. Cuanto menor sea este valor, más sensible será la detección del inicio de la voz y se podrá reconocer una voz más corta. Sin embargo, esto también aumenta la probabilidad de falsos positivos.

endOfSpeechSensitivity enum (EndSensitivity)

Opcional. Determina la probabilidad de que la voz detectada haya finalizado.

silenceDurationMs integer

Opcional. La duración requerida de la ausencia de voz detectada (p.ej., silencio) antes de que se confirme el final de la voz. Cuanto mayor sea este valor, más largos podrán ser los intervalos de voz sin interrumpir la actividad del usuario, pero esto aumentará la latencia del modelo.

Representación JSON
{ "disabled": boolean, "startOfSpeechSensitivity": enum (`StartSensitivity`), "prefixPaddingMs": integer, "endOfSpeechSensitivity": enum (`EndSensitivity`), "silenceDurationMs": integer }

StartSensitivity

Determina cómo se detecta el inicio de la voz.

Enums
`START_SENSITIVITY_UNSPECIFIED`	El valor predeterminado es START_SENSITIVITY_HIGH.
`START_SENSITIVITY_HIGH`	La detección automática detectará el inicio de la voz con más frecuencia.
`START_SENSITIVITY_LOW`	La detección automática detectará el inicio de la voz con menos frecuencia.

EndSensitivity

Determina cómo se detecta el final de la voz.

Enums
`END_SENSITIVITY_UNSPECIFIED`	El valor predeterminado es END_SENSITIVITY_HIGH.
`END_SENSITIVITY_HIGH`	La detección automática finaliza la voz con más frecuencia.
`END_SENSITIVITY_LOW`	La detección automática finaliza la voz con menos frecuencia.

ActivityHandling

Las diferentes formas de controlar la actividad del usuario

Enums
`ACTIVITY_HANDLING_UNSPECIFIED`	Si no se especifica, el comportamiento predeterminado es `START_OF_ACTIVITY_INTERRUPTS`.
`START_OF_ACTIVITY_INTERRUPTS`	Si es verdadero, el inicio de la actividad interrumpirá la respuesta del modelo (también llamada "interrupción"). La respuesta actual del modelo se cortará en el momento de la interrupción. Este es el comportamiento predeterminado.
`NO_INTERRUPTION`	No se interrumpirá la respuesta del modelo.

TurnCoverage

Son opciones sobre qué entrada se incluye en el turno del usuario.

Enums
`TURN_COVERAGE_UNSPECIFIED`	Si no se especifica, se selecciona un comportamiento predeterminado según el modelo. Por ejemplo, para Gemini 2.5, el valor predeterminado es `TURN_INCLUDES_ONLY_ACTIVITY`, mientras que para Gemini 3.1 y versiones posteriores, es `TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO`.
`TURN_INCLUDES_ONLY_ACTIVITY`	Incluye la actividad desde el último turno, sin incluir la inactividad (p.ej., silencio en la transmisión de audio).
`TURN_INCLUDES_ALL_INPUT`	Incluye todas las entradas en tiempo real desde el último turno, incluida la inactividad (p.ej., silencio en la transmisión de audio).
`TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO`	Incluye la actividad de audio y todo el video desde el último turno. Con la detección automática de actividad, la actividad de audio se refiere a la voz y excluye el silencio.

SessionResumptionConfig

Es la configuración de reanudación de la sesión.

Este mensaje se incluye en la configuración de la sesión como BidiGenerateContentSetup.session_resumption. Si se configura, el servidor enviará mensajes de SessionResumptionUpdate.

Campos

handle string

Es el identificador de una sesión anterior. Si no está presente, se crea una sesión nueva.

Los identificadores de sesión provienen de los valores SessionResumptionUpdate.token de las conexiones anteriores.

Representación JSON
{ "handle": string }

ContextWindowCompressionConfig

Habilita la compresión de la ventana de contexto, un mecanismo para administrar la ventana de contexto del modelo de modo que no supere una longitud determinada.

Campos

compression_mechanism Union type

Es el mecanismo de compresión de la ventana de contexto que se usa. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

slidingWindow object (SlidingWindow)

Un mecanismo de ventana deslizante

Fin de los campos mutuamente excluyentes.

triggerTokens string (int64 format)

Es la cantidad de tokens (antes de ejecutar un turno) necesarios para activar una compresión de la ventana de contexto.

Esto se puede usar para equilibrar la calidad con la latencia, ya que las ventanas de contexto más cortas pueden generar respuestas más rápidas del modelo. Sin embargo, cualquier operación de compresión provocará un aumento temporal de la latencia, por lo que no se deben activar con frecuencia.

Si no se establece, el valor predeterminado es el 80% del límite de la ventana de contexto del modelo. Esto deja un 20% para la siguiente solicitud del usuario o respuesta del modelo.

Representación JSON
{ // compression_mechanism "slidingWindow": { object (`SlidingWindow`) } // Union type "triggerTokens": string }

SlidingWindow

El método SlidingWindow funciona descartando el contenido al principio de la ventana de contexto. El contexto resultante siempre comenzará al inicio de un turno de rol de USUARIO. Las instrucciones del sistema y cualquier BidiGenerateContentSetup.prefix_turns siempre permanecerán al principio del resultado.

Campos

targetTokens string (int64 format)

Es la cantidad objetivo de tokens que se conservarán. El valor predeterminado es triggerTokens/2.

Descartar partes de la ventana de contexto provoca un aumento temporal de la latencia, por lo que este valor se debe calibrar para evitar operaciones de compresión frecuentes.

Representación JSON
{ "targetTokens": string }

HistoryConfig

Configuración del historial.

Este mensaje se incluye en la configuración de la sesión como BidiGenerateContentSetup.history_config. Configura el intercambio de mensajes del historial.

Campos

initialHistoryInClientContent boolean

Opcional. Si es verdadero, después de enviar setupComplete, el servidor esperará y, al principio, procesará los mensajes de clientContent hasta que turnComplete sea true. Este historial inicial no activará una llamada al modelo y puede terminar con el rol MODEL. Después de que turnComplete sea true, el cliente puede iniciar la conversación en tiempo real a través de realtimeInput.

Representación JSON
{ "initialHistoryInClientContent": boolean }

Método: auth_tokens.create

Extremo
Cuerpo de la solicitud
Cuerpo de la respuesta
Permisos de autorización

Crea un token que se puede usar para restringir el comportamiento de una sesión de BidiGenerateContent.

Extremo

post https://generativelanguage.googleapis.com/v1beta/auth_tokens

Cuerpo de la solicitud

El cuerpo de la solicitud contiene una instancia de AuthToken.

Campos

expireTime string (Timestamp format)

Si no se establece, el valor predeterminado es de 30 minutos en el futuro. Si se establece, este valor debe ser inferior a 20 horas en el futuro.

newSessionExpireTime string (Timestamp format)

Opcional. Solo entrada. Inmutable. Es el tiempo después del cual se rechazarán las nuevas sesiones de la API de Live que usen el token resultante de esta solicitud.

Si no se establece, el valor predeterminado es de 60 segundos en el futuro. Si se establece, este valor debe ser inferior a 20 horas en el futuro.

fieldMask string (FieldMask format)

Opcional. Solo entrada. Inmutable. Si fieldMask está vacío y bidiGenerateContentSetup no está presente, el mensaje BidiGenerateContentSetup efectivo se toma de la conexión de la API de Live.

Si fieldMask no está vacío, los campos correspondientes de bidiGenerateContentSetup reemplazarán los campos del mensaje de configuración en la conexión de la API de Live.

Esta es una lista separada por comas de los nombres de campos totalmente calificados. Ejemplo: "user.displayName,photo".

config Union type

Es la configuración específica del método para el token resultante. La siguiente es una lista de campos mutuamente excluyentes. Como máximo, se establecerá uno de los campos en una respuesta:

bidiGenerateContentSetup object (BidiGenerateContentSetup)

Opcional. Solo entrada. Inmutable. Configuración específica de BidiGenerateContent.

Fin de los campos mutuamente excluyentes.

uses integer

Cuerpo de la respuesta

Si el proceso se realiza de forma correcta, el cuerpo de la respuesta contiene una instancia recién creada de AuthToken.