{"meta":{"title":"Ereignisse einer Streaming-Sitzung","intro":"Jede Aktion, die der Copilot-Agent ausführt – etwa Denken, Schreiben von Code oder Ausführen von Tools – wird als Session-Ereignis ausgegeben, das Sie abonnieren können. Dieses Handbuch ist ein Verweis auf Feldebene für jeden Ereignistyp, sodass Sie genau wissen, welche Daten erwartet werden, ohne die SDK-Quelle zu lesen.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos","title":"Vorgehensweisen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk","title":"Copilot SDK"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features","title":"Funktionen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events","title":"Streamingereignisse"}],"documentType":"article"},"body":"# Ereignisse einer Streaming-Sitzung\n\nJede Aktion, die der Copilot-Agent ausführt – etwa Denken, Schreiben von Code oder Ausführen von Tools – wird als Session-Ereignis ausgegeben, das Sie abonnieren können. Dieses Handbuch ist ein Verweis auf Feldebene für jeden Ereignistyp, sodass Sie genau wissen, welche Daten erwartet werden, ohne die SDK-Quelle zu lesen.\n\n<!-- markdownlint-disable GHD046 GHD005 -->\n\n<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->\n\n## Übersicht\n\nWenn `streaming: true` für eine Sitzung festgelegt wird, sendet das SDK **kurzlebige** Ereignisse in Echtzeit (Deltas, Statusaktualisierungen) neben **dauerhaften** Ereignissen (vollständige Nachrichten, Toolergebnisse). Alle Ereignisse teilen einen gemeinsamen Umschlag und tragen eine `data` Nutzlast, deren Shape vom Ereignis `type`abhängt.\n\n![Diagramm: Sequenzdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/features-streaming-events-diagram-0.png)\n\n| Konzept                    | Description                                                                                                                                   |\n| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Ephemerales Ereignis**   | Vorübergehende; in Echtzeit gestreamt, aber **nicht** im Sitzungsprotokoll gespeichert. Wird beim Fortsetzen der Sitzung nicht wiedergegeben. |\n| **Persistiertes Ereignis** | Im Sitzungsereignisprotokoll auf dem Datenträger gespeichert. Wird wiedergegeben, wenn eine Sitzung fortgesetzt wird.                         |\n| **Delta-Ereignis**         | Ein ephemerer Streamingabschnitt (Text oder Argumentation). Sammeln Sie Deltas, um den vollständigen Inhalt zu erstellen.                     |\n| **`parentId` Kette**       | Jedes Ereignis `parentId` verweist auf das vorherige Ereignis und bildet eine verknüpfte Liste, die Sie durchlaufen können.                   |\n\n## Ereignishülle\n\nJedes Sitzungsereignis umfasst unabhängig vom Typ die folgenden Felder:\n\n| Feld                                                                                           | Typ                              | Description                                                                                                            |\n| ---------------------------------------------------------------------------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |\n| `id`                                                                                           |                                  |                                                                                                                        |\n| `string` (UUID v4)                                                                             | Eindeutiger Ereignisbezeichner   |                                                                                                                        |\n| `timestamp`                                                                                    |                                  |                                                                                                                        |\n| `string` (ISO 8601)                                                                            | Wann das Ereignis erstellt wurde |                                                                                                                        |\n| `parentId`                                                                                     | `string \\| null`                 | ID des vorherigen Ereignisses in der Kette; `null` für das erste Ereignis                                              |\n| `agentId`                                                                                      | `string?`                        | Sub-Agent-Instanz-ID für Sub-Agent-Ursprungsereignisse; für Stamm-/Haupt-Agent- und Sitzungsereignisse nicht vorhanden |\n| `ephemeral`                                                                                    | `boolean?`                       |                                                                                                                        |\n| `true` für vorübergehende Ereignisse; nicht vorhanden oder `false` für beibehaltene Ereignisse |                                  |                                                                                                                        |\n| `type`                                                                                         | `string`                         | Diskriminator des Ereignistyps (siehe Tabellen unten)                                                                  |\n| `data`                                                                                         | `object`                         | Ereignisspezifische Nutzlast                                                                                           |\n\n## Abonnieren von Ereignissen\n\n<div class=\"ghd-codetabs\">\n<div class=\"ghd-codetab\" data-lang=\"typescript\" data-label=\"TypeScript\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">TypeScript</div>\n\n```typescript\n// All events\nsession.on((event) => {\n    console.log(event.type, event.data);\n});\n\n// Specific event type — data is narrowed automatically\nsession.on(\"assistant.message_delta\", (event) => {\n    process.stdout.write(event.data.deltaContent);\n});\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"python\" data-label=\"Python\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Python</div>\n\n```python\nfrom copilot.session_events import SessionEventType\n\ndef handle(event):\n    if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:\n        print(event.data.delta_content, end=\"\", flush=True)\n\nsession.on(handle)\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"go\" data-label=\"Go\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Go</div>\n\n```golang\nsession.On(func(event copilot.SessionEvent) {\n    if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {\n        fmt.Print(d.DeltaContent)\n    }\n})\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"dotnet\" data-label=\".NET\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">.NET</div>\n\n```csharp\nsession.On<SessionEvent>(evt =>\n{\n    if (evt is AssistantMessageDeltaEvent delta)\n    {\n        Console.Write(delta.Data.DeltaContent);\n    }\n});\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"java\" data-label=\"Java\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Java</div>\n\n<!-- docs-validate: skip -->\n\n```java\n// All events\nsession.on(event -> System.out.println(event.getType()));\n\n// Specific event type — data is narrowed to the matching class\nsession.on(AssistantMessageDeltaEvent.class, event ->\n    System.out.print(event.getData().deltaContent())\n);\n```\n\n</div>\n\n</div>\n\n> \\[!TIP]\n> **(Python / Go)** Diese SDKs verwenden für jedes Ereignis separate Datentypen (z. B. `AssistantMessageDeltaData`), sodass nur die relevanten Felder in jedem Typ vorhanden sind.\n>\n> \\[!TIP]\n> **(.NET)** Das .NET SDK verwendet separate, stark typierte Datenklassen pro Ereignis (z. B. `AssistantMessageDeltaData`), sodass nur die relevanten Felder für jeden Typ vorhanden sind.\n>\n> \\[!TIP]\n> **(TypeScript)** Das TypeScript SDK verwendet ein discriminated union – wenn Sie auf `event.type` passen, wird der `data` Payload automatisch auf die richtige Form eingegrenzt.\n\n## Abonnieren vor Beginn einer Sitzung\n\nEine Sitzung kann Ereignisse ausgeben, bevor ihr create- oder resume-Aufruf zurückkehrt. Der Agent arbeitet möglicherweise bereits – insbesondere bei Fortsetzung mit `continuePendingWork` – und kurzlebige Ereignisse wie `session.idle` werden niemals in das Sitzungsprotokoll geschrieben, sodass `getMessages` sie anschließend nicht wiederherstellen kann. Ein Abonnement, das erst eingerichtet wird, nachdem das Sitzungs-Handle bereits existiert, verpasst dieses Startfenster.\n\n> \\[!TIP]\n> **(Rust)**`Client::prepare_session` und `Client::prepare_resume_session` geben ein `PreparedSession` zurück, das den Ereigniskanal der Sitzung besitzt, bevor irgendeine Protokollaktivität stattfindet. Abonnieren Sie zuerst, und rufen Sie dann auf `start()`.\n\n```rust\nuse github_copilot_sdk::{Client, SessionConfig};\n\nasync fn create_without_missing_startup_events(\n    client: &Client,\n) -> Result<(), github_copilot_sdk::Error> {\n    let prepared = client.prepare_session(\n        SessionConfig::default().with_event_buffer_capacity(2048),\n    )?;\n\n    // Installed before any wire activity: nothing is dropped for lack of a receiver.\n    let mut events = prepared.subscribe();\n    tokio::spawn(async move {\n        while let Ok(event) = events.recv().await {\n            println!(\"{}\", event.event_type);\n        }\n    });\n\n    let session = prepared.start().await?;\n    let _ = session;\n    Ok(())\n}\n```\n\n`prepare_*` ist synchron und inert: Er überprüft die Pufferkapazität, weist einen lokalen Kanal zu und führt nichts anderes aus. Es ist keine Sitzung registriert, und nichts erreicht die CLI, bis `start()` erstmals abgefragt wird. Das Ablegen einer vorbereiteten Sitzung, die nie gestartet wurde, hinterlässt keinen Zustand und schließt seine Abonnements; Wenn Sie die `start()` Zukunft löschen, wird der In-Flight-Start abgebrochen und die Registrierung der Sitzung aufgehoben, sodass ein Wiederholungsversuche mit derselben Sitzungs-ID erfolgreich ist. Die Bereinigung ist auf genau die Registrierung des abgebrochenen Startvorgangs beschränkt, sodass sie keinen Wiederholungsversuch verdrängen kann, der dieselbe Sitzungs-ID bereits übernommen hat.\n\nEs lohnt sich, die Pufferung beim Start einzuplanen:\n\n* Der Ereignispuffer ist begrenzt – auf 512 Ereignisse, sofern dies nicht durch `event_buffer_capacity` überschrieben wird. Eine Kapazität von `0` wird mit einem „invalid-config“-Fehler abgelehnt, anstatt begrenzt zu werden.\n* Langsame Abonnenten beobachten einen `Lagged` Fehler, der meldet, wie viele Ereignisse übersprungen wurden. Sie üben niemals Backpressure auf die Ereignisschleife der Sitzung aus.\n* Verbraucher, die einen lückenlosen Überblick über einen großen Start-Burst benötigen, müssen entweder eine Kapazität konfigurieren, die dies abdeckt, oder das Abonnement gleichzeitig mit `start()` aufbrauchen.\n\n> \\[!NOTE]\n> Bei Cloudsitzungen, in denen der Server die Sitzungs-ID zuweist, kann das SDK keine Benachrichtigungen weiterleiten, bis die Erstellungsantwort eingeht und die ID bekannt ist. Ereignisse, die vor diesem Zeitpunkt ausgelöst werden, lassen sich keiner Sitzung zuordnen. Die Garantie ist eingeschränkter: Weitergeleitete Ereignisse werden nie mangels eines installierten Empfängers verworfen. Heften Sie `session_id` in der Konfiguration an, um Routing – und vollständige Abdeckung vor der Antwort – ab dem ersten Byte zu erhalten.\n\n## Nur die Antwort des übergeordneten Agenten anzeigen\n\nSubagent-Ereignisse teilen den übergeordneten Sitzungsdatenstrom und umfassen `agentId` auf Envelope-Ebene. Ereignisse des Root-/Haupt-Agenten und Ereignisse auf Sitzungsebene lassen `agentId` aus, sodass Renderer des Hauptchats Assistentenereignisse, bei denen `agentId` gesetzt ist, ignorieren und stattdessen an Traces oder die Fortschritts-UI weiterleiten können.\n\n<div class=\"ghd-codetabs\">\n<div class=\"ghd-codetab\" data-lang=\"typescript\" data-label=\"TypeScript\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">TypeScript</div>\n\n```typescript\nimport type { CopilotSession } from \"@github/copilot-sdk\";\n\nexport function subscribeParentResponse(session: CopilotSession): void {\n    session.on(\"assistant.message_delta\", (event) => {\n        if (!event.agentId) {\n            process.stdout.write(event.data.deltaContent);\n        }\n    });\n}\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"python\" data-label=\"Python\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Python</div>\n\n```python\nfrom copilot import CopilotSession, SessionEvent, SessionEventType\nfrom copilot.session_events import AssistantMessageDeltaData\n\ndef subscribe_parent_response(session: CopilotSession) -> None:\n    def handle(event: SessionEvent) -> None:\n        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA and event.agent_id is None:\n            data = event.data\n            if isinstance(data, AssistantMessageDeltaData):\n                print(data.delta_content, end=\"\", flush=True)\n\n    session.on(handle)\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"go\" data-label=\"Go\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Go</div>\n\n```golang\npackage example\n\nimport (\n    \"fmt\"\n\n    copilot \"github.com/github/copilot-sdk/go\"\n)\n\nfunc subscribeParentResponse(session *copilot.Session) {\n    session.On(func(event copilot.SessionEvent) {\n        if event.AgentID != nil {\n            return\n        }\n\n        if d, ok := event.Data.(*copilot.AssistantMessageDeltaData); ok {\n            fmt.Print(d.DeltaContent)\n        }\n    })\n}\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"dotnet\" data-label=\".NET\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">.NET</div>\n\n```csharp\nusing System;\nusing GitHub.Copilot;\n\nstatic class ParentAgentResponseExample\n{\n    public static void SubscribeParentResponse(CopilotSession session)\n    {\n        session.On<AssistantMessageDeltaEvent>(evt =>\n        {\n            if (evt.AgentId is null)\n            {\n                Console.Write(evt.Data.DeltaContent);\n            }\n        });\n    }\n}\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"java\" data-label=\"Java\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Java</div>\n\n```java\nimport com.github.copilot.CopilotSession;\nimport com.github.copilot.generated.AssistantMessageDeltaEvent;\n\nfinal class ParentAgentResponseExample {\n    static void subscribeParentResponse(CopilotSession session) {\n        session.on(AssistantMessageDeltaEvent.class, event -> {\n            if (event.getAgentId() == null) {\n                System.out.print(event.getData().deltaContent());\n            }\n        });\n    }\n}\n```\n\n</div>\n\n<div class=\"ghd-codetab\" data-lang=\"rust\" data-label=\"Rust\"><div class=\"ghd-codetab-fallback-label\" role=\"heading\" aria-level=\"3\">Rust</div>\n\n```rust\nuse github_copilot_sdk::session::Session;\n\nasync fn subscribe_parent_response(session: &Session) {\n    let mut events = session.subscribe();\n\n    while let Ok(event) = events.recv().await {\n        if event.event_type == \"assistant.message_delta\" && event.agent_id.is_none() {\n            if let Some(delta) = event.data.get(\"deltaContent\").and_then(|v| v.as_str()) {\n                print!(\"{delta}\");\n            }\n        }\n    }\n}\n```\n\n</div>\n\n</div>\n\n## Ereignisse des Assistenten\n\nDiese Ereignisse verfolgen den Lebenszyklus der Antwort des Agents - vom Start der Abzweigung über die Streaming Chunks bis zur endgültigen Nachricht.\n\n### `assistant.turn_start`\n\nWird ausgelöst, wenn der Agent mit der Verarbeitung eines Ablaufschritts beginnt.\n\n| Datenfeld                                      | Typ      | Erforderlich | Description                                                          |\n| ---------------------------------------------- | -------- | ------------ | -------------------------------------------------------------------- |\n| `turnId`                                       | `string` | ✅            | Turn-Identifikator (typischerweise eine stringifizierte Turn-Nummer) |\n| `interactionId`                                | `string` |              |                                                                      |\n| CAPI-Interaktions-ID für Telemetriekorrelation |          |              |                                                                      |\n\n### `assistant.intent`\n\nFlüchtig Kurze Beschreibung dessen, was der Agent gerade tut, aktualisiert während der Vorgang läuft.\n\n| Datenfeld | Typ      | Erforderlich | Description                                      |\n| --------- | -------- | ------------ | ------------------------------------------------ |\n| `intent`  | `string` | ✅            | Lesbare Absicht (z. B. \"Erkunden der Codebasis\") |\n\n### `assistant.reasoning`\n\nSchließen Sie die erweiterte Denkblockade des Modells ab. Wird nach Abschluss der Begründung ausgegeben.\n\n| Datenfeld     | Typ      | Erforderlich | Description                                  |\n| ------------- | -------- | ------------ | -------------------------------------------- |\n| `reasoningId` | `string` | ✅            | Eindeutiger Bezeichner für diesen Logikblock |\n| `content`     | `string` | ✅            | Der vollständige erweiterte Denktext         |\n\n### `assistant.reasoning_delta`\n\nFlüchtig Inkrementeller Chunk des erweiterten Denkens des Modells, das in Echtzeit gestreamt wird.\n\n| Datenfeld      | Typ      | Erforderlich | Description                                                       |\n| -------------- | -------- | ------------ | ----------------------------------------------------------------- |\n| `reasoningId`  | `string` | ✅            | Entspricht dem entsprechenden `assistant.reasoning` Ereignis.     |\n| `deltaContent` | `string` | ✅            | Textabschnitt, der an den Inhalt von Gründen angefügt werden soll |\n\n### `assistant.message`\n\nDie vollständige Antwort des Assistenten für diesen LLM-Aufruf. Kann Toolaufrufanforderungen enthalten.\n\n| Datenfeld                                                                     | Typ             | Erforderlich | Description                                |\n| ----------------------------------------------------------------------------- | --------------- | ------------ | ------------------------------------------ |\n| `messageId`                                                                   | `string`        | ✅            | Eindeutiger Bezeichner für diese Nachricht |\n| `content`                                                                     | `string`        | ✅            | Die Textantwort des Assistenten            |\n| `toolRequests`                                                                | `ToolRequest[]` |              |                                            |\n| Toolaufrufe, die der Assistent tätigen möchte (siehe unten)                   |                 |              |                                            |\n| `reasoningOpaque`                                                             | `string`        |              |                                            |\n| Verschlüsseltes erweitertes Denken (Anthropische Modelle); sitzungsgebunden   |                 |              |                                            |\n| `reasoningText`                                                               | `string`        |              |                                            |\n| Lesbarer Reasoning-Text aus erweitertem Denken                                |                 |              |                                            |\n| `encryptedContent`                                                            | `string`        |              |                                            |\n| Verschlüsselte Begründungsinhalte (OpenAI-Modelle); sitzungsgebunden          |                 |              |                                            |\n| `phase`                                                                       | `string`        |              |                                            |\n| Generationsphase (z. B. `\"thinking\"` vs `\"response\"`)                         |                 |              |                                            |\n| `outputTokens`                                                                | `number`        |              |                                            |\n| Tatsächliche Ausgabetokenanzahl aus der API-Antwort                           |                 |              |                                            |\n| `interactionId`                                                               | `string`        |              |                                            |\n| CAPI-Interaktions-ID für Telemetrie                                           |                 |              |                                            |\n| `parentToolCallId`                                                            | `string`        |              |                                            |\n| Deprecated. Verwenden der Umschlagebene `agentId` für die Sub-Agent-Zuordnung |                 |              |                                            |\n\n\\*\\*\n`ToolRequest` Felder:\\*\\*\n\n| Feld                                                      | Typ                      | Erforderlich | Description                                    |\n| --------------------------------------------------------- | ------------------------ | ------------ | ---------------------------------------------- |\n| `toolCallId`                                              | `string`                 | ✅            | Eindeutige ID für diesen Toolaufruf            |\n| `name`                                                    | `string`                 | ✅            | Toolname (z. B., `\"bash\"`, `\"edit\"`, `\"grep\"`) |\n| `arguments`                                               | `object`                 |              |                                                |\n| Analysierte Argumente für das Tool                        |                          |              |                                                |\n| `type`                                                    | `\"function\" \\| \"custom\"` |              |                                                |\n| Anruftyp; Standardwert: `\"function\"` wenn nicht vorhanden |                          |              |                                                |\n\n### `assistant.message_delta`\n\nFlüchtig Inkrementeller Chunk der Text-Antwort des Assistenten, der in Echtzeit gestreamt wird.\n\n| Datenfeld                                                                     | Typ      | Erforderlich | Description                                                 |\n| ----------------------------------------------------------------------------- | -------- | ------------ | ----------------------------------------------------------- |\n| `messageId`                                                                   | `string` | ✅            | Entspricht dem entsprechenden `assistant.message` Ereignis. |\n| `deltaContent`                                                                | `string` | ✅            | Textabschnitt, der an die Nachricht angefügt werden soll    |\n| `parentToolCallId`                                                            | `string` |              |                                                             |\n| Deprecated. Verwenden der Umschlagebene `agentId` für die Sub-Agent-Zuordnung |          |              |                                                             |\n\n### `assistant.turn_end`\n\nWird ausgegeben, wenn der Agent eine Runde abschließt (alle Tool-Ausführungen abgeschlossen, endgültige Antwort geliefert).\n\n| Datenfeld | Typ      | Erforderlich | Description                                                    |\n| --------- | -------- | ------------ | -------------------------------------------------------------- |\n| `turnId`  | `string` | ✅            | Entspricht dem entsprechenden `assistant.turn_start` Ereignis. |\n\n### `assistant.usage`\n\nFlüchtig Tokenverwendungs- und Kosteninformationen für einen einzelnen API-Aufruf.\n\n| Datenfeld                                                                                                    | Typ                                                                        | Erforderlich | Description                          |\n| ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- | ------------ | ------------------------------------ |\n| `model`                                                                                                      | `string`                                                                   | ✅            | Modellbezeichner (z. B. `\"gpt-5.4\"`) |\n| `inputTokens`                                                                                                | `number`                                                                   |              |                                      |\n| Verbrauchte Eingabetoken                                                                                     |                                                                            |              |                                      |\n| `outputTokens`                                                                                               | `number`                                                                   |              |                                      |\n| Erzeugte Ausgabetoken                                                                                        |                                                                            |              |                                      |\n| `reasoningTokens`                                                                                            | `number`                                                                   |              |                                      |\n| Ausgabetoken, die für Begründung/Gedankengang verwendet werden (Teilmenge von `outputTokens`)                |                                                                            |              |                                      |\n| `cacheReadTokens`                                                                                            | `number`                                                                   |              |                                      |\n| Token aus dem Prompt-Cache lesen                                                                             |                                                                            |              |                                      |\n| `cacheWriteTokens`                                                                                           | `number`                                                                   |              |                                      |\n| Token werden in den Prompt-Cache geschrieben                                                                 |                                                                            |              |                                      |\n| `cacheExpiresAt`                                                                                             | `string`                                                                   |              |                                      |\n| ISO 8601-Zeitstempel, zu dem der Prompt-Cache für diesen Modellaufruf abläuft                                |                                                                            |              |                                      |\n| `contentFilterTriggered`                                                                                     | `boolean`                                                                  |              |                                      |\n| Ob die Antwort durch Inhaltsfilterung blockiert oder gekürzt wurde (`finish_reason === 'content_filter'`)    |                                                                            |              |                                      |\n| `finishReason`                                                                                               | `string`                                                                   |              |                                      |\n| Abschlussgrund des Modells (z. B. `\"stop\"`, `\"length\"`, `\"tool_calls\"`, `\"content_filter\"`)                  |                                                                            |              |                                      |\n| `cost`                                                                                                       | `number`                                                                   |              |                                      |\n| Kosten für den Modellmultiplikator bei der Abrechnung                                                        |                                                                            |              |                                      |\n| `duration`                                                                                                   | `number`                                                                   |              |                                      |\n| API-Aufrufdauer in Millisekunden                                                                             |                                                                            |              |                                      |\n| `timeToFirstTokenMs`                                                                                         | `number`                                                                   |              |                                      |\n| Zeit vom Anforderungsversand an das erste empfangene Token (Streaminglatenz)                                 |                                                                            |              |                                      |\n| `interTokenLatencyMs`                                                                                        | `number`                                                                   |              |                                      |\n| Durchschnittliche Latenz zwischen aufeinander folgenden Token (Streamingdurchsatz)                           |                                                                            |              |                                      |\n| `reasoningEffort`                                                                                            | `string`                                                                   |              |                                      |\n| Für diesen Aufruf verwendete Aufwandsstufe für die Argumentation (z. B. `\"low\"`, `\"medium\"`, `\"high\"`)       |                                                                            |              |                                      |\n| `initiator`                                                                                                  | `string`                                                                   |              |                                      |\n| Was diesen Aufruf ausgelöst hat (z. B. `\"sub-agent\"`); fehlt für vom Benutzer initiierte                     |                                                                            |              |                                      |\n| `apiCallId`                                                                                                  | `string`                                                                   |              |                                      |\n| Abschluss-ID vom Anbieter (z. B. `chatcmpl-abc123`)                                                          |                                                                            |              |                                      |\n| `serviceRequestId`                                                                                           | `string`                                                                   |              |                                      |\n| Copilot-Dienstanforderungs-ID (`x-copilot-service-request-id`) für die CAPI-Protokollkorrelation             |                                                                            |              |                                      |\n| `apiEndpoint`                                                                                                | `\"/chat/completions\" \\| \"/v1/messages\" \\| \"/responses\" \\| \"ws:/responses\"` |              |                                      |\n| API-Endpunkt, der für den Modellaufruf verwendet wird; nützlich für Beobachtbarkeit und zur Kostenzuordnung. |                                                                            |              |                                      |\n| `ws:/responses` ist die Websocket-Variante der Antwort-API.                                                  |                                                                            |              |                                      |\n| `providerCallId`                                                                                             | `string`                                                                   |              |                                      |\n| GitHub-Anforderungsablaufverfolgungs-ID (`x-github-request-id`)                                              |                                                                            |              |                                      |\n| `parentToolCallId`                                                                                           | `string`                                                                   |              |                                      |\n| Deprecated. Verwenden der Umschlagebene `agentId` für die Sub-Agent-Zuordnung                                |                                                                            |              |                                      |\n| `quotaSnapshots`                                                                                             | `Record<string, QuotaSnapshot>`                                            |              |                                      |\n| Ressourcennutzung pro Kontingent, schlüsseliert nach Kontingentbezeichner                                    |                                                                            |              |                                      |\n| `copilotUsage`                                                                                               | `CopilotUsage`                                                             |              |                                      |\n| Aufschlüsselung der Kosten für Tokens aus der API                                                            |                                                                            |              |                                      |\n\n### `assistant.streaming_delta`\n\nFlüchtig Niedrigrangige Fortschrittsanzeige – Gesamtanzahl der Bytes, die von der Streaming-API-Antwort empfangen wurden.\n\n| Datenfeld                | Typ      | Erforderlich | Description                        |\n| ------------------------ | -------- | ------------ | ---------------------------------- |\n| `totalResponseSizeBytes` | `number` | ✅            | Bisher empfangene kumulative Bytes |\n\n## Toolausführungsereignisse\n\nDiese Ereignisse verfolgen den vollständigen Lebenszyklus jedes Toolaufrufs, von der Anforderung durch das Modell über die Ausführung bis zur Fertigstellung.\n\n### `tool.execution_start`\n\nWird ausgegeben, wenn ein Tool mit der Ausführung beginnt.\n\n| Datenfeld                                                                     | Typ      | Erforderlich | Description                                          |\n| ----------------------------------------------------------------------------- | -------- | ------------ | ---------------------------------------------------- |\n| `toolCallId`                                                                  | `string` | ✅            | Eindeutiger Bezeichner für diesen Toolaufruf         |\n| `toolName`                                                                    | `string` | ✅            | Name des Tools (z. B. , `\"bash\"`, `\"edit\"`) `\"grep\"` |\n| `arguments`                                                                   | `object` |              |                                                      |\n| Analysierte Argumente, die an das Tool übergeben werden                       |          |              |                                                      |\n| `mcpServerName`                                                               | `string` |              |                                                      |\n| MCP-Servername, wenn das Tool von einem MCP-Server bereitgestellt wird        |          |              |                                                      |\n| `mcpToolName`                                                                 | `string` |              |                                                      |\n| Ursprünglicher Toolname auf dem MCP-Server                                    |          |              |                                                      |\n| `parentToolCallId`                                                            | `string` |              |                                                      |\n| Deprecated. Verwenden der Umschlagebene `agentId` für die Sub-Agent-Zuordnung |          |              |                                                      |\n\n### `tool.execution_partial_result`\n\nFlüchtig Inkrementelle Ausgabe eines laufenden Tools (z. B. gestreamte bash-Ausgabe).\n\n| Datenfeld       | Typ      | Erforderlich | Description                                          |\n| --------------- | -------- | ------------ | ---------------------------------------------------- |\n| `toolCallId`    | `string` | ✅            | Entspricht dem entsprechenden `tool.execution_start` |\n| `partialOutput` | `string` | ✅            | Inkrementeller Ausgabeabschnitt                      |\n\n### `tool.execution_progress`\n\nFlüchtig Menschenlesbarer Fortschrittsstatus von einem laufenden Tool (z. B. Fortschrittsbenachrichtigungen des MCP-Servers).\n\n| Datenfeld         | Typ      | Erforderlich | Description                                          |\n| ----------------- | -------- | ------------ | ---------------------------------------------------- |\n| `toolCallId`      | `string` | ✅            | Entspricht dem entsprechenden `tool.execution_start` |\n| `progressMessage` | `string` | ✅            | Fortschrittsstatusmeldung                            |\n\n### `tool.execution_complete`\n\nWird ausgegeben, wenn die Ausführung eines Tools abgeschlossen ist – erfolgreich oder mit einem Fehler.\n\n| Datenfeld                                                                     | Typ                  | Erforderlich | Description                                          |\n| ----------------------------------------------------------------------------- | -------------------- | ------------ | ---------------------------------------------------- |\n| `toolCallId`                                                                  | `string`             | ✅            | Entspricht dem entsprechenden `tool.execution_start` |\n| `success`                                                                     | `boolean`            | ✅            | Ob die Ausführung erfolgreich war                    |\n| `model`                                                                       | `string`             |              |                                                      |\n| Modell, das diesen Toolaufruf generiert hat                                   |                      |              |                                                      |\n| `interactionId`                                                               | `string`             |              |                                                      |\n| CAPI-Interaktions-ID                                                          |                      |              |                                                      |\n| `isUserRequested`                                                             | `boolean`            |              |                                                      |\n|                                                                               |                      |              |                                                      |\n| `true` wenn der Benutzer diesen Toolaufruf explizit angefordert hat           |                      |              |                                                      |\n| `result`                                                                      | `Result`             |              |                                                      |\n| Bei Erfolg anzeigen (siehe unten)                                             |                      |              |                                                      |\n| `error`                                                                       | `{ message, code? }` |              |                                                      |\n| Vorhanden bei Fehlschlag                                                      |                      |              |                                                      |\n| `toolTelemetry`                                                               | `object`             |              |                                                      |\n| Toolspezifische Telemetrie (z. B. Anzahl der CodeQL-Prüfungen)                |                      |              |                                                      |\n| `parentToolCallId`                                                            | `string`             |              |                                                      |\n| Deprecated. Verwenden der Umschlagebene `agentId` für die Sub-Agent-Zuordnung |                      |              |                                                      |\n\n\\*\\*\n`Result` Felder:\\*\\*\n\n| Feld                                                                                           | Typ              | Erforderlich | Description                                                                                          |\n| ---------------------------------------------------------------------------------------------- | ---------------- | ------------ | ---------------------------------------------------------------------------------------------------- |\n| `content`                                                                                      | `string`         | ✅            | Kurzes Ergebnis, das an das LLM gesendet wird (kann aus Gründen der Token-Effizienz verkürzt werden) |\n| `detailedContent`                                                                              | `string`         |              |                                                                                                      |\n| Vollständiges Ergebnis für die Anzeige, unter Beibehaltung des vollständigen Inhalts wie Diffs |                  |              |                                                                                                      |\n| `contents`                                                                                     | `ContentBlock[]` |              |                                                                                                      |\n| Strukturierte Inhaltsblöcke (Text, Terminal, Bild, Audio, Ressource)                           |                  |              |                                                                                                      |\n\n### `tool.user_requested`\n\nWird ausgegeben, wenn der Benutzende explizit einen Tool-Aufruf anfordert (und nicht das Modell selbst einen Aufruf vornimmt).\n\n| Datenfeld                | Typ      | Erforderlich | Description                                      |\n| ------------------------ | -------- | ------------ | ------------------------------------------------ |\n| `toolCallId`             | `string` | ✅            | Eindeutiger Bezeichner für diesen Toolaufruf     |\n| `toolName`               | `string` | ✅            | Name des Tools, das der Benutzer aufrufen möchte |\n| `arguments`              | `object` |              |                                                  |\n| Argumente für den Aufruf |          |              |                                                  |\n\n## Sitzungslebenszyklusereignisse\n\n### `session.idle`\n\nFlüchtig Der Agent hat die gesamte Verarbeitung abgeschlossen und ist bereit für die nächste Nachricht. Dies ist das Signal, dass eine Drehung vollständig abgeschlossen ist.\n\n| Datenfeld                                                                | Typ       | Erforderlich | Description |\n| ------------------------------------------------------------------------ | --------- | ------------ | ----------- |\n| `aborted`                                                                | `boolean` |              |             |\n| True, wenn die vorhergehende Drehung per Abbruchsignal abgebrochen wurde |           |              |             |\n\n### `session.error`\n\nEin Fehler ist während der Sitzungsverarbeitung aufgetreten.\n\n| Datenfeld                                                                          | Typ      | Erforderlich | Description                                                            |\n| ---------------------------------------------------------------------------------- | -------- | ------------ | ---------------------------------------------------------------------- |\n| `errorType`                                                                        | `string` | ✅            | Fehlerkategorie (z. B. , `\"authentication\"`, `\"quota\"`) `\"rate_limit\"` |\n| `message`                                                                          | `string` | ✅            | Vom Menschen lesbare Fehlermeldung                                     |\n| `stack`                                                                            | `string` |              |                                                                        |\n| Fehler Stack-Trace                                                                 |          |              |                                                                        |\n| `statusCode`                                                                       | `number` |              |                                                                        |\n| HTTP-Statuscode aus der upstream-Anforderung                                       |          |              |                                                                        |\n| `providerCallId`                                                                   | `string` |              |                                                                        |\n| GitHub Anforderungsablaufverfolgungs-ID für die serverseitige Protokollkorrelation |          |              |                                                                        |\n\n### `session.compaction_start`\n\nDie Verdichtung des Kontextfensters hat begonnen.\n**Die Datennutzlast ist leer (`{}`)**.\n\n### `session.compaction_complete`\n\nDie Verdichtung des Kontextfensters wurde abgeschlossen.\n\n| Datenfeld                                                            | Typ                              | Erforderlich | Description                                    |\n| -------------------------------------------------------------------- | -------------------------------- | ------------ | ---------------------------------------------- |\n| `success`                                                            | `boolean`                        | ✅            | Gibt an, ob die Komprimierung erfolgreich war. |\n| `error`                                                              | `string`                         |              |                                                |\n| Fehlermeldung, wenn die Komprimierung fehlgeschlagen ist             |                                  |              |                                                |\n| `preCompactionTokens`                                                | `number`                         |              |                                                |\n| Token vor Komprimierung                                              |                                  |              |                                                |\n| `postCompactionTokens`                                               | `number`                         |              |                                                |\n| Token nach Komprimierung                                             |                                  |              |                                                |\n| `preCompactionMessagesLength`                                        | `number`                         |              |                                                |\n| Nachrichtenanzahl vor Komprimierung                                  |                                  |              |                                                |\n| `messagesRemoved`                                                    | `number`                         |              |                                                |\n| Entfernte Nachrichten                                                |                                  |              |                                                |\n| `tokensRemoved`                                                      | `number`                         |              |                                                |\n| Token entfernt                                                       |                                  |              |                                                |\n| `summaryContent`                                                     | `string`                         |              |                                                |\n| LLM-generierte Zusammenfassung des komprimierten Verlaufs            |                                  |              |                                                |\n| `checkpointNumber`                                                   | `number`                         |              |                                                |\n| Nummer des für die Wiederherstellung erstellten Checkpoint-Snapshots |                                  |              |                                                |\n| `checkpointPath`                                                     | `string`                         |              |                                                |\n| Dateipfad, in dem der Prüfpunkt gespeichert wurde                    |                                  |              |                                                |\n| `compactionTokensUsed`                                               | `{ input, output, cachedInput }` |              |                                                |\n| Tokenverwendung für den Komprimierungsaufruf des LLM                 |                                  |              |                                                |\n| `requestId`                                                          | `string`                         |              |                                                |\n| GitHub-Anforderungsablaufverfolgungs-ID für den Kompaktierungsaufruf |                                  |              |                                                |\n\n### `session.title_changed`\n\nFlüchtig Der automatisch generierte Titel der Sitzung wurde aktualisiert.\n\n| Datenfeld | Typ      | Erforderlich | Description         |\n| --------- | -------- | ------------ | ------------------- |\n| `title`   | `string` | ✅            | Neuer Sitzungstitel |\n\n### `session.context_changed`\n\nDer Arbeitsverzeichnis- oder Repositorykontext der Sitzung wurde geändert.\n\n| Datenfeld                           | Typ      | Erforderlich | Description                  |\n| ----------------------------------- | -------- | ------------ | ---------------------------- |\n| `cwd`                               | `string` | ✅            | Aktuelles Arbeitsverzeichnis |\n| `gitRoot`                           | `string` |              |                              |\n| Git-Repository-Stammverzeichnis     |          |              |                              |\n| `repository`                        | `string` |              |                              |\n| Repository im `\"owner/name\"` Format |          |              |                              |\n| `branch`                            | `string` |              |                              |\n| Aktuelle Git-Verzweigung            |          |              |                              |\n\n### `session.usage_info`\n\nFlüchtig Momentaufnahme der Kontextfensterverwendung.\n\n| Datenfeld        | Typ      | Erforderlich | Description                                         |\n| ---------------- | -------- | ------------ | --------------------------------------------------- |\n| `tokenLimit`     | `number` | ✅            | Maximale Token für das Kontextfenster des Modells   |\n| `currentTokens`  | `number` | ✅            | Aktuelle Token im Kontextfenster                    |\n| `messagesLength` | `number` | ✅            | Aktuelle Anzahl der Nachrichten in der Konversation |\n\n### `session.session_limits_changed`\n\nDie Sitzungslimits wurden für den aktuellen Abrechnungszeitraum geändert. Ein `null``sessionLimits` Wert bedeutet, dass keine Grenzwerte aktiv sind.\n\n| Datenfeld                                                                                   | Typ                           | Erforderlich | Description                                                              |\n| ------------------------------------------------------------------------------------------- | ----------------------------- | ------------ | ------------------------------------------------------------------------ |\n| `sessionLimits`                                                                             | `SessionLimitsConfig \\| null` | ✅            | Aktuelle Sitzungsgrenzwerte oder `null` wenn keine Grenzwerte aktiv sind |\n| `sessionLimits.maxAiCredits`                                                                | `number`                      |              |                                                                          |\n| Maximale zulässige KI-Gutschriften innerhalb des aktuellen Abrechnungszeitraums der Sitzung |                               |              |                                                                          |\n\n### `session.usage_checkpoint`\n\nDauerhafter Aggregatverwendungsprüfpunkt, der zum Rekonstruieren der Buchhaltung verwendet wird, wenn eine Sitzung fortgesetzt wird.\n\n| Datenfeld                                                                          | Typ      | Erforderlich | Description                                                                        |\n| ---------------------------------------------------------------------------------- | -------- | ------------ | ---------------------------------------------------------------------------------- |\n| `totalNanoAiu`                                                                     | `number` | ✅            | Sitzungsweit kumulierte Kosten für Nano-AI-Einheiten zum Zeitpunkt des Checkpoints |\n| `totalPremiumRequests`                                                             | `number` |              |                                                                                    |\n| Gesamtanzahl der premium-API-Anforderungen, die zur Prüfpunktzeit verwendet werden |          |              |                                                                                    |\n\n### `session.task_complete`\n\nDer Agent hat seine zugewiesene Aufgabe abgeschlossen.\n\n| Datenfeld                                    | Typ      | Erforderlich | Description |\n| -------------------------------------------- | -------- | ------------ | ----------- |\n| `summary`                                    | `string` |              |             |\n| Zusammenfassung des abgeschlossenen Vorgangs |          |              |             |\n\n### `session.shutdown`\n\nDie Sitzung wurde beendet.\n\n| Datenfeld                                                    | Typ                                           | Erforderlich | Description                                            |\n| ------------------------------------------------------------ | --------------------------------------------- | ------------ | ------------------------------------------------------ |\n| `shutdownType`                                               | `\"routine\" \\| \"error\"`                        | ✅            | Normales Herunterfahren oder Absturz                   |\n| `errorReason`                                                | `string`                                      |              |                                                        |\n| Fehlerbeschreibung, wenn `shutdownType` gleich `\"error\"` ist |                                               |              |                                                        |\n| `totalPremiumRequests`                                       | `number`                                      | ✅            | Gesamtanzahl der verwendeten Premium-API-Anforderungen |\n| `totalApiDurationMs`                                         | `number`                                      | ✅            | Kumulierte API-Aufrufzeit in Millisekunden             |\n| `sessionStartTime`                                           | `number`                                      | ✅            | Unix-Zeitstempel (ms) beim Starten der Sitzung         |\n| `codeChanges`                                                | `{ linesAdded, linesRemoved, filesModified }` | ✅            | Aggregierte Codeänderungsmetriken                      |\n| `modelMetrics`                                               | `Record<string, ModelMetric>`                 | ✅            | Aufschlüsselung der Modellnutzung                      |\n| `currentModel`                                               | `string`                                      |              |                                                        |\n| Modell zum Zeitpunkt des Herunterfahrens ausgewählt          |                                               |              |                                                        |\n\n## Berechtigungs- und Benutzereingabeereignisse\n\nDiese Ereignisse werden ausgegeben, wenn der Agent eine Genehmigung oder Eingabe des Benutzers benötigt, bevor er fortfahren kann.\n\n### `permission.requested`\n\nDer Agent benötigt die Berechtigung zum Ausführen einer Aktion (Ausführen eines Befehls, Schreiben einer Datei usw.).\n\n| Datenfeld           | Typ                 | Erforderlich | Description                                                               |\n| ------------------- | ------------------- | ------------ | ------------------------------------------------------------------------- |\n| `requestId`         | `string`            | ✅            | Verwenden Sie dies, um über `session.respondToPermission()` zu antworten. |\n| `permissionRequest` | `PermissionRequest` | ✅            | Details der angeforderten Berechtigung                                    |\n\nDer `permissionRequest` ist ein discriminated union auf `kind`:\n\n| `kind`                                                          | Schlüsselfelder                             | Description |\n| --------------------------------------------------------------- | ------------------------------------------- | ----------- |\n| `\"shell\"`                                                       |                                             |             |\n| `fullCommandText`, `intention`, `commands[]`, `possiblePaths[]` | Ausführen eines Shellbefehls                |             |\n| `\"write\"`                                                       |                                             |             |\n| `fileName`, `diff`, `intention`, `newFileContents?`             | Schreiben/Ändern einer Datei                |             |\n| `\"read\"`                                                        |                                             |             |\n| `path`, `intention`                                             | Lesen einer Datei oder eines Verzeichnisses |             |\n| `\"mcp\"`                                                         |                                             |             |\n| `serverName`, `toolName`, `toolTitle`, `args?`, , `readOnly`    | Aufrufen eines MCP-Tools                    |             |\n| `\"url\"`                                                         |                                             |             |\n| `url`, `intention`                                              | Abrufen einer URL                           |             |\n| `\"memory\"`                                                      |                                             |             |\n| `subject`, `fact``citations`                                    | Ein Gedächtnis speichern                    |             |\n| `\"custom-tool\"`                                                 |                                             |             |\n| `toolName`, `toolDescription``args?`                            | Aufrufen eines benutzerdefinierten Tools    |             |\n\nAlle `kind` Varianten enthalten auch eine optionale `toolCallId` Verknüpfung mit dem Toolaufruf, der die Anforderung ausgelöst hat.\n\n### `permission.completed`\n\nEine Berechtigungsanfrage wurde gelöst.\n\n| Datenfeld     | Typ      | Erforderlich | Description                                                                                                                                                                         |\n| ------------- | -------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `requestId`   | `string` | ✅            | Entspricht dem entsprechenden `permission.requested`                                                                                                                                |\n| `result.kind` | `string` | ✅            | Einer von: `\"approved\"`, , `\"denied-by-rules\"``\"denied-interactively-by-user\"`, , `\"denied-no-approval-rule-and-could-not-request-from-user\"``\"denied-by-content-exclusion-policy\"` |\n\n### `user_input.requested`\n\nFlüchtig Der Agent stellt dem Benutzer eine Frage.\n\n| Datenfeld                                           | Typ        | Erforderlich | Description                                                              |\n| --------------------------------------------------- | ---------- | ------------ | ------------------------------------------------------------------------ |\n| `requestId`                                         | `string`   | ✅            | Verwenden Sie dies, um über `session.respondToUserInput()` zu antworten. |\n| `question`                                          | `string`   | ✅            | Die Frage, die dem Benutzer präsentiert werden soll                      |\n| `choices`                                           | `string[]` |              |                                                                          |\n| Vordefinierte Auswahlmöglichkeiten für den Benutzer |            |              |                                                                          |\n| `allowFreeform`                                     | `boolean`  |              |                                                                          |\n| Gibt an, ob Freiformtexteingaben zulässig sind.     |            |              |                                                                          |\n\n### `user_input.completed`\n\nFlüchtig Eine Benutzereingabeanforderung wurde aufgelöst.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                          |\n| ----------- | -------- | ------------ | ---------------------------------------------------- |\n| `requestId` | `string` | ✅            | Entspricht dem entsprechenden `user_input.requested` |\n\n### `elicitation.requested`\n\nFlüchtig Der Agent benötigt strukturierte Formulareingaben vom Benutzer (MCP-Elicitationsprotokoll).\n\n| Datenfeld                                | Typ                                         | Erforderlich | Description                                                                |\n| ---------------------------------------- | ------------------------------------------- | ------------ | -------------------------------------------------------------------------- |\n| `requestId`                              | `string`                                    | ✅            | Verwenden Sie dies, um über `session.respondToElicitation()` zu antworten. |\n| `message`                                | `string`                                    | ✅            | Beschreibung der benötigten Informationen                                  |\n| `mode`                                   | `\"form\"`                                    |              |                                                                            |\n| Elicitationsmodus (derzeit nur `\"form\"`) |                                             |              |                                                                            |\n| `requestedSchema`                        | `{ type: \"object\", properties, required? }` | ✅            | JSON-Schema zur Beschreibung der Formularfelder                            |\n\n### `elicitation.completed`\n\nFlüchtig Eine Anfrage wurde behoben.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                           |\n| ----------- | -------- | ------------ | ----------------------------------------------------- |\n| `requestId` | `string` | ✅            | Entspricht dem entsprechenden `elicitation.requested` |\n\n## Sub-Agenten und Skill-Ereignisse\n\n### `subagent.started`\n\nEin angepasster Agent wurde als Sub-Agent aufgerufen.\n\n| Datenfeld                                                                         | Typ      | Erforderlich | Description                                                         |\n| --------------------------------------------------------------------------------- | -------- | ------------ | ------------------------------------------------------------------- |\n| `toolCallId`                                                                      | `string` | ✅            | Übergeordneter Werkzeugaufruf, der diesen Unter-Agenten erzeugt hat |\n| `agentName`                                                                       | `string` | ✅            | Interner Name des Unter-Agents                                      |\n| `agentDisplayName`                                                                | `string` | ✅            | Menschenlesbarer Anzeigename                                        |\n| `agentDescription`                                                                | `string` | ✅            | Beschreibung der Funktionsweise des Unter-Agents                    |\n| `model`                                                                           | `string` |              |                                                                     |\n| Modell, mit dem der Sub-Agent ausgeführt wird, sofern dies beim Start bekannt ist |          |              |                                                                     |\n\n### `subagent.completed`\n\nEin Sub-Agent wurde erfolgreich abgeschlossen.\n\n| Datenfeld                                             | Typ      | Erforderlich | Description                                      |\n| ----------------------------------------------------- | -------- | ------------ | ------------------------------------------------ |\n| `toolCallId`                                          | `string` | ✅            | Entspricht dem entsprechenden `subagent.started` |\n| `agentName`                                           | `string` | ✅            | Interner Name                                    |\n| `agentDisplayName`                                    | `string` | ✅            | Anzeigename                                      |\n| `model`                                               | `string` |              |                                                  |\n| Vom Unter-Agent verwendete Modell                     |          |              |                                                  |\n| `durationMs`                                          | `number` |              |                                                  |\n| Ausführungsdauer der Wanduhr in Millisekunden         |          |              |                                                  |\n| `totalTokens`                                         | `number` |              |                                                  |\n| Gesamtzahl der verbrauchten Eingabe- und Ausgabetoken |          |              |                                                  |\n| `totalToolCalls`                                      | `number` |              |                                                  |\n| Gesamtanzahl der getätigten Toolaufrufe               |          |              |                                                  |\n\n### `subagent.failed`\n\nBei einem Unter-Agent ist ein Fehler aufgetreten.\n\n| Datenfeld                                                                  | Typ      | Erforderlich | Description                                      |\n| -------------------------------------------------------------------------- | -------- | ------------ | ------------------------------------------------ |\n| `toolCallId`                                                               | `string` | ✅            | Entspricht dem entsprechenden `subagent.started` |\n| `agentName`                                                                | `string` | ✅            | Interner Name                                    |\n| `agentDisplayName`                                                         | `string` | ✅            | Anzeigename                                      |\n| `error`                                                                    | `string` | ✅            | Fehlermeldung                                    |\n| `model`                                                                    | `string` |              |                                                  |\n| Modell ausgewählt für den Unter-Agent, wenn bekannt                        |          |              |                                                  |\n| `durationMs`                                                               | `number` |              |                                                  |\n| Ausführungsdauer der Wanduhr in Millisekunden                              |          |              |                                                  |\n| `totalTokens`                                                              | `number` |              |                                                  |\n| Gesamtanzahl der vor dem Fehler verbrauchten Eingabe- und Ausgabetoken     |          |              |                                                  |\n| `totalToolCalls`                                                           | `number` |              |                                                  |\n| Gesamtanzahl der Aufrufe von Tools, die vor einem Fehler ausgeführt wurden |          |              |                                                  |\n\n### `subagent.selected`\n\nEin benutzerdefinierter Agent wurde ausgewählt (abgeleitet), um die aktuelle Anforderung zu verarbeiten.\n\n| Datenfeld          | Typ                | Erforderlich | Description                                                  |\n| ------------------ | ------------------ | ------------ | ------------------------------------------------------------ |\n| `agentName`        | `string`           | ✅            | Interner Name des ausgewählten Agents                        |\n| `agentDisplayName` | `string`           | ✅            | Anzeigename                                                  |\n| `tools`            | `string[] \\| null` | ✅            | Für diesen Agent verfügbare Toolnamen; `null` für alle Tools |\n\n### `subagent.deselected`\n\nEin benutzerdefinierter Agent wurde deaktiviert und kehrt zum Standard-Agent zurück.\n**Die Datennutzlast ist leer (`{}`)**.\n\n### `skill.invoked`\n\nFür die aktuelle Unterhaltung wurde eine Fähigkeit aktiviert.\n\n| Datenfeld                                                                  | Typ        | Erforderlich | Description                                                           |\n| -------------------------------------------------------------------------- | ---------- | ------------ | --------------------------------------------------------------------- |\n| `name`                                                                     | `string`   | ✅            | Qualifikationsname                                                    |\n| `path`                                                                     | `string`   | ✅            | Dateipfad zur SKILL.md Definition                                     |\n| `content`                                                                  | `string`   | ✅            | Vollständiger Skill-Inhalt, der in die Kommunikation eingespeist wird |\n| `allowedTools`                                                             | `string[]` |              |                                                                       |\n| Werkzeuge werden automatisch genehmigt, solange diese Fähigkeit aktiv ist. |            |              |                                                                       |\n| `pluginName`                                                               | `string`   |              |                                                                       |\n| Plugin, aus dem die Fertigkeit stammt                                      |            |              |                                                                       |\n| `pluginVersion`                                                            | `string`   |              |                                                                       |\n| Plugin-Version                                                             |            |              |                                                                       |\n\n## Andere Ereignisse\n\n### `abort`\n\nDie aktuelle Drehung wurde abgebrochen.\n\n| Datenfeld | Typ      | Erforderlich | Description                                                    |\n| --------- | -------- | ------------ | -------------------------------------------------------------- |\n| `reason`  | `string` | ✅            | Warum die Drehung abgebrochen wurde (z. B. `\"user initiated\"`) |\n\n### `user.message`\n\nDer Benutzer hat eine Nachricht gesendet. Aufgezeichnet für den Sitzungsverlauf.\n\n| Datenfeld                                                            | Typ            | Erforderlich | Description                       |\n| -------------------------------------------------------------------- | -------------- | ------------ | --------------------------------- |\n| `content`                                                            | `string`       | ✅            | Der Nachrichtentext des Benutzers |\n| `transformedContent`                                                 | `string`       |              |                                   |\n| Transformierte Version nach der Vorverarbeitung                      |                |              |                                   |\n| `attachments`                                                        | `Attachment[]` |              |                                   |\n| Datei-, Verzeichnis-, Auswahl-, Blob- oder GitHub-Referenzanhänge    |                |              |                                   |\n| `source`                                                             | `string`       |              |                                   |\n| Nachrichtenquellenkennung                                            |                |              |                                   |\n| `agentMode`                                                          | `string`       |              |                                   |\n| Agentmodus: `\"interactive\"`, , `\"plan\"`, `\"autopilot\"`oder `\"shell\"` |                |              |                                   |\n| `interactionId`                                                      | `string`       |              |                                   |\n| CAPI-Interaktions-ID                                                 |                |              |                                   |\n\n### `system.message`\n\nEine System- oder Entwickleraufforderung wurde in die Unterhaltung eingefügt.\n\n| Datenfeld                    | Typ                              | Erforderlich | Description           |\n| ---------------------------- | -------------------------------- | ------------ | --------------------- |\n| `content`                    | `string`                         | ✅            | Der Aufforderungstext |\n| `role`                       | `\"system\" \\| \"developer\"`        | ✅            | Nachrichtenfunktion   |\n| `name`                       | `string`                         |              |                       |\n| Quellenbezeichner            |                                  |              |                       |\n| `metadata`                   | `{ promptVersion?, variables? }` |              |                       |\n| Metadaten der Prompt-Vorlage |                                  |              |                       |\n\n### `external_tool.requested`\n\nDer Agent möchte ein externes Tool aufrufen (eines, das vom SDK-Consumer bereitgestellt wird).\n\n| Datenfeld              | Typ      | Erforderlich | Description                                                                 |\n| ---------------------- | -------- | ------------ | --------------------------------------------------------------------------- |\n| `requestId`            | `string` | ✅            | Verwenden Sie dies, um über `session.respondToExternalTool()` zu antworten. |\n| `sessionId`            | `string` | ✅            | Sitzung, zu der diese Anforderung gehört                                    |\n| `toolCallId`           | `string` | ✅            | Toolaufruf-ID für diesen Aufruf                                             |\n| `toolName`             | `string` | ✅            | Name des externen Tools                                                     |\n| `arguments`            | `object` |              |                                                                             |\n| Argumente für das Tool |          |              |                                                                             |\n\n### `external_tool.completed`\n\nEine externe Toolanforderung wurde aufgelöst.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                             |\n| ----------- | -------- | ------------ | ------------------------------------------------------- |\n| `requestId` | `string` | ✅            | Entspricht dem entsprechenden `external_tool.requested` |\n\n### `exit_plan_mode.requested`\n\nFlüchtig Der Agent hat einen Plan erstellt und möchte den Planmodus beenden.\n\n| Datenfeld           | Typ        | Erforderlich | Description                                                                 |\n| ------------------- | ---------- | ------------ | --------------------------------------------------------------------------- |\n| `requestId`         | `string`   | ✅            | Verwenden Sie dies, um über `session.respondToExitPlanMode()` zu antworten. |\n| `summary`           | `string`   | ✅            | Zusammenfassung des Plans                                                   |\n| `planContent`       | `string`   | ✅            | Vollständiger Inhalt der Plandatei                                          |\n| `actions`           | `string[]` | ✅            | Verfügbare Benutzeraktionen (z. B. Genehmigen, Bearbeiten, Ablehnen)        |\n| `recommendedAction` | `string`   | ✅            | Vorgeschlagene Maßnahme                                                     |\n\n### `exit_plan_mode.completed`\n\nFlüchtig Eine Anforderung für den Exit-Plan-Modus wurde aufgelöst.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                              |\n| ----------- | -------- | ------------ | -------------------------------------------------------- |\n| `requestId` | `string` | ✅            | Entspricht dem entsprechenden `exit_plan_mode.requested` |\n\n### `command.queued`\n\nFlüchtig Ein Slash-Befehl wurde zur Ausführung in die Warteschlange gestellt.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                                                  |\n| ----------- | -------- | ------------ | ---------------------------------------------------------------------------- |\n| `requestId` | `string` | ✅            | Verwenden Sie dies, um über `session.respondToQueuedCommand()` zu antworten. |\n| `command`   | `string` | ✅            | Der Text des Slash-Befehls (z. B. `/help`, `/clear`)                         |\n\n### `command.completed`\n\nFlüchtig Ein Befehl in der Warteschlange wurde aufgelöst.\n\n| Datenfeld   | Typ      | Erforderlich | Description                                    |\n| ----------- | -------- | ------------ | ---------------------------------------------- |\n| `requestId` | `string` | ✅            | Entspricht dem entsprechenden `command.queued` |\n\n### `session_limits_exhausted.requested`\n\nFlüchtig Das aktuelle Sitzungsbudget wurde ausgeschöpft und die Laufzeit erfordert eine Entscheidung des Benutzers, bevor fortgefahren werden kann.\n\n| Datenfeld       | Typ      | Erforderlich | Description                                                                                           |\n| --------------- | -------- | ------------ | ----------------------------------------------------------------------------------------------------- |\n| `requestId`     | `string` | ✅            | Verwenden Sie diese ID, wenn Sie auf die ausstehende Anfrage zu einem ausgeschöpften Limit antworten. |\n| `maxAiCredits`  | `number` | ✅            | Konfigurierte maximale KI-Credits für den aktuellen Abrechnungszeitraum                               |\n| `usedAiCredits` | `number` | ✅            | KI-Gutschriften, die bereits im aktuellen Abrechnungsfenster verbraucht wurden                        |\n\n### `session_limits_exhausted.completed`\n\nFlüchtig Eine ausstehende Anfrage wegen eines ausgeschöpften Limits wurde bearbeitet.\n\n| Datenfeld                                                                                           | Typ                                     | Erforderlich | Description                                                                  |\n| --------------------------------------------------------------------------------------------------- | --------------------------------------- | ------------ | ---------------------------------------------------------------------------- |\n| `requestId`                                                                                         | `string`                                | ✅            | Entspricht dem entsprechenden `session_limits_exhausted.requested` Ereignis. |\n| `response.action`                                                                                   | `\"add\" \\| \"set\" \\| \"unset\" \\| \"cancel\"` | ✅            | Ausgewählte Aktion für die Anfrage bei erreichtem Limit                      |\n| `response.additionalAiCredits`                                                                      | `number`                                |              |                                                                              |\n| KI-Guthaben, die dem aktuellen Maximum hinzugefügt werden sollen, wenn `response.action``\"add\"` ist |                                         |              |                                                                              |\n| `response.maxAiCredits`                                                                             | `number`                                |              |                                                                              |\n| Neuer absoluter Höchstwert für AI-Credits, wenn `response.action``\"set\"` ist                        |                                         |              |                                                                              |\n\n## Kurzübersicht: Agentischer Handlungsfluss\n\nEin typischer Agent gibt Ereignisse in dieser Reihenfolge aus:\n\n```text\nassistant.turn_start          → Turn begins\n├── assistant.intent          → What the agent plans to do (ephemeral)\n├── assistant.reasoning_delta → Streaming thinking chunks (ephemeral, repeated)\n├── assistant.reasoning       → Complete thinking block\n├── assistant.message_delta   → Streaming response chunks (ephemeral, repeated)\n├── assistant.message         → Complete response (may include toolRequests)\n├── assistant.usage           → Token usage for this API call (ephemeral)\n│\n├── [If tools were requested:]\n│   ├── permission.requested  → Needs user approval\n│   ├── permission.completed  → Approval result\n│   ├── tool.execution_start  → Tool begins\n│   ├── tool.execution_partial_result  → Streaming tool output (ephemeral, repeated)\n│   ├── tool.execution_progress        → Progress updates (ephemeral, repeated)\n│   ├── tool.execution_complete        → Tool finished\n│   │\n│   └── [Agent loops: more reasoning → message → tool calls...]\n│\nassistant.turn_end            → Turn complete\nsession.idle                  → Ready for next message (ephemeral)\n```\n\n## Alle Ereignistypen auf einen Blick\n\nIn dieser Tabelle sind die wichtigsten `data` Nutzlastfelder aufgeführt. Allgemeine Umschlagfelder sind oben dokumentiert.\n\n| Ereignistyp                                                                                                 | Kurzlebig       | Kategorie       | Schlüsseldatenfelder     |\n| ----------------------------------------------------------------------------------------------------------- | --------------- | --------------- | ------------------------ |\n| `assistant.turn_start`                                                                                      |                 |                 |                          |\n| Assistent                                                                                                   |                 |                 |                          |\n| `turnId`, `interactionId?`                                                                                  |                 |                 |                          |\n| `assistant.intent`                                                                                          | ✅               | Assistent       | `intent`                 |\n| `assistant.reasoning`                                                                                       |                 |                 |                          |\n| Assistent                                                                                                   |                 |                 |                          |\n| `reasoningId`, `content`                                                                                    |                 |                 |                          |\n| `assistant.reasoning_delta`                                                                                 | ✅               | Assistent       |                          |\n| `reasoningId`, `deltaContent`                                                                               |                 |                 |                          |\n| `assistant.streaming_delta`                                                                                 | ✅               | Assistent       | `totalResponseSizeBytes` |\n| `assistant.message`                                                                                         |                 |                 |                          |\n| Assistent                                                                                                   |                 |                 |                          |\n| `messageId`, `content`, `toolRequests?`, `outputTokens?`, , `phase?`                                        |                 |                 |                          |\n| `assistant.message_delta`                                                                                   | ✅               | Assistent       |                          |\n| `messageId`, `deltaContent`                                                                                 |                 |                 |                          |\n| `assistant.turn_end`                                                                                        |                 |                 |                          |\n| Assistent                                                                                                   | `turnId`        |                 |                          |\n| `assistant.usage`                                                                                           | ✅               | Assistent       |                          |\n| `model`, `apiEndpoint?`, `inputTokens?`, `outputTokens?`, , `cost?`, `duration?`                            |                 |                 |                          |\n| `tool.user_requested`                                                                                       |                 |                 |                          |\n| Werkzeug                                                                                                    |                 |                 |                          |\n| `toolCallId`, `toolName``arguments?`                                                                        |                 |                 |                          |\n| `tool.execution_start`                                                                                      |                 |                 |                          |\n| Werkzeug                                                                                                    |                 |                 |                          |\n| `toolCallId`, `toolName`, `arguments?`, `mcpServerName?`                                                    |                 |                 |                          |\n| `tool.execution_partial_result`                                                                             | ✅               | Werkzeug        |                          |\n| `toolCallId`, `partialOutput`                                                                               |                 |                 |                          |\n| `tool.execution_progress`                                                                                   | ✅               | Werkzeug        |                          |\n| `toolCallId`, `progressMessage`                                                                             |                 |                 |                          |\n| `tool.execution_complete`                                                                                   |                 |                 |                          |\n| Werkzeug                                                                                                    |                 |                 |                          |\n| `toolCallId`, `success`, `result?`, `error?`                                                                |                 |                 |                          |\n| `session.idle`                                                                                              | ✅               | Session         | `aborted?`               |\n| `session.error`                                                                                             |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| `errorType`, `message``statusCode?`                                                                         |                 |                 |                          |\n| `session.compaction_start`                                                                                  |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| *(leer)*                                                                                                    |                 |                 |                          |\n| `session.compaction_complete`                                                                               |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| `success`, `preCompactionTokens?``summaryContent?`                                                          |                 |                 |                          |\n| `session.title_changed`                                                                                     | ✅               | Session         | `title`                  |\n| `session.context_changed`                                                                                   |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| `cwd`, `gitRoot?`, `repository?`, `branch?`                                                                 |                 |                 |                          |\n| `session.usage_info`                                                                                        | ✅               | Session         |                          |\n| `tokenLimit`, `currentTokens``messagesLength`                                                               |                 |                 |                          |\n| `session.session_limits_changed`                                                                            |                 |                 |                          |\n| Session                                                                                                     | `sessionLimits` |                 |                          |\n| `session.usage_checkpoint`                                                                                  |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| `totalNanoAiu`, `totalPremiumRequests?`                                                                     |                 |                 |                          |\n| `session.task_complete`                                                                                     |                 |                 |                          |\n| Session                                                                                                     | `summary?`      |                 |                          |\n| `session.shutdown`                                                                                          |                 |                 |                          |\n| Session                                                                                                     |                 |                 |                          |\n| `shutdownType`, `codeChanges``modelMetrics`                                                                 |                 |                 |                          |\n| `permission.requested`                                                                                      |                 |                 |                          |\n| Erlaubnis                                                                                                   |                 |                 |                          |\n| `requestId`, `permissionRequest`                                                                            |                 |                 |                          |\n| `permission.completed`                                                                                      |                 |                 |                          |\n| Erlaubnis                                                                                                   |                 |                 |                          |\n| `requestId`, `result.kind`                                                                                  |                 |                 |                          |\n| `user_input.requested`                                                                                      | ✅               | Benutzereingabe |                          |\n| `requestId`, `question``choices?`                                                                           |                 |                 |                          |\n| `user_input.completed`                                                                                      | ✅               | Benutzereingabe | `requestId`              |\n| `elicitation.requested`                                                                                     | ✅               | Benutzereingabe |                          |\n| `requestId`, `message``requestedSchema`                                                                     |                 |                 |                          |\n| `elicitation.completed`                                                                                     | ✅               | Benutzereingabe | `requestId`              |\n| `subagent.started`                                                                                          |                 |                 |                          |\n| Unteragent                                                                                                  |                 |                 |                          |\n| `toolCallId`, `agentName`, `agentDisplayName`, `model?`                                                     |                 |                 |                          |\n| `subagent.completed`                                                                                        |                 |                 |                          |\n| Unteragent                                                                                                  |                 |                 |                          |\n| `toolCallId`, `agentName`, `agentDisplayName`, `model?`, `durationMs?`, , `totalTokens?`, `totalToolCalls?` |                 |                 |                          |\n| `subagent.failed`                                                                                           |                 |                 |                          |\n| Unteragent                                                                                                  |                 |                 |                          |\n| `toolCallId`, `agentName`, `error`, `model?`, `durationMs?`, , `totalTokens?`, `totalToolCalls?`            |                 |                 |                          |\n| `subagent.selected`                                                                                         |                 |                 |                          |\n| Unteragent                                                                                                  |                 |                 |                          |\n| `agentName`, `agentDisplayName``tools`                                                                      |                 |                 |                          |\n| `subagent.deselected`                                                                                       |                 |                 |                          |\n| Unteragent                                                                                                  |                 |                 |                          |\n| *(leer)*                                                                                                    |                 |                 |                          |\n| `skill.invoked`                                                                                             |                 |                 |                          |\n| Skill                                                                                                       |                 |                 |                          |\n| `name`, `path`, `content`, `allowedTools?`                                                                  |                 |                 |                          |\n| `abort`                                                                                                     |                 |                 |                          |\n| Steuerung                                                                                                   | `reason`        |                 |                          |\n| `user.message`                                                                                              |                 |                 |                          |\n| Benutzer                                                                                                    |                 |                 |                          |\n| `content`, `attachments?``agentMode?`                                                                       |                 |                 |                          |\n| `system.message`                                                                                            |                 |                 |                          |\n| System                                                                                                      |                 |                 |                          |\n| `content`, `role`                                                                                           |                 |                 |                          |\n| `external_tool.requested`                                                                                   |                 |                 |                          |\n| Externes Werkzeug                                                                                           |                 |                 |                          |\n| `requestId`, `toolName``arguments?`                                                                         |                 |                 |                          |\n| `external_tool.completed`                                                                                   |                 |                 |                          |\n| Externes Werkzeug                                                                                           | `requestId`     |                 |                          |\n| `command.queued`                                                                                            | ✅               | Befehl          |                          |\n| `requestId`, `command`                                                                                      |                 |                 |                          |\n| `command.completed`                                                                                         | ✅               | Befehl          | `requestId`              |\n| `session_limits_exhausted.requested`                                                                        | ✅               | Session         |                          |\n| `requestId`, `maxAiCredits``usedAiCredits`                                                                  |                 |                 |                          |\n| `session_limits_exhausted.completed`                                                                        | ✅               | Session         |                          |\n| `requestId`, `response.action`                                                                              |                 |                 |                          |\n| `exit_plan_mode.requested`                                                                                  | ✅               | Planmodus       |                          |\n| `requestId`, `summary`, `planContent`, `actions`                                                            |                 |                 |                          |\n| `exit_plan_mode.completed`                                                                                  | ✅               | Planmodus       | `requestId`              |"}