Guide de migration du SDK Agent Platform pour Python : version 2.0.1

Le package google-cloud-aiplatform inclut à la fois le SDK Agent Platform pour Python et la bibliothèque cliente Python Agent Platform. Cette page traite des catégories de modifications suivantes dans le package google-cloud-aiplatform :

Attention : N'installez pas google-cloud-aiplatform==2.0.0. Utilisez plutôt la version 2.0.1 comme limite de la version 2. Si vous conservez le package google-cloud-aiplatform, épinglez google-cloud-aiplatform < 2.0.0 jusqu'à ce que vous ayez terminé la migration vers la version 2.0.1.

• Migration des modules d'IA générative vers le SDK Google Gen AI : les modules d'IA générative suivants du package vertexai sont obsolètes et ont été migrés vers le SDK Google Gen AI (google-genai) :

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

  Pour savoir comment migrer les modules obsolètes vers le SDK Google Gen AI, consultez Migrer les modules d'IA générative vers le SDK Google Gen AI.

• Restructuration de la surface de l'agent : les modifications suivantes ont été apportées aux modules agentplatform de google-cloud-aiplatform :

  • Changements de nom
  • Promotions au niveau supérieur
  • Suppression de l'initialiseur global

  Pour savoir comment migrer vers la nouvelle structure du SDK, consultez Restructuration du SDK Agent Platform.

• Dissociation de agentplatform : google-cloud-agentplatform est désormais une distribution légère autonome et l'installation recommandée pour les charges de travail de l'agent. Si vous ne créez que des agents, installez google-cloud-agentplatform, qui ne contient pas de modules d'IA générative. Les modules agentplatform couvrent les intégrations courantes telles que [adk], [a2a], [agent_engines], [langchain], [ag2], [llama_index], [evaluation], [bigquery], [live] et [all].

Éléments non concernés

La surface de machine learning classique (ensembles de données, entraînement, modèles, prédiction, suivi, pipelines) est entièrement compatible, n'est pas affectée par les modifications de la version 2.0.1 et n'a pas d'équivalent dans le SDK Google Gen AI. Vous pouvez toujours accéder à l'évaluation, à Agent Runtime, aux requêtes et aux compétences en installant google-cloud-aiplatform. google-cloud-aiplatform et google-genai coexistent dans un même environnement, et google-genai est désormais une dépendance stricte 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'est pas obsolète, mais un équivalent du SDK Google Gen AI existe et est l'outil recommandé.

Migrer les modules d'IA générative vers le SDK Google Gen AI

Si vous utilisez les modules d'IA générative du package google-cloud-aiplatform, suivez les recommandations ci-dessous pour migrer vers le SDK Google Gen AI (google-genai) :

1. Définissez google-cloud-aiplatform < 2.0.0 afin que les mises à jour de dépendances non liées ne puissent pas supprimer les modules sous-jacents.

2. Recherchez les modules obsolètes dans votre code :

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

   Si vous importez l'un des modules Python concernés, l'avertissement d'abandon suivant s'affiche :

   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.
   

   Exécutez votre suite de tests avec -W error::UserWarning pour détecter les importations que vous avez manquées.

3. Remplacez vertexai.init(...) par un genai.Client(enterprise=True, project=..., location=...) explicite. Conservez vertexai.init() si vous utilisez également l'interface de machine learning classique.

   Avant

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

   Après

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

   Vous pouvez également configurer l'environnement :

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

   from google import genai
   
   client = genai.Client()
   

   Remarques importantes :

   • L'état global devient un client explicite. vertexai.init() configure l'ensemble du processus, tandis que genai.Client() est un objet que vous transmettez. Avec genai.Client(), vous pouvez utiliser deux projets ou régions dans un même processus.
   • Veuillez renseigner l'élément enterprise=True. Si vous l'omettez, le client cible silencieusement l'API Gemini Developer, qui échoue ensuite sur les identifiants par défaut de l'application ou demande une clé API.
   • Le nom du modèle passe de la construction à chaque appel. Il n'existe pas d'objet de modèle à liaison unique. model= est un argument de mot clé obligatoire pour chaque appel client.models.*.
   • L'authentification reste inchangée. Les identifiants par défaut de l'application s'appliquent toujours, et credentials= accepte un google.auth.credentials.Credentials dans les deux SDK.
   • vertexai.init() comportait également des paramètres non génératifs tels que staging_bucket, experiment, encryption_spec_key_name, service_account et network. genai.Client n'a pas d'équivalent pour eux.
   • La nouvelle orthographe enterprise=True est acceptée à partir de la version 2.20.0 de google-genai, mais l'ancienne version vertexai=True fonctionne sur toutes les versions et constitue le choix le plus sûr.

4. Auditez votre code pour détecter les modifications silencieuses où le comportement diverge sans erreur. Elles se compilent et s'exécutent, mais leur signification change.

   Comportement	Avant	Après
   response.text sur une réponse bloquée ou vide	Génère ValueError	Renvoie None
   response.text avec plusieurs candidats	Génère ValueError	Enregistre un avertissement et renvoie le premier candidat
   Ciblage des clients	vertexai.init() Agent Platform implicite	Si vous omettez vertexai=True, l'API Gemini Developer est ciblée de manière silencieuse
   Embeddings auto_truncate	La valeur par défaut est True.	Non défini ; la valeur par défaut du serveur s'applique
   Une fonction Python transmise en tant qu'outil	Non compatible	Exécuté automatiquement par le SDK
   system_instruction	Lié une fois sur le modèle	Doit être transmis à chaque appel

   La modification response.text est celle à rechercher en premier. Chaque try/except ValueError encapsulé autour de .text devient du code mort, et chaque .text non protégé peut désormais générer None là où un str était précédemment renvoyé :

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

5. Conservez google-cloud-aiplatform installé si vous utilisez l'évaluation, Agent Runtime, les requêtes, les ensembles de données, les compétences et l'ensemble de la surface de machine learning classique.

6. Modifiez les appels vers les nouvelles versions. Commencez par des renommages mécaniques, puis poursuivez avec la consolidation de config=.

Modifications des appels basés sur des tâches

Consultez les appels modifiés en fonction de la tâche :

• Génération de texte
• Génération en flux continu
• Génération asynchrone
• Sessions de chat
• Configuration, paramètres de sécurité et instructions système
• Requêtes multimodales
• Appel de fonction et ancrage
• Embeddings
• Comptage des jetons
• Mise en cache du contexte
• Prédiction par lot et réglage

Génération de texte

Pour les tâches de génération de texte, tous les arguments sont des mots clés uniquement. Les appels positionnels génèrent TypeError.

Avant

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

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

Après

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

Génération en streaming

Pour les tâches de génération de flux, l'option stream=True est supprimée. Le streaming est désormais une méthode distincte qui renvoie Iterator[types.GenerateContentResponse]. Utilisez if chunk.text: pour vérifier avant d'accéder au texte, car chaque fragment est un objet de réponse complet et son attribut .text peut parfois être None.

Avant

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

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

Génération asynchrone

Pour les tâches de génération asynchrones, le suffixe de nom de méthode _async a été supprimé. Chaque appel asynchrone se trouve sous client.aio.<module> avec le même nom de méthode que son équivalent synchrone. Fermez le client avec await client.aio.aclose() ou utilisez async with genai.Client(...).aio as aclient:.

Avant

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

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

Sessions de chat

Notez les modifications suivantes pour les tâches de sessions de chat :

• Les chats sont créés à partir du client, et non d'un objet de modèle.
• chat.history (propriété) devient chat.get_history() (méthode). La nouvelle méthode utilise curated: bool = False. La transmission de True ne renvoie que les tours conservés, ce qui n'a pas d'équivalent ancien.
• client.aio.chats.create(...) renvoie directement un AsyncChat. Seuls send_message et send_message_stream sont attendus.
• Les options par tour sont regroupées dans un seul argument : send_message(message, config=types.GenerateContentConfig(...)). Le premier paramètre est également renommé de content à message.

• start_chat(response_validation=False) est une nouvelle méthode sans équivalent dans les versions précédentes.

Avant

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)

Aprè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)

Configuration, paramètres de sécurité et instructions système

Notez les modifications suivantes pour les tâches de configuration, de paramètres de sécurité et d'instructions système :

• Les arguments suivants sont regroupés dans un seul config= en tant que champs de GenerateContentConfig :

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

  Un dict simple fonctionne partout où un type de configuration fonctionne.

• system_instruction passe du constructeur de modèle à la configuration par appel. Dans la version précédente du SDK, system_instruction était défini une seule fois lors de la compilation de GenerativeModel. Désormais, system_instruction doit être transmis à chaque appel ou inclus dans client.chats.create(config=...).

• Les paramètres de sécurité passent de dict à list. Par exemple, [types.SafetySetting(category=c, threshold=t) for c, t in old_dict.items()].

• Les énumérations sont acceptées en tant que chaînes brutes et converties.

• Les noms des champs scalaires restent inchangés : 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.

• Les nouveaux champs sans équivalent ancien incluent thinking_config, cached_content, automatic_function_calling, http_options, media_resolution et speech_config.

Avant

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

Aprè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,
          ),
      ],
    ),
)

Requêtes multimodales

Notez les modifications suivantes pour les tâches d'entrée multimodale :

Ancienne version	Nouveau
Part.from_uri(uri, mime_type), positionnel autorisé	Part.from_uri(file_uri=, mime_type=), paramètre réservé aux mots clés renommé
Part.from_data(data, mime_type)	Part.from_bytes(data=, mime_type=), méthode renommée
Part.from_text(text)	Part.from_text(text=), mot clé uniquement
Image.load_from_file(path)	Aucun équivalent ; ouvrez le fichier et utilisez Part.from_bytes

• mime_type est facultatif dans types.Part.from_uri() (déduit côté serveur), mais reste obligatoire dans types.Part.from_bytes().

• client.files.upload(...) n'est compatible qu'avec l'API Gemini Developer. Pour les charges de travail Agent Platform, continuez à transmettre des URI Cloud Storage à l'aide de from_uri ou des octets intégrés à l'aide de from_bytes.

Avant

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

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

Appel de fonction et ancrage

Notez les modifications suivantes pour les tâches d'appel de fonction et d'ancrage :

• Les outils sont déplacés vers config=. Il n'y a pas d'argument tools= dans l'appel ni dans un objet de modèle.
• Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval()) devient types.Tool(google_search=types.GoogleSearch()). Une méthode de fabrique devient un champ simple. types.Tool comporte également un champ google_search_retrieval distinct.
• response.function_calls est l'accesseur idiomatique et n'échoue pas lorsque la partie zéro est du texte. L'ancien parcours fonctionne toujours.
• Le schéma JSON brut est spécifié dans parameters_json_schema. Un types.Schema typé est spécifié dans parameters.
• Vous pouvez désormais transmettre une fonction Python en tant qu'outil. L'appel de fonction automatique est activé par défaut lorsque vous transmettez la fonction. Si vous portez une boucle d'outil manuelle et transmettez un objet de fonction, le SDK commence à exécuter votre code. Désactivez l'appel de fonction automatique par défaut avec automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True).

• Les nouveaux types d'outils suivants n'ont pas d'équivalent dans les versions précédentes : code_execution, url_context, google_maps, computer_use, file_search, enterprise_web_search, mcp_servers.

Avant

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

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

Embeddings

Notez les modifications suivantes pour les tâches d'embedding :

• "TextEmbeddingInput" a bien été supprimé. task_type et title sont désormais définis par requête. Les lots de tâches mixtes doivent donc être divisés en plusieurs appels.
• Le type renvoyé est passé d'une liste directe à un objet de réponse. get_embeddings() renvoyait directement un list[TextEmbedding], de sorte que les appelants indexaient directement la liste (embeddings[0].values). Dans la nouvelle version, embed_content() renvoie un objet EmbedContentResponse contenant une liste .embeddings, ce qui vous oblige à accéder à response.embeddings[0].values. Les champs d'embedding individuels (.values et .statistics) conservent leur nom d'origine.

• auto_truncate n'est plus défini par défaut sur True. Le nouveau champ est défini par défaut sur unset. Si vous vous fiez à la troncature silencieuse des entrées trop longues, définissez explicitement auto_truncate.

Avant

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)

Aprè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)

Comptage de jetons

Notez les modifications suivantes pour les tâches de comptage de jetons :

• total_billable_characters est supprimé et n'est pas remplacé. Toute estimation des coûts basée sur total_billable_characters doit être retravaillée (par exemple, par rapport à total_tokens ou response.usage_metadata) à partir d'un appel de génération.
• client.models.compute_tokens(...) a été ajouté pour les ID de jeton et les éléments de chaîne.

• Le comptage hors connexion a été ajouté via google.genai.local_tokenizer.LocalTokenizer.

Avant

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

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

Aprè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)

mise en cache du contexte

Notez les modifications suivantes pour les tâches de cache de contexte :

• ttl passe du type datetime.timedelta à une chaîne de durée telle que "86400s".
• Les méthodes d'objet de ressource deviennent des appels de module client.

• update renvoie un nouvel objet au lieu de muter sur place.

Avant

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

Aprè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)

Prédiction par lot et réglage

Notez les modifications suivantes pour les tâches de prédiction par lot et de réglage :

• L'interrogation est basée sur la reliaison, et non sur l'interrogation sur place. Il n'y a pas de job.refresh() ni de job.has_ended. Récupérez un nouvel objet à partir de client.batches.get(name=...) et comparez job.state aux chaînes JOB_STATE_*.
• Renommages par lot : source_model en model, input_dataset en src, output_uri_prefix en config.dest, job_display_name en config.display_name.
• Les commandes de forme de machine par lot sont supprimées et n'ont pas d'équivalent dans la nouvelle version du SDK. machine_type, accelerator_type, accelerator_count, starting_replica_count et max_replica_count ne sont plus des champs de CreateBatchJobConfig.
• Les méthodes suivantes ont été renommées :
  • De sft.train à client.tunings.tune
  • De source_model à base_model
  • De train_dataset à training_dataset
  • De epochs à epoch_count
• Les ensembles de données de réglage sont encapsulés. Une chaîne "gs://..." simple devient types.TuningDataset(gcs_uri=...).

• adapter_size passe d'un type int à une chaîne d'énumération telle que "ADAPTER_SIZE_FOUR".

Avant

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

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

Restructuration du SDK Agent Platform

Si vous utilisez les modules agentplatform de google-cloud-aiplatform, suivez les recommandations ci-dessous pour migrer vers la nouvelle structure du SDK :

1. google-cloud-agentplatform est désormais une distribution légère autonome et l'installation recommandée pour les charges de travail de l'agent. Si vous n'avez pas besoin de l'interface de machine learning classique, remplacez pip install google-cloud-aiplatform par pip install google-cloud-agentplatform dans votre installation.

2. Utilisez le tableau suivant pour mettre à jour les importations et les chemins d'accès aux attributs :

   Précédent	Nouveau
   client.agent_engines.create	client.runtimes.create (Déployez une instance Agent Runtime sur Gemini Enterprise Agent Platform, qui fournit des sessions Agent Platform intégrées, l'exécution de code dans un bac à sable et la configuration de la mémoire de contexte) client.memory_banks.create (Créez des ressources Agent Platform Memory Bank autonomes pour conserver, gérer et récupérer des souvenirs d'une interaction à l'autre)
   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. L'initialiseur global est supprimé, et les frameworks d'agent ne lisent plus le projet et l'emplacement à partir de l'état aiplatform.init() ou vertexai.init(). Remplacez la configuration dérivée de l'initialiseur par des variables d'environnement pour tout ce qui s'exécute dans un framework d'agent. Le code qui s'appuie sur l'initialiseur pour configurer les agents déployés s'interrompt de manière invisible au lieu de générer une erreur.

4. Mettez à jour les sites d'appel evals.run_inference(agent=...) pour transmettre types.Runtime, car le SDK n'accepte plus types.AgentEngine.

5. Apportez les modifications suivantes :

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

   vertexai.Client émet un FutureWarning lors de la première instanciation :

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

   vertexai.rag émet un UserWarning au moment de l'importation du module, et non lors de l'appel. Migrez vers les éléments suivants :

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

6. Mettez à jour la gestion des exceptions concernant les appels AdkApp et de session. Les méthodes de session synchrones et les exécutions d'agents de streaming affichent désormais l'erreur d'API sous-jacente. Les appelants qui interceptent une erreur encapsulée générique ne correspondent plus. Remplacez les captures d'exceptions génériques du wrapper de bibliothèque par google.api_core.exceptions.GoogleAPICallError (ou des erreurs d'état spécifiques telles que ResourceExhausted et NotFound).

7. Mettez à jour les appelants client ou le middleware pour inclure le jeton d'accès OAuth de l'utilisateur dans chaque requête, car les jetons sont désormais éphémères et ne sont pas conservés avec l'état de la session. Assurez-vous que l'actualisation des jetons est gérée côté client.

8. Notez que le module a2a.tasks a été supprimé sans remplacement.