Gestionar aprobaciones e entrada de usuario

Presente las solicitudes de aprobación y preguntas aclaratorias de Claude a los usuarios, luego devuelva sus decisiones al SDK.

Mientras trabaja en una tarea, Claude a veces necesita consultar con los usuarios. Podría necesitar permiso antes de eliminar archivos, o necesitar preguntar qué base de datos usar para un nuevo proyecto. Su aplicación necesita presentar estas solicitudes a los usuarios para que Claude pueda continuar con su entrada.

Claude solicita entrada del usuario en dos situaciones: cuando necesita permiso para usar una herramienta (como eliminar archivos o ejecutar comandos), y cuando tiene preguntas aclaratorias (a través de la herramienta AskUserQuestion). Ambas activan su callback canUseTool, que pausa la ejecución hasta que devuelva una respuesta. Esto es diferente de los turnos de conversación normales donde Claude termina y espera su próximo mensaje.

Para preguntas aclaratorias, Claude genera las preguntas y opciones. Su función es presentarlas a los usuarios y devolver sus selecciones. No puede agregar sus propias preguntas a este flujo; si necesita preguntarle algo a los usuarios usted mismo, hágalo por separado en la lógica de su aplicación.

El callback puede permanecer pendiente indefinidamente. La ejecución permanece pausada hasta que su callback regrese, y el SDK solo cancela la espera cuando la consulta misma se cancela. Si un usuario podría tardar más en responder de lo que su proceso puede razonablemente mantenerse ejecutando, devuelva la decisión del hook defer, que permite que el proceso salga y se reanude más tarde desde la sesión persistida.

Esta guía le muestra cómo detectar cada tipo de solicitud y responder apropiadamente.

Detectar cuándo Claude necesita entrada

Pase un callback canUseTool en sus opciones de consulta. El callback se activa cada vez que Claude necesita entrada del usuario, recibiendo el nombre de la herramienta y la entrada como argumentos:

async def handle_tool_request(tool_name, input_data, context):
# Solicitar al usuario y devolver permitir o denegar
...


options = ClaudeAgentOptions(can_use_tool=handle_tool_request)

async function handleToolRequest(toolName, input, options) {
// options includes { signal: AbortSignal, suggestions?: PermissionUpdate[] }
// Solicitar al usuario y devolver permitir o denegar
}

const options = { canUseTool: handleToolRequest };

El callback se activa en dos casos:

1. La herramienta necesita aprobación: Claude quiere usar una herramienta que no está aprobada automáticamente por reglas de permisos o modos. Verifique tool_name para la herramienta (por ejemplo, "Bash", "Write").
2. Claude hace una pregunta: Claude llama a la herramienta AskUserQuestion. Verifique si tool_name == "AskUserQuestion" para manejarlo de manera diferente. Si especifica un array tools, incluya AskUserQuestion para que esto funcione. Vea Manejar preguntas aclaratorias para más detalles.

Manejar solicitudes de aprobación de herramientas

Una vez que haya pasado un callback canUseTool en sus opciones de consulta, se activa cuando Claude quiere usar una herramienta que no está aprobada automáticamente. Su callback recibe tres argumentos:

El objeto input contiene parámetros específicos de la herramienta. Ejemplos comunes:

Vea la referencia del SDK para esquemas de entrada completos: Python | TypeScript.

Puede mostrar esta información al usuario para que pueda decidir si permitir o rechazar la acción, luego devolver la respuesta apropiada.

El siguiente ejemplo le pide a Claude que cree y elimine un archivo de prueba. Cuando Claude intenta cada operación, el callback imprime la solicitud de herramienta en la terminal y solicita aprobación s/n.

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:
# Mostrar la solicitud de herramienta
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}")

# Obtener aprobación del usuario
response = input("Allow this action? (y/n): ")

# Devolver permitir o denegar según la respuesta del usuario
if response.lower() == "y":
# Permitir: la herramienta se ejecuta con la entrada original (o modificada)
return PermissionResultAllow(updated_input=input_data)
else:
# Denegar: la herramienta no se ejecuta, Claude ve el mensaje
return PermissionResultDeny(message="User denied this action")


# Solución requerida: hook ficticio mantiene el flujo abierto para can_use_tool
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";

// Helper para solicitar entrada del usuario en la 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) => {
// Mostrar la solicitud de herramienta
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)}`);
}

// Obtener aprobación del usuario
const response = await prompt("Allow this action? (y/n): ");

// Devolver permitir o denegar según la respuesta del usuario
if (response.toLowerCase() === "y") {
// Permitir: la herramienta se ejecuta con la entrada original (o modificada)
return { behavior: "allow", updatedInput: input };
} else {
// Denegar: la herramienta no se ejecuta, Claude ve el mensaje
return { behavior: "deny", message: "User denied this action" };
}
}
}
})) {
if ("result" in message) console.log(message.result);
}

Este ejemplo usa un flujo s/n donde cualquier entrada que no sea y se trata como una denegación. En la práctica, podría construir una interfaz de usuario más rica que permita a los usuarios modificar la solicitud, proporcionar retroalimentación o redirigir a Claude completamente. Vea Responder a solicitudes de herramientas para todas las formas en que puede responder.

Responder a solicitudes de herramientas

Su callback devuelve uno de dos tipos de respuesta:

Al permitir, pase la entrada de la herramienta (original o modificada). Al denegar, proporcione un mensaje explicando por qué. Claude ve este mensaje y puede ajustar su enfoque.

from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

# Permitir que la herramienta se ejecute
return PermissionResultAllow(updated_input=input_data)

# Bloquear la herramienta
return PermissionResultDeny(message="User rejected this action")

// Permitir que la herramienta se ejecute
return { behavior: "allow", updatedInput: input };

// Bloquear la herramienta
return { behavior: "deny", message: "User rejected this action" };

Más allá de permitir o denegar, puede modificar la entrada de la herramienta o proporcionar contexto que ayude a Claude a ajustar su enfoque:

• Aprobar: permitir que la herramienta se ejecute como Claude solicitó
• Aprobar con cambios: modificar la entrada antes de la ejecución (por ejemplo, desinfectar rutas, agregar restricciones)
• Aprobar y recordar: devolver una regla de permiso sugerida para que las llamadas coincidentes omitan el aviso la próxima vez
• Rechazar: bloquear la herramienta y decirle a Claude por qué
• Sugerir alternativa: bloquear pero guiar a Claude hacia lo que el usuario quiere en su lugar
• Redirigir completamente: usar entrada de flujo para enviar a Claude una instrucción completamente nueva

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":
# Usuario aprobó, pero limita todos los comandos a sandbox
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") {
// Usuario aprobó, pero limita todos los comandos a sandbox
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", ""):
# El usuario no quiere eliminar, sugiera archivar en su lugar
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")) {
// El usuario no quiere eliminar, sugiera archivar en su lugar
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 };
};

Manejar preguntas aclaratorias

Cuando Claude necesita más dirección en una tarea con múltiples enfoques válidos, llama a la herramienta AskUserQuestion. Esto activa su callback canUseTool con toolName establecido en AskUserQuestion. La entrada contiene las preguntas de Claude como opciones de opción múltiple, que muestra al usuario y devuelve sus selecciones.

Los siguientes pasos muestran cómo manejar preguntas aclaratorias:

async for message in query(
prompt="Analyze this codebase",
options=ClaudeAgentOptions(
# Incluya AskUserQuestion en su lista de herramientas
tools=["Read", "Glob", "Grep", "AskUserQuestion"],
can_use_tool=can_use_tool,
),
):
print(message)

for await (const message of query({
prompt: "Analyze this codebase",
options: {
// Incluya AskUserQuestion en su lista de herramientas
tools: ["Read", "Glob", "Grep", "AskUserQuestion"],
canUseTool: async (toolName, input) => {
// Manejar preguntas aclaratorias aquí
}
}
})) {
console.log(message);
}

async def can_use_tool(tool_name: str, input_data: dict, context):
if tool_name == "AskUserQuestion":
# Su implementación para recopilar respuestas del usuario
return await handle_clarifying_questions(input_data)
# Manejar otras herramientas normalmente
return await prompt_for_approval(tool_name, input_data)

canUseTool: async (toolName, input) => {
if (toolName === "AskUserQuestion") {
// Su implementación para recopilar respuestas del usuario
return handleClarifyingQuestions(input);
}
// Manejar otras herramientas normalmente
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"
}
}
};

Formato de pregunta

La entrada contiene las preguntas generadas por Claude en un array questions. Cada pregunta tiene estos campos:

La estructura que su callback recibe:

{
  "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
    }
  ]
}

Vistas previas de opciones (TypeScript)

toolConfig.askUserQuestion.previewFormat agrega un campo preview a cada opción para que su aplicación pueda mostrar una maqueta visual junto a la etiqueta. Sin esta configuración, Claude no genera vistas previas y el campo está ausente.

El formato se aplica a todas las preguntas en la sesión. Claude incluye preview en opciones donde una comparación visual ayuda (opciones de diseño, esquemas de color) y la omite donde no lo haría (confirmaciones sí/no, opciones de solo texto). Verifique undefined antes de renderizar.

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 es una cadena HTML o undefined
      return { behavior: "allow", updatedInput: input };
    }
  }
})) {
  // ...
}

Una opción con una vista previa HTML:

{
  "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>"
}

Formato de respuesta

Devuelva un objeto answers que asigne cada campo question de la pregunta a la label de la opción seleccionada:

Para preguntas de selección múltiple, pase un array de etiquetas o únalas con ", ". Para entrada de texto libre, use el texto personalizado del usuario directamente.

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

Admitir entrada de texto libre

Las opciones predefinidas de Claude no siempre cubrirán lo que los usuarios quieren. Para permitir que los usuarios escriban su propia respuesta:

• Muestre una opción "Otro" adicional después de las opciones de Claude que acepte entrada de texto
• Use el texto personalizado del usuario como valor de respuesta (no la palabra "Otro")

Vea el ejemplo completo a continuación para una implementación completa.

Ejemplo completo

Claude hace preguntas aclaratorias cuando necesita entrada del usuario para proceder. Por ejemplo, cuando se le pide que ayude a decidir sobre una pila de tecnología para una aplicación móvil, Claude podría preguntar sobre multiplataforma vs nativo, preferencias de backend o plataformas objetivo. Estas preguntas ayudan a Claude a tomar decisiones que coincidan con las preferencias del usuario en lugar de adivinar.

Este ejemplo maneja esas preguntas en una aplicación de terminal. Esto es lo que sucede en cada paso:

1. Enrutar la solicitud: El callback canUseTool verifica si el nombre de la herramienta es "AskUserQuestion" y enruta a un manejador dedicado
2. Mostrar preguntas: El manejador recorre el array questions e imprime cada pregunta con opciones numeradas
3. Recopilar entrada: El usuario puede ingresar un número para seleccionar una opción, o escribir texto libre directamente (por ejemplo, "jquery", "i don't know")
4. Asignar respuestas: El código verifica si la entrada es numérica (usa la etiqueta de la opción) o texto libre (usa el texto directamente)
5. Devolver a Claude: La respuesta incluye tanto el array questions original como el mapeo answers

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:
"""Analizar la entrada del usuario como número(s) de opción o texto libre."""
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:
"""Mostrar las preguntas de Claude y recopilar respuestas del usuario."""
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:
# Enrutar AskUserQuestion a nuestro manejador de preguntas
if tool_name == "AskUserQuestion":
return await handle_ask_user_question(input_data)
# Auto-aprobar otras herramientas para este ejemplo
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",
},
}


# Solución requerida: hook ficticio mantiene el flujo abierto para can_use_tool
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";

// Helper para solicitar entrada del usuario en la 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;
}

// Analizar la entrada del usuario como número(s) de opción o texto libre
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;
}

// Mostrar las preguntas de Claude y recopilar respuestas del usuario
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);
}

// Devolver las respuestas a Claude (debe incluir preguntas originales)
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) => {
// Enrutar AskUserQuestion a nuestro manejador de preguntas
if (toolName === "AskUserQuestion") {
return handleAskUserQuestion(input);
}
// Auto-aprobar otras herramientas para este ejemplo
return { behavior: "allow", updatedInput: input };
}
}
})) {
if ("result" in message) console.log(message.result);
}
}

main();

Limitaciones

• Subagentes: AskUserQuestion no está disponible actualmente en subagentes generados a través de la herramienta Agent
• Límites de preguntas: cada llamada AskUserQuestion admite 1-4 preguntas con 2-4 opciones cada una

Otras formas de obtener entrada del usuario

El callback canUseTool y la herramienta AskUserQuestion cubren la mayoría de escenarios de aprobación y aclaración, pero el SDK ofrece otras formas de obtener entrada de los usuarios:

Entrada de flujo

Use entrada de flujo cuando necesite:

• Interrumpir el agente a mitad de tarea: enviar una señal de cancelación o cambiar de dirección mientras Claude está trabajando
• Proporcionar contexto adicional: agregar información que Claude necesita sin esperar a que la solicite
• Construir interfaces de chat: permitir que los usuarios envíen mensajes de seguimiento durante operaciones de larga duración

La entrada de flujo es ideal para interfaces conversacionales donde los usuarios interactúan con el agente durante toda la ejecución, no solo en puntos de aprobación.

Herramientas personalizadas

Use herramientas personalizadas cuando necesite:

• Recopilar entrada estructurada: construir formularios, asistentes o flujos de trabajo de varios pasos que vayan más allá del formato de opción múltiple de AskUserQuestion
• Integrar sistemas de aprobación externos: conectarse a plataformas de tickets, flujo de trabajo o aprobación existentes
• Implementar interacciones específicas del dominio: crear herramientas adaptadas a las necesidades de su aplicación, como interfaces de revisión de código o listas de verificación de implementación

Las herramientas personalizadas le dan control total sobre la interacción, pero requieren más trabajo de implementación que usar el callback canUseTool integrado.

Recursos relacionados

• Configurar permisos: configurar modos y reglas de permisos
• Controlar la ejecución con hooks: ejecutar código personalizado en puntos clave del ciclo de vida del agente
• Referencia del SDK de TypeScript: documentación completa de la API canUseTool