Configurare i permessi

Controlla come il tuo agente utilizza gli strumenti con modalità di permesso, hook e regole dichiarative di consentimento/negazione.

Claude Agent SDK fornisce controlli di permesso per gestire come Claude utilizza gli strumenti. Utilizza modalità di permesso e regole per definire ciò che è consentito automaticamente, e il callback canUseTool per gestire tutto il resto in fase di esecuzione.

Come vengono valutate le autorizzazioni

[!NOTE]

Se carichi un plugin che contiene un mod, consulta dove si collocano le decisioni di un mod tra regole e hook.

Quando Claude richiede uno strumento, Claude Code controlla la chiamata in questi passaggi. Ogni passaggio può decidere la chiamata, inviarla al tuo callback canUseTool o lasciarla passare:

1. Hook

Esegue gli hook. Un hook può negare la chiamata completamente o lasciarla passare. Un hook che restituisce allow non salta i passaggi delle regole deny e ask, che vengono valutati indipendentemente dal risultato dell'hook.

Un hook PreToolUse che restituisce allow inoltre non può approvare un comando rm o rmdir la cui destinazione Claude Code riconosce come un percorso critico, come rm -rf ~. Per sapere cosa fa quell'allow nel plan mode, consulta Approvazioni degli hook nel plan mode.

2. Regole deny

Se una regola deny da disallowed_tools o da un file di impostazioni caricato dall'SDK corrisponde, la chiamata viene negata e canUseTool non viene chiamato. La chiamata viene negata in questo modo anche in modalità bypassPermissions e anche quando un hook ha restituito allow.

Nell'SDK TypeScript, se imposti la permission_policy di uno strumento personalizzato su always_deny, una chiamata a quello strumento viene negata in questo passaggio.

3. Regole ask

Controllare le regole ask da settings.json. Se una regola ask corrisponde, la chiamata passa al tuo callback canUseTool per la conferma, anche in modalità bypassPermissions.

Gli strumenti che richiedono l'interazione dell'utente si comportano allo stesso modo. AskUserQuestion e gli strumenti MCP il cui server imposta _meta["anthropic/requiresUserInteraction"] passano al callback, anche quando una regola allow corrisponde. In modalità dontAsk entrambi i casi vengono invece negati, perché quella modalità trasforma ogni richiesta di conferma in un rifiuto. L'annotazione MCP richiede Claude Code v2.1.199 o successivo.

Anche gli strumenti dei connettori claude.ai che la tua organizzazione ha impostato su ask lasciano il flusso in questo passaggio. Ogni chiamata passa al callback, anche in modalità bypassPermissions e anche quando una regola allow corrisponde. Il callback riceve il motivo Your organization requires approval for this tool. In modalità dontAsk la chiamata viene invece negata, perché quella modalità non chiede mai conferma.

Nell'SDK TypeScript, se imposti la permission_policy di uno strumento personalizzato su always_ask, nessuna regola allow approva le sue chiamate, nemmeno una voce di allowedTools. In modalità dontAsk Claude Code nega quelle chiamate, e in modalità auto, plan o bypassPermissions può approvarle prima che il tuo callback venga eseguito.

4. Modalità di permesso

Applicare la modalità di permesso attiva:

• In modalità bypassPermissions, Claude Code approva ogni chiamata che raggiunge questo passaggio, a meno che non sia una delle azioni che nessuna modalità approva automaticamente. Per sapere quali di queste azioni arrivano al tuo callback canUseTool, consulta Modalità bypass dei permessi.
• In modalità acceptEdits, Claude Code approva le operazioni su file elencate in Modalità accetta modifiche.
• In modalità plan, alcune chiamate raggiungono il tuo callback e, quando la modalità auto è disponibile, altre vanno invece al suo classificatore. Per maggiori informazioni, consulta Plan mode.
• In modalità default e dontAsk, la chiamata passa alle regole allow.
• Per la modalità auto, consulta Modalità auto.

5. Regole allow

Controlla le regole allow (da allowed_tools e settings.json). Se una regola corrisponde, lo strumento viene approvato. Anche una chiamata che lo strumento approva da solo viene risolta in questo passaggio, senza alcuna regola necessaria: ad esempio una lettura di file all'interno delle tue directory di lavoro o un comando Bash di sola lettura.

Le rimozioni di percorsi critici riconosciute non vengono approvate da una regola allow, e i comandi segnalati con Dangerous rm operation not ruled out non vengono approvati da una regola Bash o Bash(*). Se poi raggiungano il tuo callback dipende dalla modalità di permesso: in una sessione Agent SDK in modalità auto, ad esempio, Claude Code li nega per impostazione predefinita senza chiamarlo. La tabella delle modalità per i percorsi critici elenca cosa fa ogni modalità con essi.

Una regola allow non approva una lettura da un percorso di rete.

6. Callback canUseTool

Se la chiamata non è stata risolta da nessuno dei passaggi precedenti, chiama il tuo callback canUseTool per una decisione. In modalità dontAsk, questo passaggio viene saltato e lo strumento viene negato, anche se un mod che hai installato può comunque approvare alcune di queste chiamate.

Nell'SDK TypeScript, se impostate permissionPrompts: 'none', il vostro callback non viene chiamato in questo passaggio. Un hook PermissionRequest ha ancora la possibilità di decidere, e se non lo fa, Claude Code nega la chiamata. L'opzione richiede Claude Code v2.1.259 o successivo.

Se passate un callback canUseTool in una configurazione in cui l'SDK TypeScript si aspetta che l'ordine di valutazione approvi automaticamente le chiamate prima che il callback sia consultato, l'SDK emette un avviso di processo Node.js una volta quando la query viene costruita. Il codice dell'avviso è CLAUDE_SDK_CAN_USE_TOOL_SHADOWED. Due configurazioni lo attivano:

• permissionMode: 'bypassPermissions': il testo dell'avviso inizia con canUseTool will not be invoked: permissionMode 'bypassPermissions'. Le chiamate agli strumenti vengono approvate prima che canUseTool venga consultato, quindi il tuo callback viene eseguito solo per poche chiamate, come quelle elencate in Modalità bypass dei permessi. Per controllare anche le chiamate approvate, sposta i controlli del tuo callback in un hook PreToolUse
• Una voce di allowedTools composta solo dal nome di uno strumento, come "Read": l'avviso elenca ciascuna di queste voci dopo canUseTool will not be invoked for:. Le chiamate a uno strumento elencato vengono approvate prima che canUseTool venga consultato, a parte le chiamate che una regola allow non approva mai. Per fare in modo che il tuo callback venga eseguito per le chiamate di uno strumento elencato che richiedono approvazione, rimuovi la voce di quello strumento da allowedTools

Le voci con uno specificatore come Bash(ls *) e la modalità acceptEdits non lo attivano, e le regole allow provenienti da file di impostazioni non sono visibili al controllo.

L'avviso non blocca alcuna chiamata né modifica alcuna opzione. Se il tuo callback riceve già ogni chiamata che vuoi controllare, lascia la configurazione così com'è. Per registrare l'avviso nei log, mettiti in ascolto con process.on('warning', ...) e confronta il codice CLAUDE_SDK_CAN_USE_TOOL_SHADOWED.

Questa pagina si concentra su regole allow e deny e modalità di autorizzazione. Per gli altri passaggi:

• Hooks: eseguire codice personalizzato per consentire, negare o modificare le richieste di strumenti. Vedere Controllare l'esecuzione con gli hook.
• Callback canUseTool: richiedere l'approvazione degli utenti in fase di esecuzione, quando nessun passaggio precedente risolve la chiamata. Vedere Gestire le approvazioni e l'input dell'utente.

Regole allow e deny

Quando imposti allowedTools e disallowedTools (TypeScript) oppure allowed_tools e disallowed_tools (Python), Claude Code aggiunge le loro voci agli elenchi di regole allow e deny nel flusso di valutazione dei permessi. Qualsiasi altro strumento non elencato in allowed_tools è ancora disponibile per Claude, e una chiamata ad esso che necessita di approvazione passa alla modalità di permesso.

Le regole allow accettano glob dei nomi degli strumenti solo dopo un prefisso letterale mcp__<server>__. Il segmento del server deve essere privo di glob in modo che la regola nomini un server specifico che hai configurato: mcp__puppeteer__* corrisponde a ogni strumento dal server puppeteer, e mcp__github__get_* corrisponde ai suoi strumenti get_. Una voce non ancorata come allowed_tools=["*"] o allowed_tools=["mcp__*"] viene ignorata e non approva automaticamente nulla.

[!WARNING]

Gli strumenti approvati automaticamente non raggiungono mai canUseTool. Una chiamata a uno strumento approvata in qualsiasi fase precedente, da acceptEdits o bypassPermissions, o da una regola allow, salta il callback canUseTool, quindi i controlli di autorizzazione che inserite lì vengono silenziosamente ignorati per quello strumento.

Se le chiamate a uno strumento in allowed_tools raggiungono comunque il tuo callback canUseTool, o vengono negate in modalità dontAsk, verifica se si tratta di letture da percorsi di rete o di una delle chiamate seguenti. Nessuna regola allow approva queste chiamate. In modalità dontAsk, che non chiede mai, Claude Code le nega senza invocare canUseTool, e nelle altre modalità di permesso le gestisci come indicato in ciascuna voce:

• AskUserQuestion, gli strumenti MCP contrassegnati _meta["anthropic/requiresUserInteraction"] e gli strumenti dei connettori che la tua organizzazione ha impostato su ask: rispondi nel callback. Gestire le domande di chiarimento mostra come rispondere ad AskUserQuestion, e una chiamata a un connettore arriva con il motivo Your organization requires approval for this tool

• Strumenti personalizzati che la tua applicazione contrassegna come always_ask: decidi la chiamata nel callback. Per evitare che queste chiamate arrivino, modifica la policy durante la sessione. In modalità auto, plan e bypassPermissions la chiamata può invece essere approvata prima del callback, nei casi elencati in Modalità di permesso che possono approvare una chiamata always_ask

• Rimozioni di percorsi critici riconosciute con rm e rmdir: in modalità default, acceptEdits e bypassPermissions, consenti o nega la rimozione nel callback, dove decisionReason inizia con Dangerous rm. Per le modalità auto e plan, consulta Rimozioni di percorsi critici in ciascuna modalità di permesso

• Nome semplice: una voce come Read o mcp__github__get_issue approva automaticamente ogni chiamata a quello strumento a parte le azioni che nessuna modalità approva automaticamente e le letture da percorsi di rete.

• Regola limitata: una voce come Bash(npm test *) approva automaticamente le chiamate corrispondenti, e le altre chiamate Bash che necessitano di approvazione passano alla modalità di permesso.

Per controllare le chiamate che una regola allow, acceptEdits o bypassPermissions approva, usa un hook PreToolUse, che viene eseguito anche per quelle chiamate. Una negazione da parte di un hook si applica anche in modalità bypassPermissions.

Per un agente bloccato, abbinate allowedTools con permissionMode: "dontAsk":

const options = {
  allowedTools: ["Read", "Glob", "Grep"],
  permissionMode: "dontAsk"
};

Le chiamate elencate a Read, Glob e Grep sono approvate, a parte le azioni che nessuna modalità approva automaticamente e le letture da percorsi di rete. Ogni altra chiamata che comporterebbe una richiesta di permesso viene invece negata, anche se un mod che hai installato può comunque approvare alcune di queste chiamate.

Le chiamate che non necessitano di approvazione in modalità default vengono eseguite indipendentemente dal fatto che tu le elenchi. Includono i comandi Bash di sola lettura, strumenti come Agent che non chiedono prima di essere eseguiti, e letture di file all'interno delle tue directory di lavoro. Per nascondere completamente uno strumento integrato a Claude anziché negarne le chiamate, aggiungi il suo nome semplice a disallowedTools.

[!WARNING]

allowed_tools non vincola bypassPermissions. allowed_tools pre-approva gli strumenti che elenchi. In modalità bypassPermissions, Claude Code approva una chiamata a uno strumento non elencato a meno che non rientri tra le azioni che nessuna modalità approva automaticamente.

Se imposti allowed_tools=["Read"] con permission_mode="bypassPermissions", Claude Code approva comunque le chiamate a strumenti come Bash, Write e Edit. Se hai bisogno di bypassPermissions ma vuoi che strumenti specifici siano bloccati, usa disallowed_tools. Per le chiamate che raggiungono comunque il tuo callback canUseTool in questa modalità, consulta Modalità bypass permissions.

Potete anche configurare le regole allow, deny e ask in modo dichiarativo in .claude/settings.json. Queste regole vengono lette quando la fonte di impostazione project è abilitata, il che avviene per le opzioni predefinite di query(). Se impostate esplicitamente setting_sources (TypeScript: settingSources), includete "project" affinché si applichino. Consultate Impostazioni di autorizzazione per la sintassi delle regole.

Per sapere quando si applicano le regole allow nel file .claude/settings.json di un progetto, consulta Regole allow di progetto e attendibilità del workspace.

Modelli di percorso nelle regole

Le regole limitate per Read e Edit accettano un modello di percorso. Le regole Edit(path) governano tutti gli strumenti integrati che scrivono file, inclusi Write e NotebookEdit, quindi scrivi una regola di percorso per ciascuno di essi come Edit(path). Se scrivi una regola di percorso come Write(path) o NotebookEdit(path), non corrisponde ad alcuna chiamata e non ha alcun effetto.

In allowed_tools e disallowed_tools, inizia un modello di percorso con // per un percorso assoluto, oppure con una singola / per un percorso all'interno della directory di lavoro della sessione:

• //path: con una regola deny Edit(//secrets/**), Claude Code blocca le scritture sotto /secrets su disco da parte degli strumenti per i file di Claude e dei comandi Bash come tee e il reindirizzamento > file. Uno script che Claude esegue e che apre i file autonomamente può comunque scrivere sotto /secrets. Per un'applicazione a livello di sistema operativo, consulta Configurare lo strumento Bash in sandbox.
• /path: Edit(/secrets/**) corrisponde alla directory secrets all'interno della directory di lavoro.

Per altri modi di iniziare un modello di percorso, consulta Regole Read e Edit.

Modalità di autorizzazione

Le modalità di autorizzazione forniscono un controllo globale su come Claude utilizza gli strumenti. È possibile impostare la modalità di autorizzazione quando si chiama query() o modificarla dinamicamente durante le sessioni di streaming.

Con Claude Code v2.1.302 o successivo, la tua app si avvia in modalità default a meno che tu non imposti una modalità di permesso o che non ne riceva una da permissions.defaultMode nei suoi file di impostazioni. In modalità default, Claude Code nega qualsiasi chiamata a uno strumento che richieda approvazione, a meno che tu non la approvi tramite una regola allow, un hook, un callback canUseTool o uno strumento per le richieste di permesso. Se le chiamate agli strumenti vengono negate, consulta Chiamate agli strumenti negate in claude -p e nelle esecuzioni dell'Agent SDK.

Modalità disponibili

L'SDK supporta queste modalità di autorizzazione:

[!WARNING]

Ereditarietà dei subagent: Se la tua sessione principale è in plan mode, un subagent la cui AgentDefinition imposta permissionMode: "acceptEdits" viene comunque eseguito in plan mode. Le chiamate Edit e Write di quel subagent sui tuoi file sorgente passano comunque al tuo callback canUseTool. Il plan mode vale anche per i subagent che definisci, così che affidare il lavoro a uno di essi non permetta di aggirare la revisione preliminare del piano.

Il subagent eredita plan, acceptEdits, auto o bypassPermissions dalla sessione principale e, con una sessione principale in modalità default o dontAsk, viene eseguito nella modalità che imposti. Anche in questo caso, Claude Code non applica mai un valore "bypassPermissions" e applica un valore "auto" solo quando la modalità auto è disponibile per quel subagent. L'eccezione bypassPermissions richiede Claude Code v2.1.267 o successivo.

I subagent possono avere prompt di sistema diversi e comportamenti meno vincolati rispetto all'agente principale, quindi ereditare bypassPermissions concede loro accesso completo e autonomo al sistema. Le azioni che nessuna modalità approva automaticamente si applicano comunque.

Impostare la modalità di autorizzazione

È possibile impostare la modalità di autorizzazione una volta all'avvio di una query, oppure modificarla dinamicamente mentre la sessione è attiva.

[tab] Al momento della query

Passa permission_mode (Python) o permissionMode (TypeScript) quando crei una query.

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions


async def main():
    async for message in query(
        prompt="Help me refactor this code",
        options=ClaudeAgentOptions(
            permission_mode="default",  # Set the mode here
        ),
    ):
        if hasattr(message, "result"):
            print(message.result)


asyncio.run(main())

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

async function main() {
  for await (const message of query({
    prompt: "Help me refactor this code",
    options: {
      permissionMode: "default" // Set the mode here
    }
  })) {
    if ("result" in message) {
      console.log(message.result);
    }
  }
}

main();

[tab] Durante lo streaming

Chiamare set_permission_mode() (Python) o setPermissionMode() (TypeScript) per modificare la modalità durante la sessione. La nuova modalità ha effetto immediatamente per tutte le successive richieste di strumenti. Questo consente di iniziare in modo restrittivo e allentare le autorizzazioni man mano che la fiducia aumenta, ad esempio passando a acceptEdits dopo aver esaminato l'approccio iniziale di Claude.

import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions


async def main():
    async with ClaudeSDKClient(
        options=ClaudeAgentOptions(
            permission_mode="default",  # Start in default mode
        )
    ) as client:
        await client.query("Help me refactor this code")

        # Change mode dynamically mid-session
        await client.set_permission_mode("acceptEdits")

        # Process messages with the new permission mode
        async for message in client.receive_response():
            if hasattr(message, "result"):
                print(message.result)


asyncio.run(main())

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

async function main() {
  const q = query({
    prompt: "Help me refactor this code",
    options: {
      permissionMode: "default" // Start in default mode
    }
  });

  // Change mode dynamically mid-session
  await q.setPermissionMode("acceptEdits");

  // Process messages with the new permission mode
  for await (const message of q) {
    if ("result" in message) {
      console.log(message.result);
    }
  }
}

main();

Dettagli della modalità

Modalità accetta modifiche (acceptEdits)

Approva automaticamente le operazioni sui file in modo che Claude possa modificare il codice senza richiedere conferma. Gli altri strumenti (come i comandi Bash che non sono operazioni del filesystem) richiedono comunque autorizzazioni normali.

Operazioni approvate automaticamente:

• Modifiche ai file con gli strumenti Edit, Write e NotebookEdit
• Comandi del filesystem: mkdir, touch, rm, rmdir, mv, cp, sed

Entrambi si applicano ai percorsi all'interno della directory di lavoro o di una directory che aggiungi. In Python ne aggiungi una con add_dirs, e in TypeScript con additionalDirectories. In modalità acceptEdits, Claude Code non approva automaticamente la richiesta quando Claude:

• Lavora su un percorso al di fuori di tale ambito
• Scrive in un percorso protetto
• Rimuove con rm o rmdir un percorso che Claude Code riconosce come percorso critico
• Esegue touch con, ad esempio, un'opzione, un glob o un prefisso timeout 5 o LANG=C

Utilizzare quando: si confida nelle modifiche di Claude e si desidera un'iterazione più veloce, ad esempio durante la prototipazione o quando si lavora in una directory isolata.

Modalità non chiedere (dontAsk)

Converte qualsiasi richiesta di permesso in una negazione, senza chiamare canUseTool, anche se un mod che hai installato può comunque approvare alcune di queste chiamate. Gli strumenti pre-approvati da allowed_tools, da regole allow in settings.json o da un hook vengono eseguiti normalmente. Vengono eseguite anche le chiamate che non richiedono approvazione in modalità default, come le letture di file all'interno delle tue directory di lavoro e le chiamate a Agent.

Queste chiamate vengono negate anche quando una regola allow corrisponde:

• Gli strumenti connettore che la tua organizzazione ha impostato su ask
• Gli strumenti che richiedono interazione dell'utente, come AskUserQuestion e gli strumenti MCP il cui server imposta _meta["anthropic/requiresUserInteraction"]
• Gli strumenti personalizzati il cui permission_policy è impostato dalla tua applicazione su always_ask
• Le letture da percorsi di rete
• Le rimozioni di percorsi critici riconosciute

Se il tuo hook PreToolUse restituisce allow per una rimozione riconosciuta di un percorso critico, una lettura da un percorso di rete o una chiamata a uno strumento contrassegnato come always_ask, la chiamata viene comunque negata. Il controllo che riconosce queste rimozioni può non individuare alcuni comandi.

Utilizzare quando: esegui un agente headless e vuoi un rifiuto netto per ogni chiamata che altrimenti genererebbe una richiesta di conferma.

Modalità ignora autorizzazioni (bypassPermissions)

Approva automaticamente gli usi degli strumenti senza richiedere conferma, ad eccezione delle azioni che nessuna modalità approva automaticamente. Gli hook vengono comunque eseguiti e possono bloccare le operazioni se necessario. Su Linux e macOS, Claude Code rifiuta di avviarsi in questa modalità come root o sotto sudo al di fuori di una sandbox riconosciuta, e la query non riesce prima del primo turno.

[!WARNING]

Utilizzare con estrema cautela. Claude ha accesso completo al sistema in questa modalità. Utilizzare solo in ambienti controllati in cui si fidano di tutte le possibili operazioni.

allowed_tools non vincola questa modalità, e vengono approvate anche le chiamate agli strumenti che non hai elencato. Questi controlli si applicano comunque:

• Le regole deny, le regole esplicite ask e gli hook vengono valutati prima del controllo della modalità e possono comunque bloccare uno strumento.
• Gli strumenti connettore che la tua organizzazione ha impostato su ask, gli strumenti che richiedono interazione dell'utente, le rimozioni di percorsi critici riconosciute e i comandi Bash segnalati con Dangerous rm operation not ruled out continuano a passare al tuo callback canUseTool. Il controllo che riconosce le rimozioni di percorsi critici può non individuare alcuni comandi, e puoi disattivare la richiesta di conferma per la rimozione di percorsi critici. Al di fuori di una sessione cloud, passano al callback anche le chiamate agli strumenti personalizzati che la tua applicazione contrassegna come always_ask.
• Le protezioni della messaggistica tra sessioni si applicano comunque.

Modalità pianificazione (plan)

Claude esplora il codebase e produce un piano. Durante la pianificazione, le modifiche apportate con gli strumenti per i file di Claude al di fuori dei percorsi protetti raggiungono il tuo callback canUseTool, anche quando una regola allow corrisponde o un hook PreToolUse restituisce allow. Anche le chiamate a AskUserQuestion raggiungono il tuo callback, anche quando una regola allow indica lo strumento.

Quando la modalità auto è disponibile, Claude Code invia queste chiamate effettuate durante la pianificazione al classificatore della modalità auto per la revisione anziché al tuo callback, quando nessuna regola allow le approva:

• Comandi shell
• Recuperi web
• Ricerche web
• Chiamate agli strumenti MCP che il loro server contrassegna come di sola lettura

Questa revisione è attiva per impostazione predefinita. Per disattivarla, imposta useAutoModeDuringPlan su false nell'opzione settings che passi a query(), oppure nelle tue impostazioni utente. Mentre la revisione è disattivata, le ricerche web e le chiamate agli strumenti MCP contrassegnati come di sola lettura raggiungono il tuo callback.

Per i comandi shell e i recuperi web, la tabella mostra se ciascuna chiamata raggiunge il tuo callback:

Per sapere cosa succede dopo che il classificatore rifiuta diverse chiamate di seguito, consulta Soglie di blocchi ripetuti.

[!NOTE]

Nell'SDK TypeScript, se imposti allowDangerouslySkipPermissions: true insieme a permissionMode: 'plan', le modifiche ai file raggiungono comunque il tuo callback canUseTool. Per passare in seguito a bypassPermissions con setPermissionMode() una sessione che inizia in plan mode, devi impostare allowDangerouslySkipPermissions fin dall'inizio.

Utilizzare quando: vuoi che Claude produca prima un piano, ad esempio durante la code review o prima di una modifica di grandi dimensioni.

Modalità auto (auto)

Un modello classificatore esamina azioni come comandi shell e richieste di rete prima che vengano eseguite, e consente o blocca ciascuna di quelle che esamina. Per i modelli e i provider richiesti dalla modalità auto e l'ordine in cui valuta le azioni, consulta Eliminare le richieste di permesso con la modalità auto.

Se passi una sessione in modalità auto a un modello che la modalità auto non supporta, usando set_model(), setModel() o applyFlagSettings(), la sessione passa alla modalità default:

• Cosa vedi: un messaggio system con sottotipo status e permissionMode impostato su "default", che il TypeScript SDK tipizza come SDKStatusMessage. Da quel momento, le chiamate che richiedono approvazione e non corrispondono a nessuna regola allow raggiungono il tuo callback canUseTool.
• Per tornare alla modalità auto: passa a un modello supportato, quindi chiama set_permission_mode("auto") o setPermissionMode("auto"). Se ripristini il modello senza effettuare quella chiamata, la sessione rimane in modalità default. Mentre il modello non supportato è attivo, la chiamata non riesce con Cannot set permission mode to auto: auto mode unavailable for this model.

Il passaggio alla modalità default dopo una chiamata a set_model(), setModel() o applyFlagSettings() richiede Claude Code v2.1.299 o successivo.

Risorse correlate

Per gli altri passaggi nel flusso di valutazione delle autorizzazioni:

• Gestire approvazioni e input dell'utente: prompt di approvazione interattivi e domande di chiarimento
• Guida hooks: eseguire codice personalizzato nei punti chiave del ciclo di vita dell'agente
• Regole di autorizzazione: regole dichiarative di consentimento/negazione in settings.json