Guía de migración del SDK de Agent Platform para Python: versión 2.0.1

El paquete google-cloud-aiplatform incluye el SDK de AI Platform para Python y la biblioteca cliente de Python de Gemini Enterprise Agent Platform. En esta página, se abarcan las siguientes categorías de cambios en el paquete google-cloud-aiplatform:

Precaución: No instales google-cloud-aiplatform==2.0.0. En cambio, trata la versión 2.0.1 como el límite de la versión 2. Si te quedas con el paquete google-cloud-aiplatform, fija google-cloud-aiplatform < 2.0.0 hasta que completes la migración a la versión 2.0.1.

• Los módulos de IA generativa se trasladan al SDK de IA generativa de Google: Los siguientes módulos de IA generativa del paquete vertexai están obsoletos y se migraron al SDK de IA generativa de Google (google-genai):

  • vertexai.generative_models
  • vertexai.language_models
  • vertexai.vision_models
  • vertexai.caching
  • vertexai.tuning

  Si deseas obtener información para migrar los módulos en desuso al SDK de IA generativa de Google, consulta Cómo trasladar los módulos de IA generativa al SDK de IA generativa de Google.

• Reestructuración de la superficie del agente: Se realizaron los siguientes cambios en los módulos de agentplatform de google-cloud-aiplatform:

  • Cambios de nombre
  • Promociones a nivel superior
  • Se quitó el inicializador global

  Para obtener información sobre cómo migrar a la nueva estructura del SDK, consulta Reestructuración del SDK de Agent Platform.

• Desacoplamiento de agentplatform: google-cloud-agentplatform ahora es una distribución independiente y ligera, y la instalación recomendada para las cargas de trabajo del agente. Si solo compilas agentes, instala google-cloud-agentplatform, que no contiene módulos de IA generativa. Los módulos de agentplatform abarcan las integraciones comunes, como [adk], [a2a], [agent_engines], [langchain], [ag2], [llama_index], [evaluation], [bigquery], [live] y [all].

Qué no se verá afectado

La superficie de aprendizaje automático clásica (conjuntos de datos, entrenamiento, modelos, predicción, seguimiento, canalizaciones) es totalmente compatible, no se ve afectada por los cambios de la versión 2.0.1 y no tiene un equivalente en el SDK de IA generativa de Google. Aún puedes acceder a la evaluación, Agent Runtime, las instrucciones y las habilidades si instalas google-cloud-aiplatform. google-cloud-aiplatform y google-genai coexisten en un entorno, y google-genai ahora es una dependencia estricta de google-cloud-aiplatform:

import agentplatform

client = agentplatform.Client(project="my-project", location="global")
# client.evals                  client.prompts
# client.prompt_optimizer client.datasets           client.skills

vertexai.batch_prediction no está en desuso, pero existe un equivalente del SDK de IA generativa de Google que es la herramienta recomendada.

Migración de los módulos de IA generativa al SDK de IA generativa de Google

Si usas los módulos de IA generativa en el paquete google-cloud-aiplatform, sigue estas recomendaciones para migrar al SDK de IA generativa de Google (google-genai):

1. Establece google-cloud-aiplatform < 2.0.0 para que los aumentos de dependencias no relacionadas no puedan quitar los módulos que están debajo de ti.

2. Busca los módulos obsoletos en tu código:

   • vertexai.generative_models
   • vertexai.language_models
   • vertexai.vision_models
   • vertexai.caching
   • vertexai.tuning

   Si importas alguno de los módulos de Python afectados, recibirás la siguiente advertencia de baja:

   UserWarning: This feature is deprecated as of June 24, 2025 and will be removed on
   June 24, 2026. For details, see
   https://cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk.
   

   Ejecuta tu paquete de pruebas con -W error::UserWarning para detectar las importaciones que omitiste.

3. Reemplaza vertexai.init(...) por un genai.Client(enterprise=True, project=..., location=...) explícito. Conserva vertexai.init() si también usas la versión clásica de la plataforma de aprendizaje automático.

   Antes

   # pip install google-cloud-aiplatform
   
   import vertexai
   from vertexai.generative_models import GenerativeModel
   
   vertexai.init(project="my-project", location="us-central1")
   
   # Model identity and config are bound at construction time.
   model = GenerativeModel("gemini-2.5-flash")
   

   Después

   # pip install google-genai
   
   from google import genai
   from google.genai import types
   
   client = genai.Client(
       enterprise=True,
       project="my-project",
       location="global",
   )
   

   O bien, configúralo desde el entorno:

   export GOOGLE_GENAI_USE_ENTERPRISE=true
   export GOOGLE_CLOUD_PROJECT=my-project
   export GOOGLE_CLOUD_LOCATION=global
   

   from google import genai
   
   client = genai.Client()
   

   Consideraciones clave:

   • El estado global se convierte en un cliente explícito. vertexai.init() configuró todo el proceso; genai.Client() es un objeto que pasas. Con genai.Client(), puedes usar dos proyectos o regiones en un solo proceso.
   • El campo enterprise=True es obligatorio. Si lo omites, el cliente segmenta de forma silenciosa la API de Gemini Developer, que luego falla en las credenciales predeterminadas de la aplicación o exige una clave de API.
   • El nombre del modelo se mueve de la construcción a cada llamada. No hay ningún objeto de modelo de vinculación única. model= es un argumento de palabra clave obligatorio en cada llamada a client.models.*.
   • La autenticación no cambió. Las credenciales predeterminadas de la aplicación siguen vigentes, y credentials= acepta un google.auth.credentials.Credentials en ambos SDKs.
   • vertexai.init() también incluía parámetros de configuración no generativos, como staging_bucket, experiment, encryption_spec_key_name, service_account y network. genai.Client no tiene un equivalente para ellos.
   • La ortografía más reciente enterprise=True se acepta a partir de google-genai 2.20.0, pero la versión anterior vertexai=True funciona en todas las versiones y es la opción más segura.

4. Audita tu código para detectar cambios silenciosos en los que el comportamiento diverge sin errores. Se compilan y ejecutan, pero cambian de significado.

   Comportamiento	Antes	Después
   response.text en una respuesta bloqueada o vacía	Se genera el error ValueError	Devuelve None
   response.text con varios candidatos	Se genera el error ValueError	Registra una advertencia y devuelve el primer candidato
   Segmentación por cliente	vertexai.init() Agent Platform implícita	Si se omite vertexai=True, se segmenta de forma silenciosa la API de Gemini Developer
   Incorporaciones auto_truncate	La configuración predeterminada es True	Sin definir; se aplica la configuración predeterminada del servidor
   Una función de Python que se pasa como herramienta	No compatible	El SDK lo ejecuta automáticamente
   system_instruction	Se une una vez al modelo	Se debe pasar en cada llamada.

   El cambio de response.text es el que se debe buscar primero. Cada try/except ValueError que se incluye en .text se convierte en código inactivo, y cada .text sin protección ahora puede generar None donde antes se devolvía un str:

   if response.text is None:
       print(
           "blocked or empty:",
           response.prompt_feedback,
           response.candidates[0].finish_reason if response.candidates else None,
       )
   

5. Mantén google-cloud-aiplatform instalado si usas la evaluación, Agent Runtime, las instrucciones, los conjuntos de datos, las habilidades y toda la superficie clásica del aprendizaje automático.

6. Cambia las llamadas a las versiones nuevas. Comienza con los cambios de nombre mecánicos y, luego, continúa con la consolidación de config=.

Cambios en las llamadas basados en tareas

Consulta las llamadas modificadas según la tarea:

• Generación de texto
• Generación de transmisión
• Generación asíncrona
• Sesiones de chat
• Configuración, parámetros de seguridad y consignas del sistema
• Entrada multimodal
• Llamadas a funciones y fundamentación
• Embeddings
• Recuento de tokens
• Almacenamiento en caché del contexto
• Predicción y ajuste por lotes

Generación de texto

Para las tareas de generación de texto, todos los argumentos son solo de palabras clave. Las llamadas posicionales aumentan TypeError.

Antes

model = GenerativeModel("gemini-2.5-flash")

response = model.generate_content("Why is the sky blue?")
print(response.text)

Después

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Why is the sky blue?",
)
print(response.text)

Generación de transmisión

Se quitó la marca stream=True para las tareas de generación de transmisión. La transmisión ahora es un método independiente que devuelve Iterator[types.GenerateContentResponse]. Usa if chunk.text: para verificar antes de acceder al texto, ya que cada fragmento es un objeto de respuesta completo y su atributo .text a veces puede ser None.

Antes

stream = model.generate_content("Tell me a story in 300 words.", stream=True)
for chunk in stream:
    print(chunk.text, end="")

Después

for chunk in client.models.generate_content_stream(
    model="gemini-3.5-flash",
    contents="Tell me a story in 300 words.",
):
    if chunk.text:
        print(chunk.text, end="")

Generación asíncrona

En el caso de las tareas de generación asíncronas, se quitó el sufijo _async del nombre del método. Cada llamada asíncrona se encuentra en client.aio.<module> con el mismo nombre de método que su contraparte síncrona. Cierra el cliente con await client.aio.aclose() o usa async with genai.Client(...).aio as aclient:.

Antes

response = await model.generate_content_async("Why is the sky blue?")

async_stream = await model.generate_content_async("Why is the sky blue?", stream=True)
async for chunk in async_stream:
    print(chunk.text, end="")

Después

response = await client.aio.models.generate_content(
    model="gemini-3.5-flash",
    contents="Why is the sky blue?",
)

# Note the `await` in front of the async iterator.
async for chunk in await client.aio.models.generate_content_stream(
    model="gemini-3.5-flash",
    contents="Tell me a story in 300 words.",
):
    print(chunk.text, end="")

Sesiones de chat

Ten en cuenta los siguientes cambios en las tareas de sesiones de chat:

• Los chats se crean desde el cliente, no desde un objeto modelo.
• chat.history (propiedad) se convierte en chat.get_history() (método). El nuevo método toma curated: bool = False. Si se pasa True, solo se devuelven los giros conservados, que no tienen un equivalente anterior.
• client.aio.chats.create(...) devuelve un AsyncChat directamente. Solo se esperan send_message y send_message_stream.
• Las opciones por turno se contraen en un solo argumento: send_message(message, config=types.GenerateContentConfig(...)). También se cambió el nombre del primer parámetro de content a message.

• start_chat(response_validation=False) es un método nuevo que no tiene un equivalente en versiones anteriores.

Antes

model = GenerativeModel("gemini-2.5-flash")
chat = model.start_chat()

print(chat.send_message("Tell me a story").text)

for content in chat.history:
    print(content.role, content.parts)

Después

chat = client.chats.create(model="gemini-3.5-flash")

print(chat.send_message("Tell me a story").text)

for content in chat.get_history():
    print(content.role, content.parts)

Configuración, parámetros de seguridad y sistema de instrucciones

Ten en cuenta los siguientes cambios en las tareas de configuración, los parámetros de seguridad y las instrucciones del sistema:

• Los siguientes argumentos se contraen en un solo config= como campos de GenerateContentConfig:

  • generation_config
  • safety_settings
  • tools
  • tool_config
  • labels
  • system_instruction

  Un dict simple funciona en cualquier lugar donde funciona un tipo de configuración.

• system_instruction se mueve del constructor del modelo a la configuración por llamada. En la versión anterior del SDK, system_instruction se configuraba una vez cuando se compilaba GenerativeModel. Ahora, system_instruction se debe pasar en cada llamada o incluirse en client.chats.create(config=...).

• La configuración de seguridad cambia de dict a list. Por ejemplo, [types.SafetySetting(category=c, threshold=t) for c, t in old_dict.items()].

• Los enums se aceptan como cadenas simples y se coercionan.

• Los nombres de los campos escalares no cambian: temperature, top_p, top_k, candidate_count, max_output_tokens, stop_sequences, presence_penalty, frequency_penalty, seed, response_mime_type, response_schema, response_logprobs, logprobs.

• Los campos nuevos sin un equivalente anterior incluyen thinking_config, cached_content, automatic_function_calling, http_options, media_resolution y speech_config.

Antes

from vertexai.generative_models import (
    GenerativeModel, GenerationConfig, HarmCategory, HarmBlockThreshold,
)

model = GenerativeModel(
    "gemini-2.5-flash",
    system_instruction=["Talk like a pirate.", "Don't use rude words."],
)

response = model.generate_content(
    contents="Why is the sky blue?",
    generation_config=GenerationConfig(temperature=0, top_p=0.95, max_output_tokens=100),
    safety_settings={
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    },
)

Después

from google.genai import types

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Why is the sky blue?",
    config=types.GenerateContentConfig(
      system_instruction="Talk like a pirate. Don't use rude words.",
      temperature=0,
      top_p=0.95,
      max_output_tokens=100,
      safety_settings=[
          types.SafetySetting(
              category="HARM_CATEGORY_HATE_SPEECH",
              threshold="BLOCK_MEDIUM_AND_ABOVE",
          ),
          types.SafetySetting(
              category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
              threshold=types.HarmBlockThreshold.BLOCK_ONLY_HIGH,
          ),
      ],
    ),
)

Entrada multimodal

Ten en cuenta los siguientes cambios para las tareas de entrada multimodal:

Antigua	Nuevo
Part.from_uri(uri, mime_type), se permite la posición	Part.from_uri(file_uri=, mime_type=), solo palabras clave, se cambió el nombre del parámetro
Part.from_data(data, mime_type)	Part.from_bytes(data=, mime_type=), se cambió el nombre del método
Part.from_text(text)	Part.from_text(text=), solo palabras clave
Image.load_from_file(path)	No hay equivalente; abre el archivo y usa Part.from_bytes.

• mime_type es opcional en types.Part.from_uri() (se infiere del servidor), pero sigue siendo obligatorio en types.Part.from_bytes().

• client.files.upload(...) solo se admite en la API de Gemini Developer. Para las cargas de trabajo de Agent Platform, sigue pasando los URIs de Cloud Storage con from_uri o los bytes intercalados con from_bytes.

Antes

from vertexai.generative_models import GenerativeModel, Part, Image

image = Image.load_from_file("image.jpg")
print(model.generate_content(["What is shown in this image?", image]).text)

image_part = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg",
    mime_type="image/jpeg",
)

Después

from google.genai import types

# Image.load_from_file has no equivalent: read the bytes yourself.
with open("image.jpg", "rb") as f:
    image = types.Part.from_bytes(data=f.read(), mime_type="image/jpeg")

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents=["What is shown in this image?", image],
)

image_part = types.Part.from_uri(
    file_uri="gs://cloud-samples-data/generative-ai/image/scones.jpg",
    mime_type="image/jpeg",
)

Llamada a función y fundamentación

Ten en cuenta los siguientes cambios para las tareas de llamada a función y fundamentación:

• Las herramientas se mueven a config=. No hay ningún argumento tools= en la llamada ni en un objeto del modelo.
• Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval()) se convierte en types.Tool(google_search=types.GoogleSearch()). Un método de fábrica se convierte en un campo simple. types.Tool también tiene un campo google_search_retrieval independiente.
• response.function_calls es el descriptor de acceso idiomático y no falla cuando la parte cero resulta ser texto. El recorrido anterior sigue funcionando.
• El esquema JSON sin procesar se especifica en parameters_json_schema. Se especifica un types.Schema con tipo en parameters.
• Ahora puedes pasar una función de Python como herramienta, y la llamada automática a funciones está activada de forma predeterminada cuando pasas la función. Si transfieres un bucle de herramientas manual y pasas un objeto de función, el SDK comenzará a ejecutar tu código. Inhabilita la llamada a función automática predeterminada con automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True).

• Los siguientes tipos de herramientas nuevas no tienen equivalentes en versiones anteriores: code_execution, url_context, google_maps, computer_use, file_search, enterprise_web_search y mcp_servers.

Antes

from vertexai.generative_models import GenerativeModel, FunctionDeclaration, Tool, grounding

weather_tool = Tool(function_declarations=[
    FunctionDeclaration(
        name="get_current_weather",
        description="Get the current weather in a given location",
        parameters={
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"],
        },
    )
])

model = GenerativeModel("gemini-2.5-flash", tools=[weather_tool])
response = model.generate_content("What is the weather in Boston?")
call = response.candidates[0].content.parts[0].function_call

# Grounding
search_tool = Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval())

Después

from google.genai import types

weather_tool = types.Tool(function_declarations=[
    types.FunctionDeclaration(
        name="get_current_weather",
        description="Get the current weather in a given location",
        parameters_json_schema={
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"],
        },
    )
])

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="What is the weather in Boston?",
    config=types.GenerateContentConfig(tools=[weather_tool]),
)
call = response.function_calls[0]

# Grounding
search_tool = types.Tool(google_search=types.GoogleSearch())

Incorporaciones

Ten en cuenta los siguientes cambios para las tareas de incorporación:

• Se quitó TextEmbeddingInput. task_type y title ahora son por solicitud, por lo que los lotes de tareas mixtas se deben dividir en varias llamadas.
• El tipo de datos que se devuelve cambió de una lista directa a un objeto de respuesta. get_embeddings() devolvió directamente un list[TextEmbedding], por lo que los llamadores indexaron la lista directamente (embeddings[0].values). En la nueva versión, embed_content() devuelve un objeto EmbedContentResponse que contiene una lista .embeddings, lo que requiere que accedas a response.embeddings[0].values. Los campos de incorporación individuales (.values y .statistics) conservan sus nombres originales.

• auto_truncate ya no se establece de forma predeterminada en True. El nuevo campo se establece como unset de forma predeterminada. Si dependes del truncamiento silencioso de entradas demasiado largas, configura auto_truncate de forma explícita.

Antes

from vertexai.language_models import TextEmbeddingModel, TextEmbeddingInput

model = TextEmbeddingModel.from_pretrained("gemini-embedding-001")

text_input = TextEmbeddingInput(
    text="How do I get a driver's license?",
    task_type="RETRIEVAL_DOCUMENT",   # per input
    title="Driver's License",         # per input
)

embeddings = model.get_embeddings([text_input], output_dimensionality=3072, auto_truncate=True)
print(embeddings[0].values)

Después

from google.genai import types

response = client.models.embed_content(
    model="gemini-embedding-2",
    contents="How do I get a driver's license?",
    config=types.EmbedContentConfig(
        task_type="RETRIEVAL_DOCUMENT",   # now per request
        title="Driver's License",         # now per request
        output_dimensionality=3072,
        auto_truncate=True,
    ),
)
print(response.embeddings[0].values)

Recuento de tokens

Ten en cuenta los siguientes cambios en las tareas de recuento de tokens:

• Se quitó total_billable_characters y no tiene reemplazo. Cualquier estimación de costos basada en total_billable_characters debe modificarse (por ejemplo, en función de total_tokens o response.usage_metadata) a partir de una llamada de generación.
• Se agregó client.models.compute_tokens(...) para los IDs de tokens y las partes de cadenas.

• Se agregó el recuento sin conexión a través de google.genai.local_tokenizer.LocalTokenizer.

Antes

model = GenerativeModel("gemini-2.5-flash")

response = model.count_tokens(["Why is the sky blue?"])
print(response.total_tokens)
print(response.total_billable_characters)

Después

response = client.models.count_tokens(
    model="gemini-3.5-flash",
    contents=["Why is the sky blue?"],
)
print(response.total_tokens)
print(response.cached_content_token_count)

El almacenamiento de contexto en caché

Ten en cuenta los siguientes cambios para las tareas de almacenamiento en caché del contexto:

• ttl cambia de tipo de datetime.timedelta a una cadena de duración, como "86400s".
• Los métodos de objetos de recursos se convierten en llamadas de módulos de clientes.

• update devuelve un objeto nuevo en lugar de mutar en su lugar.

Antes

import datetime
from vertexai.caching import CachedContent

cache = CachedContent.create(
    model_name="gemini-2.5-flash",
    system_instruction="Please answer my question formally",
    contents=contents,
    ttl=datetime.timedelta(days=1),
)
cache.update(ttl=datetime.timedelta(days=2))
cache.delete()

Después

from google.genai import types

cache = client.caches.create(
    model="gemini-3.5-flash",
    config=types.CreateCachedContentConfig(
        contents=contents,
        system_instruction="Please answer my question formally",
        ttl="86400s",
    ),
)
cache = client.caches.update(
    name=cache.name, config=types.UpdateCachedContentConfig(ttl="172800s")
)
client.caches.delete(name=cache.name)

Ajuste y predicción por lotes

Ten en cuenta los siguientes cambios para las tareas de predicción por lotes y ajuste:

• El sondeo se basa en la revinculación, no en la vinculación in situ. No hay job.refresh() ni job.has_ended. Recupera un objeto nuevo de client.batches.get(name=...) y compara job.state con las cadenas de JOB_STATE_*.
• Cambios de nombre por lotes: source_model por model, input_dataset por src, output_uri_prefix por config.dest y job_display_name por config.display_name.
• Se quitaron los controles de forma automática por lotes, y no tienen un equivalente en la nueva versión del SDK. machine_type, accelerator_type, accelerator_count, starting_replica_count y max_replica_count ya no son campos de CreateBatchJobConfig.
• Se cambiaron los nombres de los siguientes métodos:
  • De sft.train a client.tunings.tune
  • De source_model a base_model
  • De train_dataset a training_dataset
  • De epochs a epoch_count
• Los conjuntos de datos de ajuste se encapsulan. Una cadena "gs://..." sin formato se convierte en types.TuningDataset(gcs_uri=...).

• adapter_size cambia de un int a una cadena de enumeración, como "ADAPTER_SIZE_FOUR".

Antes

from vertexai.batch_prediction import BatchPredictionJob
from vertexai.tuning import sft

job = BatchPredictionJob.submit(
    source_model="gemini-2.5-flash",
    input_dataset="bq://my-project.my-dataset.my-table",
    output_uri_prefix="bq://my-project.my-dataset.output",
)
while not job.has_ended:
    job.refresh()

tuning_job = sft.train(
    source_model="gemini-2.5-flash",
    train_dataset="gs://bucket/train.jsonl",
    epochs=1,
    adapter_size=4,
)

Después

from google.genai import types

job = client.batches.create(
    model="gemini-3.5-flash",
    src="bq://my-project.my-dataset.my-table",
    config=types.CreateBatchJobConfig(dest="bq://my-project.my-dataset.output"),
)
completed = {"JOB_STATE_SUCCEEDED", "JOB_STATE_FAILED", "JOB_STATE_CANCELLED", "JOB_STATE_PAUSED"}
while job.state not in completed:
    job = client.batches.get(name=job.name)

tuning_job = client.tunings.tune(
    base_model="gemini-3.5-flash",
    training_dataset=types.TuningDataset(gcs_uri="gs://bucket/train.jsonl"),
    config=types.CreateTuningJobConfig(
        epoch_count=1,
        adapter_size="ADAPTER_SIZE_FOUR",
    ),
)

Reestructuración del SDK de Agent Platform

Si usas los módulos agentplatform de google-cloud-aiplatform, sigue estas recomendaciones para migrar a la nueva estructura del SDK:

1. google-cloud-agentplatform ahora es una distribución independiente y ligera, y la instalación recomendada para las cargas de trabajo del agente. Si no necesitas la experiencia clásica de aprendizaje automático, cambia la instalación de pip install google-cloud-aiplatform a pip install google-cloud-agentplatform.

2. Usa la siguiente tabla para actualizar las importaciones y las rutas de atributos:

   Anterior	Nuevo
   client.agent_engines.create	client.runtimes.create (Implementa una instancia de Agent Runtime en Gemini Enterprise Agent Platform, que proporciona configuración integrada de sesiones, ejecución de código en zona de pruebas y memoria de contexto) client.memory_banks.create (Crea recursos independientes de Memory Bank para conservar, administrar y recuperar recuerdos en las interacciones)
   client.agent_engines.sandboxes	client.sandboxes
   client.agent_engines.sandboxes.snapshots	client.sandboxes.snapshots
   client.agent_engines.sandboxes.templates	client.sandboxes.templates
   client.agent_engines.sessions	client.sessions
   client.agent_engines.sessions.events	client.sessions.events
   client.agent_engines.runtimes.revisions	client.runtimes.revisions
   client.agent_engines.memories	client.memory_banks.memories
   agentplatform.agent_engines.templates	agentplatform.frameworks

3. Se quita el inicializador global, y los frameworks de agentes ya no leen el proyecto ni la ubicación del estado de aiplatform.init() o vertexai.init(). Reemplaza la configuración derivada del inicializador por variables de entorno para todo lo que se ejecute dentro de un framework de agentes. El código que depende del inicializador para configurar los agentes implementados se interrumpe de forma silenciosa en lugar de generar un error.

4. Actualiza los sitios de llamadas de evals.run_inference(agent=...) para que pasen types.Runtime, ya que el SDK ya no acepta types.AgentEngine.

5. Realiza los siguientes cambios:

   • De vertexai.Client a agentplatform.Client
   • De vertexai.rag a agentplatform.Client().rag

   vertexai.Client emite un FutureWarning en la primera instancia:

   The vertexai.Client class is deprecated. Please use agentplatform.Client instead.
   

   vertexai.rag emite un UserWarning en el momento de la importación del módulo, no en la llamada. Migra a lo siguiente:

   import agentplatform
   
   client = agentplatform.Client(project="your-project", location="global")
   client.rag.create_corpus(...)
   

6. Se actualizó el manejo de errores en torno a las llamadas de AdkApp y de sesión. Los métodos de sesión síncronos y las ejecuciones de agentes de transmisión ahora muestran el error de la API subyacente. Las personas que llaman que detectan un error genérico encapsulado ya no coinciden. Reemplaza las capturas de excepciones genéricas del wrapper de la biblioteca por google.api_core.exceptions.GoogleAPICallError (o errores de estado específicos, como ResourceExhausted y NotFound).

7. Actualiza los llamadores de clientes o el middleware para incluir el token de acceso de OAuth del usuario en cada solicitud, ya que los tokens ahora son efímeros y no se conservan con el estado de la sesión. Asegúrate de que la actualización del token se administre del lado del cliente.

8. Ten en cuenta que el módulo a2a.tasks se quitó sin reemplazo.