--- title: Antworten mit Event-Deltas in der Vorschau anzeigen url: https://platform.claude.com/docs/de/managed-agents/event-deltas description: Zeige den Antworttext des Agenten als Live-Vorschau an, während das Modell ihn noch generiert. featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- Standardmäßig erreicht der Antworttext des Agenten den [Session-Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) als gepufferte `agent.message`-Events. Jedes davon wird erst ausgegeben, nachdem die Modellanfrage, die es erzeugt hat, abgeschlossen ist. Mit „event deltas" (Event-Deltas) kannst du diesen Text inkrementell als Live-Vorschau rendern, während das Modell ihn noch generiert. Vorschauen sind eine Anzeigehilfe nach dem Best-Effort-Prinzip, und die gepufferte `agent.message` ist immer der maßgebliche Datensatz. Ein Client, der Vorschauen ignoriert, erhält trotzdem einen vollständigen, korrekten Stream. ## Vorschauen aktivieren Vorschauen werden pro Stream-Verbindung aktiviert. Füge dem Stream, den du liest, den Query-Parameter `event_deltas[]` hinzu und wiederhole ihn einmal für jeden Event-Typ, den du in der Vorschau sehen möchtest. Die akzeptierten Werte sind `agent.message` und `agent.thinking`. Jeder andere Wert gibt einen 400-Fehler zurück, ebenso eine Anfrage mit mehr als 100 Werten. Beide Stream-Endpunkte akzeptieren den Parameter: * **Stream auf Session-Ebene:** `GET /v1/sessions/{session_id}/events/stream` * **Session-Thread-Stream:** `GET /v1/sessions/{session_id}/threads/{thread_id}/stream` Die Vorschauen eines Subagenten erscheinen im [eigenen Thread-Stream dieses Subagenten](https://platform.claude.com/docs/de/managed-agents/event-deltas#preview-session-thread-events). `[]` ist ein Shell-Glob-Muster, setze die URL also in Anführungszeichen, wann immer du die Anfrage in einer Shell erstellst. Die Beispiele kodieren die Klammern per Prozentkodierung als `%5B%5D`, was ebenfalls funktioniert. ### Vorschau-Events Wenn ein Event mit Vorschau beginnt, gibt der Stream ein `event_start` aus, das den Typ und die `id` des bevorstehenden Events enthält: ```json { "type": "event_start", "event": { "type": "agent.message", "id": "sevt_01abc..." } } ``` Bei `agent.message` folgen auf den Start `event_delta`-Events mit inkrementellem Text. Jedes Delta benennt in `event_id` das Event, das es erweitert, und in `delta.index` den Content-Block, den es erweitert: ```json { "type": "event_delta", "event_id": "sevt_01abc...", "delta": { "type": "content_delta", "index": 0, "content": { "type": "text", "text": "Here is the summary" } } } ``` Bei `agent.thinking` wird nur das `event_start` ausgegeben, als Signal, dass ein Thinking-Block begonnen hat. Es folgen keine `event_delta`-Events. Das gepufferte `agent.thinking`-Event, das die Vorschau abschließt, ist ein Fortschrittssignal und enthält keinen Nachdenk-Inhalt. Anders als persistierte Events haben `event_start` und `event_delta` keine eigene `id` oder `processed_at`. Der einzige Bezeichner, den sie enthalten, ist die `id` des Events, das sie in der Vorschau anzeigen. Ihre Typ-Strings sind außerdem die Ausnahme von der `{domain}.{action}`-Namenskonvention persistierter Events. Event-Deltas verwenden ein anderes Wire-Format als [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming), und der Unterschied ist beabsichtigt. Eine `agent.message` mit Vorschau erhält ein einzelnes `event_start`, gefolgt ausschließlich von `event_delta`-Events. Es gibt keine Start- oder Stop-Events pro Content-Block und kein Stop-Event für das Event mit Vorschau selbst. Der Delta-Typ ist `content_delta`, nicht `content_block_delta`. Für die Messages API geschriebener Akkumulator-Code lässt sich nicht unverändert übernehmen. ## Akkumulieren und abgleichen Jedes SDK, das Event-Deltas unterstützt, enthält einen [Akkumulator-Helfer](https://platform.claude.com/docs/de/managed-agents/event-deltas#sdk-accumulator-helpers), der die `index`-Buchführung für dich übernimmt. Das manuelle Muster in diesem Abschnitt funktioniert in jeder Sprache, wenn du eine eigene Buchführung benötigst. Wende es auf die generierten Event-Typen an. Beim manuellen Muster hältst du den Vorschautext in einer temporären Map mit dem Schlüssel `(event_id, index)` und behandelst das gepufferte Event als Datensatz. Gleiche die beiden pro Modellanfrage ab. Ein Turn beginnt mit einem einzelnen `session.status_running`-Event. Bei einem Turn, der normal abgeschlossen wird, erzeugt jede Modellanfrage dann diese Events in dieser Reihenfolge: 1. `span.model_request_start` 2. `event_start` 3. Die `event_delta`-Events 4. Die gepufferte `agent.message` 5. [`span.model_request_end`](https://platform.claude.com/docs/de/managed-agents/reference#event-types) (im Tab „Span events") Auf der Leitung ist dies der Vorschau-Teil dieser Sequenz, verschachtelt mit den anderen gepufferten Events der Verbindung: ```text wrap event_start {"event": {"type": "agent.message", "id": "sevt_01abc..."}} event_delta {"event_id": "sevt_01abc...", "delta": {"type": "content_delta", "index": 0, "content": {"type": "text", "text": "..."}}} ... agent.message {"id": "sevt_01abc...", "content": [...]} ``` Die `event_delta`-Zeile wiederholt sich einmal pro Textfragment. Verarbeite jedes Event, sobald es eintrifft: 1. Notiere dir bei `event_start` die angekündigte `id`. Die Bezeichner stimmen immer überein: `event_start.event.id`, jede `event_delta.event_id` und die `id` der gepufferten `agent.message` haben denselben Wert. 2. Hänge bei jedem `event_delta` `delta.content.text` an den Eintrag bei `(event_id, delta.index)` an und rendere den laufenden Text. Das erste Delta für einen `index` erstellt diesen Eintrag. 3. Wenn die gepufferte `agent.message` eintrifft, ordne sie anhand der `id` zu, verwirf die akkumulierte Vorschau und rendere stattdessen den Inhalt der Nachricht. 4. Schließe bei `span.model_request_end` jede Vorschau, die nicht durch ihr gepuffertes Event abgeglichen wurde. Für sie kommen keine weiteren Deltas mehr. Wenn der Turn fehlschlägt oder unterbrochen wird, trifft das gepufferte Event möglicherweise nie ein, `span.model_request_end` aber trotzdem. Das Muster stützt sich auf zwei Garantien: * Das Verketten der Deltas einer Vorschau in Ankunftsreihenfolge, mit dem Schlüssel `(event_id, index)`, ergibt ein Präfix von `content[index].text` im gepufferten Event. Es ist nicht unbedingt der gesamte Text, da Deltas [unter Last verworfen](https://platform.claude.com/docs/de/managed-agents/event-deltas#limitations) werden können. * Eine Verbindung gibt höchstens ein `event_start` pro `event_id` aus, und das gepufferte Event ist das Letzte, was diese Verbindung für diese `id` liefert. ### SDK-Akkumulator-Helfer Der Helfer jedes SDKs übernimmt die `index` (csharp, go: `Index`)-Buchführung. Die Helfer für Go, Java, Ruby und C# verwenden außerdem die `id` (csharp, go: `ID`) des Events als Schlüssel für die akkumulierende Vorschau. Bei den Helfern für Python, TypeScript und PHP führst du diese Map selbst und fügst jedes Delta in den Eintrag für seine `id` (csharp, go: `ID`) ein. Die folgenden Beispiele aktivieren Vorschauen für `agent.message` und gleichen sie mit dem gepufferten Event ab: Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen. Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen. ```python Python # Vorschau-Snapshots, nach Event-ID indiziert. accumulate_managed_agents_event faltet jedes # event_start / event_delta in einen agent.message-Snapshot; die gepufferte # agent.message ersetzt ihn. previews: dict[str, BetaManagedAgentsAgentMessageEvent] = {} # Aktiviere agent.message-Vorschauen für diese Verbindung with client.beta.sessions.events.stream( session.id, event_deltas=["agent.message"] ) as stream: client.beta.sessions.events.send( session.id, events=[ { "type": "user.message", "content": [ {"type": "text", "text": "Describe the repo in one sentence."} ], }, ], ) for event in stream: match event.type: case "event_start": snapshot = accumulate_managed_agents_event(None, event) if snapshot is not None: previews[event.event.id] = snapshot print(f"event_start {event.event.type} {event.event.id}") case "event_delta": preview = accumulate_managed_agents_event( previews.get(event.event_id), event ) if preview is not None: previews[event.event_id] = preview text = "".join(block.text for block in preview.content) print(f"event_delta preview: {text!r}") case "agent.message": # Das gepufferte Event ist der Datensatz: Es ersetzt und schließt die Vorschau preview = accumulate_managed_agents_event( previews.pop(event.id, None), event ) text = "".join(block.text for block in preview.content) print(f"agent.message {event.id} {text!r}") case "span.model_request_end": # Es kommen keine weiteren Deltas. Schließe jede Vorschau, deren # gepuffertes Event nie angekommen ist. for event_id in previews: print(f"span.model_request_end closing preview for {event_id}") previews.clear() case "session.status_idle": break ``` ```typescript TypeScript // Vorschau-Snapshots, nach Event-id geordnet. `accumulateManagedAgentsEvent` // fasst event_start-/event_delta-Vorschauen zu einem agent.message-Snapshot zusammen. const previews = new Map(); // Aktiviere agent.message-Vorschauen nur für diese Verbindung const stream = await client.beta.sessions.events.stream(session.id, { event_deltas: ["agent.message"] }); await client.beta.sessions.events.send(session.id, { events: [ { type: "user.message", content: [{ type: "text", text: "Summarize the repo README" }] } ] }); deltas: for await (const event of stream) { switch (event.type) { case "event_start": { // 1. Merke dir die angekündigte id und öffne den Snapshot. Deltas und das // gepufferte Event tragen dieselbe id. const preview = accumulateManagedAgentsEvent(undefined, event); if (preview) { previews.set(event.event.id, preview); } console.log(`event_start ${event.event.type} ${event.event.id}`); break; } case "event_delta": { // 2. Füge das Fragment in den Snapshot ein und rendere ihn const preview = accumulateManagedAgentsEvent(previews.get(event.event_id), event); if (preview) { previews.set(event.event_id, preview); const text = preview.content .map((block) => (block.type === "text" ? block.text : "")) .join(""); console.log(`event_delta preview: ${JSON.stringify(text)}`); } break; } case "agent.message": { // 3. Das gepufferte Event ist der Datensatz: Es ersetzt und schließt die Vorschau const message = accumulateManagedAgentsEvent(previews.get(event.id), event); previews.delete(event.id); const text = message.content .map((block) => (block.type === "text" ? block.text : "")) .join(""); console.log(`agent.message ${event.id} ${JSON.stringify(text)}`); break; } case "span.model_request_end": // 4. Es kommen keine Deltas mehr. Schließe jede nie abgeglichene Vorschau. for (const eventId of previews.keys()) { console.log(`span.model_request_end closing preview for ${eventId}`); } previews.clear(); break; case "session.status_idle": break deltas; } } stream.controller.abort(); ``` ```csharp C# // Aktiviere Event-Deltas: agent.message-Events werden während ihrer Erzeugung als Vorschau angezeigt. using var stream = await client.Beta.Sessions.Events.WithRawResponse.StreamStreaming( session.ID, new() { EventDeltas = [BetaManagedAgentsDeltaType.AgentMessage] } ); await client.Beta.Sessions.Events.Send(session.ID, new() { Events = [ new BetaManagedAgentsUserMessageEventParams { Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage, Content = [ new BetaManagedAgentsTextBlock { Type = BetaManagedAgentsTextBlockType.Text, Text = "Write a haiku about event streams.", }, ], }, ], }); // Sammle Vorschaufragmente pro (Event-ID, Content-Index). Das gepufferte // nachfolgende agent.message enthält den vollständigen Inhalt und ersetzt daher die // gesammelte Vorschau, statt an sie angehängt zu werden. Dictionary> previews = []; await foreach (var streamEvent in stream.Enumerate()) { if (streamEvent.TryPickStartEvent(out var start)) { // Eine Vorschau wurde für das Event mit dieser ID geöffnet. Dieser Stream aktiviert nur // agent.message-Deltas; TryPick* gibt false zurück, statt eine Exception zu werfen, // daher werden andere Vorschautypen (auch später hinzugefügte) übersprungen. if (start.Event.TryPickAgentMessage(out var preview)) { Console.WriteLine($"event_start {preview.Type.Raw()} {preview.ID}"); } } else if (streamEvent.TryPickDeltaEvent(out var delta)) { // Bei neuem Index einfügen, bei bestehendem anhängen if (!previews.TryGetValue(delta.EventID, out var fragments)) { previews[delta.EventID] = fragments = []; } var index = delta.Delta.Index ?? 0; fragments[index] = fragments.GetValueOrDefault(index, "") + delta.Delta.Content.Text; Console.WriteLine($"event_delta preview: {fragments[index]}"); } else if (streamEvent.TryPickAgentMessageEvent(out var message)) { // Deltas sind Best-Effort: Verwirf die Vorschau und verwende das gepufferte Event previews.Remove(message.ID); var text = string.Concat(message.Content.Select(block => block.TryPickBetaManagedAgentsTextBlock(out var textBlock) ? textBlock.Text : "")); Console.WriteLine($"agent.message {message.ID} {text}"); } else if (streamEvent.TryPickSpanModelRequestEndEvent(out _)) { // Es kommen keine Deltas mehr; schließe jede nie abgeglichene Vorschau. foreach (var eventId in previews.Keys) { Console.WriteLine($"span.model_request_end closing preview for {eventId}"); } previews.Clear(); } else if (streamEvent.TryPickSessionStatusIdleEvent(out _)) { break; } } ``` ```go Go // Aktiviere inkrementelle Vorschauen von agent.message-Events stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{ EventDeltas: []anthropic.BetaManagedAgentsDeltaType{ anthropic.BetaManagedAgentsDeltaTypeAgentMessage, }, }) if _, err := client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{ Events: []anthropic.BetaManagedAgentsEventParamsUnion{{ OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{ Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage, Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{ OfText: &anthropic.BetaManagedAgentsTextBlockParam{ Type: anthropic.BetaManagedAgentsTextBlockTypeText, Text: "Write a haiku about the ocean.", }, }}, }, }}, }); err != nil { panic(err) } // Der Akkumulator fasst event_start- / event_delta-Fragmente zu // agent.message-Snapshots pro Event-ID zusammen. Der Nullwert ist sofort nutzbar. var previews anthropic.BetaManagedAgentsEventAccumulator deltas: for stream.Next() { event := stream.Current() previews.Accumulate(event) switch event := event.AsAny().(type) { case anthropic.BetaManagedAgentsStartEvent: fmt.Printf("event_start %s %s\n", event.Event.Type, event.Event.ID) case anthropic.BetaManagedAgentsDeltaEvent: fmt.Printf("event_delta preview: %q\n", previews.AgentMessageText(event.EventID)) case anthropic.BetaManagedAgentsAgentMessageEvent: // Das gepufferte Event enthält den vollständigen Inhalt: Der Akkumulator // ersetzt die Vorschau damit fmt.Printf("agent.message %s %q\n", event.ID, previews.AgentMessageText(event.ID)) case anthropic.BetaManagedAgentsSpanModelRequestEndEvent: // Für diesen Request kommen keine Deltas mehr. Der Akkumulator // verwirft hier seine Snapshots und schließt jede Vorschau, die nie // durch ein gepuffertes agent.message abgeglichen wurde. fmt.Println("span.model_request_end no more deltas for this request") case anthropic.BetaManagedAgentsSessionStatusIdleEvent: break deltas } } if err := stream.Err(); err != nil { panic(err) } stream.Close() ``` ```java Java // Vorschautext, nach Event-ID und dann Content-Index geschlüsselt. Die gepufferte agent.message ersetzt ihn. Map> previews = new HashMap<>(); // Aktiviere agent.message-Vorschauen für diese Verbindung try (var stream = client.beta().sessions().events().streamStreaming( session.id(), EventStreamParams.builder() .addEventDelta(BetaManagedAgentsDeltaType.AGENT_MESSAGE) .build() )) { client.beta().sessions().events().send( session.id(), EventSendParams.builder() .addEvent(BetaManagedAgentsUserMessageEventParams.builder() .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE) .addTextContent("Describe the repo in one sentence.") .build()) .build() ); Iterable events = stream.stream()::iterator; deltas: for (var event : events) { switch (event.type().value()) { case EVENT_START -> { if (event.asEventStart().event().isAgentMessage()) { var preview = event.asEventStart().event().asAgentMessage(); IO.println("event_start " + preview.type().asString() + " " + preview.id()); } } case EVENT_DELTA -> { var eventDelta = event.asEventDelta(); var fragment = eventDelta.delta(); var buffer = previews .computeIfAbsent(eventDelta.eventId(), _ -> new HashMap<>()) .computeIfAbsent(fragment.index().orElse(0L), _ -> new StringBuilder()); buffer.append(fragment.content().text()); IO.println("event_delta preview: " + buffer); } case AGENT_MESSAGE -> { // Das gepufferte Event ist maßgeblich: verwirf seine Vorschau, rendere seinen Inhalt var message = event.asAgentMessage(); previews.remove(message.id()); var text = message.content().stream() .flatMap(block -> block.text().stream()) .map(textBlock -> textBlock.text()) .collect(Collectors.joining()); IO.println("agent.message " + message.id() + " " + text); } case SPAN_MODEL_REQUEST_END -> { // Es kommen keine Deltas mehr. Schließe jede Vorschau, deren gepuffertes Event nie ankam. previews.keySet().forEach(eventId -> IO.println("span.model_request_end closing preview for " + eventId)); previews.clear(); } case SESSION_STATUS_IDLE -> { break deltas; } } } } ``` ```php PHP use Anthropic\Beta\Sessions\BetaManagedAgentsDeltaEvent; use Anthropic\Beta\Sessions\BetaManagedAgentsDeltaType; use Anthropic\Beta\Sessions\BetaManagedAgentsStartEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsSpanModelRequestEndEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock; use Anthropic\Lib\Sessions\EventAccumulator; // Vorschau-Snapshots, nach Event-ID indiziert. EventAccumulator::accumulate() fügt jedes // event_start / event_delta zu einem agent.message-Snapshot hinzu; die gepufferte // agent.message ersetzt ihn. $previews = []; // Der Text eines agent.message-Snapshots oder -Events $textOf = fn (ManagedAgentsAgentMessageEvent $message): string => implode( '', array_map( fn ($block) => $block->text, array_filter( $message->content, fn ($block) => $block instanceof ManagedAgentsTextBlock, ), ), ); // Aktiviere agent.message-Vorschauen für diese Verbindung $stream = $client->beta->sessions->events->streamStream( $session->id, eventDeltas: [BetaManagedAgentsDeltaType::AGENT_MESSAGE], ); $client->beta->sessions->events->send( $session->id, events: [ [ 'type' => 'user.message', 'content' => [['type' => 'text', 'text' => 'Describe the repo in one sentence.']], ], ], ); foreach ($stream as $event) { switch (true) { case $event instanceof BetaManagedAgentsStartEvent: $snapshot = EventAccumulator::accumulate(null, $event); if ($snapshot !== null) { $previews[$event->event->id] = $snapshot; } printf("event_start %s %s\n", $event->event->type, $event->event->id); break; case $event instanceof BetaManagedAgentsDeltaEvent: // Überspringe ein verspätetes Delta für eine bereits ersetzte oder geschlossene Vorschau if (!isset($previews[$event->eventID])) { break; // Break switch statement } $previews[$event->eventID] = EventAccumulator::accumulate($previews[$event->eventID], $event); printf("event_delta preview: %s\n", json_encode($textOf($previews[$event->eventID]))); break; case $event instanceof ManagedAgentsAgentMessageEvent: // Das gepufferte Event ist der Datensatz: Es ersetzt und schließt die Vorschau unset($previews[$event->id]); printf("agent.message %s %s\n", $event->id, json_encode($textOf($event))); break; case $event instanceof ManagedAgentsSpanModelRequestEndEvent: // Es kommen keine Deltas mehr. Schließe jede Vorschau, deren // gepuffertes Event nie angekommen ist. foreach (array_keys($previews) as $eventID) { printf("span.model_request_end closing preview for %s\n", $eventID); } $previews = []; break; case $event instanceof ManagedAgentsSessionStatusIdleEvent: break 2; // Break foreach loop } } $stream->close(); ``` ```ruby Ruby # Event-Deltas aktivieren: agent.message-Vorschauen werden als inkrementelle Fragmente gestreamt. stream = client.beta.sessions.events.stream_events( session.id, event_deltas: [Anthropic::Beta::BetaManagedAgentsDeltaType::AGENT_MESSAGE] ) client.beta.sessions.events.send_( session.id, events: [{ type: "user.message", content: [{type: "text", text: "Give a one-sentence project tagline."}] }] ) # Sammle Vorschau-Fragmente nach (event_id, index) in explizit veränderbaren # (`+""`) Puffern, damit `<<` direkt anhängen kann. Die gepufferte agent.message mit # derselben ID ist maßgeblich und ersetzt alles, was die Deltas aufgebaut haben. buffers = Hash.new do |by_event, event_id| by_event[event_id] = Hash.new { |fragments, index| fragments[index] = +"" } end stream.each do |event| case event when Anthropic::Beta::BetaManagedAgentsStartEvent puts "event_start #{event.event.type} #{event.event.id}" when Anthropic::Beta::BetaManagedAgentsDeltaEvent delta = event.delta fragment = delta.content.text buffers[event.event_id][delta.index || 0] << fragment puts "event_delta preview: #{buffers[event.event_id][delta.index || 0].inspect}" when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent # Ersetzen: verwirf die gesammelte Vorschau und rendere das vollständige Event. buffers.delete(event.id) puts "agent.message #{event.id} #{event.content.map(&:text).join.inspect}" when Anthropic::Beta::Sessions::BetaManagedAgentsSpanModelRequestEndEvent # Es kommen keine Deltas mehr. Schließe jede nie abgeglichene Vorschau. buffers.each_key { |event_id| puts "span.model_request_end closing preview for #{event_id}" } buffers.clear when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent break else # andere Event-Typen ignorieren end end ``` ## Vorschau von Session-Thread-Events In einer [Multiagenten](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration)-Session hat jeder Session-Thread seinen eigenen Event-Stream. Er akzeptiert denselben `event_deltas[]`-Parameter mit denselben Werten. Eine Verbindung zeigt nur den Thread in der Vorschau an, den sie liest. Der Stream auf Session-Ebene zeigt den primären Thread in der Vorschau an, und die Vorschauen eines Child-Threads werden nie dorthin gespiegelt. Um den Text eines Subagenten zu verfolgen, während das Modell ihn generiert, öffne den Thread-Stream dieses Subagenten. Der Pfad eines Thread-Streams endet auf `/threads/{thread_id}/stream`. `/events/stream` existiert nur auf Session-Ebene, daher gibt es keinen Endpunkt `/threads/{thread_id}/events/stream`. `event_start` und `event_delta` haben in einem Thread-Stream dieselbe Form wie im Stream auf Session-Ebene, und das Muster [Akkumulieren und abgleichen](https://platform.claude.com/docs/de/managed-agents/event-deltas#accumulate-and-reconcile) gilt wie beschrieben. Führe eine Akkumulator-Instanz pro Stream-Verbindung aus. ```bash cURL # Der Thread-Stream akzeptiert denselben event_deltas[]-Parameter wie der Session-Stream. # Kodiere die Klammern per Prozent-Encoding (%5B%5D) und setze die URL in Anführungszeichen. curl --fail-with-body -sS -N \ "https://api.anthropic.com/v1/sessions/$SESSION_ID/threads/$THREAD_ID/stream?beta=true&event_deltas%5B%5D=agent.message" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: managed-agents-2026-04-01" \ -H "accept: text/event-stream" ``` ```bash CLI # Der Thread-Stream nimmt denselben event_deltas-Parameter wie der Session-Stream, # ein --event-delta-Flag pro Event-Typ für die Vorschau. ant beta:sessions:threads:events stream \ --session-id "$SESSION_ID" \ --thread-id "$THREAD_ID" \ --event-delta agent.message ``` ```python Python # Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null # parent_thread_id, und die parent_thread_id des primären Threads ist null. child_thread = next( thread for thread in client.beta.sessions.threads.list(session.id) if thread.parent_thread_id is not None ) # Der Stream des Child-Threads nimmt denselben event_deltas-Parameter wie der # Session-Stream. with client.beta.sessions.threads.events.stream( child_thread.id, session_id=session.id, event_deltas=["agent.message"], ) as stream: for event in stream: match event.type: case "event_delta": print(event.delta.content.text, end="") case "agent.message": # Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt print() for block in event.content: if block.type == "text": print(block.text, end="") print() case "session.thread_status_idle": break ``` ```typescript TypeScript // Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null // parent_thread_id, und die parent_thread_id des primären Threads ist null. let childThreadId: string | undefined; for await (const thread of client.beta.sessions.threads.list(session.id)) { if (thread.parent_thread_id !== null) { childThreadId = thread.id; break; } } if (!childThreadId) { throw new Error("No child thread found"); } // Der Stream des Child-Threads akzeptiert denselben event_deltas-Parameter wie der // Session-Stream. const stream = await client.beta.sessions.threads.events.stream(childThreadId, { session_id: session.id, event_deltas: ["agent.message"] }); threadDeltas: for await (const event of stream) { switch (event.type) { case "event_delta": process.stdout.write(event.delta.content.text); break; case "agent.message": { // Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt. process.stdout.write("\n"); const text = event.content .map((block) => (block.type === "text" ? block.text : "")) .join(""); console.log(text); break; } case "session.thread_status_idle": break threadDeltas; } } stream.controller.abort(); ``` ```csharp C# // Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null // parent_thread_id, und die parent_thread_id des primären Threads ist null. var threads = await client.Beta.Sessions.Threads.List(session.ID); var childThread = threads.Items.First(thread => thread.ParentThreadID is not null); // Der Stream des Child-Threads akzeptiert denselben event_deltas-Parameter wie der // Session-Stream. using var stream = await client.Beta.Sessions.Threads.Events.WithRawResponse.StreamStreaming( childThread.ID, new() { SessionID = session.ID, EventDeltas = [BetaManagedAgentsDeltaType.AgentMessage] } ); await foreach (var streamEvent in stream.Enumerate()) { if (streamEvent.TryPickDeltaEvent(out var delta)) { Console.Write(delta.Delta.Content.Text); } else if (streamEvent.TryPickAgentMessageEvent(out var message)) { // Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt. Console.WriteLine(); var text = string.Concat(message.Content.Select(block => block.TryPickBetaManagedAgentsTextBlock(out var textBlock) ? textBlock.Text : "")); Console.WriteLine(text); } else if (streamEvent.TryPickSessionThreadStatusIdleEvent(out _)) { break; } } ``` ```go Go // Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null // parent_thread_id, und die parent_thread_id des primären Threads ist null. var childThreadID string threads := client.Beta.Sessions.Threads.ListAutoPaging(ctx, session.ID, anthropic.BetaSessionThreadListParams{}) for threads.Next() { if thread := threads.Current(); thread.ParentThreadID != "" { childThreadID = thread.ID break } } if err := threads.Err(); err != nil { panic(err) } // Der Stream des Child-Threads akzeptiert denselben event_deltas-Parameter wie der // Session-Stream; führe pro Stream-Verbindung eine Leseschleife aus. stream := client.Beta.Sessions.Threads.Events.StreamEvents(ctx, childThreadID, anthropic.BetaSessionThreadEventStreamParams{ SessionID: session.ID, EventDeltas: []anthropic.BetaManagedAgentsDeltaType{ anthropic.BetaManagedAgentsDeltaTypeAgentMessage, }, }) threadDeltas: for stream.Next() { switch event := stream.Current().AsAny().(type) { case anthropic.BetaManagedAgentsDeltaEvent: fmt.Print(event.Delta.Content.Text) case anthropic.BetaManagedAgentsAgentMessageEvent: // Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt. fmt.Println() // konkret typisierte Liste: BetaManagedAgentsTextBlock for _, block := range event.Content { fmt.Print(block.Text) } fmt.Println() case anthropic.BetaManagedAgentsSessionThreadStatusIdleEvent: break threadDeltas } } if err := stream.Err(); err != nil { panic(err) } stream.Close() ``` ```java Java // Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null // parent_thread_id, und die parent_thread_id des primären Threads ist null. var childThread = client.beta().sessions().threads().list(session.id()).autoPager().stream() .filter(thread -> thread.parentThreadId().isPresent()) .findFirst() .orElseThrow(); // Der Stream des Child-Threads nimmt denselben event_deltas-Parameter wie der Session- // Stream. Seine Params-Klasse hat denselben einfachen Namen wie die auf Session-Ebene, also qualifiziere sie. try (var stream = client.beta().sessions().threads().events().streamStreaming( childThread.id(), com.anthropic.models.beta.sessions.threads.events.EventStreamParams.builder() .sessionId(session.id()) .addEventDelta(BetaManagedAgentsDeltaType.AGENT_MESSAGE) .build() )) { Iterable events = stream.stream()::iterator; threadDeltas: for (var event : events) { switch (event.type().value()) { case EVENT_DELTA -> IO.print(event.asEventDelta().delta().content().text()); case AGENT_MESSAGE -> { // Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt. IO.println(); event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text()))); IO.println(); } case SESSION_THREAD_STATUS_IDLE -> { break threadDeltas; } } } } ``` ```php PHP use Anthropic\Beta\Sessions\BetaManagedAgentsDeltaEvent; use Anthropic\Beta\Sessions\BetaManagedAgentsDeltaType; use Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsSessionThreadStatusIdleEvent; use Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock; // Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null // parentThreadID, und die parentThreadID des primären Threads ist null. $childThread = null; foreach ($client->beta->sessions->threads->list($session->id)->pagingEachItem() as $thread) { if ($thread->parentThreadID !== null) { $childThread = $thread; break; } } // Der Stream des Child-Threads akzeptiert denselben eventDeltas-Parameter wie der // Session-Stream. $stream = $client->beta->sessions->threads->events->streamStream( $childThread->id, sessionID: $session->id, eventDeltas: [BetaManagedAgentsDeltaType::AGENT_MESSAGE], ); foreach ($stream as $event) { switch (true) { case $event instanceof BetaManagedAgentsDeltaEvent: echo $event->delta->content->text; break; case $event instanceof ManagedAgentsAgentMessageEvent: // Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt echo "\n"; foreach ($event->content as $block) { if ($block instanceof ManagedAgentsTextBlock) { echo $block->text; } } echo "\n"; break; case $event instanceof ManagedAgentsSessionThreadStatusIdleEvent: break 2; // Break foreach loop } } $stream->close(); ``` ```ruby Ruby # Liste die Threads der Session auf und wähle einen Child-Thread: Child-Threads haben eine nicht-null # parent_thread_id, und die parent_thread_id des primären Threads ist null. child_thread = client.beta.sessions.threads.list(session.id).to_enum.find { it.parent_thread_id } # Der Stream des Child-Threads akzeptiert denselben event_deltas-Parameter wie der # Session-Stream. stream = client.beta.sessions.threads.events.stream_events( child_thread.id, session_id: session.id, event_deltas: [Anthropic::Beta::BetaManagedAgentsDeltaType::AGENT_MESSAGE] ) stream.each do |event| case event when Anthropic::Beta::BetaManagedAgentsDeltaEvent print event.delta.content.text when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent # Das gepufferte Event ist der maßgebliche Datensatz; rendere seinen Inhalt. puts event.content.each { print it.text } puts when Anthropic::Beta::Sessions::BetaManagedAgentsSessionThreadStatusIdleEvent break else # andere Event-Typen ignorieren end end ``` Die Leseschleife endet bei [`session.thread_status_idle`](https://platform.claude.com/docs/de/managed-agents/reference#event-types), dem Event, das ausgegeben wird, wenn der Turn des Session-Threads abgeschlossen ist und der Thread in den Leerlauf wechselt. ## Einschränkungen * **Best Effort:** Unter Last kann der Server Deltas für ein Event verwerfen. In diesem Fall erhältst du ein zusammenhängendes Präfix des Textes und danach keine weiteren Deltas für dieses Event. Die gepufferte `agent.message` trifft trotzdem vollständig ein. Behandle eine akkumulierte Vorschau niemals als endgültig. * **Keine Wiedergabe bei erneuter Verbindung:** Deltas werden nur an die Verbindung geliefert, die sie aktiviert hat, solange sie geöffnet ist. Dies gilt gleichermaßen für den Stream auf Session-Ebene und für jeden Session-Thread-Stream. Eine Verbindung, die nach dem Start einer Modellanfrage geöffnet wurde, erhält keine Deltas für dieses laufende Event. Es gibt keine Möglichkeit, verpasste Deltas erneut anzufordern. * **Ein Thread, nur Text:** Vorschauen umfassen Assistententext in [dem Thread, den die Verbindung liest](https://platform.claude.com/docs/de/managed-agents/event-deltas#preview-session-thread-events). „Tool use" (Tool-Nutzung), Tool-Ergebnisse und MCP-Ergebnisse werden nie in der Vorschau angezeigt. * **Nie persistiert:** `event_start` und `event_delta` existieren nur im Live-Stream. Sie erscheinen weder im Event-Verlauf der Session (`GET /v1/sessions/{session_id}/events`) noch im Event-Verlauf eines Session-Threads. ## Fehlerbehebung bei Vorschauen | Du siehst | Was es bedeutet | | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Einen Stream mit gepufferten Events, aber ohne `event_start` oder `event_delta` | Die Verbindung, die du liest, hat die Vorschau nicht aktiviert, oder der Turn hat den Thread, den du streamst, nie berührt. `event_deltas[]` gilt pro Verbindung, nicht pro Session. Um herauszufinden, welcher Thread ausgeführt wurde, liste die Threads der Session auf (`GET /v1/sessions/{session_id}/threads`). | | Einen Stream, der während einer Vorschau abbricht | Deltas werden nicht erneut wiedergegeben. Folge dem [Verfahren zur erneuten Verbindung](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#reconnect-without-missing-events): Öffne den Stream erneut und liste den Event-Verlauf auf. Der Verlauf enthält alle gepufferten Events, die ausgegeben wurden, während du getrennt warst, einschließlich der `agent.message`, auf die deine Vorschau gewartet hat. | | Einen 404-Fehler bei der Stream-URL | Der Pfad oder eine ID ist falsch, oder die Anfrage enthält überhaupt keinen managed-agents-Beta-Header. Die Thread-Endpunkte sind Beta-geschützt, ohne den Header existieren sie also nicht. | | Einen 400-Fehler, der `event_deltas` nennt | Nur `agent.message` und `agent.thinking` werden akzeptiert. | ## Nächste Schritte Sende Events, streame Antworten und unterbrich oder lenke deine Session während der Ausführung um. Koordiniere mehrere Agenten innerhalb einer einzigen Session.