Documentation — Spybara

agent-sdk/mcp.md +1 −1

Details

309 </Tab>309 </Tab>

310</Tabs>310</Tabs>

311 311

312Verwenden Sie für HTTP (nicht-Streaming) stattdessen `"type": "http"`.312Verwenden Sie für den streamfähigen HTTP-Transport stattdessen `"type": "http"`. In `.mcp.json` und anderen JSON-Konfigurationsdateien wird `"streamable-http"` als Alias für `"http"` akzeptiert. Die programmgesteuerte `mcpServers`-Option akzeptiert nur `"http"`.

313 313

314### SDK MCP-Server314### SDK MCP-Server

315 315

agent-sdk/python.md +111 −109

Details

2294 2294

2295```python theme={null}2295```python theme={null}

2296{2296{

2297 "description": str, # A short (3-5 word) description of the task2297 "description": str, # Eine kurze (3-5 Wörter) Beschreibung der Aufgabe

2298 "prompt": str, # The task for the agent to perform2298 "prompt": str, # Die Aufgabe, die der Agent ausführen soll

2299 "subagent_type": str, # The type of specialized agent to use2299 "subagent_type": str, # Der Typ des spezialisierten Agenten, der verwendet werden soll

2300}2300}

2301```2301```

2302 2302

2304 2304

2305```python theme={null}2305```python theme={null}

2306{2306{

2307 "result": str, # Final result from the subagent2307 "result": str, # Endergebnis vom Subagenten

2308 "usage": dict | None, # Token usage statistics2308 "usage": dict | None, # Token-Nutzungsstatistiken

2309 "total_cost_usd": float | None, # Estimated total cost in USD2309 "total_cost_usd": float | None, # Geschätzte Gesamtkosten in USD

2310 "duration_ms": int | None, # Execution duration in milliseconds2310 "duration_ms": int | None, # Ausführungsdauer in Millisekunden

2311}2311}

2312```2312```

2313 2313

2321 2321

2322```python theme={null}2322```python theme={null}

2323{2323{

2324 "questions": [ # Questions to ask the user (1-4 questions)2324 "questions": [ # Fragen, die dem Benutzer gestellt werden (1-4 Fragen)

2325 {2325 {

2326 "question": str, # The complete question to ask the user2326 "question": str, # Die vollständige Frage, die dem Benutzer gestellt werden soll

2327 "header": str, # Very short label displayed as a chip/tag (max 12 chars)2327 "header": str, # Sehr kurzes Label, das als Chip/Tag angezeigt wird (max. 12 Zeichen)

2328 "options": [ # The available choices (2-4 options)2328 "options": [ # Die verfügbaren Auswahlmöglichkeiten (2-4 Optionen)

2329 {2329 {

2330 "label": str, # Display text for this option (1-5 words)2330 "label": str, # Anzeigetext für diese Option (1-5 Wörter)

2331 "description": str, # Explanation of what this option means2331 "description": str, # Erklärung, was diese Option bedeutet

2332 }2332 }

2333 ],2333 ],

2334 "multiSelect": bool, # Set to true to allow multiple selections2334 "multiSelect": bool, # Auf true setzen, um mehrere Auswahlen zu ermöglichen

2335 }2335 }

2336 ],2336 ],

2337 "answers": dict | None, # User answers populated by the permission system2337 "answers": dict[str, str | list[str]] | None,

2338 # Benutzerantworten, die vom Berechtigungssystem ausgefüllt werden. Multi-Select-

2339 # Antworten können eine Liste von Labels oder eine kommagetrennte Zeichenkette sein

2338}2340}

2339```2341```

2340 2342

2342 2344

2343```python theme={null}2345```python theme={null}

2344{2346{

2345 "questions": [ # The questions that were asked2347 "questions": [ # Die Fragen, die gestellt wurden

2346 {2348 {

2347 "question": str,2349 "question": str,

2348 "header": str,2350 "header": str,

2350 "multiSelect": bool,2352 "multiSelect": bool,

2351 }2353 }

2352 ],2354 ],

2353 "answers": dict[str, str], # Maps question text to answer string2355 "answers": dict[str, str], # Ordnet Fragetext der Antwortzeichenkette zu

2354 # Multi-select answers are comma-separated2356 # Multi-Select-Antworten sind kommagetrennt

2355}2357}

2356```2358```

2357 2359

2363 2365

2364```python theme={null}2366```python theme={null}

2365{2367{

2366 "command": str, # The command to execute2368 "command": str, # Der auszuführende Befehl

2367 "timeout": int | None, # Optional timeout in milliseconds (max 600000)2369 "timeout": int | None, # Optionales Timeout in Millisekunden (max. 600000)

2368 "description": str | None, # Clear, concise description (5-10 words)2370 "description": str | None, # Klare, prägnante Beschreibung (5-10 Wörter)

2369 "run_in_background": bool | None, # Set to true to run in background2371 "run_in_background": bool | None, # Auf true setzen, um im Hintergrund auszuführen

2370}2372}

2371```2373```

2372 2374

2374 2376

2375```python theme={null}2377```python theme={null}

2376{2378{

2377 "output": str, # Combined stdout and stderr output2379 "output": str, # Kombinierte stdout- und stderr-Ausgabe

2378 "exitCode": int, # Exit code of the command2380 "exitCode": int, # Exit-Code des Befehls

2379 "killed": bool | None, # Whether command was killed due to timeout2381 "killed": bool | None, # Ob der Befehl aufgrund eines Timeouts beendet wurde

2380 "shellId": str | None, # Shell ID for background processes2382 "shellId": str | None, # Shell-ID für Hintergrundprozesse

2381}2383}

2382```2384```

2383 2385

2391 2393

2392```python theme={null}2394```python theme={null}

2393{2395{

2394 "command": str, # Shell script; each stdout line is an event, exit ends the watch2396 "command": str, # Shell-Skript; jede stdout-Zeile ist ein Ereignis, exit beendet die Überwachung

2395 "description": str, # Short description shown in notifications2397 "description": str, # Kurze Beschreibung, die in Benachrichtigungen angezeigt wird

2396 "timeout_ms": int | None, # Kill after this deadline (default 300000, max 3600000)2398 "timeout_ms": int | None, # Nach dieser Frist beenden (Standard 300000, max. 3600000)

2397 "persistent": bool | None, # Run for the lifetime of the session; stop with TaskStop2399 "persistent": bool | None, # Für die Lebensdauer der Sitzung ausführen; mit TaskStop stoppen

2398}2400}

2399```2401```

2400 2402

2402 2404

2403```python theme={null}2405```python theme={null}

2404{2406{

2405 "taskId": str, # ID of the background monitor task2407 "taskId": str, # ID der Background-Monitor-Aufgabe

2406 "timeoutMs": int, # Timeout deadline in milliseconds (0 when persistent)2408 "timeoutMs": int, # Timeout-Frist in Millisekunden (0 wenn persistent)

2407 "persistent": bool | None, # True when running until TaskStop or session end2409 "persistent": bool | None, # True, wenn bis TaskStop oder Sitzungsende ausgeführt wird

2408}2410}

2409```2411```

2410 2412

2416 2418

2417```python theme={null}2419```python theme={null}

2418{2420{

2419 "file_path": str, # The absolute path to the file to modify2421 "file_path": str, # Der absolute Pfad zur zu ändernden Datei

2420 "old_string": str, # The text to replace2422 "old_string": str, # Der zu ersetzende Text

2421 "new_string": str, # The text to replace it with2423 "new_string": str, # Der Text, durch den er ersetzt werden soll

2422 "replace_all": bool | None, # Replace all occurrences (default False)2424 "replace_all": bool | None, # Alle Vorkommen ersetzen (Standard False)

2423}2425}

2424```2426```

2425 2427

2427 2429

2428```python theme={null}2430```python theme={null}

2429{2431{

2430 "message": str, # Confirmation message2432 "message": str, # Bestätigungsmeldung

2431 "replacements": int, # Number of replacements made2433 "replacements": int, # Anzahl der durchgeführten Ersetzungen

2432 "file_path": str, # File path that was edited2434 "file_path": str, # Dateipfad, der bearbeitet wurde

2433}2435}

2434```2436```

2435 2437

2441 2443

2442```python theme={null}2444```python theme={null}

2443{2445{

2444 "file_path": str, # The absolute path to the file to read2446 "file_path": str, # Der absolute Pfad zur zu lesenden Datei

2445 "offset": int | None, # The line number to start reading from2447 "offset": int | None, # Die Zeilennummer, ab der gelesen werden soll

2446 "limit": int | None, # The number of lines to read2448 "limit": int | None, # Die Anzahl der zu lesenden Zeilen

2447}2449}

2448```2450```

2449 2451

2451 2453

2452```python theme={null}2454```python theme={null}

2453{2455{

2454 "content": str, # File contents with line numbers2456 "content": str, # Dateiinhalt mit Zeilennummern

2455 "total_lines": int, # Total number of lines in file2457 "total_lines": int, # Gesamtzahl der Zeilen in der Datei

2456 "lines_returned": int, # Lines actually returned2458 "lines_returned": int, # Tatsächlich zurückgegebene Zeilen

2457}2459}

2458```2460```

2459 2461

2461 2463

2462```python theme={null}2464```python theme={null}

2463{2465{

2464 "image": str, # Base64 encoded image data2466 "image": str, # Base64-codierte Bilddaten

2465 "mime_type": str, # Image MIME type2467 "mime_type": str, # MIME-Typ des Bildes

2466 "file_size": int, # File size in bytes2468 "file_size": int, # Dateigröße in Bytes

2467}2469}

2468```2470```

2469 2471

2475 2477

2476```python theme={null}2478```python theme={null}

2477{2479{

2478 "file_path": str, # The absolute path to the file to write2480 "file_path": str, # Der absolute Pfad zur zu schreibenden Datei

2479 "content": str, # The content to write to the file2481 "content": str, # Der in die Datei zu schreibende Inhalt

2480}2482}

2481```2483```

2482 2484

2484 2486

2485```python theme={null}2487```python theme={null}

2486{2488{

2487 "message": str, # Success message2489 "message": str, # Erfolgsmeldung

2488 "bytes_written": int, # Number of bytes written2490 "bytes_written": int, # Anzahl der geschriebenen Bytes

2489 "file_path": str, # File path that was written2491 "file_path": str, # Dateipfad, der geschrieben wurde

2490}2492}

2491```2493```

2492 2494

2498 2500

2499```python theme={null}2501```python theme={null}

2500{2502{

2501 "pattern": str, # The glob pattern to match files against2503 "pattern": str, # Das Glob-Muster zum Abgleich von Dateien

2502 "path": str | None, # The directory to search in (defaults to cwd)2504 "path": str | None, # Das zu durchsuchende Verzeichnis (Standard: cwd)

2503}2505}

2504```2506```

2505 2507

2507 2509

2508```python theme={null}2510```python theme={null}

2509{2511{

2510 "matches": list[str], # Array of matching file paths2512 "matches": list[str], # Array von übereinstimmenden Dateipfaden

2511 "count": int, # Number of matches found2513 "count": int, # Anzahl der gefundenen Übereinstimmungen

2512 "search_path": str, # Search directory used2514 "search_path": str, # Verwendetes Suchverzeichnis

2513}2515}

2514```2516```

2515 2517

2521 2523

2522```python theme={null}2524```python theme={null}

2523{2525{

2524 "pattern": str, # The regular expression pattern2526 "pattern": str, # Das reguläre Ausdrucksmuster

2525 "path": str | None, # File or directory to search in2527 "path": str | None, # Datei oder Verzeichnis zum Durchsuchen

2526 "glob": str | None, # Glob pattern to filter files2528 "glob": str | None, # Glob-Muster zum Filtern von Dateien

2527 "type": str | None, # File type to search2529 "type": str | None, # Dateityp zum Durchsuchen

2528 "output_mode": str | None, # "content", "files_with_matches", or "count"2530 "output_mode": str | None, # "content", "files_with_matches" oder "count"

2529 "-i": bool | None, # Case insensitive search2531 "-i": bool | None, # Suche ohne Berücksichtigung der Groß-/Kleinschreibung

2530 "-n": bool | None, # Show line numbers2532 "-n": bool | None, # Zeilennummern anzeigen

2531 "-B": int | None, # Lines to show before each match2533 "-B": int | None, # Zeilen vor jeder Übereinstimmung anzeigen

2532 "-A": int | None, # Lines to show after each match2534 "-A": int | None, # Zeilen nach jeder Übereinstimmung anzeigen

2533 "-C": int | None, # Lines to show before and after2535 "-C": int | None, # Zeilen vor und nach anzeigen

2534 "head_limit": int | None, # Limit output to first N lines/entries2536 "head_limit": int | None, # Ausgabe auf erste N Zeilen/Einträge begrenzen

2535 "multiline": bool | None, # Enable multiline mode2537 "multiline": bool | None, # Mehrzeilenmodus aktivieren

2536}2538}

2537```2539```

2538 2540

2557 2559

2558```python theme={null}2560```python theme={null}

2559{2561{

2560 "files": list[str], # Files containing matches2562 "files": list[str], # Dateien mit Übereinstimmungen

2561 "count": int, # Number of files with matches2563 "count": int, # Anzahl der Dateien mit Übereinstimmungen

2562}2564}

2563```2565```

2564 2566

2570 2572

2571```python theme={null}2573```python theme={null}

2572{2574{

2573 "notebook_path": str, # Absolute path to the Jupyter notebook2575 "notebook_path": str, # Absoluter Pfad zum Jupyter-Notebook

2574 "cell_id": str | None, # The ID of the cell to edit2576 "cell_id": str | None, # Die ID der zu bearbeitenden Zelle

2575 "new_source": str, # The new source for the cell2577 "new_source": str, # Die neue Quelle für die Zelle

2576 "cell_type": "code" | "markdown" | None, # The type of the cell2578 "cell_type": "code" | "markdown" | None, # Der Typ der Zelle

2578}2580}

2579```2581```

2580 2582

2582 2584

2583```python theme={null}2585```python theme={null}

2584{2586{

2585 "message": str, # Success message2587 "message": str, # Erfolgsmeldung

2586 "edit_type": "replaced" | "inserted" | "deleted", # Type of edit performed2588 "edit_type": "replaced" | "inserted" | "deleted", # Typ der durchgeführten Bearbeitung

2587 "cell_id": str | None, # Cell ID that was affected2589 "cell_id": str | None, # Zellen-ID, die betroffen war

2588 "total_cells": int, # Total cells in notebook after edit2590 "total_cells": int, # Gesamtzellen im Notebook nach Bearbeitung

2589}2591}

2590```2592```

2591 2593

2597 2599

2598```python theme={null}2600```python theme={null}

2599{2601{

2600 "url": str, # The URL to fetch content from2602 "url": str, # Die URL, von der Inhalte abgerufen werden sollen

2601 "prompt": str, # The prompt to run on the fetched content2603 "prompt": str, # Der Prompt, der auf den abgerufenen Inhalt angewendet werden soll

2602}2604}

2603```2605```

2604 2606

2606 2608

2607```python theme={null}2609```python theme={null}

2608{2610{

2609 "response": str, # AI model's response to the prompt2611 "response": str, # Antwort des KI-Modells auf den Prompt

2610 "url": str, # URL that was fetched2612 "url": str, # URL, die abgerufen wurde

2611 "final_url": str | None, # Final URL after redirects2613 "final_url": str | None, # Endgültige URL nach Umleitungen

2612 "status_code": int | None, # HTTP status code2614 "status_code": int | None, # HTTP-Statuscode

2613}2615}

2614```2616```

2615 2617

2621 2623

2622```python theme={null}2624```python theme={null}

2623{2625{

2624 "query": str, # The search query to use2626 "query": str, # Die zu verwendende Suchanfrage

2625 "allowed_domains": list[str] | None, # Only include results from these domains2627 "allowed_domains": list[str] | None, # Nur Ergebnisse von diesen Domains einbeziehen

2626 "blocked_domains": list[str] | None, # Never include results from these domains2628 "blocked_domains": list[str] | None, # Niemals Ergebnisse von diesen Domains einbeziehen

2627}2629}

2628```2630```

2629 2631

2647{2649{

2648 "todos": [2650 "todos": [

2649 {2651 {

2650 "content": str, # The task description2652 "content": str, # Die Aufgabenbeschreibung

2651 "status": "pending" | "in_progress" | "completed", # Task status2653 "status": "pending" | "in_progress" | "completed", # Aufgabenstatus

2652 "activeForm": str, # Active form of the description2654 "activeForm": str, # Aktive Form der Beschreibung

2653 }2655 }

2654 ]2656 ]

2655}2657}

2659 2661

2660```python theme={null}2662```python theme={null}

2661{2663{

2662 "message": str, # Success message2664 "message": str, # Erfolgsmeldung

2663 "stats": {"total": int, "pending": int, "in_progress": int, "completed": int},2665 "stats": {"total": int, "pending": int, "in_progress": int, "completed": int},

2664}2666}

2665```2667```

2672 2674

2673```python theme={null}2675```python theme={null}

2674{2676{

2675 "bash_id": str, # The ID of the background shell2677 "bash_id": str, # Die ID der Background-Shell

2676 "filter": str | None, # Optional regex to filter output lines2678 "filter": str | None, # Optionaler Regex zum Filtern von Ausgabezeilen

2677}2679}

2678```2680```

2679 2681

2681 2683

2682```python theme={null}2684```python theme={null}

2683{2685{

2684 "output": str, # New output since last check2686 "output": str, # Neue Ausgabe seit der letzten Überprüfung

2685 "status": "running" | "completed" | "failed", # Current shell status2687 "status": "running" | "completed" | "failed", # Aktueller Shell-Status

2686 "exitCode": int | None, # Exit code when completed2688 "exitCode": int | None, # Exit-Code bei Abschluss

2687}2689}

2688```2690```

2689 2691

2695 2697

2696```python theme={null}2698```python theme={null}

2697{2699{

2698 "shell_id": str # The ID of the background shell to kill2700 "shell_id": str # Die ID der zu beendenden Background-Shell

2699}2701}

2700```2702```

2701 2703

2703 2705

2704```python theme={null}2706```python theme={null}

2705{2707{

2706 "message": str, # Success message2708 "message": str, # Erfolgsmeldung

2707 "shell_id": str, # ID of the killed shell2709 "shell_id": str, # ID der beendeten Shell

2708}2710}

2709```2711```

2710 2712

2716 2718

2717```python theme={null}2719```python theme={null}

2718{2720{

2719 "plan": str # The plan to run by the user for approval2721 "plan": str # Der Plan, der vom Benutzer zur Genehmigung ausgeführt werden soll

2720}2722}

2721```2723```

2722 2724

2724 2726

2725```python theme={null}2727```python theme={null}

2726{2728{

2727 "message": str, # Confirmation message2729 "message": str, # Bestätigungsmeldung

2728 "approved": bool | None, # Whether user approved the plan2730 "approved": bool | None, # Ob der Benutzer den Plan genehmigt hat

2729}2731}

2730```2732```

2731 2733

2737 2739

2738```python theme={null}2740```python theme={null}

2739{2741{

2740 "server": str | None # Optional server name to filter resources by2742 "server": str | None # Optionaler Servername zum Filtern von Ressourcen

2741}2743}

2742```2744```

2743 2745

2766 2768

2767```python theme={null}2769```python theme={null}

2768{2770{

2769 "server": str, # The MCP server name2771 "server": str, # Der MCP-Servername

2770 "uri": str, # The resource URI to read2772 "uri": str, # Die zu lesende Ressourcen-URI

2771}2773}

2772```2774```

2773 2775

agent-sdk/typescript.md +82 −0

Details

310 310

311### `resolveSettings()`

312

313Löst die effektiven Claude Code-Einstellungen für ein bestimmtes Verzeichnis mithilfe der gleichen Merge-Engine wie die CLI auf, ohne die Claude CLI zu spawnen. Verwenden Sie es, um zu überprüfen, welche Konfiguration ein `query()`-Aufruf sehen würde, bevor Sie einen aufrufen.

314

315<Note>

316 Diese Funktion ist Alpha und ihre API kann sich vor der Stabilisierung ändern. Sie liest MDM-Quellen, einschließlich macOS plist und Windows HKLM/HKCU, für Parität mit CLI-Startup, führt aber nicht den vom Administrator konfigurierten `policyHelper`-Unterprozess aus. Das Feld `permissions.defaultMode` wird unverändert aus allen Ebenen einschließlich Projekteinstellungen zurückgegeben. Der Vertrauensfilter, den die CLI vor der Berücksichtigung eskalierender Berechtigungsmodi anwendet, wird nicht angewendet.

317</Note>

318

319```typescript theme={null}

320function resolveSettings(

321 options?: ResolveSettingsOptions

322): Promise<ResolvedSettings>;

323```

324

325#### Parameter

326

327`resolveSettings()` akzeptiert ein einzelnes Optionsobjekt. Alle Felder sind optional.

328

329| Parameter | Typ | Standard | Beschreibung |

330| :------------------------------ | :------------------------------------ | :-------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

332| `options.settingSources` | [`SettingSource`](#settingsource)`[]` | Alle Quellen | Welche Dateisystemquellen geladen werden sollen. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu überspringen. Verwaltete Richtlinieneinstellungen werden in allen Fällen geladen |

333| `options.managedSettings` | `Settings` | `undefined` | Restriktive Richtlinien-Tier-Einstellungen, die auf der Ebene der verwalteten Richtlinien zusammengeführt werden. Nicht-restriktive Schlüssel wie `model` werden stillschweigend gelöscht |

335

336#### Rückgabetyp: `ResolvedSettings`

337

338`resolveSettings()` gibt ein Objekt zurück, das die zusammengeführten Einstellungen und die Quelle beschreibt, die jeden Schlüssel beigetragen hat.

339

340| Eigenschaft | Typ | Beschreibung |

341| :----------- | :-------------------------------------------------- | :----------------------------------------------------------------------------------------------- |

342| `effective` | `Settings` | Zusammengeführte Einstellungen nach Anwendung aller aktivierten Quellen in Prioritätsreihenfolge |

343| `provenance` | `Partial<Record<keyof Settings, ProvenanceEntry>>` | Für jeden Top-Level-Schlüssel in `effective`, welche Quelle den Wert bereitgestellt hat |

344| `sources` | `Array<{ source, settings, path?, policyOrigin? }>` | Pro-Quelle rohe Einstellungen, geordnet von niedrigster zu höchster Priorität |

345

346#### Beispiel

347

348Das folgende Beispiel löst Einstellungen für ein Projektverzeichnis auf und gibt die Quelle aus, die die Bereinigungsperiode steuert.

349

350```typescript theme={null}

351import { resolveSettings } from "@anthropic-ai/claude-agent-sdk";

352

353const { effective, provenance } = await resolveSettings({

354 cwd: "/path/to/project",

355 settingSources: ["user", "project", "local"],

356});

357

358console.log(`Cleanup period: ${effective.cleanupPeriodDays} days`);

359console.log(`Set by: ${provenance.cleanupPeriodDays?.source}`);

360```

361

311## Typen362## Typen

312 363

313### `Options`364### `Options`

864 | SDKFilesPersistedEvent915 | SDKFilesPersistedEvent

865 | SDKToolUseSummaryMessage916 | SDKToolUseSummaryMessage

866 | SDKRateLimitEvent917 | SDKRateLimitEvent

918 | SDKPermissionDeniedMessage

867 | SDKPromptSuggestionMessage;919 | SDKPromptSuggestionMessage;

868```920```

869 921

1052};1104};

1053```1105```

1054 1106

1107### `SDKPermissionDeniedMessage`

1108

1109Stream-Ereignis, das ausgegeben wird, wenn das Berechtigungssystem einen Tool-Aufruf automatisch ablehnt, ohne eine interaktive Eingabeaufforderung anzuzeigen. Verwenden Sie es, um die Ablehnung in Ihrer Benutzeroberfläche zu rendern, während sie geschieht, anstatt nur das `is_error`-Tool-Ergebnis zu beobachten, das folgt. Der interaktive Anfragepfad erreicht Ihre Anwendung separat über den [`canUseTool`](#canusetool)-Callback. Ablehnungen, die von einem `PreToolUse`-Hook ausgegeben werden, werden nicht über dieses Ereignis gemeldet.

1110

1111Dieses Ereignis erfordert Claude Code v2.1.136 oder später.

1112

1113```typescript theme={null}

1114type SDKPermissionDeniedMessage = {

1115 type: "system";

1116 subtype: "permission_denied";

1117 tool_name: string;

1118 tool_use_id: string;

1119 agent_id?: string;

1120 decision_reason_type?: string;

1121 decision_reason?: string;

1122 message: string;

1123 uuid: UUID;

1124 session_id: string;

1125};

1126```

1127

1128| Feld | Typ | Beschreibung |

1129| ---------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |

1130| `tool_name` | `string` | Name des Tools, das abgelehnt wurde |

1131| `tool_use_id` | `string` | ID des `tool_use`-Blocks, auf den diese Ablehnung antwortet |

1132| `agent_id` | `string` | Subagent-ID, wenn der abgelehnte Aufruf innerhalb eines Subagenten stammt. Spiegelt das Feld auf `can_use_tool` für das Routing auf der Host-Seite |

1133| `decision_reason_type` | `string` | Diskriminator für die Komponente, die entschieden hat, z. B. `"rule"`, `"mode"`, `"classifier"` oder `"asyncAgent"` |

1134| `decision_reason` | `string` | Menschenlesbarer Grund von der entscheidenden Komponente, wenn verfügbar |

1135| `message` | `string` | Ablehnungsnachricht, die an das Modell im `tool_result` zurückgegeben wird |

1136

1055### `SDKPermissionDenial`1137### `SDKPermissionDenial`

1056 1138

1057Informationen über einen verweigerten Tool-Einsatz.1139Informationen über einen verweigerten Tool-Einsatz.

agent-sdk/user-input.md +810 −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# Genehmigungen und Benutzereingaben verarbeiten

7> Zeigen Sie Claudes Genehmigungsanfragen und Klärungsfragen den Benutzern an und geben Sie deren Entscheidungen an das SDK zurück.

9Während Claude an einer Aufgabe arbeitet, muss er manchmal mit Benutzern Rücksprache halten. Er könnte eine Genehmigung benötigen, bevor er Dateien löscht, oder fragen müssen, welche Datenbank für ein neues Projekt verwendet werden soll. Ihre Anwendung muss diese Anfragen den Benutzern anzeigen, damit Claude mit deren Eingabe fortfahren kann.

11Claude fordert Benutzereingaben in zwei Situationen an: wenn er **Genehmigung zur Verwendung eines Tools benötigt** (wie das Löschen von Dateien oder das Ausführen von Befehlen) und wenn er **Klärungsfragen hat** (über das `AskUserQuestion`-Tool). Beide lösen Ihren `canUseTool`-Callback aus, der die Ausführung pausiert, bis Sie eine Antwort zurückgeben. Dies unterscheidet sich von normalen Gesprächsrunden, bei denen Claude fertig ist und auf Ihre nächste Nachricht wartet.

13Bei Klärungsfragen generiert Claude die Fragen und Optionen. Ihre Aufgabe besteht darin, sie den Benutzern zu präsentieren und ihre Auswahl zurückzugeben. Sie können diesem Ablauf keine eigenen Fragen hinzufügen; wenn Sie Benutzer selbst etwas fragen müssen, tun Sie dies separat in Ihrer Anwendungslogik.

15Der Callback kann unbegrenzt ausstehend bleiben. Die Ausführung bleibt pausiert, bis Ihr Callback zurückkommt, und das SDK bricht das Warten nur ab, wenn die Abfrage selbst abgebrochen wird. Wenn ein Benutzer länger braucht, um zu antworten, als Ihr Prozess vernünftigerweise laufen kann, unterstützt das TypeScript SDK den [`defer`-Hook-Entscheidung](/de/hooks#defer-a-tool-call-for-later), mit dem der Prozess beendet und später aus der persistierten Sitzung fortgesetzt werden kann; diese Option ist im Python SDK nicht verfügbar.

17Diese Anleitung zeigt Ihnen, wie Sie jeden Anforderungstyp erkennen und angemessen reagieren.

19## Erkennen Sie, wenn Claude Eingaben benötigt

21Übergeben Sie einen `canUseTool`-Callback in Ihren Abfrageoptionen. Der Callback wird ausgelöst, wenn Claude Benutzereingaben benötigt, und erhält den Tool-Namen und die Eingabe als Argumente:

23<CodeGroup>

24 ```python Python theme={null}

25 async def handle_tool_request(tool_name, input_data, context):

26 # Benutzer auffordern und Zulassung oder Ablehnung zurückgeben

27 ...

30 options = ClaudeAgentOptions(can_use_tool=handle_tool_request)

31 ```

33 ```typescript TypeScript theme={null}

34 async function handleToolRequest(toolName, input, options) {

35 // options includes { signal: AbortSignal, suggestions?: PermissionUpdate[] }

36 // Benutzer auffordern und Zulassung oder Ablehnung zurückgeben

37 }

39 const options = { canUseTool: handleToolRequest };

40 ```

41</CodeGroup>

43Der Callback wird in zwei Fällen ausgelöst:

451. **Tool benötigt Genehmigung**: Claude möchte ein Tool verwenden, das nicht durch [Berechtigungsregeln](/de/agent-sdk/permissions) oder Modi automatisch genehmigt wird. Überprüfen Sie `tool_name` auf das Tool (z. B. `"Bash"`, `"Write"`).

462. **Claude stellt eine Frage**: Claude ruft das `AskUserQuestion`-Tool auf. Überprüfen Sie, ob `tool_name == "AskUserQuestion"`, um es anders zu behandeln. Wenn Sie ein `tools`-Array angeben, fügen Sie `AskUserQuestion` ein, damit dies funktioniert. Siehe [Klärungsfragen verarbeiten](#handle-clarifying-questions) für Details.

48<Note>

49 Um Tools automatisch zuzulassen oder abzulehnen, ohne Benutzer zu fragen, verwenden Sie stattdessen [Hooks](/de/agent-sdk/hooks). Hooks werden vor `canUseTool` ausgeführt und können Anfragen basierend auf Ihrer eigenen Logik zulassen, ablehnen oder ändern. Sie können auch den [`PermissionRequest`-Hook](/de/agent-sdk/hooks#available-hooks) verwenden, um externe Benachrichtigungen (Slack, E-Mail, Push) zu senden, wenn Claude auf Genehmigung wartet.

50</Note>

52## Tool-Genehmigungsanfragen verarbeiten

54Nachdem Sie einen `canUseTool`-Callback in Ihren Abfrageoptionen übergeben haben, wird er ausgelöst, wenn Claude ein Tool verwenden möchte, das nicht automatisch genehmigt ist. Ihr Callback erhält drei Argumente:

56| Argument | Beschreibung |

57| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

58| `toolName` | Der Name des Tools, das Claude verwenden möchte (z. B. `"Bash"`, `"Write"`, `"Edit"`) |

59| `input` | Die Parameter, die Claude an das Tool übergibt. Der Inhalt variiert je nach Tool. |

60| `options` (TS) / `context` (Python) | Zusätzlicher Kontext, einschließlich optionaler `suggestions` (vorgeschlagene `PermissionUpdate`-Einträge, um erneute Aufforderungen zu vermeiden) und eines Abbruchsignals. In TypeScript ist `signal` ein `AbortSignal`; in Python ist das Signalfeld für zukünftige Verwendung reserviert. Siehe [`ToolPermissionContext`](/de/agent-sdk/python#toolpermissioncontext) für Python. |

62Das `input`-Objekt enthält Tool-spezifische Parameter. Häufige Beispiele:

64| Tool | Eingabefelder |

65| ------- | --------------------------------------- |

66| `Bash` | `command`, `description`, `timeout` |

67| `Write` | `file_path`, `content` |

68| `Edit` | `file_path`, `old_string`, `new_string` |

69| `Read` | `file_path`, `offset`, `limit` |

71Siehe die SDK-Referenz für vollständige Eingabeschemas: [Python](/de/agent-sdk/python#tool-input%2Foutput-types) | [TypeScript](/de/agent-sdk/typescript#tool-input-types).

73Sie können diese Informationen dem Benutzer anzeigen, damit er entscheiden kann, ob er die Aktion zulässt oder ablehnt, und dann die entsprechende Antwort zurückgeben.

75Das folgende Beispiel fordert Claude auf, eine Testdatei zu erstellen und zu löschen. Wenn Claude jeden Vorgang versucht, druckt der Callback die Tool-Anfrage auf dem Terminal aus und fordert zur y/n-Genehmigung auf.

77<CodeGroup>

78 ```python Python theme={null}

79 import asyncio

81 from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query

82 from claude_agent_sdk.types import (

83 HookMatcher,

84 PermissionResultAllow,

85 PermissionResultDeny,

86 ToolPermissionContext,

87 )

90 async def can_use_tool(

91 tool_name: str, input_data: dict, context: ToolPermissionContext

92 ) -> PermissionResultAllow | PermissionResultDeny:

93 # Tool-Anfrage anzeigen

94 print(f"\nTool: {tool_name}")

95 if tool_name == "Bash":

96 print(f"Command: {input_data.get('command')}")

97 if input_data.get("description"):

98 print(f"Description: {input_data.get('description')}")

99 else:

100 print(f"Input: {input_data}")

101

102 # Benutzergenehmigung abrufen

103 response = input("Allow this action? (y/n): ")

104

105 # Zulassung oder Ablehnung basierend auf der Antwort des Benutzers zurückgeben

106 if response.lower() == "y":

107 # Zulassen: Tool wird mit der ursprünglichen (oder geänderten) Eingabe ausgeführt

108 return PermissionResultAllow(updated_input=input_data)

109 else:

110 # Ablehnen: Tool wird nicht ausgeführt, Claude sieht die Nachricht

111 return PermissionResultDeny(message="User denied this action")

112

113

114 # Erforderliche Umgehung: Dummy-Hook hält den Stream für can_use_tool offen

115 async def dummy_hook(input_data, tool_use_id, context):

116 return {"continue_": True}

117

118

119 async def prompt_stream():

120 yield {

121 "type": "user",

122 "message": {

123 "role": "user",

124 "content": "Create a test file in /tmp and then delete it",

125 },

126 }

127

128

129 async def main():

130 async for message in query(

131 prompt=prompt_stream(),

132 options=ClaudeAgentOptions(

133 can_use_tool=can_use_tool,

134 hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},

135 ),

136 ):

137 if isinstance(message, ResultMessage) and message.subtype == "success":

138 print(message.result)

139

140

141 asyncio.run(main())

142 ```

143

144 ```typescript TypeScript theme={null}

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

146 import * as readline from "readline";

147

148 // Hilfsfunktion zum Auffordern von Benutzereingaben im Terminal

149 function prompt(question: string): Promise<string> {

150 const rl = readline.createInterface({

151 input: process.stdin,

152 output: process.stdout

153 });

154 return new Promise((resolve) =>

155 rl.question(question, (answer) => {

156 rl.close();

157 resolve(answer);

158 })

159 );

160 }

161

162 for await (const message of query({

163 prompt: "Create a test file in /tmp and then delete it",

164 options: {

165 canUseTool: async (toolName, input) => {

166 // Tool-Anfrage anzeigen

167 console.log(`\nTool: ${toolName}`);

168 if (toolName === "Bash") {

169 console.log(`Command: ${input.command}`);

170 if (input.description) console.log(`Description: ${input.description}`);

171 } else {

172 console.log(`Input: ${JSON.stringify(input, null, 2)}`);

173 }

174

175 // Benutzergenehmigung abrufen

176 const response = await prompt("Allow this action? (y/n): ");

177

178 // Zulassung oder Ablehnung basierend auf der Antwort des Benutzers zurückgeben

179 if (response.toLowerCase() === "y") {

180 // Zulassen: Tool wird mit der ursprünglichen (oder geänderten) Eingabe ausgeführt

181 return { behavior: "allow", updatedInput: input };

182 } else {

183 // Ablehnen: Tool wird nicht ausgeführt, Claude sieht die Nachricht

184 return { behavior: "deny", message: "User denied this action" };

185 }

186 }

187 }

188 })) {

189 if ("result" in message) console.log(message.result);

190 }

191 ```

192</CodeGroup>

193

194<Note>

195 In Python erfordert `can_use_tool` den [Streaming-Modus](/de/agent-sdk/streaming-vs-single-mode) und einen `PreToolUse`-Hook, der `{"continue_": True}` zurückgibt, um den Stream offen zu halten. Ohne diesen Hook wird der Stream geschlossen, bevor der Berechtigungscallback aufgerufen werden kann.

196</Note>

197

198Dieses Beispiel verwendet einen `y/n`-Ablauf, bei dem jede Eingabe außer `y` als Ablehnung behandelt wird. In der Praxis könnten Sie eine umfangreichere Benutzeroberfläche erstellen, die es Benutzern ermöglicht, die Anfrage zu ändern, Feedback zu geben oder Claude vollständig umzuleiten. Siehe [Auf Tool-Anfragen reagieren](#respond-to-tool-requests) für alle Möglichkeiten, wie Sie reagieren können.

199

200### Auf Tool-Anfragen reagieren

201

202Ihr Callback gibt einen von zwei Antworttypen zurück:

203

204| Antwort | Python | TypeScript |

205| ------------ | ------------------------------------------ | ------------------------------------- |

206| **Zulassen** | `PermissionResultAllow(updated_input=...)` | `{ behavior: "allow", updatedInput }` |

207| **Ablehnen** | `PermissionResultDeny(message=...)` | `{ behavior: "deny", message }` |

208

209Beim Zulassen übergeben Sie die Tool-Eingabe (original oder geändert). Beim Ablehnen geben Sie eine Nachricht an, die erklärt, warum. Claude sieht diese Nachricht und kann seinen Ansatz anpassen.

210

211<CodeGroup>

212 ```python Python theme={null}

213 from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

214

215 # Tool-Ausführung zulassen

216 return PermissionResultAllow(updated_input=input_data)

217

218 # Tool blockieren

219 return PermissionResultDeny(message="User rejected this action")

220 ```

221

222 ```typescript TypeScript theme={null}

223 // Tool-Ausführung zulassen

224 return { behavior: "allow", updatedInput: input };

225

226 // Tool blockieren

227 return { behavior: "deny", message: "User rejected this action" };

228 ```

229</CodeGroup>

230

231Über das Zulassen oder Ablehnen hinaus können Sie die Eingabe des Tools ändern oder Kontext bereitstellen, der Claude hilft, seinen Ansatz anzupassen:

232

233* **Genehmigen**: Lassen Sie das Tool genau wie von Claude angefordert ausführen

234* **Mit Änderungen genehmigen**: Ändern Sie die Eingabe vor der Ausführung (z. B. Pfade bereinigen, Einschränkungen hinzufügen)

235* **Ablehnen**: Blockieren Sie das Tool und teilen Sie Claude mit, warum

236* **Alternative vorschlagen**: Blockieren Sie, aber leiten Sie Claude zu dem hin, was der Benutzer stattdessen möchte

237* **Vollständig umleiten**: Verwenden Sie [Streaming-Eingabe](/de/agent-sdk/streaming-vs-single-mode), um Claude eine völlig neue Anweisung zu senden

238

239<Tabs>

240 <Tab title="Genehmigen">

241 Der Benutzer genehmigt die Aktion unverändert. Geben Sie die `input` aus Ihrem Callback unverändert durch und das Tool wird genau wie von Claude angefordert ausgeführt.

242

243 <CodeGroup>

244 ```python Python theme={null}

245 async def can_use_tool(tool_name, input_data, context):

246 print(f"Claude wants to use {tool_name}")

247 approved = await ask_user("Allow this action?")

248

249 if approved:

250 return PermissionResultAllow(updated_input=input_data)

251 return PermissionResultDeny(message="User declined")

252 ```

253

254 ```typescript TypeScript theme={null}

255 canUseTool: async (toolName, input) => {

256 console.log(`Claude wants to use ${toolName}`);

257 const approved = await askUser("Allow this action?");

258

259 if (approved) {

260 return { behavior: "allow", updatedInput: input };

261 }

262 return { behavior: "deny", message: "User declined" };

263 };

264 ```

265 </CodeGroup>

266 </Tab>

267

268 <Tab title="Mit Änderungen genehmigen">

269 Der Benutzer genehmigt, möchte aber die Anfrage zuerst ändern. Sie können die Eingabe vor der Tool-Ausführung ändern. Claude sieht das Ergebnis, wird aber nicht darüber informiert, dass Sie etwas geändert haben. Nützlich zum Bereinigen von Parametern, zum Hinzufügen von Einschränkungen oder zum Einschränken des Zugriffs.

270

271 <CodeGroup>

272 ```python Python theme={null}

273 async def can_use_tool(tool_name, input_data, context):

274 if tool_name == "Bash":

275 # Benutzer genehmigt, aber alle Befehle auf Sandbox beschränken

276 sandboxed_input = {**input_data}

277 sandboxed_input["command"] = input_data["command"].replace(

278 "/tmp", "/tmp/sandbox"

279 )

280 return PermissionResultAllow(updated_input=sandboxed_input)

281 return PermissionResultAllow(updated_input=input_data)

282 ```

283

284 ```typescript TypeScript theme={null}

285 canUseTool: async (toolName, input) => {

286 if (toolName === "Bash") {

287 // Benutzer genehmigt, aber alle Befehle auf Sandbox beschränken

288 const sandboxedInput = {

289 ...input,

290 command: input.command.replace("/tmp", "/tmp/sandbox")

291 };

292 return { behavior: "allow", updatedInput: sandboxedInput };

293 }

294 return { behavior: "allow", updatedInput: input };

295 };

296 ```

297 </CodeGroup>

298 </Tab>

299

300 <Tab title="Ablehnen">

301 Der Benutzer möchte nicht, dass diese Aktion stattfindet. Blockieren Sie das Tool und geben Sie eine Nachricht an, die erklärt, warum. Claude sieht diese Nachricht und kann einen anderen Ansatz versuchen.

302

303 <CodeGroup>

304 ```python Python theme={null}

305 async def can_use_tool(tool_name, input_data, context):

306 approved = await ask_user(f"Allow {tool_name}?")

307

308 if not approved:

309 return PermissionResultDeny(message="User rejected this action")

310 return PermissionResultAllow(updated_input=input_data)

311 ```

312

313 ```typescript TypeScript theme={null}

314 canUseTool: async (toolName, input) => {

315 const approved = await askUser(`Allow ${toolName}?`);

316

317 if (!approved) {

318 return {

319 behavior: "deny",

320 message: "User rejected this action"

321 };

322 }

323 return { behavior: "allow", updatedInput: input };

324 };

325 ```

326 </CodeGroup>

327 </Tab>

328

329 <Tab title="Alternative vorschlagen">

330 Der Benutzer möchte diese spezifische Aktion nicht, hat aber eine andere Idee. Blockieren Sie das Tool und fügen Sie Anleitung in Ihre Nachricht ein. Claude wird dies lesen und basierend auf Ihrem Feedback entscheiden, wie er vorgehen soll.

331

332 <CodeGroup>

333 ```python Python theme={null}

334 async def can_use_tool(tool_name, input_data, context):

335 if tool_name == "Bash" and "rm" in input_data.get("command", ""):

336 # Benutzer möchte nicht löschen, schlagen Sie stattdessen Archivierung vor

337 return PermissionResultDeny(

338 message="User doesn't want to delete files. They asked if you could compress them into an archive instead."

339 )

340 return PermissionResultAllow(updated_input=input_data)

341 ```

342

343 ```typescript TypeScript theme={null}

344 canUseTool: async (toolName, input) => {

345 if (toolName === "Bash" && input.command.includes("rm")) {

346 // Benutzer möchte nicht löschen, schlagen Sie stattdessen Archivierung vor

347 return {

348 behavior: "deny",

349 message:

350 "User doesn't want to delete files. They asked if you could compress them into an archive instead."

351 };

352 }

353 return { behavior: "allow", updatedInput: input };

354 };

355 ```

356 </CodeGroup>

357 </Tab>

358

359 <Tab title="Vollständig umleiten">

360 Für eine vollständige Richtungsänderung (nicht nur einen Anstoß) verwenden Sie [Streaming-Eingabe](/de/agent-sdk/streaming-vs-single-mode), um Claude eine neue Anweisung direkt zu senden. Dies umgeht die aktuelle Tool-Anfrage und gibt Claude völlig neue Anweisungen zum Befolgen.

361 </Tab>

362</Tabs>

363

364## Klärungsfragen verarbeiten

365

366Wenn Claude mehr Anleitung zu einer Aufgabe mit mehreren gültigen Ansätzen benötigt, ruft es das `AskUserQuestion`-Tool auf. Dies löst Ihren `canUseTool`-Callback mit `toolName` auf `AskUserQuestion` aus. Die Eingabe enthält Claudes Fragen als Multiple-Choice-Optionen, die Sie dem Benutzer anzeigen und deren Auswahl zurückgeben.

367

368<Tip>

369 Klärungsfragen sind besonders häufig im [`plan`-Modus](/de/agent-sdk/permissions#plan-mode-plan), in dem Claude die Codebasis erkundet und Fragen stellt, bevor er einen Plan vorschlägt. Dies macht den Plan-Modus ideal für interaktive Workflows, bei denen Claude Anforderungen sammeln soll, bevor Änderungen vorgenommen werden.

370</Tip>

371

372Die folgenden Schritte zeigen, wie Sie Klärungsfragen verarbeiten:

373

374<Steps>

375 <Step title="Übergeben Sie einen canUseTool-Callback">

376 Übergeben Sie einen `canUseTool`-Callback in Ihren Abfrageoptionen. Standardmäßig ist `AskUserQuestion` verfügbar. Wenn Sie ein `tools`-Array angeben, um Claudes Funktionen einzuschränken (z. B. einen schreibgeschützten Agent mit nur `Read`, `Glob` und `Grep`), fügen Sie `AskUserQuestion` in dieses Array ein. Andernfalls kann Claude keine Klärungsfragen stellen:

377

378 <CodeGroup>

379 ```python Python theme={null}

380 async for message in query(

381 prompt="Analyze this codebase",

382 options=ClaudeAgentOptions(

383 # Fügen Sie AskUserQuestion in Ihre Tools-Liste ein

384 tools=["Read", "Glob", "Grep", "AskUserQuestion"],

385 can_use_tool=can_use_tool,

386 ),

387 ):

388 print(message)

389 ```

390

391 ```typescript TypeScript theme={null}

392 for await (const message of query({

393 prompt: "Analyze this codebase",

394 options: {

395 // Fügen Sie AskUserQuestion in Ihre Tools-Liste ein

396 tools: ["Read", "Glob", "Grep", "AskUserQuestion"],

397 canUseTool: async (toolName, input) => {

398 // Klärungsfragen hier verarbeiten

399 }

400 }

401 })) {

402 console.log(message);

403 }

404 ```

405 </CodeGroup>

406 </Step>

407

408 <Step title="Erkennen Sie AskUserQuestion">

409 Überprüfen Sie in Ihrem Callback, ob `toolName` gleich `AskUserQuestion` ist, um es anders als andere Tools zu behandeln:

410

411 <CodeGroup>

412 ```python Python theme={null}

413 async def can_use_tool(tool_name: str, input_data: dict, context):

414 if tool_name == "AskUserQuestion":

415 # Ihre Implementierung zum Sammeln von Antworten vom Benutzer

416 return await handle_clarifying_questions(input_data)

417 # Andere Tools normal verarbeiten

418 return await prompt_for_approval(tool_name, input_data)

419 ```

420

421 ```typescript TypeScript theme={null}

422 canUseTool: async (toolName, input) => {

423 if (toolName === "AskUserQuestion") {

424 // Ihre Implementierung zum Sammeln von Antworten vom Benutzer

425 return handleClarifyingQuestions(input);

426 }

427 // Andere Tools normal verarbeiten

428 return promptForApproval(toolName, input);

429 };

430 ```

431 </CodeGroup>

432 </Step>

433

434 <Step title="Analysieren Sie die Frageneingabe">

435 Die Eingabe enthält Claudes Fragen in einem `questions`-Array. Jede Frage hat eine `question` (der anzuzeigende Text), `options` (die Auswahlmöglichkeiten) und `multiSelect` (ob mehrere Auswahlen zulässig sind):

436

437 ```json theme={null}

438 {

439 "questions": [

440 {

441 "question": "How should I format the output?",

442 "header": "Format",

443 "options": [

444 { "label": "Summary", "description": "Brief overview" },

445 { "label": "Detailed", "description": "Full explanation" }

446 ],

447 "multiSelect": false

448 },

449 {

450 "question": "Which sections should I include?",

451 "header": "Sections",

452 "options": [

453 { "label": "Introduction", "description": "Opening context" },

454 { "label": "Conclusion", "description": "Final summary" }

455 ],

456 "multiSelect": true

457 }

458 ]

459 }

460 ```

461

462 Siehe [Frageformat](#question-format) für vollständige Feldbeschreibungen.

463 </Step>

464

465 <Step title="Sammeln Sie Antworten vom Benutzer">

466 Präsentieren Sie die Fragen dem Benutzer und sammeln Sie deren Auswahl. Wie Sie dies tun, hängt von Ihrer Anwendung ab: ein Terminal-Prompt, ein Web-Formular, ein mobiler Dialog usw.

467 </Step>

468

469 <Step title="Geben Sie Antworten an Claude zurück">

470 Erstellen Sie das `answers`-Objekt als Datensatz, wobei jeder Schlüssel der `question`-Text ist und jeder Wert das `label` der ausgewählten Option ist:

471

472 | Aus dem Frageobjekt | Verwenden Sie als |

473 | ----------------------------------------------------------- | ----------------- |

474 | `question`-Feld (z. B. `"How should I format the output?"`) | Schlüssel |

475 | `label`-Feld der ausgewählten Option (z. B. `"Summary"`) | Wert |

476

477 Für Multi-Select-Fragen übergeben Sie ein Array von Labels oder verbinden Sie sie mit `", "`. Wenn Sie [freie Texteingabe unterstützen](#support-free-text-input), verwenden Sie den benutzerdefinierten Text des Benutzers als Wert.

478

479 <CodeGroup>

480 ```python Python theme={null}

481 return PermissionResultAllow(

482 updated_input={

483 "questions": input_data.get("questions", []),

484 "answers": {

485 "How should I format the output?": "Summary",

486 "Which sections should I include?": ["Introduction", "Conclusion"],

487 },

488 }

489 )

490 ```

491

492 ```typescript TypeScript theme={null}

493 return {

494 behavior: "allow",

495 updatedInput: {

496 questions: input.questions,

497 answers: {

498 "How should I format the output?": "Summary",

499 "Which sections should I include?": "Introduction, Conclusion"

500 }

501 }

502 };

503 ```

504 </CodeGroup>

505 </Step>

506</Steps>

507

508### Frageformat

509

510Die Eingabe enthält Claudes generierte Fragen in einem `questions`-Array. Jede Frage hat diese Felder:

511

512| Feld | Beschreibung |

513| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |

514| `question` | Der vollständige Fragetext zum Anzeigen |

515| `header` | Kurzes Label für die Frage (max. 12 Zeichen) |

516| `options` | Array von 2-4 Auswahlmöglichkeiten, jeweils mit `label` und `description`. TypeScript: optional `preview` (siehe [unten](#option-previews-type-script)) |

517| `multiSelect` | Wenn `true`, können Benutzer mehrere Optionen auswählen |

518

519Die Struktur, die Ihr Callback erhält:

520

521```json theme={null}

522{

523 "questions": [

524 {

525 "question": "How should I format the output?",

526 "header": "Format",

527 "options": [

528 { "label": "Summary", "description": "Brief overview of key points" },

529 { "label": "Detailed", "description": "Full explanation with examples" }

530 ],

531 "multiSelect": false

532 }

533 ]

534}

535```

536

537#### Optionsvorschau (TypeScript)

538

539`toolConfig.askUserQuestion.previewFormat` fügt jedem Option ein `preview`-Feld hinzu, damit Ihre App ein visuelles Mockup neben dem Label anzeigen kann. Ohne diese Einstellung generiert Claude keine Vorschau und das Feld ist nicht vorhanden.

540

541| `previewFormat` | `preview` enthält |

542| :----------------------- | :--------------------------------------------------------------------------------------------------------------------------- |

543| nicht gesetzt (Standard) | Feld ist nicht vorhanden. Claude generiert keine Vorschau. |

544| `"markdown"` | ASCII-Art und eingezäunte Code-Blöcke |

545| `"html"` | Ein gestyltes `<div>`-Fragment (das SDK lehnt `<script>`, `<style>` und `<!DOCTYPE>` ab, bevor Ihr Callback ausgeführt wird) |

546

547Das Format gilt für alle Fragen in der Sitzung. Claude fügt `preview` bei Optionen ein, bei denen ein visueller Vergleich hilfreich ist (Layout-Auswahlmöglichkeiten, Farbschemas) und lässt es weg, wo nicht (Ja/Nein-Bestätigungen, nur Text-Auswahlmöglichkeiten). Überprüfen Sie auf `undefined`, bevor Sie rendern.

548

549```typescript theme={null}

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

551

552for await (const message of query({

553 prompt: "Help me choose a card layout",

554 options: {

555 toolConfig: {

556 askUserQuestion: { previewFormat: "html" }

557 },

558 canUseTool: async (toolName, input) => {

559 // input.questions[].options[].preview ist ein HTML-String oder undefined

560 return { behavior: "allow", updatedInput: input };

561 }

562 }

563})) {

564 // ...

565}

566```

567

568Eine Option mit HTML-Vorschau:

569

570```json theme={null}

571{

572 "label": "Compact",

573 "description": "Title and metric value only",

574 "preview": "<div style=\"padding:12px;border:1px solid #ddd;border-radius:8px\"><div style=\"font-size:12px;color:#666\">Active users</div><div style=\"font-size:28px;font-weight:600\">1,284</div></div>"

575}

576```

577

578### Antwortformat

579

580Geben Sie ein `answers`-Objekt zurück, das jedes `question`-Feld der Frage dem `label` der ausgewählten Option zuordnet:

581

582| Feld | Beschreibung |

583| ----------- | ------------------------------------------------------------------------------------------ |

584| `questions` | Geben Sie das ursprüngliche Questions-Array durch (erforderlich für die Tool-Verarbeitung) |

585| `answers` | Objekt, bei dem Schlüssel Fragetext und Werte ausgewählte Labels sind |

586

587Für Multi-Select-Fragen übergeben Sie ein Array von Labels oder verbinden Sie sie mit `", "`. Für freie Texteingabe verwenden Sie den benutzerdefinierten Text des Benutzers direkt.

588

589```json theme={null}

590{

591 "questions": [

592 // ...

593 ],

594 "answers": {

595 "How should I format the output?": "Summary",

596 "Which sections should I include?": ["Introduction", "Conclusion"]

597 }

598}

599```

600

601#### Unterstützen Sie freie Texteingabe

602

603Claudes vordefinierte Optionen decken nicht immer ab, was Benutzer möchten. Um Benutzern zu ermöglichen, ihre eigene Antwort einzugeben:

604

605* Zeigen Sie nach Claudes Optionen eine zusätzliche "Other"-Auswahlmöglichkeit an, die Texteingabe akzeptiert

606* Verwenden Sie den benutzerdefinierten Text des Benutzers als Antwortwert (nicht das Wort "Other")

607

608Siehe das [vollständige Beispiel](#complete-example) unten für eine vollständige Implementierung.

609

610### Vollständiges Beispiel

611

612Claude stellt Klärungsfragen, wenn er Benutzereingaben benötigt, um fortzufahren. Wenn Claude beispielsweise aufgefordert wird, bei der Entscheidung über einen Tech-Stack für eine mobile App zu helfen, könnte Claude Fragen zu Cross-Platform vs. Native, Backend-Vorlieben oder Zielplattformen stellen. Diese Fragen helfen Claude, Entscheidungen zu treffen, die den Vorlieben des Benutzers entsprechen, anstatt zu raten.

613

614Dieses Beispiel verarbeitet diese Fragen in einer Terminal-Anwendung. Hier ist, was bei jedem Schritt passiert:

615

6161. **Leiten Sie die Anfrage weiter**: Der `canUseTool`-Callback überprüft, ob der Tool-Name `"AskUserQuestion"` ist, und leitet zu einem dedizierten Handler weiter

6172. **Zeigen Sie Fragen an**: Der Handler durchläuft das `questions`-Array und druckt jede Frage mit nummerierten Optionen

6183. **Sammeln Sie Eingaben**: Der Benutzer kann eine Nummer eingeben, um eine Option auszuwählen, oder direkt freien Text eingeben (z. B. "jquery", "i don't know")

6194. **Ordnen Sie Antworten zu**: Der Code überprüft, ob die Eingabe numerisch ist (verwendet das Label der Option) oder freier Text (verwendet den Text direkt)

6205. **Geben Sie an Claude zurück**: Die Antwort enthält sowohl das ursprüngliche `questions`-Array als auch die `answers`-Zuordnung

621

622<CodeGroup>

623 ```python Python theme={null}

624 import asyncio

625

626 from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query

627 from claude_agent_sdk.types import HookMatcher, PermissionResultAllow

628

629

630 def parse_response(response: str, options: list) -> str:

631 """Analysieren Sie Benutzereingaben als Optionsnummer(n) oder freien Text."""

632 try:

633 indices = [int(s.strip()) - 1 for s in response.split(",")]

634 labels = [options[i]["label"] for i in indices if 0 <= i < len(options)]

635 return ", ".join(labels) if labels else response

636 except ValueError:

637 return response

638

639

640 async def handle_ask_user_question(input_data: dict) -> PermissionResultAllow:

641 """Zeigen Sie Claudes Fragen an und sammeln Sie Benutzerantworten."""

642 answers = {}

643

644 for q in input_data.get("questions", []):

645 print(f"\n{q['header']}: {q['question']}")

646

647 options = q["options"]

648 for i, opt in enumerate(options):

649 print(f" {i + 1}. {opt['label']} - {opt['description']}")

650 if q.get("multiSelect"):

651 print(" (Enter numbers separated by commas, or type your own answer)")

652 else:

653 print(" (Enter a number, or type your own answer)")

654

655 response = input("Your choice: ").strip()

656 answers[q["question"]] = parse_response(response, options)

657

658 return PermissionResultAllow(

659 updated_input={

660 "questions": input_data.get("questions", []),

661 "answers": answers,

662 }

663 )

664

665

666 async def can_use_tool(

667 tool_name: str, input_data: dict, context

668 ) -> PermissionResultAllow:

669 # Leiten Sie AskUserQuestion zu unserem Frage-Handler weiter

670 if tool_name == "AskUserQuestion":

671 return await handle_ask_user_question(input_data)

672 # Auto-Genehmigung anderer Tools für dieses Beispiel

673 return PermissionResultAllow(updated_input=input_data)

674

675

676 async def prompt_stream():

677 yield {

678 "type": "user",

679 "message": {

680 "role": "user",

681 "content": "Help me decide on the tech stack for a new mobile app",

682 },

683 }

684

685

686 # Erforderliche Umgehung: Dummy-Hook hält den Stream für can_use_tool offen

687 async def dummy_hook(input_data, tool_use_id, context):

688 return {"continue_": True}

689

690

691 async def main():

692 async for message in query(

693 prompt=prompt_stream(),

694 options=ClaudeAgentOptions(

695 can_use_tool=can_use_tool,

696 hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},

697 ),

698 ):

699 if isinstance(message, ResultMessage) and message.subtype == "success":

700 print(message.result)

701

702

703 asyncio.run(main())

704 ```

705

706 ```typescript TypeScript theme={null}

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

708 import * as readline from "readline/promises";

709

710 // Hilfsfunktion zum Auffordern von Benutzereingaben im Terminal

711 async function prompt(question: string): Promise<string> {

712 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

713 const answer = await rl.question(question);

714 rl.close();

715 return answer;

716 }

717

718 // Analysieren Sie Benutzereingaben als Optionsnummer(n) oder freien Text

719 function parseResponse(response: string, options: any[]): string {

720 const indices = response.split(",").map((s) => parseInt(s.trim()) - 1);

721 const labels = indices

722 .filter((i) => !isNaN(i) && i >= 0 && i < options.length)

723 .map((i) => options[i].label);

724 return labels.length > 0 ? labels.join(", ") : response;

725 }

726

727 // Zeigen Sie Claudes Fragen an und sammeln Sie Benutzerantworten

728 async function handleAskUserQuestion(input: any) {

729 const answers: Record<string, string> = {};

730

731 for (const q of input.questions) {

732 console.log(`\n${q.header}: ${q.question}`);

733

734 const options = q.options;

735 options.forEach((opt: any, i: number) => {

736 console.log(` ${i + 1}. ${opt.label} - ${opt.description}`);

737 });

738 if (q.multiSelect) {

739 console.log(" (Enter numbers separated by commas, or type your own answer)");

740 } else {

741 console.log(" (Enter a number, or type your own answer)");

742 }

743

744 const response = (await prompt("Your choice: ")).trim();

745 answers[q.question] = parseResponse(response, options);

746 }

747

748 // Geben Sie die Antworten an Claude zurück (muss ursprüngliche Fragen enthalten)

749 return {

750 behavior: "allow",

751 updatedInput: { questions: input.questions, answers }

752 };

753 }

754

755 async function main() {

756 for await (const message of query({

757 prompt: "Help me decide on the tech stack for a new mobile app",

758 options: {

759 canUseTool: async (toolName, input) => {

760 // Leiten Sie AskUserQuestion zu unserem Frage-Handler weiter

761 if (toolName === "AskUserQuestion") {

762 return handleAskUserQuestion(input);

763 }

764 // Auto-Genehmigung anderer Tools für dieses Beispiel

765 return { behavior: "allow", updatedInput: input };

766 }

767 }

768 })) {

769 if ("result" in message) console.log(message.result);

770 }

771 }

772

773 main();

774 ```

775</CodeGroup>

776

777## Einschränkungen

778

779* **Subagenten**: `AskUserQuestion` ist derzeit nicht in Subagenten verfügbar, die über das Agent-Tool erzeugt werden

780* **Fragenlimits**: Jeder `AskUserQuestion`-Aufruf unterstützt 1-4 Fragen mit jeweils 2-4 Optionen

781

782## Andere Möglichkeiten, Benutzereingaben zu erhalten

783

784Der `canUseTool`-Callback und das `AskUserQuestion`-Tool decken die meisten Genehmigungs- und Klärungsszenarien ab, aber das SDK bietet andere Möglichkeiten, Eingaben von Benutzern zu erhalten:

785

786### Streaming-Eingabe

787

788Verwenden Sie [Streaming-Eingabe](/de/agent-sdk/streaming-vs-single-mode), wenn Sie:

789

790* **Den Agent mitten in der Aufgabe unterbrechen**: Senden Sie ein Abbruchsignal oder ändern Sie die Richtung, während Claude arbeitet

791* **Zusätzlichen Kontext bereitstellen**: Fügen Sie Informationen hinzu, die Claude benötigt, ohne darauf zu warten, dass es fragt

792* **Chat-Schnittstellen erstellen**: Lassen Sie Benutzer Folgenachrichten während langwieriger Operationen senden

793

794Streaming-Eingabe ist ideal für Konversations-UIs, bei denen Benutzer während der Ausführung mit dem Agent interagieren, nicht nur bei Genehmigungsprüfpunkten.

795

796### Benutzerdefinierte Tools

797

798Verwenden Sie [benutzerdefinierte Tools](/de/agent-sdk/custom-tools), wenn Sie:

799

800* **Strukturierte Eingaben sammeln**: Erstellen Sie Formulare, Assistenten oder mehrstufige Workflows, die über das Multiple-Choice-Format von `AskUserQuestion` hinausgehen

801* **Externe Genehmigungssysteme integrieren**: Verbinden Sie sich mit bestehenden Ticketing-, Workflow- oder Genehmigungsplattformen

802* **Domänenspezifische Interaktionen implementieren**: Erstellen Sie Tools, die auf die Anforderungen Ihrer Anwendung zugeschnitten sind, wie Code-Review-Schnittstellen oder Bereitstellungs-Checklisten

803

804Benutzerdefinierte Tools geben Ihnen vollständige Kontrolle über die Interaktion, erfordern aber mehr Implementierungsarbeit als die Verwendung des integrierten `canUseTool`-Callbacks.

805

806## Verwandte Ressourcen

807

808* [Berechtigungen konfigurieren](/de/agent-sdk/permissions): Richten Sie Berechtigungsmodi und -regeln ein

809* [Ausführung mit Hooks steuern](/de/agent-sdk/hooks): Führen Sie benutzerdefinierten Code an Schlüsselpunkten im Agent-Lebenszyklus aus

810* [TypeScript SDK-Referenz](/de/agent-sdk/typescript#canusetool): Vollständige canUseTool-API-Dokumentation

auto-mode-config.md +16 −11

Details

39 39

40Der Klassifizierer liest `autoMode` nicht aus gemeinsamen Projekteinstellungen in `.claude/settings.json`, daher kann ein eingechecktes Repo seine eigenen Allow-Regeln nicht injizieren.40Der Klassifizierer liest `autoMode` nicht aus gemeinsamen Projekteinstellungen in `.claude/settings.json`, daher kann ein eingechecktes Repo seine eigenen Allow-Regeln nicht injizieren.

41 41

42Einträge aus jedem Bereich werden kombiniert. Ein Entwickler kann `environment`, `allow` und `soft_deny` mit persönlichen Einträgen erweitern, kann aber keine Einträge entfernen, die verwaltete Einstellungen bereitstellen. Da Allow-Regeln als Ausnahmen zu Block-Regeln innerhalb des Klassifizierers fungieren, kann ein von einem Entwickler hinzugefügter `allow`-Eintrag einen organisatorischen `soft_deny`-Eintrag überschreiben: Die Kombination ist additiv, keine harte Richtliniengrenze.42Einträge aus jedem Bereich werden kombiniert. Ein Entwickler kann `environment`, `allow`, `soft_deny` und `hard_deny` mit persönlichen Einträgen erweitern, kann aber keine Einträge entfernen, die verwaltete Einstellungen bereitstellen. Da Allow-Regeln als Ausnahmen zu Soft-Block-Regeln innerhalb des Klassifizierers fungieren, kann ein von einem Entwickler hinzugefügter `allow`-Eintrag einen organisatorischen `soft_deny`-Eintrag überschreiben: Die Kombination ist additiv, keine harte Richtliniengrenze.

43 43

44<Note>44<Note>

45 Der Klassifizierer ist ein zweites Gate, das nach dem [Berechtigungssystem](/de/permissions) ausgeführt wird. Für Aktionen, die niemals ausgeführt werden dürfen, unabhängig von der Benutzerabsicht oder der Klassifizierer-Konfiguration, verwenden Sie `permissions.deny` in verwalteten Einstellungen, das die Aktion blockiert, bevor der Klassifizierer konsultiert wird, und kann nicht überschrieben werden.45 Der Klassifizierer ist ein zweites Gate, das nach dem [Berechtigungssystem](/de/permissions) ausgeführt wird. Für Aktionen, die niemals ausgeführt werden dürfen, unabhängig von der Benutzerabsicht oder der Klassifizierer-Konfiguration, verwenden Sie `permissions.deny` in verwalteten Einstellungen, das die Aktion blockiert, bevor der Klassifizierer konsultiert wird, und kann nicht überschrieben werden.

99 99

100## Blockierungs- und Zulassungsregeln überschreiben100## Blockierungs- und Zulassungsregeln überschreiben

101 101

102Zwei zusätzliche Felder ermöglichen es Ihnen, die integrierten Regellisten des Klassifizierers zu ersetzen: `autoMode.soft_deny` steuert, was blockiert wird, und `autoMode.allow` steuert, welche Ausnahmen gelten. Jedes ist ein Array von Prosabeschreibungen, das als natürlichsprachige Regeln gelesen wird. Es gibt kein `autoMode.deny`-Feld; um eine Aktion unabhängig von der Absicht hart zu blockieren, verwenden Sie [`permissions.deny`](/de/permissions), das vor dem Klassifizierer ausgeführt wird.102Drei zusätzliche Felder ermöglichen es Ihnen, die integrierten Regellisten des Klassifizierers zu ersetzen: `autoMode.hard_deny` für bedingungslose Sicherheitsgrenzen, `autoMode.soft_deny` für destruktive Aktionen, die Benutzerabsicht aufheben kann, und `autoMode.allow` für Ausnahmen. Jedes ist ein Array von Prosabeschreibungen, das als natürlichsprachige Regeln gelesen wird. Für werkzeugmuster-basierte harte Blöcke, die vor dem Klassifizierer ausgeführt werden, verwenden Sie [`permissions.deny`](/de/permissions).

103 103

104Innerhalb des Klassifizierers funktioniert die Vorrangigkeit in drei Ebenen:104Innerhalb des Klassifizierers funktioniert die Vorrangigkeit in vier Ebenen:

105 105

106* `soft_deny`-Regeln blockieren zuerst106* `hard_deny`-Regeln blockieren bedingungslos. Benutzerabsicht und `allow`-Ausnahmen gelten nicht.

107* `allow`-Regeln überschreiben dann übereinstimmende Blöcke als Ausnahmen107* `soft_deny`-Regeln blockieren als nächstes. Benutzerabsicht und `allow`-Ausnahmen können diese überschreiben.

108* Explizite Benutzerabsicht überschreibt beide: Wenn die Nachricht des Benutzers direkt und spezifisch die genaue Aktion beschreibt, die Claude ausführen wird, erlaubt der Klassifizierer es, auch wenn eine `soft_deny`-Regel zutrifft108* `allow`-Regeln überschreiben dann übereinstimmende `soft_deny`-Regeln als Ausnahmen.

109* Explizite Benutzerabsicht überschreibt die verbleibenden weichen Blöcke: Wenn die Nachricht des Benutzers direkt und spezifisch die genaue Aktion beschreibt, die Claude ausführen wird, erlaubt der Klassifizierer es, auch wenn eine `soft_deny`-Regel zutrifft.

109 110

110Allgemeine Anfragen zählen nicht als explizite Absicht. Claude zu bitten, das Repo „aufzuräumen", autorisiert keinen Force-Push, aber Claude zu bitten, „diesen Branch zu force-pushen", tut es.111Allgemeine Anfragen zählen nicht als explizite Absicht. Claude zu bitten, das Repo „aufzuräumen", autorisiert keinen Force-Push, aber Claude zu bitten, „diesen Branch zu force-pushen", tut es.

111 112

112Um zu lockern, fügen Sie zu `allow` hinzu, wenn der Klassifizierer wiederholt ein routinemäßiges Muster kennzeichnet, das die Standard-Ausnahmen nicht abdecken. Um zu straffen, fügen Sie zu `soft_deny` für Risiken hinzu, die spezifisch für Ihre Umgebung sind und die Standardwerte übersehen. Um die integrierten Regeln beizubehalten und gleichzeitig Ihre eigenen hinzuzufügen, fügen Sie die Literalzeichenkette `"$defaults"` in das Array ein. Die Standardregeln werden an dieser Position eingefügt, sodass Ihre benutzerdefinierten Regeln vor oder nach ihnen stehen können, und Sie erhalten weiterhin Updates, wenn sich die integrierte Liste über Versionen hinweg ändert.113Um zu lockern, fügen Sie zu `allow` hinzu, wenn der Klassifizierer wiederholt ein routinemäßiges Muster kennzeichnet, das die Standard-Ausnahmen nicht abdecken. Um zu straffen, fügen Sie zu `soft_deny` für destruktive Risiken hinzu, die spezifisch für Ihre Umgebung sind und die Standardwerte übersehen, oder zu `hard_deny` für Sicherheitsgrenzen, die niemals überschritten werden dürfen. Um die integrierten Regeln beizubehalten und gleichzeitig Ihre eigenen hinzuzufügen, fügen Sie die Literalzeichenkette `"$defaults"` in das Array ein. Die Standardregeln werden an dieser Position eingefügt, sodass Ihre benutzerdefinierten Regeln vor oder nach ihnen stehen können, und Sie erhalten weiterhin Updates, wenn sich die integrierte Liste über Versionen hinweg ändert.

113 114

114```json theme={null}115```json theme={null}

115{116{

127 "$defaults",128 "$defaults",

128 "Never run database migrations outside the migrations CLI, even against dev databases",129 "Never run database migrations outside the migrations CLI, even against dev databases",

129 "Never modify files under infra/terraform/prod/: production infrastructure changes go through the review workflow"130 "Never modify files under infra/terraform/prod/: production infrastructure changes go through the review workflow"

131 ],

132 "hard_deny": [

133 "$defaults",

134 "Never send repository contents to third-party code-review APIs"

130 ]135 ]

131 }136 }

132}137}

133```138```

134 139

135<Danger>140<Danger>

136 Das Festlegen eines der Felder `environment`, `allow` oder `soft_deny` ohne `"$defaults"` ersetzt die gesamte Standardliste für diesen Abschnitt. Wenn Sie `soft_deny` mit einem einzelnen Eintrag festlegen und `"$defaults"` weglassen, wird jede integrierte Block-Regel verworfen: Force-Push, Datenexfiltration, `curl | bash`, Produktionsbereitstellungen und alle anderen Standard-Block-Regeln werden erlaubt. Lassen Sie `"$defaults"` nur weg, wenn Sie die vollständige Kontrolle über die Liste übernehmen möchten. Führen Sie in diesem Fall `claude auto-mode defaults` aus, um die integrierten Regeln auszudrucken, kopieren Sie sie in Ihre Einstellungsdatei, und überprüfen Sie dann jede Regel gegen Ihre eigene Pipeline und Risikotoleranz.141 Das Festlegen eines der Felder `environment`, `allow`, `soft_deny` oder `hard_deny` ohne `"$defaults"` ersetzt die gesamte Standardliste für diesen Abschnitt. Ein `soft_deny`-Array ohne `"$defaults"` verwirft jede integrierte Soft-Block-Regel, einschließlich Force-Push, `curl | bash` und Produktionsbereitstellungen. Ein `hard_deny`-Array ohne `"$defaults"` verwirft die integrierten Datenexfiltrations- und Sicherheitsprüfungs-Bypass-Regeln.

137</Danger>142</Danger>

138 143

139Jeder Abschnitt wird unabhängig ausgewertet, sodass das Festlegen von `environment` allein die Standard-`allow`- und `soft_deny`-Listen intakt lässt.144Jeder Abschnitt wird unabhängig ausgewertet, sodass das Festlegen von `environment` allein die Standard-`allow`-, `soft_deny`- und `hard_deny`-Listen intakt lässt. Lassen Sie `"$defaults"` nur weg, wenn Sie die vollständige Kontrolle über die Liste übernehmen möchten. Um dies sicher zu tun, führen Sie `claude auto-mode defaults` aus, um die integrierten Regeln auszudrucken, kopieren Sie sie in Ihre Einstellungsdatei, und überprüfen Sie dann jede Regel gegen Ihre eigene Pipeline und Risikotoleranz.

140 145

141## Überprüfen Sie die Standardwerte und Ihre effektive Konfiguration146## Überprüfen Sie die Standardwerte und Ihre effektive Konfiguration

142 147

143Drei CLI-Unterbefehle helfen Ihnen beim Überprüfen und Validieren Ihrer Konfiguration.148Drei CLI-Unterbefehle helfen Ihnen beim Überprüfen und Validieren Ihrer Konfiguration.

144 149

145Drucken Sie die integrierten `environment`-, `allow`- und `soft_deny`-Regeln als JSON:150Drucken Sie die integrierten `environment`-, `allow`-, `soft_deny`- und `hard_deny`-Regeln als JSON:

146 151

147```bash theme={null}152```bash theme={null}

148claude auto-mode defaults153claude auto-mode defaults

154claude auto-mode config159claude auto-mode config

155```160```

156 161

157Erhalten Sie KI-Feedback zu Ihren benutzerdefinierten `allow`- und `soft_deny`-Regeln:162Erhalten Sie KI-Feedback zu Ihren benutzerdefinierten `allow`-, `soft_deny`- und `hard_deny`-Regeln:

158 163

159```bash theme={null}164```bash theme={null}

160claude auto-mode critique165claude auto-mode critique

commands.md +3 −2

Details

46| `/btw <question>` | Stellen Sie eine schnelle [Nebenfrage](/de/interactive-mode#side-questions-with-%2Fbtw) ohne Hinzufügen zum Gespräch |46| `/btw <question>` | Stellen Sie eine schnelle [Nebenfrage](/de/interactive-mode#side-questions-with-%2Fbtw) ohne Hinzufügen zum Gespräch |

48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/de/skills#bundled-skills).** Laden Sie Claude API-Referenzmaterial für die Sprache Ihres Projekts (Python, TypeScript, Java, Go, Ruby, C#, PHP oder cURL) und Managed Agents-Referenz. Behandelt Tool-Nutzung, Streaming, Batches, strukturierte Ausgaben und häufige Fallstricke. Wird auch automatisch aktiviert, wenn Ihr Code `anthropic` oder `@anthropic-ai/sdk` importiert. Führen Sie `/claude-api migrate` aus, um vorhandenen Claude API-Code auf ein neueres Modell zu aktualisieren: Claude fragt, welche Dateien gescannt werden sollen und welches Modell das Ziel sein soll, dann aktualisiert Modell-IDs, Thinking-Konfiguration und andere Parameter, die sich zwischen Versionen geändert haben. Führen Sie `/claude-api managed-agents-onboard` aus, um eine interaktive Anleitung zu erhalten, die einen neuen Managed Agent von Grund auf erstellt |48| `/claude-api [migrate\|managed-agents-onboard]` | **[Skill](/de/skills#bundled-skills).** Laden Sie Claude API-Referenzmaterial für die Sprache Ihres Projekts (Python, TypeScript, Java, Go, Ruby, C#, PHP oder cURL) und Managed Agents-Referenz. Behandelt Tool-Nutzung, Streaming, Batches, strukturierte Ausgaben und häufige Fallstricke. Wird auch automatisch aktiviert, wenn Ihr Code `anthropic` oder `@anthropic-ai/sdk` importiert. Führen Sie `/claude-api migrate` aus, um vorhandenen Claude API-Code auf ein neueres Modell zu aktualisieren: Claude fragt, welche Dateien gescannt werden sollen und welches Modell das Ziel sein soll, dann aktualisiert Modell-IDs, Thinking-Konfiguration und andere Parameter, die sich zwischen Versionen geändert haben. Führen Sie `/claude-api managed-agents-onboard` aus, um eine interaktive Anleitung zu erhalten, die einen neuen Managed Agent von Grund auf erstellt |

49| `/clear` | Starten Sie ein neues Gespräch mit leerem Kontext. Das vorherige Gespräch bleibt in `/resume` verfügbar. Um Kontext freizugeben und gleichzeitig das gleiche Gespräch fortzusetzen, verwenden Sie stattdessen `/compact`. Aliase: `/reset`, `/new` |49| `/clear [name]` | Starten Sie ein neues Gespräch mit leerem Kontext. Das vorherige Gespräch bleibt in `/resume` verfügbar. Übergeben Sie einen Namen, um das vorherige Gespräch in der `/resume`-Auswahl zu kennzeichnen. Um Kontext freizugeben und gleichzeitig das gleiche Gespräch fortzusetzen, verwenden Sie stattdessen `/compact`. Aliase: `/reset`, `/new` |

50| `/color [color\|default]` | Legen Sie die Farbe der Eingabeaufforderungsleiste für die aktuelle Sitzung fest. Verfügbare Farben: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Verwenden Sie `default`, um zurückzusetzen, oder führen Sie ohne Argument aus, um eine zufällige Farbe auszuwählen. Wenn [Remote Control](/de/remote-control) verbunden ist, wird die Farbe mit claude.ai/code synchronisiert |50| `/color [color\|default]` | Legen Sie die Farbe der Eingabeaufforderungsleiste für die aktuelle Sitzung fest. Verfügbare Farben: `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan`. Verwenden Sie `default`, um zurückzusetzen, oder führen Sie ohne Argument aus, um eine zufällige Farbe auszuwählen. Wenn [Remote Control](/de/remote-control) verbunden ist, wird die Farbe mit claude.ai/code synchronisiert |

51| `/compact [instructions]` | Geben Sie Kontext frei, indem Sie das bisherige Gespräch zusammenfassen. Übergeben Sie optional Fokusanweisungen für die Zusammenfassung. Siehe [wie Komprimierung Regeln, Skills und Speicherdateien handhabt](/de/context-window#what-survives-compaction) |51| `/compact [instructions]` | Geben Sie Kontext frei, indem Sie das bisherige Gespräch zusammenfassen. Übergeben Sie optional Fokusanweisungen für die Zusammenfassung. Siehe [wie Komprimierung Regeln, Skills und Speicherdateien handhabt](/de/context-window#what-survives-compaction) |

52| `/config` | Öffnen Sie die [Einstellungen](/de/settings)-Schnittstelle, um Design, Modell, [Ausgabestil](/de/output-styles) und andere Einstellungen anzupassen. Alias: `/settings` |52| `/config` | Öffnen Sie die [Einstellungen](/de/settings)-Schnittstelle, um Design, Modell, [Ausgabestil](/de/output-styles) und andere Einstellungen anzupassen. Alias: `/settings` |

53| `/context` | Visualisieren Sie die aktuelle Kontextnutzung als farbiges Gitter. Zeigt Optimierungsvorschläge für kontextintensive Tools, Speicherverschwendung und Kapazitätswarnungen |53| `/context [all]` | Visualisieren Sie die aktuelle Kontextnutzung als farbiges Gitter. Zeigt Optimierungsvorschläge für kontextintensive Tools, Speicherverschwendung und Kapazitätswarnungen. Im [Vollbildmodus](/de/fullscreen) wird die Pro-Element-Aufschlüsselung zusammengeklappt, um das Gitter sichtbar zu halten. Übergeben Sie `all`, um es zu erweitern |

54| `/copy [N]` | Kopieren Sie die letzte Antwort des Assistenten in die Zwischenablage. Übergeben Sie eine Zahl `N`, um die N-te letzte Antwort zu kopieren: `/copy 2` kopiert die vorletzte. Wenn Codeblöcke vorhanden sind, wird eine interaktive Auswahl angezeigt, um einzelne Blöcke oder die vollständige Antwort auszuwählen. Drücken Sie `w` in der Auswahl, um die Auswahl stattdessen in eine Datei zu schreiben, anstatt sie in die Zwischenablage zu kopieren, was über SSH nützlich ist |54| `/copy [N]` | Kopieren Sie die letzte Antwort des Assistenten in die Zwischenablage. Übergeben Sie eine Zahl `N`, um die N-te letzte Antwort zu kopieren: `/copy 2` kopiert die vorletzte. Wenn Codeblöcke vorhanden sind, wird eine interaktive Auswahl angezeigt, um einzelne Blöcke oder die vollständige Antwort auszuwählen. Drücken Sie `w` in der Auswahl, um die Auswahl stattdessen in eine Datei zu schreiben, anstatt sie in die Zwischenablage zu kopieren, was über SSH nützlich ist |

56| `/debug [description]` | **[Skill](/de/skills#bundled-skills).** Aktivieren Sie Debug-Protokollierung für die aktuelle Sitzung und beheben Sie Probleme durch Lesen des Sitzungs-Debug-Protokolls. Debug-Protokollierung ist standardmäßig deaktiviert, es sei denn, Sie haben mit `claude --debug` gestartet, daher startet die Ausführung von `/debug` während der Sitzung die Erfassung von Protokollen ab diesem Punkt. Beschreiben Sie optional das Problem, um die Analyse zu fokussieren |56| `/debug [description]` | **[Skill](/de/skills#bundled-skills).** Aktivieren Sie Debug-Protokollierung für die aktuelle Sitzung und beheben Sie Probleme durch Lesen des Sitzungs-Debug-Protokolls. Debug-Protokollierung ist standardmäßig deaktiviert, es sei denn, Sie haben mit `claude --debug` gestartet, daher startet die Ausführung von `/debug` während der Sitzung die Erfassung von Protokollen ab diesem Punkt. Beschreiben Sie optional das Problem, um die Analyse zu fokussieren |

89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Entfernt in v2.1.91. Fragen Sie Claude direkt, um Pull Request-Kommentare anzuzeigen. In früheren Versionen werden Kommentare aus einem GitHub Pull Request abgerufen und angezeigt; erkennt automatisch den PR für den aktuellen Branch, oder übergeben Sie eine PR-URL oder -Nummer. Erfordert die `gh` CLI |89| `/pr-comments [PR]` | {/* max-version: 2.1.90 */}Entfernt in v2.1.91. Fragen Sie Claude direkt, um Pull Request-Kommentare anzuzeigen. In früheren Versionen werden Kommentare aus einem GitHub Pull Request abgerufen und angezeigt; erkennt automatisch den PR für den aktuellen Branch, oder übergeben Sie eine PR-URL oder -Nummer. Erfordert die `gh` CLI |

90| `/privacy-settings` | Zeigen Sie Ihre Datenschutzeinstellungen an und aktualisieren Sie sie. Nur für Pro- und Max-Plan-Abonnenten verfügbar |90| `/privacy-settings` | Zeigen Sie Ihre Datenschutzeinstellungen an und aktualisieren Sie sie. Nur für Pro- und Max-Plan-Abonnenten verfügbar |

91| `/radio` | Öffnen Sie Claude FM Lo-Fi-Radio in Ihrem Browser. Druckt die Stream-URL, wenn kein Browser verfügbar ist. Nicht verfügbar auf Bedrock, Vertex oder Foundry |

91| `/recap` | Generieren Sie eine einzeilige Zusammenfassung der aktuellen Sitzung auf Anfrage. Siehe [Sitzungs-Recap](/de/interactive-mode#session-recap) für das automatische Recap, das angezeigt wird, nachdem Sie weg waren |92| `/recap` | Generieren Sie eine einzeilige Zusammenfassung der aktuellen Sitzung auf Anfrage. Siehe [Sitzungs-Recap](/de/interactive-mode#session-recap) für das automatische Recap, das angezeigt wird, nachdem Sie weg waren |

92| `/release-notes` | Zeigen Sie das Änderungsprotokoll in einer interaktiven Versionswahl an. Wählen Sie eine bestimmte Version, um ihre Versionshinweise anzuzeigen, oder wählen Sie, um alle Versionen anzuzeigen |93| `/release-notes` | Zeigen Sie das Änderungsprotokoll in einer interaktiven Versionswahl an. Wählen Sie eine bestimmte Version, um ihre Versionshinweise anzuzeigen, oder wählen Sie, um alle Versionen anzuzeigen |

93| `/reload-plugins` | Laden Sie alle aktiven [Plugins](/de/plugins) neu, um ausstehende Änderungen anzuwenden, ohne neu zu starten. Meldet Zählungen für jede neu geladene Komponente und kennzeichnet alle Ladefehler |94| `/reload-plugins` | Laden Sie alle aktiven [Plugins](/de/plugins) neu, um ausstehende Änderungen anzuwenden, ohne neu zu starten. Meldet Zählungen für jede neu geladene Komponente und kennzeichnet alle Ladefehler |

env-vars.md +3 −1

Details

92| `CLAUDE_CODE_EFFORT_LEVEL` | Legen Sie die Anstrengungsstufe für unterstützte Modelle fest. Werte: `low`, `medium`, `high`, `xhigh`, `max` oder `auto` für den Modellstandard. Verfügbare Stufen hängen vom Modell ab. Hat Vorrang vor `/effort` und der `effortLevel`-Einstellung. Siehe [Anstrengungsstufe anpassen](/de/model-config#adjust-effort-level) |92| `CLAUDE_CODE_EFFORT_LEVEL` | Legen Sie die Anstrengungsstufe für unterstützte Modelle fest. Werte: `low`, `medium`, `high`, `xhigh`, `max` oder `auto` für den Modellstandard. Verfügbare Stufen hängen vom Modell ab. Hat Vorrang vor `/effort` und der `effortLevel`-Einstellung. Siehe [Anstrengungsstufe anpassen](/de/model-config#adjust-effort-level) |

93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Überschreiben Sie die Verfügbarkeit von [Sitzungs-Zusammenfassung](/de/interactive-mode#session-recap). Setzen Sie auf `0`, um Zusammenfassungen unabhängig vom `/config`-Umschalter auszuschalten. Setzen Sie auf `1`, um Zusammenfassungen zu erzwingen, wenn [`awaySummaryEnabled`](/de/settings#available-settings) `false` ist. Hat Vorrang vor der Einstellung und dem `/config`-Umschalter |93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Überschreiben Sie die Verfügbarkeit von [Sitzungs-Zusammenfassung](/de/interactive-mode#session-recap). Setzen Sie auf `0`, um Zusammenfassungen unabhängig vom `/config`-Umschalter auszuschalten. Setzen Sie auf `1`, um Zusammenfassungen zu erzwingen, wenn [`awaySummaryEnabled`](/de/settings#available-settings) `false` ist. Hat Vorrang vor der Einstellung und dem `/config`-Umschalter |

94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Setzen Sie auf `1`, um den Plugin-Status an Turn-Grenzen im [nicht-interaktiven Modus](/de/headless) zu aktualisieren, nachdem eine Hintergrund-Installation abgeschlossen ist. Standardmäßig aus, da die Aktualisierung den System-Prompt mitten in der Sitzung ändert, was [Prompt-Caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) für diesen Turn ungültig macht |94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Setzen Sie auf `1`, um den Plugin-Status an Turn-Grenzen im [nicht-interaktiven Modus](/de/headless) zu aktualisieren, nachdem eine Hintergrund-Installation abgeschlossen ist. Standardmäßig aus, da die Aktualisierung den System-Prompt mitten in der Sitzung ändert, was [Prompt-Caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) für diesen Turn ungültig macht |

95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Steuert, ob Tool-Call-Eingaben von der API streamen, während Claude sie generiert. Wenn dies aus ist, kommt eine große Tool-Eingabe wie ein langer Datei-Schreibvorgang erst an, nachdem Claude die Generierung abgeschlossen hat, was aussehen kann, als würde es hängen. Standardmäßig für direkte Anthropic API-Verbindungen aktiviert. Setzen Sie auf `0`, um sich abzumelden. Setzen Sie auf `1`, um zu erzwingen, auch wenn der serverseitige Standard aus ist. Hat keine Auswirkung auf Bedrock, Vertex, Foundry oder [Gateway](/de/llm-gateway)-Verbindungen |95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Steuert, ob Tool-Call-Eingaben von der API streamen, während Claude sie generiert. Wenn dies aus ist, kommt eine große Tool-Eingabe wie ein langer Datei-Schreibvorgang erst an, nachdem Claude die Generierung abgeschlossen hat, was aussehen kann, als würde es hängen. Standardmäßig für direkte Anthropic API-Verbindungen aktiviert. Auf Bedrock und Vertex, aktiviert pro Modell, wo der bereitgestellte Container es unterstützt. Setzen Sie auf `0`, um sich abzumelden. Setzen Sie auf `1`, um zu erzwingen, wenn Sie durch einen Proxy über `ANTHROPIC_BASE_URL`, `ANTHROPIC_VERTEX_BASE_URL` oder `ANTHROPIC_BEDROCK_BASE_URL` routen. Standardmäßig aus auf Foundry und [Gateway](/de/llm-gateway)-Verbindungen |

96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Setzen Sie auf `1`, um die `/model`-Auswahl aus dem `/v1/models`-Endpunkt Ihres Gateways zu füllen, wenn `ANTHROPIC_BASE_URL` auf ein Anthropic-kompatibles Gateway wie LiteLLM, Kong oder einen internen Proxy verweist. Standardmäßig aus, da Gateways, die von einem gemeinsamen API-Schlüssel unterstützt werden, ansonsten jedem Benutzer jedes Modell anzeigen würden, auf das der Schlüssel zugreifen kann. Erkannte Modelle werden weiterhin durch die [`availableModels`](/de/settings#available-settings)-Zulassungsliste gefiltert |96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Setzen Sie auf `1`, um die `/model`-Auswahl aus dem `/v1/models`-Endpunkt Ihres Gateways zu füllen, wenn `ANTHROPIC_BASE_URL` auf ein Anthropic-kompatibles Gateway wie LiteLLM, Kong oder einen internen Proxy verweist. Standardmäßig aus, da Gateways, die von einem gemeinsamen API-Schlüssel unterstützt werden, ansonsten jedem Benutzer jedes Modell anzeigen würden, auf das der Schlüssel zugreifen kann. Erkannte Modelle werden weiterhin durch die [`availableModels`](/de/settings#available-settings)-Zulassungsliste gefiltert |

97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Setzen Sie auf `false`, um Prompt-Vorschläge zu deaktivieren (der Umschalter „Prompt-Vorschläge" in `/config`). Dies sind die ausgegraut angezeigten Vorhersagen, die in Ihrer Prompt-Eingabe nach Claudes Antwort erscheinen. Siehe [Prompt-Vorschläge](/de/interactive-mode#prompt-suggestions) |97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Setzen Sie auf `false`, um Prompt-Vorschläge zu deaktivieren (der Umschalter „Prompt-Vorschläge" in `/config`). Dies sind die ausgegraut angezeigten Vorhersagen, die in Ihrer Prompt-Eingabe nach Claudes Antwort erscheinen. Siehe [Prompt-Vorschläge](/de/interactive-mode#prompt-suggestions) |

98| `CLAUDE_CODE_ENABLE_TASKS` | Setzen Sie auf `1`, um das Task-Tracking-System im nicht-interaktiven Modus (das Flag `-p`) zu aktivieren. Tasks sind standardmäßig im interaktiven Modus aktiviert. Siehe [Aufgabenliste](/de/interactive-mode#task-list) |98| `CLAUDE_CODE_ENABLE_TASKS` | Setzen Sie auf `1`, um das Task-Tracking-System im nicht-interaktiven Modus (das Flag `-p`) zu aktivieren. Tasks sind standardmäßig im interaktiven Modus aktiviert. Siehe [Aufgabenliste](/de/interactive-mode#task-list) |

116| `CLAUDE_CODE_MAX_RETRIES` | Überschreiben Sie die Anzahl der Wiederholungen fehlgeschlagener API-Anfragen (Standard: 10) |116| `CLAUDE_CODE_MAX_RETRIES` | Überschreiben Sie die Anzahl der Wiederholungen fehlgeschlagener API-Anfragen (Standard: 10) |

117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Maximale Anzahl von schreibgeschützten Tools und Subagenten, die parallel ausgeführt werden können (Standard: 10). Höhere Werte erhöhen die Parallelität, verbrauchen aber mehr Ressourcen |117| `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` | Maximale Anzahl von schreibgeschützten Tools und Subagenten, die parallel ausgeführt werden können (Standard: 10). Höhere Werte erhöhen die Parallelität, verbrauchen aber mehr Ressourcen |

118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Setzen Sie auf `1`, um stdio MCP-Server nur mit einer sicheren Baseline-Umgebung plus der konfigurierten `env` des Servers zu spawnen, anstatt Ihre Shell-Umgebung zu erben |118| `CLAUDE_CODE_MCP_ALLOWLIST_ENV` | Setzen Sie auf `1`, um stdio MCP-Server nur mit einer sicheren Baseline-Umgebung plus der konfigurierten `env` des Servers zu spawnen, anstatt Ihre Shell-Umgebung zu erben |

119| `CLAUDE_CODE_NATIVE_CURSOR` | Setzen Sie auf `1`, um den eigenen Cursor des Terminals an der Eingabeeinfügemarke anzuzeigen, anstatt eines gezeichneten Blocks. Der Cursor respektiert die Blink-, Form- und Fokuseinstellungen des Terminals |

119| `CLAUDE_CODE_NEW_INIT` | Setzen Sie auf `1`, um `/init` einen interaktiven Setup-Flow ausführen zu lassen. Der Flow fragt, welche Dateien generiert werden sollen, einschließlich CLAUDE.md, Skills und Hooks, bevor die Codebasis erkundet und geschrieben wird. Ohne diese Variable generiert `/init` automatisch eine CLAUDE.md ohne Aufforderung. |120| `CLAUDE_CODE_NEW_INIT` | Setzen Sie auf `1`, um `/init` einen interaktiven Setup-Flow ausführen zu lassen. Der Flow fragt, welche Dateien generiert werden sollen, einschließlich CLAUDE.md, Skills und Hooks, bevor die Codebasis erkundet und geschrieben wird. Ohne diese Variable generiert `/init` automatisch eine CLAUDE.md ohne Aufforderung. |

120| `CLAUDE_CODE_NO_FLICKER` | Setzen Sie auf `1`, um die [Vollbilddarstellung](/de/fullscreen) zu aktivieren, eine Forschungsvorschau, die Flimmern reduziert und den Speicher in langen Konversationen flach hält. Äquivalent zur [`tui`](/de/settings#available-settings)-Einstellung; Sie können auch mit `/tui fullscreen` wechseln |121| `CLAUDE_CODE_NO_FLICKER` | Setzen Sie auf `1`, um die [Vollbilddarstellung](/de/fullscreen) zu aktivieren, eine Forschungsvorschau, die Flimmern reduziert und den Speicher in langen Konversationen flach hält. Äquivalent zur [`tui`](/de/settings#available-settings)-Einstellung; Sie können auch mit `/tui fullscreen` wechseln |

121| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | OAuth-Aktualisierungstoken für Claude.ai-Authentifizierung. Wenn gesetzt, tauscht `claude auth login` dieses Token direkt aus, anstatt einen Browser zu öffnen. Erfordert `CLAUDE_CODE_OAUTH_SCOPES`. Nützlich für die Bereitstellung von Authentifizierung in automatisierten Umgebungen |122| `CLAUDE_CODE_OAUTH_REFRESH_TOKEN` | OAuth-Aktualisierungstoken für Claude.ai-Authentifizierung. Wenn gesetzt, tauscht `claude auth login` dieses Token direkt aus, anstatt einen Browser zu öffnen. Erfordert `CLAUDE_CODE_OAUTH_SCOPES`. Nützlich für die Bereitstellung von Authentifizierung in automatisierten Umgebungen |

191| `DISABLE_TELEMETRY` | Setzen Sie auf `1`, um sich von Telemetrie abzumelden. Telemetrie-Ereignisse enthalten keine Benutzerdaten wie Code, Dateipfade oder Bash-Befehle |192| `DISABLE_TELEMETRY` | Setzen Sie auf `1`, um sich von Telemetrie abzumelden. Telemetrie-Ereignisse enthalten keine Benutzerdaten wie Code, Dateipfade oder Bash-Befehle |

192| `DISABLE_UPDATES` | Setzen Sie auf `1`, um alle Updates zu blockieren, einschließlich manuelles `claude update` und `claude install`. Strenger als `DISABLE_AUTOUPDATER`. Verwenden Sie, wenn Sie Claude Code über Ihre eigenen Kanäle verteilen und Benutzer sich nicht selbst aktualisieren sollten |193| `DISABLE_UPDATES` | Setzen Sie auf `1`, um alle Updates zu blockieren, einschließlich manuelles `claude update` und `claude install`. Strenger als `DISABLE_AUTOUPDATER`. Verwenden Sie, wenn Sie Claude Code über Ihre eigenen Kanäle verteilen und Benutzer sich nicht selbst aktualisieren sollten |

195| `DO_NOT_TRACK` | Setzen Sie auf `1`, um sich von Telemetrie abzumelden. Äquivalent zum Setzen von `DISABLE_TELEMETRY`. Wird als [Standard-Cross-Tool-Konvention](https://consoledonottrack.com/) anerkannt |

194| `ENABLE_CLAUDEAI_MCP_SERVERS` | Setzen Sie auf `false`, um [claude.ai MCP-Server](/de/mcp#use-mcp-servers-from-claude-ai) in Claude Code zu deaktivieren. Standardmäßig für angemeldete Benutzer aktiviert |196| `ENABLE_CLAUDEAI_MCP_SERVERS` | Setzen Sie auf `false`, um [claude.ai MCP-Server](/de/mcp#use-mcp-servers-from-claude-ai) in Claude Code zu deaktivieren. Standardmäßig für angemeldete Benutzer aktiviert |

195| `ENABLE_PROMPT_CACHING_1H` | Setzen Sie auf `1`, um eine 1-Stunden-Prompt-Cache-TTL anstelle der Standard-5-Minuten anzufordern. Vorgesehen für API-Schlüssel-, [Bedrock](/de/amazon-bedrock)-, [Vertex](/de/google-vertex-ai)- und [Foundry](/de/microsoft-foundry)-Benutzer. Abonnement-Benutzer erhalten automatisch 1-Stunden-TTL. 1-Stunden-Cache-Schreibvorgänge werden mit einer höheren Rate abgerechnet |197| `ENABLE_PROMPT_CACHING_1H` | Setzen Sie auf `1`, um eine 1-Stunden-Prompt-Cache-TTL anstelle der Standard-5-Minuten anzufordern. Vorgesehen für API-Schlüssel-, [Bedrock](/de/amazon-bedrock)-, [Vertex](/de/google-vertex-ai)- und [Foundry](/de/microsoft-foundry)-Benutzer. Abonnement-Benutzer erhalten automatisch 1-Stunden-TTL. 1-Stunden-Cache-Schreibvorgänge werden mit einer höheren Rate abgerechnet |

errors.md +16 −0

Details

34| `Routines are disabled by your organization's policy` | [Authentifizierung](#routines-are-disabled-by-your-organizations-policy) |

252* Führen Sie danach `/status` aus, um zu bestätigen, dass die aktive Anmeldeinformation Ihr Abonnement ist253* Führen Sie danach `/status` aus, um zu bestätigen, dass die aktive Anmeldeinformation Ihr Abonnement ist

253* Wenn keine Umgebungsvariable gesetzt ist und der Fehler weiterhin auftritt, ist die deaktivierte Organisation die, die an Ihrem `/login` gebunden ist. Kontaktieren Sie den Support oder melden Sie sich mit einem anderen Konto an.254* Wenn keine Umgebungsvariable gesetzt ist und der Fehler weiterhin auftritt, ist die deaktivierte Organisation die, die an Ihrem `/login` gebunden ist. Kontaktieren Sie den Support oder melden Sie sich mit einem anderen Konto an.

254 255

256### Routines are disabled by your organization's policy

257

258Ihr Team- oder Enterprise-Administrator hat Routinen auf Organisationsebene deaktiviert. Der Fehler wird angezeigt, wenn Sie versuchen, eine Routine zu erstellen oder auszuführen, einschließlich von `/schedule` und der [Routines](/de/routines)-Benutzeroberfläche auf claude.ai/code.

259

260```text theme={null}

261Routines are disabled by your organization's policy.

262```

263

264Dies ist eine serverseitige Einstellung, daher kann sie nicht durch lokale Einstellungen, Umgebungsvariablen oder CLI-Flags überschrieben werden.

265

266**Was zu tun ist:**

267

268* Bitten Sie Ihren Administrator, den **Routines**-Schalter unter [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code) zu aktivieren

269* Für einmalige geplante Arbeiten, die keine Routinen auf Organisationsebene erfordern, siehe [geplante Aufgaben](/de/scheduled-tasks)

270

255### OAuth token revoked or expired271### OAuth token revoked or expired

256 272

257Ihre gespeicherte Anmeldung ist nicht mehr gültig. Ein widerrufener Token bedeutet, dass Sie sich überall abgemeldet haben oder ein Administrator den Zugriff entfernt hat; ein abgelaufener Token bedeutet, dass die automatische Aktualisierung mitten in der Sitzung fehlgeschlagen ist.273Ihre gespeicherte Anmeldung ist nicht mehr gültig. Ein widerrufener Token bedeutet, dass Sie sich überall abgemeldet haben oder ein Administrator den Zugriff entfernt hat; ein abgelaufener Token bedeutet, dass die automatische Aktualisierung mitten in der Sitzung fehlgeschlagen ist.

interactive-mode.md +1 −1

Details

289 289

290Nachdem Claude antwortet, werden weiterhin Vorschläge basierend auf Ihrem Gesprächsverlauf angezeigt, z. B. ein Folgenschritt aus einer mehrteiligen Anfrage oder eine natürliche Fortsetzung Ihres Workflows.290Nachdem Claude antwortet, werden weiterhin Vorschläge basierend auf Ihrem Gesprächsverlauf angezeigt, z. B. ein Folgenschritt aus einer mehrteiligen Anfrage oder eine natürliche Fortsetzung Ihres Workflows.

291 291

292* Drücken Sie **Tab** oder **Rechts-Pfeil**, um den Vorschlag zu akzeptieren, oder drücken Sie **Enter**, um zu akzeptieren und einzureichen292* Drücken Sie **Tab** oder **Rechts-Pfeil**, um den Vorschlag in die Eingabeaufforderung zu platzieren, und dann **Enter**, um einzureichen

293* Beginnen Sie zu tippen, um ihn zu verwerfen293* Beginnen Sie zu tippen, um ihn zu verwerfen

294 294

295Der Vorschlag wird als Hintergrund-Anfrage ausgeführt, die den Prompt-Cache des übergeordneten Gesprächs wiederverwenden, sodass die zusätzlichen Kosten minimal sind. Claude Code überspringt die Vorschlagsgenerierung, wenn der Cache kalt ist, um unnötige Kosten zu vermeiden.295Der Vorschlag wird als Hintergrund-Anfrage ausgeführt, die den Prompt-Cache des übergeordneten Gesprächs wiederverwenden, sodass die zusätzlichen Kosten minimal sind. Claude Code überspringt die Vorschlagsgenerierung, wenn der Cache kalt ist, um unnötige Kosten zu vermeiden.

mcp.md +2 −0

Details

265 --header "Authorization: Bearer your-token"265 --header "Authorization: Bearer your-token"

266```266```

267 267

268Bei der Konfiguration von MCP-Servern über JSON in `.mcp.json`, `~/.claude.json` oder `claude mcp add-json` akzeptiert das Feld `type` `streamable-http` als Alias für `http`. Die MCP-Spezifikation verwendet den Namen `streamable-http` für dieses Transportprotokoll, sodass Konfigurationen, die aus der Server-Dokumentation kopiert werden, ohne Änderungen funktionieren.

269

268### Option 2: Einen Remote-SSE-Server hinzufügen270### Option 2: Einen Remote-SSE-Server hinzufügen

269 271

270<Warning>272<Warning>

permissions.md +7 −0

Details

210* `Edit(//tmp/scratch.txt)`: bearbeitet den absoluten Pfad `/tmp/scratch.txt`210* `Edit(//tmp/scratch.txt)`: bearbeitet den absoluten Pfad `/tmp/scratch.txt`

211* `Read(src/**)`: liest aus `<current-directory>/src/`211* `Read(src/**)`: liest aus `<current-directory>/src/`

212 212

213Eine Regel gleicht nur Dateien unter ihrem Anker ab, daher bestimmt der Anker, wie weit eine Deny-Regel reicht. Bare Dateinamen folgen gitignore-Semantik und gleichen in jeder Tiefe ab, daher sind `Read(.env)` und `Read(**/.env)` gleichwertig:

214

215| Deny-Regel | Blockiert | Blockiert nicht |

216| --------------------------------- | --------------------------------------------------- | --------------------------------------------------------------------- |

217| `Read(.env)` oder `Read(**/.env)` | jede `.env` im oder unter dem aktuellen Verzeichnis | `.env` in einem übergeordneten Verzeichnis oder einem anderen Projekt |

218| `Read(//**/.env)` | jede `.env` überall im Dateisystem | nichts; die Regel ist am Dateisystem-Root verankert |

219

213<Note>220<Note>

214 In gitignore-Mustern gleicht `*` Dateien in einem einzelnen Verzeichnis ab, während `**` rekursiv über Verzeichnisse hinweg abgleicht. Um allen Dateizugriff zu ermöglichen, verwenden Sie einfach den Werkzeugnamen ohne Klammern: `Read`, `Edit` oder `Write`.221 In gitignore-Mustern gleicht `*` Dateien in einem einzelnen Verzeichnis ab, während `**` rekursiv über Verzeichnisse hinweg abgleicht. Um allen Dateizugriff zu ermöglichen, verwenden Sie einfach den Werkzeugnamen ohne Klammern: `Read`, `Edit` oder `Write`.

215</Note>222</Note>

plugins-reference.md +8 −3

Details

423 423

424| Feld | Typ | Beschreibung | Beispiel |424| Feld | Typ | Beschreibung | Beispiel |

425| :---------------------- | :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------- |425| :---------------------- | :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------- |

510 510

511### Pfad-Verhaltensregeln511### Pfad-Verhaltensregeln

512 512

513Für `skills`, `commands`, `agents`, `outputStyles`, `experimental.themes` und `experimental.monitors` ersetzt ein benutzerdefinierter Pfad den Standard. Wenn das Manifest `skills` angibt, wird das Standard-Verzeichnis `skills/` nicht gescannt; wenn es `experimental.monitors` angibt, wird die Standard-Datei `monitors/monitors.json` nicht geladen. [Hooks](#hooks), [MCP-Server](#mcp-servers) und [LSP-Server](#lsp-servers) haben unterschiedliche Semantiken für die Behandlung mehrerer Quellen.513Ob ein benutzerdefinierter Pfad das Standard-Verzeichnis des Plugins ersetzt oder erweitert, hängt vom Feld ab:

514

515* **Ersetzt den Standard**: `commands`, `agents`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Beispielsweise wird das Standard-Verzeichnis `commands/` nicht gescannt, wenn das Manifest `commands` angibt. Um den Standard zu behalten und mehr hinzuzufügen, listen Sie ihn explizit auf: `"commands": ["./commands/", "./extras/"]`

516* **Fügt zum Standard hinzu**: `skills`. Das Standard-Verzeichnis `skills/` wird immer gescannt, und Verzeichnisse, die in `skills` aufgelistet sind, werden zusammen mit ihm geladen

517* **Eigene Merge-Regeln**: [hooks](#hooks), [MCP-Server](#mcp-servers) und [LSP-Server](#lsp-servers). Siehe jeden Abschnitt für die Kombinationsweise mehrerer Quellen

518

519Für alle Pfadfelder:

514 520

515* Alle Pfade müssen relativ zum Plugin-Root sein und mit `./` beginnen521* Alle Pfade müssen relativ zum Plugin-Root sein und mit `./` beginnen

516* Komponenten aus benutzerdefinierten Pfaden verwenden die gleichen Benennungs- und Namensgebungsregeln522* Komponenten aus benutzerdefinierten Pfaden verwenden die gleichen Benennungs- und Namensgebungsregeln

517* Mehrere Pfade können als Arrays angegeben werden523* Mehrere Pfade können als Arrays angegeben werden

518* Um das Standard-Verzeichnis zu behalten und mehr Pfade für Skills, Befehle, Agents oder Output-Styles hinzuzufügen, schließen Sie den Standard in Ihr Array ein: `"skills": ["./skills/", "./extras/"]`

519* Wenn ein Skill-Pfad auf ein Verzeichnis verweist, das direkt ein `SKILL.md` enthält, beispielsweise `"skills": ["./"]` verweist auf den Plugin-Root, bestimmt das Frontmatter-Feld `name` in `SKILL.md` den Aufrufen-Namen des Skills. Dies gibt einen stabilen Namen unabhängig vom Installationsverzeichnis. Wenn `name` nicht im Frontmatter gesetzt ist, wird der Verzeichnis-Basename als Fallback verwendet.524* Wenn ein Skill-Pfad auf ein Verzeichnis verweist, das direkt ein `SKILL.md` enthält, beispielsweise `"skills": ["./"]` verweist auf den Plugin-Root, bestimmt das Frontmatter-Feld `name` in `SKILL.md` den Aufrufen-Namen des Skills. Dies gibt einen stabilen Namen unabhängig vom Installationsverzeichnis. Wenn `name` nicht im Frontmatter gesetzt ist, wird der Verzeichnis-Basename als Fallback verwendet.

520 525

521**Pfad-Beispiele**:526**Pfad-Beispiele**:

routines.md +8 −0

Details

22 22

23Routinen sind auf Pro-, Max-, Team- und Enterprise-Plänen mit aktiviertem [Claude Code im Web](/de/claude-code-on-the-web) verfügbar. Erstellen und verwalten Sie sie unter [claude.ai/code/routines](https://claude.ai/code/routines) oder über die CLI mit `/schedule`.23Routinen sind auf Pro-, Max-, Team- und Enterprise-Plänen mit aktiviertem [Claude Code im Web](/de/claude-code-on-the-web) verfügbar. Erstellen und verwalten Sie sie unter [claude.ai/code/routines](https://claude.ai/code/routines) oder über die CLI mit `/schedule`.

24 24

25Team- und Enterprise-Administratoren können Routinen für alle Mitglieder mit dem Routinen-Toggle unter [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code) deaktivieren. Wenn deaktiviert, werden vorhandene Routinen nicht mehr ausgeführt und Mitglieder können keine neuen erstellen.

25Diese Seite behandelt das Erstellen einer Routine, das Konfigurieren jedes Trigger-Typs, das Verwalten von Ausführungen und wie Nutzungslimits angewendet werden.27Diese Seite behandelt das Erstellen einer Routine, das Konfigurieren jedes Trigger-Typs, das Verwalten von Ausführungen und wie Nutzungslimits angewendet werden.

26 28

27## Beispiel-Anwendungsfälle29## Beispiel-Anwendungsfälle

360 362

361Einmalige Ausführungen werden nicht auf das tägliche Routine-Ausführungslimit angerechnet. Sie verbrauchen Ihre reguläre Abonnement-Nutzung wie jede andere Sitzung, sind aber von der täglichen Routine-Ausführungszulage pro Konto ausgenommen.363Einmalige Ausführungen werden nicht auf das tägliche Routine-Ausführungslimit angerechnet. Sie verbrauchen Ihre reguläre Abonnement-Nutzung wie jede andere Sitzung, sind aber von der täglichen Routine-Ausführungszulage pro Konto ausgenommen.

362 364

365## Fehlerbehebung

366

367### 'Routinen sind durch die Richtlinie Ihrer Organisation deaktiviert"

368

369Ihr Team- oder Enterprise-Administrator hat wahrscheinlich den **Routinen**-Toggle unter [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code) ausgeschaltet. Dies ist eine serverseitige Organisationseinstellung, daher kann sie nicht aus Ihrer lokalen Konfiguration überschrieben werden. Kontaktieren Sie Ihren Administrator, um anzufordern, dass Routinen für Ihre Organisation aktiviert werden.

370

363## Verwandte Ressourcen371## Verwandte Ressourcen

364 372

365* [`/loop` und In-Session-Planung](/de/scheduled-tasks): Planen Sie lokale Aufgaben innerhalb einer offenen CLI-Sitzung373* [`/loop` und In-Session-Planung](/de/scheduled-tasks): Planen Sie lokale Aufgaben innerhalb einer offenen CLI-Sitzung

security.md +1 −1

Details

59* **Genehmigung von Netzwerkanfragen**: Tools, die Netzwerkanfragen stellen, erfordern standardmäßig Benutzergenehmigung59* **Genehmigung von Netzwerkanfragen**: Tools, die Netzwerkanfragen stellen, erfordern standardmäßig Benutzergenehmigung

60* **Isolierte Kontextfenster**: Web Fetch verwendet ein separates Kontextfenster, um die Injection potenziell bösartiger Prompts zu vermeiden60* **Isolierte Kontextfenster**: Web Fetch verwendet ein separates Kontextfenster, um die Injection potenziell bösartiger Prompts zu vermeiden

61* **Vertrauensüberprüfung**: Erste Codebasis-Ausführungen und neue MCP-Server erfordern Vertrauensüberprüfung61* **Vertrauensüberprüfung**: Erste Codebasis-Ausführungen und neue MCP-Server erfordern Vertrauensüberprüfung

~~62 * Hinweis: Vertrauensüberprüfung ist deaktiviert, wenn nicht-interaktiv mit dem `-p`-Flag ausgeführt wird~~62 * Hinweis: Vertrauensüberprüfung ist deaktiviert, wenn nicht-interaktiv mit dem `-p`-Flag ausgeführt wird. Die Ausnahme ist [`--worktree`](/de/worktrees), das weiterhin erfordert, dass das Vertrauen für das Verzeichnis akzeptiert wurde

63* **Erkennung von Befehlsinjektionen**: Verdächtige Bash-Befehle erfordern manuelle Genehmigung, auch wenn sie zuvor auf die Zulassungsliste gesetzt wurden63* **Erkennung von Befehlsinjektionen**: Verdächtige Bash-Befehle erfordern manuelle Genehmigung, auch wenn sie zuvor auf die Zulassungsliste gesetzt wurden

64* **Fail-Closed-Matching**: Nicht übereinstimmende Befehle erfordern standardmäßig manuelle Genehmigung64* **Fail-Closed-Matching**: Nicht übereinstimmende Befehle erfordern standardmäßig manuelle Genehmigung

65* **Beschreibungen in natürlicher Sprache**: Komplexe Bash-Befehle enthalten Erklärungen zum Verständnis des Benutzers65* **Beschreibungen in natürlicher Sprache**: Komplexe Bash-Befehle enthalten Erklärungen zum Verständnis des Benutzers

server-managed-settings.md +3 −2

Details

41 </Step>41 </Step>

42 42

43 <Step title="Definieren Sie Ihre Einstellungen">43 <Step title="Definieren Sie Ihre Einstellungen">

44 Fügen Sie Ihre Konfiguration als JSON hinzu. Alle [in `settings.json` verfügbaren Einstellungen](/de/settings#available-settings) werden unterstützt, einschließlich [hooks](/de/hooks), [Umgebungsvariablen](/de/env-vars) und [nur verwaltete Einstellungen](/de/permissions#managed-only-settings) wie `allowManagedPermissionRulesOnly`.44 Fügen Sie Ihre Konfiguration als JSON hinzu. Alle [in `settings.json` verfügbaren Einstellungen](/de/settings#available-settings) werden unterstützt, mit Ausnahme derjenigen, die auf die Bereitstellung auf OS-Ebene beschränkt sind. Siehe [Aktuelle Einschränkungen](#current-limitations) für diese kurze Liste. Dies umfasst [hooks](/de/hooks), [Umgebungsvariablen](/de/env-vars) und [nur verwaltete Einstellungen](/de/permissions#managed-only-settings) wie `allowManagedPermissionRulesOnly`.

45 45

46 Dieses Beispiel erzwingt eine Berechtigungsverweigerungsliste, verhindert, dass Benutzer Berechtigungen umgehen, und beschränkt Berechtigungsregeln auf diejenigen, die in verwalteten Einstellungen definiert sind:46 Dieses Beispiel erzwingt eine Berechtigungsverweigerungsliste, verhindert, dass Benutzer Berechtigungen umgehen, und beschränkt Berechtigungsregeln auf diejenigen, die in verwalteten Einstellungen definiert sind:

47 47

93 }93 }

94 ```94 ```

95 95

96 Da Hooks Shell-Befehle ausführen, sehen Benutzer einen [Sicherheitsgenehmigungsdialog](#security-approval-dialogs), bevor sie angewendet werden. Siehe [Auto-Modus konfigurieren](/de/auto-mode-config), um zu erfahren, wie die `autoMode` Einträge beeinflussen, was der Klassifizierer blockiert, und wichtige Warnungen zu den Feldern `allow` und `soft_deny`.96 Da Hooks Shell-Befehle ausführen, sehen Benutzer einen [Sicherheitsgenehmigungsdialog](#security-approval-dialogs), bevor sie angewendet werden. Siehe [Auto-Modus konfigurieren](/de/auto-mode-config), um zu erfahren, wie die `autoMode` Einträge beeinflussen, was der Klassifizierer blockiert, und wichtige Warnungen zu den Feldern `environment`, `allow`, `soft_deny` und `hard_deny`.

97 </Step>97 </Step>

98 98

99 <Step title="Speichern und bereitstellen">99 <Step title="Speichern und bereitstellen">

124 124

125* Einstellungen gelten einheitlich für alle Benutzer in der Organisation. Konfigurationen pro Gruppe werden noch nicht unterstützt.125* Einstellungen gelten einheitlich für alle Benutzer in der Organisation. Konfigurationen pro Gruppe werden noch nicht unterstützt.

126* [MCP-Serverkonfigurationen](/de/mcp#managed-mcp-configuration) können nicht über serververwaltete Einstellungen verteilt werden.126* [MCP-Serverkonfigurationen](/de/mcp#managed-mcp-configuration) können nicht über serververwaltete Einstellungen verteilt werden.

127* Einstellungen, die auf OS-Ebene-Richtlinienquellen beschränkt sind, wie `policyHelper` und `wslInheritsWindowsSettings`, werden nicht berücksichtigt. Stellen Sie sie stattdessen über MDM oder eine System-Datei `managed-settings.json` bereit.

127 128

128## Einstellungsbereitstellung129## Einstellungsbereitstellung

129 130

settings.md +28 −1

Details

169| `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": ""}` |

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"` |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. Um dies über eine Umgebungsvariable zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/de/env-vars) in `env` | `false` |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. Um dies über eine Umgebungsvariable zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/de/env-vars) in `env` | `false` |

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"]}` |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`, `soft_deny` und `hard_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"]}` |

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` |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` |

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. Um Auto-Updates vollständig zu deaktivieren, setzen Sie [`DISABLE_AUTOUPDATER`](/de/setup#disable-auto-updates) in `env` | `"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. Um Auto-Updates vollständig zu deaktivieren, setzen Sie [`DISABLE_AUTOUPDATER`](/de/setup#disable-auto-updates) in `env` | `"stable"` |

175| `availableModels` | Beschränken Sie, welche Modelle Benutzer über `/model`, `--model` oder `ANTHROPIC_MODEL` auswählen können. Beeinflusst nicht die Standardoption. Siehe [Modellauswahl einschränken](/de/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |175| `availableModels` | Beschränken Sie, welche Modelle Benutzer über `/model`, `--model` oder `ANTHROPIC_MODEL` auswählen können. Beeinflusst nicht die Standardoption. Siehe [Modellauswahl einschränken](/de/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |

217| `pluginTrustMessage` | (Nur verwaltete Einstellungen) Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung angehängt wird. Verwenden Sie dies, um organisationsspezifischen Kontext hinzuzufügen, z. B. um zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft sind. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Nur verwaltete Einstellungen) Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung angehängt wird. Verwenden Sie dies, um organisationsspezifischen Kontext hinzuzufügen, z. B. um zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft sind. | `"All plugins from our marketplace are approved by IT"` |

218| `policyHelper` | {/* min-version: 2.1.136 */}Von Admin bereitgestellte ausführbare Datei, die verwaltete Einstellungen dynamisch beim Start berechnet. Wird nur von MDM oder einer System-`managed-settings.json`-Datei berücksichtigt. Siehe [Berechnen Sie verwaltete Einstellungen mit einem Policy Helper](#compute-managed-settings-with-a-policy-helper). Erfordert Claude Code v2.1.136 oder später | `{"path": "/usr/local/bin/claude-policy"}` |

218| `preferredNotifChannel` | Methode für Task-Complete- und Berechtigungsaufforderungs-Benachrichtigungen: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"` oder `"notifications_disabled"`. Standard: `"auto"`, das eine Desktop-Benachrichtigung in iTerm2, Ghostty und Kitty sendet und in anderen Terminals nichts tut. Setzen Sie `"terminal_bell"`, um das Glockenzeichen in jedem Terminal zu klingeln. Wird in `/config` als **Notifications** angezeigt. Siehe [Erhalten Sie einen Terminal-Glockenzeichen oder eine Benachrichtigung](/de/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |219| `preferredNotifChannel` | Methode für Task-Complete- und Berechtigungsaufforderungs-Benachrichtigungen: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"` oder `"notifications_disabled"`. Standard: `"auto"`, das eine Desktop-Benachrichtigung in iTerm2, Ghostty und Kitty sendet und in anderen Terminals nichts tut. Setzen Sie `"terminal_bell"`, um das Glockenzeichen in jedem Terminal zu klingeln. Wird in `/config` als **Notifications** angezeigt. Siehe [Erhalten Sie einen Terminal-Glockenzeichen oder eine Benachrichtigung](/de/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |

220| `prUrlTemplate` | URL-Vorlage für das PR-Badge, das in der Fußzeile und in Tool-Ergebnis-Zusammenfassungen angezeigt wird. Ersetzt `{host}`, `{owner}`, `{repo}`, `{number}` und `{url}` aus der von `gh` gemeldeten PR-URL. Verwenden Sie dies, um PR-Links auf ein internes Code-Review-Tool statt auf `github.com` zu verweisen. Beeinflusst nicht `#123` Autolinks in Claudes Prosa | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |221| `prUrlTemplate` | URL-Vorlage für das PR-Badge, das in der Fußzeile und in Tool-Ergebnis-Zusammenfassungen angezeigt wird. Ersetzt `{host}`, `{owner}`, `{repo}`, `{number}` und `{url}` aus der von `gh` gemeldeten PR-URL. Verwenden Sie dies, um PR-Links auf ein internes Code-Review-Tool statt auf `github.com` zu verweisen. Beeinflusst nicht `#123` Autolinks in Claudes Prosa | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

470}471}

471```472```

472 473

474### Berechnen Sie verwaltete Einstellungen mit einem Policy Helper

475

476Die Einstellung `policyHelper` verweist auf eine ausführbare Datei, die verwaltete Einstellungen beim Start dynamisch berechnet, sodass Administratoren Richtlinien von Geräteposition, Identität oder einem Remote-Service ableiten können, anstatt eine statische Datei zu verwenden. Konfigurieren Sie sie von MDM oder einer System-`managed-settings.json`-Datei. Claude Code ignoriert `policyHelper`, wenn es in einem anderen Bereich erscheint, einschließlich Benutzereinstellungen, Projekteinstellungen, der HKCU-Registry-Struktur und [serververwalteten Einstellungen](/de/server-managed-settings).

477

478Die Einstellung akzeptiert diese Schlüssel:

479

480| Schlüssel | Typ | Beschreibung |

481| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |

482| `path` | string | Absoluter Pfad zur Helper-Ausführungsdatei |

483| `timeoutMs` | number | Wie lange auf den Helper gewartet werden soll, bevor die Ausführung als fehlgeschlagen behandelt wird |

484| `refreshIntervalMs` | number | Wie oft der Helper im Hintergrund erneut ausgeführt werden soll. Setzen Sie auf `0`, um die Aktualisierung zu deaktivieren, oder auf mindestens `60000` |

485

486Der Helper schreibt eine JSON-Umschlag zu stdout. Setzen Sie die Einstellungen unter einen `managedSettings`-Schlüssel, anstatt auf der obersten Ebene, da ein bloßes Einstellungsobjekt mit `managedSettings` undefined analysiert wird und nichts anwendet:

487

488```json theme={null}

489{

490 "managedSettings": {

491 "permissions": { "deny": ["Read(//etc/secrets/**)"] }

492 },

493 "claudeMd": "# Organization context\n...",

494 "appendSystemPrompt": "Always cite the internal style guide."

495}

496```

497

498Wenn der Helper `managedSettings` ausgibt, ersetzt dieses Objekt die dateibasierten verwalteten Einstellungen für die Ausführung. Wenn der Helper beim Start mit einem Fehler beendet wird, druckt Claude Code den Fehler und weigert sich zu starten, daher sollte ein Helper, der Ausfallsicherheit benötigt, aus seinem eigenen Cache bedienen und mit `0` beenden.

499

473### Einstellungspriorität500### Einstellungspriorität

474 501

475Einstellungen werden in Prioritätsreihenfolge angewendet. Von höchster zu niedrigster:502Einstellungen werden in Prioritätsreihenfolge angewendet. Von höchster zu niedrigster:

whats-new.md +17 −1

Details

8 8

9Die wöchentliche Entwickler-Zusammenfassung hebt die Funktionen hervor, die am ehesten ändern, wie Sie arbeiten. Jeder Eintrag enthält ausführbaren Code, eine kurze Demo und einen Link zur vollständigen Dokumentation. Für jeden Fehlerbehebung und kleinere Verbesserung siehe das [Changelog](/de/changelog).9Die wöchentliche Entwickler-Zusammenfassung hebt die Funktionen hervor, die am ehesten ändern, wie Sie arbeiten. Jeder Eintrag enthält ausführbaren Code, eine kurze Demo und einen Link zur vollständigen Dokumentation. Für jeden Fehlerbehebung und kleinere Verbesserung siehe das [Changelog](/de/changelog).

10 10

11<Update label="Woche 19" description="4.–8. Mai 2026" tags={["v2.1.128–v2.1.136"]}>

12 **Plugins laden aus `.zip`-Archiven und URLs**: `--plugin-dir` akzeptiert jetzt `.zip`-Dateien, und `--plugin-url` ruft ein Plugin-Archiv für die aktuelle Sitzung ab.

14 Auch diese Woche: **`worktree.baseRef`** wählt, ob neue Worktrees vom Remote-Standard oder lokalen `HEAD` verzweigen; **Auto-Modus Hard-Deny-Regeln** blockieren Aktionen bedingungslos unabhängig von Allow-Ausnahmen; und **Hooks sehen die aktive Aufwandsstufe** über `effort.level` und `$CLAUDE_EFFORT`.

16 [Lesen Sie die Woche-19-Zusammenfassung →](/de/whats-new/2026-w19)

17</Update>

19<Update label="Woche 18" description="27. April – 1. Mai 2026" tags={["v2.1.120–v2.1.126"]}>

20 **Windows ohne Git Bash**: Git für Windows ist nicht mehr erforderlich, und Claude Code verwendet PowerShell als Shell-Tool, wenn Bash nicht vorhanden ist.

22 Auch diese Woche: **`claude ultrareview`** bringt Cloud-Code-Überprüfung zu CI und Skripten; **`claude project purge`** bereinigt den lokalen Status für ein Projekt; und das Einfügen einer **PR-URL in `/resume`** findet die Sitzung, die sie erstellt hat.

24 [Lesen Sie die Woche-18-Zusammenfassung →](/de/whats-new/2026-w18)

25</Update>

11<Update label="Woche 17" description="20.–24. April 2026" tags={["v2.1.114–v2.1.119"]}>27<Update label="Woche 17" description="20.–24. April 2026" tags={["v2.1.114–v2.1.119"]}>

12 **`/ultrareview`** öffnet sich als öffentliche Forschungsvorschau: Eine Flotte von Fehlersuche-Agenten läuft in der Cloud und die Ergebnisse landen automatisch in Ihrer CLI oder Desktop zurück.28 **`/ultrareview`** öffnet sich als öffentliche Forschungsvorschau: Eine Flotte von Fehlersuche-Agenten läuft in der Cloud und die Ergebnisse landen automatisch in Ihrer CLI oder Desktop zurück.

13 29

19<Update label="Woche 16" description="13.–17. April 2026" tags={["v2.1.105–v2.1.113"]}>35<Update label="Woche 16" description="13.–17. April 2026" tags={["v2.1.105–v2.1.113"]}>

20 **Claude Opus 4.7** landet als neue Standardeinstellung auf Max und Team Premium, mit einer neuen `xhigh`-Aufwandsstufe, die die empfohlene Einstellung für die meisten Codierungsarbeiten ist, und einem interaktiven `/effort`-Schieberegler zum Einstellen.36 **Claude Opus 4.7** landet als neue Standardeinstellung auf Max und Team Premium, mit einer neuen `xhigh`-Aufwandsstufe, die die empfohlene Einstellung für die meisten Codierungsarbeiten ist, und einem interaktiven `/effort`-Schieberegler zum Einstellen.

21 37

22 Auch diese Woche: **Routinen** auf Claude Code im Web starten vorlagengesteuerte Cloud-Agenten nach einem Zeitplan, GitHub-Ereignis oder API-Aufruf; `/ultrareview` führt parallele Multi-Agent-Code-Überprüfung in der Cloud durch; `/usage` zeigt, was Ihre Limits antreibt; und die CLI wechselt zu nativen Binärdateien.38 Auch diese Woche: **Routinen** auf Claude Code im Web starten vorlagengesteuerte Cloud-Agenten nach einem Zeitplan, GitHub-Ereignis oder API-Aufruf; **mobile Push-Benachrichtigungen** benachrichtigen Ihr Telefon, wenn eine lange Aufgabe abgeschlossen ist oder Claude Sie braucht; `/usage` zeigt, was Ihre Limits antreibt; und die CLI wechselt zu nativen Binärdateien.

23 39

24 [Lesen Sie die Woche-16-Zusammenfassung →](/de/whats-new/2026-w16)40 [Lesen Sie die Woche-16-Zusammenfassung →](/de/whats-new/2026-w16)

25</Update>41</Update>

whats-new/2026-w16.md +11 −13

Details

4 4

5# Woche 16 · 13.–17. April 20265# Woche 16 · 13.–17. April 2026

6 6

7> Claude Opus 4.7 mit der neuen xhigh-Anstrengungsstufe, Routinen auf Claude Code im Web, /ultrareview Cloud-Code-Review, eine /usage-Aufschlüsselung, die zeigt, was Ihre Limits antreibt, und native Binärdateien ersetzen das gebündelte JavaScript.7> Claude Opus 4.7 mit der neuen xhigh-Anstrengungsstufe, Routinen auf Claude Code im Web, mobile Push-Benachrichtigungen, die Ihr Telefon anpingen, wenn Claude Sie braucht, eine /usage-Aufschlüsselung, die zeigt, was Ihre Limits antreibt, und native Binärdateien ersetzen das gebündelte JavaScript.

8 8

9<div className="digest-meta">9<div className="digest-meta">

10 <span>Releases <a href="/de/docs/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>10 <span>Releases <a href="/de/docs/changelog#2-1-105">v2.1.105 → v2.1.113</a></span>

73 73

74<div className="digest-feature">74<div className="digest-feature">

75 <div className="digest-feature-header">75 <div className="digest-feature-header">

~~76 <span className="digest-feature-title">/ultrareview</span>~~76 <span className="digest-feature-title">Mobile Push-Benachrichtigungen</span>

~~77 <span className="digest-feature-pill">v2.1.111</span>~~77 <span className="digest-feature-pill">mobile</span>

78 </div>78 </div>

79 79

80 <p className="digest-feature-lede">Umfassende Code-Überprüfung in der Cloud. Ultrareview verteilt Ihren Branch auf parallele Reviewer auf Claude Code im Web, führt einen gegnerischen Kritik-Pass über jeden Fund durch und gibt einen verifizierten Fundebericht zurück, während Ihr Terminal frei bleibt. Rufen Sie es ohne Argumente auf, um Ihren aktuellen Branch zu überprüfen, oder übergeben Sie eine PR-Nummer, um diese PR zu holen und zu überprüfen. Der Startdialog zeigt jetzt ein Diffstat, damit Sie wissen, was hochgeht, bevor Sie bestätigen.</p>80 <p className="digest-feature-lede">Mit <a href="/de/docs/remote-control">Remote Control</a> verbunden kann Claude eine Push-Benachrichtigung an Ihr Telefon senden, wenn eine lange Aufgabe abgeschlossen ist oder es eine Entscheidung braucht, um weiterzumachen. Aktivieren Sie es mit „Push, wenn Claude entscheidet" in <code>/config</code>, oder fordern Sie eine in Ihrem Prompt an. Nützlich, wenn Sie einen langen Agent-Lauf starten und sich vom Terminal entfernen möchten.</p>

81 81

~~82 <p className="digest-feature-try">Überprüfen Sie den Branch, auf dem Sie sich befinden:</p>~~82 <Frame>

83 83 <video autoPlay muted loop playsInline className="w-full" src="https://mintcdn.com/claude-code/uII1TETOZxBUZ3lB/images/whats-new/push-notifications.mp4?fit=max&auto=format&n=uII1TETOZxBUZ3lB&q=85&s=c91a967139596500cbdb581a53822ac1" data-path="images/whats-new/push-notifications.mp4" />

~~84 ```text Claude Code theme={null}~~84 </Frame>

~~85 > /ultrareview~~

~~86 ```~~

87 85

~~88 <p className="digest-feature-try">Oder zeigen Sie auf einen PR:</p>~~86 <p className="digest-feature-try">Bitten Sie Claude, Sie anzupingen, wenn es fertig ist:</p>

89 87

90 ```text Claude Code theme={null}88 ```text Claude Code theme={null}

~~91 > /ultrareview 1234~~89 > notify me when the tests pass

92 ```90 ```

93 91

~~94 <a className="digest-feature-link" href="/de/docs/ultrareview">Ultrareview-Anleitung</a>~~92 <a className="digest-feature-link" href="/de/docs/remote-control#mobile-push-notifications">Remote Control: mobile Push-Benachrichtigungen</a>

95</div>93</div>

96 94

97<div className="digest-feature">95<div className="digest-feature">

116 <p className="digest-wins-title">Weitere Erfolge</p>114 <p className="digest-wins-title">Weitere Erfolge</p>

117 115

118 <div className="digest-wins-grid">116 <div className="digest-wins-grid">

117 <div>Neuer <a href="/de/docs/ultrareview"><code>/ultrareview</code></a>: umfassende Code-Überprüfung in der Cloud mit paralleler Multi-Agent-Analyse und einem gegnerischen Kritik-Pass. Führen Sie es ohne Argumente aus, um Ihren aktuellen Branch zu überprüfen, oder <code>/ultrareview \<PR#></code> für einen bestimmten PR</div>

119 <div><a href="/de/docs/permission-modes#eliminate-prompts-with-auto-mode">Auto-Modus</a> ist jetzt für Max-Abonnenten auf Opus 4.7 verfügbar, und das Flag <code>--enable-auto-mode</code> ist nicht mehr erforderlich</div>118 <div><a href="/de/docs/permission-modes#eliminate-prompts-with-auto-mode">Auto-Modus</a> ist jetzt für Max-Abonnenten auf Opus 4.7 verfügbar, und das Flag <code>--enable-auto-mode</code> ist nicht mehr erforderlich</div>

120 <div><a href="/de/docs/interactive-mode#session-recap">Sitzungszusammenfassung</a> zeigt eine einzeilige Zusammenfassung dessen, was passiert ist, während Sie weg waren; führen Sie <code>/recap</code> bei Bedarf aus oder deaktivieren Sie es über <code>/config</code></div>119 <div><a href="/de/docs/interactive-mode#session-recap">Sitzungszusammenfassung</a> zeigt eine einzeilige Zusammenfassung dessen, was passiert ist, während Sie weg waren; führen Sie <code>/recap</code> bei Bedarf aus oder deaktivieren Sie es über <code>/config</code></div>

121 <div>Neuer <code>/tui</code>-Befehl und <code>tui</code>-Einstellung wechseln zwischen klassischem und flimmerfreiem Rendering während des Gesprächs; Fokusansicht wurde von <code>Ctrl+O</code> zu ihrem eigenen <code>/focus</code>-Befehl verschoben</div>120 <div>Neuer <code>/tui</code>-Befehl und <code>tui</code>-Einstellung wechseln zwischen klassischem und flimmerfreiem Rendering während des Gesprächs; Fokusansicht wurde von <code>Ctrl+O</code> zu ihrem eigenen <code>/focus</code>-Befehl verschoben</div>

122 <div>Push-Benachrichtigungstool: Mit <a href="/de/docs/remote-control">Remote Control</a> verbunden und „Push, wenn Claude entscheidet" aktiviert, kann Claude Ihr Telefon anpingen, wenn es Sie braucht</div>

123 <div>Plugins können Hintergrund-Watcher über einen Top-Level-<code>monitors</code>-Manifest-Schlüssel versenden, der sich beim Sitzungsstart oder beim Skill-Aufruf automatisch aktiviert</div>121 <div>Plugins können Hintergrund-Watcher über einen Top-Level-<code>monitors</code>-Manifest-Schlüssel versenden, der sich beim Sitzungsstart oder beim Skill-Aufruf automatisch aktiviert</div>

124 <div>Option „Auto (Terminal abgleichen)" in <code>/theme</code> folgt dem dunklen/hellen Modus Ihres Terminals</div>122 <div>Option „Auto (Terminal abgleichen)" in <code>/theme</code> folgt dem dunklen/hellen Modus Ihres Terminals</div>

125 <div><code>/fewer-permission-prompts</code> scannt Ihre Transkripte nach häufigen schreibgeschützten Bash- und MCP-Aufrufen und schlägt eine Allowlist für <code>.claude/settings.json</code> vor</div>123 <div><code>/fewer-permission-prompts</code> scannt Ihre Transkripte nach häufigen schreibgeschützten Bash- und MCP-Aufrufen und schlägt eine Allowlist für <code>.claude/settings.json</code> vor</div>

whats-new/2026-w18.md +113 −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# Woche 18 · 27. April – 1. Mai 2026

7> Claude Code unter Windows läuft ohne Git Bash, claude auth login akzeptiert einen eingefügten OAuth-Code, wenn der Browser-Callback localhost nicht erreichen kann, claude project purge bereinigt den lokalen Status pro Projekt, und das Einfügen einer PR-URL in /resume findet die Sitzung, die sie erstellt hat.

9<div className="digest-meta">

10 <span>Releases <a href="/de/changelog#2-1-120">v2.1.120 → v2.1.126</a></span>

11 <span>4 Funktionen · 27. April – 1. Mai</span>

12</div>

14<div className="digest-feature">

15 <div className="digest-feature-header">

16 <span className="digest-feature-title">Anmelden ohne Browser-Callback</span>

17 <span className="digest-feature-pill">v2.1.126</span>

18 </div>

20 <p className="digest-feature-lede"><code>claude auth login</code> akzeptiert nun den OAuth-Code, der direkt in das Terminal eingefügt wird, wenn der Browser-Callback localhost nicht erreichen kann. Dies deckt WSL2, SSH-Sitzungen und Container ab, bei denen die Umleitung zu einem lokalen Port nicht funktioniert. Die gleiche Version behebt auch Anmelde-Timeouts bei langsamen oder Proxy-Verbindungen und in IPv6-only DevContainern.</p>

22 <p className="digest-feature-try">Melden Sie sich an und fügen Sie dann den Code aus dem Browser ein:</p>

24 ```bash theme={null}

25 claude auth login

26 ```

28 <a className="digest-feature-link" href="/de/cli-reference#cli-commands">CLI-Referenz</a>

29</div>

31<div className="digest-feature">

32 <div className="digest-feature-header">

33 <span className="digest-feature-title">claude project purge</span>

34 <span className="digest-feature-pill">v2.1.126</span>

35 </div>

37 <p className="digest-feature-lede">Löschen Sie alle Claude Code-Status für ein Projekt: Transkripte, Aufgaben, Dateiverlauf und den Konfigurationseintrag des Projekts. Unterstützt `--dry-run` zur Vorschau, `-y`/`--yes` zum Überspringen der Bestätigung, `-i`/`--interactive` zur Auswahl und `--all` zum Löschen aller Projekte.</p>

39 <p className="digest-feature-try">Vorschau, was gelöscht würde:</p>

41 ```bash theme={null}

42 claude project purge --dry-run

43 ```

45 <p className="digest-feature-try">Dann führen Sie es aus:</p>

47 ```bash theme={null}

48 claude project purge

49 ```

51 <a className="digest-feature-link" href="/de/cli-reference">CLI-Referenz</a>

52</div>

54<div className="digest-feature">

55 <div className="digest-feature-header">

56 <span className="digest-feature-title">Fortsetzen nach PR-URL</span>

57 <span className="digest-feature-pill">v2.1.122</span>

58 </div>

60 <p className="digest-feature-lede">Wenn Sie einen Pull Request mit <code>gh pr create</code> erstellen, verknüpft Claude Code ihn mit der Sitzung, die ihn erstellt hat. Jetzt können Sie zu dieser Sitzung nur anhand der PR-URL zurückkehren, ohne sich ihren Namen merken zu müssen.</p>

62 <p className="digest-feature-try">Öffnen Sie die Sitzungsauswahl:</p>

64 ```text Claude Code theme={null}

65 > /resume

66 ```

68 <p className="digest-feature-try">Fügen Sie die PR-URL in die Auswahl ein. Das erste Zeichen des eingefügten Textes versetzt Sie in den Suchmodus, und die Liste wird auf die Sitzung gefiltert, die diesen PR erstellt hat. Drücken Sie die Eingabetaste, um sie fortzusetzen. GitHub-, GitHub Enterprise-, GitLab- und Bitbucket-Pull- und Merge-Request-URLs funktionieren alle.</p>

70 ```text Claude Code theme={null}

71 https://github.com/your-org/your-repo/pull/1234

72 ```

74 <p className="digest-feature-try">Um die Auswahl zu überspringen, übergeben Sie stattdessen die PR-Nummer in der Befehlszeile:</p>

76 ```bash theme={null}

77 claude --from-pr 1234

78 ```

80 <a className="digest-feature-link" href="/de/sessions#use-the-session-picker">Sitzungen: Verwenden Sie die Sitzungsauswahl</a>

81</div>

83<div className="digest-feature">

84 <div className="digest-feature-header">

85 <span className="digest-feature-title">Windows ohne Git Bash</span>

86 <span className="digest-feature-pill">Windows</span>

87 </div>

89 <p className="digest-feature-lede">Git für Windows ist nicht mehr erforderlich. Wenn Bash nicht vorhanden ist, verwendet Claude Code PowerShell als Shell-Tool, und wenn das PowerShell-Tool aktiviert ist, wird es als primäre Shell behandelt. PowerShell 7, das über den Microsoft Store, MSI ohne PATH oder als <code>.NET</code> Global Tool installiert ist, wird jetzt automatisch erkannt.</p>

91 <a className="digest-feature-link" href="/de/setup">Installationsanleitung</a>

92</div>

94<div className="digest-wins">

95 <p className="digest-wins-title">Weitere Verbesserungen</p>

97 <div className="digest-wins-grid">

98 <div>MCP-Server können sich mit `alwaysLoad: true` in ihrer Konfiguration von der Tool-Suche-Verschiebung abmelden, sodass alle Tools dieses Servers immer verfügbar sind</div>

99 <div>Neuer `claude plugin prune` entfernt verwaiste automatisch installierte Plugin-Abhängigkeiten, und `plugin uninstall --prune` kaskadiert</div>

100 <div>`/skills` hat jetzt ein Typ-zum-Filtern-Suchfeld, damit Sie eine Fähigkeit in einer langen Liste finden können, ohne zu scrollen</div>

101 <div>`PostToolUse` Hooks können Tool-Ausgabe für jedes Tool über `hookSpecificOutput.updatedToolOutput` ersetzen, nicht nur für MCP-Tools</div>

102 <div>Neuer <a href="/de/ultrareview"><code>claude ultrareview</code></a> Unterbefehl führt `/ultrareview` nicht interaktiv aus CI oder Skripten aus: gibt Ergebnisse auf stdout aus (`--json` für Rohausgabe) und beendet mit 0 bei Abschluss oder 1 bei Fehler</div>

103 <div>`--dangerously-skip-permissions` umgeht nun Eingabeaufforderungen für Schreibvorgänge in `.claude/`, `.git/`, `.vscode/`, Shell-Konfigurationsdateien und anderen zuvor geschützten Pfaden, während katastrophale Löschbefehle als Sicherheitsnetz weiterhin auffordern</div>

104 <div>Die `/model` Auswahl kann Modelle aus dem `/v1/models` Endpunkt Ihres Gateways auflisten, wenn `ANTHROPIC_BASE_URL` auf ein Anthropic-kompatibles Gateway verweist; aktivieren Sie mit `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` seit v2.1.129</div>

105 <div>MCP-Server, die während des Starts einen vorübergehenden Fehler treffen, versuchen jetzt automatisch bis zu 3 Mal erneut, anstatt getrennt zu bleiben</div>

106 <div>`ANTHROPIC_BEDROCK_SERVICE_TIER` wählt einen Bedrock-Service-Tier: `default`, `flex` oder `priority`</div>

107 <div>`/terminal-setup` aktiviert die Clipboard-Zugriffseinstellen von iTerm2, damit `/copy` funktioniert, auch von tmux aus</div>

108 <div>Vertex AI unterstützt jetzt X.509-Zertifikat-basierte Workload Identity Federation (mTLS ADC)</div>

109 <div>Signifikante Speicherleck-Fixes: bildintensive Sitzungen, `/usage` bei großen Transkript-Historien und lang laufende Tools ohne Progress-Events</div>

110 </div>

111</div>

112

113[Vollständiges Changelog für v2.1.120–v2.1.126 →](/de/changelog#2-1-120)

whats-new/2026-w19.md +60 −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# Woche 19 · 4.–8. Mai 2026

7> Laden Sie Plugins aus .zip-Archiven und URLs, durchsuchen Sie den Befehlsverlauf über alle Projekte hinweg mit Strg+R, erstellen Sie neue Worktrees aus lokalem HEAD oder dem Remote-Standard, und blockieren Sie Aktionen bedingungslos mit Auto-Modus-Hard-Deny-Regeln.

9<div className="digest-meta">

10 <span>Releases <a href="/de/changelog#2-1-128">v2.1.128 → v2.1.136</a></span>

11 <span>2 Features · 4.–8. Mai</span>

12</div>

14<div className="digest-feature">

15 <div className="digest-feature-header">

16 <span className="digest-feature-title">Plugins aus .zip-Archiven und URLs</span>

17 </div>

19 <p className="digest-feature-lede"><code>--plugin-dir</code> akzeptiert nun ein <code>.zip</code>-Plugin-Archiv zusätzlich zu einem Verzeichnis, und das neue Flag <code>--plugin-url</code> ruft ein Plugin-Archiv von einer URL für die aktuelle Sitzung ab. Nützlich zum Testen eines Plugins, bevor Sie es zu einem Marketplace hinzufügen, oder zum Versand interner Plugins aus einem Artifact Store.</p>

21 <p className="digest-feature-try">Laden Sie ein Plugin direkt von einer URL:</p>

23 ```bash terminal theme={null}

24 claude --plugin-url https://example.com/my-plugin.zip

25 ```

27 <a className="digest-feature-link" href="/de/plugins">Plugins-Anleitung</a>

28</div>

30<div className="digest-feature">

31 <div className="digest-feature-header">

32 <span className="digest-feature-title">Verlaufssuche über alle Ihre Projekte</span>

33 <span className="digest-feature-pill">v2.1.129</span>

34 </div>

36 <p className="digest-feature-lede"><code>Strg+R</code> Rückwärtssuche durchsucht nun standardmäßig alle Prompts über alle Projekte hinweg und stellt das Verhalten von vor v2.1.124 wieder her. Drücken Sie <code>Strg+S</code> während der Suche, um die Suche auf das aktuelle Projekt oder die aktuelle Sitzung einzugrenzen. Praktisch, wenn Sie sich an einen Befehl erinnern, den Sie letzte Woche in einem anderen Repository ausgeführt haben, und nicht danach graben möchten.</p>

38 <a className="digest-feature-link" href="/de/interactive-mode#command-history">Interaktiver Modus: Befehlsverlauf</a>

39</div>

41<div className="digest-wins">

42 <p className="digest-wins-title">Weitere Verbesserungen</p>

44 <div className="digest-wins-grid">

45 <div>Neue Einstellung <code>worktree.baseRef</code> (<code>fresh</code> | <code>head</code>) steuert, ob <code>--worktree</code>, das Tool <code>EnterWorktree</code> und Agent-Isolations-Worktrees vom Remote-Standard-Branch oder vom lokalen <code>HEAD</code> abzweigen; der Standard <code>fresh</code> hält nicht gepushte Commits aus neuen Worktrees heraus</div>

46 <div>Neue Regeln <code>settings.autoMode.hard\_deny</code> blockieren übereinstimmende Aktionen bedingungslos im Auto-Modus, unabhängig von Allow-Ausnahmen, für Aktionen, die niemals automatisch ausgeführt werden sollten, auch wenn breitere Allow-Regeln gelten</div>

47 <div>Hooks erhalten nun die aktive Anstrengungsebene über das JSON-Eingabefeld <code>effort.level</code> und die Umgebungsvariable <code>$CLAUDE_EFFORT</code>, und Bash-Tool-Befehle können <code>$CLAUDE\_EFFORT</code> lesen</div>

48 <div><code>CLAUDE\_CODE\_DISABLE\_ALTERNATE\_SCREEN=1</code> deaktiviert den Vollbild-Alternate-Screen-Renderer und behält die Konversation im nativen Scrollback des Terminals</div>

49 <div><code>CLAUDE\_CODE\_PACKAGE\_MANAGER\_AUTO\_UPDATE</code> ermöglicht es Homebrew- oder WinGet-Installationen, das Upgrade im Hintergrund auszuführen und zum Neustart aufzufordern</div>

50 <div><code>CLAUDE\_CODE\_SESSION\_ID</code> ist nun in der Bash-Tool-Subprozess-Umgebung vorhanden und entspricht der <code>session\_id</code>, die an Hooks übergeben wird</div>

51 <div><code>/mcp</code> zeigt nun die Werkzeuganzahl für verbundene Server an und kennzeichnet Server, die mit 0 Werkzeugen verbunden sind</div>

52 <div><code>--channels</code> funktioniert nun mit Konsolen-Authentifizierung (API-Schlüssel)</div>

53 <div>Subprozesse wie Bash, Hooks, MCP und LSP erben nicht mehr <code>OTEL\_\*</code> Umgebungsvariablen, sodass OTEL-instrumentierte Apps, die über das Bash-Tool ausgeführt werden, nicht mehr den OTLP-Endpunkt der CLI selbst aufgreifen</div>

54 <div>Zusammenfassungen zum Fortschritt von Sub-Agenten treffen nun den Prompt-Cache und reduzieren die <code>cache\_creation</code> Token-Kosten um etwa das 3-fache</div>

55 <div>Mehrere OAuth- und Anmeldedaten-Zuverlässigkeitskorrektionen: Parallele Sitzungen enden nicht mehr bei 401 nach einem Refresh-Token-Rennen, MCP-OAuth-Refresh-Token gehen nicht mehr verloren, wenn mehrere Server gleichzeitig aktualisiert werden, und eine seltene Anmeldeschleife aus einem gleichzeitigen Anmeldedaten-Schreibvorgang ist behoben</div>

56 <div>Neuer Admin-Schlüssel <code>parentSettingsBehavior</code> ermöglicht es Administratoren, SDK <code>managedSettings</code> in die Richtlinien-Zusammenführung einzubeziehen</div>

57 </div>

58</div>

60[Vollständiges Changelog für v2.1.128–v2.1.136 →](/de/changelog#2-1-128)

Documentation 2026-05-08 22:00 UTC to 2026-05-09 04:57 UTC