Session

C# AgentSession est une classe de base abstraite. Les implémentations concrètes (créées via CreateSessionAsync()) peuvent ajouter un état supplémentaire, par exemple un ID pour le stockage de l’historique des conversations distantes, lorsque l’historique géré par le service est utilisé.

Les sessions fournissent un stockage clé-valeur typé :

type UserPrefs struct {
    Theme    string `json:"theme"`
    Language string `json:"language"`
}

session.Set("user_prefs", UserPrefs{Theme: "dark", Language: "en"})

var prefs UserPrefs
session.Get("user_prefs", &prefs)

session.Delete("user_prefs")

AgentSession session = await agent.CreateSessionAsync();

var first = await agent.RunAsync("My name is Alice.", session);
var second = await agent.RunAsync("What is my name?", session);

session = agent.create_session()

first = await agent.run("My name is Alice.", session=session)
second = await agent.run("What is my name?", session=session)

session, err := a.CreateSession(ctx)
if err != nil {
    panic(err)
}

resp, _ := a.RunText(ctx, "Hello!", agent.WithSession(session)).Collect()
resp, _ = a.RunText(ctx, "Follow-up question.", agent.WithSession(session)).Collect()

HarnessAgent a la valeur par défaut InMemoryChatHistoryProvider. Remplacez-le par HarnessAgentOptions.ChatHistoryProvider le biais du moment où l’historique doit utiliser un autre magasin. AsHarnessAgent(options) est abrégé pour la construction new HarnessAgent(chatClient, options).

HarnessAgent agent = chatClient.AsHarnessAgent();
AgentSession session = await agent.CreateSessionAsync();

await agent.RunAsync("Plan the migration.", session);
await agent.RunAsync("Continue with the next step.", session);

var serialized = await agent.SerializeSessionAsync(session);
AgentSession resumed = await agent.DeserializeSessionAsync(serialized);

Le harnais conserve l’historique des conversations locales après chaque appel de modèle à l’intérieur d’une boucle d’appel d’outils, non seulement après l’exécution de l’agent externe. Continuez à passer la même session pour conserver cet historique en boucle et l’état des fournisseurs de contexte par défaut.

create_harness_agent history_provider est défini par défaut sur InMemoryHistoryProvider(). Passez une commande personnalisée HistoryProviderhistory_provider= lorsque l’historique doit utiliser un autre magasin.

agent = create_harness_agent(client)
session = agent.create_session()

await agent.run("Plan the migration.", session=session)
await agent.run("Continue with the next step.", session=session)

serialized = session.to_dict()
resumed = AgentSession.from_dict(serialized)

Le harnais nécessite la persistance de l’historique des appels par service. Par conséquent, le fournisseur d’historique configuré enregistre chaque appel de modèle à l’intérieur d’une boucle d’outil. Une session est également requise par le middleware d’approbation d’outil par défaut ; réutilisez et restaurez-le pour conserver l’état de l’approbation et du fournisseur de contexte.

L’agent Harness n’est actuellement pas disponible dans le Kit de développement logiciel (SDK) Go. Utilisez le modèle de session régulière indiqué ci-dessus.

La création d’une session à partir d’un ID de conversation existant varie selon le type d’agent. Voici quelques exemples.

Lors de l'utilisation de ChatClientAgent

AgentSession session = await chatClientAgent.CreateSessionAsync(conversationId);

Lors de l’utilisation d’un A2AAgent

AgentSession session = await a2aAgent.CreateSessionAsync(contextId, taskId);

Utilisez ceci lorsque le service de support dispose déjà d'un état de conversation.

session = agent.get_session(service_session_id="<service-conversation-id>")
response = await agent.run("Continue this conversation.", session=session)

Dans les applications hébergées, résolvez <service-conversation-id> à partir du stockage appartenant à l’application après avoir vérifié l’utilisateur ou le locataire actuel. Évitez d’accepter des identifiants bruts générés côté service fournis par un client, sauf si vous vérifiez d’abord que l’appelant est bien propriétaire de la conversation.

var serialized = agent.SerializeSession(session);
AgentSession resumed = await agent.DeserializeSessionAsync(serialized);

Dans une application auto-hébergée, une AgentSessionStore application peut charger et enregistrer des sessions par un ID de continuation dans le cadre du traitement des demandes. Cela est distinct de la persistance manuelle d’une session et de la configuration d’un fournisseur d’historique. Consultez les applications Framework de l’agent auto-hôte.

serialized = session.to_dict()
resumed = AgentSession.from_dict(serialized)

data, err := json.Marshal(session)
if err != nil {
    panic(err)
}

// Save to disk, database, etc.
if err := os.WriteFile("session.json", data, 0o644); err != nil {
    panic(err)
}

// Later, restore the session.
loaded, err := os.ReadFile("session.json")
if err != nil {
    panic(err)
}

var resumedSession agent.Session
if err := json.Unmarshal(loaded, &resumedSession); err != nil {
    panic(err)
}

resp, _ := a.RunText(ctx, "Continue from where we left off.", agent.WithSession(&resumedSession)).Collect()