Speichere jede Sitzungs-ID im Datenspeicher deiner Anwendung. Mit der ID kannst du den aktuellen Zustand der Sitzung abrufen, Anfragen des Agenten bearbeiten oder die Sitzung löschen.
Liste die Sitzungen in deinem Projekt auf, um frühere Arbeiten durchzusehen. Mit den Hilfsfunktionen des SDK für die Paginierung kannst du weitere Ergebnisseiten abrufen:
1
2
3
4
5
6
7
8
9import OpenAI from "openai";
const client = new OpenAI();
let page = await client.beta.agents.sessions.list({ limit: 20 });
console.log(page.data);
if (page.hasNextPage()) {
page = await page.getNextPage();
console.log(page.data);
}
1
2
3
4
5
6
7
8from openai import OpenAI
client = OpenAI()
page = client.beta.agents.sessions.list(limit=20)
print(page.to_json())
if page.has_next_page():
page = page.get_next_page()
print(page.to_json())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
)
ctx := context.Background()
client := openai.NewClient()
result, err := client.Beta.Agents.Sessions.List(ctx,
openai.BetaAgentSessionListParams{Limit: openai.Int(20)})
if err != nil {
panic(err)
}
fmt.Println(result.Data)
if result.HasMore {
result, err = result.GetNextPage()
if err != nil {
panic(err)
}
fmt.Println(result.Data)
}
1
2
3
4
5
6
7
8
9
10
11
12import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.beta.agents.sessions.SessionListParams;
OpenAIClient client = OpenAIOkHttpClient.fromEnv();
var result =
client.beta().agents().sessions().list(SessionListParams.builder().limit(20L).build());
System.out.println(result.items());
if (result.hasNextPage()) {
result = result.nextPage();
System.out.println(result.items());
}
1
2
3
4
5
6
7
8
9require "openai"
client = OpenAI::Client.new
result = client.beta.agents.sessions.list(limit: 20)
puts result.data
if result.next_page?
result = result.next_page
puts result.data
end
1
2
3
4
5
6
7
8
9
10
11
12page=$(curl -sS --fail-with-body "https://api.openai.com/v1/agents/sessions?limit=20&order=desc" \
-H "OpenAI-Beta: agents=v1" \
-H "Authorization: Bearer $OPENAI_API_KEY")
after=$(printf '%s' "$page" | jq -r 'select(.has_more) | .last_id // empty')
if [ -n "$after" ]; then
curl --get "https://api.openai.com/v1/agents/sessions" \
-H "OpenAI-Beta: agents=v1" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
--data-urlencode "after=$after" \
--data-urlencode "limit=20"
fi
Rufe eine Sitzung ab, um ihren Status, die Konfiguration des Agenten, die Umgebung und den Inhalt von required_actions einzusehen. Übergib dazu deinen API-Client und die Sitzungs-ID der Unterhaltung:
1
2
3
4// Pass your saved session ID to this helper.
async function retrieveSession(client: OpenAI, sessionId: string) {
return client.beta.agents.sessions.retrieve(sessionId);
}
1
2
3# Pass your saved session ID to this helper.
def retrieve_session(client: OpenAI, session_id: str):
return client.beta.agents.sessions.retrieve(session_id)
1
2
3
4// Pass your saved session ID to this helper.
func retrieveSession(ctx context.Context, client *openai.Client, sessionID string) (*openai.AgentSession, error) {
return client.Beta.Agents.Sessions.Get(ctx, sessionID)
}
1
2
3
4
5
6
7
8// Pass your saved session ID to this helper.
public static AgentSession retrieveSession(OpenAIClient client, String sessionId) {
return client
.beta()
.agents()
.sessions()
.retrieve(SessionRetrieveParams.builder().sessionId(sessionId).build());
}
1
2
3
4# Pass your saved session ID to this helper.
def retrieve_session(client, session_id)
client.beta.agents.sessions.retrieve(session_id)
end
1
2
3
4curl \
"https://api.openai.com/v1/agents/sessions/$session_id" \
-H "OpenAI-Beta: agents=v1" \
-H "Authorization: Bearer $OPENAI_API_KEY"
Das vollständige Schema der Antwort findest du in der API-Referenz zum Abrufen einer Sitzung.
Bei einer Sitzung mit dem Status requires_action muss deine Anwendung eine Aktion ausführen, bevor die Arbeit weitergehen kann. Wenn du das Ereignis agent.session.requires_action empfängst, rufe die Sitzung ab und prüfe jeden Eintrag in required_actions:
function_call: Rufe die in name angegebene Funktion mit den Argumenten aus arguments auf. Gib das Ergebnis in derselben Sitzung zurück und verwende dafür turn_id und call_id aus der Aktion. Siehe Funktionen als Tools verwenden.
environment_connection: Stelle eine Verbindung zu der in environment_id angegebenen Umgebung her. Siehe Eine Umgebung verbinden.
Das Ereignis signalisiert deiner Anwendung, wann sie die Sitzung prüfen soll. Aus den abgerufenen Sitzungsdaten geht hervor, welche Aktionen sie ausführen muss. Rufe die Sitzung nach einem Neustart oder einer Unterbrechung des Ereignisstreams ab, um ausstehende Aktionen zu finden. Sobald du sie ausgeführt hast, verfolge die weiteren Ereignisse, um zu erfahren, wie der Turn endet.
Wie du gespeicherte Nachrichten, Tool-Aufrufe und Ergebnisse einzelner Turns abrufst, erfährst du im Abschnitt Elemente und Turns abrufen. Wie du feststellst, welcher Agent einen Befehl ausgeführt hat, erfährst du im Abschnitt Delegation nachvollziehen.
Lösche eine Sitzung, sobald deine Anwendung sie nicht mehr benötigt. Dadurch wird die Sitzung aus der API entfernt. Die physische Bereinigung der Daten kann anschließend asynchron weiterlaufen.
1
2
3
4
5
6
7
8
9// Replace the illustrative IDs and URLs below with your own resource values.
import OpenAI from "openai";
async function deleteSession(client: OpenAI, sessionId: string) {
return client.beta.agents.sessions.delete(sessionId);
}
const result = await deleteSession(new OpenAI(), "sess_123");
console.log(result);
1
2
3
4
5
6
7
8
9
10
11
12# Replace the illustrative IDs and URLs below with your own resource values.
from openai import OpenAI
def delete_session(client: OpenAI, session_id: str):
return client.beta.agents.sessions.delete(session_id)
if __name__ == "__main__":
result = delete_session(OpenAI(), "sess_123")
print(result.to_json())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22// Replace the illustrative IDs and URLs below with your own resource values.
package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
)
func deleteSession(ctx context.Context, client *openai.Client, sessionID string) (*openai.AgentSessionDeleted, error) {
return client.Beta.Agents.Sessions.Delete(ctx, sessionID)
}
func main() {
client := openai.NewClient()
result, err := deleteSession(context.Background(), &client, "sess_123")
if err != nil {
panic(err)
}
fmt.Println(result)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20// Replace the illustrative IDs and URLs below with your own resource values.
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.beta.agents.AgentSessionDeleted;
import com.openai.models.beta.agents.sessions.SessionDeleteParams;
public final class AgentsApiSessionsDeleteSessionExample {
public static AgentSessionDeleted deleteSession(OpenAIClient client, String sessionId) {
return client
.beta()
.agents()
.sessions()
.delete(SessionDeleteParams.builder().sessionId(sessionId).build());
}
public static void main(String[] args) {
var result = deleteSession(OpenAIOkHttpClient.fromEnv(), "sess_123");
System.out.println(result);
}
}
1
2
3
4
5
6
7
8# Replace the illustrative IDs and URLs below with your own resource values.
require "openai"
def delete_session(client, session_id)
client.beta.agents.sessions.delete(session_id)
end
puts delete_session(OpenAI::Client.new, "sess_123")
1
2
3
4curl -X DELETE \
"https://api.openai.com/v1/agents/sessions/$session_id" \
-H "OpenAI-Beta: agents=v1" \
-H "Authorization: Bearer $OPENAI_API_KEY"
Wenn du die laufende Arbeit stoppen und die Unterhaltung behalten möchtest, brich den aktiven Turn ab. Die Antwort auf die Löschanfrage findest du in der API-Referenz zum Löschen einer Sitzung.