User input and approvals

const options = {
  canUseTool: async (toolName: string, input: Record<string, unknown>, opts: { signal: AbortSignal; suggestions?: unknown[] }) => {
    // show the request, wait for a decision, return allow or deny
  },
};

async def can_use_tool(tool_name, input_data, context):
    ...  # show the request, wait for a decision, return allow or deny

options = ClaudeAgentOptions(can_use_tool=can_use_tool)

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

async function ask(question: string) {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  const answer = await rl.question(question);
  rl.close();
  return answer.trim().toLowerCase();
}

for await (const msg of query({
  prompt: "Archive log files in ./logs older than 30 days into logs/archive.tar.gz, then remove the originals",
  options: {
    canUseTool: async (toolName, input) => {
      const summary = toolName === "Bash" ? String(input.command) : JSON.stringify(input);
      const answer = await ask(`\n${toolName}: ${summary}\nAllow? [y/N] `);
      return answer === "y"
        ? { behavior: "allow", updatedInput: input }
        : { behavior: "deny", message: "The operator declined this step." };
    },
  },
})) {
  if (msg.type === "result" && msg.subtype === "success") console.log(msg.result);
}

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

async def can_use_tool(tool_name, input_data, context):
    shown = input_data.get("command") if tool_name == "Bash" else input_data
    answer = input(f"\n{tool_name}: {shown}\nAllow? [y/N] ").strip().lower()
    if answer == "y":
        return PermissionResultAllow(updated_input=input_data)
    return PermissionResultDeny(message="The operator declined this step.")

async def keep_stream_open(input_data, tool_use_id, context):
    return {"continue_": True}

async def prompt():
    yield {"type": "user", "message": {"role": "user",
           "content": "Archive logs older than 30 days into logs/archive.tar.gz, then remove the originals"}}

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

asyncio.run(main())

async def can_use_tool(tool_name, input_data, context):
    if tool_name in ("Write", "Edit"):
        path = input_data["file_path"]
        if not path.startswith("/srv/staging/"):
            safe = {**input_data, "file_path": "/srv/staging/" + path.lstrip("/")}
            return PermissionResultAllow(updated_input=safe)
    return PermissionResultAllow(updated_input=input_data)

canUseTool: async (toolName, input) => {
  if (toolName === "Bash" && /\bgit push\b/.test(String(input.command))) {
    return {
      behavior: "deny",
      message: "Do not push. Commit locally and tell me the branch name; I will open the PR myself.",
    };
  }
  return { behavior: "allow", updatedInput: input };
};

canUseTool: async (toolName, input, { suggestions = [] }) => {
  const choice = await askOperator(`Allow ${toolName}?`, ["once", "always", "no"]);
  if (choice === "always") {
    return {
      behavior: "allow",
      updatedInput: input,
      updatedPermissions: suggestions.filter((s) => s.destination === "localSettings"),
    };
  }
  if (choice === "once") return { behavior: "allow", updatedInput: input };
  return { behavior: "deny", message: "Declined by operator" };
};

ClaudeAgentOptions(tools=["Read", "Glob", "Grep", "AskUserQuestion"], can_use_tool=can_use_tool)

{
  "questions": [
    {
      "question": "Which payment provider should the checkout use?",
      "header": "Payments",
      "options": [
        { "label": "Stripe", "description": "Already used by the subscriptions service" },
        { "label": "GoCardless", "description": "Direct debit, lower fees for UK customers" }
      ],
      "multiSelect": false
    },
    {
      "question": "Which customer notifications do you want?",
      "header": "Emails",
      "options": [
        { "label": "Receipt", "description": "Sent on successful payment" },
        { "label": "Failed payment", "description": "Sent when a charge fails" },
        { "label": "Renewal reminder", "description": "Sent a week before renewal" }
      ],
      "multiSelect": true
    }
  ]
}

return {
  behavior: "allow",
  updatedInput: {
    questions: input.questions,
    answers: {
      "Which payment provider should the checkout use?": "GoCardless",
      "Which customer notifications do you want?": "Receipt, Failed payment",
    },
  },
};

from claude_agent_sdk.types import PermissionResultAllow

def to_answer(raw: str, options: list) -> str:
    try:
        picks = [int(part) - 1 for part in raw.split(",")]
        labels = [options[i]["label"] for i in picks if 0 <= i < len(options)]
        return ", ".join(labels) or raw
    except ValueError:
        return raw  # free text

async def answer_questions(input_data):
    answers = {}
    for q in input_data.get("questions", []):
        print(f"\n[{q['header']}] {q['question']}")
        for n, opt in enumerate(q["options"], start=1):
            print(f"  {n}. {opt['label']}: {opt['description']}")
        hint = "numbers separated by commas" if q.get("multiSelect") else "a number"
        raw = input(f"Choose {hint}, or type your own answer: ").strip()
        answers[q["question"]] = to_answer(raw, q["options"])
    return PermissionResultAllow(updated_input={"questions": input_data["questions"], "answers": answers})

async def can_use_tool(tool_name, input_data, context):
    if tool_name == "AskUserQuestion":
        return await answer_questions(input_data)
    return PermissionResultAllow(updated_input=input_data)

query({
  prompt: "Help me pick a layout for the pricing page",
  options: {
    toolConfig: { askUserQuestion: { previewFormat: "html" } },
    canUseTool: async (toolName, input) => renderQuestionCards(toolName, input),
  },
});