Guia de migração do SDK da Agent Platform para Python: versão 2.0.1

O pacote google-cloud-aiplatform inclui o SDK do AI Platform para Python e a biblioteca de cliente Python da Gemini Enterprise Agent Platform. Esta página aborda as seguintes categorias de mudanças no pacote google-cloud-aiplatform:

Cuidado:não instale google-cloud-aiplatform==2.0.0. Em vez disso, trate 2.0.1 como o limite da versão 2. Se você continuar no pacote google-cloud-aiplatform, fixe google-cloud-aiplatform < 2.0.0 até concluir a migração para a versão 2.0.1.

• Os módulos de IA generativa são movidos para o SDK de IA Generativa do Google: os seguintes módulos de IA generativa no pacote vertexai foram descontinuados e migrados para o SDK de IA Generativa do Google (google-genai):

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

  Para saber como migrar os módulos descontinuados para o SDK de IA generativa do Google, consulte Migrar módulos de IA generativa para o SDK de IA generativa do Google.

• Reestruturação da interface do agente:as seguintes mudanças foram feitas nos módulos agentplatform do google-cloud-aiplatform:

  • Renomeações
  • Promoções para o nível superior
  • Remoção do inicializador global

  Para saber como migrar para a nova estrutura do SDK, consulte Reestruturação do SDK da Agent Platform.

• Desacoplamento de agentplatform: google-cloud-agentplatform agora é uma distribuição independente e leve, além de ser a instalação recomendada para cargas de trabalho do agente. Se você só criar agentes, instale o google-cloud-agentplatform, que não contém módulos de IA generativa. Os módulos agentplatform abrangem as integrações comuns, como [adk], [a2a], [agent_engines], [langchain], [ag2], [llama_index], [evaluation], [bigquery], [live] e [all].

O que não será afetado

A plataforma clássica de aprendizado de máquina (conjuntos de dados, treinamento, modelos, previsão, rastreamento, pipelines) tem suporte total, não é afetada pelas mudanças da versão 2.0.1 e não tem equivalente no SDK de IA generativa do Google. Você ainda pode acessar a avaliação, o Agent Runtime, os comandos e as habilidades instalando o google-cloud-aiplatform. google-cloud-aiplatform e google-genai coexistem em um ambiente, e google-genai agora é uma dependência rígida 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 não está descontinuado, mas existe um equivalente no SDK de IA generativa do Google, que é a ferramenta recomendada.

Como mover módulos de IA generativa para o SDK de IA generativa do Google

Se você usa os módulos de IA generativa no pacote google-cloud-aiplatform, siga estas recomendações para migrar para o SDK de IA Generativa do Google (google-genai):

1. Defina google-cloud-aiplatform < 2.0.0 para que aumentos de dependências não relacionadas não possam remover os módulos abaixo de você.

2. Procure os módulos descontinuados no seu código:

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

   Se você importar algum dos módulos Python afetados, vai receber o seguinte aviso de descontinuação:

   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.
   

   Execute o conjunto de testes com -W error::UserWarning para detectar importações que você perdeu.

3. Substitua vertexai.init(...) por um genai.Client(enterprise=True, project=..., location=...) explícito. Mantenha vertexai.init() se você também usa a interface clássica de machine learning.

   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")
   

   Depois

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

   Ou configure no ambiente:

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

   from google import genai
   
   client = genai.Client()
   

   Principais considerações:

   • O estado global se torna um cliente explícito. vertexai.init() configurou todo o processo; genai.Client() é um objeto que você transmite. Com o genai.Client(), é possível usar dois projetos ou regiões em um processo.
   • enterprise=True é obrigatório. Se você omitir esse parâmetro, o cliente vai direcionar silenciosamente a API Gemini Developer, que vai falhar nas credenciais padrão do aplicativo ou exigir uma chave de API.
   • O nome do modelo passa da construção para cada chamada. Não há um objeto de modelo de vinculação única. model= é um argumento de palavra-chave obrigatório em cada chamada client.models.*.
   • A autenticação não foi alterada. As credenciais padrão do aplicativo ainda são válidas, e o credentials= aceita um google.auth.credentials.Credentials nos dois SDKs.
   • O vertexai.init() também tinha configurações não generativas, como staging_bucket, experiment, encryption_spec_key_name, service_account e network. genai.Client não tem um equivalente para eles.
   • A grafia mais recente enterprise=True é aceita a partir da versão 2.20.0 do google-genai, mas a versão mais antiga vertexai=True funciona em todas as versões e é a opção mais segura.

4. Audite seu código para mudanças silenciosas em que o comportamento diverge sem um erro. Elas compilam e são executadas, mas mudam de significado.

   Comportamento	Antes	Depois
   response.text em uma resposta bloqueada ou vazia	Gera ValueError	Retorna None
   response.text com vários candidatos	Gera ValueError	Registra um aviso e retorna o primeiro candidato.
   Segmentação por cliente	vertexai.init() Agent Platform implícita	Omitir vertexai=True silenciosamente tem como destino a API Gemini Developer
   Embeddings auto_truncate	O valor padrão é True.	Não definido; o padrão do servidor é aplicado
   Uma função Python transmitida como uma ferramenta	Sem suporte	Executado automaticamente pelo SDK
   system_instruction	Vinculado uma vez ao modelo	Precisa ser transmitido em todas as chamadas

   A mudança response.text é a primeira a ser pesquisada. Todo try/except ValueError envolvido em .text se torna código morto, e todo .text sem proteção agora pode gerar None, em vez de um str, como acontecia antes:

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

5. Mantenha o google-cloud-aiplatform instalado se você usa avaliação, Agent Runtime, comandos, conjuntos de dados, habilidades e toda a superfície clássica de aprendizado de máquina.

6. Mude as chamadas para as novas versões. Comece com renomeações mecânicas e continue com a consolidação de config=.

Mudanças nas chamadas com base em tarefas

Confira as chamadas alteradas com base na tarefa:

• Geração de texto
• Geração de streaming
• Geração assíncrona
• Sessões de chat
• Configuração, configurações de segurança e instruções do sistema
• Entrada multimodal
• Chamada de função e embasamento
• Embeddings
• Contagem de tokens
• Cache de contexto
• Previsão e ajuste em lote

Geração de texto

Para tarefas de geração de texto, todos os argumentos são somente palavras-chave. Chamadas posicionais geram TypeError.

Antes

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

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

Depois

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

Geração de streaming

Para tarefas de geração de streaming, a flag stream=True é removida. O streaming agora é um método separado que retorna Iterator[types.GenerateContentResponse]. Use if chunk.text: para verificar antes de acessar o texto, porque cada parte é um objeto de resposta completo, e o atributo .text às vezes pode ser None.

Antes

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

Depois

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="")

Geração assíncrona

Para tarefas de geração assíncronas, o sufixo "method-name" _async foi removido. Cada chamada assíncrona fica em client.aio.<module> com o mesmo nome de método da contraparte síncrona. Feche o cliente com await client.aio.aclose() ou use 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="")

Depois

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="")

Sessões de chat

Confira as seguintes mudanças nas tarefas de sessões de chat:

• Os chats são criados pelo cliente, não por um objeto de modelo.
• chat.history (propriedade) se torna chat.get_history() (método). O novo método usa curated: bool = False. Transmitir True retorna apenas os turnos mantidos, que não têm um equivalente antigo.
• client.aio.chats.create(...) retorna um AsyncChat diretamente. Somente send_message e send_message_stream são aguardados.
• As opções por turno são recolhidas em um argumento: send_message(message, config=types.GenerateContentConfig(...)). O primeiro parâmetro também foi renomeado de content para message.

• start_chat(response_validation=False) é um novo método sem equivalente em versões 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)

Depois

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)

Configuração, configurações de segurança e instruções do sistema

Confira as seguintes mudanças nas tarefas de configuração, configurações de segurança e instruções do sistema:

• Os argumentos a seguir são recolhidos em um config= como campos de GenerateContentConfig:

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

  Um dict simples funciona em qualquer lugar que um tipo de configuração funcione.

• system_instruction passa do construtor do modelo para a configuração por chamada. Na versão anterior do SDK, system_instruction era definido uma vez ao criar GenerativeModel. Agora, system_instruction precisa ser transmitido em todas as chamadas ou incluído em client.chats.create(config=...).

• As configurações de segurança mudam de dict para list. Por exemplo, [types.SafetySetting(category=c, threshold=t) for c, t in old_dict.items()].

• As enumerações são aceitas como strings simples e forçadas.

• Os nomes de campos escalares não mudam: 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.

• Os novos campos sem equivalentes antigos incluem thinking_config, cached_content, automatic_function_calling, http_options, media_resolution e 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,
    },
)

Depois

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

Confira as seguintes mudanças para tarefas de entrada multimodal:

Antigo	Novo
Part.from_uri(uri, mime_type), posicional permitida	Part.from_uri(file_uri=, mime_type=), somente palavra-chave, parâmetro renomeado
Part.from_data(data, mime_type)	Part.from_bytes(data=, mime_type=), método renomeado
Part.from_text(text)	Part.from_text(text=), somente palavra-chave
Image.load_from_file(path)	Não há equivalente. Abra o arquivo e use Part.from_bytes.

• mime_type é opcional em types.Part.from_uri() (inferido do lado do servidor), mas continua sendo obrigatório em types.Part.from_bytes().

• O client.files.upload(...) só é compatível com a API Gemini Developer. Para cargas de trabalho da Agent Platform, continue transmitindo URIs do Cloud Storage usando from_uri ou bytes inline usando 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",
)

Depois

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",
)

Chamada de função e embasamento

Confira as seguintes mudanças nas tarefas de chamada de função e embasamento:

• As ferramentas são movidas para config=. Não há um argumento tools= na chamada ou em um objeto de modelo.
• Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval()) se torna types.Tool(google_search=types.GoogleSearch()). Um método de fábrica se torna um campo simples. types.Tool também tem um campo google_search_retrieval separado.
• response.function_calls é o acessador idiomático e não falha quando a parte zero é um texto. A travessia antiga ainda funciona.
• O esquema JSON bruto é especificado em parameters_json_schema. Um types.Schema tipado é especificado em parameters.
• Agora é possível transmitir uma função Python como uma ferramenta, e a chamada automática de função fica ativada por padrão quando você transmite a função. Se você portar um loop de ferramenta manual e transmitir um objeto de função, o SDK vai começar a executar seu código. Desative a chamada de função automática padrão com automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True).

• Os seguintes tipos de ferramentas não têm equivalentes em versões anteriores: code_execution, url_context, google_maps, computer_use, file_search, enterprise_web_search, 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())

Depois

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())

Embeddings

Confira as seguintes mudanças para tarefas de incorporação:

• TextEmbeddingInput foi removido. task_type e title agora são por solicitação. Portanto, os lotes de tarefas mistas precisam ser divididos em várias chamadas.
• O tipo de retorno mudou de uma lista direta para um objeto de resposta. get_embeddings() retornava diretamente um list[TextEmbedding], então os chamadores indexavam a lista diretamente (embeddings[0].values). Na nova versão, embed_content() retorna um objeto EmbedContentResponse que contém uma lista .embeddings, exigindo que você acesse response.embeddings[0].values. Os campos de incorporação individuais (.values e .statistics) mantêm os nomes originais.

• O padrão de auto_truncate não é mais True. O novo campo tem unset como padrão. Se você depender do truncamento silencioso de entradas muito longas, defina auto_truncate explicitamente.

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)

Depois

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)

Contagem de tokens

Confira as seguintes mudanças para tarefas de contagem de tokens:

• total_billable_characters foi removido e não tem substituição. Qualquer estimativa de custo com base em total_billable_characters precisa ser reformulada (por exemplo, em relação a total_tokens ou response.usage_metadata) de uma chamada de geração.
• client.models.compute_tokens(...) foi adicionado para IDs de token e partes de string.

• A contagem off-line foi adicionada por 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)

Depois

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)

O armazenamento em cache de contexto

Observe as seguintes mudanças nas tarefas de cache de contexto:

• ttl muda o tipo de datetime.timedelta para uma string de duração, como "86400s".
• Os métodos de objeto de recurso se tornam chamadas de módulo do cliente.

• update retorna um novo objeto em vez de fazer mutações no local.

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()

Depois

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)

Predição em lote e ajuste

Confira as seguintes mudanças nas tarefas de previsão e ajuste em lote:

• A sondagem é baseada em vinculação, não no local. Não há job.refresh() nem job.has_ended. Busque um novo objeto de client.batches.get(name=...) e compare job.state com as strings JOB_STATE_*.
• Renomeações em lote: source_model para model, input_dataset para src, output_uri_prefix para config.dest, job_display_name para config.display_name.
• Os controles de forma de máquina em lote foram removidos e não têm equivalente na nova versão do SDK. machine_type, accelerator_type, accelerator_count, starting_replica_count e max_replica_count não são mais campos de CreateBatchJobConfig.
• Os seguintes métodos foram renomeados:
  • sft.train a client.tunings.tune
  • De source_model para base_model
  • De train_dataset para training_dataset
  • epochs a epoch_count
• Os conjuntos de dados de ajuste são encapsulados. Uma string "gs://..." simples se torna types.TuningDataset(gcs_uri=...).

• adapter_size muda o tipo de um int para uma string de enumeração, 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,
)

Depois

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",
    ),
)

Reestruturação do SDK da Agent Platform

Se você usa os módulos agentplatform do google-cloud-aiplatform, siga estas recomendações para migrar para a nova estrutura do SDK:

1. O google-cloud-agentplatform agora é uma distribuição independente e leve, além de ser a instalação recomendada para cargas de trabalho de agentes. Se você não precisar da interface clássica de aprendizado de máquina, mude a instalação de pip install google-cloud-aiplatform para pip install google-cloud-agentplatform.

2. Use a tabela a seguir para atualizar importações e caminhos de atributos:

   Anterior	Novo
   client.agent_engines.create	client.runtimes.create (Implante um ambiente de execução do agente em uma instância da Gemini Enterprise Agent Platform, que oferece sessões integradas, execução de código em sandbox e configuração de memória de contexto) client.memory_banks.create (Crie recursos independentes do Memory Bank para persistir, gerenciar e recuperar memórias em várias interações)
   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. O inicializador global é removido, e os frameworks de agente não leem mais o projeto e o local do estado aiplatform.init() ou vertexai.init(). Substitua a configuração derivada do inicializador por variáveis de ambiente para tudo o que estiver sendo executado em uma estrutura de agente. O código que depende do inicializador para configurar agentes implantados falha silenciosamente em vez de gerar um erro.

4. Atualize os sites de chamada evals.run_inference(agent=...) para transmitir types.Runtime, já que o SDK não aceita mais types.AgentEngine.

5. Faça as mudanças a seguir:

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

   O vertexai.Client emite um FutureWarning na primeira instanciação:

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

   vertexai.rag emite um UserWarning no momento da importação do módulo, não na chamada. Migre para o seguinte:

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

6. Atualizar o tratamento de erros em torno de AdkApp e chamadas de sessão. Os métodos de sessão síncronos e as execuções de agentes de streaming agora mostram o erro da API subjacente. Os chamadores que capturam um erro encapsulado genérico não correspondem mais. Substitua as capturas de exceções genéricas de wrapper de biblioteca por google.api_core.exceptions.GoogleAPICallError (ou erros de status específicos, como ResourceExhausted e NotFound).

7. Atualize os chamadores de cliente ou o middleware para incluir o token de acesso OAuth do usuário em cada solicitação, já que os tokens agora são efêmeros e não são mantidos com o estado da sessão. Verifique se a atualização do token é gerenciada do lado do cliente.

8. O módulo a2a.tasks foi removido sem substituição.