> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Werkzeugreferenz
> Vollständige Referenz für die Werkzeuge, die Fuxi Code verwenden kann, einschließlich Berechtigungsanforderungen und Verhalten pro Werkzeug.
Fuxi Code hat Zugriff auf eine Reihe von integrierten Werkzeugen, die ihm helfen, Ihre Codebasis zu verstehen und zu ändern. Die Werkzeugnamen sind die genauen Zeichenketten, die Sie in [Berechtigungsregeln](/de/permissions#tool-specific-permission-rules), [Subagent-Werkzeuglisten](/de/sub-agents) und [Hook-Matchern](/de/hooks) verwenden. Um ein Werkzeug vollständig zu deaktivieren, fügen Sie seinen Namen zum `deny`-Array in Ihren [Berechtigungseinstellungen](/de/permissions#tool-specific-permission-rules) hinzu.
Um benutzerdefinierte Werkzeuge hinzuzufügen, verbinden Sie einen [MCP-Server](/de/mcp). Um Fuxi mit wiederverwendbaren Prompt-basierten Workflows zu erweitern, schreiben Sie einen [Skill](/de/skills), der über das vorhandene `Skill`-Werkzeug ausgeführt wird, anstatt einen neuen Werkzeugeintrag hinzuzufügen.
Die Spalte „Berechtigung erforderlich" zeigt, ob das Werkzeug im Standard-Berechtigungsmodus für Pfade innerhalb des Arbeitsverzeichnisses auffordert. Dateizugriffswerkzeuge, die mit „Nein" gekennzeichnet sind, einschließlich `Read`, `Grep` und `Glob`, fordern weiterhin für Pfade außerhalb des [Arbeitsverzeichnisses und zusätzlicher Verzeichnisse](/de/permissions#working-directories) auf. `Bash` ist mit „Ja" gekennzeichnet, führt aber einen integrierten Satz von [schreibgeschützten Befehlen](/de/permissions#read-only-commands) ohne Aufforderung aus.
| Werkzeug | Beschreibung | Berechtigung erforderlich |
| :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------ |
| `Agent` | Erzeugt einen [Subagenten](/de/sub-agents) mit eigenem Kontextfenster zur Bewältigung einer Aufgabe. Siehe [Agent-Werkzeugverhalten](#agent-tool-behavior) | Nein |
| `Artifact` | Veröffentlicht eine HTML- oder Markdown-Datei als [Artefakt](/de/artifacts): eine private, interaktive Seite auf fuxi.ai. In Team- und Enterprise-Plänen können Sie diese in Ihrer Organisation freigeben. {/* plan-availability: feature=artifacts plans=pro,max,team,enterprise providers=anthropic */}Erfordert einen Pro-, Max-, Team- oder Enterprise-Plan und `/login`-Authentifizierung; siehe [Verfügbarkeit](/de/artifacts#availability) | Ja |
| `AskUserQuestion` | Stellt Multiple-Choice-Fragen, um Anforderungen zu sammeln oder Mehrdeutigkeiten zu klären. {/* min-version: 2.1.200 */}Fragen bleiben offen, bis Sie sie beantworten: Es gibt standardmäßig kein Idle-Timeout. Um einen Idle-Dialog stattdessen automatisch fortzusetzen, setzen Sie die Einstellung [`askUserQuestionTimeout`](/de/settings#available-settings) auf `60s`, `5m` oder `10m`, entweder in Ihrer Benutzer-`settings.json` oder in der Zeile **Question auto-continue timeout** in `/config`. Sobald die gewählte Idle-Zeit ohne Eingabe verstrichen ist, schließt sich der Dialog von selbst: Er sendet alle Optionen, die Sie bereits ausgewählt haben, und teilt Fuxi mit, dass Sie möglicherweise weg von Ihrer Tastatur sind, damit Fuxi nach eigenem Ermessen fortfährt und später erneut fragen kann. Ein Countdown wird in den letzten 20 Sekunden angezeigt. Jeder Tastendruck setzt den Timer zurück, ebenso wie ein fokussiertes Fenster auf Terminals, die Fokus melden. Das Timeout gilt nur für die Multiple-Choice-Fragen von `AskUserQuestion`; Berechtigungsaufforderungen, einschließlich Planbestätigung, werden bei Untätigkeit nie automatisch aufgelöst. In v2.1.198 und v2.1.199 wurde der Dialog standardmäßig nach 60 Sekunden Untätigkeit automatisch fortgesetzt, und [`FUXI_AFK_TIMEOUT_MS`](/de/env-vars#variables) war die einzige Möglichkeit, dies zu ändern | Nein |
| `Bash` | Führt Shell-Befehle in Ihrer Umgebung aus. Siehe [Bash-Werkzeugverhalten](#bash-tool-behavior) | Ja |
| `CronCreate` | Plant eine wiederkehrende oder einmalige Eingabeaufforderung innerhalb der aktuellen Sitzung. Aufgaben sind sitzungsbezogen und werden bei `--resume` oder `--continue` wiederhergestellt, wenn sie nicht abgelaufen sind. Siehe [geplante Aufgaben](/de/scheduled-tasks) | Nein |
| `CronDelete` | Bricht eine geplante Aufgabe nach ID ab | Nein |
| `CronList` | Listet alle geplanten Aufgaben in der Sitzung auf | Nein |
| `Edit` | Nimmt gezielte Änderungen an bestimmten Dateien vor. Siehe [Edit-Werkzeugverhalten](#edit-tool-behavior) | Ja |
| `EnterPlanMode` | Wechselt in Plan Mode, um einen Ansatz vor dem Codieren zu entwerfen | Nein |
| `EnterWorktree` | Erstellt einen isolierten [Git Worktree](/de/worktrees) und wechselt hinein. Übergeben Sie einen `path`, um stattdessen in einen vorhandenen Worktree zu wechseln. {/* min-version: 2.1.203 */}Beim ersten Eintritt kann das Ziel ein Worktree des aktuellen Repositorys oder in einem Multi-Repo-Workspace ein darin verschachteltes Repository sein. Vor v2.1.203 wurde ein Worktree eines verschachtelten Repositorys abgelehnt. Aus einer Worktree-Sitzung oder von einem Subagenten mit einem angehefteten Arbeitsverzeichnis wie [`isolation: worktree`](/de/sub-agents#supported-frontmatter-fields) ist nur die `path`-Form verfügbar und das Ziel muss unter `.fuxi/worktrees/` des Repositorys der Sitzung liegen | Nein |
| `ExitPlanMode` | Präsentiert einen Plan zur Genehmigung und beendet Plan Mode | Ja |
| `ExitWorktree` | Beendet eine Worktree-Sitzung und kehrt zum ursprünglichen Verzeichnis zurück. Nicht für Subagenten verfügbar, die bereits in ihrem eigenen Arbeitsverzeichnis ausgeführt werden, z. B. mit [`isolation: worktree`](/de/sub-agents#supported-frontmatter-fields) | Nein |
| `Glob` | Findet Dateien basierend auf Musterabgleich. Siehe [Glob-Werkzeugverhalten](#glob-tool-behavior) | Nein |
| `Grep` | Sucht nach Mustern in Dateiinhalten. Siehe [Grep-Werkzeugverhalten](#grep-tool-behavior) | Nein |
| `ListMcpResourcesTool` | Listet Ressourcen auf, die von verbundenen [MCP-Servern](/de/mcp) bereitgestellt werden | Nein |
| `LSP` | Code-Intelligenz über Sprachserver: Sprung zu Definitionen, Suche nach Referenzen, Meldung von Typfehlern und Warnungen. Siehe [LSP-Werkzeugverhalten](#lsp-tool-behavior) | Nein |
| `Monitor` | Führt einen Befehl im Hintergrund aus und gibt jede Ausgabezeile an Fuxi zurück, damit er auf Protokolleinträge, Dateiänderungen oder abgerufene Status während des Gesprächs reagieren kann. Kann auch einen WebSocket öffnen und jede eingehende Nachricht als Ereignis behandeln. Siehe [Monitor-Werkzeug](#monitor-tool) | Ja |
| `NotebookEdit` | Ändert Jupyter-Notebook-Zellen. Siehe [NotebookEdit-Werkzeugverhalten](#notebookedit-tool-behavior) | Ja |
| `PowerShell` | Führt PowerShell-Befehle nativ aus. Siehe [PowerShell-Werkzeug](#powershell-tool) für Verfügbarkeit | Ja |
| `PushNotification` | Sendet eine Desktop-Benachrichtigung und eine Telefon-Push-Benachrichtigung, wenn [Remote Control](/de/remote-control) verbunden ist, damit eine langfristige Aufgabe oder [geplante Aufgabe](/de/scheduled-tasks) Sie erreichen kann, wenn Sie weg sind. {/* plan-availability: feature=push-notifications providers=anthropic */}Push-Zustellung läuft über von Anthropic gehostete Infrastruktur, auf die von Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry nicht zugegriffen werden kann | Nein |
| `Read` | Liest den Inhalt von Dateien. Siehe [Read-Werkzeugverhalten](#read-tool-behavior) | Nein |
| `ReadMcpResourceTool` | Liest eine bestimmte MCP-Ressource nach URI | Nein |
| `RemoteTrigger` | Erstellt, aktualisiert, führt aus und listet [Routinen](/de/routines) auf fuxi.ai auf. Unterstützt den `/schedule`-Befehl. {/* plan-availability: feature=routines plans=pro,max,team,enterprise providers=anthropic */}Routinen befinden sich auf fuxi.ai und erfordern einen Pro-, Max-, Team- oder Enterprise-Plan, daher ist dieses Werkzeug nicht über Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry zugänglich | Nein |
| `ReportFindings` | Meldet Code-Review-Ergebnisse als strukturierte Liste mit einer Datei, Zusammenfassung und Fehlerfall pro Ergebnis, damit Fuxi Code sie rendern kann, anstatt sie als Text auszudrucken. Fuxi ruft es auf, wenn aktive Code-Review-Anweisungen dies vorsehen. {/* min-version: 2.1.196 */}Erfordert Fuxi Code v2.1.196 oder später. {/* min-version: 2.1.199 */}Ab v2.1.199 kann ein Ergebnis auch einen optionalen `category`-Slug tragen, wie `correctness` oder `test-coverage`, der neben dem Dateispeicherort in der gerenderten Liste angezeigt wird | Nein |
| `ScheduleWakeup` | Plant die nächste Iteration eines [selbstgesteuerten `/loop`](/de/scheduled-tasks#let-fuxi-choose-the-interval) neu. Fuxi ruft dies am Ende jeder Iteration auf, um auszuwählen, wann die nächste ausgeführt wird, zwischen einer Minute und einer Stunde später; Sie rufen es nicht direkt auf. Um die Schleife stattdessen zu beenden, ruft Fuxi es mit `stop: true` auf, was das ausstehende Wakeup abbricht. {/* min-version: 2.1.202 */}Das Feld `stop` erfordert Fuxi Code v2.1.202 oder später. Das ausstehende Wakeup wird in `session_crons` in [Stop-Hook-Eingabe](/de/hooks#stop-input) angezeigt. {/* plan-availability: feature=loop-dynamic providers=anthropic */}Nicht verfügbar auf Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry, wo ein `/loop`-Prompt ohne Intervall stattdessen nach einem festen Zeitplan ausgeführt wird | Nein |
| `SendMessage` | Sendet eine Nachricht an einen [Agent-Team](/de/agent-teams)-Mitarbeiter oder [setzt einen Subagenten](/de/sub-agents#resume-subagents) nach seiner Agent-ID oder seinem Namen fort. Ein abgeschlossener Subagent wird automatisch im Hintergrund fortgesetzt; ein Subagent, den Sie von `/tasks` aus gestoppt haben, wird nicht fortgesetzt und der Aufruf gibt eine Ablehnung zurück. Strukturierte Team-Protokoll-Nachrichten erfordern Agent-Teams. Ein Empfänger behandelt eine Nachricht von einem anderen Agenten niemals als Ihre Zustimmung oder Genehmigung. {/* min-version: 2.1.198 */}Ab v2.1.198 behandelt ein Subagent eine Nachricht vom Agent, der ihn gestartet hat, als normale Aufgabenrichtung statt als Peer-Anfrage. {/* min-version: 2.1.199 */}Ab v2.1.199 wird ein Senden an einen Namen, der sich jetzt zu einem anderen Agenten auflöst als früher im Gespräch, abgelehnt statt zugestellt; siehe [Subagenten fortsetzen](/de/sub-agents#resume-subagents) | Nein |
| `SendUserFile` | Sendet Dateien aus der Sitzung an Sie mit einer optionalen Beschriftung, damit ein generierter Bericht, Diagramm, Screenshot oder erstelltes Artefakt Ihr Gerät erreicht, anstatt nur im Transkript erwähnt zu werden. {/* min-version: 2.1.196 */}Ab v2.1.196 steuert die optionale `display`-Eingabe die Präsentation: `render` öffnet die Datei inline im Client, `attach` zeigt nur eine Download-Karte an, und wenn nicht gesetzt, entscheidet der Client nach Dateityp. Verfügbar, wenn ein [Remote Control](/de/remote-control)-Client verbunden ist oder die Sitzung in einer verwalteten Cloud-Umgebung wie [Fuxi Code im Web](/de/fuxi-code-on-the-web) ausgeführt wird. Die Zustellung läuft über von Anthropic gehostete Infrastruktur, daher ist das Werkzeug nicht auf Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry verfügbar | Nein |
| `ShareOnboardingGuide` | {/* plan-availability: feature=onboarding-guide-share plans=pro,max,team,enterprise providers=anthropic */}Lädt `ONBOARDING.md` hoch und gibt einen Freigabelink zurück, den Mitarbeiter in Fuxi Code öffnen können. Wird nach dem Schreiben des Leitfadens von `/team-onboarding` aufgerufen. Verfügbar für fuxi.ai-Abonnenten mit Pro-, Max-, Team- und Enterprise-Plänen | Ja |
| `Skill` | Führt einen [Skill](/de/skills#control-who-invokes-a-skill) innerhalb des Hauptgesprächs aus | Ja |
| `TaskCreate` | Erstellt eine neue Aufgabe in der Aufgabenliste | Nein |
| `TaskGet` | Ruft vollständige Details für eine bestimmte Aufgabe ab | Nein |
| `TaskList` | Listet alle Aufgaben mit ihrem aktuellen Status auf | Nein |
| `TaskOutput` | Ruft Ausgabe von einer Hintergrundaufgabe ab. Veraltet zugunsten von `Read` auf dem Ausgabedateipfad der Aufgabe. {/* min-version: 2.1.203 */}Wenn keine Aufgabe der ID entspricht, listet der Fehler die laufenden Hintergrund-Agenten nach ID und Beschreibung auf. Vor v2.1.203 benannte der Fehler nur die fehlende ID | Nein |
| `TaskStop` | Beendet eine laufende Hintergrundaufgabe nach ID. {/* min-version: 2.1.198 */}Es akzeptiert auch einen [Agent-Team-Mitarbeiter](/de/agent-teams) oder einen benannten Hintergrund-Agenten nach Agent-ID oder Name. Vor v2.1.198 akzeptierte es nur eine Hintergrundaufgaben-ID. {/* min-version: 2.1.203 */}Wenn keine Aufgabe der ID entspricht, listet der Fehler die laufenden Hintergrund-Agenten nach ID und Beschreibung auf, einschließlich Agenten, die ein anderer Agent erzeugt hat. Vor v2.1.203 listete der Fehler laufende Mitarbeiter und benannte Agenten auf, aber nicht Hintergrund-Agenten, die ein anderer Agent erzeugt hat, daher konnten diese nicht identifiziert oder aus dem Hauptgespräch gestoppt werden | Nein |
| `TaskUpdate` | Aktualisiert Aufgabenstatus, Abhängigkeiten, Details oder löscht Aufgaben | Nein |
| `TodoWrite` | {/* min-version: 2.1.142 */}Verwaltet die Sitzungs-Aufgabenliste. Standardmäßig ab v2.1.142 deaktiviert zugunsten von `TaskCreate`, `TaskGet`, `TaskList` und `TaskUpdate`. Setzen Sie `FUXI_CODE_ENABLE_TASKS=0`, um es erneut zu aktivieren | Nein |
| `ToolSearch` | Sucht nach verschobenen Werkzeugen und lädt sie, wenn [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) aktiviert ist | Nein |
| `WaitForMcpServers` | Wartet auf einen oder mehrere [MCP-Server](/de/mcp), die noch im Hintergrund verbunden werden, damit eine Anfrage ihre Werkzeuge verwenden kann, ohne die Sitzung neu zu starten. Fuxi ruft es auf, wenn ein benötigter Server noch nicht verbunden ist. Wird nur angezeigt, wenn [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) deaktiviert ist, da `ToolSearch` das Warten handhabt, wenn es aktiviert ist | Nein |
| `WebFetch` | Ruft Inhalte von einer angegebenen URL ab. Siehe [WebFetch-Werkzeugverhalten](#webfetch-tool-behavior) | Ja |
| `WebSearch` | Führt Web-Suchen durch. Siehe [WebSearch-Werkzeugverhalten](#websearch-tool-behavior) | Ja |
| `Workflow` | Führt einen [dynamischen Workflow](/de/workflows) aus: ein Skript, das viele Subagenten im Hintergrund orchestriert und ein konsolidiertes Ergebnis zurückgibt | Ja |
| `Write` | Erstellt oder überschreibt Dateien. Siehe [Write-Werkzeugverhalten](#write-tool-behavior) | Ja |
Größtenteils entscheidet Fuxi, wann diese Werkzeuge verwendet werden sollen, und Sie müssen sie nicht selbst benennen, wenn Sie mit Fuxi interagieren. Sie verweisen direkt auf Werkzeugnamen, wenn Sie Berechtigungen und andere Konfigurationen definieren:
* in [`permissions.allow` und `permissions.deny`](/de/settings#available-settings) in den Einstellungen und der `/permissions`-Schnittstelle
* in den [CLI-Flags](/de/cli-reference) `--allowedTools` und `--disallowedTools`
* in den Optionen [`allowedTools` und `disallowedTools`](/de/agent-sdk/permissions#allow-and-deny-rules) des Agent SDK
* in einem [Subagenten-`tools` oder `disallowedTools`](/de/sub-agents#supported-frontmatter-fields)-Frontmatter
* in einem [Skill-`allowed-tools`](/de/skills#frontmatter-reference)-Frontmatter
* in der [`if`-Bedingung](/de/hooks-guide#filter-by-tool-name-and-arguments-with-the-if-field) eines Hooks
Alle diese akzeptieren das gleiche Regelformat, `ToolName(specifier)`. Der Specifier hängt vom Werkzeug ab, und mehrere Werkzeuge teilen ein Format:
| Regelformat | Gilt für | Details |
| :----------------------------- | :------------------------ | :------------------------------------------------------------------------ |
| `Bash(npm run *)` | Bash, Monitor | [Befehlsmuster-Matching](/de/permissions#bash) |
| `PowerShell(Get-ChildItem *)` | PowerShell | [Befehlsmuster-Matching](/de/permissions#powershell) |
| `Read(~/secrets/**)` | Read, Grep, Glob, LSP | [Pfadmuster-Matching](/de/permissions#read-and-edit) |
| `Edit(/src/**)` | Edit, Write, NotebookEdit | [Pfadmuster-Matching](/de/permissions#read-and-edit) |
| `Skill(deploy *)` | Skill | [Skill-Namen-Matching](/de/skills#restrict-fuxi%E2%80%99s-skill-access) |
| `Agent(Explore)` | Agent | [Subagenten-Typ-Matching](/de/permissions#agent-subagents) |
| `WebFetch(domain:example.com)` | WebFetch | [Domain-Matching](/de/permissions#webfetch) |
| `WebSearch` | WebSearch | Kein Specifier; Werkzeug als Ganzes zulassen oder ablehnen |
Werkzeuge, die hier nicht aufgelistet sind, wie `ExitPlanMode` oder `ShareOnboardingGuide`, akzeptieren nur den bloßen Werkzeugnamen ohne Specifier.
Eine `Edit(...)`-Zulassungsregel gewährt auch Lesezugriff auf denselben Pfad, daher benötigen Sie keine entsprechende `Read(...)`-Regel.
Hook-`matcher`-Felder verwenden bloße Werkzeugnamen, nicht das geklammerte Regelformat. Siehe [Matcher-Muster](/de/hooks#matcher-patterns) für die Matching-Regeln. Für die Feldnamen, die jedes Werkzeug an `tool_input` in Hooks übergibt, siehe die [PreToolUse-Eingabereferenz](/de/hooks#pretooluse-input).
Das Agent-Werkzeug erzeugt einen Subagenten in einem separaten Kontextfenster. Der Subagent arbeitet seine Aufgabe autonom durch und gibt dann ein einzelnes Textergebnis an das übergeordnete Gespräch zurück. Das übergeordnete Gespräch sieht nicht die Zwischenwerkzeugaufrufe oder Ausgaben des Subagenten, sondern nur dieses Endergebnis.
Um zu begrenzen, wie viele Durchläufe ein Subagent ausführt, setzen Sie `maxTurns` in der [Subagenten-Definition](/de/sub-agents#supported-frontmatter-fields).
Das gleiche Agent-Werkzeug startet auch [verzweigte Subagenten](/de/sub-agents#fork-the-current-conversation), wenn der Fork-Modus aktiviert ist. Ein Fork erbt das vollständige übergeordnete Gespräch, anstatt neu zu beginnen, läuft immer im Hintergrund und zeigt dennoch Berechtigungsaufforderungen in Ihrem Terminal. Der Rest dieses Abschnitts beschreibt benannte Subagenten.
Welche Werkzeuge ein benannter Subagent verwenden kann, hängt von den Feldern `tools` und `disallowedTools` in der [Subagenten-Definition](/de/sub-agents) ab:
* **Keines der Felder gesetzt**: Der Subagent erbt jedes Werkzeug, das dem übergeordneten Agenten zur Verfügung steht.
* **Nur `tools`**: Der Subagent erhält nur die aufgelisteten Werkzeuge.
* **Nur `disallowedTools`**: Der Subagent erhält jedes übergeordnete Werkzeug außer den aufgelisteten.
* **Beide gesetzt**: `disallowedTools` hat Vorrang. Ein Werkzeug, das in beiden aufgelistet ist, wird entfernt.
Das Starten des Subagenten fordert nicht selbst zur Berechtigung auf. Fuxi Code überprüft die eigenen Werkzeugaufrufe des Subagenten während der Ausführung gegen Ihre Berechtigungsregeln.
{/* min-version: 2.1.198 */}Ab v2.1.198 werden Subagenten standardmäßig im Hintergrund ausgeführt; Fuxi führt einen im Vordergrund aus, wenn es das Ergebnis benötigt, bevor es fortfährt.
* **Vordergrund-Subagenten** zeigen die gleichen Berechtigungsaufforderungen, die Sie im Hauptgespräch sehen würden, in dem Moment, in dem jeder Werkzeugaufruf stattfindet.
* **Hintergrund-Subagenten** {/* min-version: 2.1.186 */}zeigen Berechtigungsaufforderungen in Ihrer Hauptsitzung ab v2.1.186. Die Aufforderung nennt, welcher Subagent fragt, und das Drücken von Esc lehnt diesen einen Werkzeugaufruf ab, ohne den Subagenten zu stoppen. Vor v2.1.186 lehnten Hintergrund-Subagenten automatisch jeden Werkzeugaufruf ab, der sonst eine Aufforderung auslösen würde, und setzten fort ohne dieses Werkzeug.
Um zu begrenzen, was ein Subagent in erster Linie erreichen kann, verengen Sie sein `tools`-Feld, lassen Sie Bash von der Liste weg oder setzen Sie Ablehnungsregeln in Ihren Einstellungen, wie in [Subagenten-Funktionen steuern](/de/sub-agents#control-subagent-capabilities) beschrieben. Weitere Informationen zur Wahl zwischen Vordergrund und Hintergrund finden Sie unter [Subagenten im Vordergrund oder Hintergrund ausführen](/de/sub-agents#run-subagents-in-foreground-or-background).
Das Bash-Werkzeug führt jeden Befehl in einem separaten Prozess mit folgendem Persistenzverhalten aus:
* Wenn Fuxi `cd` in der Hauptsitzung ausführt, wird das neue Arbeitsverzeichnis zu späteren Bash-Befehlen übertragen, solange es sich im Projektverzeichnis oder einem [zusätzlichen Arbeitsverzeichnis](/de/permissions#working-directories) befindet, das Sie mit `--add-dir`, `/add-dir` oder `additionalDirectories` in den Einstellungen hinzugefügt haben. Subagent-Sitzungen übertragen niemals Arbeitsverzeichnisänderungen.
* Wenn `cd` außerhalb dieser Verzeichnisse landet, setzt Fuxi Code auf das Projektverzeichnis zurück und fügt `Shell cwd was reset to ` zum Werkzeugergebnis hinzu.
* Um diese Übertragung zu deaktivieren, damit jeder Bash-Befehl im Projektverzeichnis startet, setzen Sie `FUXI_BASH_MAINTAIN_PROJECT_WORKING_DIR=1`.
* Umgebungsvariablen bleiben nicht erhalten. Ein `export` in einem Befehl ist im nächsten nicht verfügbar.
* Aliase und Shell-Funktionen, die in Ihrer Shell-Startdatei definiert sind, sind verfügbar. Beim Sitzungsstart sourced Fuxi Code `~/.zshrc`, `~/.bashrc` oder `~/.profile` je nach Ihrer Shell, erfasst die resultierenden Aliase, Funktionen und Shell-Optionen und wendet sie auf jeden Bash-Befehl an.
Aktivieren Sie Ihre virtualenv- oder Conda-Umgebung, bevor Sie Fuxi Code starten. Um Umgebungsvariablen über Bash-Befehle hinweg persistent zu machen, setzen Sie [`FUXI_ENV_FILE`](/de/env-vars) auf ein Shell-Skript, bevor Sie Fuxi Code starten, oder verwenden Sie einen [SessionStart-Hook](/de/hooks#persist-environment-variables), um ihn dynamisch zu füllen.
Zwei Grenzen begrenzen jeden Befehl:
* **Timeout**: Standardmäßig zwei Minuten. Fuxi kann bis zu 10 Minuten pro Befehl mit dem `timeout`-Parameter anfordern. Überschreiben Sie den Standard und die Obergrenze mit [`BASH_DEFAULT_TIMEOUT_MS` und `BASH_MAX_TIMEOUT_MS`](/de/env-vars).
* **Ausgabelänge**: Standardmäßig 30.000 Zeichen. Wenn ein Befehl mehr als das produziert, speichert Fuxi Code die vollständige Ausgabe in einer Datei im Sitzungsverzeichnis und gibt Fuxi den Dateipfad plus eine kurze Vorschau vom Anfang. Fuxi liest oder durchsucht diese Datei, wenn er den Rest benötigt. Erhöhen Sie das Limit mit [`BASH_MAX_OUTPUT_LENGTH`](/de/env-vars), bis zu einer harten Obergrenze von 150.000 Zeichen.
Für langfristige Prozesse wie Dev-Server oder Watch-Builds kann Fuxi `run_in_background: true` setzen, um den Befehl als Hintergrundaufgabe zu starten und weiter zu arbeiten, während er läuft. Listen Sie Hintergrundaufgaben auf und beenden Sie sie mit `/tasks`.
Das Edit-Werkzeug führt exakte Zeichenkettenersetzung durch. Es nimmt einen `old_string` und einen `new_string` und ersetzt den ersten mit dem zweiten. Es verwendet keine Regex oder Fuzzy-Matching.
Drei Überprüfungen müssen bestanden werden, damit eine Bearbeitung angewendet wird:
* **Lesen vor Bearbeitung**: Fuxi muss die Datei im aktuellen Gespräch gelesen haben, und die Datei darf sich auf der Festplatte nicht geändert haben, seit sie gelesen wurde. Diese Überprüfung läuft zuerst, vor jedem Zeichenkettenabgleich.
* **Abgleich**: `old_string` muss in der Datei genau wie geschrieben vorkommen. Ein einzelnes Zeichen Unterschied in Leerzeichen oder Einrückung reicht aus, um zu verfehlen.
* **Eindeutigkeit**: `old_string` muss genau einmal vorkommen. Wenn es mehr als einmal vorkommt, liefert Fuxi entweder eine längere Zeichenkette mit ausreichend umgebendem Kontext, um ein Vorkommen festzulegen, oder setzt `replace_all: true`, um alle zu ersetzen.
Das Anzeigen einer Datei mit Bash erfüllt auch die Anforderung zum Lesen vor Bearbeitung, wenn der Befehl `cat`, `head`, `tail`, `sed -n 'X,Yp'`, `grep`, `egrep` oder `fgrep` auf einer einzelnen Datei ohne Pipes oder Umleitungen ist. Gepipte Ausgabe und andere Bash-Befehle zählen nicht, und Fuxi muss in diesen Fällen Read vor der Bearbeitung verwenden.
Dies betrifft nur die Bearbeitungsberechtigung, nicht die Berechtigungen. [Read- und Edit-Ablehnungsregeln](/de/permissions#tool-specific-permission-rules) gelten auch für Dateibefehle, die Fuxi Code in Bash erkennt, wie `cat`, `head`, `tail`, `sed` und `grep`, aber nicht für beliebige Unterprozesse, die Dateien indirekt lesen oder schreiben, wie ein Python- oder Node-Skript, das Dateien selbst öffnet. Der Satz von Befehlen, die für Ablehnungsregeln erkannt werden, ist nicht derselbe wie die obige Liste zum Lesen vor Bearbeitung: Beispielsweise zählen `egrep` und `fgrep` für Lesen vor Bearbeitung, werden aber nicht gegen Read-Ablehnungsregeln überprüft. Für OS-Ebenen-Durchsetzung, die jeden Prozess abdeckt, [aktivieren Sie die Sandbox](/de/sandboxing).
Das Glob-Werkzeug findet Dateien nach Namensmuster. Es unterstützt Standard-Glob-Syntax einschließlich `**` für rekursives Verzeichnis-Matching:
* `**/*.js` passt alle `.js`-Dateien in beliebiger Tiefe
* `src/**/*.ts` passt alle `.ts`-Dateien unter `src/`
* `*.{json,yaml}` passt `.json`- und `.yaml`-Dateien im aktuellen Verzeichnis
Ergebnisse werden nach Änderungszeit sortiert und auf 100 Dateien begrenzt. Wenn die Obergrenze erreicht wird, sieht Fuxi ein Kürzungsflag im Ergebnis und kann das Muster verengen.
Glob respektiert `.gitignore` standardmäßig nicht, daher findet es gitignorierte Dateien neben verfolgten. Dies unterscheidet sich von [Grep](#grep-tool-behavior), das gitignorierte Dateien überspringt. Um Glob `.gitignore` respektieren zu lassen, setzen Sie `FUXI_CODE_GLOB_NO_IGNORE=false`, bevor Sie Fuxi Code starten.
Das Grep-Werkzeug durchsucht Dateiinhalte nach Mustern. Während [Glob](#glob-tool-behavior) Dateien nach Namen findet, findet Grep Zeilen in ihnen.
Grep basiert auf [ripgrep](https://github.com/BurntSushi/ripgrep) und verwendet ripgreps Regex-Syntax, nicht POSIX-Grep. Muster, die Regex-Metazeichen enthalten, müssen maskiert werden. Zum Beispiel erfordert das Finden von `interface{}` in Go-Code das Muster `interface\{\}`.
Drei Ausgabemodi steuern, was zurückkommt:
* `files_with_matches`: nur Dateipfade, kein Zeileninhalt. Dies ist die Standardeinstellung.
* `content`: übereinstimmende Zeilen mit Datei und Zeilennummer.
* `count`: Übereinstimmungsanzahl pro Datei.
Fuxi kann Ergebnisse nach Datei mit dem `glob`-Parameter wie `**/*.tsx` oder nach Sprache mit dem `type`-Parameter wie `py` oder `rust` eingrenzen. Standardmäßig passen Muster innerhalb einer einzelnen Zeile. Fuxi kann `multiline: true` setzen, um über Zeilengrenzen hinweg zu passen.
Grep respektiert `.gitignore`, daher werden gitignorierte Dateien übersprungen. Um eine gitignorierte Datei zu durchsuchen, übergibt Fuxi ihren Pfad direkt.
Das LSP-Werkzeug gibt Fuxi Code-Intelligenz von einem laufenden Sprachserver. Nach jeder Dateiänderung meldet es automatisch Typfehler und Warnungen, damit Fuxi Probleme ohne einen separaten Build-Schritt beheben kann. Fuxi kann es auch direkt aufrufen, um Code zu navigieren:
* Sprung zu einer Symbol-Definition
* Suche nach allen Referenzen zu einem Symbol
* Typinformationen an einer Position abrufen
* Symbole in einer Datei auflisten
* Suche nach einem Symbol nach Name im gesamten Workspace
* Implementierungen einer Schnittstelle finden
* Aufrufen-Hierarchien verfolgen
Das Werkzeug ist inaktiv, bis Sie ein [Code-Intelligence-Plugin](/de/discover-plugins#code-intelligence) für Ihre Sprache installieren. Das Plugin bündelt die Sprachserver-Konfiguration, und Sie installieren die Server-Binärdatei separat.
Das Monitor-Werkzeug ermöglicht es Fuxi, etwas im Hintergrund zu beobachten und zu reagieren, wenn es sich ändert, ohne das Gespräch zu unterbrechen. Bitten Sie Fuxi:
* Eine Protokolldatei zu verfolgen und Fehler zu kennzeichnen, wenn sie erscheinen
* Eine PR oder CI-Job abzufragen und zu melden, wenn sich ihr Status ändert
* Ein Verzeichnis auf Dateiänderungen zu überwachen
* Ausgabe von einem beliebigen langfristigen Skript zu verfolgen, auf das Sie es hinweisen
* Eine Verbindung zu einem WebSocket-Feed herzustellen und jede Nachricht zu melden, wenn sie ankommt
Für die meisten Überwachungen schreibt Fuxi ein kleines Skript, führt es im Hintergrund aus und empfängt jede Ausgabezeile, wenn sie ankommt. Für einen Server, der bereits Ereignisse pusht, kann Fuxi stattdessen eine [WebSocket](#websocket-source) öffnen, anstatt ein Skript auszuführen.
Sie arbeiten weiter in der gleichen Sitzung und Fuxi interveniert, wenn ein Ereignis eintritt. Beenden Sie eine Überwachung, indem Sie Fuxi auffordern, sie zu stornieren, oder indem Sie die Sitzung beenden.
Wenn Monitor einen Befehl ausführt, verwendet es die gleichen [Berechtigungsregeln wie Bash](/de/permissions#tool-specific-permission-rules), daher gelten `allow`- und `deny`-Muster, die Sie für Bash festgelegt haben, auch hier. Die [WebSocket-Quelle](#websocket-source) hat ihre eigene Genehmigungsaufforderung.
Das Werkzeug ist nicht auf Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry verfügbar. Es ist auch nicht verfügbar, wenn `DISABLE_TELEMETRY` oder `FUXI_CODE_DISABLE_NONESSENTIAL_TRAFFIC` gesetzt ist.
Plugins können Monitore deklarieren, die automatisch starten, wenn das Plugin aktiv ist, anstatt Fuxi zu bitten, sie zu starten. Siehe [Plugin-Monitore](/de/plugins-reference#monitors).
WebSocket-Quelle
Die WebSocket-Quelle erfordert Fuxi Code v2.1.195 oder später.
Wenn ein Server bereits Ereignisse über eine WebSocket pusht, kann Fuxi sich direkt damit verbinden, anstatt ein Abfrageskript zu schreiben. Jede Art von Socket-Aktivität wird entweder zu einem Ereignis oder beendet die Überwachung:
* **Textnachrichten**: jede wird zu einem Ereignis, auch wenn die Nachricht mehrere Zeilen umfasst.
* **Binärnachrichten**: werden nicht weitergeleitet. Fuxi empfängt stattdessen eine Platzhalterzeile wie `[binary frame, 512 bytes]`.
* **Nachrichten größer als 1 MiB**: die Überwachung endet, daher abonnieren Sie einen gefilterten Feed, falls vorhanden.
* **Socket-Schließung**: die Überwachung endet und Fuxi empfängt den Schließungscode.
Eine WebSocket-Überwachung nimmt eine `ws`-Eingabe anstelle von `command` und ein einzelner Monitor-Aufruf kann die beiden nicht kombinieren. Die `ws`-Eingabe hat zwei Felder:
| Feld | Erforderlich | Beschreibung |
| :---------- | :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url` | Ja | Der Endpunkt zum Verbinden. Muss eine `ws://`- oder `wss://`-URL ohne eingebettete Anmeldedaten oder Leerzeichen sein, nur ASCII-Zeichen verwenden |
| `protocols` | Nein | WebSocket-Subprotokollnamen, die während des Handshake angeboten werden. Jeder Eintrag muss ein gültiges Subprotokoll-Token sein, und die Liste darf keine Duplikate enthalten |
Die Eingaben `timeout_ms` und `persistent` verhalten sich gleich wie bei einem Befehl: die Überwachung endet bei der Frist, es sei denn, `persistent` ist gesetzt, und `TaskStop` bricht sie früh ab.
Das Öffnen einer WebSocket fordert zur Genehmigung auf, und die Aufforderung bietet keine Option, zukünftige Aufforderungen für denselben Host zu überspringen.
Fuxi Code lehnt URLs ab, die auf eine private, Link-Local- oder Cloud-Metadaten-Adresse verweisen, einschließlich Hostnamen, die zu einer aufgelöst werden. Es lehnt auch Hosts in `sandbox.network.deniedDomains` ab, und wenn [`allowManagedDomainsOnly`](/de/settings#sandbox-settings) in verwalteten Einstellungen gesetzt ist, jeden Host außerhalb der verwalteten Zulassungsliste.
NotebookEdit ändert ein Jupyter-Notebook eine Zelle nach der anderen, indem es Zellen nach ihrer `cell_id` anvisiert. Es führt keine Zeichenkettenersetzung über das Notebook durch wie [Edit](#edit-tool-behavior) auf einfachen Dateien.
Drei Bearbeitungsmodi steuern, was mit der Zielzelle geschieht:
* `replace`: Überschreiben Sie die Quelle der Zelle. Dies ist die Standardeinstellung.
* `insert`: Fügen Sie eine neue Zelle nach der Zielzelle hinzu. Ohne `cell_id` geht die neue Zelle an den Anfang des Notebooks. Erfordert `cell_type` auf `code` oder `markdown` gesetzt.
* `delete`: Entfernen Sie die Zielzelle.
Berechtigungsregeln verwenden das `Edit(...)`-Pfadformat. Eine Regel wie `Edit(notebooks/**)` deckt NotebookEdit-Aufrufe auf Dateien in diesem Verzeichnis ab.
Das PowerShell-Werkzeug ermöglicht es Fuxi, PowerShell-Befehle nativ auszuführen. Unter Windows bedeutet dies, dass Befehle in PowerShell ausgeführt werden, anstatt sie über Git Bash zu leiten. Wie das Werkzeug verfügbar wird, hängt von Ihrer Plattform ab:
* **Windows ohne Git Bash**: Das Werkzeug ist automatisch aktiviert.
* **Windows mit installiertem Git Bash**: Das Werkzeug wird schrittweise eingeführt.
* **Linux, macOS und WSL**: Das Werkzeug ist optional.
Setzen Sie `FUXI_CODE_USE_POWERSHELL_TOOL=1` in Ihrer Umgebung oder in `settings.json`:
```json theme={null}
{
"env": {
"FUXI_CODE_USE_POWERSHELL_TOOL": "1"
}
}
```
Unter Windows setzen Sie die Variable auf `0`, um sich von der Einführung abzumelden. Unter Linux, macOS und WSL erfordert das Werkzeug PowerShell 7 oder später: Installieren Sie `pwsh` und stellen Sie sicher, dass es sich auf Ihrem `PATH` befindet.
Unter Windows erkennt Fuxi Code `pwsh.exe` für PowerShell 7+ automatisch mit einem Fallback auf `powershell.exe` für PowerShell 5.1. Wenn das Werkzeug aktiviert ist, behandelt Fuxi PowerShell als die primäre Shell. Das Bash-Werkzeug bleibt für POSIX-Skripte verfügbar, wenn Git Bash installiert ist.
Fuxi Code startet PowerShell mit `-ExecutionPolicy Bypass` nur im Prozessbereich, sodass `.ps1`-Skripte und Modulimporte auf Standard-Windows-Installationen funktionieren, ohne die Richtlinie des Computers zu ändern. Der Prozessbereich-Bypass überschreibt nicht die Gruppenrichtlinie `MachinePolicy` oder `UserPolicy`, daher gelten Unternehmensrichtlinien weiterhin. Um stattdessen die effektive Ausführungsrichtlinie des Computers zu respektieren, setzen Sie `FUXI_CODE_POWERSHELL_RESPECT_EXECUTION_POLICY=1`.
Shell-Auswahl in Einstellungen, Hooks und Skills
Drei zusätzliche Einstellungen steuern, wo PowerShell verwendet wird:
* `"defaultShell": "powershell"` in [`settings.json`](/de/settings#available-settings): leitet interaktive `!`-Befehle durch PowerShell. Erfordert, dass das PowerShell-Werkzeug aktiviert ist.
* `"shell": "powershell"` auf einzelnen [Command-Hooks](/de/hooks#command-hook-fields): führt diesen Hook in PowerShell aus. Hooks starten PowerShell direkt, daher funktioniert dies unabhängig von `FUXI_CODE_USE_POWERSHELL_TOOL`.
* `shell: powershell` in [Skill-Frontmatter](/de/skills#frontmatter-reference): führt `` !`command` ``-Blöcke in PowerShell aus. Erfordert, dass das PowerShell-Werkzeug aktiviert ist.
Das gleiche Verhalten zum Zurücksetzen des Arbeitsverzeichnisses in der Hauptsitzung, das im Abschnitt zum Bash-Werkzeug beschrieben ist, gilt für PowerShell-Befehle, einschließlich der Umgebungsvariable `FUXI_BASH_MAINTAIN_PROJECT_WORKING_DIR`.
{/* min-version: 2.1.196 */}Ab v2.1.196 entspricht das PowerShell-Werkzeug der Behandlung von Such- und Diff-Exit-Codes durch das Bash-Werkzeug. Exit-Code 1 von `grep`, `egrep`, `fgrep` und `git grep` bedeutet keine Übereinstimmungen, und Exit-Code 1 von `git diff` bedeutet, dass Unterschiede vorhanden sind, daher werden diese Ergebnisse Fuxi nicht als Befehlsfehler gemeldet.
Vorschau-Einschränkungen
Das PowerShell-Werkzeug hat während der Vorschau die folgenden bekannten Einschränkungen:
* PowerShell-Profile werden nicht geladen
* Unter Windows wird Sandboxing nicht unterstützt
Das Read-Werkzeug nimmt einen Dateipfad und gibt den Inhalt mit Zeilennummern zurück. Fuxi wird angewiesen, immer absolute Pfade zu übergeben.
Standardmäßig gibt Read die Datei vom Anfang zurück. Wenn ein Ganz-Datei-Lesevorgang das Token-Limit überschreitet, gibt Read die erste Seite mit einer `PARTIAL view`-Benachrichtigung zurück, die Fuxi mitteilt, wie viel der Datei er erhalten hat und wie er mit `offset` und `limit` mehr lesen kann. Ein Lesevorgang, der einen expliziten `offset` oder `limit` übergibt und immer noch das Token-Limit überschreitet, gibt einen Fehler zurück.
Read verarbeitet mehrere Dateitypen über einfachen Text hinaus:
* **Bilder**: PNG, JPG und andere Bildformate werden als visueller Inhalt zurückgegeben, den Fuxi sehen kann, nicht als Rohbytes. Fuxi Code ändert die Größe großer Bilder und komprimiert sie neu, um sie in die Bildgrößenlimits des Modells zu passen, bevor sie gesendet werden, daher kann Fuxi eine herunterskalierte Version eines großen Screenshots sehen. {/* min-version: 2.1.196 */}Ab v2.1.196 wird ein Bild, das nach dieser Größenänderung immer noch größer als 500 KB ist, als JPEG mit reduzierter Qualität neu codiert, wobei seine Pixeldimensionen unverändert bleiben. Wenn Fuxi feines Pixel-Level-Detail in einem großen Bild vermisst, bitten Sie es, die Region von Interesse zuerst zuzuschneiden, zum Beispiel mit ImageMagick über Bash.
* **PDFs**: Fuxi liest kurze `.pdf`-Dateien ganz. Für PDFs länger als 10 Seiten liest es in Bereichen mit einem `pages`-Parameter wie `"1-5"` bis zu 20 Seiten auf einmal.
* **Jupyter-Notebooks**: `.ipynb`-Dateien geben alle Zellen mit ihren Ausgaben zurück, einschließlich Code, Markdown und Visualisierungen.
Read liest nur Dateien, keine Verzeichnisse. Fuxi verwendet `ls` über das Bash-Werkzeug, um Verzeichnisinhalte aufzulisten.
WebFetch nimmt eine URL und eine Eingabeaufforderung, die beschreibt, was extrahiert werden soll. Es ruft die Seite ab, konvertiert die Antwort in Markdown, wenn der Server HTML zurückgibt, und führt die Eingabeaufforderung gegen den Inhalt mit einem kleinen, schnellen Modell aus. Für die meisten Abrufe erhält Fuxi die Antwort dieses Modells, nicht die Rohseite. Der Konvertierungsschritt ist nicht konfigurierbar.
Dies macht WebFetch absichtlich verlustbehaftet. Die Extraktions-Eingabeaufforderung bestimmt, was Fuxi erreicht, daher kann ein Ergebnis, das besagt, dass eine Seite etwas nicht erwähnt, nur bedeuten, dass die Eingabeaufforderung nicht danach gefragt hat. Bitten Sie Fuxi, erneut mit einer spezifischeren Eingabeaufforderung abzurufen, oder verwenden Sie `curl` über Bash für die unverarbeitete Seite.
Einige Verhaltensweisen prägen die Antwort, die Fuxi erhält:
* HTTP-URLs werden automatisch auf HTTPS aktualisiert.
* Große Seiten werden auf ein festes Zeichenlimit gekürzt, bevor sie verarbeitet werden.
* Antworten werden 15 Minuten lang zwischengespeichert, daher geben wiederholte Abrufe derselben URL schnell zurück.
* Wenn eine URL zu einem anderen Host umleitet, gibt WebFetch ein Textergebnis zurück, das die ursprüngliche URL und das Umleitungsziel benennt, anstatt es zu folgen. Fuxi ruft dann die neue URL mit einem zweiten WebFetch-Aufruf ab.
In den Standard- und `acceptEdits`-Berechtigungsmodi fordert WebFetch das erste Mal auf, wenn es eine neue Domain erreicht, mit Ausnahme einer integrierten Gruppe von vorab genehmigten Dokumentationsdomains, die ohne Aufforderung abgerufen werden. Um eine andere Domain im Voraus ohne Aufforderung zuzulassen, fügen Sie eine Berechtigungsregel wie `WebFetch(domain:example.com)` hinzu. Die `auto`- und `bypassPermissions`-[Berechtigungsmodi](/de/permissions#permission-modes) überspringen die Aufforderung vollständig.
Eine explizite `WebFetch(domain:...)`-Regel in `deny`, `ask` oder `allow` hat Vorrang vor der vorab genehmigten Gruppe, sodass Sie eine vorab genehmigte Domain blockieren oder eine Aufforderung dafür verlangen können.
WebFetch setzt einen `User-Agent`-Header, der mit `Fuxi-User` beginnt, und einen `Accept`-Header, der Markdown gegenüber HTML bevorzugt, damit Server, die Content-Negotiation unterstützen, Markdown direkt zurückgeben können.
Sie konfigurieren [Sandbox](/de/sandboxing)-Netzwerkregeln separat, daher benötigt eine Domain, die ein Sandbox-Prozess erreichen soll, immer noch eine explizite Sandbox-Berechtigungsregel.
WebSearch führt eine Abfrage gegen Anthropics [Web-Suche](https://platform.fuxi.com/docs/de/agents-and-tools/tool-use/web-search-tool)-Backend aus und gibt Ergebnistitel und URLs zurück. Es ruft die Ergebnisseiten nicht ab. Um eine Seite zu lesen, die Fuxi in Suchergebnissen findet, folgt es mit [WebFetch](#webfetch-tool-behavior) auf.
Das Werkzeug kann bis zu acht Backend-Suchen pro Aufruf durchführen und die Suche intern verfeinern, bevor Ergebnisse zurückgegeben werden. Fuxi kann Ergebnisse mit `allowed_domains` eingrenzen, um nur bestimmte Hosts einzuschließen, oder `blocked_domains`, um sie auszuschließen. Die beiden Listen können nicht in einem einzelnen Aufruf kombiniert werden.
Das Such-Backend ist nicht konfigurierbar. Um mit einem anderen Anbieter zu suchen, fügen Sie einen [MCP-Server](/de/mcp) hinzu, der ein Such-Werkzeug bereitstellt.
WebSearch-Berechtigungsregeln nehmen keinen Specifier. Ein bloßer `WebSearch`-Eintrag in `allow` oder `deny` ist die einzige Form.
WebSearch ist auf der Fuxi API, [Fuxi Platform on AWS](/de/fuxi-platform-on-aws) und Microsoft Foundry verfügbar. Auf Google Cloud's Agent Platform funktioniert es mit Fuxi 4 und späteren Modellen, einschließlich Opus, Sonnet und Haiku. Amazon Bedrock stellt das serverseitige Web-Such-Werkzeug nicht bereit.
Das Write-Werkzeug erstellt eine neue Datei oder überschreibt eine vorhandene mit dem vollständigen bereitgestellten Inhalt. Es fügt nicht an oder führt zusammen.
Wenn der Zielpfad bereits existiert, muss Fuxi diese Datei mindestens einmal im aktuellen Gespräch gelesen haben, bevor er sie überschreibt. Ein Write zu einer ungelesenen vorhandenen Datei schlägt mit einem Fehler fehl. Diese Einschränkung gilt nicht für neue Dateien.
Das Anzeigen der Datei mit Bash erfüllt auch diese Anforderung unter den gleichen Regeln, die in [Edit-Werkzeugverhalten](#edit-tool-behavior) beschrieben sind.
Für teilweise Änderungen an einer vorhandenen Datei verwendet Fuxi Edit anstelle von Write.
Ihr genaues Werkzeugsatz hängt von Ihrem Anbieter, Ihrer Plattform und Ihren Einstellungen ab. Um zu überprüfen, was in einer laufenden Sitzung geladen ist, fragen Sie Fuxi direkt:
```text theme={null}
What tools do you have access to?
```
Fuxi gibt eine Zusammenfassung im Gesprächsstil. Für genaue MCP-Werkzeugnamen führen Sie `/mcp` aus.
Das [Advisor-Tool](/de/advisor) ist ein [Server-Tool](https://platform.fuxi.com/docs/en/agents-and-tools/tool-use/advisor-tool), das die API ausführt, anstatt ein Tool, das Fuxi Code implementiert. Es hat keinen Namen, auf den Sie in Berechtigungsregeln oder Hook-Matchern verweisen können.
Siehe auch
* [MCP-Server](/de/mcp): Fügen Sie benutzerdefinierte Werkzeuge durch Verbindung externer Server hinzu
* [Berechtigungen](/de/permissions): Berechtigungssystem, Regelsyntax und werkzeugspezifische Muster
* [Subagents](/de/sub-agents): Konfigurieren Sie Werkzeugzugriff für Subagents
* [Hooks](/de/hooks-guide): Führen Sie benutzerdefinierte Befehle vor oder nach der Werkzeugausführung aus