66 66 

67<Steps>67<Steps>

68 <Step title="Erstellen Sie das Projekt">68 <Step title="Erstellen Sie das Projekt">

69 Die Beispiele für Berechtigungsweiterleitungen später auf dieser Seite importieren `zod` direkt, daher wird es zusammen mit dem MCP SDK installiert. Erstellen Sie ein neues Verzeichnis und installieren Sie beide:69 Die [Beispiele für Berechtigungsweiterleitungen](#relay-permission-prompts) importieren `zod` direkt, daher wird es zusammen mit dem MCP SDK installiert. Erstellen Sie ein neues Verzeichnis und installieren Sie beide:

70 70 

71 ```bash theme={null}71 ```bash theme={null}

72 mkdir webhook-channel && cd webhook-channel72 mkdir webhook-channel && cd webhook-channel

116 })116 })

117 ```117 ```

118 118 

119 Die Datei macht drei Dinge in Reihenfolge:119 Die Datei konfiguriert den Server, verbindet sich über stdio und startet einen HTTP-Listener in dieser Reihenfolge:

120 120 

121 * **Server-Konfiguration**: erstellt den MCP-Server mit `claude/channel` in seinen Funktionalitäten, was Claude Code mitteilt, dass dies ein Channel ist. Claude Code liefert die [`instructions`](#server-options)-Zeichenkette an Claude als Kontext, wenn der Server sich verbindet: teilen Sie Claude mit, welche Ereignisse zu erwarten sind, ob es antworten soll, und wie Antworten weitergeleitet werden sollen, falls ja.121 * **Server-Konfiguration**: erstellt den MCP-Server mit `claude/channel` in seinen Funktionalitäten, was Claude Code mitteilt, dass dies ein Channel ist. Claude Code liefert die [`instructions`](#server-options)-Zeichenkette an Claude als Kontext, wenn der Server sich verbindet: teilen Sie Claude mit, welche Ereignisse zu erwarten sind, ob es antworten soll, und wie Antworten weitergeleitet werden sollen, falls ja.

122 * **Stdio-Verbindung**: verbindet sich mit Claude Code über stdin/stdout. Dies ist Standard für jeden [MCP-Server](https://modelcontextprotocol.io/docs/concepts/transports#standard-io).122 * **Stdio-Verbindung**: verbindet sich mit Claude Code über stdin/stdout. Dies ist Standard für jeden [MCP-Server](https://modelcontextprotocol.io/docs/concepts/transports#standard-io).

452Die [Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram)- und [Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord)-Channels gaten auf eine Sender-Allowlist auf die gleiche Weise. Sie bootstrappen die Liste durch [Pairing](/docs/de/channels#security). Siehe eine der Implementierungen für den vollständigen Pairing-Flow. Der [iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage)-Channel verfolgt einen anderen Ansatz: Er erkennt die eigenen Adressen des Benutzers aus der Messages-Datenbank beim Start und lässt sie automatisch durch, wobei andere Sender nach Handle hinzugefügt werden.452Die [Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram)- und [Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord)-Channels gaten auf eine Sender-Allowlist auf die gleiche Weise. Sie bootstrappen die Liste durch [Pairing](/docs/de/channels#security). Siehe eine der Implementierungen für den vollständigen Pairing-Flow. Der [iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage)-Channel verfolgt einen anderen Ansatz: Er erkennt die eigenen Adressen des Benutzers aus der Messages-Datenbank beim Start und lässt sie automatisch durch, wobei andere Sender nach Handle hinzugefügt werden.

453 453 

454<h2 id="relay-permission-prompts">454<h2 id="relay-permission-prompts">

455 Berechtigungsprompts weitergeben455 Relay-Berechtigungsdialoge

456</h2>456</h2>

457 457 

458Wenn Claude ein Tool aufruft, das Genehmigung benötigt, öffnet sich der lokale Terminal-Dialog und die Sitzung wartet. Ein bidirektionaler Channel kann sich dafür entscheiden, denselben Prompt parallel zu empfangen und ihn an Sie auf einem anderen Gerät weiterzuleiten. Beide bleiben aktiv: Sie können im Terminal oder auf Ihrem Telefon antworten, und Claude Code wendet die Antwort an, die zuerst ankommt, und schließt die andere.458Wenn Claude ein Tool aufruft, das Genehmigung benötigt, öffnet sich der lokale Terminal-Dialog und die Sitzung wartet. Ein bidirektionaler Kanal kann sich anmelden, um die gleiche Eingabeaufforderung parallel zu erhalten und sie an Sie auf einem anderen Gerät weiterzuleiten. Beide bleiben aktiv: Sie können im Terminal oder auf Ihrem Telefon antworten, und Claude Code wendet die Antwort an, die zuerst ankommt, und schließt die andere.

459 459 

460Die Weitergabe deckt Tool-Nutzungsgenehmigungen wie `Bash`, `Write` und `Edit` ab. Projekt-Vertrauen und MCP-Server-Zustimmungsdialoge werden nicht weitergeleitet; diese erscheinen nur im lokalen Terminal.460Relay deckt Tool-Nutzungsgenehmigungen wie `Bash`, `Write` und `Edit` ab. Projektvertrauen und MCP-Server-Zustimmungsdialoge werden nicht weitergeleitet; diese erscheinen nur im lokalen Terminal.

461 461 

462Claude Code v2.1.234 und später sendet Berechtigungsanfragen nur an Server, die es als Channels für die Sitzung registriert hat, daher sitzt die Weitergabe hinter denselben [Sitzungs-Opt-in- und Organisationskontrollen](/docs/de/channels#security) wie die Nachrichtenübermittlung. Die Weitergabe erfordert auch, dass Sie den Server mit `--channels` oder dem Development-Flag aktivieren, und erfordert, dass der Server die Berechtigungsfunktionalität deklariert.462Claude Code v2.1.234 und später sendet Berechtigungsanfragen nur an Server, die es als Kanäle für die Sitzung registriert hat, sodass Relay hinter den gleichen [Sitzungs-Opt-in- und Organisationskontrollen](/docs/de/channels#security) wie die Nachrichtenübermittlung sitzt. Relay erfordert auch, dass Sie den Server mit `--channels` oder dem Entwicklungs-Flag aktivieren, und erfordert, dass der Server die Berechtigungsfunktion deklariert.

463 463 

464<h3 id="how-relay-works">464<h3 id="how-relay-works">

465 Wie die Weitergabe funktioniert465 Wie Relay funktioniert

466</h3>466</h3>

467 467 

468Wenn ein Berechtigungsprompt öffnet, hat die Weitergabeschleife vier Schritte:468Wenn ein Berechtigungsdialog öffnet, hat die Relay-Schleife vier Schritte:

469 469 

4701. Claude Code generiert eine kurze Request-ID und benachrichtigt Ihren Server4701. Claude Code generiert eine kurze Anfrage-ID und benachrichtigt Ihren Server

4712. Ihr Server leitet den Prompt und die ID an Ihre Chat-App weiter4712. Ihr Server leitet die Eingabeaufforderung und ID an Ihre Chat-App weiter

4723. Der Remote-Benutzer antwortet mit ja oder nein und dieser ID4723. Der Remote-Benutzer antwortet mit Ja oder Nein und dieser ID

4734. Ihr eingehender Handler analysiert die Antwort in ein Urteil, und Claude Code wendet es nur an, wenn die ID einer offenen Anfrage entspricht4734. Ihr Inbound-Handler analysiert die Antwort in ein Urteil, und Claude Code wendet es nur an, wenn die ID einer offenen Anfrage entspricht

474 474 

475Der lokale Terminal-Dialog bleibt während all dessen offen. Wenn jemand am Terminal antwortet, bevor das Remote-Urteil ankommt, wird diese Antwort stattdessen angewendet und die ausstehende Remote-Anfrage wird gelöscht.475Der lokale Terminal-Dialog bleibt während all dieser Zeit offen. Wenn jemand am Terminal antwortet, bevor das Remote-Urteil ankommt, wird diese Antwort stattdessen angewendet und die ausstehende Remote-Anfrage wird verworfen.

476 476 

477<img src="https://mintcdn.com/claude-code/9FG0ZKj9uKYiHmbi/images/channel-permission-relay.svg?fit=max&auto=format&n=9FG0ZKj9uKYiHmbi&q=85&s=97d57f128f0da55f105ab1e3a7e10240" className="dark:hidden" alt="Sequenzdiagramm: Claude Code sendet eine permission_request-Benachrichtigung an den Channel-Server, der Server formatiert und sendet den Prompt an die Chat-App, der Mensch antwortet mit einem Urteil, und der Server analysiert diese Antwort in eine Berechtigungsbenachrichtigung zurück an Claude Code" width="600" height="230" data-path="images/channel-permission-relay.svg" />477<img src="https://mintcdn.com/claude-code/9FG0ZKj9uKYiHmbi/images/channel-permission-relay.svg?fit=max&auto=format&n=9FG0ZKj9uKYiHmbi&q=85&s=97d57f128f0da55f105ab1e3a7e10240" className="dark:hidden" alt="Sequenzdiagramm: Claude Code sendet eine permission_request-Benachrichtigung an den Kanal-Server, der Server formatiert und sendet die Eingabeaufforderung an die Chat-App, der Mensch antwortet mit einem Urteil, und der Server analysiert diese Antwort in eine Berechtigungsbenachrichtigung zurück an Claude Code" width="600" height="230" data-path="images/channel-permission-relay.svg" />

478 478 

479<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/channel-permission-relay-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=368c8d9119a9a9cff5d826d806724842" className="hidden dark:block" alt="Sequenzdiagramm: Claude Code sendet eine permission_request-Benachrichtigung an den Channel-Server, der Server formatiert und sendet den Prompt an die Chat-App, der Mensch antwortet mit einem Urteil, und der Server analysiert diese Antwort in eine Berechtigungsbenachrichtigung zurück an Claude Code" width="600" height="230" data-path="images/channel-permission-relay-dark.svg" />479<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/channel-permission-relay-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=368c8d9119a9a9cff5d826d806724842" className="hidden dark:block" alt="Sequenzdiagramm: Claude Code sendet eine permission_request-Benachrichtigung an den Kanal-Server, der Server formatiert und sendet die Eingabeaufforderung an die Chat-App, der Mensch antwortet mit einem Urteil, und der Server analysiert diese Antwort in eine Berechtigungsbenachrichtigung zurück an Claude Code" width="600" height="230" data-path="images/channel-permission-relay-dark.svg" />

480 480 

481<h3 id="permission-request-fields">481<h3 id="permission-request-fields">

482 Berechtigungsanfrage-Felder482 Berechtigungsanfrage-Felder

483</h3>483</h3>

484 484 

485Die ausgehende Benachrichtigung von Claude Code ist `notifications/claude/channel/permission_request`. Wie die [Channel-Benachrichtigung](#notification-format) ist der Transport Standard-MCP, aber die Methode und das Schema sind Claude Code-Erweiterungen. Das `params`-Objekt hat vier String-Felder, die Ihr Server in den ausgehenden Prompt formatiert:485Die ausgehende Benachrichtigung von Claude Code ist `notifications/claude/channel/permission_request`. Wie die [Kanal-Benachrichtigung](#notification-format) ist der Transport Standard-MCP, aber die Methode und das Schema sind Claude Code-Erweiterungen. Das `params`-Objekt hat vier String-Felder, die Ihr Server in die ausgehende Eingabeaufforderung formatiert:

486 486 

487| Feld | Beschreibung |487| Feld | Beschreibung |

488| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |488| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

489| `request_id` | Fünf Kleinbuchstaben aus `a`-`z` ohne `l`, damit es nie als `1` oder `I` gelesen wird, wenn es auf einem Telefon eingegeben wird. Fügen Sie es in Ihren ausgehenden Prompt ein, damit es in der Antwort wiederholt werden kann. Claude Code akzeptiert nur ein Urteil, das eine ID trägt, die es ausgestellt hat. Der lokale Terminal-Dialog zeigt diese ID nicht an, daher ist Ihr ausgehender Handler die einzige Möglichkeit, sie zu erfahren. |489| `request_id` | Fünf Kleinbuchstaben aus `a`-`z` ohne `l`, sodass es niemals als `1` oder `I` gelesen wird, wenn es auf einem Telefon eingegeben wird. Fügen Sie es in Ihre ausgehende Eingabeaufforderung ein, damit es in der Antwort wiederholt werden kann. Claude Code akzeptiert nur ein Urteil, das eine ID trägt, die es ausgestellt hat. Der lokale Terminal-Dialog zeigt diese ID nicht an, daher ist Ihr ausgehender Handler die einzige Möglichkeit, sie zu erfahren. |

490| `tool_name` | Name des Tools, das Claude verwenden möchte, zum Beispiel `Bash` oder `Write`. |490| `tool_name` | Name des Tools, das Claude verwenden möchte, z. B. `Bash` oder `Write`. |

491| `description` | Menschenlesbarer Zusammenfassung dessen, was dieser spezifische Tool-Aufruf tut, niemals der Befehl selbst. Für einen Bash-Aufruf ist dies Claudes Beschreibung des Befehls; wenn das Modell keine Beschreibung gibt, ist das Feld die Konstante `Run shell command` und enthält null Befehlsdetails. Rendern Sie `input_preview`, wenn Sie Platz haben. |491| `description` | Für Menschen lesbare Zusammenfassung, was dieser spezifische Tool-Aufruf tut, niemals der Befehl selbst. Für einen Bash-Aufruf ist dies Claudes Beschreibung des Befehls; wenn das Modell keine Beschreibung gibt, ist das Feld die Konstante `Run shell command` und enthält null Befehlsdetails. Rendern Sie `input_preview`, wenn Sie Platz haben. |

492| `input_preview` | Die Argumente des Tools als JSON-förmiger Anzeigetext, nach Top-Level-Feld verschlüsselt. Für Bash ist dies der Befehl; für Write sind dies der Dateipfad und der Inhalt. Lassen Sie es aus Ihrem Prompt weg, wenn Sie nur Platz für eine einzeilige Nachricht haben. Ihr Server entscheidet, was angezeigt wird. |492| `input_preview` | Die Argumente des Tools als JSON-förmiger Anzeigetext, nach Top-Level-Feld verschlüsselt. Für Bash ist dies der Befehl; für Write die Dateipfad und der Inhalt. Lassen Sie es aus Ihrer Eingabeaufforderung weg, wenn Sie nur Platz für eine einzeilige Nachricht haben. Ihr Server entscheidet, was angezeigt werden soll. |

493 493 

494Clients auf Claude Code v2.1.211 oder später bereinigen `description` und `input_preview` vor der Weitergabe. Erwarten Sie drei Änderungen im Text, den Sie erhalten:494Clients auf Claude Code v2.1.211 oder später bereinigen `description` und `input_preview`, bevor sie sie weitergeleitet. Erwarten Sie drei Änderungen im Text, den Sie erhalten:

495 495 

496* Claude Code neutralisiert Richtungsüberschreibungszeichen, unsichtbare Zeichen und Anführungszeichen und Winkelklammer-Lookalikes.496* Claude Code neutralisiert Richtungsüberschreibungszeichen, unsichtbare Zeichen und Anführungszeichen und Winkelklammer-Lookalikes.

497* Claude Code faltet jeden Lauf von Leerzeichen zu einem einzelnen Leerzeichen.497* Claude Code faltet jeden Lauf von Leerzeichen zu einem einzelnen Leerzeichen.

498* Claude Code leitet Text ganz bis zu 3.500 Code-Punkte weiter. Für einen längeren Wert erhalten Sie seinen Anfang und sein Ende um einen gezählten `⋯ N code points elided ⋯`-Marker. Das Ende eines langen Befehls erreicht immer noch den Genehmiger.498* Claude Code leitet Text ganz bis zu 3.500 Code-Punkte weiter. Für einen längeren Wert erhalten Sie seinen Anfang und sein Ende um einen gezählten `⋯ N code points elided ⋯` Marker. Das Ende eines langen Befehls erreicht immer noch den Genehmiger.

499 499 

500Für `input_preview` wendet Claude Code das 3.500-Limit auf jedes Top-Level-Feld der Argumente separat an und behält die strukturellen Anführungszeichen des JSON. Clients vor v2.1.211 leiten `description` roh weiter und schneiden `input_preview` auf 200 UTF-16-Einheiten mit einer nachfolgenden Ellipse.500Für `input_preview` wendet Claude Code das 3.500-Limit auf jedes Top-Level-Feld der Argumente separat an und behält die strukturellen Anführungszeichen des JSON. Clients vor v2.1.211 leiten `description` roh weiter und schneiden `input_preview` auf 200 UTF-16-Einheiten mit einer nachfolgenden Ellipse.

501 501 

502Clients auf Claude Code v2.1.234 oder später leiten den Marker `(value unserializable)` anstelle eines `input_preview`-Feldwerts weiter, den sie nicht sicher serialisieren können, wie eine zirkuläre Struktur oder ein extrem großes Array. Sie erhalten immer noch den Feldschlüssel, und die anderen Felder der Vorschau sind unverändert.502Clients auf Claude Code v2.1.234 oder später leiten den Marker `(value unserializable)` anstelle eines `input_preview`-Feldwerts weiter, den sie nicht sicher serialisieren können, z. B. eine zirkuläre Struktur oder ein extrem großes Array. Sie erhalten immer noch den Schlüssel des Feldes, und die anderen Felder der Vorschau sind unverändert.

503 503 

504Clients auf Claude Code v2.1.234 oder später maskieren auch Anmeldedaten in `description` und `input_preview`. Sie erhalten `[REDACTED]` anstelle eines erkennbaren Provider-Anmeldedaten-Tokens, wie eines API-Schlüssels oder eines persönlichen Zugriffstokens. Erwarten Sie drei Auswirkungen der Maskierung, wenn Sie die Felder rendern:504Clients auf Claude Code v2.1.234 oder später maskieren auch Anmeldedaten in `description` und `input_preview`. Sie erhalten `[REDACTED]` anstelle eines erkennbaren Provider-Anmeldedaten-Tokens, z. B. eines API-Schlüssels oder eines persönlichen Zugriffstokens. Erwarten Sie drei Auswirkungen der Maskierung, wenn Sie die Felder rendern:

505 505 

506* Claude Code maskiert Schlüsselnamen in `input_preview` sowie deren Werte. Ein Schlüsselname, den Sie anzeigen, stimmt möglicherweise nicht mit dem Schlüsselnamen in der Eingabe überein.506* Claude Code maskiert Schlüsselnamen in `input_preview` sowie deren Werte. Ein Schlüsselname, den Sie anzeigen, stimmt möglicherweise nicht mit dem Schlüsselnamen in der Eingabe überein.

507* Claude Code maskiert niemals eine Spanne, die Shell-Syntax, Pfadzeichen oder URL-Zeichen enthält. Eine Maske kann den Befehl, Dateipfad oder das Ziel, das genehmigt wird, nicht verbergen.507* Claude Code maskiert niemals eine Spanne, die Shell-Syntax, Pfadzeichen oder URL-Zeichen enthält. Eine Maske kann den Befehl, Dateipfad oder das Ziel, das genehmigt wird, nicht verbergen.

508* Claude Code maskiert kein Geheimnis, das ein erkennbares Präfix fehlt, oder ein Geheimnis, das sich über Leerzeichen erstreckt, wie einen Private-Key-Block. Beide erreichen Ihren Server unmasked.508* Claude Code maskiert kein Geheimnis, dem ein erkennbares Präfix fehlt, oder ein Geheimnis, das sich über Leerzeichen erstreckt, z. B. einen Private-Key-Block. Beide erreichen Ihren Server unmasked.

509 509 

510Die Maskierung ändert nicht, wer die Felder empfängt. Was unmasked bleibt, geht nur an Server, die Sie mit `--channels` oder dem Development-Flag aktiviert haben. Behandeln Sie beide Felder als nicht vertrauenswürdig, es sei denn, Sie kontrollieren die Client-Flotte.510Die Maskierung ändert nicht, wer die Felder erhält. Was unmasked bleibt, geht nur an Server, die Sie mit `--channels` oder dem Entwicklungs-Flag aktiviert haben. Behandeln Sie beide Felder als nicht vertrauenswürdig, es sei denn, Sie kontrollieren die Client-Flotte.

511 511 

512Das Urteil, das Ihr Server zurücksendet, ist `notifications/claude/channel/permission` mit zwei Feldern: `request_id`, das die obige ID wiederholt, und `behavior`, das auf `'allow'` oder `'deny'` gesetzt ist. Allow lässt den Tool-Aufruf fortfahren; deny lehnt ihn ab, dasselbe wie das Antworten mit Nein im lokalen Dialog. Weder das Urteil beeinflusst zukünftige Aufrufe.512Das Urteil, das Ihr Server zurücksendet, ist `notifications/claude/channel/permission` mit zwei Feldern: `request_id` wiederholt die obige ID, und `behavior` ist auf `'allow'` oder `'deny'` gesetzt. Allow lässt den Tool-Aufruf fortfahren; deny lehnt ihn ab. Keines der beiden Urteile beeinflusst zukünftige Aufrufe.

513 513 

514<h3 id="add-relay-to-a-chat-bridge">514<h3 id="add-relay-to-a-chat-bridge">

515 Weitergabe zu einer Chat-Brücke hinzufügen515 Relay zu einer Chat-Bridge hinzufügen

516</h3>516</h3>

517 517 

518Das Hinzufügen von Berechtigungsweitergabe zu einem bidirektionalen Channel erfordert drei Komponenten:518Das Hinzufügen von Berechtigungsrelay zu einem bidirektionalen Kanal erfordert drei Komponenten:

519 519 

5201. Ein `claude/channel/permission: {}`-Eintrag unter `experimental`-Funktionalitäten in Ihrem `Server`-Constructor, damit Claude Code weiß, dass Prompts weitergeleitet werden sollen5201. Ein `claude/channel/permission: {}`-Eintrag unter `experimental`-Fähigkeiten in Ihrem `Server`-Konstruktor, damit Claude Code weiß, dass Eingabeaufforderungen weitergeleitet werden sollen

5212. Ein Benachrichtigungshandler für `notifications/claude/channel/permission_request`, der den Prompt formatiert und ihn über Ihre Plattform-API sendet5212. Ein Benachrichtigungshandler für `notifications/claude/channel/permission_request`, der die Eingabeaufforderung formatiert und sie über Ihre Plattform-API sendet

5223. Eine Überprüfung in Ihrem eingehenden Nachrichtenhandler, die `yes <id>` oder `no <id>` erkennt und stattdessen eine `notifications/claude/channel/permission`-Urteilsbenachrichtigung emittiert, anstatt den Text an Claude weiterzuleiten5223. Eine Überprüfung in Ihrem Inbound-Nachrichtenhandler, die `yes <id>` oder `no <id>` erkennt und stattdessen ein `notifications/claude/channel/permission`-Urteil ausgibt, anstatt den Text an Claude weiterzuleiten

523 523 

524Deklarieren Sie die Funktionalität nur, wenn Ihr Channel [den Sender authentifiziert](#gate-inbound-messages), da jeder, der über Ihren Channel antworten kann, Tool-Nutzung in Ihrer Sitzung genehmigen oder ablehnen kann.524Deklarieren Sie die Fähigkeit nur, wenn Ihr Kanal [den Absender authentifiziert](#gate-inbound-messages), da jeder, der über Ihren Kanal antworten kann, die Tool-Nutzung in Ihrer Sitzung genehmigen oder ablehnen kann.

525 525 

526Um diese zu einer bidirektionalen Chat-Brücke wie der in [Antwort-Tool bereitstellen](#expose-a-reply-tool) zusammengestellten hinzuzufügen:526Um diese zu einer bidirektionalen Chat-Bridge wie der in [Expose a reply tool](#expose-a-reply-tool) zusammengestellten hinzuzufügen:

527 527 

528<Steps>528<Steps>

529 <Step title="Deklarieren Sie die Berechtigungsfunktionalität">529 <Step title="Deklarieren Sie die Berechtigungsfähigkeit">

530 In Ihrem `Server`-Constructor fügen Sie `claude/channel/permission: {}` neben `claude/channel` unter `experimental` hinzu:530 Fügen Sie in Ihrem `Server`-Konstruktor `claude/channel/permission: {}` neben `claude/channel` unter `experimental` hinzu:

531 531 

532 ```ts theme={null}532 ```ts theme={null}

533 capabilities: {533 capabilities: {

541 </Step>541 </Step>

542 542 

543 <Step title="Behandeln Sie die eingehende Anfrage">543 <Step title="Behandeln Sie die eingehende Anfrage">

544 Registrieren Sie einen Benachrichtigungshandler zwischen Ihrem `Server`-Constructor und `mcp.connect()`. Claude Code ruft ihn mit den [vier Anfrage-Feldern](#permission-request-fields) auf, wenn ein Berechtigungsdialog öffnet. Ihr Handler formatiert den Prompt für Ihre Plattform und enthält Anweisungen zum Antworten mit der ID:544 Registrieren Sie einen Benachrichtigungshandler zwischen Ihrem `Server`-Konstruktor und `mcp.connect()`. Claude Code ruft ihn mit den [vier Anfrage-Feldern](#permission-request-fields) auf, wenn ein Berechtigungsdialog öffnet. Ihr Handler formatiert die Eingabeaufforderung für Ihre Plattform und enthält Anweisungen zum Antworten mit der ID:

545 545 

546 ```ts theme={null}546 ```ts theme={null}

547 import { z } from 'zod'547 import { z } from 'zod'

548 548 

549 // setNotificationHandler leitet nach z.literal auf dem method-Feld weiter,549 // setNotificationHandler routes by z.literal on the method field,

550 // daher ist dieses Schema sowohl der Validator als auch der Dispatch-Schlüssel550 // so this schema is both the validator and the dispatch key

551 const PermissionRequestSchema = z.object({551 const PermissionRequestSchema = z.object({

552 method: z.literal('notifications/claude/channel/permission_request'),552 method: z.literal('notifications/claude/channel/permission_request'),

553 params: z.object({553 params: z.object({

559 })559 })

560 560 

561 mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {561 mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {

562 // send() ist Ihre Ausgangsrichtung: POST an Ihre Chat-Plattform, oder für lokales562 // send() is your outbound: POST to your chat platform, or for local

563 // Testen die SSE-Übertragung, die im vollständigen Beispiel unten gezeigt wird.563 // testing the SSE broadcast shown in the full example below.

564 send(564 send(

565 `Claude wants to run ${params.tool_name}: ${params.description}\n` +565 `Claude wants to run ${params.tool_name}: ${params.description}\n` +

566 // input_preview trägt die tatsächlichen Argumente; rendern Sie es, wenn Sie566 // input_preview carries the actual arguments; render it when you

567 // Platz haben: für Bash kann die Beschreibung allein nur567 // have room: for Bash the description alone may be just

568 // "Run shell command" sein mit null Befehlsdetails568 // "Run shell command" with zero command detail

569 `${params.input_preview}\n\n` +569 `${params.input_preview}\n\n` +

570 // die ID in der Anweisung ist das, was Ihr eingehender Handler in Schritt 3 analysiert570 // the ID in the instruction is what your inbound handler parses in Step 3

571 `Reply "yes ${params.request_id}" or "no ${params.request_id}"`,571 `Reply "yes ${params.request_id}" or "no ${params.request_id}"`,

572 )572 )

573 })573 })

574 ```574 ```

575 </Step>575 </Step>

576 576 

577 <Step title="Fangen Sie das Urteil in Ihrem eingehenden Handler ab">577 <Step title="Fangen Sie das Urteil in Ihrem Inbound-Handler ab">

578 Ihr eingehender Handler ist die Schleife oder der Callback, der Nachrichten von Ihrer Plattform empfängt: derselbe Ort, an dem Sie [auf Sender gaten](#gate-inbound-messages) und `notifications/claude/channel` emittieren, um Chat an Claude weiterzuleiten. Fügen Sie eine Überprüfung vor dem Chat-Weiterleitungsaufruf hinzu, die das Urteilsformat erkennt und stattdessen die Berechtigungsbenachrichtigung emittiert.578 Ihr Inbound-Handler ist die Schleife oder der Callback, der Nachrichten von Ihrer Plattform empfängt: der gleiche Ort, an dem Sie [auf Absender gating](#gate-inbound-messages) und `notifications/claude/channel` ausgeben, um Chat an Claude weiterzuleiten. Fügen Sie eine Überprüfung vor dem Chat-Weiterleitungsaufruf hinzu, die das Urteilsformat erkennt und stattdessen die Berechtigungsbenachrichtigung ausgibt.

579 579 

580 Der Regex entspricht dem ID-Format, das Claude Code generiert: fünf Buchstaben, nie `l`. Das `/i`-Flag toleriert Telefon-Autokorrektur, die die Antwort großschreibt; kleinschreiben Sie die erfasste ID, bevor Sie sie zurücksendet.580 Der Regex entspricht dem ID-Format, das Claude Code generiert: fünf Buchstaben, niemals `l`. Das `/i`-Flag toleriert die Autokorrektur des Telefons, die die Antwort großschreibt; kleinschreiben Sie die erfasste ID, bevor Sie sie zurücksendet.

581 581 

582 ```ts theme={null}582 ```ts theme={null}

583 // matches "y abcde", "yes abcde", "n abcde", "no abcde"583 // matches "y abcde", "yes abcde", "n abcde", "no abcde"

614 614 

615Eine Remote-Antwort, die nicht genau dem erwarteten Format entspricht, schlägt auf eine von zwei Arten fehl, und in beiden Fällen bleibt der lokale Terminal-Dialog offen:615Eine Remote-Antwort, die nicht genau dem erwarteten Format entspricht, schlägt auf eine von zwei Arten fehl, und in beiden Fällen bleibt der lokale Terminal-Dialog offen:

616 616 

617* **Anderes Format**: der Regex Ihres eingehenden Handlers schlägt fehl zu entsprechen, daher fällt Text wie `approve it` oder `yes` ohne ID als normale Nachricht an Claude durch.617* **Anderes Format**: Der Regex Ihres Inbound-Handlers schlägt fehl, sodass Text wie `approve it` oder `yes` ohne ID als normale Nachricht an Claude durchfällt.

618* **Richtiges Format, falsche ID**: Ihr Server emittiert ein Urteil, aber Claude Code findet keine offene Anfrage mit dieser ID und löscht es stillschweigend.618* **Richtiges Format, falsche ID**: Ihr Server gibt ein Urteil aus, aber Claude Code findet keine offene Anfrage mit dieser ID und verwirft es stillschweigend.

619 619 

620<h3 id="full-example">620<h3 id="full-example">

621 Vollständiges Beispiel621 Vollständiges Beispiel

622</h3>622</h3>

623 623 

624Die zusammengestellte `webhook.ts` unten kombiniert alle drei Erweiterungen von dieser Seite: das Antwort-Tool, Sender-Gating und Berechtigungsweitergabe. Wenn Sie hier anfangen, benötigen Sie auch die [Projekt-Setup und `.mcp.json`-Eintrag](#example-build-a-webhook-receiver) aus der anfänglichen Anleitung.624Das zusammengestellte `webhook.ts` unten kombiniert alle drei Erweiterungen von dieser Seite: das Reply-Tool, Absender-Gating und Berechtigungsrelay. Wenn Sie hier anfangen, benötigen Sie auch die [Projekteinrichtung und `.mcp.json`-Eintrag](#example-build-a-webhook-receiver) aus der anfänglichen Anleitung.

625 625 

626Um beide Richtungen von curl aus testbar zu machen, dient der HTTP-Listener zwei Pfaden:626Um beide Richtungen von curl aus testbar zu machen, bedient der HTTP-Listener zwei Pfade:

627 627 

628* **`GET /events`**: hält einen SSE-Stream offen und pusht jede ausgehende Nachricht als `data:`-Zeile, daher kann `curl -N` Claudes Antworten und Berechtigungsprompts live beobachten, wenn sie ankommen.628* **`GET /events`**: hält einen SSE-Stream offen und pusht jede ausgehende Nachricht als `data:`-Zeile, sodass `curl -N` Claudes Antworten und alle Berechtigungsaufforderungen live sehen kann.

629* **`POST /`**: die eingehende Seite, derselbe Handler wie zuvor, jetzt mit der Urteilsformat-Überprüfung vor dem Chat-Weiterleitungszweig eingefügt.629* **`POST /`**: die Inbound-Seite, der gleiche Handler wie zuvor, jetzt mit der Urteilsformat-Überprüfung vor dem Chat-Forward-Branch eingefügt.

630 630 

631```ts title="Full webhook.ts with permission relay" expandable theme={null}631```ts title="Full webhook.ts with permission relay" expandable theme={null}

632#!/usr/bin/env bun632#!/usr/bin/env bun

635import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'635import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'

636import { z } from 'zod'636import { z } from 'zod'

637 637 

638// --- Ausgangsrichtung: schreiben Sie an alle curl -N-Listener auf /events ---638// --- Outbound: write to any curl -N listeners on /events ---

639// Eine echte Brücke würde stattdessen an Ihre Chat-Plattform POSTen.639// A real bridge would POST to your chat platform instead.

640const listeners = new Set<(chunk: string) => void>()640const listeners = new Set<(chunk: string) => void>()

641function send(text: string) {641function send(text: string) {

642 const chunk = text.split('\n').map(l => `data: ${l}\n`).join('') + '\n'642 const chunk = text.split('\n').map(l => `data: ${l}\n`).join('') + '\n'

643 for (const emit of listeners) emit(chunk)643 for (const emit of listeners) emit(chunk)

644}644}

645 645 

646// Sender-Allowlist. Für die lokale Anleitung vertrauen wir dem einzelnen X-Sender646// Sender allowlist. For the local walkthrough we trust the single X-Sender

647// Header-Wert "dev"; eine echte Brücke würde die Plattform-Benutzer-ID überprüfen.647// header value "dev"; a real bridge would check the platform's user ID.

648const allowed = new Set(['dev'])648const allowed = new Set(['dev'])

649 649 

650const mcp = new Server(650const mcp = new Server(

764})764})

765```765```

766 766 

767Testen Sie den Urteilspfad in drei Terminals. Das erste ist Ihre Claude Code-Sitzung, gestartet mit dem [Development-Flag](#test-during-the-research-preview), damit es `webhook.ts` startet:767Testen Sie den Urteilspfad in drei Terminals. Das erste ist Ihre Claude Code-Sitzung, gestartet mit dem [Entwicklungs-Flag](#test-during-the-research-preview), damit es `webhook.ts` spawnt:

768 768 

769```bash theme={null}769```bash theme={null}

770claude --dangerously-load-development-channels server:webhook770claude --dangerously-load-development-channels server:webhook

771```771```

772 772 

773Diese Anleitung testet den Berechtigungsdialog selbst, daher drücken Sie, sobald die Sitzung offen ist, `Shift+Tab`, bis die Statusleiste `⏸ manual mode on` anzeigt. Im Auto-Modus würde der Klassifizierer den `reply`-Aufruf stattdessen entscheiden, und kein Dialog würde sich für die Remote-Seite öffnen, um zu antworten.773Diese Anleitung testet den Berechtigungsdialog selbst, also drücken Sie nach dem Öffnen der Sitzung `Shift+Tab`, bis die Statusleiste `⏸ manual mode on` anzeigt. Im Auto-Modus würde der Klassifizierer den `reply`-Aufruf statt Ihnen entscheiden, und kein Dialog würde für die Remote-Seite zum Antworten öffnen.

774 774 

775Im zweiten streamen Sie die ausgehende Seite, damit Sie Claudes Antworten und alle Berechtigungsprompts live sehen können, wenn sie ankommen:775Im zweiten, streamen Sie die ausgehende Seite, damit Sie Claudes Antworten und alle Berechtigungsaufforderungen live sehen können, wenn sie auslösen:

776 776 

777```bash theme={null}777```bash theme={null}

778curl -N localhost:8788/events778curl -N localhost:8788/events

779```779```

780 780 

781Im dritten senden Sie eine Nachricht, die Claude veranlasst, einen Befehl auszuführen:781Im dritten, senden Sie eine Nachricht, die Claude veranlasst, einen Befehl auszuführen:

782 782 

783```bash theme={null}783```bash theme={null}

784curl -d "list the files in this directory" -H "X-Sender: dev" localhost:8788784curl -d "list the files in this directory" -H "X-Sender: dev" localhost:8788

785```785```

786 786 

787Das Auflisten von Dateien ist schreibgeschützt, daher führt Claude es ohne Genehmigung aus. Der Berechtigungsdialog öffnet sich, wenn Claude das `reply`-Tool aufruft, um seine Antwort zurückzusenden. Der lokale Dialog öffnet sich in Ihrem Claude Code-Terminal, und einen Moment später erscheint der Prompt für `mcp__webhook__reply` im `/events`-Stream, einschließlich der fünf-buchstabigen ID. Genehmigen Sie ihn von der Remote-Seite:787Das Auflisten von Dateien ist schreibgeschützt, daher führt Claude es ohne Genehmigung aus. Der Berechtigungsdialog öffnet, wenn Claude das `reply`-Tool aufruft, um seine Antwort zurückzusenden. Der lokale Dialog öffnet sich in Ihrem Claude Code-Terminal, und kurz darauf erscheint die Eingabeaufforderung für `mcp__webhook__reply` im `/events`-Stream, einschließlich der fünfstelligen ID. Genehmigen Sie es von der Remote-Seite:

788 788 

789```bash theme={null}789```bash theme={null}

790curl -d "yes <id>" -H "X-Sender: dev" localhost:8788790curl -d "yes <id>" -H "X-Sender: dev" localhost:8788

791```791```

792 792 

793Der lokale Dialog schließt sich, das `reply`-Tool läuft, und Claudes Antwort landet im Stream.793Der lokale Dialog schließt sich, das `reply`-Tool läuft, und Claudes Antwort erscheint im Stream.

794 794 

795Die drei Channel-spezifischen Teile in dieser Datei:795Die drei Kanal-spezifischen Teile in dieser Datei:

796 796 

797* **Funktionalitäten** im `Server`-Constructor: `claude/channel` registriert den Benachrichtigungslistener, `claude/channel/permission` entscheidet sich für Berechtigungsweitergabe, `tools` lässt Claude das Antwort-Tool entdecken.797* **Fähigkeiten** im `Server`-Konstruktor: `claude/channel` registriert den Benachrichtigungslistener, `claude/channel/permission` aktiviert Berechtigungsrelay, `tools` lässt Claude das Reply-Tool entdecken.

798* **Ausgehende Pfade**: der `reply`-Tool-Handler ist das, was Claude für Gesprächsantworten aufruft; der `PermissionRequestSchema`-Benachrichtigungshandler ist das, was Claude Code aufruft, wenn ein Berechtigungsdialog öffnet. Beide rufen `send()` auf, um über `/events` zu übertragen, aber sie werden von verschiedenen Teilen des Systems ausgelöst.798* **Ausgehende Pfade**: Der `reply`-Tool-Handler ist das, was Claude für Gesprächsantworten aufruft; der `PermissionRequestSchema`-Benachrichtigungshandler ist das, was Claude Code aufruft, wenn ein Berechtigungsdialog öffnet. Beide rufen `send()` auf, um über `/events` zu broadcasten, aber sie werden von verschiedenen Teilen des Systems ausgelöst.

799* **HTTP-Handler**: `GET /events` hält einen SSE-Stream offen, damit curl Ausgangsrichtung live beobachten kann; `POST` ist eingehend, gatet auf dem `X-Sender`-Header. Ein `yes <id>`- oder `no <id>`-Body geht an Claude Code als Urteilsbenachrichtigung und erreicht nie Claude; alles andere wird an Claude als Channel-Ereignis weitergeleitet.799* **HTTP-Handler**: `GET /events` hält einen SSE-Stream offen, damit curl ausgehend live beobachten kann; `POST` ist eingehend, gated auf dem `X-Sender`-Header. Ein `yes <id>`- oder `no <id>`-Body geht an Claude Code als Urteilsbenachrichtigung und erreicht niemals Claude; alles andere wird an Claude als Kanal-Event weitergeleitet.

800 800 

801<h2 id="package-as-a-plugin">801<h2 id="package-as-a-plugin">

802 Als Plugin verpacken802 Als Plugin verpacken