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 Agent Platform para Python y la biblioteca cliente de Agent Platform para Python. 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 su lugar, trata la versión 2.0.1 como el límite de la versión 2. Si permaneces en 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 dejaron de estar disponibles 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

  Para aprender a migrar los módulos obsoletos al SDK de IA generativa de Google, consulta Mueve módulos de IA generativa al SDK de IA generativa de Google.

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

  • Cambios de nombre
  • Promociones al nivel superior
  • Eliminación del inicializador global

  Para aprender a migrar a la nueva estructura del SDK, consulta Reestructuración del SDK de Agent Platform.

• Desvinculación de agentplatform: google-cloud-agentplatform ahora es una distribución ligera independiente y la instalación recomendada para las cargas de trabajo de agentes. 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 plataforma de aprendizaje automático clásica (conjuntos de datos, entrenamiento, modelos, predicción, seguimiento y 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. Puedes seguir accediendo a la evaluación, Agent Runtime, las instrucciones y las habilidades instalando google-cloud-aiplatform. Tanto google-cloud-aiplatform como 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á obsoleto, pero existe un equivalente del SDK de IA generativa de Google y es la herramienta recomendada.

Mover 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 relacionados no puedan quitar los módulos que se encuentran 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 te faltaron.

3. Reemplaza vertexai.init(...) por un genai.Client(enterprise=True, project=..., location=...) explícito. Conserva vertexai.init() si también usas la plataforma clásica 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, configura 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() configura todo el proceso; genai.Client() es un objeto que pasas. Con genai.Client(), puedes usar dos proyectos o regiones en un proceso.
   • El campo enterprise=True es obligatorio. Si lo omites, el cliente se orienta de forma silenciosa a 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 un 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 cambia. Las credenciales predeterminadas de la aplicación siguen aplicándose, 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 de 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 difiera sin un error. Estos se compilan y ejecutan, pero cambian de significado.

   Comportamiento	Antes	Después
   response.text en una respuesta bloqueada o vacía	Genera ValueError	Devuelve None
   response.text con varios candidatos	Genera ValueError	Registra una advertencia y devuelve el primer candidato
   Segmentación de clientes	vertexai.init() de Agent Platform implícitos	Si omites vertexai=True, se orienta de forma silenciosa a la API de Gemini Developer
   Embeddings 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 una herramienta	No compatible	El SDK lo ejecuta automáticamente.
   system_instruction	Se vincula una vez en el modelo	Se debe pasar en cada llamada.

   El cambio de response.text es el primero que se debe buscar. Cada try/except ValueError que se une a .text se convierte en código muerto, 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 plataforma de aprendizaje automático clásica.

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 basadas en tareas

Consulta las llamadas modificadas según la tarea:

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

Generación de texto

Para las tareas de generación de texto, todos los argumentos son solo de palabras clave. Las llamadas posicionales generan 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 transmisiones

Para las tareas de generación de transmisión, se quita la marca stream=True. 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

Para las tareas de generación asíncronas, se quitó el sufijo del nombre del método _async. 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 las sesiones de chat:

• Los chats se crean desde el cliente, no desde un objeto de modelo.
• chat.history (propiedad) se convierte en chat.get_history() (método). El método nuevo toma curated: bool = False. Pasar True solo devuelve los turnos conservados, que no tienen un equivalente antiguo.
• 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 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 equivalente en las 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 e instrucciones del sistema

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

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

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

  Un dict simple funciona en cualquier lugar donde funcione 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, se debe pasar system_instruction 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 sin formato y se convierten.

• De lo contrario, los nombres de los campos escalares no se modifican: 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.

• Entre los campos nuevos sin equivalente anterior, se 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 permiten argumentos posicionales	Se cambió el nombre del parámetro Part.from_uri(file_uri=, mime_type=), que solo acepta palabras clave
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 lado 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 funciones y fundamentación

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

• Las herramientas se mueven a config=. No hay ningún argumento tools= en la llamada ni en un objeto de 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 es 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 una herramienta, y la llamada a función automática está activada de forma predeterminada cuando pasas la función. Si portas un bucle de herramientas manual y pasas un objeto de función, el SDK comienza a ejecutar tu código. Inhabilita la llamada a funciones automática predeterminada con automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True).

• Los siguientes tipos de herramientas nuevos no tienen equivalentes en las 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 se realizan 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() devolvía directamente un list[TextEmbedding], por lo que los emisores indexaban 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 campo nuevo se establece de forma predeterminada en unset. 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 para 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 volver a calcularse (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 en las tareas de almacenamiento en caché de contexto:

• ttl cambia el 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 cliente.

• update devuelve un objeto nuevo en lugar de mutar en el 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)

Predicción por lotes y ajuste

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 el lugar. No hay job.refresh() ni job.has_ended. Recupera un objeto nuevo de client.batches.get(name=...) y compara job.state con las cadenas JOB_STATE_*.
• Se cambiaron los nombres de los 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 de máquina 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 unen. Una cadena "gs://..." simple se convierte en types.TuningDataset(gcs_uri=...).

• adapter_size cambia el tipo 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 ligera independiente y la instalación recomendada para las cargas de trabajo de agentes. Si no necesitas la plataforma de aprendizaje automático clásica, 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 acceso de los atributos:

   Anterior	Nuevo
   client.agent_engines.create	client.runtimes.create (Implementa una instancia de Agent Runtime en Gemini Enterprise Agent Platform, que proporciona sesiones de Agent Platform integradas, ejecución de código de zona de pruebas y configuración de memoria de contexto) client.memory_banks.create (Crea recursos independientes de Agent Platform Memory Bank para conservar, administrar y recuperar memorias en todas 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 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 pasar 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 creación de una 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. Actualiza 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. Los emisores que detectan un error genérico unido ya no coinciden. Reemplaza las capturas de excepciones genéricas de wrapper de biblioteca por google.api_core.exceptions.GoogleAPICallError (o errores de estado específicos, como ResourceExhausted y NotFound).

7. Actualiza los emisores de llamadas o el middleware del cliente 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 de tokens se administre del lado del cliente.

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