Session

C# AgentSession es una clase base abstracta. Las implementaciones concretas (creadas a través de CreateSessionAsync()) pueden agregar estado adicional, por ejemplo, un identificador para el almacenamiento del historial de chat remoto, cuando se utiliza el historial administrado por el servicio.

Las sesiones proporcionan almacenamiento tipado de pares clave-valor:

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 se establece de forma predeterminada en InMemoryChatHistoryProvider. Reemplácelo a través de HarnessAgentOptions.ChatHistoryProvider cuando el historial debe usar otro almacén. AsHarnessAgent(options) es una abreviatura para construir 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);

El arnés conserva el historial de chat local después de cada llamada de modelo dentro de un bucle de llamada a herramientas, no solo después de la ejecución del agente externo. Continúe pasando la misma sesión para conservar ese historial en bucle y el estado de los proveedores de contexto predeterminados.

create_harness_agent el valor predeterminado es history_providerInMemoryHistoryProvider(). Pase un personalizado HistoryProvider a través history_provider= de cuando el historial debe usar otro almacén.

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)

El arnés requiere persistencia del historial de llamadas por servicio, por lo que el proveedor de historial configurado guarda cada llamada de modelo dentro de un bucle de herramientas. El middleware predeterminado de aprobación de herramientas también requiere una sesión; reutilice y restáurelo para conservar el estado de aprobación y proveedor de contexto.

El agente de Harness no está disponible actualmente en el SDK de Go. Use el patrón de sesión normal mostrado anteriormente.

Crear una nueva sesión a partir de un identificador de conversación existente varía según el tipo de agente. A continuación, encontrará algunos ejemplos.

Al usar ChatClientAgent

AgentSession session = await chatClientAgent.CreateSessionAsync(conversationId);

Cuando se usa un A2AAgent

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

Úselo cuando el servicio de respaldo ya tenga el estado de conversación.

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

En las aplicaciones hospedadas, resuelva <service-conversation-id> desde el almacenamiento propiedad de la aplicación después de comprobar el usuario o inquilino actual. Evite aceptar IDs en bruto del lado del servicio procedentes de un cliente, a menos que primero compruebe que quien realiza la llamada es propietario de la conversación.

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

En una aplicación autohospedada, puede AgentSessionStore cargar y guardar sesiones mediante un identificador de continuación como parte del procesamiento de solicitudes. Esto es distinto de conservar manualmente una sesión y de configurar un proveedor de historial. Consulte Aplicaciones de Marco de agente autohospedado.

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