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

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

Attention : N'installez pas google-cloud-aiplatform==2.0.0. Traitez plutôt la version 2.0.1 comme la limite de la version 2. Si vous restez sur 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 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 :

  • Renommages
  • 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.

• Découplage de agentplatform : google-cloud-agentplatform est désormais une distribution légère autonome et l'installation recommandée pour les charges de travail des agents. 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].

Ce qui n'est pas affecté

La surface de machine learning classique (ensembles de données, entraînement, modèles, prédiction, suivi, pipelines) est entièrement prise en charge, 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 existe dans le SDK Google Gen AI et est l'outil recommandé.

Migration des 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 de dépréciation 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'ancienne interface de machine learning.

   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() a configuré l'ensemble du processus ; 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 exige une clé API.
   • Le nom du modèle passe de la construction à chaque appel. Il n'existe aucun objet de modèle bind-once. 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 depuis google-genai 2.20.0, mais l'ancienne version vertexai=True fonctionne sur toutes les versions et constitue le choix le plus sûr.

4. Vérifiez 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 sera ciblée en mode silencieux.
   Embeddings auto_truncate	La valeur par défaut est True.	Non défini ; la valeur par défaut du serveur s'applique
   Fonction Python transmise en tant qu'outil	Non compatible	Exécuté automatiquement par le SDK
   system_instruction	Lié une fois au modèle	Doit être transmis à chaque appel

   La modification response.text est celle à rechercher en premier. Chaque try/except ValueError entourant .text devient du code mort, et chaque .text non protégé peut désormais générer None alors qu'un str était renvoyé auparavant :

   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 l'ancienne surface de machine learning.

6. Modifiez les appels vers les nouvelles versions. Commencez par les renommages mécaniques, puis passez à la consolidation config=.

Modifications des appels basés sur les tâches

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

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

Génération de texte

Pour les tâches de génération de texte, tous les arguments sont des arguments de mot clé 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 flux continu

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 bloc 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 homologue 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 discussions sont créées à partir du client, et non à partir d'un objet de modèle.
• chat.history (propriété) devient chat.get_history() (méthode). La nouvelle méthode prend curated: bool = False. Si vous transmettez True, seuls les tours conservés seront renvoyés. Il n'existe 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 en 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 concernant les tâches de configuration, les paramètres de sécurité et les 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 création 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 simples et sont forcées.

• 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 multimodales :

Ancienne version	Nouveau
Part.from_uri(uri, mime_type), positionnel autorisé	Part.from_uri(file_uri=, mime_type=), paramètre renommé (mot clé uniquement)
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() (inféré 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 les URI Cloud Storage à l'aide de from_uri ou les 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 concernant 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 ne génère pas d'erreur lorsque la partie 0 est du texte. L'ancienne méthode de 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 manuel 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 concernant les tâches d'intégration :

• "TextEmbeddingInput" a bien été supprimé. task_type et title sont désormais 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'intégration individuels (.values et .statistics) conservent leur nom d'origine.

• auto_truncate n'est plus défini par défaut sur True. La valeur par défaut du nouveau champ est unset. Si vous vous appuyez sur 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 des 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 décompte 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 mise en cache du contexte :

• Le type de ttl passe de 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 le modifier 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 réassociation, et non sur le remplacement. 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 mise en forme automatique par lot ont été 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 :
  • sft.train à client.tunings.tune
  • De source_model à base_model
  • De train_dataset à training_dataset
  • epochs à epoch_count
• Les ensembles de données de réglage sont encapsulés. Une chaîne "gs://..." brute 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'ancienne interface de machine learning, 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'attributs :

   Précédent	Nouveau
   client.agent_engines.create	client.runtimes.create (Déployer un Agent Runtime sur une instance Gemini Enterprise Agent Platform, qui fournit des sessions intégrées, l'exécution de code dans le bac à sable et la configuration de la mémoire contextuelle) client.memory_banks.create (Créer des ressources Memory Bank autonomes pour conserver, gérer et récupérer des souvenirs lors des interactions)
   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 ni 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 silencieusement 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 :

   • vertexai.Client à agentplatform.Client
   • 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. Mise à jour de la gestion des exceptions concernant les appels AdkApp et de session. Les méthodes de session synchrone et les exécutions d'agent de streaming affichent désormais l'erreur d'API sous-jacente. Les appelants qui détectent une erreur générique encapsulée ne correspondent plus. Remplacez les captures d'exceptions de wrapper de bibliothèque génériques par google.api_core.exceptions.GoogleAPICallError (ou des erreurs d'état spécifiques comme ResourceExhausted et NotFound).

7. Mettez à jour les appelants ou le middleware du client 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 être remplacé.