Documentation — Spybara

agent-sdk/agent-loop.md +395 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# So funktioniert die Agent-Schleife

7> Verstehen Sie den Nachrichtenlebenszyklus, die Werkzeugausführung, das Kontextfenster und die Architektur, die Ihre SDK-Agenten antreibt.

9Das Agent SDK ermöglicht es Ihnen, die autonome Agent-Schleife von Claude Code in Ihre eigenen Anwendungen einzubetten. Das SDK ist ein eigenständiges Paket, das Ihnen programmatische Kontrolle über Werkzeuge, Berechtigungen, Kostenlimits und Ausgabe gibt. Sie müssen die Claude Code CLI nicht installiert haben, um es zu verwenden.

11Wenn Sie einen Agent starten, führt das SDK die gleiche [Ausführungsschleife aus, die Claude Code antreibt](/de/how-claude-code-works#the-agentic-loop): Claude bewertet Ihren Prompt, ruft Werkzeuge auf, um Maßnahmen zu ergreifen, erhält die Ergebnisse und wiederholt dies, bis die Aufgabe abgeschlossen ist. Diese Seite erklärt, was in dieser Schleife passiert, damit Sie Ihre Agenten effektiv erstellen, debuggen und optimieren können.

13## Die Schleife auf einen Blick

15Jede Agent-Sitzung folgt dem gleichen Zyklus:

17<img src="https://mintcdn.com/claude-code/gvy2DIUELtNA8qD3/images/agent-loop-diagram.svg?fit=max&auto=format&n=gvy2DIUELtNA8qD3&q=85&s=192e1bd6c8a2950a16e5ee0b94e27e26" alt="Agent-Schleife: Prompt wird eingegeben, Claude bewertet, verzweigt sich zu Werkzeugaufrufen oder endgültiger Antwort" width="680" height="150" data-path="images/agent-loop-diagram.svg" />

191. **Prompt empfangen.** Claude empfängt Ihren Prompt zusammen mit dem System-Prompt, Werkzeugdefinitionen und Gesprächsverlauf. Das SDK gibt eine [`SystemMessage`](#message-types) mit dem Subtyp `"init"` aus, die Sitzungsmetadaten enthält.

202. **Bewerten und antworten.** Claude bewertet den aktuellen Status und bestimmt, wie vorzugehen ist. Es kann mit Text antworten, einen oder mehrere Werkzeugaufrufe anfordern oder beides. Das SDK gibt eine [`AssistantMessage`](#message-types) aus, die den Text und alle Werkzeugaufrufe enthält.

213. **Werkzeuge ausführen.** Das SDK führt jedes angeforderte Werkzeug aus und sammelt die Ergebnisse. Jeder Satz von Werkzeugergebnissen wird an Claude für die nächste Entscheidung zurückgesendet. Sie können [Hooks](/de/agent-sdk/hooks) verwenden, um Werkzeugaufrufe vor ihrer Ausführung abzufangen, zu ändern oder zu blockieren.

224. **Wiederholen.** Die Schritte 2 und 3 wiederholen sich als Zyklus. Jeder vollständige Zyklus ist eine Runde. Claude ruft weiterhin Werkzeuge auf und verarbeitet Ergebnisse, bis es eine Antwort ohne Werkzeugaufrufe erzeugt.

235. **Ergebnis zurückgeben.** Das SDK gibt eine endgültige [`AssistantMessage`](#message-types) mit der Textantwort (keine Werkzeugaufrufe) aus, gefolgt von einer [`ResultMessage`](#message-types) mit dem endgültigen Text, Token-Nutzung, Kosten und Sitzungs-ID.

25Eine schnelle Frage („welche Dateien sind hier?") könnte eine oder zwei Runden dauern, in denen `Glob` aufgerufen und die Ergebnisse beantwortet werden. Eine komplexe Aufgabe („refaktorisieren Sie das Auth-Modul und aktualisieren Sie die Tests") kann Dutzende von Werkzeugaufrufen über viele Runden hinweg verketten, Dateien lesen, Code bearbeiten und Tests ausführen, wobei Claude seinen Ansatz basierend auf jedem Ergebnis anpasst.

27## Runden und Nachrichten

29Eine Runde ist eine Hin- und Rückfahrt in der Schleife: Claude erzeugt eine Ausgabe, die Werkzeugaufrufe enthält, das SDK führt diese Werkzeuge aus, und die Ergebnisse werden automatisch an Claude zurückgesendet. Dies geschieht, ohne die Kontrolle an Ihren Code zurückzugeben. Runden werden fortgesetzt, bis Claude eine Ausgabe ohne Werkzeugaufrufe erzeugt, woraufhin die Schleife endet und das endgültige Ergebnis geliefert wird.

31Stellen Sie sich vor, wie eine vollständige Sitzung für den Prompt „Beheben Sie die fehlgeschlagenen Tests in auth.ts" aussehen könnte.

33Zunächst sendet das SDK Ihren Prompt an Claude und gibt eine [`SystemMessage`](#message-types) mit den Sitzungsmetadaten aus. Dann beginnt die Schleife:

351. **Runde 1:** Claude ruft `Bash` auf, um `npm test` auszuführen. Das SDK gibt eine [`AssistantMessage`](#message-types) mit dem Werkzeugaufruf aus, führt den Befehl aus und gibt dann eine [`UserMessage`](#message-types) mit der Ausgabe (drei Fehler) aus.

362. **Runde 2:** Claude ruft `Read` auf `auth.ts` und `auth.test.ts` auf. Das SDK gibt die Dateiinhalte zurück und gibt eine `AssistantMessage` aus.

373. **Runde 3:** Claude ruft `Edit` auf, um `auth.ts` zu beheben, und ruft dann `Bash` auf, um `npm test` erneut auszuführen. Alle drei Tests bestehen. Das SDK gibt eine `AssistantMessage` aus.

384. **Letzte Runde:** Claude erzeugt eine nur-Text-Antwort ohne Werkzeugaufrufe: „Behobener Auth-Bug, alle drei Tests bestehen jetzt." Das SDK gibt eine endgültige `AssistantMessage` mit diesem Text aus, gefolgt von einer [`ResultMessage`](#message-types) mit dem gleichen Text plus Kosten und Nutzung.

40Das waren vier Runden: drei mit Werkzeugaufrufen, eine endgültige nur-Text-Antwort.

42Sie können die Schleife mit `max_turns` / `maxTurns` begrenzen, die nur Werkzeug-Nutzungsrunden zählt. Zum Beispiel würde `max_turns=2` in der obigen Schleife vor dem Bearbeitungsschritt gestoppt haben. Sie können auch `max_budget_usd` / `maxBudgetUsd` verwenden, um Runden basierend auf einem Ausgabenschwellenwert zu begrenzen.

44Ohne Limits läuft die Schleife, bis Claude von selbst fertig ist, was für gut definierte Aufgaben in Ordnung ist, aber bei offenen Prompts lange laufen kann („verbessern Sie diese Codebasis"). Das Festlegen eines Budgets ist eine gute Standardeinstellung für Produktionsagenten. Siehe [Runden und Budget](#turns-and-budget) unten für die Optionsreferenz.

46## Nachrichtentypen

48Während die Schleife läuft, gibt das SDK einen Stream von Nachrichten aus. Jede Nachricht trägt einen Typ, der Ihnen sagt, aus welcher Phase der Schleife sie stammt. Die fünf Kerntypen sind:

50* **`SystemMessage`:** Sitzungslebenszyklus-Ereignisse. Das Feld `subtype` unterscheidet sie: `"init"` ist die erste Nachricht (Sitzungsmetadaten), und `"compact_boundary"` wird nach [Komprimierung](#automatic-compaction) ausgelöst. In TypeScript ist die Komprimierungsgrenze ihr eigener [`SDKCompactBoundaryMessage`](/de/agent-sdk/typescript#sdkcompactboundarymessage)-Typ statt eines Subtyps von `SDKSystemMessage`.

51* **`AssistantMessage`:** wird nach jeder Claude-Antwort ausgegeben, einschließlich der endgültigen nur-Text-Antwort. Enthält Textinhaltsblöcke und Werkzeugaufrufsblöcke aus dieser Runde.

52* **`UserMessage`:** wird nach jeder Werkzeugausführung mit dem Werkzeugergebnis-Inhalt ausgegeben, der an Claude zurückgesendet wird. Wird auch für alle Benutzereingaben ausgegeben, die Sie mid-loop streamen.

53* **`StreamEvent`:** wird nur ausgegeben, wenn Teilteilnachrichten aktiviert sind. Enthält rohe API-Streaming-Ereignisse (Text-Deltas, Werkzeug-Input-Chunks). Siehe [Stream-Antworten](/de/agent-sdk/streaming-output).

54* **`ResultMessage`:** markiert das Ende der Agent-Schleife. Enthält das endgültige Textergebnis, Token-Nutzung, Kosten und Sitzungs-ID. Überprüfen Sie das Feld `subtype`, um zu bestimmen, ob die Aufgabe erfolgreich war oder ein Limit erreicht hat. Eine kleine Anzahl von nachfolgenden Systemevenementen, wie `prompt_suggestion`, können danach ankommen, daher sollten Sie den Stream bis zum Ende durchlaufen, anstatt beim Ergebnis zu unterbrechen. Siehe [Ergebnis verarbeiten](#handle-the-result).

56Diese fünf Typen decken den vollständigen Lebenszyklus der Agent-Schleife in beiden SDKs ab. Das TypeScript SDK gibt auch zusätzliche Observability-Ereignisse aus (Hook-Ereignisse, Werkzeugfortschritt, Ratenlimits, Task-Benachrichtigungen), die zusätzliche Details bieten, aber nicht erforderlich sind, um die Schleife zu steuern. Siehe die [Python-Nachrichtentypen-Referenz](/de/agent-sdk/python#message-types) und [TypeScript-Nachrichtentypen-Referenz](/de/agent-sdk/typescript#message-types) für die vollständigen Listen.

58### Nachrichten verarbeiten

60Welche Nachrichten Sie verarbeiten, hängt davon ab, was Sie erstellen:

62* **Nur endgültige Ergebnisse:** verarbeiten Sie `ResultMessage`, um die Ausgabe, Kosten und ob die Aufgabe erfolgreich war oder ein Limit erreicht hat, zu erhalten.

63* **Fortschritts-Updates:** verarbeiten Sie `AssistantMessage`, um zu sehen, was Claude jede Runde tut, einschließlich welche Werkzeuge es aufgerufen hat.

64* **Live-Streaming:** aktivieren Sie Teilteilnachrichten (`include_partial_messages` in Python, `includePartialMessages` in TypeScript), um `StreamEvent`-Nachrichten in Echtzeit zu erhalten. Siehe [Stream-Antworten in Echtzeit](/de/agent-sdk/streaming-output).

66Wie Sie Nachrichtentypen überprüfen, hängt vom SDK ab:

68* **Python:** überprüfen Sie Nachrichtentypen mit `isinstance()` gegen Klassen, die aus `claude_agent_sdk` importiert wurden (zum Beispiel, `isinstance(message, ResultMessage)`).

69* **TypeScript:** überprüfen Sie das Feld `type` string (zum Beispiel, `message.type === "result"`). `AssistantMessage` und `UserMessage` umhüllen die rohe API-Nachricht in einem `.message`-Feld, daher befinden sich Inhaltsblöcke bei `message.message.content`, nicht bei `message.content`.

71<Accordion title="Beispiel: Nachrichtentypen überprüfen und Ergebnisse verarbeiten">

72 <CodeGroup>

73 ```python Python theme={null}

74 from claude_agent_sdk import query, AssistantMessage, ResultMessage

76 async for message in query(prompt="Summarize this project"):

77 if isinstance(message, AssistantMessage):

78 print(f"Turn completed: {len(message.content)} content blocks")

79 if isinstance(message, ResultMessage):

80 if message.subtype == "success":

81 print(message.result)

82 else:

83 print(f"Stopped: {message.subtype}")

84 ```

86 ```typescript TypeScript theme={null}

87 import { query } from "@anthropic-ai/claude-agent-sdk";

89 for await (const message of query({ prompt: "Summarize this project" })) {

90 if (message.type === "assistant") {

91 console.log(`Turn completed: ${message.message.content.length} content blocks`);

92 }

93 if (message.type === "result") {

94 if (message.subtype === "success") {

95 console.log(message.result);

96 } else {

97 console.log(`Stopped: ${message.subtype}`);

98 }

99 }

100 }

101 ```

102 </CodeGroup>

103</Accordion>

104

105## Werkzeugausführung

106

107Werkzeuge geben Ihrem Agent die Möglichkeit, Maßnahmen zu ergreifen. Ohne Werkzeuge kann Claude nur mit Text antworten. Mit Werkzeugen kann Claude Dateien lesen, Befehle ausführen, Code durchsuchen und mit externen Diensten interagieren.

108

109### Integrierte Werkzeuge

110

111Das SDK enthält die gleichen Werkzeuge, die Claude Code antreiben:

112

113| Kategorie | Werkzeuge | Was sie tun |

114| :----------------- | :----------------------------------------------- | :-------------------------------------------------------------------------------- |

115| **Dateivorgänge** | `Read`, `Edit`, `Write` | Dateien lesen, ändern und erstellen |

116| **Suche** | `Glob`, `Grep` | Dateien nach Muster finden, Inhalte mit Regex durchsuchen |

117| **Ausführung** | `Bash` | Shell-Befehle, Skripte, Git-Vorgänge ausführen |

118| **Web** | `WebSearch`, `WebFetch` | Das Web durchsuchen, Seiten abrufen und analysieren |

119| **Erkennung** | `ToolSearch` | Werkzeuge dynamisch finden und bei Bedarf laden, anstatt alle vorab zu laden |

120| **Orchestrierung** | `Agent`, `Skill`, `AskUserQuestion`, `TodoWrite` | Subagenten spawnen, Fähigkeiten aufrufen, den Benutzer fragen, Aufgaben verfolgen |

121

122Über integrierte Werkzeuge hinaus können Sie:

123

124* **Externe Dienste verbinden** mit [MCP-Servern](/de/agent-sdk/mcp) (Datenbanken, Browser, APIs)

125* **Benutzerdefinierte Werkzeuge definieren** mit [benutzerdefinierten Werkzeug-Handlern](/de/agent-sdk/custom-tools)

126* **Projekt-Fähigkeiten laden** über [Einstellungsquellen](/de/agent-sdk/claude-code-features) für wiederverwendbare Workflows

127

128### Werkzeugberechtigungen

129

130Claude bestimmt, welche Werkzeuge aufgerufen werden sollen, basierend auf der Aufgabe, aber Sie kontrollieren, ob diese Aufrufe ausgeführt werden dürfen. Sie können bestimmte Werkzeuge automatisch genehmigen, andere vollständig blockieren oder Genehmigung für alles verlangen. Drei Optionen arbeiten zusammen, um zu bestimmen, was ausgeführt wird:

131

132* **`allowed_tools` / `allowedTools`** genehmigt automatisch aufgelistete Werkzeuge. Ein schreibgeschützter Agent mit `["Read", "Glob", "Grep"]` in seiner Werkzeugliste für zulässige Werkzeuge führt diese Werkzeuge ohne Aufforderung aus. Werkzeuge, die nicht aufgelistet sind, sind immer noch verfügbar, erfordern aber Berechtigung.

133* **`disallowed_tools` / `disallowedTools`** blockiert aufgelistete Werkzeuge, unabhängig von anderen Einstellungen. Siehe [Berechtigungen](/de/agent-sdk/permissions) für die Reihenfolge, in der Regeln überprüft werden, bevor ein Werkzeug ausgeführt wird.

134* **`permission_mode` / `permissionMode`** kontrolliert, was mit Werkzeugen passiert, die nicht durch Zulassungs- oder Ablehnungsregeln abgedeckt sind. Siehe [Berechtigungsmodus](#permission-mode) für verfügbare Modi.

135

136Sie können auch einzelne Werkzeuge mit Regeln wie `"Bash(npm *)"` einschränken, um nur bestimmte Befehle zuzulassen. Siehe [Berechtigungen](/de/agent-sdk/permissions) für die vollständige Regelsyntax.

137

138Wenn ein Werkzeug abgelehnt wird, erhält Claude eine Ablehnungsnachricht als Werkzeugergebnis und versucht normalerweise einen anderen Ansatz oder meldet, dass es nicht fortfahren konnte.

139

140### Parallele Werkzeugausführung

141

142Wenn Claude mehrere Werkzeugaufrufe in einer einzelnen Runde anfordert, können beide SDKs sie je nach Werkzeug gleichzeitig oder sequenziell ausführen. Schreibgeschützte Werkzeuge (wie `Read`, `Glob`, `Grep` und MCP-Werkzeuge, die als schreibgeschützt gekennzeichnet sind) können gleichzeitig ausgeführt werden. Werkzeuge, die den Status ändern (wie `Edit`, `Write` und `Bash`), werden sequenziell ausgeführt, um Konflikte zu vermeiden.

143

144Benutzerdefinierte Werkzeuge verwenden standardmäßig sequenzielle Ausführung. Um parallele Ausführung für ein benutzerdefiniertes Werkzeug zu aktivieren, setzen Sie `readOnlyHint` in seinen Anmerkungen. Beide [TypeScript](/de/agent-sdk/typescript#tool) und [Python](/de/agent-sdk/python#tool) SDKs verwenden diesen Feldnamen aus dem MCP SDK.

145

146## Kontrollieren Sie, wie die Schleife läuft

147

148Sie können begrenzen, wie viele Runden die Schleife dauert, wie viel sie kostet, wie tief Claude denkt, und ob Werkzeuge vor der Ausführung genehmigt werden müssen. All diese sind Felder auf [`ClaudeAgentOptions`](/de/agent-sdk/python#claudeagentoptions) (Python) / [`Options`](/de/agent-sdk/typescript#options) (TypeScript).

149

150### Runden und Budget

151

152| Option | Was es kontrolliert | Standard |

153| :--------------------------------------------- | :---------------------------------------------- | :--------- |

154| Max Runden (`max_turns` / `maxTurns`) | Maximale Werkzeug-Nutzungs-Hin- und Rückfahrten | Kein Limit |

155| Max Budget (`max_budget_usd` / `maxBudgetUsd`) | Maximale Kosten vor dem Stoppen | Kein Limit |

156

157Wenn eines der Limits erreicht wird, gibt das SDK eine `ResultMessage` mit einem entsprechenden Fehler-Subtyp (`error_max_turns` oder `error_max_budget_usd`) zurück. Siehe [Ergebnis verarbeiten](#handle-the-result) für die Überprüfung dieser Subtypen und [`ClaudeAgentOptions`](/de/agent-sdk/python#claudeagentoptions) / [`Options`](/de/agent-sdk/typescript#options) für die Syntax.

158

159### Anstrengungsgrad

160

161Die Option `effort` kontrolliert, wie viel Denken Claude anwendet. Niedrigere Anstrengungsgrade verwenden weniger Token pro Runde und reduzieren Kosten. Nicht alle Modelle unterstützen den Anstrengungsparameter. Siehe [Anstrengung](https://platform.claude.com/docs/en/build-with-claude/effort) für welche Modelle es unterstützen.

162

163| Stufe | Verhalten | Gut für |

164| :--------- | :----------------------------------- | :----------------------------------------------------------------- |

165| `"low"` | Minimales Denken, schnelle Antworten | Datei-Lookups, Verzeichnisse auflisten |

166| `"medium"` | Ausgewogenes Denken | Routine-Bearbeitungen, Standard-Aufgaben |

167| `"high"` | Gründliche Analyse | Refaktorisierungen, Debugging |

168| `"xhigh"` | Erweiterte Denktiefe | Kodierungs- und agentengesteuerte Aufgaben; empfohlen auf Opus 4.7 |

169| `"max"` | Maximale Denktiefe | Mehrstufige Probleme, die tiefe Analyse erfordern |

170

171Wenn Sie `effort` nicht setzen, lässt das Python SDK den Parameter ungesetzt und überlässt das Standardverhalten dem Modell. Das TypeScript SDK verwendet standardmäßig `"high"`.

172

173<Note>

174 `effort` tauscht Latenz und Token-Kosten gegen Denktiefe innerhalb jeder Antwort. [Erweitertes Denken](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) ist eine separate Funktion, die sichtbare Gedankenketten-Blöcke in der Ausgabe erzeugt. Sie sind unabhängig: Sie können `effort: "low"` mit aktiviertem erweiterten Denken setzen oder `effort: "max"` ohne es.

175</Note>

176

177Verwenden Sie niedrigere Anstrengung für Agenten, die einfache, gut definierte Aufgaben ausführen (wie Dateien auflisten oder ein einzelnes Grep ausführen), um Kosten und Latenz zu reduzieren. Setzen Sie `effort` in den Top-Level-`query()`-Optionen für die gesamte Sitzung oder pro Subagent mit dem Feld `effort` auf [`AgentDefinition`](/de/agent-sdk/subagents#agentdefinition-configuration), um die Sitzungsebene zu überschreiben.

178

179### Berechtigungsmodus

180

181Die Berechtigungsmodus-Option (`permission_mode` in Python, `permissionMode` in TypeScript) kontrolliert, ob der Agent vor der Verwendung von Werkzeugen um Genehmigung fragt:

182

183| Modus | Verhalten |

184| :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

185| `"default"` | Werkzeuge, die nicht durch Zulassungsregeln abgedeckt sind, lösen Ihren Genehmigungsrückruf aus; kein Rückruf bedeutet Ablehnung |

186| `"acceptEdits"` | Genehmigt automatisch Dateibearbeitungen und häufige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp`, usw.); andere Bash-Befehle folgen Standardregeln |

187| `"plan"` | Schreibgeschützte Werkzeuge laufen; Claude erkundet und erzeugt einen Plan, ohne Ihre Quelldateien zu bearbeiten |

188| `"dontAsk"` | Fragt nie. Werkzeuge, die durch [Berechtigungsregeln](/de/settings#permission-settings) vorab genehmigt wurden, laufen, alles andere wird abgelehnt |

189| `"auto"` (nur TypeScript) | Verwendet einen Modell-Klassifizierer, um jeden Werkzeugaufruf zu genehmigen oder abzulehnen. Siehe [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) für Verfügbarkeit und Verhalten |

190| `"bypassPermissions"` | Führt alle zulässigen Werkzeuge aus, ohne zu fragen. Kann nicht verwendet werden, wenn als Root auf Unix ausgeführt wird. Verwenden Sie nur in isolierten Umgebungen, in denen die Aktionen des Agenten keine Systeme beeinflussen können, die Ihnen wichtig sind |

191

192Für interaktive Anwendungen verwenden Sie `"default"` mit einem Werkzeug-Genehmigungsrückruf, um Genehmigungsaufforderungen anzuzeigen. Für autonome Agenten auf einer Dev-Maschine verwenden Sie `"acceptEdits"`, um Dateibearbeitungen und häufige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp`, usw.) automatisch zu genehmigen, während Sie andere `Bash`-Befehle immer noch hinter Zulassungsregeln gating. Reservieren Sie `"bypassPermissions"` für CI, Container oder andere isolierte Umgebungen. Siehe [Berechtigungen](/de/agent-sdk/permissions) für vollständige Details.

193

194### Modell

195

196Wenn Sie `model` nicht setzen, verwendet das SDK Claude Codes Standard, der von Ihrer Authentifizierungsmethode und Ihrem Abonnement abhängt. Setzen Sie es explizit (zum Beispiel, `model="claude-sonnet-4-6"`), um ein bestimmtes Modell zu fixieren oder um ein kleineres Modell für schnellere, billigere Agenten zu verwenden. Siehe [Modelle](https://platform.claude.com/docs/en/about-claude/models) für verfügbare IDs.

197

198## Das Kontextfenster

199

200Das Kontextfenster ist die Gesamtmenge an Informationen, die Claude während einer Sitzung zur Verfügung stehen. Es wird nicht zwischen Runden innerhalb einer Sitzung zurückgesetzt. Alles sammelt sich an: der System-Prompt, Werkzeugdefinitionen, Gesprächsverlauf, Werkzeugeingaben und Werkzeugergebnisse. Inhalte, die über Runden hinweg gleich bleiben (System-Prompt, Werkzeugdefinitionen, CLAUDE.md), werden automatisch [prompt-gecacht](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), was Kosten und Latenz für wiederholte Präfixe reduziert.

201

202### Was Kontext verbraucht

203

204Hier ist, wie jede Komponente den Kontext im SDK beeinflusst:

205

206| Quelle | Wann es lädt | Auswirkung |

207| :--------------------------- | :------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

208| **System-Prompt** | Jede Anfrage | Kleine feste Kosten, immer vorhanden |

209| **CLAUDE.md-Dateien** | Sitzungsstart, über [`settingSources`](/de/agent-sdk/claude-code-features) | Vollständiger Inhalt in jeder Anfrage (aber prompt-gecacht, daher zahlt nur die erste Anfrage die vollständigen Kosten) |

210| **Werkzeugdefinitionen** | Jede Anfrage | Jedes Werkzeug fügt sein Schema hinzu; verwenden Sie [MCP-Werkzeugsuche](/de/agent-sdk/mcp#mcp-tool-search), um Werkzeuge bei Bedarf zu laden, anstatt alle auf einmal |

211| **Gesprächsverlauf** | Sammelt sich über Runden an | Wächst mit jeder Runde: Prompts, Antworten, Werkzeugeingaben, Werkzeugergebnisse |

212| **Fähigkeitsbeschreibungen** | Sitzungsstart, über Einstellungsquellen | Kurze Zusammenfassungen; vollständiger Inhalt lädt nur bei Aufruf |

213

214Große Werkzeugergebnisse verbrauchen erheblichen Kontext. Das Lesen einer großen Datei oder das Ausführen eines Befehls mit ausführlicher Ausgabe kann Tausende von Token in einer einzelnen Runde verwenden. Der Kontext sammelt sich über Runden an, daher bauen längere Sitzungen mit vielen Werkzeugaufrufen erheblich mehr Kontext auf als kurze.

215

216### Automatische Komprimierung

217

218Wenn sich das Kontextfenster seinem Limit nähert, komprimiert das SDK automatisch das Gespräch: Es fasst ältere Verlauf zusammen, um Platz freizugeben, während Ihre neuesten Austausche und wichtigen Entscheidungen intakt bleiben. Das SDK gibt eine Nachricht mit `type: "system"` und `subtype: "compact_boundary"` im Stream aus, wenn dies geschieht (in Python ist dies eine `SystemMessage`; in TypeScript ist es ein separater `SDKCompactBoundaryMessage`-Typ).

219

220Die Komprimierung ersetzt ältere Nachrichten durch eine Zusammenfassung, daher können spezifische Anweisungen von früh im Gespräch möglicherweise nicht beibehalten werden. Persistente Regeln gehören in CLAUDE.md (geladen über [`settingSources`](/de/agent-sdk/claude-code-features)) statt in den anfänglichen Prompt, da CLAUDE.md-Inhalte bei jeder Anfrage erneut eingespritzt werden.

221

222Sie können das Komprimierungsverhalten auf mehrere Arten anpassen:

223

224* **Zusammenfassungsanweisungen in CLAUDE.md:** Der Kompressor liest Ihre CLAUDE.md wie jeden anderen Kontext, daher können Sie einen Abschnitt einschließen, der ihm sagt, was beim Zusammenfassen zu bewahren ist. Der Abschnittskopf ist frei (nicht eine magische Zeichenkette); der Kompressor passt auf Absicht an.

225* **`PreCompact`-Hook:** Führen Sie benutzerdefinierte Logik vor der Komprimierung aus, zum Beispiel um das vollständige Transkript zu archivieren. Der Hook erhält ein `trigger`-Feld (`manual` oder `auto`). Siehe [Hooks](/de/agent-sdk/hooks).

226* **Manuelle Komprimierung:** Senden Sie `/compact` als Prompt-String, um Komprimierung bei Bedarf auszulösen. (Schrägstrich-Befehle, die auf diese Weise gesendet werden, sind SDK-Eingaben, keine nur-CLI-Verknüpfungen. Siehe [Schrägstrich-Befehle im SDK](/de/agent-sdk/slash-commands).)

227

228<Accordion title="Beispiel: Zusammenfassungsanweisungen in CLAUDE.md">

229 Fügen Sie einen Abschnitt zu Ihrer Projekt-CLAUDE.md hinzu, der dem Kompressor sagt, was zu bewahren ist. Der Kopfname ist nicht speziell; verwenden Sie ein beliebiges klares Label.

230

231 ```markdown CLAUDE.md theme={null}

232 # Summary instructions

233

234 When summarizing this conversation, always preserve:

235 - The current task objective and acceptance criteria

236 - File paths that have been read or modified

237 - Test results and error messages

238 - Decisions made and the reasoning behind them

239 ```

240</Accordion>

241

242### Kontext effizient halten

243

244Ein paar Strategien für langfristig laufende Agenten:

245

246* **Verwenden Sie Subagenten für Unteraufgaben.** Jeder Subagent startet mit einem frischen Gespräch (kein vorheriger Nachrichtenverlauf, obwohl er seinen eigenen System-Prompt und Projekt-Kontext wie CLAUDE.md lädt). Er sieht nicht die Runden des Elternteils, und nur seine endgültige Antwort kehrt zum Elternteil als Werkzeugergebnis zurück. Der Kontext des Hauptagenten wächst um diese Zusammenfassung, nicht um das vollständige Unteraufgaben-Transkript. Siehe [Was Subagenten erben](/de/agent-sdk/subagents#what-subagents-inherit) für Details.

247* **Seien Sie selektiv mit Werkzeugen.** Jede Werkzeugdefinition nimmt Kontextraum ein. Verwenden Sie das Feld `tools` auf [`AgentDefinition`](/de/agent-sdk/subagents#agentdefinition-configuration), um Subagenten auf die minimale Menge zu beschränken, die sie benötigen, und verwenden Sie [MCP-Werkzeugsuche](/de/agent-sdk/mcp#mcp-tool-search), um Werkzeuge bei Bedarf zu laden, anstatt alle vorab zu laden.

248* **Beobachten Sie MCP-Server-Kosten.** Jeder MCP-Server fügt alle seine Werkzeugschemas zu jeder Anfrage hinzu. Ein paar Server mit vielen Werkzeugen können erheblichen Kontext verbrauchen, bevor der Agent irgendwelche Arbeiten verrichtet. Das Werkzeug `ToolSearch` kann helfen, indem es Werkzeuge bei Bedarf lädt, anstatt alle vorab zu laden. Siehe [MCP-Werkzeugsuche](/de/agent-sdk/mcp#mcp-tool-search) für die Konfiguration.

249* **Verwenden Sie niedrigere Anstrengung für Routine-Aufgaben.** Setzen Sie [Anstrengung](#effort-level) auf `"low"` für Agenten, die nur Dateien lesen oder Verzeichnisse auflisten müssen. Dies reduziert Token-Nutzung und Kosten.

250

251Für eine detaillierte Aufschlüsselung der Pro-Feature-Kontextkosten siehe [Kontextkosten verstehen](/de/features-overview#understand-context-costs).

252

253## Sitzungen und Kontinuität

254

255Jede Interaktion mit dem SDK erstellt oder setzt eine Sitzung fort. Erfassen Sie die Sitzungs-ID aus `ResultMessage.session_id` (verfügbar in beiden SDKs), um später fortzufahren. Das TypeScript SDK macht es auch als direktes Feld auf der Init-`SystemMessage` verfügbar; in Python ist es in `SystemMessage.data` verschachtelt.

256

257Wenn Sie fortfahren, wird der vollständige Kontext aus vorherigen Runden wiederhergestellt: Dateien, die gelesen wurden, Analysen, die durchgeführt wurden, und Aktionen, die ergriffen wurden. Sie können auch eine Sitzung forken, um in einen anderen Ansatz zu verzweigen, ohne das Original zu ändern.

258

259Siehe [Sitzungsverwaltung](/de/agent-sdk/sessions) für den vollständigen Leitfaden zu Resume-, Continue- und Fork-Mustern.

260

261<Note>

262 In Python verwaltet `ClaudeSDKClient` Sitzungs-IDs automatisch über mehrere Aufrufe hinweg. Siehe die [Python SDK-Referenz](/de/agent-sdk/python#choosing-between-query-and-claudesdkclient) für Details.

263</Note>

264

265## Ergebnis verarbeiten

266

267Wenn die Schleife endet, sagt Ihnen die `ResultMessage`, was passiert ist, und gibt Ihnen die Ausgabe. Das Feld `subtype` (verfügbar in beiden SDKs) ist die primäre Methode, um den Beendigungsstatus zu überprüfen.

268

269| Ergebnis-Subtyp | Was passiert ist | Feld `result` verfügbar? |

270| :------------------------------------ | :------------------------------------------------------------------------------------------ | :----------------------: |

271| `success` | Claude hat die Aufgabe normal abgeschlossen | Ja |

272| `error_max_turns` | Hat das `maxTurns`-Limit erreicht, bevor es fertig wurde | Nein |

273| `error_max_budget_usd` | Hat das `maxBudgetUsd`-Limit erreicht, bevor es fertig wurde | Nein |

274| `error_during_execution` | Ein Fehler unterbrach die Schleife (zum Beispiel, ein API-Fehler oder abgebrochene Anfrage) | Nein |

275| `error_max_structured_output_retries` | Strukturierte Ausgabevalidierung fehlgeschlagen nach dem konfigurierten Wiederholungslimit | Nein |

276

277Das Feld `result` (die endgültige Textausgabe) ist nur in der `success`-Variante vorhanden, daher überprüfen Sie immer den Subtyp, bevor Sie es lesen. Alle Ergebnis-Subtypen tragen `total_cost_usd`, `usage`, `num_turns` und `session_id`, daher können Sie Kosten verfolgen und fortfahren, auch nach Fehlern. In Python sind `total_cost_usd` und `usage` als optional typisiert und können auf einigen Fehlerpfaden `None` sein, daher schützen Sie vor dem Formatieren. Siehe [Kosten und Nutzung verfolgen](/de/agent-sdk/cost-tracking) für Details zur Interpretation der `usage`-Felder.

278

279Das Ergebnis enthält auch ein Feld `stop_reason` (`string | null` in TypeScript, `str | None` in Python), das angibt, warum das Modell bei seiner endgültigen Runde die Generierung gestoppt hat. Häufige Werte sind `end_turn` (Modell fertig normal), `max_tokens` (hat das Ausgabe-Token-Limit erreicht) und `refusal` (das Modell lehnte die Anfrage ab). Bei Fehler-Ergebnis-Subtypen trägt `stop_reason` den Wert aus der letzten Assistenten-Antwort, bevor die Schleife endete. Um Ablehnungen zu erkennen, überprüfen Sie `stop_reason === "refusal"` (TypeScript) oder `stop_reason == "refusal"` (Python). Siehe [`SDKResultMessage`](/de/agent-sdk/typescript#sdkresultmessage) (TypeScript) oder [`ResultMessage`](/de/agent-sdk/python#resultmessage) (Python) für den vollständigen Typ.

280

281## Hooks

282

283[Hooks](/de/agent-sdk/hooks) sind Rückrufe, die an bestimmten Punkten in der Schleife ausgelöst werden: bevor ein Werkzeug läuft, nachdem es zurückkommt, wenn der Agent fertig ist, und so weiter. Einige häufig verwendete Hooks sind:

284

285| Hook | Wann es ausgelöst wird | Häufige Verwendungen |

286| :------------------------------- | :----------------------------------------------- | :--------------------------------------------------------------- |

287| `PreToolUse` | Bevor ein Werkzeug ausgeführt wird | Eingaben validieren, gefährliche Befehle blockieren |

288| `PostToolUse` | Nachdem ein Werkzeug zurückkommt | Ausgaben prüfen, Nebenwirkungen auslösen |

289| `UserPromptSubmit` | Wenn ein Prompt gesendet wird | Zusätzlichen Kontext in Prompts injizieren |

290| `Stop` | Wenn der Agent fertig ist | Ergebnis validieren, Sitzungsstatus speichern |

291| `SubagentStart` / `SubagentStop` | Wenn ein Subagent spawnt oder abgeschlossen wird | Parallele Task-Ergebnisse verfolgen und aggregieren |

292| `PreCompact` | Bevor Kontext-Komprimierung auftritt | Vollständiges Transkript archivieren, bevor zusammengefasst wird |

293

294Hooks laufen in Ihrem Anwendungsprozess, nicht im Kontext des Agenten, daher verbrauchen sie keinen Kontext. Hooks können auch die Schleife kurzschließen: ein `PreToolUse`-Hook, der einen Werkzeugaufruf ablehnt, verhindert seine Ausführung, und Claude erhält stattdessen die Ablehnungsnachricht.

295

296Beide SDKs unterstützen alle oben genannten Ereignisse. Das TypeScript SDK enthält zusätzliche Ereignisse, die Python noch nicht unterstützt. Siehe [Ausführung mit Hooks kontrollieren](/de/agent-sdk/hooks) für die vollständige Ereignisliste, Pro-SDK-Verfügbarkeit und die vollständige Callback-API.

297

298## Alles zusammenbringen

299

300Dieses Beispiel kombiniert die Schlüsselkonzepte von dieser Seite in einen einzelnen Agent, der fehlgeschlagene Tests behebt. Es konfiguriert den Agent mit zulässigen Werkzeugen (automatisch genehmigt, damit der Agent autonom läuft), Projekteinstellungen und Sicherheitslimits für Runden und Anstrengungsgrad. Während die Schleife läuft, erfasst sie die Sitzungs-ID für mögliche Wiederaufnahme, verarbeitet das endgültige Ergebnis und gibt die Gesamtkosten aus.

301

302<CodeGroup>

303 ```python Python theme={null}

304 import asyncio

305 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

306

307

308 async def run_agent():

309 session_id = None

310

311 async for message in query(

312 prompt="Find and fix the bug causing test failures in the auth module",

313 options=ClaudeAgentOptions(

314 allowed_tools=[

315 "Read",

316 "Edit",

317 "Bash",

318 "Glob",

319 "Grep",

320 ], # Listing tools here auto-approves them (no prompting)

321 setting_sources=[

322 "project"

323 ], # Load CLAUDE.md, skills, hooks from current directory

324 max_turns=30, # Prevent runaway sessions

325 effort="high", # Thorough reasoning for complex debugging

326 ),

327 ):

328 # Handle the final result

329 if isinstance(message, ResultMessage):

330 session_id = message.session_id # Save for potential resumption

331

332 if message.subtype == "success":

333 print(f"Done: {message.result}")

334 elif message.subtype == "error_max_turns":

335 # Agent ran out of turns. Resume with a higher limit.

336 print(f"Hit turn limit. Resume session {session_id} to continue.")

337 elif message.subtype == "error_max_budget_usd":

338 print("Hit budget limit.")

339 else:

340 print(f"Stopped: {message.subtype}")

341 if message.total_cost_usd is not None:

342 print(f"Cost: ${message.total_cost_usd:.4f}")

343

344

345 asyncio.run(run_agent())

346 ```

347

348 ```typescript TypeScript theme={null}

349 import { query } from "@anthropic-ai/claude-agent-sdk";

350

351 let sessionId: string | undefined;

352

353 for await (const message of query({

354 prompt: "Find and fix the bug causing test failures in the auth module",

355 options: {

356 allowedTools: ["Read", "Edit", "Bash", "Glob", "Grep"], // Listing tools here auto-approves them (no prompting)

357 settingSources: ["project"], // Load CLAUDE.md, skills, hooks from current directory

358 maxTurns: 30, // Prevent runaway sessions

359 effort: "high" // Thorough reasoning for complex debugging

360 }

361 })) {

362 // Save the session ID to resume later if needed

363 if (message.type === "system" && message.subtype === "init") {

364 sessionId = message.session_id;

365 }

366

367 // Handle the final result

368 if (message.type === "result") {

369 if (message.subtype === "success") {

370 console.log(`Done: ${message.result}`);

371 } else if (message.subtype === "error_max_turns") {

372 // Agent ran out of turns. Resume with a higher limit.

373 console.log(`Hit turn limit. Resume session ${sessionId} to continue.`);

374 } else if (message.subtype === "error_max_budget_usd") {

375 console.log("Hit budget limit.");

376 } else {

377 console.log(`Stopped: ${message.subtype}`);

378 }

379 console.log(`Cost: $${message.total_cost_usd.toFixed(4)}`);

380 }

381 }

382 ```

383</CodeGroup>

384

385## Nächste Schritte

386

387Jetzt, da Sie die Schleife verstehen, hier ist, wohin Sie gehen sollten, je nachdem, was Sie erstellen:

388

389* **Haben Sie noch keinen Agent ausgeführt?** Beginnen Sie mit dem [Schnellstart](/de/agent-sdk/quickstart), um das SDK installiert zu bekommen und ein vollständiges Beispiel von Anfang bis Ende laufen zu sehen.

390* **Bereit, in Ihr Projekt zu integrieren?** [Laden Sie CLAUDE.md, Fähigkeiten und Dateisystem-Hooks](/de/agent-sdk/claude-code-features), damit der Agent automatisch Ihren Projektkonventionen folgt.

391* **Erstellen Sie eine interaktive Benutzeroberfläche?** Aktivieren Sie [Streaming](/de/agent-sdk/streaming-output), um Live-Text und Werkzeugaufrufe anzuzeigen, während die Schleife läuft.

392* **Benötigen Sie strengere Kontrolle über das, was der Agent tun kann?** Sperren Sie den Werkzeugzugriff mit [Berechtigungen](/de/agent-sdk/permissions) und verwenden Sie [Hooks](/de/agent-sdk/hooks), um Werkzeugaufrufe vor ihrer Ausführung zu prüfen, zu blockieren oder zu transformieren.

393* **Führen Sie lange oder teure Aufgaben aus?** Lagern Sie isolierte Arbeiten auf [Subagenten](/de/agent-sdk/subagents) aus, um Ihren Hauptkontext schlank zu halten.

394

395Für das breitere konzeptionelle Bild der agentengesteuerten Schleife (nicht SDK-spezifisch) siehe [So funktioniert Claude Code](/de/how-claude-code-works).

agent-sdk/hooks.md +11 −11

Details

236Ihr Callback gibt ein Objekt mit zwei Kategorien von Feldern zurück:236Ihr Callback gibt ein Objekt mit zwei Kategorien von Feldern zurück:

237 237

238* **Top-Level-Felder** steuern das Gespräch: `systemMessage` fügt eine Nachricht in das Gespräch ein, die für das Modell sichtbar ist, und `continue` (`continue_` in Python) bestimmt, ob der Agent nach diesem Hook weiterläuft.238* **Top-Level-Felder** steuern das Gespräch: `systemMessage` fügt eine Nachricht in das Gespräch ein, die für das Modell sichtbar ist, und `continue` (`continue_` in Python) bestimmt, ob der Agent nach diesem Hook weiterläuft.

239* **`hookSpecificOutput`** steuert die aktuelle Operation. Die Felder darin hängen vom Hook-Ereignistyp ab. Für `PreToolUse` Hooks ist dies der Ort, an dem Sie `permissionDecision` (`"allow"`, `"deny"` oder `"ask"`), `permissionDecisionReason` und `updatedInput` setzen. Im TypeScript SDK akzeptiert `permissionDecision` auch `"defer"`, um die Abfrage zu beenden und [später fortzufahren](/de/hooks#defer-a-tool-call-for-later); dieser Wert ist im Python SDK nicht verfügbar. Für `PostToolUse` Hooks können Sie `additionalContext` setzen, um Informationen zum Tool-Ergebnis anzuhängen.239* **`hookSpecificOutput`** steuert die aktuelle Operation. Die Felder darin hängen vom Hook-Ereignistyp ab. Für `PreToolUse` Hooks ist dies der Ort, an dem Sie `permissionDecision` (`"allow"`, `"deny"` oder `"ask"`), `permissionDecisionReason` und `updatedInput` setzen. Im TypeScript SDK akzeptiert `permissionDecision` auch `"defer"`, um die Abfrage zu beenden und [später fortzufahren](/de/hooks#defer-a-tool-call-for-later); dieser Wert ist im Python SDK nicht verfügbar. Für `PostToolUse` Hooks können Sie `additionalContext` setzen, um Informationen zum Tool-Ergebnis anzuhängen, oder `updatedToolOutput`, um die Ausgabe des Tools vollständig zu ersetzen, bevor Claude sie sieht.

240 240

241Geben Sie `{}` zurück, um die Operation ohne Änderungen zuzulassen. SDK-Callback-Hooks verwenden das gleiche JSON-Ausgabeformat wie [Claude Code Shell-Befehls-Hooks](/de/hooks#json-output), das jedes Feld und ereignisspezifische Option dokumentiert. Für die SDK-Typdefinitionen siehe die [TypeScript](/de/agent-sdk/typescript#sync-hook-json-output) und [Python](/de/agent-sdk/python#sync-hook-json-output) SDK-Referenzen.241Geben Sie `{}` zurück, um die Operation ohne Änderungen zuzulassen. SDK-Callback-Hooks verwenden das gleiche JSON-Ausgabeformat wie [Claude Code Shell-Befehls-Hooks](/de/hooks#json-output), das jedes Feld und ereignisspezifische Option dokumentiert. Für die SDK-Typdefinitionen siehe die [TypeScript](/de/agent-sdk/typescript#sync-hook-json-output) und [Python](/de/agent-sdk/python#sync-hook-json-output) SDK-Referenzen.

242 242

417 ```417 ```

418</CodeGroup>418</CodeGroup>

419 419

420### Mehrere Hooks verketten420### Mehrere Hooks registrieren

421 421

422Hooks werden in der Reihenfolge ausgeführt, in der sie im Array erscheinen. Halten Sie jeden Hook auf eine einzelne Verantwortung konzentriert und verketten Sie mehrere Hooks für komplexe Logik:422Wenn ein Ereignis ausgelöst wird, werden alle übereinstimmenden Hooks parallel ausgeführt. Bei Berechtigungsentscheidungen gewinnt das restriktivste Ergebnis: Ein einzelnes `deny` blockiert den Tool-Aufruf, unabhängig davon, was die anderen Hooks zurückgeben. Da die Abschlussreihenfolge nicht deterministisch ist, schreiben Sie jeden Hook so, dass er unabhängig agiert, anstatt sich darauf zu verlassen, dass ein anderer Hook zuerst ausgeführt wurde.

423

424Das folgende Beispiel registriert drei unabhängige Prüfungen für jeden Tool-Aufruf:

423 425

424<CodeGroup>426<CodeGroup>

425 ```python Python theme={null}427 ```python Python theme={null}

426 options = ClaudeAgentOptions(428 options = ClaudeAgentOptions(

427 hooks={429 hooks={

428 "PreToolUse": [430 "PreToolUse": [

429 HookMatcher(hooks=[rate_limiter]), # First: check rate limits431 HookMatcher(hooks=[authorization_check]),

430 HookMatcher(hooks=[authorization_check]), # Second: verify permissions432 HookMatcher(hooks=[input_validator]),

431 HookMatcher(hooks=[input_sanitizer]), # Third: sanitize inputs433 HookMatcher(hooks=[audit_logger]),

432 HookMatcher(hooks=[audit_logger]), # Last: log the action

433 ]434 ]

434 }435 }

435 )436 )

439 const options = {440 const options = {

440 hooks: {441 hooks: {

441 PreToolUse: [442 PreToolUse: [

442 { hooks: [rateLimiter] }, // First: check rate limits443 { hooks: [authorizationCheck] },

443 { hooks: [authorizationCheck] }, // Second: verify permissions444 { hooks: [inputValidator] },

444 { hooks: [inputSanitizer] }, // Third: sanitize inputs445 { hooks: [auditLogger] }

445 { hooks: [auditLogger] } // Last: log the action

446 ]446 ]

447 }447 }

448 };448 };

agent-sdk/migration-guide.md +289 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Migrieren zum Claude Agent SDK

7> Leitfaden für die Migration der Claude Code TypeScript- und Python-SDKs zum Claude Agent SDK

9## Übersicht

11Das Claude Code SDK wurde in das **Claude Agent SDK** umbenannt und seine Dokumentation wurde neu organisiert. Diese Änderung spiegelt die umfassenderen Funktionen des SDKs für die Erstellung von KI-Agenten über reine Codierungsaufgaben hinaus wider.

13## Was hat sich geändert

15| Aspekt | Alt | Neu |

16| :-------------------- | :-------------------------- | :-------------------------------- |

17| **Paketname (TS/JS)** | `@anthropic-ai/claude-code` | `@anthropic-ai/claude-agent-sdk` |

18| **Python-Paket** | `claude-code-sdk` | `claude-agent-sdk` |

19| **Dokumentationsort** | Claude Code-Dokumentation | API-Leitfaden → Agent SDK-Bereich |

21<Note>

22 **Dokumentationsänderungen:** Die Agent SDK-Dokumentation wurde aus der Claude Code-Dokumentation in den API-Leitfaden unter einem dedizierten [Agent SDK](/de/agent-sdk/overview)-Bereich verschoben. Die Claude Code-Dokumentation konzentriert sich nun auf das CLI-Tool und Automatisierungsfunktionen.

23</Note>

25## Migrationsschritte

27### Für TypeScript/JavaScript-Projekte

29**1. Deinstallieren Sie das alte Paket:**

31```bash theme={null}

32npm uninstall @anthropic-ai/claude-code

33```

35**2. Installieren Sie das neue Paket:**

37```bash theme={null}

38npm install @anthropic-ai/claude-agent-sdk

39```

41**3. Aktualisieren Sie Ihre Importe:**

43Ändern Sie alle Importe von `@anthropic-ai/claude-code` zu `@anthropic-ai/claude-agent-sdk`:

45```typescript theme={null}

46// Vorher

47import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-code";

49// Nachher

50import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";

51```

53**4. Aktualisieren Sie die package.json-Abhängigkeiten:**

55Wenn Sie das Paket in Ihrer `package.json` aufgelistet haben, aktualisieren Sie es:

57Vorher:

59```json theme={null}

60{

61 "dependencies": {

62 "@anthropic-ai/claude-code": "^0.0.42"

63 }

64}

65```

67Nachher:

69```json theme={null}

70{

71 "dependencies": {

72 "@anthropic-ai/claude-agent-sdk": "^0.2.0"

73 }

74}

75```

77Das ist alles! Keine weiteren Codeänderungen sind erforderlich.

79### Für Python-Projekte

81**1. Deinstallieren Sie das alte Paket:**

83```bash theme={null}

84pip uninstall claude-code-sdk

85```

87**2. Installieren Sie das neue Paket:**

89```bash theme={null}

90pip install claude-agent-sdk

91```

93**3. Aktualisieren Sie Ihre Importe:**

95Ändern Sie alle Importe von `claude_code_sdk` zu `claude_agent_sdk`:

97```python theme={null}

98# Vorher

99from claude_code_sdk import query, ClaudeCodeOptions

100

101# Nachher

102from claude_agent_sdk import query, ClaudeAgentOptions

103```

104

105**4. Aktualisieren Sie die Typnamen:**

106

107Ändern Sie `ClaudeCodeOptions` zu `ClaudeAgentOptions`:

108

109```python theme={null}

110# Vorher

111from claude_code_sdk import query, ClaudeCodeOptions

112

113options = ClaudeCodeOptions(model="claude-opus-4-7")

114

115# Nachher

116from claude_agent_sdk import query, ClaudeAgentOptions

117

118options = ClaudeAgentOptions(model="claude-opus-4-7")

119```

120

121**5. Überprüfen Sie [Breaking Changes](#breaking-changes)**

122

123Nehmen Sie alle erforderlichen Codeänderungen vor, um die Migration abzuschließen.

124

125## Breaking Changes

126

127<Warning>

128 Um die Isolation und explizite Konfiguration zu verbessern, führt Claude Agent SDK v0.1.0 Breaking Changes für Benutzer ein, die vom Claude Code SDK migrieren. Überprüfen Sie diesen Abschnitt sorgfältig vor der Migration.

129</Warning>

130

131### Python: ClaudeCodeOptions in ClaudeAgentOptions umbenannt

132

133**Was hat sich geändert:** Der Python SDK-Typ `ClaudeCodeOptions` wurde in `ClaudeAgentOptions` umbenannt.

134

135**Migration:**

136

137```python theme={null}

138# VORHER (claude-code-sdk)

139from claude_code_sdk import query, ClaudeCodeOptions

140

141options = ClaudeCodeOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

142

143# NACHHER (claude-agent-sdk)

144from claude_agent_sdk import query, ClaudeAgentOptions

145

146options = ClaudeAgentOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

147```

148

149**Warum sich das geändert hat:** Der Typname entspricht nun dem Branding „Claude Agent SDK" und bietet Konsistenz in den Namenskonventionen des SDKs.

150

151### System-Prompt ist nicht mehr Standard

152

153**Was hat sich geändert:** Das SDK verwendet nicht mehr standardmäßig Claude Codes System-Prompt.

154

155**Migration:**

156

157<CodeGroup>

158 ```typescript TypeScript theme={null}

159 // VORHER (v0.0.x) - Verwendete Claude Codes System-Prompt standardmäßig

160 const result = query({ prompt: "Hello" });

161

162 // NACHHER (v0.1.0) - Verwendet standardmäßig minimalen System-Prompt

163 // Um das alte Verhalten zu erhalten, fordern Sie explizit Claude Codes Voreinstellung an:

164 const result = query({

165 prompt: "Hello",

166 options: {

167 systemPrompt: { type: "preset", preset: "claude_code" }

168 }

169 });

170

171 // Oder verwenden Sie einen benutzerdefinierten System-Prompt:

172 const result = query({

173 prompt: "Hello",

174 options: {

175 systemPrompt: "You are a helpful coding assistant"

176 }

177 });

178 ```

179

180 ```python Python theme={null}

181 # VORHER (v0.0.x) - Verwendete Claude Codes System-Prompt standardmäßig

182 async for message in query(prompt="Hello"):

183 print(message)

184

185 # NACHHER (v0.1.0) - Verwendet standardmäßig minimalen System-Prompt

186 # Um das alte Verhalten zu erhalten, fordern Sie explizit Claude Codes Voreinstellung an:

187 from claude_agent_sdk import query, ClaudeAgentOptions

188

189 async for message in query(

190 prompt="Hello",

191 options=ClaudeAgentOptions(

192 system_prompt={"type": "preset", "preset": "claude_code"} # Verwenden Sie die Voreinstellung

193 ),

194 ):

195 print(message)

196

197 # Oder verwenden Sie einen benutzerdefinierten System-Prompt:

198 async for message in query(

199 prompt="Hello",

200 options=ClaudeAgentOptions(system_prompt="You are a helpful coding assistant"),

201 ):

202 print(message)

203 ```

204</CodeGroup>

205

206**Warum sich das geändert hat:** Bietet bessere Kontrolle und Isolation für SDK-Anwendungen. Sie können nun Agenten mit benutzerdefiniertem Verhalten erstellen, ohne Claude Codes CLI-fokussierte Anweisungen zu erben.

207

208### Einstellungsquellen-Standard

209

210Dieser Standard wurde kurzzeitig in v0.1.0 geändert und dann rückgängig gemacht, daher ist keine Migrationsaktion erforderlich.

211

212**Aktuelles Verhalten:** Das Weglassen von `settingSources` auf `query()` lädt Benutzer-, Projekt- und lokale Dateisystem-Einstellungen, was dem CLI entspricht. Dies umfasst `~/.claude/settings.json`, `.claude/settings.json`, `.claude/settings.local.json`, CLAUDE.md-Dateien und benutzerdefinierte Befehle.

213

214Um isoliert von Dateisystem-Einstellungen zu laufen, übergeben Sie ein leeres Array:

215

216<CodeGroup>

217 ```typescript TypeScript theme={null}

218 const result = query({

219 prompt: "Hello",

220 options: {

221 settingSources: [] // Keine Dateisystem-Einstellungen geladen

222 }

223 });

224

225 // Oder laden Sie nur bestimmte Quellen:

226 const result = query({

227 prompt: "Hello",

228 options: {

229 settingSources: ["project"] // Nur Projekteinstellungen

230 }

231 });

232 ```

233

234 ```python Python theme={null}

235 from claude_agent_sdk import query, ClaudeAgentOptions

236

237 async for message in query(

238 prompt="Hello",

239 options=ClaudeAgentOptions(setting_sources=[]), # Keine Dateisystem-Einstellungen geladen

240 ):

241 print(message)

242

243 # Oder laden Sie nur bestimmte Quellen:

244 async for message in query(

245 prompt="Hello",

246 options=ClaudeAgentOptions(

247 setting_sources=["project"] # Nur Projekteinstellungen

248 ),

249 ):

250 print(message)

251 ```

252</CodeGroup>

253

254Isolation ist besonders wichtig für CI/CD-Pipelines, bereitgestellte Anwendungen, Testumgebungen und Multi-Tenant-Systeme, in denen lokale Anpassungen nicht eindringen sollten.

255

256<Note>

257 SDK v0.1.0 standardmäßig kurzzeitig auf keine geladenen Einstellungen; dies wurde in nachfolgenden Versionen rückgängig gemacht. Python SDK 0.1.59 und früher behandelten eine leere Liste genauso wie das Weglassen der Option, daher aktualisieren Sie vor dem Verlassen auf `setting_sources=[]`. Siehe [Was settingSources nicht kontrolliert](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) für Eingaben, die auch gelesen werden, wenn `settingSources` `[]` ist.

258</Note>

259

260## Warum die Umbenennung?

261

262Das Claude Code SDK wurde ursprünglich für Codierungsaufgaben entwickelt, hat sich aber zu einem leistungsstarken Framework für die Erstellung aller Arten von KI-Agenten entwickelt. Der neue Name „Claude Agent SDK" spiegelt seine Funktionen besser wider:

263

264* Erstellung von Business-Agenten (Rechtsassistenten, Finanzberater, Kundensupport)

265* Erstellung spezialisierter Codierungs-Agenten (SRE-Bots, Sicherheitsprüfer, Code-Review-Agenten)

266* Entwicklung benutzerdefinierter Agenten für jede Domäne mit Tool-Nutzung, MCP-Integration und mehr

267

268## Hilfe erhalten

269

270Wenn Sie während der Migration auf Probleme stoßen:

271

272**Für TypeScript/JavaScript:**

273

2741. Überprüfen Sie, dass alle Importe aktualisiert wurden, um `@anthropic-ai/claude-agent-sdk` zu verwenden

2752. Überprüfen Sie, dass Ihre package.json den neuen Paketnamen hat

2763. Führen Sie `npm install` aus, um sicherzustellen, dass die Abhängigkeiten aktualisiert werden

277

278**Für Python:**

279

2801. Überprüfen Sie, dass alle Importe aktualisiert wurden, um `claude_agent_sdk` zu verwenden

2812. Überprüfen Sie, dass Ihre requirements.txt oder pyproject.toml den neuen Paketnamen hat

2823. Führen Sie `pip install claude-agent-sdk` aus, um sicherzustellen, dass das Paket installiert ist

283

284## Nächste Schritte

285

286* Erkunden Sie die [Agent SDK-Übersicht](/de/agent-sdk/overview), um mehr über verfügbare Funktionen zu erfahren

287* Schauen Sie sich die [TypeScript SDK-Referenz](/de/agent-sdk/typescript) für detaillierte API-Dokumentation an

288* Überprüfen Sie die [Python SDK-Referenz](/de/agent-sdk/python) für Python-spezifische Dokumentation

289* Erfahren Sie mehr über [Benutzerdefinierte Tools](/de/agent-sdk/custom-tools) und [MCP-Integration](/de/agent-sdk/mcp)

agent-sdk/permissions.md +242 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Berechtigungen konfigurieren

7> Kontrollieren Sie, wie Ihr Agent Tools mit Berechtigungsmodi, Hooks und deklarativen Allow/Deny-Regeln verwendet.

9Das Claude Agent SDK bietet Berechtigungskontrollen zur Verwaltung der Tool-Nutzung durch Claude. Verwenden Sie Berechtigungsmodi und Regeln, um zu definieren, was automatisch zulässig ist, und den [`canUseTool`-Callback](/de/agent-sdk/user-input), um alles andere zur Laufzeit zu handhaben.

11<Note>

12 Diese Seite behandelt Berechtigungsmodi und Regeln. Um interaktive Genehmigungsabläufe zu erstellen, bei denen Benutzer Tool-Anfragen zur Laufzeit genehmigen oder ablehnen, siehe [Genehmigungen und Benutzereingaben handhaben](/de/agent-sdk/user-input).

13</Note>

15## Wie Berechtigungen ausgewertet werden

17Wenn Claude ein Tool anfordert, prüft das SDK die Berechtigungen in dieser Reihenfolge:

19<Steps>

20 <Step title="Hooks">

21 Führen Sie [Hooks](/de/agent-sdk/hooks) zuerst aus. Ein Hook kann den Aufruf direkt ablehnen oder ihn weitergeben. Ein Hook, der `allow` zurückgibt, überspringt nicht die Deny- und Ask-Regeln unten; diese werden unabhängig vom Hook-Ergebnis ausgewertet.

22 </Step>

24 <Step title="Deny-Regeln">

25 Prüfen Sie `deny`-Regeln (aus `disallowed_tools` und [settings.json](/de/settings#permission-settings)). Wenn eine Deny-Regel zutrifft, wird das Tool blockiert, auch im `bypassPermissions`-Modus.

26 </Step>

28 <Step title="Berechtigungsmodus">

29 Wenden Sie den aktiven [Berechtigungsmodus](#permission-modes) an. `bypassPermissions` genehmigt alles, das diesen Schritt erreicht. `acceptEdits` genehmigt Dateivorgänge. Andere Modi fallen durch.

30 </Step>

32 <Step title="Allow-Regeln">

33 Prüfen Sie `allow`-Regeln (aus `allowed_tools` und settings.json). Wenn eine Regel zutrifft, wird das Tool genehmigt.

34 </Step>

36 <Step title="canUseTool-Callback">

37 Wenn nicht durch eines der oben genannten Verfahren gelöst, rufen Sie Ihren [`canUseTool`-Callback](/de/agent-sdk/user-input) für eine Entscheidung auf. Im `dontAsk`-Modus wird dieser Schritt übersprungen und das Tool wird abgelehnt.

38 </Step>

39</Steps>

41<img src="https://mintcdn.com/claude-code/FEspvVUyRuaWjm0s/images/agent-sdk/permissions-flow.svg?fit=max&auto=format&n=FEspvVUyRuaWjm0s&q=85&s=a1759b0cf4541281a9fdd8f5348228e8" alt="Diagramm des Berechtigungsauswertungsflusses" width="920" height="260" data-path="images/agent-sdk/permissions-flow.svg" />

43Diese Seite konzentriert sich auf **Allow- und Deny-Regeln** sowie **Berechtigungsmodi**. Für die anderen Schritte:

45* **Hooks:** Führen Sie benutzerdefinierten Code aus, um Tool-Anfragen zu genehmigen, abzulehnen oder zu ändern. Siehe [Ausführung mit Hooks steuern](/de/agent-sdk/hooks).

46* **canUseTool-Callback:** Fordern Sie Benutzer zur Laufzeit zur Genehmigung auf. Siehe [Genehmigungen und Benutzereingaben handhaben](/de/agent-sdk/user-input).

48## Allow- und Deny-Regeln

50`allowed_tools` und `disallowed_tools` (TypeScript: `allowedTools` / `disallowedTools`) fügen Einträge zu den Allow- und Deny-Regellisten im obigen Auswertungsfluss hinzu. Sie steuern, ob ein Tool-Aufruf genehmigt wird, nicht ob das Tool für Claude verfügbar ist.

52| Option | Auswirkung |

53| :------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

54| `allowed_tools=["Read", "Grep"]` | `Read` und `Grep` werden automatisch genehmigt. Tools, die hier nicht aufgelistet sind, existieren immer noch und fallen durch zum Berechtigungsmodus und `canUseTool`. |

55| `disallowed_tools=["Bash"]` | `Bash` wird immer abgelehnt. Deny-Regeln werden zuerst geprüft und gelten in jedem Berechtigungsmodus, einschließlich `bypassPermissions`. |

57Für einen gesperrten Agent kombinieren Sie `allowedTools` mit `permissionMode: "dontAsk"`. Aufgelistete Tools werden genehmigt; alles andere wird direkt abgelehnt, anstatt zu fragen:

59```typescript theme={null}

60const options = {

61 allowedTools: ["Read", "Glob", "Grep"],

62 permissionMode: "dontAsk"

63};

64```

66<Warning>

67 **`allowed_tools` beschränkt `bypassPermissions` nicht.** `allowed_tools` genehmigt nur die Tools, die Sie aufgelistet haben. Nicht aufgelistete Tools werden von keiner Allow-Regel erfasst und fallen durch zum Berechtigungsmodus, wo `bypassPermissions` sie genehmigt. Das Setzen von `allowed_tools=["Read"]` zusammen mit `permission_mode="bypassPermissions"` genehmigt immer noch jedes Tool, einschließlich `Bash`, `Write` und `Edit`. Wenn Sie `bypassPermissions` benötigen, aber bestimmte Tools blockieren möchten, verwenden Sie `disallowed_tools`.

68</Warning>

70Sie können Allow-, Deny- und Ask-Regeln auch deklarativ in `.claude/settings.json` konfigurieren. Diese Regeln werden gelesen, wenn die `project`-Einstellungsquelle aktiviert ist, was sie für Standard-`query()`-Optionen ist. Wenn Sie `setting_sources` (TypeScript: `settingSources`) explizit setzen, fügen Sie `"project"` ein, damit sie angewendet werden. Siehe [Berechtigungseinstellungen](/de/settings#permission-settings) für die Regelsyntax.

72## Berechtigungsmodi

74Berechtigungsmodi bieten globale Kontrolle über die Tool-Nutzung durch Claude. Sie können den Berechtigungsmodus beim Aufrufen von `query()` setzen oder ihn dynamisch während Streaming-Sitzungen ändern.

76### Verfügbare Modi

78Das SDK unterstützt diese Berechtigungsmodi:

80| Modus | Beschreibung | Tool-Verhalten |

81| :---------------------- | :----------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- |

82| `default` | Standardberechtigungsverhalten | Keine automatischen Genehmigungen; nicht übereinstimmende Tools lösen Ihren `canUseTool`-Callback aus |

83| `dontAsk` | Ablehnung statt Nachfrage | Alles, das nicht von `allowed_tools` oder Regeln vorab genehmigt ist, wird abgelehnt; `canUseTool` wird nie aufgerufen |

84| `acceptEdits` | Dateibearbeitungen automatisch akzeptieren | Dateibearbeitungen und [Dateisystemvorgänge](#accept-edits-mode-acceptedits) (`mkdir`, `rm`, `mv` usw.) werden automatisch genehmigt |

85| `bypassPermissions` | Alle Berechtigungsprüfungen umgehen | Alle Tools werden ohne Berechtigungsaufforderungen ausgeführt (mit Vorsicht verwenden) |

86| `plan` | Planungsmodus | Schreibgeschützte Tools werden ausgeführt; Claude analysiert und plant, ohne Ihre Quelldateien zu bearbeiten |

87| `auto` (nur TypeScript) | Modellklassifizierte Genehmigungen | Ein Modellklassifizierer genehmigt oder lehnt jeden Tool-Aufruf ab. Siehe [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) für Verfügbarkeit |

89<Warning>

90 **Subagent-Vererbung:** Wenn der übergeordnete Agent `bypassPermissions`, `acceptEdits` oder `auto` verwendet, erben alle Subagents diesen Modus und er kann nicht pro Subagent überschrieben werden. Subagents können unterschiedliche Systemaufforderungen und weniger eingeschränktes Verhalten als Ihr Hauptagent haben, daher erbt `bypassPermissions` ihnen vollständigen, autonomen Systemzugriff ohne Genehmigungsaufforderungen.

91</Warning>

93### Berechtigungsmodus setzen

95Sie können den Berechtigungsmodus einmal beim Starten einer Abfrage setzen oder ihn dynamisch ändern, während die Sitzung aktiv ist.

97<Tabs>

98 <Tab title="Zur Abfragezeit">

99 Übergeben Sie `permission_mode` (Python) oder `permissionMode` (TypeScript) beim Erstellen einer Abfrage. Dieser Modus gilt für die gesamte Sitzung, es sei denn, er wird dynamisch geändert.

100

101 <CodeGroup>

102 ```python Python theme={null}

103 import asyncio

104 from claude_agent_sdk import query, ClaudeAgentOptions

105

106

107 async def main():

108 async for message in query(

109 prompt="Help me refactor this code",

110 options=ClaudeAgentOptions(

111 permission_mode="default", # Set the mode here

112 ),

113 ):

114 if hasattr(message, "result"):

115 print(message.result)

116

117

118 asyncio.run(main())

119 ```

120

121 ```typescript TypeScript theme={null}

122 import { query } from "@anthropic-ai/claude-agent-sdk";

123

124 async function main() {

125 for await (const message of query({

126 prompt: "Help me refactor this code",

127 options: {

128 permissionMode: "default" // Set the mode here

129 }

130 })) {

131 if ("result" in message) {

132 console.log(message.result);

133 }

134 }

135 }

136

137 main();

138 ```

139 </CodeGroup>

140 </Tab>

141

142 <Tab title="Während des Streaming">

143 Rufen Sie `set_permission_mode()` (Python) oder `setPermissionMode()` (TypeScript) auf, um den Modus während der Sitzung zu ändern. Der neue Modus wird sofort für alle nachfolgenden Tool-Anfragen wirksam. Dies ermöglicht es Ihnen, restriktiv zu beginnen und Berechtigungen zu lockern, wenn Vertrauen aufgebaut wird, z. B. zum Wechsel zu `acceptEdits` nach Überprüfung von Claudes anfänglichem Ansatz.

144

145 <CodeGroup>

146 ```python Python theme={null}

147 import asyncio

148 from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

149

150

151 async def main():

152 async with ClaudeSDKClient(

153 options=ClaudeAgentOptions(

154 permission_mode="default", # Start in default mode

155 )

156 ) as client:

157 await client.query("Help me refactor this code")

158

159 # Change mode dynamically mid-session

160 await client.set_permission_mode("acceptEdits")

161

162 # Process messages with the new permission mode

163 async for message in client.receive_response():

164 if hasattr(message, "result"):

165 print(message.result)

166

167

168 asyncio.run(main())

169 ```

170

171 ```typescript TypeScript theme={null}

172 import { query } from "@anthropic-ai/claude-agent-sdk";

173

174 async function main() {

175 const q = query({

176 prompt: "Help me refactor this code",

177 options: {

178 permissionMode: "default" // Start in default mode

179 }

180 });

181

182 // Change mode dynamically mid-session

183 await q.setPermissionMode("acceptEdits");

184

185 // Process messages with the new permission mode

186 for await (const message of q) {

187 if ("result" in message) {

188 console.log(message.result);

189 }

190 }

191 }

192

193 main();

194 ```

195 </CodeGroup>

196 </Tab>

197</Tabs>

198

199### Modusdetails

200

201#### Accept Edits-Modus (`acceptEdits`)

202

203Genehmigt automatisch Dateivorgänge, damit Claude Code ohne Aufforderung bearbeiten kann. Andere Tools (wie Bash-Befehle, die keine Dateisystemvorgänge sind) erfordern weiterhin normale Berechtigungen.

204

205**Automatisch genehmigte Vorgänge:**

206

207* Dateibearbeitungen (Edit-, Write-Tools)

208* Dateisystembefehle: `mkdir`, `touch`, `rm`, `rmdir`, `mv`, `cp`, `sed`

209

210Beide gelten nur für Pfade innerhalb des Arbeitsverzeichnisses oder `additionalDirectories`. Pfade außerhalb dieses Bereichs und Schreibvorgänge auf geschützte Pfade werden weiterhin angefordert.

211

212**Verwenden Sie, wenn:** Sie Claudes Bearbeitungen vertrauen und schnellere Iteration wünschen, z. B. während der Prototypenerstellung oder beim Arbeiten in einem isolierten Verzeichnis.

213

214#### Don't Ask-Modus (`dontAsk`)

215

216Konvertiert jede Berechtigungsaufforderung in eine Ablehnung. Tools, die von `allowed_tools`, `settings.json`-Allow-Regeln oder einem Hook vorab genehmigt sind, werden normal ausgeführt. Alles andere wird abgelehnt, ohne `canUseTool` aufzurufen.

217

218**Verwenden Sie, wenn:** Sie eine feste, explizite Tool-Oberfläche für einen Headless-Agent wünschen und eine harte Ablehnung gegenüber stiller Abhängigkeit von fehlender `canUseTool` bevorzugen.

219

220#### Bypass Permissions-Modus (`bypassPermissions`)

221

222Genehmigt automatisch alle Tool-Nutzungen ohne Aufforderungen. Hooks werden weiterhin ausgeführt und können Vorgänge bei Bedarf blockieren.

223

224<Warning>

225 Mit äußerster Vorsicht verwenden. Claude hat in diesem Modus vollständigen Systemzugriff. Verwenden Sie nur in kontrollierten Umgebungen, in denen Sie allen möglichen Vorgängen vertrauen.

226

227 `allowed_tools` beschränkt diesen Modus nicht. Jedes Tool wird genehmigt, nicht nur die, die Sie aufgelistet haben. Deny-Regeln (`disallowed_tools`), explizite `ask`-Regeln und Hooks werden vor der Modusüberprüfung ausgewertet und können ein Tool immer noch blockieren.

228</Warning>

229

230#### Plan-Modus (`plan`)

231

232Beschränkt Claude auf schreibgeschützte Tools. Claude kann Dateien lesen und schreibgeschützte Shell-Befehle ausführen, um die Codebasis zu erkunden, bearbeitet aber nicht Ihre Quelldateien. Claude kann `AskUserQuestion` verwenden, um Anforderungen zu klären, bevor der Plan abgeschlossen wird. Siehe [Genehmigungen und Benutzereingaben handhaben](/de/agent-sdk/user-input#handle-clarifying-questions) für die Behandlung dieser Aufforderungen.

233

234**Verwenden Sie, wenn:** Sie möchten, dass Claude Änderungen vorschlägt, ohne sie auszuführen, z. B. während der Code-Überprüfung oder wenn Sie Änderungen genehmigen müssen, bevor sie vorgenommen werden.

235

236## Verwandte Ressourcen

237

238Für die anderen Schritte im Berechtigungsauswertungsfluss:

239

240* [Genehmigungen und Benutzereingaben handhaben](/de/agent-sdk/user-input): interaktive Genehmigungsaufforderungen und Klärungsfragen

241* [Hooks-Anleitung](/de/agent-sdk/hooks): Führen Sie benutzerdefinierten Code an Schlüsselpunkten im Agent-Lebenszyklus aus

242* [Berechtigungsregeln](/de/settings#permission-settings): deklarative Allow/Deny-Regeln in `settings.json`

agent-sdk/python.md +39 −37

Details

113#### Parameter113#### Parameter

114 114

115| Parameter | Typ | Beschreibung |115| Parameter | Typ | Beschreibung |

116| :------------- | :----------------------------------------------- | :------------------------------------------------------------------------------- |116| :------------- | :---------------------------------------------- | :------------------------------------------------------------------------------- |

117| `name` | `str` | Eindeutige Kennung für das Tool |117| `name` | `str` | Eindeutige Kennung für das Tool |

118| `description` | `str` | Lesbare Beschreibung, was das Tool tut |118| `description` | `str` | Lesbare Beschreibung, was das Tool tut |

121 121

122#### Eingabeschema-Optionen122#### Eingabeschema-Optionen

123 123

253| :------------------ | :------------ | :------- | :---------------------------------------------------------------------------------------------------------------------------- |253| :------------------ | :------------ | :------- | :---------------------------------------------------------------------------------------------------------------------------- |

257 257

258#### Rückgabetyp: `SDKSessionInfo`258#### Rückgabetyp: `SDKSessionInfo`

259 259

269| `cwd` | `str \| None` | Arbeitsverzeichnis für die Sitzung |269| `cwd` | `str \| None` | Arbeitsverzeichnis für die Sitzung |

270| `tag` | `str \| None` | Vom Benutzer festgelegtes Sitzungs-Tag (siehe [`tag_session()`](#tag-session)) |270| `tag` | `str \| None` | Vom Benutzer festgelegtes Sitzungs-Tag (siehe [`tag_session()`](#tag_session)) |

272 272

273#### Beispiel273#### Beispiel

345 345

346Gibt [`SDKSessionInfo`](#return-type-sdk-session-info) zurück, oder `None`, wenn die Sitzung nicht gefunden wird.346Gibt [`SDKSessionInfo`](#return-type-sdksessioninfo) zurück, oder `None`, wenn die Sitzung nicht gefunden wird.

347 347

348#### Beispiel348#### Beispiel

349 349

381 381

382#### Beispiel382#### Beispiel

383 383

384Benennen Sie die neueste Sitzung um, damit sie später leichter zu finden ist. Der neue Titel wird in [`SDKSessionInfo.custom_title`](#return-type-sdk-session-info) bei nachfolgenden Lesevorgängen angezeigt.384Benennen Sie die neueste Sitzung um, damit sie später leichter zu finden ist. Der neue Titel wird in [`SDKSessionInfo.custom_title`](#return-type-sdksessioninfo) bei nachfolgenden Lesevorgängen angezeigt.

385 385

386```python theme={null}386```python theme={null}

387from claude_agent_sdk import list_sessions, rename_session387from claude_agent_sdk import list_sessions, rename_session

477| `set_model(model)` | Ändern Sie das Modell für die aktuelle Sitzung. Übergeben Sie `None`, um auf Standard zurückzusetzen |477| `set_model(model)` | Ändern Sie das Modell für die aktuelle Sitzung. Übergeben Sie `None`, um auf Standard zurückzusetzen |

478| `rewind_files(user_message_id)` | Stellen Sie Dateien in ihren Zustand bei der angegebenen Benutzernachricht wieder her. Erfordert `enable_file_checkpointing=True`. Siehe [Datei-Checkpointing](/de/agent-sdk/file-checkpointing) |478| `rewind_files(user_message_id)` | Stellen Sie Dateien in ihren Zustand bei der angegebenen Benutzernachricht wieder her. Erfordert `enable_file_checkpointing=True`. Siehe [Datei-Checkpointing](/de/agent-sdk/file-checkpointing) |

479| `get_mcp_status()` | Rufen Sie den Status aller konfigurierten MCP-Server ab. Gibt [`McpStatusResponse`](#mcp-status-response) zurück |479| `get_mcp_status()` | Rufen Sie den Status aller konfigurierten MCP-Server ab. Gibt [`McpStatusResponse`](#mcpstatusresponse) zurück |

480| `reconnect_mcp_server(server_name)` | Versuchen Sie, eine Verbindung zu einem MCP-Server herzustellen, der fehlgeschlagen ist oder getrennt wurde |480| `reconnect_mcp_server(server_name)` | Versuchen Sie, eine Verbindung zu einem MCP-Server herzustellen, der fehlgeschlagen ist oder getrennt wurde |

481| `toggle_mcp_server(server_name, enabled)` | Aktivieren oder deaktivieren Sie einen MCP-Server während der Sitzung. Das Deaktivieren entfernt seine Tools |481| `toggle_mcp_server(server_name, enabled)` | Aktivieren oder deaktivieren Sie einen MCP-Server während der Sitzung. Das Deaktivieren entfernt seine Tools |

482| `stop_task(task_id)` | Stoppen Sie eine laufende Hintergrundaufgabe. Eine [`TaskNotificationMessage`](#task-notification-message) mit Status `"stopped"` folgt im Nachrichtenstrom |482| `stop_task(task_id)` | Stoppen Sie eine laufende Hintergrundaufgabe. Eine [`TaskNotificationMessage`](#tasknotificationmessage) mit Status `"stopped"` folgt im Nachrichtenstrom |

485 485

791 effort: Literal["low", "medium", "high", "max"] | None = None791 effort: Literal["low", "medium", "high", "max"] | None = None

792 enable_file_checkpointing: bool = False792 enable_file_checkpointing: bool = False

793 session_store: SessionStore | None = None793 session_store: SessionStore | None = None

794 session_store_flush: SessionStoreFlushMode = "batched"

794```795```

795 796

796| Eigenschaft | Typ | Standard | Beschreibung |797| Eigenschaft | Typ | Standard | Beschreibung |

797| :---------------------------- | :------------------------------------------------------------------------------------- | :---------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |798| :---------------------------- | :------------------------------------------------------------------------------------ | :---------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

798| `tools` | `list[str] \| ToolsPreset \| None` | `None` | Tools-Konfiguration. Verwenden Sie `{"type": "preset", "preset": "claude_code"}` für die Standard-Tools von Claude Code |799| `tools` | `list[str] \| ToolsPreset \| None` | `None` | Tools-Konfiguration. Verwenden Sie `{"type": "preset", "preset": "claude_code"}` für die Standard-Tools von Claude Code |

799| `allowed_tools` | `list[str]` | `[]` | Tools, die automatisch genehmigt werden, ohne zu fragen. Dies beschränkt Claude nicht nur auf diese Tools; nicht aufgelistete Tools fallen durch `permission_mode` und `can_use_tool`. Verwenden Sie `disallowed_tools`, um Tools zu blockieren. Siehe [Berechtigungen](/de/agent-sdk/permissions#allow-and-deny-rules) |800| `allowed_tools` | `list[str]` | `[]` | Tools, die automatisch genehmigt werden, ohne zu fragen. Dies beschränkt Claude nicht nur auf diese Tools; nicht aufgelistete Tools fallen durch `permission_mode` und `can_use_tool`. Verwenden Sie `disallowed_tools`, um Tools zu blockieren. Siehe [Berechtigungen](/de/agent-sdk/permissions#allow-and-deny-rules) |

800| `system_prompt` | `str \| SystemPromptPreset \| None` | `None` | System-Prompt-Konfiguration. Übergeben Sie eine Zeichenkette für einen benutzerdefinierten Prompt, oder verwenden Sie `{"type": "preset", "preset": "claude_code"}` für den System-Prompt von Claude Code. Fügen Sie `"append"` hinzu, um den Preset zu erweitern |801| `system_prompt` | `str \| SystemPromptPreset \| None` | `None` | System-Prompt-Konfiguration. Übergeben Sie eine Zeichenkette für einen benutzerdefinierten Prompt, oder verwenden Sie `{"type": "preset", "preset": "claude_code"}` für den System-Prompt von Claude Code. Fügen Sie `"append"` hinzu, um den Preset zu erweitern |

812| `output_format` | `dict[str, Any] \| None` | `None` | Ausgabeformat für strukturierte Antworten (z. B. `{"type": "json_schema", "schema": {...}}`). Siehe [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs) für Details |813| `output_format` | `dict[str, Any] \| None` | `None` | Ausgabeformat für strukturierte Antworten (z. B. `{"type": "json_schema", "schema": {...}}`). Siehe [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs) für Details |

814| `cwd` | `str \| Path \| None` | `None` | Aktuelles Arbeitsverzeichnis |815| `cwd` | `str \| Path \| None` | `None` | Aktuelles Arbeitsverzeichnis |

831| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI-Standard: alle Quellen) | Kontrollieren Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |832| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI-Standard: alle Quellen) | Kontrollieren Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

835| `session_store` | [`SessionStore`](/de/agent-sdk/session-storage#the-session-store-interface) ` \| None` | `None` | Spiegeln Sie Sitzungstranskripte zu einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher beibehalten](/de/agent-sdk/session-storage) |836| `session_store` | [`SessionStore`](/de/agent-sdk/session-storage#the-sessionstore-interface) ` \| None` | `None` | Spiegeln Sie Sitzungstranskripte zu einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher beibehalten](/de/agent-sdk/session-storage) |

837| `session_store_flush` | `Literal["batched", "eager"]` | `"batched"` | Wann sollen gespiegelte Transkripteinträge zu `session_store` geleert werden. `"batched"` leert einmal pro Umdrehung oder wenn der Puffer voll wird; `"eager"` löst nach jedem Frame einen Hintergrund-Flush aus. Wird ignoriert, wenn `session_store` `None` ist |

836 838

837### `OutputFormat`839### `OutputFormat`

838 840

1035 1037

1036<Note>1038<Note>

1037 `AgentDefinition`-Feldnamen verwenden camelCase, wie `disallowedTools`, `permissionMode` und `maxTurns`. Diese Namen werden direkt dem Drahtformat zugeordnet, das mit dem TypeScript SDK geteilt wird. Dies unterscheidet sich von `ClaudeAgentOptions`, das Python snake\_case für die entsprechenden Top-Level-Felder wie `disallowed_tools` und `permission_mode` verwendet. Da `AgentDefinition` eine Dataclass ist, wirft das Übergeben eines snake\_case-Schlüsselworts einen `TypeError` zur Konstruktionszeit auf.1039 `AgentDefinition`-Feldnamen verwenden camelCase, wie `disallowedTools`, `permissionMode` und `maxTurns`. Diese Namen werden direkt dem Drahtformat zugeordnet, das mit dem TypeScript SDK geteilt wird. Dies unterscheidet sich von `ClaudeAgentOptions`, das Python snake\_case für die entsprechenden Top-Level-Felder wie `disallowed_tools` und `permission_mode` verwendet. Da `AgentDefinition` eine Dataclass ist, wirft das Übergeben eines snake\_case-Schlüsselworts einen `TypeError` zur Konstruktionszeit auf.

1045PermissionMode = Literal[1047PermissionMode = Literal[

1046 "default", # Standard permission behavior1048 "default", # Standard permission behavior

1047 "acceptEdits", # Auto-accept file edits1049 "acceptEdits", # Auto-accept file edits

1048 "plan", # Planning mode - no execution1050 "plan", # Planning mode - read-only tools only

1049 "dontAsk", # Deny anything not pre-approved instead of prompting1051 "dontAsk", # Deny anything not pre-approved instead of prompting

1050 "bypassPermissions", # Bypass all permission checks (use with caution)1052 "bypassPermissions", # Bypass all permission checks (use with caution)

1051]1053]

1081```1083```

1082 1084

1083| Feld | Typ | Beschreibung |1085| Feld | Typ | Beschreibung |

1084| :------------ | :----------------------- | :--------------------------------------------------- |1086| :------------ | :----------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1086| `suggestions` | `list[PermissionUpdate]` | Berechtigungsaktualisierungsvorschläge von der CLI |1088| `suggestions` | `list[PermissionUpdate]` | Berechtigungsaktualisierungsvorschläge von der CLI. Bash-Aufforderungen enthalten einen Vorschlag mit dem `localSettings`-Ziel, daher gibt das Zurückgeben in `updated_permissions` die Regel in `.claude/settings.local.json` aus und bleibt über Sitzungen hinweg bestehen. |

1087 1089

1088### `PermissionResult`1090### `PermissionResult`

1089 1091

1289 1291

1290### `McpServerStatusConfig`1292### `McpServerStatusConfig`

1291 1293

1292Die Konfiguration eines MCP-Servers, wie von [`get_mcp_status()`](#methods) gemeldet. Dies ist die Union aller [`McpServerConfig`](#mcp-server-config)-Transport-Varianten plus eine nur-Ausgabe-`claudeai-proxy`-Variante für Server, die durch claude.ai proxiert werden.1294Die Konfiguration eines MCP-Servers, wie von [`get_mcp_status()`](#methods) gemeldet. Dies ist die Union aller [`McpServerConfig`](#mcpserverconfig)-Transport-Varianten plus eine nur-Ausgabe-`claudeai-proxy`-Variante für Server, die durch claude.ai proxiert werden.

1293 1295

1294```python theme={null}1296```python theme={null}

1295McpServerStatusConfig = (1297McpServerStatusConfig = (

1301)1303)

1302```1304```

1303 1305

1304`McpSdkServerConfigStatus` ist die serialisierbare Form von [`McpSdkServerConfig`](#mcp-sdk-server-config) mit nur `type` (`"sdk"`) und `name` (`str`)-Feldern; die In-Process-`instance` wird weggelassen. `McpClaudeAIProxyServerConfig` hat `type` (`"claudeai-proxy"`), `url` (`str`) und `id` (`str`)-Felder.1306`McpSdkServerConfigStatus` ist die serialisierbare Form von [`McpSdkServerConfig`](#mcpsdkserverconfig) mit nur `type` (`"sdk"`) und `name` (`str`)-Feldern; die In-Process-`instance` wird weggelassen. `McpClaudeAIProxyServerConfig` hat `type` (`"claudeai-proxy"`), `url` (`str`) und `id` (`str`)-Felder.

1305 1307

1306### `McpStatusResponse`1308### `McpStatusResponse`

1307 1309

1314 1316

1315### `McpServerStatus`1317### `McpServerStatus`

1316 1318

1317Status eines verbundenen MCP-Servers, enthalten in [`McpStatusResponse`](#mcp-status-response).1319Status eines verbundenen MCP-Servers, enthalten in [`McpStatusResponse`](#mcpstatusresponse).

1318 1320

1319```python theme={null}1321```python theme={null}

1320class McpServerStatus(TypedDict):1322class McpServerStatus(TypedDict):

1328```1330```

1329 1331

1330| Feld | Typ | Beschreibung |1332| Feld | Typ | Beschreibung |

1331| :----------- | :-------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |1333| :----------- | :----------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

1332| `name` | `str` | Servername |1334| `name` | `str` | Servername |

1333| `status` | `str` | Einer von `"connected"`, `"failed"`, `"needs-auth"`, `"pending"` oder `"disabled"` |1335| `status` | `str` | Einer von `"connected"`, `"failed"`, `"needs-auth"`, `"pending"` oder `"disabled"` |

1334| `serverInfo` | `dict` (optional) | Servername und Version (`{"name": str, "version": str}`) |1336| `serverInfo` | `dict` (optional) | Servername und Version (`{"name": str, "version": str}`) |

1336| `config` | [`McpServerStatusConfig`](#mcp-server-status-config) (optional) | Server-Konfiguration. Gleiche Form wie [`McpServerConfig`](#mcp-server-config) (stdio, SSE, HTTP oder SDK), plus eine `claudeai-proxy`-Variante für Server, die über claude.ai verbunden sind |1338| `config` | [`McpServerStatusConfig`](#mcpserverstatusconfig) (optional) | Server-Konfiguration. Gleiche Form wie [`McpServerConfig`](#mcpserverconfig) (stdio, SSE, HTTP oder SDK), plus eine `claudeai-proxy`-Variante für Server, die über claude.ai verbunden sind |

1339 1341

1416```1418```

1417 1419

1418| Feld | Typ | Beschreibung |1420| Feld | Typ | Beschreibung |

1419| :------------------- | :------------------------------------------------------------- | :------------------------------------------------------------------------------------------- |1421| :------------------- | :----------------------------------------------------------- | :------------------------------------------------------------------------------------------ |

1421| `model` | `str` | Modell, das die Antwort generiert hat |1423| `model` | `str` | Modell, das die Antwort generiert hat |

1426 1428

1427### `AssistantMessageError`1429### `AssistantMessageError`

1481| `cache_creation_input_tokens` | `int` | Token, die zum Erstellen neuer Cache-Einträge verwendet wurden. |1483| `cache_creation_input_tokens` | `int` | Token, die zum Erstellen neuer Cache-Einträge verwendet wurden. |

1482| `cache_read_input_tokens` | `int` | Token, die aus vorhandenen Cache-Einträgen gelesen wurden. |1484| `cache_read_input_tokens` | `int` | Token, die aus vorhandenen Cache-Einträgen gelesen wurden. |

1483 1485

1484Das `model_usage`-Dict ordnet Modellnamen der Nutzung pro Modell zu. Die inneren Dict-Schlüssel verwenden camelCase, da der Wert unverändert vom zugrunde liegenden CLI-Prozess übergeben wird und dem TypeScript [`ModelUsage`](/de/agent-sdk/typescript#model-usage)-Typ entspricht:1486Das `model_usage`-Dict ordnet Modellnamen der Nutzung pro Modell zu. Die inneren Dict-Schlüssel verwenden camelCase, da der Wert unverändert vom zugrunde liegenden CLI-Prozess übergeben wird und dem TypeScript [`ModelUsage`](/de/agent-sdk/typescript#modelusage)-Typ entspricht:

1485 1487

1486| Schlüssel | Typ | Beschreibung |1488| Schlüssel | Typ | Beschreibung |

1487| -------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |1489| -------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1489| `outputTokens` | `int` | Ausgabe-Token für dieses Modell. |1491| `outputTokens` | `int` | Ausgabe-Token für dieses Modell. |

1490| `cacheReadInputTokens` | `int` | Cache-Lese-Token für dieses Modell. |1492| `cacheReadInputTokens` | `int` | Cache-Lese-Token für dieses Modell. |

1491| `cacheCreationInputTokens` | `int` | Cache-Erstellungs-Token für dieses Modell. |1493| `cacheCreationInputTokens` | `int` | Cache-Erstellungs-Token für dieses Modell. |

1492| `webSearchRequests` | `int` | Webbsuche-Anfragen, die von diesem Modell gestellt wurden. |1494| `webSearchRequests` | `int` | Websuch-Anfragen, die von diesem Modell gestellt wurden. |

1493| `costUSD` | `float` | Geschätzte Kosten in USD für dieses Modell, clientseitig berechnet. Siehe [Kosten und Nutzung verfolgen](/de/agent-sdk/cost-tracking) für Abrechnungsvorbehalt. |1495| `costUSD` | `float` | Geschätzte Kosten in USD für dieses Modell, clientseitig berechnet. Siehe [Kosten und Nutzung verfolgen](/de/agent-sdk/cost-tracking) für Abrechnungsvorbehalt. |

1494| `contextWindow` | `int` | Kontextfenstergröße für dieses Modell. |1496| `contextWindow` | `int` | Kontextfenstergröße für dieses Modell. |

1495| `maxOutputTokens` | `int` | Maximale Ausgabe-Token-Grenze für dieses Modell. |1497| `maxOutputTokens` | `int` | Maximale Ausgabe-Token-Grenze für dieses Modell. |

1527```1529```

1528 1530

1529| Feld | Typ | Beschreibung |1531| Feld | Typ | Beschreibung |

1530| :---------------- | :---------------------------------- | :-------------------------- |1532| :---------------- | :-------------------------------- | :-------------------------- |

1532| `uuid` | `str` | Eindeutige Ereigniskennung |1534| `uuid` | `str` | Eindeutige Ereigniskennung |

1533| `session_id` | `str` | Sitzungskennung |1535| `session_id` | `str` | Sitzungskennung |

1534 1536

1535### `RateLimitInfo`1537### `RateLimitInfo`

1536 1538

1537Rate-Limit-Status, den [`RateLimitEvent`](#rate-limit-event) trägt.1539Rate-Limit-Status, den [`RateLimitEvent`](#ratelimitevent) trägt.

1538 1540

1539```python theme={null}1541```python theme={null}

1540RateLimitStatus = Literal["allowed", "allowed_warning", "rejected"]1542RateLimitStatus = Literal["allowed", "allowed_warning", "rejected"]

1812 1814

1813Parameter:1815Parameter:

1814 1816

1815* `input`: Stark typisierte Hook-Eingabe mit diskriminierten Unions basierend auf `hook_event_name` (siehe [`HookInput`](#hook-input))1817* `input`: Stark typisierte Hook-Eingabe mit diskriminierten Unions basierend auf `hook_event_name` (siehe [`HookInput`](#hookinput))

1816* `tool_use_id`: Optionale Tool-Use-Kennung (für Tool-bezogene Hooks)1818* `tool_use_id`: Optionale Tool-Use-Kennung (für Tool-bezogene Hooks)

1817* `context`: Hook-Kontext mit zusätzlichen Informationen1819* `context`: Hook-Kontext mit zusätzlichen Informationen

1818 1820

1819Gibt ein [`HookJSONOutput`](#hook-json-output) zurück, das enthalten kann:1821Gibt ein [`HookJSONOutput`](#hookjsonoutput) zurück, das enthalten kann:

1820 1822

1821* `decision`: `"block"`, um die Aktion zu blockieren1823* `decision`: `"block"`, um die Aktion zu blockieren

1822* `systemMessage`: System-Nachricht, die zum Transkript hinzugefügt werden soll1824* `systemMessage`: System-Nachricht, die zum Transkript hinzugefügt werden soll

3109```3111```

3110 3112

3111| Eigenschaft | Typ | Standard | Beschreibung |3113| Eigenschaft | Typ | Standard | Beschreibung |

3112| :-------------------------- | :------------------------------------------------------ | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |3114| :-------------------------- | :---------------------------------------------------- | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

3116| `allowUnsandboxedCommands` | `bool` | `True` | Erlauben Sie dem Modell, die Ausführung von Befehlen außerhalb der Sandbox anzufordern. Wenn `True`, kann das Modell `dangerouslyDisableSandbox` in der Tool-Eingabe setzen, was auf das [Berechtigungssystem](#permissions-fallback-for-unsandboxed-commands) zurückfällt |3118| `allowUnsandboxedCommands` | `bool` | `True` | Erlauben Sie dem Modell, die Ausführung von Befehlen außerhalb der Sandbox anzufordern. Wenn `True`, kann das Modell `dangerouslyDisableSandbox` in der Tool-Eingabe setzen, was auf das [Berechtigungssystem](#permissions-fallback-for-unsandboxed-commands) zurückfällt |

3120 3122

3121#### Beispielverwendung3123#### Beispielverwendung

agent-sdk/streaming-output.md +396 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Antworten in Echtzeit streamen

7> Erhalten Sie Echtzeit-Antworten vom Agent SDK, während Text und Tool-Aufrufe gestreamt werden

9Standardmäßig liefert das Agent SDK vollständige `AssistantMessage`-Objekte, nachdem Claude die Generierung jeder Antwort abgeschlossen hat. Um inkrementelle Aktualisierungen zu erhalten, während Text und Tool-Aufrufe generiert werden, aktivieren Sie das Streaming von Teillmeldungen, indem Sie `include_partial_messages` (Python) oder `includePartialMessages` (TypeScript) in Ihren Optionen auf `true` setzen.

11<Tip>

12 Diese Seite behandelt das Ausgabe-Streaming (Empfangen von Token in Echtzeit). Informationen zu Eingabemodi (wie Sie Nachrichten senden), finden Sie unter [Nachrichten an Agenten senden](/de/agent-sdk/streaming-vs-single-mode). Sie können auch [Antworten mit dem Agent SDK über die CLI streamen](/de/headless).

13</Tip>

15## Ausgabe-Streaming aktivieren

17Um Streaming zu aktivieren, setzen Sie `include_partial_messages` (Python) oder `includePartialMessages` (TypeScript) in Ihren Optionen auf `true`. Dies führt dazu, dass das SDK `StreamEvent`-Nachrichten mit rohen API-Ereignissen liefert, die ankommen, zusätzlich zu den üblichen `AssistantMessage`- und `ResultMessage`-Objekten.

19Ihr Code muss dann:

211. Den Typ jeder Nachricht überprüfen, um `StreamEvent` von anderen Nachrichtentypen zu unterscheiden

222. Für `StreamEvent` das Feld `event` extrahieren und seinen `type` überprüfen

233. Nach `content_block_delta`-Ereignissen suchen, bei denen `delta.type` gleich `text_delta` ist, die die tatsächlichen Text-Chunks enthalten

25Das folgende Beispiel aktiviert Streaming und gibt Text-Chunks aus, während sie ankommen. Beachten Sie die verschachtelten Typüberprüfungen: zuerst für `StreamEvent`, dann für `content_block_delta`, dann für `text_delta`:

27<CodeGroup>

28 ```python Python theme={null}

29 from claude_agent_sdk import query, ClaudeAgentOptions

30 from claude_agent_sdk.types import StreamEvent

31 import asyncio

34 async def stream_response():

35 options = ClaudeAgentOptions(

36 include_partial_messages=True,

37 allowed_tools=["Bash", "Read"],

38 )

40 async for message in query(prompt="List the files in my project", options=options):

41 if isinstance(message, StreamEvent):

42 event = message.event

43 if event.get("type") == "content_block_delta":

44 delta = event.get("delta", {})

45 if delta.get("type") == "text_delta":

46 print(delta.get("text", ""), end="", flush=True)

49 asyncio.run(stream_response())

50 ```

52 ```typescript TypeScript theme={null}

53 import { query } from "@anthropic-ai/claude-agent-sdk";

55 for await (const message of query({

56 prompt: "List the files in my project",

57 options: {

58 includePartialMessages: true,

59 allowedTools: ["Bash", "Read"]

60 }

61 })) {

62 if (message.type === "stream_event") {

63 const event = message.event;

64 if (event.type === "content_block_delta") {

65 if (event.delta.type === "text_delta") {

66 process.stdout.write(event.delta.text);

67 }

68 }

69 }

70 }

71 ```

72</CodeGroup>

74## StreamEvent-Referenz

76Wenn Teillmeldungen aktiviert sind, erhalten Sie rohe Claude-API-Streaming-Ereignisse, die in einem Objekt verpackt sind. Der Typ hat in jedem SDK unterschiedliche Namen:

78* **Python**: `StreamEvent` (importieren aus `claude_agent_sdk.types`)

79* **TypeScript**: `SDKPartialAssistantMessage` mit `type: 'stream_event'`

81Beide enthalten rohe Claude-API-Ereignisse, nicht angesammelte Text. Sie müssen Text-Deltas selbst extrahieren und ansammeln. Hier ist die Struktur jedes Typs:

83<CodeGroup>

84 ```python Python theme={null}

85 @dataclass

86 class StreamEvent:

87 uuid: str # Unique identifier for this event

88 session_id: str # Session identifier

89 event: dict[str, Any] # The raw Claude API stream event

90 parent_tool_use_id: str | None # Parent tool ID if from a subagent

91 ```

93 ```typescript TypeScript theme={null}

94 type SDKPartialAssistantMessage = {

95 type: "stream_event";

96 event: BetaRawMessageStreamEvent; // From Anthropic SDK

97 parent_tool_use_id: string | null;

98 uuid: UUID;

99 session_id: string;

100 };

101 ```

102</CodeGroup>

103

104Das Feld `event` enthält das rohe Streaming-Ereignis aus der [Claude API](https://platform.claude.com/docs/en/build-with-claude/streaming#event-types). Häufige Ereignistypen sind:

105

106| Ereignistyp | Beschreibung |

107| :-------------------- | :----------------------------------------------------------- |

108| `message_start` | Beginn einer neuen Nachricht |

109| `content_block_start` | Beginn eines neuen Inhaltsblocks (Text oder Tool-Verwendung) |

110| `content_block_delta` | Inkrementelle Aktualisierung des Inhalts |

111| `content_block_stop` | Ende eines Inhaltsblocks |

112| `message_delta` | Aktualisierungen auf Nachrichtenebene (Stoppgrund, Nutzung) |

113| `message_stop` | Ende der Nachricht |

114

115## Nachrichtenfluss

116

117Mit aktivierten Teillmeldungen erhalten Sie Nachrichten in dieser Reihenfolge:

118

119```text theme={null}

120StreamEvent (message_start)

121StreamEvent (content_block_start) - text block

122StreamEvent (content_block_delta) - text chunks...

123StreamEvent (content_block_stop)

124StreamEvent (content_block_start) - tool_use block

125StreamEvent (content_block_delta) - tool input chunks...

126StreamEvent (content_block_stop)

127StreamEvent (message_delta)

128StreamEvent (message_stop)

129AssistantMessage - complete message with all content

130... tool executes ...

131... more streaming events for next turn ...

132ResultMessage - final result

133```

134

135Ohne aktivierte Teillmeldungen (`include_partial_messages` in Python, `includePartialMessages` in TypeScript) erhalten Sie alle Nachrichtentypen außer `StreamEvent`. Häufige Typen sind `SystemMessage` (Sitzungsinitialisierung), `AssistantMessage` (vollständige Antworten), `ResultMessage` (Endergebnis) und eine kompakte Grenzmarkierung, die anzeigt, wann der Gesprächsverlauf komprimiert wurde (`SDKCompactBoundaryMessage` in TypeScript; `SystemMessage` mit Subtyp `"compact_boundary"` in Python).

136

137## Text-Antworten streamen

138

139Um Text anzuzeigen, während er generiert wird, suchen Sie nach `content_block_delta`-Ereignissen, bei denen `delta.type` gleich `text_delta` ist. Diese enthalten die inkrementellen Text-Chunks. Das folgende Beispiel gibt jeden Chunk aus, während er ankommt:

140

141<CodeGroup>

142 ```python Python theme={null}

143 from claude_agent_sdk import query, ClaudeAgentOptions

144 from claude_agent_sdk.types import StreamEvent

145 import asyncio

146

147

148 async def stream_text():

149 options = ClaudeAgentOptions(include_partial_messages=True)

150

151 async for message in query(prompt="Explain how databases work", options=options):

152 if isinstance(message, StreamEvent):

153 event = message.event

154 if event.get("type") == "content_block_delta":

155 delta = event.get("delta", {})

156 if delta.get("type") == "text_delta":

157 # Print each text chunk as it arrives

158 print(delta.get("text", ""), end="", flush=True)

159

160 print() # Final newline

161

162

163 asyncio.run(stream_text())

164 ```

165

166 ```typescript TypeScript theme={null}

167 import { query } from "@anthropic-ai/claude-agent-sdk";

168

169 for await (const message of query({

170 prompt: "Explain how databases work",

171 options: { includePartialMessages: true }

172 })) {

173 if (message.type === "stream_event") {

174 const event = message.event;

175 if (event.type === "content_block_delta" && event.delta.type === "text_delta") {

176 process.stdout.write(event.delta.text);

177 }

178 }

179 }

180

181 console.log(); // Final newline

182 ```

183</CodeGroup>

184

185## Tool-Aufrufe streamen

186

187Tool-Aufrufe werden auch inkrementell gestreamt. Sie können verfolgen, wann Tools starten, ihre Eingabe erhalten, während sie generiert wird, und sehen, wann sie abgeschlossen sind. Das folgende Beispiel verfolgt das aktuell aufgerufene Tool und sammelt die JSON-Eingabe, während sie gestreamt wird. Es verwendet drei Ereignistypen:

188

189* `content_block_start`: Tool beginnt

190* `content_block_delta` mit `input_json_delta`: Eingabe-Chunks kommen an

191* `content_block_stop`: Tool-Aufruf abgeschlossen

192

193<CodeGroup>

194 ```python Python theme={null}

195 from claude_agent_sdk import query, ClaudeAgentOptions

196 from claude_agent_sdk.types import StreamEvent

197 import asyncio

198

199

200 async def stream_tool_calls():

201 options = ClaudeAgentOptions(

202 include_partial_messages=True,

203 allowed_tools=["Read", "Bash"],

204 )

205

206 # Track the current tool and accumulate its input JSON

207 current_tool = None

208 tool_input = ""

209

210 async for message in query(prompt="Read the README.md file", options=options):

211 if isinstance(message, StreamEvent):

212 event = message.event

213 event_type = event.get("type")

214

215 if event_type == "content_block_start":

216 # New tool call is starting

217 content_block = event.get("content_block", {})

218 if content_block.get("type") == "tool_use":

219 current_tool = content_block.get("name")

220 tool_input = ""

221 print(f"Starting tool: {current_tool}")

222

223 elif event_type == "content_block_delta":

224 delta = event.get("delta", {})

225 if delta.get("type") == "input_json_delta":

226 # Accumulate JSON input as it streams in

227 chunk = delta.get("partial_json", "")

228 tool_input += chunk

229 print(f" Input chunk: {chunk}")

230

231 elif event_type == "content_block_stop":

232 # Tool call complete - show final input

233 if current_tool:

234 print(f"Tool {current_tool} called with: {tool_input}")

235 current_tool = None

236

237

238 asyncio.run(stream_tool_calls())

239 ```

240

241 ```typescript TypeScript theme={null}

242 import { query } from "@anthropic-ai/claude-agent-sdk";

243

244 // Track the current tool and accumulate its input JSON

245 let currentTool: string | null = null;

246 let toolInput = "";

247

248 for await (const message of query({

249 prompt: "Read the README.md file",

250 options: {

251 includePartialMessages: true,

252 allowedTools: ["Read", "Bash"]

253 }

254 })) {

255 if (message.type === "stream_event") {

256 const event = message.event;

257

258 if (event.type === "content_block_start") {

259 // New tool call is starting

260 if (event.content_block.type === "tool_use") {

261 currentTool = event.content_block.name;

262 toolInput = "";

263 console.log(`Starting tool: ${currentTool}`);

264 }

265 } else if (event.type === "content_block_delta") {

266 if (event.delta.type === "input_json_delta") {

267 // Accumulate JSON input as it streams in

268 const chunk = event.delta.partial_json;

269 toolInput += chunk;

270 console.log(` Input chunk: ${chunk}`);

271 }

272 } else if (event.type === "content_block_stop") {

273 // Tool call complete - show final input

274 if (currentTool) {

275 console.log(`Tool ${currentTool} called with: ${toolInput}`);

276 currentTool = null;

277 }

278 }

279 }

280 }

281 ```

282</CodeGroup>

283

284## Streaming-UI erstellen

285

286Dieses Beispiel kombiniert Text- und Tool-Streaming in eine kohärente Benutzeroberfläche. Es verfolgt, ob der Agent gerade ein Tool ausführt (mit einem `in_tool`-Flag), um Statusanzeigen wie `[Using Read...]` anzuzeigen, während Tools ausgeführt werden. Text wird normal gestreamt, wenn nicht in einem Tool, und die Tool-Fertigstellung löst eine „done"-Nachricht aus. Dieses Muster ist nützlich für Chat-Schnittstellen, die während mehrstufiger Agent-Aufgaben Fortschritt anzeigen müssen.

287

288<CodeGroup>

289 ```python Python theme={null}

290 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

291 from claude_agent_sdk.types import StreamEvent

292 import asyncio

293 import sys

294

295

296 async def streaming_ui():

297 options = ClaudeAgentOptions(

298 include_partial_messages=True,

299 allowed_tools=["Read", "Bash", "Grep"],

300 )

301

302 # Track whether we're currently in a tool call

303 in_tool = False

304

305 async for message in query(

306 prompt="Find all TODO comments in the codebase", options=options

307 ):

308 if isinstance(message, StreamEvent):

309 event = message.event

310 event_type = event.get("type")

311

312 if event_type == "content_block_start":

313 content_block = event.get("content_block", {})

314 if content_block.get("type") == "tool_use":

315 # Tool call is starting - show status indicator

316 tool_name = content_block.get("name")

317 print(f"\n[Using {tool_name}...]", end="", flush=True)

318 in_tool = True

319

320 elif event_type == "content_block_delta":

321 delta = event.get("delta", {})

322 # Only stream text when not executing a tool

323 if delta.get("type") == "text_delta" and not in_tool:

324 sys.stdout.write(delta.get("text", ""))

325 sys.stdout.flush()

326

327 elif event_type == "content_block_stop":

328 if in_tool:

329 # Tool call finished

330 print(" done", flush=True)

331 in_tool = False

332

333 elif isinstance(message, ResultMessage):

334 # Agent finished all work

335 print(f"\n\n--- Complete ---")

336

337

338 asyncio.run(streaming_ui())

339 ```

340

341 ```typescript TypeScript theme={null}

342 import { query } from "@anthropic-ai/claude-agent-sdk";

343

344 // Track whether we're currently in a tool call

345 let inTool = false;

346

347 for await (const message of query({

348 prompt: "Find all TODO comments in the codebase",

349 options: {

350 includePartialMessages: true,

351 allowedTools: ["Read", "Bash", "Grep"]

352 }

353 })) {

354 if (message.type === "stream_event") {

355 const event = message.event;

356

357 if (event.type === "content_block_start") {

358 if (event.content_block.type === "tool_use") {

359 // Tool call is starting - show status indicator

360 process.stdout.write(`\n[Using ${event.content_block.name}...]`);

361 inTool = true;

362 }

363 } else if (event.type === "content_block_delta") {

364 // Only stream text when not executing a tool

365 if (event.delta.type === "text_delta" && !inTool) {

366 process.stdout.write(event.delta.text);

367 }

368 } else if (event.type === "content_block_stop") {

369 if (inTool) {

370 // Tool call finished

371 console.log(" done");

372 inTool = false;

373 }

374 }

375 } else if (message.type === "result") {

376 // Agent finished all work

377 console.log("\n\n--- Complete ---");

378 }

379 }

380 ```

381</CodeGroup>

382

383## Bekannte Einschränkungen

384

385Einige SDK-Funktionen sind mit Streaming nicht kompatibel:

386

387* **Erweitertes Denken**: Wenn Sie `max_thinking_tokens` (Python) oder `maxThinkingTokens` (TypeScript) explizit setzen, werden `StreamEvent`-Nachrichten nicht ausgegeben. Sie erhalten nur vollständige Nachrichten nach jeder Runde. Beachten Sie, dass Denken im SDK standardmäßig deaktiviert ist, daher funktioniert Streaming, es sei denn, Sie aktivieren es.

388* **Strukturierte Ausgabe**: Das JSON-Ergebnis erscheint nur in der finalen `ResultMessage.structured_output`, nicht als Streaming-Deltas. Weitere Informationen finden Sie unter [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs).

389

390## Nächste Schritte

391

392Jetzt, da Sie Text und Tool-Aufrufe in Echtzeit streamen können, erkunden Sie diese verwandten Themen:

393

394* [Interaktive vs. One-Shot-Abfragen](/de/agent-sdk/streaming-vs-single-mode): Wählen Sie zwischen Eingabemodi für Ihren Anwendungsfall

395* [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs): Erhalten Sie typisierte JSON-Antworten vom Agent

396* [Berechtigungen](/de/agent-sdk/permissions): Kontrollieren Sie, welche Tools der Agent verwenden kann

agent-sdk/todo-tracking.md +189 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Todo-Listen

7> Verfolgen und zeigen Sie Todos mit dem Claude Agent SDK für organisierte Aufgabenverwaltung an

9Die Todo-Verfolgung bietet eine strukturierte Möglichkeit, Aufgaben zu verwalten und Benutzer über den Aufgabenfortschritt zu informieren. Das Claude Agent SDK enthält integrierte Todo-Funktionalität, die dabei hilft, komplexe Arbeitsabläufe zu organisieren und Benutzer über die Aufgabenprogression zu informieren.

11### Todo-Lebenszyklus

13Todos folgen einem vorhersehbaren Lebenszyklus:

151. **Erstellt** als `pending`, wenn Aufgaben identifiziert werden

162. **Aktiviert** zu `in_progress`, wenn die Arbeit beginnt

173. **Abgeschlossen**, wenn die Aufgabe erfolgreich beendet wird

184. **Entfernt**, wenn alle Aufgaben in einer Gruppe abgeschlossen sind

20### Wann Todos verwendet werden

22Das SDK erstellt automatisch Todos für:

24* **Komplexe mehrstufige Aufgaben**, die 3 oder mehr unterschiedliche Aktionen erfordern

25* **Von Benutzern bereitgestellte Aufgabenlisten**, wenn mehrere Elemente erwähnt werden

26* **Nicht triviale Operationen**, die von der Fortschrittsverfolgung profitieren

27* **Explizite Anfragen**, wenn Benutzer um Todo-Organisation bitten

29## Beispiele

31### Überwachung von Todo-Änderungen

33<CodeGroup>

34 ```typescript TypeScript theme={null}

35 import { query } from "@anthropic-ai/claude-agent-sdk";

37 for await (const message of query({

38 prompt: "Optimize my React app performance and track progress with todos",

39 options: { maxTurns: 15 }

40 })) {

41 // Todo updates are reflected in the message stream

42 if (message.type === "assistant") {

43 for (const block of message.message.content) {

44 if (block.type === "tool_use" && block.name === "TodoWrite") {

45 const todos = block.input.todos;

47 console.log("Todo Status Update:");

48 todos.forEach((todo, index) => {

49 const status =

50 todo.status === "completed" ? "✅" : todo.status === "in_progress" ? "🔧" : "❌";

51 console.log(`${index + 1}. ${status} ${todo.content}`);

52 });

53 }

54 }

55 }

56 }

57 ```

59 ```python Python theme={null}

60 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock

62 async for message in query(

63 prompt="Optimize my React app performance and track progress with todos",

64 options=ClaudeAgentOptions(max_turns=15),

65 ):

66 # Todo updates are reflected in the message stream

67 if isinstance(message, AssistantMessage):

68 for block in message.content:

69 if isinstance(block, ToolUseBlock) and block.name == "TodoWrite":

70 todos = block.input["todos"]

72 print("Todo Status Update:")

73 for i, todo in enumerate(todos):

74 status = (

75 "✅"

76 if todo["status"] == "completed"

77 else "🔧"

78 if todo["status"] == "in_progress"

79 else "❌"

80 )

81 print(f"{i + 1}. {status} {todo['content']}")

82 ```

83</CodeGroup>

85### Echtzeit-Fortschrittsanzeige

87<CodeGroup>

88 ```typescript TypeScript theme={null}

89 import { query } from "@anthropic-ai/claude-agent-sdk";

91 class TodoTracker {

92 private todos: any[] = [];

94 displayProgress() {

95 if (this.todos.length === 0) return;

97 const completed = this.todos.filter((t) => t.status === "completed").length;

98 const inProgress = this.todos.filter((t) => t.status === "in_progress").length;

99 const total = this.todos.length;

100

101 console.log(`\nProgress: ${completed}/${total} completed`);

102 console.log(`Currently working on: ${inProgress} task(s)\n`);

103

104 this.todos.forEach((todo, index) => {

105 const icon =

106 todo.status === "completed" ? "✅" : todo.status === "in_progress" ? "🔧" : "❌";

107 const text = todo.status === "in_progress" ? todo.activeForm : todo.content;

108 console.log(`${index + 1}. ${icon} ${text}`);

109 });

110 }

111

112 async trackQuery(prompt: string) {

113 for await (const message of query({

114 prompt,

115 options: { maxTurns: 20 }

116 })) {

117 if (message.type === "assistant") {

118 for (const block of message.message.content) {

119 if (block.type === "tool_use" && block.name === "TodoWrite") {

120 this.todos = block.input.todos;

121 this.displayProgress();

122 }

123 }

124 }

125 }

126 }

127 }

128

129 // Usage

130 const tracker = new TodoTracker();

131 await tracker.trackQuery("Build a complete authentication system with todos");

132 ```

133

134 ```python Python theme={null}

135 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, ToolUseBlock

136 from typing import List, Dict

137

138

139 class TodoTracker:

140 def __init__(self):

141 self.todos: List[Dict] = []

142

143 def display_progress(self):

144 if not self.todos:

145 return

146

147 completed = len([t for t in self.todos if t["status"] == "completed"])

148 in_progress = len([t for t in self.todos if t["status"] == "in_progress"])

149 total = len(self.todos)

150

151 print(f"\nProgress: {completed}/{total} completed")

152 print(f"Currently working on: {in_progress} task(s)\n")

153

154 for i, todo in enumerate(self.todos):

155 icon = (

156 "✅"

157 if todo["status"] == "completed"

158 else "🔧"

159 if todo["status"] == "in_progress"

160 else "❌"

161 )

162 text = (

163 todo["activeForm"]

164 if todo["status"] == "in_progress"

165 else todo["content"]

166 )

167 print(f"{i + 1}. {icon} {text}")

168

169 async def track_query(self, prompt: str):

170 async for message in query(prompt=prompt, options=ClaudeAgentOptions(max_turns=20)):

171 if isinstance(message, AssistantMessage):

172 for block in message.content:

173 if isinstance(block, ToolUseBlock) and block.name == "TodoWrite":

174 self.todos = block.input["todos"]

175 self.display_progress()

176

177

178 # Usage

179 tracker = TodoTracker()

180 await tracker.track_query("Build a complete authentication system with todos")

181 ```

182</CodeGroup>

183

184## Zugehörige Dokumentation

185

186* [TypeScript SDK-Referenz](/de/agent-sdk/typescript)

187* [Python SDK-Referenz](/de/agent-sdk/python)

188* [Streaming vs. Single Mode](/de/agent-sdk/streaming-vs-single-mode)

189* [Benutzerdefinierte Tools](/de/agent-sdk/custom-tools)

agent-sdk/typescript.md +31 −31

Details

41#### Parameter41#### Parameter

42 42

43| Parameter | Typ | Beschreibung |43| Parameter | Typ | Beschreibung |

~~44| :-------- | :---------------------------------------------------------------- | :----------------------------------------------------------------------------------------- |~~44| :-------- | :--------------------------------------------------------------- | :----------------------------------------------------------------------------------------- |

47 47

48#### Rückgabewert48#### Rückgabewert

49 49

~~50Gibt ein [`Query`](#query-object)-Objekt zurück, das `AsyncGenerator<`[`SDKMessage`](#sdk-message)`, void>` mit zusätzlichen Methoden erweitert.~~50Gibt ein [`Query`](#query-object)-Objekt zurück, das `AsyncGenerator<`[`SDKMessage`](#sdkmessage)`, void>` mit zusätzlichen Methoden erweitert.

51 51

52### `startup()`52### `startup()`

53 53

54Wärmt den CLI-Unterprozess vor, indem er ihn spawnt und den Initialize-Handshake abschließt, bevor eine Eingabeaufforderung verfügbar ist. Das zurückgegebene [`WarmQuery`](#warm-query)-Handle akzeptiert später eine Eingabeaufforderung und schreibt sie in einen bereits bereiten Prozess, sodass der erste `query()`-Aufruf ohne Kosten für das Spawnen und Initialisieren des Unterprozesses aufgelöst wird.54Wärmt den CLI-Unterprozess vor, indem er ihn spawnt und den Initialize-Handshake abschließt, bevor eine Eingabeaufforderung verfügbar ist. Das zurückgegebene [`WarmQuery`](#warmquery)-Handle akzeptiert später eine Eingabeaufforderung und schreibt sie in einen bereits bereiten Prozess, sodass der erste `query()`-Aufruf ohne Kosten für das Spawnen und Initialisieren des Unterprozesses aufgelöst wird.

55 55

56```typescript theme={null}56```typescript theme={null}

57function startup(params?: {57function startup(params?: {

69 69

70#### Rückgabewert70#### Rückgabewert

71 71

~~72Gibt ein `Promise<`[`WarmQuery`](#warm-query)`>` zurück, das aufgelöst wird, sobald der Unterprozess gespawnt wurde und seinen Initialize-Handshake abgeschlossen hat.~~72Gibt ein `Promise<`[`WarmQuery`](#warmquery)`>` zurück, das aufgelöst wird, sobald der Unterprozess gespawnt wurde und seinen Initialize-Handshake abgeschlossen hat.

73 73

74#### Beispiel74#### Beispiel

75 75

104#### Parameter104#### Parameter

105 105

106| Parameter | Typ | Beschreibung |106| Parameter | Typ | Beschreibung |

107| :------------ | :------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------- |107| :------------ | :---------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |

112| `extras` | `{ annotations?: `[`ToolAnnotations`](#tool-annotations)` }` | Optionale MCP-Tool-Anmerkungen, die Verhaltenshinweise für Clients bereitstellen |112| `extras` | `{ annotations?: `[`ToolAnnotations`](#toolannotations)` }` | Optionale MCP-Tool-Anmerkungen, die Verhaltenshinweise für Clients bereitstellen |

113 113

114#### `ToolAnnotations`114#### `ToolAnnotations`

115 115

191 191

192#### Beispiel192#### Beispiel

272 272

273Gibt [`SDKSessionInfo`](#return-type-sdk-session-info) zurück, oder `undefined`, wenn die Sitzung nicht gefunden wird.273Gibt [`SDKSessionInfo`](#return-type-sdksessioninfo) zurück, oder `undefined`, wenn die Sitzung nicht gefunden wird.

274 274

275### `renameSession()`275### `renameSession()`

276 276

328| `allowedTools` | `string[]` | `[]` | Tools, die automatisch genehmigt werden, ohne zu fragen. Dies beschränkt Claude nicht nur auf diese Tools; nicht aufgelistete Tools fallen durch `permissionMode` und `canUseTool`. Verwenden Sie `disallowedTools`, um Tools zu blockieren. Siehe [Berechtigungen](/de/agent-sdk/permissions#allow-and-deny-rules) |328| `allowedTools` | `string[]` | `[]` | Tools, die automatisch genehmigt werden, ohne zu fragen. Dies beschränkt Claude nicht nur auf diese Tools; nicht aufgelistete Tools fallen durch `permissionMode` und `canUseTool`. Verwenden Sie `disallowedTools`, um Tools zu blockieren. Siehe [Berechtigungen](/de/agent-sdk/permissions#allow-and-deny-rules) |

341| `extraArgs` | `Record<string, string \| null>` | `{}` | Zusätzliche Argumente |341| `extraArgs` | `Record<string, string \| null>` | `{}` | Zusätzliche Argumente |

344| `hooks` | `Partial<Record<`[`HookEvent`](#hook-event)`, `[`HookCallbackMatcher`](#hook-callback-matcher)`[]>>` | `{}` | Hook-Callbacks für Ereignisse |344| `hooks` | `Partial<Record<`[`HookEvent`](#hookevent)`, `[`HookCallbackMatcher`](#hookcallbackmatcher)`[]>>` | `{}` | Hook-Callbacks für Ereignisse |

346| `maxBudgetUsd` | `number` | `undefined` | Beenden Sie die Abfrage, wenn die clientseitige Kostenschätzung diesen USD-Wert erreicht. Verglichen mit derselben Schätzung wie `total_cost_usd`; siehe [Kosten und Nutzung verfolgen](/de/agent-sdk/cost-tracking) für Genauigkeitsvorbehalt |346| `maxBudgetUsd` | `number` | `undefined` | Beenden Sie die Abfrage, wenn die clientseitige Kostenschätzung diesen USD-Wert erreicht. Verglichen mit derselben Schätzung wie `total_cost_usd`; siehe [Kosten und Nutzung verfolgen](/de/agent-sdk/cost-tracking) für Genauigkeitsvorbehalt |

349| `mcpServers` | `Record<string, [`McpServerConfig`](#mcp-server-config)>` | `{}` | MCP-Server-Konfigurationen |349| `mcpServers` | `Record<string, [`McpServerConfig`](#mcpserverconfig)>` | `{}` | MCP-Server-Konfigurationen |

351| `outputFormat` | `{ type: 'json_schema', schema: JSONSchema }` | `undefined` | Definieren Sie das Ausgabeformat für Agent-Ergebnisse. Siehe [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs) für Details |351| `outputFormat` | `{ type: 'json_schema', schema: JSONSchema }` | `undefined` | Definieren Sie das Ausgabeformat für Agent-Ergebnisse. Siehe [Strukturierte Ausgaben](/de/agent-sdk/structured-outputs) für Details |

352| `pathToClaudeCodeExecutable` | `string` | Automatisch aufgelöst aus gebündelter nativer Binärdatei | Pfad zur Claude Code-Ausführungsdatei. Nur erforderlich, wenn optionale Abhängigkeiten während der Installation übersprungen wurden oder Ihre Plattform nicht in der unterstützten Menge enthalten ist |352| `pathToClaudeCodeExecutable` | `string` | Automatisch aufgelöst aus gebündelter nativer Binärdatei | Pfad zur Claude Code-Ausführungsdatei. Nur erforderlich, wenn optionale Abhängigkeiten während der Installation übersprungen wurden oder Ihre Plattform nicht in der unterstützten Menge enthalten ist |

357| `promptSuggestions` | `boolean` | `false` | Aktivieren Sie Eingabeaufforderungsvorschläge. Gibt nach jedem Turn eine `prompt_suggestion`-Nachricht mit einer vorhergesagten nächsten Benutzer-Eingabeaufforderung aus |357| `promptSuggestions` | `boolean` | `false` | Aktivieren Sie Eingabeaufforderungsvorschläge. Gibt nach jedem Turn eine `prompt_suggestion`-Nachricht mit einer vorhergesagten nächsten Benutzer-Eingabeaufforderung aus |

362| `sessionStore` | [`SessionStore`](/de/agent-sdk/session-storage#the-session-store-interface) | `undefined` | Spiegeln Sie Sitzungstranskripte auf einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher persistieren](/de/agent-sdk/session-storage) |362| `sessionStore` | [`SessionStore`](/de/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Spiegeln Sie Sitzungstranskripte auf einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher persistieren](/de/agent-sdk/session-storage) |

363| `settingSources` | [`SettingSource`](#setting-source)`[]` | CLI-Standards (alle Quellen) | Steuern Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |363| `settingSources` | [`SettingSource`](#settingsource)`[]` | CLI-Standards (alle Quellen) | Steuern Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

364| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Benutzerdefinierte Funktion zum Spawnen des Claude Code-Prozesses. Verwenden Sie, um Claude Code in VMs, Containern oder Remote-Umgebungen auszuführen |364| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Benutzerdefinierte Funktion zum Spawnen des Claude Code-Prozesses. Verwenden Sie, um Claude Code in VMs, Containern oder Remote-Umgebungen auszuführen |

367| `systemPrompt` | `string \| { type: 'preset'; preset: 'claude_code'; append?: string; excludeDynamicSections?: boolean }` | `undefined` (minimale Eingabeaufforderung) | Konfiguration der Systemeingabeaufforderung. Übergeben Sie eine Zeichenkette für eine benutzerdefinierte Eingabeaufforderung oder `{ type: 'preset', preset: 'claude_code' }`, um die Systemeingabeaufforderung von Claude Code zu verwenden. Bei Verwendung der Preset-Objektform fügen Sie `append` hinzu, um sie mit zusätzlichen Anweisungen zu erweitern, und setzen Sie `excludeDynamicSections: true`, um sitzungsspezifischen Kontext in die erste Benutzer-Nachricht zu verschieben, um [bessere Prompt-Cache-Wiederverwendung über Maschinen hinweg](/de/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines) |367| `systemPrompt` | `string \| { type: 'preset'; preset: 'claude_code'; append?: string; excludeDynamicSections?: boolean }` | `undefined` (minimale Eingabeaufforderung) | Konfiguration der Systemeingabeaufforderung. Übergeben Sie eine Zeichenkette für eine benutzerdefinierte Eingabeaufforderung oder `{ type: 'preset', preset: 'claude_code' }`, um die Systemeingabeaufforderung von Claude Code zu verwenden. Bei Verwendung der Preset-Objektform fügen Sie `append` hinzu, um sie mit zusätzlichen Anweisungen zu erweitern, und setzen Sie `excludeDynamicSections: true`, um sitzungsspezifischen Kontext in die erste Benutzer-Nachricht zu verschieben, um [bessere Prompt-Cache-Wiederverwendung über Maschinen hinweg](/de/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines) |

368| `thinking` | [`ThinkingConfig`](#thinking-config) | `{ type: 'adaptive' }` für unterstützte Modelle | Steuert das Denk-/Reasoning-Verhalten von Claude. Siehe [`ThinkingConfig`](#thinking-config) für Optionen |368| `thinking` | [`ThinkingConfig`](#thinkingconfig) | `{ type: 'adaptive' }` für unterstützte Modelle | Steuert das Denk-/Reasoning-Verhalten von Claude. Siehe [`ThinkingConfig`](#thinkingconfig) für Optionen |

370| `tools` | `string[] \| { type: 'preset'; preset: 'claude_code' }` | `undefined` | Tool-Konfiguration. Übergeben Sie ein Array von Tool-Namen oder verwenden Sie die Voreinstellung, um die Standard-Tools von Claude Code zu erhalten |370| `tools` | `string[] \| { type: 'preset'; preset: 'claude_code' }` | `undefined` | Tool-Konfiguration. Übergeben Sie ein Array von Tool-Namen oder verwenden Sie die Voreinstellung, um die Standard-Tools von Claude Code zu erhalten |

371 371

372### `Query`-Objekt372### `Query`-Objekt

410| `initializationResult()` | Gibt das vollständige Initialisierungsergebnis zurück, einschließlich unterstützter Befehle, Modelle, Kontoinformationen und Ausgabestil-Konfiguration |410| `initializationResult()` | Gibt das vollständige Initialisierungsergebnis zurück, einschließlich unterstützter Befehle, Modelle, Kontoinformationen und Ausgabestil-Konfiguration |

498 498

499### `AgentMcpServerSpec`499### `AgentMcpServerSpec`

626 | "default" // Standardberechtigungsverhalten626 | "default" // Standardberechtigungsverhalten

627 | "acceptEdits" // Dateibearbeitungen automatisch akzeptieren627 | "acceptEdits" // Dateibearbeitungen automatisch akzeptieren

628 | "bypassPermissions" // Alle Berechtigungsprüfungen umgehen628 | "bypassPermissions" // Alle Berechtigungsprüfungen umgehen

629 | "plan" // Planungsmodus - keine Ausführung629 | "plan" // Planungsmodus - nur Lesezugriff-Tools

630 | "dontAsk" // Fragen Sie nicht nach Berechtigungen, verweigern Sie, wenn nicht vorab genehmigt630 | "dontAsk" // Fragen Sie nicht nach Berechtigungen, verweigern Sie, wenn nicht vorab genehmigt

631 | "auto"; // Verwenden Sie einen Modell-Klassifizierer, um jeden Tool-Aufruf zu genehmigen oder zu verweigern631 | "auto"; // Verwenden Sie einen Modell-Klassifizierer, um jeden Tool-Aufruf zu genehmigen oder zu verweigern

632```632```

651```651```

652 652

653| Option | Typ | Beschreibung |653| Option | Typ | Beschreibung |

654| :--------------- | :------------------------------------------- | :-------------------------------------------------------------------------------------------------------------- |654| :--------------- | :------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

656| `suggestions` | [`PermissionUpdate`](#permission-update)`[]` | Vorgeschlagene Berechtigungsaktualisierungen, damit der Benutzer nicht erneut für dieses Tool aufgefordert wird |656| `suggestions` | [`PermissionUpdate`](#permissionupdate)`[]` | Vorgeschlagene Berechtigungsaktualisierungen, damit der Benutzer nicht erneut für dieses Tool aufgefordert wird. Bash-Eingabeaufforderungen enthalten einen Vorschlag mit dem `localSettings` [Ziel](#permissionupdatedestination), sodass die Rückgabe in `updatedPermissions` die Regel in `.claude/settings.local.json` schreibt und über Sitzungen hinweg persistiert. |

2379 | McpClaudeAIProxyServerConfig;2379 | McpClaudeAIProxyServerConfig;

2380```2380```

2381 2381

2382Siehe [`McpServerConfig`](#mcp-server-config) für Details zu jedem Transporttyp.2382Siehe [`McpServerConfig`](#mcpserverconfig) für Details zu jedem Transporttyp.

2383 2383

2384### `AccountInfo`2384### `AccountInfo`

2385 2385

2825```2825```

2826 2826

2827| Eigenschaft | Typ | Standard | Beschreibung |2827| Eigenschaft | Typ | Standard | Beschreibung |

2828| :-------------------------- | :------------------------------------------------------ | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |2828| :-------------------------- | :---------------------------------------------------- | :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

2832| `allowUnsandboxedCommands` | `boolean` | `true` | Erlauben Sie dem Modell, die Ausführung von Befehlen außerhalb der Sandbox anzufordern. Wenn `true`, kann das Modell `dangerouslyDisableSandbox` in der Tool-Eingabe setzen, was auf das [Berechtigungssystem](#permissions-fallback-for-unsandboxed-commands) zurückfällt |2832| `allowUnsandboxedCommands` | `boolean` | `true` | Erlauben Sie dem Modell, die Ausführung von Befehlen außerhalb der Sandbox anzufordern. Wenn `true`, kann das Modell `dangerouslyDisableSandbox` in der Tool-Eingabe setzen, was auf das [Berechtigungssystem](#permissions-fallback-for-unsandboxed-commands) zurückfällt |

2835| `ignoreViolations` | `Record<string, string[]>` | `undefined` | Zuordnung von Verletzungskategorien zu Mustern zum Ignorieren (z. B. `{ file: ['/tmp/*'], network: ['localhost'] }`) |2835| `ignoreViolations` | `Record<string, string[]>` | `undefined` | Zuordnung von Verletzungskategorien zu Mustern zum Ignorieren (z. B. `{ file: ['/tmp/*'], network: ['localhost'] }`) |

2837| `ripgrep` | `{ command: string; args?: string[] }` | `undefined` | Benutzerdefinierte ripgrep-Binärkonfiguration für Sandbox-Umgebungen |2837| `ripgrep` | `{ command: string; args?: string[] }` | `undefined` | Benutzerdefinierte ripgrep-Binärkonfiguration für Sandbox-Umgebungen |

data-usage.md +1 −1

Details

67 67

68Das folgende Diagramm zeigt, wie Claude Code während der Installation und des normalen Betriebs eine Verbindung zu externen Diensten herstellt. Durchgehende Linien zeigen erforderliche Verbindungen an, während gestrichelte Linien optionale oder vom Benutzer initiierte Datenflüsse darstellen.68Das folgende Diagramm zeigt, wie Claude Code während der Installation und des normalen Betriebs eine Verbindung zu externen Diensten herstellt. Durchgehende Linien zeigen erforderliche Verbindungen an, während gestrichelte Linien optionale oder vom Benutzer initiierte Datenflüsse darstellen.

69 69

70<img src="https://mintcdn.com/claude-code/YcBW2H7CArGcduPb/images/claude-code-data-flow.svg?fit=max&auto=format&n=YcBW2H7CArGcduPb&q=85&s=b600a89f84fc86f9ff7be00a466c0635" alt="Diagramm, das die externen Verbindungen von Claude Code zeigt: Installation/Update verbindet sich mit dem Verteilungsserver, und Benutzeranfragen verbinden sich mit Anthropic-Diensten, einschließlich Console-Authentifizierung, öffentlicher API und optional Statsig, Sentry und Bug-Berichterstattung" width="720" height="520" data-path="images/claude-code-data-flow.svg" />70<img src="https://mintcdn.com/claude-code/RcOyXc06Ja8cuvMZ/images/claude-code-data-flow.svg?fit=max&auto=format&n=RcOyXc06Ja8cuvMZ&q=85&s=b5be40abf333defe984993af89546c19" alt="Diagramm, das die externen Verbindungen von Claude Code zeigt: Installation/Update verbindet sich mit dem Verteilungsserver, und Benutzeranfragen verbinden sich mit Anthropic-Diensten, einschließlich Console-Authentifizierung, öffentlicher API und optional Statsig, Sentry und Bug-Berichterstattung" width="720" height="520" data-path="images/claude-code-data-flow.svg" />

71 71

72Claude Code wird lokal ausgeführt. Um mit dem LLM zu interagieren, sendet Claude Code Daten über das Netzwerk. Diese Daten umfassen alle Benutzereingabeaufforderungen und Modellausgaben, verschlüsselt während der Übertragung über TLS 1.2+. Claude Code ist mit den meisten gängigen VPNs und LLM-Proxys kompatibel.72Claude Code wird lokal ausgeführt. Um mit dem LLM zu interagieren, sendet Claude Code Daten über das Netzwerk. Diese Daten umfassen alle Benutzereingabeaufforderungen und Modellausgaben, verschlüsselt während der Übertragung über TLS 1.2+. Claude Code ist mit den meisten gängigen VPNs und LLM-Proxys kompatibel.

73 73

desktop.md +7 −5

Details

282 282

283### Arbeiten Sie parallel mit Sitzungen283### Arbeiten Sie parallel mit Sitzungen

284 284

285Klicken Sie auf **+ Neue Sitzung** in der Seitenleiste, oder drücken Sie **Cmd+N** auf macOS oder **Ctrl+N** auf Windows, um an mehreren Aufgaben parallel zu arbeiten. Drücken Sie **Ctrl+Tab** und **Ctrl+Shift+Tab**, um durch Sitzungen in der Seitenleiste zu zyklisieren. Für Git-Repositories erhält jede Sitzung ihre eigene isolierte Kopie Ihres Projekts mit [Git Worktrees](/de/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees), sodass Änderungen in einer Sitzung andere Sitzungen nicht beeinflussen, bis Sie sie committen.285Klicken Sie auf **+ Neue Sitzung** in der Seitenleiste, oder drücken Sie **Cmd+N** auf macOS oder **Ctrl+N** auf Windows, um an mehreren Aufgaben parallel zu arbeiten. Drücken Sie **Ctrl+Tab** und **Ctrl+Shift+Tab**, um durch Sitzungen in der Seitenleiste zu zyklisieren. Für Git-Repositories erhält jede Sitzung ihre eigene isolierte Kopie Ihres Projekts mit [Git Worktrees](/de/worktrees), sodass Änderungen in einer Sitzung andere Sitzungen nicht beeinflussen, bis Sie sie committen.

286

287Um zwei Sitzungen gleichzeitig anzuzeigen, halten Sie **Cmd** auf macOS oder **Ctrl** auf Windows gedrückt und klicken Sie auf eine Sitzung in der Seitenleiste. Die Sitzung wird in einem zweiten Bereich neben dem bereits geöffneten angezeigt. Während die Aufteilung aktiv ist, ersetzt das Klicken auf eine andere Sitzung in der Seitenleiste denjenigen Bereich, der den Fokus hat. Drücken Sie **Cmd+\\** auf macOS oder **Ctrl+\\** auf Windows, um den fokussierten Bereich zu schließen und zu einer einzelnen Sitzung zurückzukehren.

286 288

287Worktrees werden standardmäßig in `<project-root>/.claude/worktrees/` gespeichert. Sie können dies in Einstellungen → Claude Code unter 'Worktree-Speicherort" in ein benutzerdefiniertes Verzeichnis ändern. Sie können auch ein Branch-Präfix festlegen, das jedem Worktree-Branch-Namen vorangestellt wird, was nützlich ist, um von Claude erstellte Branches organisiert zu halten. Um einen Worktree zu entfernen, wenn Sie fertig sind, fahren Sie mit der Maus über die Sitzung in der Seitenleiste und klicken Sie auf das Archiv-Symbol. Um Sitzungen automatisch zu archivieren, wenn ihr Pull Request zusammengeführt oder geschlossen wird, schalten Sie **Auto-Archivieren nach PR-Merge oder -Schließung** in Einstellungen → Claude Code ein. Auto-Archivieren gilt nur für lokale Sitzungen, die beendet wurden.289Worktrees werden standardmäßig in `<project-root>/.claude/worktrees/` gespeichert. Sie können dies in Einstellungen → Claude Code unter 'Worktree-Speicherort" in ein benutzerdefiniertes Verzeichnis ändern. Sie können auch ein Branch-Präfix festlegen, das jedem Worktree-Branch-Namen vorangestellt wird, was nützlich ist, um von Claude erstellte Branches organisiert zu halten. Um einen Worktree zu entfernen, wenn Sie fertig sind, fahren Sie mit der Maus über die Sitzung in der Seitenleiste und klicken Sie auf das Archiv-Symbol. Um Sitzungen automatisch zu archivieren, wenn ihr Pull Request zusammengeführt oder geschlossen wird, schalten Sie **Auto-Archivieren nach PR-Merge oder -Schließung** in Einstellungen → Claude Code ein. Auto-Archivieren gilt nur für lokale Sitzungen, die beendet wurden.

288 290

289Um gitignorierte Dateien wie `.env` in neue Worktrees einzubeziehen, erstellen Sie eine [`.worktreeinclude`-Datei](/de/common-workflows#copy-gitignored-files-to-worktrees) in Ihrem Projektstammverzeichnis.291Um gitignorierte Dateien wie `.env` in neue Worktrees einzubeziehen, erstellen Sie eine [`.worktreeinclude`-Datei](/de/worktrees#copy-gitignored-files-into-worktrees) in Ihrem Projektstammverzeichnis.

290 292

291<Note>293<Note>

292 Die Sitzungsisolation erfordert [Git](https://git-scm.com/downloads). Die meisten Macs enthalten Git standardmäßig. Führen Sie `git --version` im Terminal aus, um zu überprüfen. Unter Windows ist Git erforderlich, damit die Registerkarte „Code" funktioniert: [Laden Sie Git für Windows herunter](https://git-scm.com/downloads/win), installieren Sie es und starten Sie die App neu. Wenn Sie auf Git-Fehler stoßen, bitten Sie Claude im [Cowork-Tab](https://claude.com/product/cowork), Ihnen bei der Behebung Ihres Setups zu helfen.294 Die Sitzungsisolation erfordert [Git](https://git-scm.com/downloads). Die meisten Macs enthalten Git standardmäßig. Führen Sie `git --version` im Terminal aus, um zu überprüfen. Unter Windows ist Git erforderlich, damit die Registerkarte „Code" funktioniert: [Laden Sie Git für Windows herunter](https://git-scm.com/downloads/win), installieren Sie es und starten Sie die App neu. Wenn Sie auf Git-Fehler stoßen, bitten Sie Claude im [Cowork-Tab](https://claude.com/product/cowork), Ihnen bei der Behebung Ihres Setups zu helfen.

516 518

517Um Umgebungsvariablen für lokale Sitzungen und Dev-Server auf jeder Plattform festzulegen, öffnen Sie das Umgebungs-Dropdown im Eingabefeld, fahren Sie mit der Maus über **Lokal** und klicken Sie auf das Zahnrad-Symbol, um den lokalen Umgebungs-Editor zu öffnen. Variablen, die Sie hier speichern, werden verschlüsselt auf Ihrem Computer gespeichert und gelten für jede lokale Sitzung und jeden Vorschau-Server, den Sie starten. Sie können auch Variablen zum Schlüssel `env` in Ihrer Datei `~/.claude/settings.json` hinzufügen, obwohl diese nur Claude-Sitzungen erreichen und nicht Dev-Server. Siehe [Umgebungsvariablen](/de/env-vars) für die vollständige Liste der unterstützten Variablen.519Um Umgebungsvariablen für lokale Sitzungen und Dev-Server auf jeder Plattform festzulegen, öffnen Sie das Umgebungs-Dropdown im Eingabefeld, fahren Sie mit der Maus über **Lokal** und klicken Sie auf das Zahnrad-Symbol, um den lokalen Umgebungs-Editor zu öffnen. Variablen, die Sie hier speichern, werden verschlüsselt auf Ihrem Computer gespeichert und gelten für jede lokale Sitzung und jeden Vorschau-Server, den Sie starten. Sie können auch Variablen zum Schlüssel `env` in Ihrer Datei `~/.claude/settings.json` hinzufügen, obwohl diese nur Claude-Sitzungen erreichen und nicht Dev-Server. Siehe [Umgebungsvariablen](/de/env-vars) für die vollständige Liste der unterstützten Variablen.

518 520

519[Erweitertes Denken](/de/common-workflows#use-extended-thinking-thinking-mode) ist standardmäßig aktiviert, was die Leistung bei komplexen Denkaufgaben verbessert, aber zusätzliche Token verwendet. Um das Denken vollständig zu deaktivieren, setzen Sie `MAX_THINKING_TOKENS` auf `0` im lokalen Umgebungs-Editor. Bei Modellen mit [adaptiver Argumentation](/de/model-config#adjust-effort-level) wird jeder andere `MAX_THINKING_TOKENS`-Wert ignoriert, da adaptive Argumentation die Denktiefe steuert. Bei Opus 4.6 und Sonnet 4.6 setzen Sie `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` auf `1`, um ein festes Denk-Budget zu verwenden; Opus 4.7 verwendet immer adaptive Argumentation und hat keinen Modus mit festem Budget.521[Erweitertes Denken](/de/model-config#extended-thinking) ist standardmäßig aktiviert, was die Leistung bei komplexen Denkaufgaben verbessert, aber zusätzliche Token verwendet. Um das Denken vollständig zu deaktivieren, setzen Sie `MAX_THINKING_TOKENS` auf `0` im lokalen Umgebungs-Editor. Bei Modellen mit [adaptiver Argumentation](/de/model-config#adjust-effort-level) wird jeder andere `MAX_THINKING_TOKENS`-Wert ignoriert, da adaptive Argumentation die Denktiefe steuert. Bei Opus 4.6 und Sonnet 4.6 setzen Sie `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` auf `1`, um ein festes Denk-Budget zu verwenden; Opus 4.7 verwendet immer adaptive Argumentation und hat keinen Modus mit festem Budget.

520 522

521### Remote-Sitzungen523### Remote-Sitzungen

522 524

523Remote-Sitzungen werden im Hintergrund fortgesetzt, auch wenn Sie die App schließen. Die Nutzung wird auf Ihre [Abonnementplanlimits](/de/costs) angerechnet, ohne separate Compute-Gebühren.525Remote-Sitzungen werden im Hintergrund fortgesetzt, auch wenn Sie die App schließen. Die Nutzung wird auf Ihre [Abonnementplanlimits](/de/costs) angerechnet, ohne separate Compute-Gebühren.

524 526

525Sie können benutzerdefinierte Cloud-Umgebungen mit verschiedenen Netzwerkzugriffsstufen und Umgebungsvariablen erstellen. Wählen Sie das Umgebungs-Dropdown beim Starten einer Remote-Sitzung und wählen Sie **Umgebung hinzufügen**. Siehe [Cloud-Umgebung](/de/claude-code-on-the-web#the-cloud-environment) für Details zur Konfiguration von Netzwerkzugriff und Umgebungsvariablen.527Sie können benutzerdefinierte Cloud-Umgebungen mit verschiedenen Netzwerkzugriffsstufen und Umgebungsvariablen erstellen. Wählen Sie das Umgebungs-Dropdown beim Starten einer Remote-Sitzung und wählen Sie **Umgebung hinzufügen**. Siehe [die Cloud-Umgebung](/de/claude-code-on-the-web#the-cloud-environment) für Details zur Konfiguration von Netzwerkzugriff und Umgebungsvariablen.

526 528

527### SSH-Sitzungen529### SSH-Sitzungen

528 530

529SSH-Sitzungen ermöglichen es Ihnen, Claude Code auf einem Remote-Computer auszuführen, während Sie die Desktop-App als Ihre Schnittstelle verwenden. Dies ist nützlich für die Arbeit mit Codebases, die auf Cloud-VMs, Dev-Containern oder Servern mit spezifischer Hardware oder Abhängigkeiten leben.531SSH-Sitzungen ermöglichen es Ihnen, Claude Code auf einem Remote-Computer auszuführen, während Sie die Desktop-App als Ihre Schnittstelle verwenden. Dies ist nützlich für die Arbeit mit Codebases, die auf Cloud-VMs, Dev-Containern oder Servern mit spezifischer Hardware oder Abhängigkeiten vorhanden sind.

530 532

531Um eine SSH-Verbindung hinzuzufügen, klicken Sie auf das Umgebungs-Dropdown vor dem Starten einer Sitzung und wählen Sie **+ SSH-Verbindung hinzufügen**. Der Dialog fragt nach:533Um eine SSH-Verbindung hinzuzufügen, klicken Sie auf das Umgebungs-Dropdown vor dem Starten einer Sitzung und wählen Sie **+ SSH-Verbindung hinzufügen**. Der Dialog fragt nach:

532 534

features-overview.md +53 −16

Details

12 Informationen zur Funktionsweise der Kern-Agentenschleife finden Sie unter [How Claude Code works](/de/how-claude-code-works).12 Informationen zur Funktionsweise der Kern-Agentenschleife finden Sie unter [How Claude Code works](/de/how-claude-code-works).

13</Note>13</Note>

14 14

~~15**Neu bei Claude Code?** Beginnen Sie mit [CLAUDE.md](/de/memory) für Projektkonventionen. Fügen Sie andere Erweiterungen nach Bedarf hinzu.~~15**Neu bei Claude Code?** Beginnen Sie mit [CLAUDE.md](/de/memory) für Projektkonventionen. Fügen Sie dann andere Erweiterungen [hinzu, wenn spezifische Trigger auftreten](#build-your-setup-over-time).

16 16

17## Übersicht17## Übersicht

18 18

23* **[MCP](/de/mcp)** verbindet Claude mit externen Diensten und Tools23* **[MCP](/de/mcp)** verbindet Claude mit externen Diensten und Tools

24* **[Subagents](/de/sub-agents)** führen ihre eigenen Schleifen in isoliertem Kontext aus und geben Zusammenfassungen zurück24* **[Subagents](/de/sub-agents)** führen ihre eigenen Schleifen in isoliertem Kontext aus und geben Zusammenfassungen zurück

25* **[Agent teams](/de/agent-teams)** koordinieren mehrere unabhängige Sitzungen mit gemeinsamen Aufgaben und Peer-to-Peer-Messaging25* **[Agent teams](/de/agent-teams)** koordinieren mehrere unabhängige Sitzungen mit gemeinsamen Aufgaben und Peer-to-Peer-Messaging

~~26* **[Hooks](/de/hooks)** laufen vollständig außerhalb der Schleife als deterministische Skripte~~26* **[Hooks](/de/hooks-guide)** werden bei Lebenszyklusereignissen ausgelöst und können ein Skript, eine HTTP-Anfrage, einen Prompt oder einen Subagent ausführen

27* **[Plugins](/de/plugins)** und **[Marketplaces](/de/plugin-marketplaces)** verpacken und verteilen diese Funktionen27* **[Plugins](/de/plugins)** und **[Marketplaces](/de/plugin-marketplaces)** verpacken und verteilen diese Funktionen

28 28

29[Skills](/de/skills) sind die flexibelste Erweiterung. Ein Skill ist eine Markdown-Datei, die Wissen, Workflows oder Anweisungen enthält. Sie können Skills mit einem Befehl wie `/deploy` aufrufen, oder Claude kann sie automatisch laden, wenn sie relevant sind. Skills können in Ihrer aktuellen Konversation oder in einem isolierten Kontext über Subagents ausgeführt werden.29[Skills](/de/skills) sind die flexibelste Erweiterung. Ein Skill ist eine Markdown-Datei, die Wissen, Workflows oder Anweisungen enthält. Sie können Skills mit einem Befehl wie `/deploy` aufrufen, oder Claude kann sie automatisch laden, wenn sie relevant sind. Skills können in Ihrer aktuellen Konversation oder in einem isolierten Kontext über Subagents ausgeführt werden.

39| **Subagent** | Isolierter Ausführungskontext, der zusammengefasste Ergebnisse zurückgibt | Kontextisolation, parallele Aufgaben, spezialisierte Worker | Recherche-Aufgabe, die viele Dateien liest, aber nur wichtige Erkenntnisse zurückgibt |39| **Subagent** | Isolierter Ausführungskontext, der zusammengefasste Ergebnisse zurückgibt | Kontextisolation, parallele Aufgaben, spezialisierte Worker | Recherche-Aufgabe, die viele Dateien liest, aber nur wichtige Erkenntnisse zurückgibt |

40| **[Agent teams](/de/agent-teams)** | Koordinieren Sie mehrere unabhängige Claude Code-Sitzungen | Parallele Recherche, neue Funktionsentwicklung, Debugging mit konkurrierenden Hypothesen | Spawnen Sie Reviewer, um Sicherheit, Leistung und Tests gleichzeitig zu überprüfen |40| **[Agent teams](/de/agent-teams)** | Koordinieren Sie mehrere unabhängige Claude Code-Sitzungen | Parallele Recherche, neue Funktionsentwicklung, Debugging mit konkurrierenden Hypothesen | Spawnen Sie Reviewer, um Sicherheit, Leistung und Tests gleichzeitig zu überprüfen |

41| **MCP** | Verbindung zu externen Diensten | Externe Daten oder Aktionen | Abfrage Ihrer Datenbank, Posten auf Slack, Steuerung eines Browsers |41| **MCP** | Verbindung zu externen Diensten | Externe Daten oder Aktionen | Abfrage Ihrer Datenbank, Posten auf Slack, Steuerung eines Browsers |

43 43

44**[Plugins](/de/plugins)** sind die Verpackungsebene. Ein Plugin bündelt Skills, Hooks, Subagents und MCP-Server in eine einzelne installierbare Einheit. Plugin-Skills sind namensgebunden (wie `/my-plugin:review`), sodass mehrere Plugins nebeneinander existieren können. Verwenden Sie Plugins, wenn Sie dasselbe Setup über mehrere Repositories hinweg wiederverwenden möchten oder es über einen **[Marketplace](/de/plugin-marketplaces)** an andere verteilen möchten.44**[Plugins](/de/plugins)** sind die Verpackungsebene. Ein Plugin bündelt Skills, Hooks, Subagents und MCP-Server in eine einzelne installierbare Einheit. Plugin-Skills sind namensgebunden (wie `/my-plugin:review`), sodass mehrere Plugins nebeneinander existieren können. Verwenden Sie Plugins, wenn Sie dasselbe Setup über mehrere Repositories hinweg wiederverwenden möchten oder es über einen **[Marketplace](/de/plugin-marketplaces)** an andere verteilen möchten.

45 45

~~46### Ähnliche Funktionen vergleichen~~46### Bauen Sie Ihr Setup im Laufe der Zeit auf

48Sie müssen nicht alles im Voraus konfigurieren. Jede Funktion hat einen erkennbaren Trigger, und die meisten Teams fügen sie ungefähr in dieser Reihenfolge hinzu:

50| Trigger | Hinzufügen |

51| :---------------------------------------------------------------------------------------------------- | :--------------------------------------------------------- |

52| Claude bekommt eine Konvention oder einen Befehl zweimal falsch | Fügen Sie es zu [CLAUDE.md](/de/memory) hinzu |

53| Sie tippen immer wieder denselben Prompt, um eine Aufgabe zu starten | Speichern Sie es als benutzer-aufrufen [Skill](/de/skills) |

54| Sie fügen zum dritten Mal dasselbe Playbook oder mehrstufige Verfahren in den Chat ein | Erfassen Sie es als [Skill](/de/skills) |

55| Sie kopieren immer wieder Daten aus einer Browser-Registerkarte, die Claude nicht sehen kann | Verbinden Sie dieses System als [MCP-Server](/de/mcp) |

56| Eine Nebenaufgabe überschwemmt Ihre Konversation mit Ausgabe, auf die Sie nicht mehr verweisen werden | Leiten Sie sie durch einen [Subagent](/de/sub-agents) |

57| Sie möchten, dass etwas jedes Mal passiert, ohne zu fragen | Schreiben Sie einen [Hook](/de/hooks-guide) |

58| Ein zweites Repository benötigt dasselbe Setup | Verpacken Sie es als [Plugin](/de/plugins) |

60Die gleichen Trigger sagen Ihnen, wann Sie das aktualisieren, was Sie bereits haben. Ein wiederholter Fehler oder ein wiederkehrender Review-Kommentar ist eine CLAUDE.md-Bearbeitung, keine einmalige Korrektur im Chat. Ein Workflow, den Sie immer wieder von Hand anpassen, ist ein Skill, der eine weitere Überarbeitung benötigt.

62### Vergleichen Sie ähnliche Funktionen

47 63

48Einige Funktionen können ähnlich wirken. Hier erfahren Sie, wie Sie sie unterscheiden.64Einige Funktionen können ähnlich wirken. Hier erfahren Sie, wie Sie sie unterscheiden.

49 65

55 * **Subagents** sind isolierte Worker, die separat von Ihrer Hauptkonversation ausgeführt werden71 * **Subagents** sind isolierte Worker, die separat von Ihrer Hauptkonversation ausgeführt werden

56 72

~~58 | ----------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------- |~~74 | --------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------- |

77 | **[Kontextfenster](/de/context-window) Auswirkung** | Wird zu Ihrem Hauptfenster hinzugefügt | Verwendet ein separates Fenster mit eigenen Input- und Output-Tokens |

62 79

63 **Skills können Referenz oder Aktion sein.** Referenz-Skills bieten Wissen, das Claude während Ihrer Sitzung nutzt (wie Ihr API-Stilhandbuch). Action-Skills sagen Claude, etwas Bestimmtes zu tun (wie `/deploy`, das Ihren Bereitstellungs-Workflow ausführt).80 **Skills können Referenz oder Aktion sein.** Referenz-Skills bieten Wissen, das Claude während Ihrer Sitzung nutzt (wie Ihr API-Stilhandbuch). Action-Skills sagen Claude, etwas Bestimmtes zu tun (wie `/deploy`, das Ihren Bereitstellungs-Workflow ausführt).

64 81

65 **Verwenden Sie einen Subagent**, wenn Sie Kontextisolation benötigen oder wenn Ihr Kontextfenster voll wird. Der Subagent könnte Dutzende von Dateien lesen oder umfangreiche Suchen durchführen, aber Ihre Hauptkonversation erhält nur eine Zusammenfassung. Da die Arbeit des Subagent Ihren Hauptkontext nicht verbraucht, ist dies auch nützlich, wenn Sie nicht möchten, dass die Zwischenarbeit sichtbar bleibt. Benutzerdefinierte Subagents können ihre eigenen Anweisungen haben und Skills vorladen.82 **Verwenden Sie einen Subagent**, wenn Sie Kontextisolation benötigen oder wenn Ihr Kontextfenster voll wird. Der Subagent könnte Dutzende von Dateien lesen oder umfangreiche Suchen durchführen, aber Ihre Hauptkonversation erhält nur eine Zusammenfassung. Da die Arbeit des Subagent Ihren Hauptkontext nicht verbraucht, ist dies auch nützlich, wenn Sie nicht möchten, dass die Zwischenarbeit sichtbar bleibt. Benutzerdefinierte Subagents können ihre eigenen Anweisungen haben und können Skills vorladen.

66 83

67 **Sie können sich kombinieren.** Ein Subagent kann spezifische Skills vorladen (`skills:`-Feld). Ein Skill kann in isoliertem Kontext mit `context: fork` ausgeführt werden. Weitere Informationen finden Sie unter [Skills](/de/skills).84 **Sie können sich kombinieren.** Ein Subagent kann spezifische Skills vorladen (`skills:`-Feld). Ein Skill kann in isoliertem Kontext mit `context: fork` ausgeführt werden. Weitere Informationen finden Sie unter [Skills](/de/skills).

68 </Tab>85 </Tab>

142 159

143 Beispiel: Ein MCP-Server verbindet Claude mit Ihrer Datenbank. Ein Skill lehrt Claude Ihr Datenmodell, häufige Abfragemuster und welche Tabellen für verschiedene Aufgaben verwendet werden.160 Beispiel: Ein MCP-Server verbindet Claude mit Ihrer Datenbank. Ein Skill lehrt Claude Ihr Datenmodell, häufige Abfragemuster und welche Tabellen für verschiedene Aufgaben verwendet werden.

144 </Tab>161 </Tab>

162

163 <Tab title="Hook vs Skill">

164 Ein Hook wird bei einem Lebenszyklusereignis ausgelöst; ein Skill wird in den Kontext geladen, damit Claude ihn anwendet.

165

166 | Aspekt | Hook | Skill |

167 | ------------------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |

168 | **Läuft** | Ein Shell-Befehl, eine HTTP-Anfrage, ein LLM-Prompt oder ein Subagent | Anweisungen, die Claude liest und befolgt |

169 | **Ausgelöst durch** | [Lebenszyklusereignisse](/de/hooks#hook-events) wie `PostToolUse` oder `SessionStart` | Sie tippen `/<name>`, oder Claude passt die Beschreibung zu Ihrer Aufgabe an |

170 | **Determinismus** | Wird immer bei seinem Ereignis ausgelöst; der Trigger ist garantiert | Claude interpretiert die Anweisungen; das Ergebnis kann variieren |

171 | **Kontextkosten** | Null, es sei denn, der Hook gibt Ausgabe zurück | Beschreibung lädt jede Sitzung; vollständiger Inhalt lädt bei Verwendung |

172 | **Am besten für** | Linting nach Bearbeitungen, Blockierung unsicherer Befehle, Logging, Benachrichtigungen | Workflows, die Überlegung benötigen, Referenzmaterial, mehrstufige Aufgaben |

173

174 **Verwenden Sie einen Hook**, wenn die Aktion jedes Mal auf die gleiche Weise erfolgen muss und Claude nicht denken muss. Beispiel: Formatierung beim Speichern, Ablehnung von `rm -rf /`, Posten einer Slack-Nachricht, wenn eine Sitzung endet.

175

176 **Verwenden Sie einen Skill**, wenn Claude entscheiden sollte, wie die Schritte angewendet werden, oder wenn der Inhalt eher Wissen als ein Skript ist. Beispiel: eine `/release`-Checkliste, Ihr API-Stilhandbuch, ein Debugging-Playbook.

177

178 **Setzen Sie Schutzmaßnahmen in Hooks.** Eine Anweisung wie „niemals `.env` bearbeiten" in CLAUDE.md oder einem Skill ist eine Anfrage, keine Garantie. Ein `PreToolUse`-Hook, der die Bearbeitung blockiert, ist Durchsetzung. Wenn eine Regel jedes Mal gelten muss, machen Sie sie zu einem Hook statt zu einer Prompt-Anweisung.

179

180 **Hook-Ausgabe landet im Kontext.** Ein `PostToolUse`-Hook, der Ihren Linter ausführt, gibt Ergebnisse als Text zurück, den Claude liest; ein `/fix-lint`-Skill sagt Claude, wie sie zu beheben sind.

181 </Tab>

145</Tabs>182</Tabs>

146 183

147### Verstehen Sie, wie Funktionen sich schichten184### Verstehen Sie, wie Funktionen sich schichten

153* **MCP-Server** überschreiben nach Name: lokal > Projekt > Benutzer. Siehe [MCP-Umfang](/de/mcp#scope-hierarchy-and-precedence).190* **MCP-Server** überschreiben nach Name: lokal > Projekt > Benutzer. Siehe [MCP-Umfang](/de/mcp#scope-hierarchy-and-precedence).

154* **Hooks** zusammenführen: alle registrierten Hooks werden für ihre übereinstimmenden Ereignisse unabhängig von der Quelle ausgelöst. Siehe [Hooks](/de/hooks).191* **Hooks** zusammenführen: alle registrierten Hooks werden für ihre übereinstimmenden Ereignisse unabhängig von der Quelle ausgelöst. Siehe [Hooks](/de/hooks).

155 192

156### Funktionen kombinieren193### Kombinieren Sie Funktionen

157 194

158Jede Erweiterung löst ein anderes Problem: CLAUDE.md behandelt immer aktivem Kontext, Skills behandeln On-Demand-Wissen und Workflows, MCP behandelt externe Verbindungen, Subagents behandeln Isolation und Hooks behandeln Automatisierung. Echte Setups kombinieren sie basierend auf Ihrem Workflow.195Jede Erweiterung löst ein anderes Problem: CLAUDE.md behandelt immer aktivem Kontext, Skills behandeln On-Demand-Wissen und Workflows, MCP behandelt externe Verbindungen, Subagents behandeln Isolation und Hooks behandeln Automatisierung. Echte Setups kombinieren sie basierend auf Ihrem Workflow.

159 196

163| ---------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |200| ---------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |

165| **Skill + Subagent** | Ein Skill spawnt Subagents für parallele Arbeit | `/audit`-Skill startet Sicherheits-, Leistungs- und Style-Subagents, die in isoliertem Kontext arbeiten |202| **Skill + Subagent** | Ein Skill spawnt Subagents für parallele Arbeit | `/audit`-Skill startet Sicherheits-, Leistungs- und Style-Subagents, die in isoliertem Kontext arbeiten |

166| **CLAUDE.md + Skills** | CLAUDE.md hält immer aktivem Regeln; Skills halten Referenzmaterial, das On Demand geladen wird | CLAUDE.md sagt 'folgen Sie unseren API-Konventionen", ein Skill enthält das vollständige API-Stilhandbuch |203| **CLAUDE.md + Skills** | CLAUDE.md hält immer aktivem Regeln; Skills halten Referenzmaterial, das On Demand geladen wird | CLAUDE.md sagt „folgen Sie unseren API-Konventionen", ein Skill enthält das vollständige API-Stilhandbuch |

168 205

169## Verstehen Sie Kontextkosten206## Verstehen Sie Kontextkosten

170 207

171Jede Funktion, die Sie hinzufügen, verbraucht etwas von Claudes Kontext. Zu viel kann Ihr Kontextfenster füllen, aber es kann auch Rauschen hinzufügen, das Claude weniger effektiv macht; Skills werden möglicherweise nicht korrekt ausgelöst, oder Claude kann Ihre Konventionen aus den Augen verlieren. Das Verständnis dieser Kompromisse hilft Ihnen, ein effektives Setup zu erstellen.208Jede Funktion, die Sie hinzufügen, verbraucht etwas von Claudes Kontext. Zu viel kann Ihr Kontextfenster füllen, aber es kann auch Rauschen hinzufügen, das Claude weniger effektiv macht; Skills werden möglicherweise nicht korrekt ausgelöst, oder Claude kann Ihre Konventionen aus den Augen verlieren. Das Verständnis dieser Kompromisse hilft Ihnen, ein effektives Setup zu erstellen. Für eine interaktive Ansicht, wie diese Funktionen in einer laufenden Sitzung kombiniert werden, siehe [Erkunden Sie das Kontextfenster](/de/context-window).

172 209

173### Kontextkosten nach Funktion210### Kontextkosten nach Funktion

174 211

178| -------------- | ------------------------------ | -------------------------------------------------------------- | -------------------------------------------------------- |215| -------------- | ------------------------------ | -------------------------------------------------------------- | -------------------------------------------------------- |

184 221

186 223

187### Verstehen Sie, wie Funktionen geladen werden224### Verstehen Sie, wie Funktionen geladen werden

188 225

189Jede Funktion wird an verschiedenen Punkten in Ihrer Sitzung geladen. Die folgenden Registerkarten erklären, wann jede geladen wird und was in den Kontext geht.226Jede Funktion wird an verschiedenen Punkten in Ihrer Sitzung geladen. Die Registerkarten unten erklären, wann jede geladen wird und was in den Kontext geht.

190 227

191<img src="https://mintcdn.com/claude-code/6yTCYq1p37ZB8-CQ/images/context-loading.svg?fit=max&auto=format&n=6yTCYq1p37ZB8-CQ&q=85&s=5a58ce953a35a2412892015e2ad6cb67" alt="Kontextladung: CLAUDE.md und MCP werden beim Sitzungsstart geladen und bleiben in jeder Anfrage. Skills laden Beschreibungen beim Start, vollständigen Inhalt bei Aufruf. Subagents erhalten isolierten Kontext. Hooks laufen extern." width="720" height="410" data-path="images/context-loading.svg" />228<img src="https://mintcdn.com/claude-code/6yTCYq1p37ZB8-CQ/images/context-loading.svg?fit=max&auto=format&n=6yTCYq1p37ZB8-CQ&q=85&s=5a58ce953a35a2412892015e2ad6cb67" alt="Kontextladung: CLAUDE.md lädt beim Sitzungsstart und bleibt in jeder Anfrage. MCP-Tool-Namen laden beim Start mit vollständigen Schemas, die bis zur Verwendung aufgeschoben werden. Skills laden Beschreibungen beim Start, vollständigen Inhalt bei Aufruf. Subagents erhalten isolierten Kontext. Hooks laufen extern." width="720" height="410" data-path="images/context-loading.svg" />

192 229

193<Tabs>230<Tabs>

194 <Tab title="CLAUDE.md">231 <Tab title="CLAUDE.md">

202 </Tab>239 </Tab>

203 240

204 <Tab title="Skills">241 <Tab title="Skills">

205 Skills sind zusätzliche Funktionen in Claudes Toolkit. Sie können Referenzmaterial sein (wie ein API-Stilhandbuch) oder aufrufbare Workflows, die Sie mit `/<name>` auslösen (wie `/deploy`). Claude Code wird mit [gebündelten Skills](/de/skills#bundled-skills) wie `/simplify`, `/batch` und `/debug` ausgeliefert, die sofort funktionieren. Sie können auch Ihre eigenen erstellen. Claude verwendet Skills, wenn angemessen, oder Sie können einen direkt aufrufen.242 Skills sind zusätzliche Funktionen in Claudes Toolkit. Sie können Referenzmaterial sein (wie ein API-Stilhandbuch) oder aufrufbare Workflows, die Sie mit `/<name>` auslösen (wie `/deploy`). Claude Code wird mit [gebündelten Skills](/de/commands) wie `/simplify`, `/batch` und `/debug` ausgeliefert, die sofort funktionieren. Sie können auch Ihre eigenen erstellen. Claude verwendet Skills, wenn angemessen, oder Sie können einen direkt aufrufen.

206 243

207 **Wann:** Hängt von der Konfiguration des Skills ab. Standardmäßig werden Beschreibungen beim Sitzungsstart geladen und vollständiger Inhalt bei Verwendung. Für nur-Benutzer-Skills (`disable-model-invocation: true`) wird nichts geladen, bis Sie sie aufrufen.244 **Wann:** Hängt von der Konfiguration des Skills ab. Standardmäßig werden Beschreibungen beim Sitzungsstart geladen und vollständiger Inhalt bei Verwendung. Für nur-Benutzer-Skills (`disable-model-invocation: true`) wird nichts geladen, bis Sie sie aufrufen.

208 245

220 <Tab title="MCP-Server">257 <Tab title="MCP-Server">

221 **Wann:** Sitzungsstart.258 **Wann:** Sitzungsstart.

222 259

223 **Was lädt:** Alle Tool-Definitionen und JSON-Schemas von verbundenen Servern.260 **Was lädt:** Tool-Namen von verbundenen Servern. Vollständige JSON-Schemas bleiben aufgeschoben, bis Claude ein bestimmtes Tool benötigt.

224 261

225 **Kontextkosten:** [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) (standardmäßig aktiviert) lädt MCP-Tools bis zu 10% des Kontexts und verschiebt den Rest bis zur Notwendigkeit.262 **Kontextkosten:** [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) ist standardmäßig aktiviert, sodass untätige MCP-Tools minimalen Kontext verbrauchen.

226 263

227 **Zuverlässigkeitshinweis:** MCP-Verbindungen können während einer Sitzung stillschweigend fehlschlagen. Wenn ein Server die Verbindung trennt, verschwinden seine Tools ohne Warnung. Claude kann versuchen, ein Tool zu verwenden, das nicht mehr vorhanden ist. Wenn Sie bemerken, dass Claude ein MCP-Tool nicht verwenden kann, auf das es zuvor zugreifen konnte, überprüfen Sie die Verbindung mit `/mcp`.264 **Zuverlässigkeitshinweis:** MCP-Verbindungen können während einer Sitzung stillschweigend fehlschlagen. Wenn ein Server die Verbindung trennt, verschwinden seine Tools ohne Warnung. Claude kann versuchen, ein Tool zu verwenden, das nicht mehr vorhanden ist. Wenn Sie bemerken, dass Claude ein MCP-Tool nicht verwenden kann, auf das es zuvor zugreifen konnte, überprüfen Sie die Verbindung mit `/mcp`.

228 265

247 <Tab title="Hooks">284 <Tab title="Hooks">

248 **Wann:** Bei Auslösung. Hooks werden bei bestimmten Lebenszyklusereignissen ausgelöst, wie Tool-Ausführung, Sitzungsgrenzen, Prompt-Einreichung, Berechtigungsanfragen und Komprimierung. Siehe [Hooks](/de/hooks) für die vollständige Liste.285 **Wann:** Bei Auslösung. Hooks werden bei bestimmten Lebenszyklusereignissen ausgelöst, wie Tool-Ausführung, Sitzungsgrenzen, Prompt-Einreichung, Berechtigungsanfragen und Komprimierung. Siehe [Hooks](/de/hooks) für die vollständige Liste.

249 286

250 **Was lädt:** Standardmäßig nichts. Hooks laufen als externe Skripte.287 **Was lädt:** Standardmäßig nichts. Hooks laufen außerhalb der Hauptkonversation.

251 288

252 **Kontextkosten:** Null, es sei denn, der Hook gibt Ausgabe zurück, die als Nachrichten zu Ihrer Konversation hinzugefügt wird.289 **Kontextkosten:** Null, es sei denn, der Hook gibt Ausgabe zurück, die als Nachrichten zu Ihrer Konversation hinzugefügt wird.

253 290

hooks.md +4 −4

Details

974| `decision` | `"block"` verhindert die Verarbeitung des Prompts und löscht ihn aus dem Kontext. Weglassen, um den Prompt fortzusetzen |974| `decision` | `"block"` verhindert die Verarbeitung des Prompts und löscht ihn aus dem Kontext. Weglassen, um den Prompt fortzusetzen |

976| `additionalContext` | Zeichenkette, die zu Claudes Kontext hinzugefügt wird, zusammen mit dem eingereichten Prompt. Siehe [Kontext für Claude hinzufügen](#add-context-for-claude) |976| `additionalContext` | Zeichenkette, die zu Claudes Kontext hinzugefügt wird, zusammen mit dem eingereichten Prompt. Siehe [Kontext für Claude hinzufügen](#add-context-for-claude) |

977| `sessionTitle` | Setzt den Sitzungstitel, gleiche Auswirkung wie `/rename`. Verwenden Sie, um Sitzungen automatisch basierend auf dem Prompt-Inhalt zu benennen |977| `sessionTitle` | Setzt den Sitzungstitel. Verwenden Sie, um Sitzungen automatisch basierend auf dem Prompt-Inhalt zu benennen |

978 978

979```json theme={null}979```json theme={null}

980{980{

2407```2407```

2408 2408

2409| Feld | Beschreibung |2409| Feld | Beschreibung |

2410| :------- | :----------------------------------------------------------------- |2410| :------- | :----------------------------------------------------------------------------------------------- |

2411| `ok` | `true` erlaubt die Aktion, `false` verhindert sie |2411| `ok` | `true` erlaubt die Aktion, `false` verhindert sie. Siehe das ereignisspezifische Verhalten unten |

2413 2413

2414Was bei `ok: false` passiert, hängt vom Ereignis ab:2414Was bei `ok: false` passiert, hängt vom Ereignis ab:

2415 2415

permissions.md +5 −5

Details

36| :------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |36| :------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

38| `acceptEdits` | Akzeptiert automatisch Dateiberechtigungen und häufige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp` usw.) für Pfade im Arbeitsverzeichnis oder `additionalDirectories` |38| `acceptEdits` | Akzeptiert automatisch Dateiberechtigungen und häufige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp` usw.) für Pfade im Arbeitsverzeichnis oder `additionalDirectories` |

40| `auto` | Genehmigt Werkzeugaufrufe automatisch mit Hintergrund-Sicherheitsprüfungen, die überprüfen, ob Aktionen mit Ihrer Anfrage übereinstimmen. Derzeit eine Forschungsvorschau |40| `auto` | Genehmigt Werkzeugaufrufe automatisch mit Hintergrund-Sicherheitsprüfungen, die überprüfen, ob Aktionen mit Ihrer Anfrage übereinstimmen. Derzeit eine Forschungsvorschau |

41| `dontAsk` | Verweigert Werkzeuge automatisch, es sei denn, sie sind vorab über `/permissions` oder `permissions.allow`-Regeln genehmigt |41| `dontAsk` | Verweigert Werkzeuge automatisch, es sei denn, sie sind vorab über `/permissions` oder `permissions.allow`-Regeln genehmigt |

42| `bypassPermissions` | Überspringt alle Berechtigungsaufforderungen. Entfernungen von Dateisystem-Root oder Home-Verzeichnis wie `rm -rf /` und `rm -rf ~` fordern weiterhin auf als Schutzschalter gegen Modellfehler |42| `bypassPermissions` | Überspringt alle Berechtigungsaufforderungen. Entfernungen von Dateisystem-Root oder Home-Verzeichnis wie `rm -rf /` und `rm -rf ~` fordern weiterhin auf als Schutzschalter gegen Modellfehler |

296 296

297* Berechtigungs-Deny-Regeln blockieren Claude daran, überhaupt zu versuchen, auf eingeschränkte Ressourcen zuzugreifen297* Berechtigungs-Deny-Regeln blockieren Claude daran, überhaupt zu versuchen, auf eingeschränkte Ressourcen zuzugreifen

298* Sandbox-Einschränkungen verhindern, dass Bash-Befehle Ressourcen außerhalb definierter Grenzen erreichen, selbst wenn eine Prompt-Injection Claude's Entscheidungsfindung umgeht298* Sandbox-Einschränkungen verhindern, dass Bash-Befehle Ressourcen außerhalb definierter Grenzen erreichen, selbst wenn eine Prompt-Injection Claude's Entscheidungsfindung umgeht

299* Dateisystem-Einschränkungen in der Sandbox verwenden Read- und Edit-Deny-Regeln, nicht separate Sandbox-Konfiguration299* Dateisystem-Einschränkungen in der Sandbox kombinieren die [`sandbox.filesystem`](/de/sandboxing)-Einstellungen mit Read- und Edit-Deny-Regeln; beide werden in die endgültige Sandbox-Grenze zusammengeführt

300* Netzwerk-Einschränkungen kombinieren WebFetch-Berechtigungsregeln mit den `allowedDomains`- und `deniedDomains`-Listen der Sandbox300* Netzwerk-Einschränkungen kombinieren WebFetch-Berechtigungsregeln mit den `allowedDomains`- und `deniedDomains`-Listen der Sandbox

301 301

302Wenn Sandboxing mit `autoAllowBashIfSandboxed: true` aktiviert ist, was die Standardeinstellung ist, laufen sandboxed Bash-Befehle ohne Aufforderung, selbst wenn Ihre Berechtigungen `ask: Bash(*)` enthalten. Die Sandbox-Grenze ersetzt die Pro-Befehl-Aufforderung. Explizite Deny-Regeln gelten weiterhin, und `rm`- oder `rmdir`-Befehle, die auf `/`, Ihr Home-Verzeichnis oder andere kritische Systempfade abzielen, lösen weiterhin eine Aufforderung aus. Siehe [Sandbox-Modi](/de/sandboxing#sandbox-modes), um dieses Verhalten zu ändern.302Wenn Sandboxing mit `autoAllowBashIfSandboxed: true` aktiviert ist, was die Standardeinstellung ist, laufen sandboxed Bash-Befehle ohne Aufforderung, selbst wenn Ihre Berechtigungen `ask: Bash(*)` enthalten. Die Sandbox-Grenze ersetzt die Pro-Befehl-Aufforderung. Explizite Deny-Regeln gelten weiterhin, und `rm`- oder `rmdir`-Befehle, die auf `/`, Ihr Home-Verzeichnis oder andere kritische Systempfade abzielen, lösen weiterhin eine Aufforderung aus. Siehe [Sandbox-Modi](/de/sandboxing#sandbox-modes), um dieses Verhalten zu ändern.

316| `allowManagedMcpServersOnly` | Wenn `true`, werden nur `allowedMcpServers` aus verwalteten Einstellungen berücksichtigt. `deniedMcpServers` wird immer noch aus allen Quellen zusammengeführt. Siehe [Verwaltete MCP-Konfiguration](/de/mcp#managed-mcp-configuration) |316| `allowManagedMcpServersOnly` | Wenn `true`, werden nur `allowedMcpServers` aus verwalteten Einstellungen berücksichtigt. `deniedMcpServers` wird immer noch aus allen Quellen zusammengeführt. Siehe [Verwaltete MCP-Konfiguration](/de/mcp#managed-mcp-configuration) |

317| `allowManagedPermissionRulesOnly` | Wenn `true`, verhindert, dass Benutzer- und Projekteinstellungen `allow`-, `ask`- oder `deny`-Berechtigungsregeln definieren. Nur Regeln in verwalteten Einstellungen gelten |317| `allowManagedPermissionRulesOnly` | Wenn `true`, verhindert, dass Benutzer- und Projekteinstellungen `allow`-, `ask`- oder `deny`-Berechtigungsregeln definieren. Nur Regeln in verwalteten Einstellungen gelten |

318| `blockedMarketplaces` | Blocklist von Marketplace-Quellen. Blockierte Quellen werden vor dem Download überprüft, sodass sie das Dateisystem nie berühren. Siehe [verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) |318| `blockedMarketplaces` | Blocklist von Marketplace-Quellen. Blockierte Quellen werden vor dem Download überprüft, sodass sie das Dateisystem nie berühren. Siehe [verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) |

319| `channelsEnabled` | Ermöglichen Sie [Channels](/de/channels) für Team- und Enterprise-Benutzer. Nicht gesetzt oder `false` blockiert die Nachrichtenübermittlung über Channels, unabhängig davon, was Benutzer an `--channels` übergeben |319| `channelsEnabled` | Ermöglichen Sie [Channels](/de/channels) für die Organisation. Siehe [Enterprise-Kontrollen](/de/channels#enterprise-controls) für die Standardeinstellung bei jedem Plan |

320| `forceRemoteSettingsRefresh` | Wenn `true`, blockiert CLI-Start, bis remote verwaltete Einstellungen aktuell abgerufen werden, und beendet sich, wenn der Abruf fehlschlägt. Siehe [Fail-Closed-Durchsetzung](/de/server-managed-settings#enforce-fail-closed-startup) |320| `forceRemoteSettingsRefresh` | Wenn `true`, blockiert CLI-Start, bis remote verwaltete Einstellungen aktuell abgerufen werden, und beendet sich, wenn der Abruf fehlschlägt. Siehe [Fail-Closed-Durchsetzung](/de/server-managed-settings#enforce-fail-closed-startup) |

321| `pluginTrustMessage` | Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung hinzugefügt wird |321| `pluginTrustMessage` | Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung hinzugefügt wird |

322| `sandbox.filesystem.allowManagedReadPathsOnly` | Wenn `true`, werden nur `filesystem.allowRead`-Pfade aus verwalteten Einstellungen berücksichtigt. `denyRead` wird immer noch aus allen Quellen zusammengeführt |322| `sandbox.filesystem.allowManagedReadPathsOnly` | Wenn `true`, werden nur `filesystem.allowRead`-Pfade aus verwalteten Einstellungen berücksichtigt. `denyRead` wird immer noch aus allen Quellen zusammengeführt |

323| `sandbox.network.allowManagedDomainsOnly` | Wenn `true`, werden nur `allowedDomains` und `WebFetch(domain:...)`-Allow-Regeln aus verwalteten Einstellungen berücksichtigt. Nicht zulässige Domänen werden automatisch blockiert, ohne den Benutzer zu fragen. Verweigerte Domänen werden immer noch aus allen Quellen zusammengeführt |323| `sandbox.network.allowManagedDomainsOnly` | Wenn `true`, werden nur `allowedDomains` und `WebFetch(domain:...)`-Allow-Regeln aus verwalteten Einstellungen berücksichtigt. Nicht zulässige Domänen werden automatisch blockiert, ohne den Benutzer zu fragen. Verweigerte Domänen werden immer noch aus allen Quellen zusammengeführt |

324| `strictKnownMarketplaces` | Steuert, welche Plugin-Marketplaces Benutzer hinzufügen können. Siehe [verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) |324| `strictKnownMarketplaces` | Steuert, welche Plugin-Marketplace-Quellen Benutzer hinzufügen und Plugins installieren können. Siehe [verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) |

325| `wslInheritsWindowsSettings` | Wenn `true` im Windows HKLM-Registrierungsschlüssel oder in `C:\Program Files\ClaudeCode\managed-settings.json`, liest WSL verwaltete Einstellungen aus der Windows-Richtlinienkette zusätzlich zu `/etc/claude-code`. Siehe [Einstellungsdateien](/de/settings#settings-files) |325| `wslInheritsWindowsSettings` | Wenn `true` im Windows HKLM-Registrierungsschlüssel oder in `C:\Program Files\ClaudeCode\managed-settings.json`, liest WSL verwaltete Einstellungen aus der Windows-Richtlinienkette zusätzlich zu `/etc/claude-code`. Siehe [Einstellungsdateien](/de/settings#settings-files) |

326 326

327`disableBypassPermissionsMode` wird normalerweise in verwalteten Einstellungen platziert, um Organisationsrichtlinien durchzusetzen, funktioniert aber aus jedem Bereich. Ein Benutzer kann es in seinen eigenen Einstellungen festlegen, um sich selbst aus dem Bypass-Modus auszusperren.327`disableBypassPermissionsMode` wird normalerweise in verwalteten Einstellungen platziert, um Organisationsrichtlinien durchzusetzen, funktioniert aber aus jedem Bereich. Ein Benutzer kann es in seinen eigenen Einstellungen festlegen, um sich selbst aus dem Bypass-Modus auszusperren.

328 328

329<Note>329<Note>

330 Der Zugriff auf [Remote Control](/de/remote-control) und [Web-Sitzungen](/de/claude-code-on-the-web) wird nicht durch einen Schlüssel für verwaltete Einstellungen gesteuert. Bei Team- und Enterprise-Plänen aktiviert oder deaktiviert ein Administrator diese Funktionen in [Claude Code-Administratoreinstellungen](https://claude.ai/admin-settings/claude-code).330 Bei Team- und Enterprise-Plänen aktiviert oder deaktiviert ein Administrator [Remote Control](/de/remote-control) und [Web-Sitzungen](/de/claude-code-on-the-web) organisationsweit in [Claude Code-Administratoreinstellungen](https://claude.ai/admin-settings/claude-code). Remote Control kann zusätzlich pro Gerät mit der verwalteten Einstellung [`disableRemoteControl`](/de/settings#available-settings) deaktiviert werden. Web-Sitzungen haben keinen verwalteten Einstellungsschlüssel pro Gerät.

331</Note>331</Note>

332 332

333## Einstellungspriorität333## Einstellungspriorität

platforms.md +6 −3

Details

13Wählen Sie eine Plattform basierend auf Ihrer bevorzugten Arbeitsweise und dem Ort Ihres Projekts.13Wählen Sie eine Plattform basierend auf Ihrer bevorzugten Arbeitsweise und dem Ort Ihres Projekts.

14 14

16| :-------------------------------- | :-------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------- |16| :-------------------------------- | :-------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

17| [CLI](/de/quickstart) | Terminal-Arbeitsabläufe, Scripting, Remote-Server | Vollständiger Funktionsumfang, [Agent SDK](/de/headless), Drittanbieter-Provider |17| [CLI](/de/quickstart) | Terminal-Arbeitsabläufe, Scripting, Remote-Server | Vollständiger Funktionsumfang, [Agent SDK](/de/headless), [Computernutzung](/de/computer-use) auf macOS (Pro und Max), Drittanbieter-Provider |

18| [Desktop](/de/desktop) | Visuelle Überprüfung, parallele Sitzungen, verwaltetes Setup | Diff-Viewer, App-Vorschau, [Computernutzung](/de/desktop#let-claude-use-your-computer) und [Dispatch](/de/desktop#sessions-from-dispatch) auf Pro und Max |18| [Desktop](/de/desktop) | Visuelle Überprüfung, parallele Sitzungen, verwaltetes Setup | Diff-Viewer, App-Vorschau, [Computernutzung](/de/desktop#let-claude-use-your-computer) und [Dispatch](/de/desktop#sessions-from-dispatch) auf Pro und Max |

21| [Web](/de/claude-code-on-the-web) | Langfristige Aufgaben, die nicht viel Steuerung benötigen, oder Arbeiten, die offline fortgesetzt werden sollen | Von Anthropic verwaltete Cloud, wird nach dem Trennen fortgesetzt |21| [Web](/de/claude-code-on-the-web) | Langfristige Aufgaben, die nicht viel Steuerung benötigen, oder Arbeiten, die offline fortgesetzt werden sollen | Von Anthropic verwaltete Cloud, wird nach dem Trennen fortgesetzt |

22| Mobile | Starten und Überwachen von Aufgaben, wenn Sie weg von Ihrem Computer sind | Cloud-Sitzungen aus der Claude-App für iOS und Android, [Remote Control](/de/remote-control) für lokale Sitzungen, [Dispatch](/de/desktop#sessions-from-dispatch) zu Desktop auf Pro und Max |

22 23

23Die CLI ist die vollständigste Oberfläche für Terminal-native Arbeiten: Scripting, Drittanbieter-Provider und das Agent SDK sind nur in der CLI verfügbar. Desktop und die IDE-Erweiterungen verzichten auf einige CLI-exklusive Funktionen zugunsten visueller Überprüfung und engerer Editor-Integration. Das Web läuft in Anthropics Cloud, sodass Aufgaben nach dem Trennen weitergehen.24Die CLI ist die vollständigste Oberfläche für Terminal-native Arbeiten: Scripting und das Agent SDK sind nur in der CLI verfügbar. Drittanbieter-Provider funktionieren auch in [VS Code](/de/vs-code#use-third-party-providers). Enterprise-[Desktop](/de/desktop)-Bereitstellungen unterstützen Vertex AI und Gateway-Provider; für Bedrock oder Foundry verwenden Sie stattdessen die CLI oder VS Code anstelle von Desktop. Desktop und die IDE-Erweiterungen verzichten auf einige CLI-exklusive Funktionen zugunsten visueller Überprüfung und engerer Editor-Integration. Das Web läuft in Anthropics Cloud, sodass Aufgaben nach dem Trennen weitergehen. Mobile ist ein einfacher Client für diese gleichen Cloud-Sitzungen oder für eine lokale Sitzung über Remote Control und kann Aufgaben mit Dispatch zu Desktop senden.

24 25

25Sie können mehrere Oberflächen im gleichen Projekt verwenden. Konfiguration, Projektgedächtnis und MCP-Server werden über die lokalen Oberflächen hinweg gemeinsam genutzt.26Sie können mehrere Oberflächen im gleichen Projekt verwenden. Konfiguration, Projektgedächtnis und MCP-Server werden über die lokalen Oberflächen hinweg gemeinsam genutzt.

26 27

61* [VS Code](/de/vs-code): die Claude Code-Erweiterung in Ihrem Editor62* [VS Code](/de/vs-code): die Claude Code-Erweiterung in Ihrem Editor

62* [JetBrains](/de/jetbrains): die Erweiterung für IntelliJ, PyCharm und andere JetBrains-IDEs63* [JetBrains](/de/jetbrains): die Erweiterung für IntelliJ, PyCharm und andere JetBrains-IDEs

63* [Claude Code im Web](/de/claude-code-on-the-web): Cloud-Sitzungen, die weiterlaufen, wenn Sie sich trennen64* [Claude Code im Web](/de/claude-code-on-the-web): Cloud-Sitzungen, die weiterlaufen, wenn Sie sich trennen

65* Mobile: die Claude-App für [iOS](https://apps.apple.com/us/app/claude-by-anthropic/id6473753684) und [Android](https://play.google.com/store/apps/details?id=com.anthropic.claude) zum Starten und Überwachen von Aufgaben, wenn Sie weg von Ihrem Computer sind

64 66

65### Integrationen67### Integrationen

66 68

67* [Chrome](/de/chrome): Automatisieren Sie Browser-Aufgaben mit Ihren angemeldeten Sitzungen69* [Chrome](/de/chrome): Automatisieren Sie Browser-Aufgaben mit Ihren angemeldeten Sitzungen

70* [Computernutzung](/de/computer-use): Lassen Sie Claude Apps öffnen und Ihren Bildschirm auf macOS steuern

68* [GitHub Actions](/de/github-actions): Führen Sie Claude in Ihrer CI-Pipeline aus71* [GitHub Actions](/de/github-actions): Führen Sie Claude in Ihrer CI-Pipeline aus

69* [GitLab CI/CD](/de/gitlab-ci-cd): dasselbe für GitLab72* [GitLab CI/CD](/de/gitlab-ci-cd): dasselbe für GitLab

70* [Code Review](/de/code-review): automatische Überprüfung bei jedem Pull Request73* [Code Review](/de/code-review): automatische Überprüfung bei jedem Pull Request

plugin-marketplaces.md +8 −6

Details

23 23

24## Anleitung: Erstellen Sie einen lokalen Marktplatz24## Anleitung: Erstellen Sie einen lokalen Marktplatz

25 25

26Dieses Beispiel erstellt einen Marktplatz mit einem Plugin: ein `/quality-review` skill für Code-Reviews. Sie erstellen die Verzeichnisstruktur, fügen ein skill hinzu, erstellen das Plugin-Manifest und den Marktplatzkatalog und installieren und testen ihn dann.26Dieses Beispiel erstellt einen Marktplatz mit einem Plugin: ein `quality-review` skill für Code-Reviews. Sie erstellen die Verzeichnisstruktur, fügen ein skill hinzu, erstellen das Plugin-Manifest und den Marktplatzkatalog und installieren und testen ihn dann.

27 27

28<Steps>28<Steps>

29 <Step title="Erstellen Sie die Verzeichnisstruktur">29 <Step title="Erstellen Sie die Verzeichnisstruktur">

35 </Step>35 </Step>

36 36

37 <Step title="Erstellen Sie das skill">37 <Step title="Erstellen Sie das skill">

~~38 Erstellen Sie eine `SKILL.md`-Datei, die definiert, was das `/quality-review` skill tut.~~38 Erstellen Sie eine `SKILL.md`-Datei, die definiert, was das `quality-review` skill tut.

39 39

40 ```markdown my-marketplace/plugins/quality-review-plugin/skills/quality-review/SKILL.md theme={null}40 ```markdown my-marketplace/plugins/quality-review-plugin/skills/quality-review/SKILL.md theme={null}

41 ---41 ---

59 ```json my-marketplace/plugins/quality-review-plugin/.claude-plugin/plugin.json theme={null}59 ```json my-marketplace/plugins/quality-review-plugin/.claude-plugin/plugin.json theme={null}

60 {60 {

61 "name": "quality-review-plugin",61 "name": "quality-review-plugin",

~~62 "description": "Adds a /quality-review skill for quick code reviews",~~62 "description": "Adds a quality-review skill for quick code reviews",

63 "version": "1.0.0"63 "version": "1.0.0"

64 }64 }

65 ```65 ```

82 {82 {

83 "name": "quality-review-plugin",83 "name": "quality-review-plugin",

84 "source": "./plugins/quality-review-plugin",84 "source": "./plugins/quality-review-plugin",

~~85 "description": "Adds a /quality-review skill for quick code reviews"~~85 "description": "Adds a quality-review skill for quick code reviews"

86 }86 }

87 ]87 ]

88 }88 }

99 </Step>99 </Step>

100 100

101 <Step title="Probieren Sie es aus">101 <Step title="Probieren Sie es aus">

102 Wählen Sie etwas Code in Ihrem Editor aus und führen Sie Ihr neues skill aus.102 Wählen Sie etwas Code in Ihrem Editor aus und führen Sie Ihr neues skill aus. Plugin-skills sind mit dem Plugin-Namen namespaced.

103 103

104 ```shell theme={null}104 ```shell theme={null}

105 /quality-review105 /quality-review-plugin:quality-review

106 ```106 ```

107 </Step>107 </Step>

108</Steps>108</Steps>

693* Für `hostPattern`-Quellen: Der Marktplatz-Host wird gegen das Regex-Muster abgeglichen693* Für `hostPattern`-Quellen: Der Marktplatz-Host wird gegen das Regex-Muster abgeglichen

694* Für `pathPattern`-Quellen: Der Dateisystempfad des Marktplatzes wird gegen das Regex-Muster abgeglichen694* Für `pathPattern`-Quellen: Der Dateisystempfad des Marktplatzes wird gegen das Regex-Muster abgeglichen

695 695

696Exakter Abgleich normalisiert URLs nicht: Ein nachgestellter Schrägstrich, `.git`-Suffix oder `ssh://` versus `https://`-Form werden als unterschiedliche Werte behandelt. Wenn Ihr Organisations-Marktplatz durch mehr als eine URL-Form geklont werden kann, bevorzugen Sie einen `hostPattern`-Eintrag gegenüber einer literalen URL, damit alle Formen übereinstimmen.

697

696Da `strictKnownMarketplaces` in [verwalteten Einstellungen](/de/settings#settings-files) festgelegt ist, können einzelne Benutzer und Projektkonfigurationen diese Einschränkungen nicht überschreiben.698Da `strictKnownMarketplaces` in [verwalteten Einstellungen](/de/settings#settings-files) festgelegt ist, können einzelne Benutzer und Projektkonfigurationen diese Einschränkungen nicht überschreiben.

697 699

698Für vollständige Konfigurationsdetails einschließlich aller unterstützten Quellentypen und Vergleich mit `extraKnownMarketplaces` siehe die [strictKnownMarketplaces-Referenz](/de/settings#strictknownmarketplaces).700Für vollständige Konfigurationsdetails einschließlich aller unterstützten Quellentypen und Vergleich mit `extraKnownMarketplaces` siehe die [strictKnownMarketplaces-Referenz](/de/settings#strictknownmarketplaces).

plugins-reference.md +7 −3

Details

262**Verfügbare LSP-Plugins:**262**Verfügbare LSP-Plugins:**

263 263

265| :--------------- | :------------------------- | :------------------------------------------------------------------------------------------- |265| :------------------ | :------------------------- | :------------------------------------------------------------------------------------------- |

269 269

270Installieren Sie zuerst den Language Server, dann installieren Sie das Plugin vom Marktplatz.270Installieren Sie zuerst den Language Server, dann installieren Sie das Plugin vom Marktplatz.

271 271

531 531

532Claude Code bietet zwei Variablen zum Referenzieren von Plugin-Pfaden. Beide werden überall dort inline ersetzt, wo sie in Skill-Inhalten, Agent-Inhalten, Hook-Befehlen, Monitor-Befehlen und MCP- oder LSP-Server-Konfigurationen erscheinen. Beide werden auch als Umgebungsvariablen an Hook-Prozesse und MCP- oder LSP-Server-Subprozesse exportiert.532Claude Code bietet zwei Variablen zum Referenzieren von Plugin-Pfaden. Beide werden überall dort inline ersetzt, wo sie in Skill-Inhalten, Agent-Inhalten, Hook-Befehlen, Monitor-Befehlen und MCP- oder LSP-Server-Konfigurationen erscheinen. Beide werden auch als Umgebungsvariablen an Hook-Prozesse und MCP- oder LSP-Server-Subprozesse exportiert.

533 533

534**`${CLAUDE_PLUGIN_ROOT}`**: Der absolute Pfad zum Installationsverzeichnis Ihres Plugins. Verwenden Sie dies, um auf Skripte, Binärdateien und Konfigurationsdateien zu verweisen, die mit dem Plugin gebündelt sind. Dieser Pfad ändert sich, wenn das Plugin aktualisiert wird, daher überleben Dateien, die Sie hier schreiben, ein Update nicht.534**`${CLAUDE_PLUGIN_ROOT}`**: Der absolute Pfad zum Installationsverzeichnis Ihres Plugins. Verwenden Sie dies, um auf Skripte, Binärdateien und Konfigurationsdateien zu verweisen, die mit dem Plugin gebündelt sind. Dieser Pfad ändert sich, wenn das Plugin aktualisiert wird. Das Verzeichnis der vorherigen Version bleibt etwa sieben Tage nach einem Update auf der Festplatte, bevor es bereinigt wird, aber behandeln Sie es als kurzlebig und schreiben Sie keinen Status hier.

535

536Wenn ein Plugin während einer Sitzung aktualisiert wird, verwenden Hook-Befehle, Monitore, MCP-Server und LSP-Server weiterhin den Pfad der vorherigen Version. Führen Sie `/reload-plugins` aus, um Hooks, MCP-Server und LSP-Server auf den neuen Pfad umzuschalten; Monitore erfordern einen Neustart der Sitzung.

535 537

536**`${CLAUDE_PLUGIN_DATA}`**: Ein persistentes Verzeichnis für Plugin-Status, das Updates überlebt. Verwenden Sie dies für installierte Abhängigkeiten wie `node_modules` oder Python-Umgebungen, generierte Code, Caches und alle anderen Dateien, die über Plugin-Versionen hinweg bestehen bleiben sollten. Das Verzeichnis wird automatisch erstellt, wenn diese Variable zum ersten Mal referenziert wird.538**`${CLAUDE_PLUGIN_DATA}`**: Ein persistentes Verzeichnis für Plugin-Status, das Updates überlebt. Verwenden Sie dies für installierte Abhängigkeiten wie `node_modules` oder Python-Umgebungen, generierte Code, Caches und alle anderen Dateien, die über Plugin-Versionen hinweg bestehen bleiben sollten. Das Verzeichnis wird automatisch erstellt, wenn diese Variable zum ersten Mal referenziert wird.

537 539

677 Das `.claude-plugin/` Verzeichnis enthält die `plugin.json` Datei. Alle anderen Verzeichnisse (commands/, agents/, skills/, output-styles/, themes/, monitors/, hooks/) müssen sich im Plugin-Root befinden, nicht innerhalb von `.claude-plugin/`.679 Das `.claude-plugin/` Verzeichnis enthält die `plugin.json` Datei. Alle anderen Verzeichnisse (commands/, agents/, skills/, output-styles/, themes/, monitors/, hooks/) müssen sich im Plugin-Root befinden, nicht innerhalb von `.claude-plugin/`.

678</Warning>680</Warning>

679 681

682Eine `CLAUDE.md` Datei im Plugin-Root wird nicht als Projektkontext geladen. Plugins tragen Kontext durch Skills, Agents und Hooks bei, anstatt durch CLAUDE.md. Um Anweisungen bereitzustellen, die in Claudes Kontext geladen werden, fügen Sie diese in einen [Skill](#skills) ein.

683

680### Datei-Speicherorte-Referenz684### Datei-Speicherorte-Referenz

681 685

security.md +1 −1

Details

27* **Sandbox-Bash-Tool**: [Sandbox](/de/sandboxing) Bash-Befehle mit Dateisystem- und Netzwerkisolation, wodurch Berechtigungsaufforderungen reduziert werden, während die Sicherheit gewährleistet bleibt. Aktivieren Sie mit `/sandbox`, um Grenzen zu definieren, in denen Claude Code autonom arbeiten kann27* **Sandbox-Bash-Tool**: [Sandbox](/de/sandboxing) Bash-Befehle mit Dateisystem- und Netzwerkisolation, wodurch Berechtigungsaufforderungen reduziert werden, während die Sicherheit gewährleistet bleibt. Aktivieren Sie mit `/sandbox`, um Grenzen zu definieren, in denen Claude Code autonom arbeiten kann

28* **Schreibzugriffsbeschränkung**: Claude Code kann nur in den Ordner schreiben, in dem es gestartet wurde, und in dessen Unterordner – es kann Dateien in übergeordneten Verzeichnissen nicht ohne explizite Genehmigung ändern. Während Claude Code Dateien außerhalb des Arbeitsverzeichnisses lesen kann (nützlich für den Zugriff auf Systembibliotheken und Abhängigkeiten), sind Schreibvorgänge streng auf den Projektumfang beschränkt und schaffen eine klare Sicherheitsgrenze28* **Schreibzugriffsbeschränkung**: Claude Code kann nur in den Ordner schreiben, in dem es gestartet wurde, und in dessen Unterordner – es kann Dateien in übergeordneten Verzeichnissen nicht ohne explizite Genehmigung ändern. Während Claude Code Dateien außerhalb des Arbeitsverzeichnisses lesen kann (nützlich für den Zugriff auf Systembibliotheken und Abhängigkeiten), sind Schreibvorgänge streng auf den Projektumfang beschränkt und schaffen eine klare Sicherheitsgrenze

29* **Minderung von Genehmigungsmüdigkeit**: Unterstützung für das Zulassen häufig verwendeter sicherer Befehle pro Benutzer, pro Codebasis oder pro Organisation29* **Minderung von Genehmigungsmüdigkeit**: Unterstützung für das Zulassen häufig verwendeter sicherer Befehle pro Benutzer, pro Codebasis oder pro Organisation

~~30* **Accept Edits-Modus**: Mehrere Bearbeitungen stapelweise akzeptieren, während Berechtigungsaufforderungen für Befehle mit Nebenwirkungen beibehalten werden~~30* **Accept Edits-Modus**: Genehmigt automatisch Dateibearbeitungen und einen festen Satz von Dateisystem-Bash-Befehlen wie `mkdir`, `touch`, `rm`, `mv`, `cp` und `sed` für Pfade im Arbeitsverzeichnis. Andere Bash-Befehle und Pfade außerhalb des Umfangs werden weiterhin angefordert

31 31

32### Benutzerverantwortung32### Benutzerverantwortung

33 33

settings.md +26 −3

Details

73 73

74Unter Windows werden Pfade, die als `~/.claude` angezeigt werden, zu `%USERPROFILE%\.claude` aufgelöst.

74***76***

75 77

76## Einstellungsdateien78## Einstellungsdateien

166| `apiKeyHelper` | Benutzerdefiniertes Skript, das in `/bin/sh` ausgeführt werden soll, um einen Auth-Wert zu generieren. Dieser Wert wird als `X-Api-Key` und `Authorization: Bearer` Header für Modellanfragen gesendet | `/bin/generate_temp_api_key.sh` |168| `apiKeyHelper` | Benutzerdefiniertes Skript, das in `/bin/sh` ausgeführt werden soll, um einen Auth-Wert zu generieren. Dieser Wert wird als `X-Api-Key` und `Authorization: Bearer` Header für Modellanfragen gesendet | `/bin/generate_temp_api_key.sh` |

167| `attribution` | Passen Sie die Zuschreibung für Git-Commits und Pull Requests an. Siehe [Zuschreibungseinstellungen](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |169| `attribution` | Passen Sie die Zuschreibung für Git-Commits und Pull Requests an. Siehe [Zuschreibungseinstellungen](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

168| `autoMemoryDirectory` | Benutzerdefiniertes Verzeichnis für [automatisches Speichern](/de/memory#storage-location). Akzeptiert einen absoluten Pfad oder einen `~/`-erweiterten Pfad. Akzeptiert von Richtlinien- und Benutzereinstellungen sowie vom Flag `--settings`. Nicht akzeptiert von Projekt- oder lokalen Einstellungen, da ein geklontes Repository eine Datei bereitstellen könnte, um Speicherschreibvorgänge an sensible Orte umzuleiten | `"~/my-memory-dir"` |170| `autoMemoryDirectory` | Benutzerdefiniertes Verzeichnis für [automatisches Speichern](/de/memory#storage-location). Akzeptiert einen absoluten Pfad oder einen `~/`-erweiterten Pfad. Akzeptiert von Richtlinien- und Benutzereinstellungen sowie vom Flag `--settings`. Nicht akzeptiert von Projekt- oder lokalen Einstellungen, da ein geklontes Repository eine Datei bereitstellen könnte, um Speicherschreibvorgänge an sensible Orte umzuleiten | `"~/my-memory-dir"` |

171| `autoMemoryEnabled` | Aktivieren Sie [automatisches Speichern](/de/memory#enable-or-disable-auto-memory). Wenn `false`, liest Claude nicht aus dem oder schreibt nicht in das automatische Speicherverzeichnis. Standard: `true`. Sie können dies auch während einer Sitzung mit `/memory` umschalten | `false` |

169| `autoMode` | Passen Sie an, was der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode)-Klassifizierer blockiert und erlaubt. Enthält `environment`, `allow` und `soft_deny` Arrays von Prosa-Regeln. Schließen Sie die Literalzeichenkette `"$defaults"` in ein Array ein, um die integrierten Regeln an dieser Position zu erben. Siehe [Konfigurieren Sie den Auto-Modus](/de/auto-mode-config). Nicht aus gemeinsamen Projekteinstellungen gelesen | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |172| `autoMode` | Passen Sie an, was der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode)-Klassifizierer blockiert und erlaubt. Enthält `environment`, `allow` und `soft_deny` Arrays von Prosa-Regeln. Schließen Sie die Literalzeichenkette `"$defaults"` in ein Array ein, um die integrierten Regeln an dieser Position zu erben. Siehe [Konfigurieren Sie den Auto-Modus](/de/auto-mode-config). Nicht aus gemeinsamen Projekteinstellungen gelesen | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |

170| `autoScrollEnabled` | Im [Fullscreen-Rendering](/de/fullscreen) folgen Sie neuer Ausgabe zum unteren Ende des Gesprächs. Standard: `true`. Wird in `/config` als **Auto-scroll** angezeigt. Berechtigungsaufforderungen scrollen weiterhin in die Ansicht, wenn dies ausgeschaltet ist | `false` |173| `autoScrollEnabled` | Im [Fullscreen-Rendering](/de/fullscreen) folgen Sie neuer Ausgabe zum unteren Ende des Gesprächs. Standard: `true`. Wird in `/config` als **Auto-scroll** angezeigt. Berechtigungsaufforderungen scrollen weiterhin in die Ansicht, wenn dies ausgeschaltet ist | `false` |

171| `autoUpdatesChannel` | Release-Kanal zum Folgen von Updates. Verwenden Sie `"stable"` für eine Version, die normalerweise etwa eine Woche alt ist und Versionen mit großen Regressionen überspringt, oder `"latest"` (Standard) für die neueste Version | `"stable"` |174| `autoUpdatesChannel` | Release-Kanal zum Folgen von Updates. Verwenden Sie `"stable"` für eine Version, die normalerweise etwa eine Woche alt ist und Versionen mit großen Regressionen überspringt, oder `"latest"` (Standard) für die neueste Version | `"stable"` |

174| `awsAuthRefresh` | Benutzerdefiniertes Skript, das das `.aws`-Verzeichnis ändert (siehe [erweiterte Anmeldedatenkonfiguration](/de/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |177| `awsAuthRefresh` | Benutzerdefiniertes Skript, das das `.aws`-Verzeichnis ändert (siehe [erweiterte Anmeldedatenkonfiguration](/de/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |

175| `awsCredentialExport` | Benutzerdefiniertes Skript, das JSON mit AWS-Anmeldedaten ausgibt (siehe [erweiterte Anmeldedatenkonfiguration](/de/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |178| `awsCredentialExport` | Benutzerdefiniertes Skript, das JSON mit AWS-Anmeldedaten ausgibt (siehe [erweiterte Anmeldedatenkonfiguration](/de/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |

176| `blockedMarketplaces` | (Nur verwaltete Einstellungen) Blocklist von Marketplace-Quellen. Erzwungen bei Marketplace-Hinzufügung und bei Plugin-Installation, Update, Aktualisierung und Auto-Update, sodass ein Marketplace, der vor dem Setzen der Richtlinie hinzugefügt wurde, nicht zum Abrufen von Plugins verwendet werden kann. Blockierte Quellen werden vor dem Download überprüft, sodass sie das Dateisystem nie berühren. Siehe [Verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |179| `blockedMarketplaces` | (Nur verwaltete Einstellungen) Blocklist von Marketplace-Quellen. Erzwungen bei Marketplace-Hinzufügung und bei Plugin-Installation, Update, Aktualisierung und Auto-Update, sodass ein Marketplace, der vor dem Setzen der Richtlinie hinzugefügt wurde, nicht zum Abrufen von Plugins verwendet werden kann. Blockierte Quellen werden vor dem Download überprüft, sodass sie das Dateisystem nie berühren. Siehe [Verwaltete Marketplace-Einschränkungen](/de/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |

177| `channelsEnabled` | (Nur verwaltete Einstellungen) Erlauben Sie [Kanäle](/de/channels) für Team- und Enterprise-Benutzer. Nicht gesetzt oder `false` blockiert die Kanalzustellung unabhängig davon, was Benutzer an `--channels` übergeben | `true` |180| `channelsEnabled` | (Nur verwaltete Einstellungen) Erlauben Sie [Kanäle](/de/channels) für die Organisation. Bei Claude.ai Team- und Enterprise-Plänen werden Kanäle blockiert, wenn dies nicht gesetzt oder `false` ist. Für [Anthropic Console](/de/authentication#claude-console-authentication)-Konten mit API-Schlüssel-Authentifizierung sind Kanäle standardmäßig zulässig, es sei denn, Ihre Organisation stellt verwaltete Einstellungen bereit. In diesem Fall muss dieser Schlüssel auf `true` gesetzt werden | `true` |

178| `cleanupPeriodDays` | Sitzungsdateien, die älter als dieser Zeitraum sind, werden beim Start gelöscht (Standard: 30 Tage, Minimum 1). Das Setzen auf `0` wird mit einem Validierungsfehler abgelehnt. Steuert auch den Altersgrenzwert für die automatische Entfernung von [verwaisten Subagent-Worktrees](/de/worktrees#clean-up-worktrees) beim Start. Um Transkriptschreibvorgänge vollständig zu deaktivieren, setzen Sie die Umgebungsvariable [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/de/env-vars) oder verwenden Sie im nicht-interaktiven Modus (`-p`) das Flag `--no-session-persistence` oder die SDK-Option `persistSession: false`. | `20` |181| `cleanupPeriodDays` | Sitzungsdateien, die älter als dieser Zeitraum sind, werden beim Start gelöscht (Standard: 30 Tage, Minimum 1). Das Setzen auf `0` wird mit einem Validierungsfehler abgelehnt. Steuert auch den Altersgrenzwert für die automatische Entfernung von [verwaisten Subagent-Worktrees](/de/worktrees#clean-up-worktrees) beim Start. Um Transkriptschreibvorgänge vollständig zu deaktivieren, setzen Sie die Umgebungsvariable [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/de/env-vars) oder verwenden Sie im nicht-interaktiven Modus (`-p`) das Flag `--no-session-persistence` oder die SDK-Option `persistSession: false`. | `20` |

179| `companyAnnouncements` | Ankündigung, die Benutzern beim Start angezeigt werden soll. Wenn mehrere Ankündigungen bereitgestellt werden, werden sie zufällig durchlaufen. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |182| `companyAnnouncements` | Ankündigung, die Benutzern beim Start angezeigt werden soll. Wenn mehrere Ankündigungen bereitgestellt werden, werden sie zufällig durchlaufen. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |

180| `defaultShell` | Standard-Shell für Input-Box `!` Befehle. Akzeptiert `"bash"` (Standard) oder `"powershell"`. Das Setzen auf `"powershell"` leitet interaktive `!` Befehle über PowerShell unter Windows. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) | `"powershell"` |183| `defaultShell` | Standard-Shell für Input-Box `!` Befehle. Akzeptiert `"bash"` (Standard) oder `"powershell"`. Das Setzen auf `"powershell"` leitet interaktive `!` Befehle über PowerShell unter Windows. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) | `"powershell"` |

183| `disableAutoMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) aktiviert wird. Entfernt `auto` aus dem `Shift+Tab`-Zyklus und lehnt `--permission-mode auto` beim Start ab. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `"disable"` |186| `disableAutoMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) aktiviert wird. Entfernt `auto` aus dem `Shift+Tab`-Zyklus und lehnt `--permission-mode auto` beim Start ab. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `"disable"` |

184| `disableDeepLinkRegistration` | Setzen Sie auf `"disable"`, um zu verhindern, dass Claude Code den `claude-cli://` Protokoll-Handler beim Start mit dem Betriebssystem registriert. Deep Links ermöglichen es externen Tools, eine Claude Code-Sitzung mit einer vorausgefüllten Aufforderung zu öffnen. Nützlich in Umgebungen, in denen die Protokoll-Handler-Registrierung eingeschränkt oder separat verwaltet wird | `"disable"` |187| `disableDeepLinkRegistration` | Setzen Sie auf `"disable"`, um zu verhindern, dass Claude Code den `claude-cli://` Protokoll-Handler beim Start mit dem Betriebssystem registriert. Deep Links ermöglichen es externen Tools, eine Claude Code-Sitzung mit einer vorausgefüllten Aufforderung zu öffnen. Nützlich in Umgebungen, in denen die Protokoll-Handler-Registrierung eingeschränkt oder separat verwaltet wird | `"disable"` |

189| `disableRemoteControl` | {/* min-version: 2.1.128 */}Deaktivieren Sie [Remote Control](/de/remote-control): blockiert `claude remote-control`, das Flag `--remote-control`, Auto-Start und den In-Session-Toggle. Normalerweise in [verwalteten Einstellungen](/de/permissions#managed-settings) für die Pro-Gerät-MDM-Durchsetzung platziert, funktioniert aber aus jedem Bereich. Erfordert Claude Code v2.1.128 oder später | `true` |

186| `disableSkillShellExecution` | Deaktivieren Sie die Inline-Shell-Ausführung für `` !`...` `` und ` ```! ` Blöcke in [Skills](/de/skills) und benutzerdefinierten Befehlen aus Benutzer-, Projekt-, Plugin- oder zusätzlichen Verzeichnisquellen. Befehle werden durch `[shell command execution disabled by policy]` ersetzt, anstatt ausgeführt zu werden. Gebündelte und verwaltete Skills sind nicht betroffen. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `true` |190| `disableSkillShellExecution` | Deaktivieren Sie die Inline-Shell-Ausführung für `` !`...` `` und ` ```! ` Blöcke in [Skills](/de/skills) und benutzerdefinierten Befehlen aus Benutzer-, Projekt-, Plugin- oder zusätzlichen Verzeichnisquellen. Befehle werden durch `[shell command execution disabled by policy]` ersetzt, anstatt ausgeführt zu werden. Gebündelte und verwaltete Skills sind nicht betroffen. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `true` |

187| `editorMode` | Tastaturkürzel-Modus für die Eingabeaufforderung: `"normal"` oder `"vim"`. Standard: `"normal"`. Wird in `/config` als **Editor mode** angezeigt | `"vim"` |191| `editorMode` | Tastaturkürzel-Modus für die Eingabeaufforderung: `"normal"` oder `"vim"`. Standard: `"normal"`. Wird in `/config` als **Editor mode** angezeigt | `"vim"` |

188| `effortLevel` | Persistieren Sie die [Anstrengungsstufe](/de/model-config#adjust-effort-level) über Sitzungen hinweg. Akzeptiert `"low"`, `"medium"`, `"high"` oder `"xhigh"`. Wird automatisch geschrieben, wenn Sie `/effort` mit einem dieser Werte ausführen. Siehe [Anstrengungsstufe anpassen](/de/model-config#adjust-effort-level) für unterstützte Modelle | `"xhigh"` |192| `effortLevel` | Persistieren Sie die [Anstrengungsstufe](/de/model-config#adjust-effort-level) über Sitzungen hinweg. Akzeptiert `"low"`, `"medium"`, `"high"` oder `"xhigh"`. Wird automatisch geschrieben, wenn Sie `/effort` mit einem dieser Werte ausführen. Siehe [Anstrengungsstufe anpassen](/de/model-config#adjust-effort-level) für unterstützte Modelle | `"xhigh"` |

550 },554 },

551 "extraKnownMarketplaces": {555 "extraKnownMarketplaces": {

552 "acme-tools": {556 "acme-tools": {

557 "source": {

553 "source": "github",558 "source": "github",

554 "repo": "acme-corp/claude-plugins"559 "repo": "acme-corp/claude-plugins"

555 }560 }

556 }561 }

562 }

557}563}

558```564```

559 565

568* **Lokale Einstellungen** (`.claude/settings.local.json`): Pro-Maschinen-Überschreibungen (nicht eingecheckt)574* **Lokale Einstellungen** (`.claude/settings.local.json`): Pro-Maschinen-Überschreibungen (nicht eingecheckt)

569* **Verwaltete Einstellungen** (`managed-settings.json`): Organisationsweite Richtlinien-Überschreibungen, die die Installation auf allen Ebenen blockieren und das Plugin aus dem Marketplace ausblenden575* **Verwaltete Einstellungen** (`managed-settings.json`): Organisationsweite Richtlinien-Überschreibungen, die die Installation auf allen Ebenen blockieren und das Plugin aus dem Marketplace ausblenden

570 576

577<Note>

578 Projekteinstellungen haben Vorrang vor Benutzereinstellungen, daher führt das Setzen eines Plugins auf `false` in `~/.claude/settings.json` nicht dazu, dass ein Plugin deaktiviert wird, das die `.claude/settings.json` des Projekts aktiviert. Um sich von einem projektaktivierten Plugin auf Ihrem Computer abzumelden, setzen Sie es stattdessen auf `false` in `.claude/settings.local.json`.

579

580 Plugins, die durch verwaltete Einstellungen erzwungen aktiviert sind, können auf diese Weise nicht deaktiviert werden, da verwaltete Einstellungen lokale Einstellungen überschreiben.

581</Note>

582

571**Beispiel**:583**Beispiel**:

572 584

573```json theme={null}585```json theme={null}

659* Nur in verwalteten Einstellungen verfügbar (`managed-settings.json`)671* Nur in verwalteten Einstellungen verfügbar (`managed-settings.json`)

660* Kann nicht durch Benutzer- oder Projekteinstellungen überschrieben werden (höchste Priorität)672* Kann nicht durch Benutzer- oder Projekteinstellungen überschrieben werden (höchste Priorität)

661* Durchgesetzt VOR Netzwerk-/Dateisystem-Operationen (blockierte Quellen werden nie ausgeführt)673* Durchgesetzt VOR Netzwerk-/Dateisystem-Operationen (blockierte Quellen werden nie ausgeführt)

662* Verwendet exakte Übereinstimmung für Quellspezifikationen (einschließlich `ref`, `path` für Git-Quellen), außer `hostPattern`, das Regex-Abgleich verwendet674* Verwendet exakte Übereinstimmung für Quellspezifikationen (einschließlich `ref`, `path` für Git-Quellen), außer `hostPattern` und `pathPattern`, die Regex-Abgleich verwenden

663 675

664**Allowlist-Verhalten**:676**Allowlist-Verhalten**:

665 677

669 681

670**Alle unterstützten Quellentypen**:682**Alle unterstützten Quellentypen**:

671 683

672Die Allowlist unterstützt mehrere Marketplace-Quellentypen. Die meisten Quellen verwenden exakte Übereinstimmung, während `hostPattern` Regex-Abgleich gegen den Marketplace-Host verwendet.684Die Allowlist unterstützt mehrere Marketplace-Quellentypen. Die meisten Quellen verwenden exakte Übereinstimmung, während `hostPattern` und `pathPattern` Regex-Abgleich gegen den Marketplace-Host und den Dateisystem-Pfad verwenden.

673 685

6741. **GitHub-Repositories**:6861. **GitHub-Repositories**:

675 687

749* `url`: extrahiert Hostname aus der URL761* `url`: extrahiert Hostname aus der URL

750* `npm`, `file`, `directory`: nicht unterstützt für Host-Muster-Abgleich762* `npm`, `file`, `directory`: nicht unterstützt für Host-Muster-Abgleich

751 763

7648. **Pfad-Muster-Abgleich**:

765

766```json theme={null}

767{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }

768{ "source": "pathPattern", "pathPattern": ".*" }

769```

770

771Felder: `pathPattern` (erforderlich: Regex-Muster, das gegen das `path`-Feld von `file` und `directory`-Quellen abgeglichen wird)

772

773Verwenden Sie Pfad-Muster-Abgleich, um dateisystem-basierte Marketplaces neben `hostPattern`-Einschränkungen für Netzwerk-Quellen zu erlauben. Setzen Sie `".*"` auf alle lokalen Pfade, oder ein engeres Muster, um auf bestimmte Verzeichnisse zu beschränken.

774

752**Konfigurationsbeispiele**:775**Konfigurationsbeispiele**:

753 776

754Beispiel: Nur bestimmte Marketplaces erlauben:777Beispiel: Nur bestimmte Marketplaces erlauben:

sub-agents.md +35 −10

Details

51 </Tab>51 </Tab>

52 52

53 <Tab title="Plan">53 <Tab title="Plan">

~~54 Ein Forschungsagent, der während des [Plan-Modus](/de/common-workflows#use-plan-mode-for-safe-code-analysis) verwendet wird, um Kontext zu sammeln, bevor ein Plan präsentiert wird.~~54 Ein Forschungsagent, der während des [Plan-Modus](/de/permission-modes#analyze-before-you-edit-with-plan-mode) verwendet wird, um Kontext zu sammeln, bevor ein Plan präsentiert wird.

55 55

56 * **Modell**: Erbt von Hauptkonversation56 * **Modell**: Erbt von Hauptkonversation

57 * **Werkzeuge**: Schreibgeschützte Werkzeuge (kein Zugriff auf Write- und Edit-Werkzeuge)57 * **Werkzeuge**: Schreibgeschützte Werkzeuge (kein Zugriff auf Write- und Edit-Werkzeuge)

77 | :---------------- | :----- | :--------------------------------------------------------------------- |77 | :---------------- | :----- | :--------------------------------------------------------------------- |

80 </Tab>80 </Tab>

81</Tabs>81</Tabs>

82 82

180 180

181**CLI-definierte Subagenten** werden als JSON beim Starten von Claude Code übergeben. Sie existieren nur für diese Sitzung und werden nicht auf der Festplatte gespeichert, was sie für schnelle Tests oder Automatisierungsskripte nützlich macht. Sie können mehrere Subagenten in einem einzigen `--agents`-Aufruf definieren:181**CLI-definierte Subagenten** werden als JSON beim Starten von Claude Code übergeben. Sie existieren nur für diese Sitzung und werden nicht auf der Festplatte gespeichert, was sie für schnelle Tests oder Automatisierungsskripte nützlich macht. Sie können mehrere Subagenten in einem einzigen `--agents`-Aufruf definieren:

182 182

183```bash theme={null}183<Tabs>

184claude --agents '{184 <Tab title="macOS, Linux, WSL">

185 ```bash theme={null}

186 claude --agents '{

185 "code-reviewer": {187 "code-reviewer": {

186 "description": "Expert code reviewer. Use proactively after code changes.",188 "description": "Expert code reviewer. Use proactively after code changes.",

187 "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",189 "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",

192 "description": "Debugging specialist for errors and test failures.",194 "description": "Debugging specialist for errors and test failures.",

193 "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."195 "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."

194 }196 }

195}'197 }'

196```198 ```

199 </Tab>

200

201 <Tab title="Windows PowerShell">

202 ```powershell theme={null}

203 claude --agents @'

204 {

205 "code-reviewer": {

206 "description": "Expert code reviewer. Use proactively after code changes.",

207 "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",

208 "tools": ["Read", "Grep", "Glob", "Bash"],

209 "model": "sonnet"

210 },

211 "debugger": {

212 "description": "Debugging specialist for errors and test failures.",

213 "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."

214 }

215 }

216 '@

217 ```

218 </Tab>

219</Tabs>

197 220

198Das `--agents`-Flag akzeptiert JSON mit denselben [Frontmatter](#supported-frontmatter-fields)-Feldern wie dateibasierte Subagenten: `description`, `prompt`, `tools`, `disallowedTools`, `model`, `permissionMode`, `mcpServers`, `hooks`, `maxTurns`, `skills`, `initialPrompt`, `memory`, `effort`, `background`, `isolation` und `color`. Verwenden Sie `prompt` für den Systemprompt, äquivalent zum Markdown-Body in dateibasierten Subagenten.221Das `--agents`-Flag akzeptiert JSON mit denselben [Frontmatter](#supported-frontmatter-fields)-Feldern wie dateibasierte Subagenten: `description`, `prompt`, `tools`, `disallowedTools`, `model`, `permissionMode`, `mcpServers`, `hooks`, `maxTurns`, `skills`, `initialPrompt`, `memory`, `effort`, `background`, `isolation` und `color`. Verwenden Sie `prompt` für den Systemprompt, äquivalent zum Markdown-Body in dateibasierten Subagenten.

199 222

212Subagenten-Dateien verwenden YAML-Frontmatter für die Konfiguration, gefolgt vom Systemprompt in Markdown:235Subagenten-Dateien verwenden YAML-Frontmatter für die Konfiguration, gefolgt vom Systemprompt in Markdown:

213 236

214<Note>237<Note>

215 Subagenten werden beim Sitzungsstart geladen. Wenn Sie einen Subagenten durch manuelles Hinzufügen einer Datei erstellen, starten Sie Ihre Sitzung neu oder verwenden Sie `/agents`, um ihn sofort zu laden.238 Subagenten werden beim Sitzungsstart geladen. Wenn Sie einen Subagenten durch direktes Hinzufügen oder Bearbeiten einer Subagenten-Datei auf der Festplatte erstellen, starten Sie Ihre Sitzung neu, um ihn zu laden. Subagenten, die über die `/agents`-Schnittstelle erstellt werden, werden sofort wirksam, ohne dass ein Neustart erforderlich ist.

216</Note>239</Note>

217 240

218```markdown theme={null}241```markdown theme={null}

251| `background` | Nein | Auf `true` setzen, um diesen Subagenten immer als [Hintergrundaufgabe](#run-subagents-in-foreground-or-background) auszuführen. Standard: `false` |274| `background` | Nein | Auf `true` setzen, um diesen Subagenten immer als [Hintergrundaufgabe](#run-subagents-in-foreground-or-background) auszuführen. Standard: `false` |

252| `effort` | Nein | Aufwandsstufe, wenn dieser Subagent aktiv ist. Überschreibt die Aufwandsstufe der Sitzung. Standard: erbt von Sitzung. Optionen: `low`, `medium`, `high`, `xhigh`, `max`; verfügbare Stufen hängen vom Modell ab |275| `effort` | Nein | Aufwandsstufe, wenn dieser Subagent aktiv ist. Überschreibt die Aufwandsstufe der Sitzung. Standard: erbt von Sitzung. Optionen: `low`, `medium`, `high`, `xhigh`, `max`; verfügbare Stufen hängen vom Modell ab |

253| `isolation` | Nein | Auf `worktree` setzen, um den Subagenten in einem temporären [Git-Worktree](/de/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) auszuführen, was ihm eine isolierte Kopie des Repositorys gibt. Der Worktree wird automatisch bereinigt, wenn der Subagent keine Änderungen vornimmt |276| `isolation` | Nein | Auf `worktree` setzen, um den Subagenten in einem temporären [Git-Worktree](/de/worktrees) auszuführen, was ihm eine isolierte Kopie des Repositorys gibt. Der Worktree wird automatisch bereinigt, wenn der Subagent keine Änderungen vornimmt |

254| `color` | Nein | Anzeigefarbe für den Subagenten in der Aufgabenliste und dem Transkript. Akzeptiert `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink` oder `cyan` |277| `color` | Nein | Anzeigefarbe für den Subagenten in der Aufgabenliste und dem Transkript. Akzeptiert `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink` oder `cyan` |

255| `initialPrompt` | Nein | Auto-eingereicht als der erste Benutzer-Turn, wenn dieser Agent als Hauptsitzungs-Agent läuft (über `--agent` oder die `agent`-Einstellung). [Befehle](/de/commands) und [Skills](/de/skills) werden verarbeitet. Vorangestellt zu jedem vom Benutzer bereitgestellten Prompt |278| `initialPrompt` | Nein | Auto-eingereicht als der erste Benutzer-Turn, wenn dieser Agent als Hauptsitzungs-Agent läuft (über `--agent` oder die `agent`-Einstellung). [Befehle](/de/commands) und [Skills](/de/skills) werden verarbeitet. Vorangestellt zu jedem vom Benutzer bereitgestellten Prompt |

256 279

484exit 0507exit 0

485```508```

486 509

487Siehe [Hook-Eingabe](/de/hooks#pretooluse-input) für das vollständige Eingabeschema und [Exit-Codes](/de/hooks#exit-code-output) für die Auswirkungen von Exit-Codes auf das Verhalten.510Siehe [Hook-Eingabe](/de/hooks#pretooluse-input) für das vollständige Eingabeschema und [Exit-Codes](/de/hooks#exit-code-output) für die Auswirkungen von Exit-Codes auf das Verhalten. Unter Windows schreiben Sie Hook-Skripte in PowerShell und fügen Sie `shell: powershell` zum Hook-Eintrag hinzu, wie in [Ausführen von Hooks in PowerShell](/de/hooks#windows-powershell-tool) gezeigt.

488 511

489#### Deaktivieren Sie spezifische Subagenten512#### Deaktivieren Sie spezifische Subagenten

490 513

994exit 01017exit 0

995```1018```

996 1019

997Machen Sie das Skript ausführbar:1020Machen Sie das Skript unter macOS und Linux ausführbar:

998 1021

999```bash theme={null}1022```bash theme={null}

1000chmod +x ./scripts/validate-readonly-query.sh1023chmod +x ./scripts/validate-readonly-query.sh

1001```1024```

1002 1025

1026Unter Windows schreiben Sie das Validierungsskript in PowerShell und fügen `shell: powershell` zum Hook-Eintrag hinzu. Siehe [Hooks in PowerShell ausführen](/de/hooks#windows-powershell-tool).

1027

1003Der Hook empfängt JSON über stdin mit dem Bash-Befehl in `tool_input.command`. Exit-Code 2 blockiert die Operation und leitet die Fehlermeldung an Claude weiter. Siehe [Hooks](/de/hooks#exit-code-output) für Details zu Exit-Codes und [Hook-Eingabe](/de/hooks#pretooluse-input) für das vollständige Eingabeschema.1028Der Hook empfängt JSON über stdin mit dem Bash-Befehl in `tool_input.command`. Exit-Code 2 blockiert die Operation und leitet die Fehlermeldung an Claude weiter. Siehe [Hooks](/de/hooks#exit-code-output) für Details zu Exit-Codes und [Hook-Eingabe](/de/hooks#pretooluse-input) für das vollständige Eingabeschema.

1004 1029

1005## Nächste Schritte1030## Nächste Schritte

Documentation 2026-05-04 22:58 UTC to 2026-05-05 23:00 UTC