Genehmigungen und Benutzereingaben verarbeiten

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

Wä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.

Claude 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.

Bei 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.

Der 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, geben Sie die defer-Hook-Entscheidung zurück, mit der der Prozess beendet und später aus der persistierten Sitzung fortgesetzt werden kann.

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

Erkennen Sie, wenn Claude Eingaben benötigt

Ü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:

async def handle_tool_request(tool_name, input_data, context):
# Benutzer auffordern und Zulassung oder Ablehnung zurückgeben
...


options = ClaudeAgentOptions(can_use_tool=handle_tool_request)

async function handleToolRequest(toolName, input, options) {
// options includes { signal: AbortSignal, suggestions?: PermissionUpdate[] }
// Benutzer auffordern und Zulassung oder Ablehnung zurückgeben
}

const options = { canUseTool: handleToolRequest };

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

1. Tool benötigt Genehmigung: Claude möchte ein Tool verwenden, das nicht durch Berechtigungsregeln oder Modi automatisch genehmigt wird. Überprüfen Sie tool_name auf das Tool (z. B. "Bash", "Write").
2. 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 für Details.

Tool-Genehmigungsanfragen verarbeiten

Nachdem 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:

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

Siehe die SDK-Referenz für vollständige Eingabeschemas: Python | TypeScript.

Sie 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.

Das 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.

import asyncio

from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
from claude_agent_sdk.types import (
HookMatcher,
PermissionResultAllow,
PermissionResultDeny,
ToolPermissionContext,
)


async def can_use_tool(
tool_name: str, input_data: dict, context: ToolPermissionContext
) -> PermissionResultAllow | PermissionResultDeny:
# Tool-Anfrage anzeigen
print(f"\nTool: {tool_name}")
if tool_name == "Bash":
print(f"Command: {input_data.get('command')}")
if input_data.get("description"):
print(f"Description: {input_data.get('description')}")
else:
print(f"Input: {input_data}")

# Benutzergenehmigung abrufen
response = input("Allow this action? (y/n): ")

# Zulassung oder Ablehnung basierend auf der Antwort des Benutzers zurückgeben
if response.lower() == "y":
# Zulassen: Tool wird mit der ursprünglichen (oder geänderten) Eingabe ausgeführt
return PermissionResultAllow(updated_input=input_data)
else:
# Ablehnen: Tool wird nicht ausgeführt, Claude sieht die Nachricht
return PermissionResultDeny(message="User denied this action")


# Erforderliche Umgehung: Dummy-Hook hält den Stream für can_use_tool offen
async def dummy_hook(input_data, tool_use_id, context):
return {"continue_": True}


async def prompt_stream():
yield {
"type": "user",
"message": {
"role": "user",
"content": "Create a test file in /tmp and then delete it",
},
}


async def main():
async for message in query(
prompt=prompt_stream(),
options=ClaudeAgentOptions(
can_use_tool=can_use_tool,
hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},
),
):
if isinstance(message, ResultMessage) and message.subtype == "success":
print(message.result)


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";
import * as readline from "readline";

// Hilfsfunktion zum Auffordern von Benutzereingaben im Terminal
function prompt(question: string): Promise<string> {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
return new Promise((resolve) =>
rl.question(question, (answer) => {
rl.close();
resolve(answer);
})
);
}

for await (const message of query({
prompt: "Create a test file in /tmp and then delete it",
options: {
canUseTool: async (toolName, input) => {
// Tool-Anfrage anzeigen
console.log(`\nTool: ${toolName}`);
if (toolName === "Bash") {
console.log(`Command: ${input.command}`);
if (input.description) console.log(`Description: ${input.description}`);
} else {
console.log(`Input: ${JSON.stringify(input, null, 2)}`);
}

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

// Zulassung oder Ablehnung basierend auf der Antwort des Benutzers zurückgeben
if (response.toLowerCase() === "y") {
// Zulassen: Tool wird mit der ursprünglichen (oder geänderten) Eingabe ausgeführt
return { behavior: "allow", updatedInput: input };
} else {
// Ablehnen: Tool wird nicht ausgeführt, Claude sieht die Nachricht
return { behavior: "deny", message: "User denied this action" };
}
}
}
})) {
if ("result" in message) console.log(message.result);
}

Dieses 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 für alle Möglichkeiten, wie Sie reagieren können.

Auf Tool-Anfragen reagieren

Ihr Callback gibt einen von zwei Antworttypen zurück:

Beim 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.

from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

# Tool-Ausführung zulassen
return PermissionResultAllow(updated_input=input_data)

# Tool blockieren
return PermissionResultDeny(message="User rejected this action")

// Tool-Ausführung zulassen
return { behavior: "allow", updatedInput: input };

// Tool blockieren
return { behavior: "deny", message: "User rejected this action" };

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

• Genehmigen: Lassen Sie das Tool genau wie von Claude angefordert ausführen
• Mit Änderungen genehmigen: Ändern Sie die Eingabe vor der Ausführung (z. B. Pfade bereinigen, Einschränkungen hinzufügen)
• Genehmigen und merken: Geben Sie eine vorgeschlagene Berechtigungsregel zurück, damit übereinstimmende Aufrufe das nächste Mal die Aufforderung überspringen
• Ablehnen: Blockieren Sie das Tool und teilen Sie Claude mit, warum
• Alternative vorschlagen: Blockieren Sie, aber leiten Sie Claude zu dem hin, was der Benutzer stattdessen möchte
• Vollständig umleiten: Verwenden Sie Streaming-Eingabe, um Claude eine völlig neue Anweisung zu senden

async def can_use_tool(tool_name, input_data, context):
print(f"Claude wants to use {tool_name}")
approved = await ask_user("Allow this action?")

if approved:
return PermissionResultAllow(updated_input=input_data)
return PermissionResultDeny(message="User declined")

canUseTool: async (toolName, input) => {
console.log(`Claude wants to use ${toolName}`);
const approved = await askUser("Allow this action?");

if (approved) {
return { behavior: "allow", updatedInput: input };
}
return { behavior: "deny", message: "User declined" };
};

async def can_use_tool(tool_name, input_data, context):
if tool_name == "Bash":
# Benutzer genehmigt, aber alle Befehle auf Sandbox beschränken
sandboxed_input = {**input_data}
sandboxed_input["command"] = input_data["command"].replace(
"/tmp", "/tmp/sandbox"
)
return PermissionResultAllow(updated_input=sandboxed_input)
return PermissionResultAllow(updated_input=input_data)

canUseTool: async (toolName, input) => {
if (toolName === "Bash") {
// Benutzer genehmigt, aber alle Befehle auf Sandbox beschränken
const sandboxedInput = {
...input,
command: input.command.replace("/tmp", "/tmp/sandbox")
};
return { behavior: "allow", updatedInput: sandboxedInput };
}
return { behavior: "allow", updatedInput: input };
};

async def can_use_tool(tool_name, input_data, context):
choice = await ask_user(f"Allow {tool_name}?", ["once", "always", "no"])

if choice == "always":
persist = [
s for s in context.suggestions if s.destination == "localSettings"
]
return PermissionResultAllow(
updated_input=input_data, updated_permissions=persist
)
if choice == "once":
return PermissionResultAllow(updated_input=input_data)
return PermissionResultDeny(message="User declined")

canUseTool: async (toolName, input, { suggestions = [] }) => {
const choice = await askUser(`Allow ${toolName}?`, ["once", "always", "no"]);

if (choice === "always") {
const persist = suggestions.filter(
(s) => s.destination === "localSettings"
);
return {
behavior: "allow",
updatedInput: input,
updatedPermissions: persist
};
}
if (choice === "once") {
return { behavior: "allow", updatedInput: input };
}
return { behavior: "deny", message: "User declined" };
};

async def can_use_tool(tool_name, input_data, context):
approved = await ask_user(f"Allow {tool_name}?")

if not approved:
return PermissionResultDeny(message="User rejected this action")
return PermissionResultAllow(updated_input=input_data)

canUseTool: async (toolName, input) => {
const approved = await askUser(`Allow ${toolName}?`);

if (!approved) {
return {
behavior: "deny",
message: "User rejected this action"
};
}
return { behavior: "allow", updatedInput: input };
};

async def can_use_tool(tool_name, input_data, context):
if tool_name == "Bash" and "rm" in input_data.get("command", ""):
# Benutzer möchte nicht löschen, schlagen Sie stattdessen Archivierung vor
return PermissionResultDeny(
message="User doesn't want to delete files. They asked if you could compress them into an archive instead."
)
return PermissionResultAllow(updated_input=input_data)

canUseTool: async (toolName, input) => {
if (toolName === "Bash" && input.command.includes("rm")) {
// Benutzer möchte nicht löschen, schlagen Sie stattdessen Archivierung vor
return {
behavior: "deny",
message:
"User doesn't want to delete files. They asked if you could compress them into an archive instead."
};
}
return { behavior: "allow", updatedInput: input };
};

Klärungsfragen verarbeiten

Wenn 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.

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

async for message in query(
prompt="Analyze this codebase",
options=ClaudeAgentOptions(
# Fügen Sie AskUserQuestion in Ihre Tools-Liste ein
tools=["Read", "Glob", "Grep", "AskUserQuestion"],
can_use_tool=can_use_tool,
),
):
print(message)

for await (const message of query({
prompt: "Analyze this codebase",
options: {
// Fügen Sie AskUserQuestion in Ihre Tools-Liste ein
tools: ["Read", "Glob", "Grep", "AskUserQuestion"],
canUseTool: async (toolName, input) => {
// Klärungsfragen hier verarbeiten
}
}
})) {
console.log(message);
}

async def can_use_tool(tool_name: str, input_data: dict, context):
if tool_name == "AskUserQuestion":
# Ihre Implementierung zum Sammeln von Antworten vom Benutzer
return await handle_clarifying_questions(input_data)
# Andere Tools normal verarbeiten
return await prompt_for_approval(tool_name, input_data)

canUseTool: async (toolName, input) => {
if (toolName === "AskUserQuestion") {
// Ihre Implementierung zum Sammeln von Antworten vom Benutzer
return handleClarifyingQuestions(input);
}
// Andere Tools normal verarbeiten
return promptForApproval(toolName, input);
};

{
"questions": [
{
"question": "How should I format the output?",
"header": "Format",
"options": [
{ "label": "Summary", "description": "Brief overview" },
{ "label": "Detailed", "description": "Full explanation" }
],
"multiSelect": false
},
{
"question": "Which sections should I include?",
"header": "Sections",
"options": [
{ "label": "Introduction", "description": "Opening context" },
{ "label": "Conclusion", "description": "Final summary" }
],
"multiSelect": true
}
]
}

return PermissionResultAllow(
updated_input={
"questions": input_data.get("questions", []),
"answers": {
"How should I format the output?": "Summary",
"Which sections should I include?": ["Introduction", "Conclusion"],
},
}
)

return {
behavior: "allow",
updatedInput: {
questions: input.questions,
answers: {
"How should I format the output?": "Summary",
"Which sections should I include?": "Introduction, Conclusion"
}
}
};

Frageformat

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

Die Struktur, die Ihr Callback erhält:

{
  "questions": [
    {
      "question": "How should I format the output?",
      "header": "Format",
      "options": [
        { "label": "Summary", "description": "Brief overview of key points" },
        { "label": "Detailed", "description": "Full explanation with examples" }
      ],
      "multiSelect": false
    }
  ]
}

Optionsvorschau (TypeScript)

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.

Das 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.

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

for await (const message of query({
  prompt: "Help me choose a card layout",
  options: {
    toolConfig: {
      askUserQuestion: { previewFormat: "html" }
    },
    canUseTool: async (toolName, input) => {
      // input.questions[].options[].preview ist ein HTML-String oder undefined
      return { behavior: "allow", updatedInput: input };
    }
  }
})) {
  // ...
}

Eine Option mit HTML-Vorschau:

{
  "label": "Compact",
  "description": "Title and metric value only",
  "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>"
}

Antwortformat

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

Fü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.

{
  "questions": [
    // ...
  ],
  "answers": {
    "How should I format the output?": "Summary",
    "Which sections should I include?": ["Introduction", "Conclusion"]
  }
}

Unterstützen Sie freie Texteingabe

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

• Zeigen Sie nach Claudes Optionen eine zusätzliche "Other"-Auswahlmöglichkeit an, die Texteingabe akzeptiert
• Verwenden Sie den benutzerdefinierten Text des Benutzers als Antwortwert (nicht das Wort "Other")

Siehe das vollständige Beispiel unten für eine vollständige Implementierung.

Vollständiges Beispiel

Claude 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.

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

1. Leiten Sie die Anfrage weiter: Der canUseTool-Callback überprüft, ob der Tool-Name "AskUserQuestion" ist, und leitet zu einem dedizierten Handler weiter
2. Zeigen Sie Fragen an: Der Handler durchläuft das questions-Array und druckt jede Frage mit nummerierten Optionen
3. 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")
4. 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)
5. Geben Sie an Claude zurück: Die Antwort enthält sowohl das ursprüngliche questions-Array als auch die answers-Zuordnung

import asyncio

from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
from claude_agent_sdk.types import HookMatcher, PermissionResultAllow


def parse_response(response: str, options: list) -> str:
"""Analysieren Sie Benutzereingaben als Optionsnummer(n) oder freien Text."""
try:
indices = [int(s.strip()) - 1 for s in response.split(",")]
labels = [options[i]["label"] for i in indices if 0 <= i < len(options)]
return ", ".join(labels) if labels else response
except ValueError:
return response


async def handle_ask_user_question(input_data: dict) -> PermissionResultAllow:
"""Zeigen Sie Claudes Fragen an und sammeln Sie Benutzerantworten."""
answers = {}

for q in input_data.get("questions", []):
print(f"\n{q['header']}: {q['question']}")

options = q["options"]
for i, opt in enumerate(options):
print(f"  {i + 1}. {opt['label']} - {opt['description']}")
if q.get("multiSelect"):
print("  (Enter numbers separated by commas, or type your own answer)")
else:
print("  (Enter a number, or type your own answer)")

response = input("Your choice: ").strip()
answers[q["question"]] = parse_response(response, options)

return PermissionResultAllow(
updated_input={
"questions": input_data.get("questions", []),
"answers": answers,
}
)


async def can_use_tool(
tool_name: str, input_data: dict, context
) -> PermissionResultAllow:
# Leiten Sie AskUserQuestion zu unserem Frage-Handler weiter
if tool_name == "AskUserQuestion":
return await handle_ask_user_question(input_data)
# Auto-Genehmigung anderer Tools für dieses Beispiel
return PermissionResultAllow(updated_input=input_data)


async def prompt_stream():
yield {
"type": "user",
"message": {
"role": "user",
"content": "Help me decide on the tech stack for a new mobile app",
},
}


# Erforderliche Umgehung: Dummy-Hook hält den Stream für can_use_tool offen
async def dummy_hook(input_data, tool_use_id, context):
return {"continue_": True}


async def main():
async for message in query(
prompt=prompt_stream(),
options=ClaudeAgentOptions(
can_use_tool=can_use_tool,
hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[dummy_hook])]},
),
):
if isinstance(message, ResultMessage) and message.subtype == "success":
print(message.result)


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";
import * as readline from "readline/promises";

// Hilfsfunktion zum Auffordern von Benutzereingaben im Terminal
async function prompt(question: string): Promise<string> {
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const answer = await rl.question(question);
rl.close();
return answer;
}

// Analysieren Sie Benutzereingaben als Optionsnummer(n) oder freien Text
function parseResponse(response: string, options: any[]): string {
const indices = response.split(",").map((s) => parseInt(s.trim()) - 1);
const labels = indices
.filter((i) => !isNaN(i) && i >= 0 && i < options.length)
.map((i) => options[i].label);
return labels.length > 0 ? labels.join(", ") : response;
}

// Zeigen Sie Claudes Fragen an und sammeln Sie Benutzerantworten
async function handleAskUserQuestion(input: any) {
const answers: Record<string, string> = {};

for (const q of input.questions) {
console.log(`\n${q.header}: ${q.question}`);

const options = q.options;
options.forEach((opt: any, i: number) => {
console.log(`  ${i + 1}. ${opt.label} - ${opt.description}`);
});
if (q.multiSelect) {
console.log("  (Enter numbers separated by commas, or type your own answer)");
} else {
console.log("  (Enter a number, or type your own answer)");
}

const response = (await prompt("Your choice: ")).trim();
answers[q.question] = parseResponse(response, options);
}

// Geben Sie die Antworten an Claude zurück (muss ursprüngliche Fragen enthalten)
return {
behavior: "allow",
updatedInput: { questions: input.questions, answers }
};
}

async function main() {
for await (const message of query({
prompt: "Help me decide on the tech stack for a new mobile app",
options: {
canUseTool: async (toolName, input) => {
// Leiten Sie AskUserQuestion zu unserem Frage-Handler weiter
if (toolName === "AskUserQuestion") {
return handleAskUserQuestion(input);
}
// Auto-Genehmigung anderer Tools für dieses Beispiel
return { behavior: "allow", updatedInput: input };
}
}
})) {
if ("result" in message) console.log(message.result);
}
}

main();

Einschränkungen

• Subagenten: AskUserQuestion ist derzeit nicht in Subagenten verfügbar, die über das Agent-Tool erzeugt werden
• Fragenlimits: Jeder AskUserQuestion-Aufruf unterstützt 1-4 Fragen mit jeweils 2-4 Optionen

Andere Möglichkeiten, Benutzereingaben zu erhalten

Der 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:

Streaming-Eingabe

Verwenden Sie Streaming-Eingabe, wenn Sie:

• Den Agent mitten in der Aufgabe unterbrechen: Senden Sie ein Abbruchsignal oder ändern Sie die Richtung, während Claude arbeitet
• Zusätzlichen Kontext bereitstellen: Fügen Sie Informationen hinzu, die Claude benötigt, ohne darauf zu warten, dass es fragt
• Chat-Schnittstellen erstellen: Lassen Sie Benutzer Folgenachrichten während langwieriger Operationen senden

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

Benutzerdefinierte Tools

Verwenden Sie benutzerdefinierte Tools, wenn Sie:

• Strukturierte Eingaben sammeln: Erstellen Sie Formulare, Assistenten oder mehrstufige Workflows, die über das Multiple-Choice-Format von AskUserQuestion hinausgehen
• Externe Genehmigungssysteme integrieren: Verbinden Sie sich mit bestehenden Ticketing-, Workflow- oder Genehmigungsplattformen
• Domänenspezifische Interaktionen implementieren: Erstellen Sie Tools, die auf die Anforderungen Ihrer Anwendung zugeschnitten sind, wie Code-Review-Schnittstellen oder Bereitstellungs-Checklisten

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

Verwandte Ressourcen

• Berechtigungen konfigurieren: Richten Sie Berechtigungsmodi und -regeln ein
• Ausführung mit Hooks steuern: Führen Sie benutzerdefinierten Code an Schlüsselpunkten im Agent-Lebenszyklus aus
• TypeScript SDK-Referenz: Vollständige canUseTool-API-Dokumentation