async def handle_tool_request(tool_name, input_data, context):
# 提示使用者並返回允許或拒絕
...


options = ClaudeAgentOptions(can_use_tool=handle_tool_request)

async function handleToolRequest(toolName, input, options) {
// options includes { signal: AbortSignal, suggestions?: PermissionUpdate[] }
// 提示使用者並返回允許或拒絕
}

const options = { canUseTool: handleToolRequest };

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:
# 顯示工具請求
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}")

# 獲取使用者批准
response = input("Allow this action? (y/n): ")

# 根據使用者的回應返回允許或拒絕
if response.lower() == "y":
# 允許：工具使用原始（或修改的）輸入執行
return PermissionResultAllow(updated_input=input_data)
else:
# 拒絕：工具不執行，Claude 看到訊息
return PermissionResultDeny(message="User denied this action")


# 必需的解決方法：虛擬 hook 保持流開放以供 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";

// 幫助程式在終端機中提示使用者輸入
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) => {
// 顯示工具請求
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)}`);
}

// 獲取使用者批准
const response = await prompt("Allow this action? (y/n): ");

// 根據使用者的回應返回允許或拒絕
if (response.toLowerCase() === "y") {
// 允許：工具使用原始（或修改的）輸入執行
return { behavior: "allow", updatedInput: input };
} else {
// 拒絕：工具不執行，Claude 看到訊息
return { behavior: "deny", message: "User denied this action" };
}
}
}
})) {
if ("result" in message) console.log(message.result);
}

from claude_agent_sdk.types import PermissionResultAllow, PermissionResultDeny

# 允許工具執行
return PermissionResultAllow(updated_input=input_data)

# 阻止工具
return PermissionResultDeny(message="User rejected this action")

// 允許工具執行
return { behavior: "allow", updatedInput: input };

// 阻止工具
return { behavior: "deny", message: "User rejected this action" };

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:
"""將使用者輸入解析為選項編號或自由文字。"""
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:
"""顯示 Claude 的問題並收集使用者答案。"""
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:
# 將 AskUserQuestion 路由到我們的問題處理程式
if tool_name == "AskUserQuestion":
return await handle_ask_user_question(input_data)
# 為此範例自動批准其他工具
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",
},
}


# 必需的解決方法：虛擬 hook 保持流開放以供 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";

// 幫助程式在終端機中提示使用者輸入
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;
}

// 將使用者輸入解析為選項編號或自由文字
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;
}

// 顯示 Claude 的問題並收集使用者答案
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);
}

// 將答案返回給 Claude（必須包括原始問題）
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) => {
// 將 AskUserQuestion 路由到我們的問題處理程式
if (toolName === "AskUserQuestion") {
return handleAskUserQuestion(input);
}
// 為此範例自動批准其他工具
return { behavior: "allow", updatedInput: input };
}
}
})) {
if ("result" in message) console.log(message.result);
}
}

main();