6 6
7> Controlla come il tuo agente utilizza gli strumenti con modalità di permesso, hook e regole dichiarative di consentimento/negazione.7> Controlla come il tuo agente utilizza gli strumenti con modalità di permesso, hook e regole dichiarative di consentimento/negazione.
8 8
9Claude Agent SDK fornisce controlli di permesso per gestire come Claude utilizza gli strumenti. Utilizza modalità di permesso e regole per definire cosa è consentito automaticamente, e il callback [`canUseTool`](/docs/it/agent-sdk/user-input) per gestire tutto il resto in fase di esecuzione.9Claude 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`](/docs/it/agent-sdk/user-input) per gestire tutto il resto in fase di esecuzione.
10 10
11<h2 id="how-permissions-are-evaluated">11<h2 id="how-permissions-are-evaluated">
12 Come vengono valutati i permessi12 Come vengono valutate le autorizzazioni
13</h2>13</h2>
14 14
15Quando Claude richiede uno strumento, l'SDK controlla i permessi in questo ordine:15Quando Claude richiede uno strumento, l'SDK controlla le autorizzazioni in questo ordine:
16 16
17<Steps>17<Steps>
18 <Step title="Hooks">18 <Step title="Hooks">
19 Esegui [hooks](/docs/it/agent-sdk/hooks) per primo. Un hook può negare la chiamata completamente o trasmetterla. Un hook che restituisce `allow` non salta le regole di negazione e richiesta di seguito; quelle vengono valutate indipendentemente dal risultato dell'hook. Un hook `PreToolUse` allow inoltre non può approvare una rimozione `rm` o `rmdir` che prende di mira un [percorso critico](/docs/it/permission-modes#critical-paths).19 Eseguire prima gli [hooks](/docs/it/agent-sdk/hooks). Un hook può negare la chiamata completamente o lasciarla passare. Un hook che restituisce `allow` non salta le regole di negazione e richiesta di seguito; quelle vengono valutate indipendentemente dal risultato dell'hook. Un hook `PreToolUse` allow inoltre non può approvare una rimozione `rm` o `rmdir` che prende di mira un [percorso critico](/docs/it/permission-modes#critical-paths).
20 </Step>20 </Step>
21 21
22 <Step title="Regole di negazione">22 <Step title="Regole di negazione">
23 Controlla le regole `deny` (da `disallowed_tools` e [settings.json](/docs/it/settings-reference#permission-settings)). Se una regola di negazione corrisponde, lo strumento viene bloccato, anche in modalità `bypassPermissions`. Le regole di negazione con nome semplice come `Bash` rimuovono lo strumento dal contesto di Claude prima che questa valutazione inizi, quindi solo le regole con ambito come `Bash(rm *)` vengono controllate in questo passaggio.23 Controllare le regole `deny` (da `disallowed_tools` e [settings.json](/docs/it/settings-reference#permission-settings)). Se una regola di negazione corrisponde, lo strumento viene bloccato, anche in modalità `bypassPermissions`. Le regole di negazione con nome semplice come `Bash` rimuovono lo strumento dal contesto di Claude prima che questa valutazione inizi, quindi solo le regole con ambito come `Bash(rm *)` vengono controllate in questo passaggio.
24 </Step>24 </Step>
25 25
26 <Step title="Regole di richiesta">26 <Step title="Regole di richiesta">
27 Controlla le regole `ask` da [settings.json](/docs/it/settings-reference#permission-settings). Se una regola di richiesta corrisponde, la chiamata passa al tuo callback [`canUseTool`](/docs/it/agent-sdk/user-input) per la conferma, anche in modalità `bypassPermissions`.27 Controllare le regole `ask` da [settings.json](/docs/it/settings-reference#permission-settings). Se una regola di richiesta corrisponde, la chiamata passa al vostro callback [`canUseTool`](/docs/it/agent-sdk/user-input) per la conferma, anche in modalità `bypassPermissions`.
28 28
29 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"]`](/docs/it/mcp#require-approval-for-a-specific-tool) passano sempre al callback, anche quando una regola di consentimento corrisponde. In modalità `dontAsk` entrambi i casi vengono negati invece, perché quella modalità non richiede mai conferma. L'annotazione MCP richiede Claude Code v2.1.199 o successivo.29 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"]`](/docs/it/mcp#require-approval-for-a-specific-tool) passano sempre al callback, anche quando una regola di autorizzazione corrisponde. In modalità `dontAsk` entrambi i casi vengono negati, perché quella modalità non richiede mai. L'annotazione MCP richiede Claude Code v2.1.199 o successivo.
30 30
31 Gli strumenti del connettore [claude.ai](/docs/it/mcp#organization-controls-on-connector-tools) che la tua organizzazione ha impostato su `ask` lasciano anche il flusso in questo passaggio. Ogni chiamata passa al callback, anche in modalità `bypassPermissions` e anche quando una regola di consentimento corrisponde. Il callback riceve il motivo `La tua organizzazione richiede l'approvazione per questo strumento`. In modalità `dontAsk` la chiamata viene negata invece, perché quella modalità non richiede mai conferma.31 Gli strumenti del connettore [claude.ai](/docs/it/mcp#organization-controls-on-connector-tools) che la vostra organizzazione ha impostato su `ask` lasciano anche il flusso in questo passaggio. Ogni chiamata passa al callback, anche in modalità `bypassPermissions` e anche quando una regola di autorizzazione corrisponde. Il callback riceve il motivo `Your organization requires approval for this tool`. In modalità `dontAsk` la chiamata viene negata, perché quella modalità non richiede mai.
32 </Step>32 </Step>
33 33
34 <Step title="Modalità di permesso">34 <Step title="Modalità di autorizzazione">
35 Applica la [modalità di permesso](#permission-modes) attiva:35 Applicare la [modalità di autorizzazione](#permission-modes) attiva:
36 36
37 * In modalità `bypassPermissions`, Claude Code approva tutto ciò che raggiunge questo passaggio tranne le rimozioni `rm` e `rmdir` che prendono di mira un [percorso critico](/docs/it/permission-modes#critical-paths), che passano invece.37 * In modalità `bypassPermissions`, Claude Code approva tutto ciò che raggiunge questo passaggio tranne le rimozioni `rm` e `rmdir` che prendono di mira un [percorso critico](/docs/it/permission-modes#critical-paths), che passano invece.
38 * In modalità `acceptEdits`, Claude Code approva le operazioni su file elencate in [Modalità accetta modifiche](#accept-edits-mode-acceptedits).38 * In modalità `acceptEdits`, Claude Code approva le operazioni su file elencate in [Modalità accetta modifiche](#accept-edits-mode-acceptedits).
39 * In modalità `plan`, Claude Code invia gli strumenti di modifica file e scrittura shell al tuo callback `canUseTool` indipendentemente dalle regole di consentimento, quindi le operazioni di scrittura non possono essere approvate automaticamente durante la pianificazione.39 * In modalità `plan`, Claude Code invia gli strumenti di modifica file e scrittura shell al vostro callback `canUseTool` indipendentemente dalle regole di autorizzazione, in modo che le operazioni di scrittura non possano essere approvate automaticamente durante la pianificazione.
40 * Nelle altre modalità, la richiesta passa oltre.40 * In altre modalità, la richiesta passa.
41 </Step>41 </Step>
42 42
43 <Step title="Regole di consentimento">43 <Step title="Regole di autorizzazione">
44 Controlla le regole `allow` (da `allowed_tools` e settings.json). Se una regola corrisponde, lo strumento viene approvato. Una chiamata che lo strumento approva da solo viene risolta in questo passaggio anche, senza alcuna regola necessaria: ad esempio una lettura di file all'interno delle tue directory di lavoro o un [comando Bash di sola lettura](/docs/it/permissions#read-only-commands). Le rimozioni `rm` e `rmdir` che prendono di mira un [percorso critico](/docs/it/permission-modes#critical-paths) non vengono mai approvate da una regola di consentimento: raggiungono il tuo callback nelle modalità che richiedono conferma, vanno al [classificatore](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) in modalità `auto` su Claude Code v2.1.218 o successivo, e vengono negate in modalità `dontAsk`.44 Controllare le regole `allow` (da `allowed_tools` e settings.json). Se una regola corrisponde, lo strumento viene approvato. 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 vostre directory di lavoro o un [comando Bash di sola lettura](/docs/it/permissions#read-only-commands). Le rimozioni `rm` e `rmdir` che prendono di mira un [percorso critico](/docs/it/permission-modes#critical-paths) non vengono mai approvate da una regola di autorizzazione: raggiungono il vostro callback nelle modalità che richiedono, vanno al [classificatore](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) in modalità `auto` su Claude Code v2.1.218 o successivo, e vengono negate in modalità `dontAsk`.
45 </Step>45 </Step>
46 46
47 <Step title="Callback canUseTool">47 <Step title="Callback canUseTool">
48 Se non risolto da nessuno dei precedenti, chiama il tuo callback [`canUseTool`](/docs/it/agent-sdk/user-input) per una decisione. In modalità `dontAsk`, questo passaggio viene saltato e lo strumento viene negato.48 Se non risolto da nessuno dei precedenti, chiamare il vostro callback [`canUseTool`](/docs/it/agent-sdk/user-input) per una decisione. In modalità `dontAsk`, questo passaggio viene saltato e lo strumento viene negato.
49 49
50 Nell'SDK TypeScript, se imposti [`permissionPrompts: 'none'`](/docs/it/agent-sdk/typescript#options), il tuo callback non viene chiamato in questo passaggio. Un hook [`PermissionRequest`](/docs/it/hooks#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.50 Nell'SDK TypeScript, se impostate [`permissionPrompts: 'none'`](/docs/it/agent-sdk/typescript#options), il vostro callback non viene chiamato in questo passaggio. Un hook [`PermissionRequest`](/docs/it/hooks#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.
51 </Step>51 </Step>
52</Steps>52</Steps>
53 53
54<img src="https://mintcdn.com/claude-code/jYgs7qigNjO1Badj/images/agent-sdk/permissions-flow.svg?fit=max&auto=format&n=jYgs7qigNjO1Badj&q=85&s=c771ad9085b1277d3708027a49c744bc" className="dark:hidden" alt="Diagramma del flusso di valutazione dei permessi in sei passaggi che corrisponde ai passaggi precedenti: una richiesta di strumento passa attraverso hook, regole di negazione, regole di richiesta, modalità di permesso, regole di consentimento e canUseTool. Hook, regole di negazione e canUseTool possono instradare verso Bloccato; bypass della modalità di permesso, regole di consentimento e canUseTool possono instradare verso Esegui; regole di richiesta instradano verso canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow.svg" />54<img src="https://mintcdn.com/claude-code/jYgs7qigNjO1Badj/images/agent-sdk/permissions-flow.svg?fit=max&auto=format&n=jYgs7qigNjO1Badj&q=85&s=c771ad9085b1277d3708027a49c744bc" className="dark:hidden" alt="Diagramma del flusso di valutazione delle autorizzazioni in sei passaggi che corrisponde ai passaggi precedenti: una richiesta di strumento passa attraverso hook, regole di negazione, regole di richiesta, modalità di autorizzazione, regole di autorizzazione e canUseTool. Hook, regole di negazione e canUseTool possono instradare verso il basso a Bloccato; bypass della modalità di autorizzazione, regole di autorizzazione e canUseTool possono instradare verso l'alto a Esegui; le regole di richiesta instradano a canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow.svg" />
55 55
56<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/agent-sdk/permissions-flow-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=e53a91e9059cbf51852b7cedb4dd4251" className="hidden dark:block" alt="Diagramma del flusso di valutazione dei permessi in sei passaggi che corrisponde ai passaggi precedenti: una richiesta di strumento passa attraverso hook, regole di negazione, regole di richiesta, modalità di permesso, regole di consentimento e canUseTool. Hook, regole di negazione e canUseTool possono instradare verso Bloccato; bypass della modalità di permesso, regole di consentimento e canUseTool possono instradare verso Esegui; regole di richiesta instradano verso canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow-dark.svg" />56<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/agent-sdk/permissions-flow-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=e53a91e9059cbf51852b7cedb4dd4251" className="hidden dark:block" alt="Diagramma del flusso di valutazione delle autorizzazioni in sei passaggi che corrisponde ai passaggi precedenti: una richiesta di strumento passa attraverso hook, regole di negazione, regole di richiesta, modalità di autorizzazione, regole di autorizzazione e canUseTool. Hook, regole di negazione e canUseTool possono instradare verso il basso a Bloccato; bypass della modalità di autorizzazione, regole di autorizzazione e canUseTool possono instradare verso l'alto a Esegui; le regole di richiesta instradano a canUseTool." width="1180" height="260" data-path="images/agent-sdk/permissions-flow-dark.svg" />
57 57
58Se passi 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 del processo Node.js una volta quando la query viene costruita. Il codice dell'avviso è `CLAUDE_SDK_CAN_USE_TOOL_SHADOWED`. Due configurazioni lo attivano:58Se 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:
59 59
60* `permissionMode: 'bypassPermissions'`, che approva automaticamente ogni chiamata che raggiunge il passaggio della modalità di permesso a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves)60* `permissionMode: 'bypassPermissions'`, che approva automaticamente ogni chiamata che raggiunge il passaggio della modalità di autorizzazione a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves)
61* Ogni voce `allowedTools` semplice come `"Read"`, che approva automaticamente quello strumento intero prima che il callback sia consultato, a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves)61* Ogni voce `allowedTools` semplice come `"Read"`, che approva automaticamente quello strumento intero prima che il callback sia consultato, a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves)
62 62
63Le voci con uno specificatore come `Bash(ls *)` e la modalità `acceptEdits` non lo attivano, e le regole di consentimento provenienti da file di impostazioni non sono visibili al controllo.63Le voci con uno specificatore come `Bash(ls *)` e la modalità `acceptEdits` non lo attivano, e le regole di autorizzazione provenienti da file di impostazioni non sono visibili al controllo.
64 64
65Ascolta con `process.on('warning', ...)` e abbina il codice per registrarlo o sopprimerlo. Per controllare ogni chiamata di strumento indipendentemente dalla modalità e dalle regole, utilizza invece un hook [`PreToolUse`](/docs/it/agent-sdk/hooks).65Ascoltate con `process.on('warning', ...)` e abbinate il codice per registrarlo o sopprimerlo. Per controllare ogni chiamata di strumento indipendentemente dalla modalità e dalle regole, utilizzate invece un [hook `PreToolUse`](/docs/it/agent-sdk/hooks).
66 66
67Questa pagina si concentra su **regole di consentimento e negazione** e **modalità di permesso**. Per gli altri passaggi:67Questa pagina si concentra su **regole di autorizzazione e negazione** e **modalità di autorizzazione**. Per gli altri passaggi:
68 68
69* **Hooks:** esegui codice personalizzato per consentire, negare o modificare le richieste di strumenti. Vedi [Controllare l'esecuzione con gli hook](/docs/it/agent-sdk/hooks).69* **Hooks:** eseguire codice personalizzato per consentire, negare o modificare le richieste di strumenti. Vedere [Controllare l'esecuzione con gli hook](/docs/it/agent-sdk/hooks).
70* **Callback canUseTool:** richiedi agli utenti l'approvazione in fase di esecuzione, quando nessun passaggio precedente risolve la chiamata. Vedi [Gestire approvazioni e input dell'utente](/docs/it/agent-sdk/user-input).70* **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](/docs/it/agent-sdk/user-input).
71 71
72<h2 id="allow-and-deny-rules">72<h2 id="allow-and-deny-rules">
73 Regole di consentimento e negazione73 Regole di consentimento e negazione
74</h2>74</h2>
75 75
76`allowed_tools` e `disallowed_tools` (TypeScript: `allowedTools` / `disallowedTools`) aggiungono voci agli elenchi di regole di consentimento e negazione nel flusso di valutazione sopra. Se nominate uno dei [task-tracking tools](/docs/it/agent-sdk/todo-tracking#model-availability) in `allowed_tools`, Claude Code opta anche la sessione. Qualsiasi altro strumento non elencato in `allowed_tools` è ancora disponibile per Claude e una chiamata ad esso che necessita approvazione passa alla modalità di permesso. Le regole di negazione si comportano diversamente a seconda che denominino uno strumento o limitino un modello all'interno di uno.76`allowed_tools` e `disallowed_tools` (TypeScript: `allowedTools` / `disallowedTools`) aggiungono voci agli elenchi di regole di consentimento e negazione nel flusso di valutazione sopra descritto. Se nominate uno dei [strumenti di tracciamento delle attività](/docs/it/agent-sdk/todo-tracking#model-availability) in `allowed_tools`, Claude Code opta anche per la sessione. Qualsiasi altro strumento non elencato in `allowed_tools` è ancora disponibile per Claude, e una chiamata ad esso che necessita di approvazione passa attraverso la modalità di autorizzazione. Le regole di negazione si comportano diversamente a seconda che nominino uno strumento o limitino un modello all'interno di uno.
77 77
78| Opzione | Effetto |78| Opzione | Effetto |
79| :-------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |79| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
80| `allowed_tools=["Read", "Grep"]` | `Read` e `Grep` vengono approvati automaticamente. Gli altri strumenti non elencati qui esistono ancora e le chiamate ad essi che necessitano approvazione passano alla modalità di permesso e `canUseTool`. |80| `allowed_tools=["Read", "Grep"]` | `Read` e `Grep` sono approvati automaticamente. Gli altri strumenti non elencati qui esistono ancora, e le chiamate ad essi che necessitano di approvazione passano attraverso la modalità di autorizzazione e `canUseTool`. |
81| `disallowed_tools=["Bash"]` | La definizione dello strumento `Bash` viene rimossa dalla richiesta. Claude non vede lo strumento e non può tentarlo. |81| `disallowed_tools=["Bash"]` | La definizione dello strumento `Bash` viene rimossa dalla richiesta. Claude non vede lo strumento e non può tentarlo. |
82| `disallowed_tools=["Bash(rm *)"]` | `Bash` rimane disponibile. Le chiamate corrispondenti a `rm *` [come scritto](/docs/it/permissions#bash-rule-limits) vengono negate in ogni modalità di permesso, inclusa `bypassPermissions`. Altre chiamate `Bash`, incluso `/bin/rm`, passano alla modalità di permesso. |82| `disallowed_tools=["Bash(rm *)"]` | `Bash` rimane disponibile. Le chiamate che corrispondono a `rm *` [come scritto](/docs/it/permissions#bash-rule-limits) vengono negate in ogni modalità di autorizzazione, inclusa `bypassPermissions`. Le altre chiamate `Bash`, incluso `/bin/rm`, passano attraverso la modalità di autorizzazione. |
83| `disallowed_tools=["*"]` | Ogni definizione di strumento viene rimossa dalla richiesta. I glob dei nomi degli strumenti sono supportati nelle regole di negazione: `"*"` corrisponde a ogni strumento e `"mcp__*"` corrisponde a ogni strumento MCP su tutti i server. |83| `disallowed_tools=["*"]` | Ogni definizione di strumento viene rimossa dalla richiesta. I glob dei nomi degli strumenti sono supportati nelle regole di negazione: `"*"` corrisponde a ogni strumento e `"mcp__*"` corrisponde a ogni strumento MCP su tutti i server. |
84 84
85Le regole di consentimento 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 con un avviso di avvio e non approva automaticamente nulla.85Le regole di consentimento 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 avete 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 con un avviso di avvio e non approva automaticamente nulla.
86 86
87Le 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`; una regola `Write(path)` non viene mai abbinata dai controlli di permesso dei file.87Le 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`; una regola `Write(path)` non viene mai abbinata dai controlli di autorizzazione dei file.
88 88
89Utilizza `//path` per un percorso del file system assoluto: una regola di negazione di `Edit(//secrets/**)` blocca le scritture ovunque sotto `/secrets` su disco. Con una singola barra iniziale, `Edit(/secrets/**)` si ancora alla fonte della regola. Per le regole passate tramite `allowed_tools` o `disallowed_tools`, ciò significa la directory di lavoro della sessione, quindi la regola non blocca `/secrets` su disco. Vedi [Regole Read e Edit](/docs/it/permissions#read-and-edit) per i quattro moduli di ancoraggio e come le regole dai file di impostazioni si risolvono.89Utilizzate `//path` per un percorso del filesystem assoluto: una regola di negazione di `Edit(//secrets/**)` blocca le scritture ovunque sotto `/secrets` su disco. Con una singola barra iniziale, `Edit(/secrets/**)` si ancora alla fonte della regola. Per le regole passate attraverso `allowed_tools` o `disallowed_tools`, ciò significa la directory di lavoro della sessione, quindi la regola non blocca `/secrets` su disco. Consultate [Regole Read e Edit](/docs/it/permissions#read-and-edit) per i quattro moduli di ancoraggio e come le regole dai file di impostazioni si risolvono.
90 90
91<Warning>91<Warning>
92 **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 di consentimento, salta il tuo callback `canUseTool`, quindi i controlli di permesso che inserisci lì vengono silenziosamente ignorati per quello strumento. `AskUserQuestion`, gli strumenti MCP contrassegnati [`_meta["anthropic/requiresUserInteraction"]`](/docs/it/mcp#require-approval-for-a-specific-tool), gli strumenti connettore [che la tua organizzazione ha impostato su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), e le rimozioni `rm` e `rmdir` che puntano a un [percorso critico](/docs/it/permission-modes#critical-paths) raggiungono comunque il callback, anche quando una regola di consentimento corrisponde. In modalità `auto`, le rimozioni di percorsi critici vanno al [classificatore](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) invece del callback, mentre le altre chiamate elencate qui lo raggiungono ancora; il routing del classificatore richiede Claude Code v2.1.218 o successivo. In modalità `dontAsk` queste chiamate vengono invece negate, senza invocare il callback.92 **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 di consentimento, salta il callback `canUseTool`, quindi i controlli di autorizzazione che inserite lì vengono silenziosamente ignorati per quello strumento. `AskUserQuestion`, gli strumenti MCP contrassegnati [`_meta["anthropic/requiresUserInteraction"]`](/docs/it/mcp#require-approval-for-a-specific-tool), gli strumenti del connettore [che la vostra organizzazione ha impostato su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), e le rimozioni `rm` e `rmdir` che puntano a un [percorso critico](/docs/it/permission-modes#critical-paths) raggiungono ancora il callback, anche quando una regola di consentimento corrisponde. In modalità `auto`, le rimozioni di percorsi critici vanno al [classificatore](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) invece del callback, mentre le altre chiamate elencate qui lo raggiungono ancora; il routing del classificatore richiede Claude Code v2.1.218 o successivo. In modalità `dontAsk` queste chiamate vengono invece negate, senza invocare il callback.
93 93
94 La copertura dipende dalla forma della voce: un nome semplice come `Read` o `mcp__github__get_issue` approva automaticamente ogni chiamata a quello strumento a parte le eccezioni sopra, mentre una regola limitata come `Bash(npm test *)` approva automaticamente solo le chiamate corrispondenti e altre chiamate `Bash` che necessitano approvazione passano comunque al callback. Per i controlli che devono essere eseguiti su ogni chiamata a uno strumento, utilizza un hook [`PreToolUse`](/docs/it/agent-sdk/hooks): gli hook vengono eseguiti prima di ogni altro passaggio e un hook di negazione si applica anche in modalità `bypassPermissions`.94 La copertura dipende dalla forma della voce: un nome semplice come `Read` o `mcp__github__get_issue` approva automaticamente ogni chiamata a quello strumento a parte le eccezioni sopra, mentre una regola limitata come `Bash(npm test *)` approva automaticamente solo le chiamate corrispondenti, e le altre chiamate `Bash` che necessitano di approvazione passano ancora attraverso il callback. Per i controlli che devono essere eseguiti su ogni chiamata a uno strumento, utilizzate un [hook `PreToolUse`](/docs/it/agent-sdk/hooks): gli hook vengono eseguiti prima di ogni altro passaggio, e un hook di negazione si applica anche in modalità `bypassPermissions`.
95</Warning>95</Warning>
96 96
97Per un agente bloccato, abbina `allowedTools` con `permissionMode: "dontAsk"`:97Per un agente bloccato, abbinate `allowedTools` con `permissionMode: "dontAsk"`:
98 98
99```typescript theme={null}99```typescript theme={null}
100const options = {100const options = {
103};103};
104```104```
105 105
106Gli strumenti elencati vengono approvati, a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves), e ogni altra chiamata che comporterebbe una richiesta viene invece negata. Le chiamate che non necessitano approvazione in modalità `default` vengono eseguite indipendentemente dal fatto che le elenchi, come i [comandi Bash di sola lettura](/docs/it/permissions#read-only-commands), strumenti come `Agent` che non chiedono prima di eseguire, e letture di file all'interno delle tue directory di lavoro. Per mettere uno strumento completamente fuori dalla portata di Claude, aggiungi il suo nome semplice a `disallowedTools`.106Gli strumenti elencati sono approvati, a parte le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves), e ogni altra chiamata che comporterebbe una richiesta viene invece negata. Le chiamate che non necessitano di approvazione in modalità `default` vengono eseguite indipendentemente dal fatto che le elenchiate, come i [comandi Bash di sola lettura](/docs/it/permissions#read-only-commands), strumenti come `Agent` che non chiedono prima di eseguire, e letture di file all'interno delle vostre directory di lavoro. Per mettere uno strumento completamente fuori dalla portata di Claude, aggiungete il suo nome semplice a `disallowedTools`.
107 107
108<Warning>108<Warning>
109 **`allowed_tools` non vincola `bypassPermissions`.** `allowed_tools` pre-approva gli strumenti che elenchi. Gli strumenti non elencati non vengono abbinati da alcuna regola di consentimento e passano alla modalità di permesso, dove `bypassPermissions` li approva. Impostare `allowed_tools=["Read"]` insieme a `permission_mode="bypassPermissions"` approva comunque ogni strumento, inclusi `Bash`, `Write` e `Edit`. Se hai bisogno di `bypassPermissions` ma vuoi bloccare strumenti specifici, usa `disallowed_tools`.109 **`allowed_tools` non vincola `bypassPermissions`.** `allowed_tools` pre-approva gli strumenti che elencate. Gli altri strumenti non elencati non vengono abbinati da alcuna regola di consentimento e passano attraverso la modalità di autorizzazione, dove `bypassPermissions` li approva. L'impostazione di `allowed_tools=["Read"]` insieme a `permission_mode="bypassPermissions"` approva comunque ogni strumento, inclusi `Bash`, `Write` e `Edit`. Se avete bisogno di `bypassPermissions` ma volete che strumenti specifici siano bloccati, utilizzate `disallowed_tools`.
110</Warning>110</Warning>
111 111
112Puoi anche configurare regole di consentimento, negazione e richiesta in modo dichiarativo in `.claude/settings.json`. Queste regole vengono lette quando la fonte di impostazione `project` è abilitata, il che è il caso per le opzioni predefinite di `query()`. Se imposti `setting_sources` (TypeScript: `settingSources`) esplicitamente, includi `"project"` affinché si applichino. Vedi [Impostazioni di permesso](/docs/it/settings-reference#permission-settings) per la sintassi delle regole.112Potete anche configurare le regole di consentimento, negazione e richiesta 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](/docs/it/settings-reference#permission-settings) per la sintassi delle regole.
113 113
114<h2 id="permission-modes">114<h2 id="permission-modes">
115 Modalità di permesso115 Modalità di autorizzazione
116</h2>116</h2>
117 117
118Le modalità di permesso forniscono un controllo globale su come Claude utilizza gli strumenti. Puoi impostare la modalità di permesso quando chiami `query()` o cambiarla dinamicamente durante le sessioni di streaming.118Le 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.
119 119
120<h3 id="available-modes">120<h3 id="available-modes">
121 Modalità disponibili121 Modalità disponibili
122</h3>122</h3>
123 123
124L'SDK supporta queste modalità di permesso:124L'SDK supporta queste modalità di autorizzazione:
125 125
126| Modalità | Descrizione | Comportamento dello strumento |126| Modalità | Descrizione | Comportamento dello strumento |
127| :------------------ | :------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |127| :------------------ | :------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
128| `default` | Comportamento di permesso standard | Nessuna approvazione automatica basata sulla modalità; le chiamate che necessitano di approvazione e non corrispondono a nessuna regola di consentimento attivano il tuo callback `canUseTool` |128| `default` | Comportamento di autorizzazione standard | Nessuna approvazione automatica basata sulla modalità; le chiamate che richiedono approvazione e non corrispondono a nessuna regola di autorizzazione attivano il callback `canUseTool` |
129| `dontAsk` | Nega invece di richiedere | Qualsiasi chiamata che altrimenti richiederebbe viene negata. Le chiamate approvate da `allowed_tools` o regole vengono eseguite, così come le chiamate che non necessitano di approvazione in modalità `default`; gli strumenti del connettore [che la tua organizzazione ha impostato su `ask`](/docs/it/mcp#organization-controls-on-connector-tools) e gli strumenti che richiedono l'interazione dell'utente vengono negati anche se li hai pre-approvati, così come le rimozioni `rm` e `rmdir` che puntano a un [percorso critico](/docs/it/permission-modes#critical-paths). `canUseTool` non viene mai chiamato |129| `dontAsk` | Nega invece di chiedere | Qualsiasi chiamata che altrimenti richiederebbe una richiesta viene negata. Le chiamate approvate da `allowed_tools` o regole vengono eseguite, così come le chiamate che non richiedono approvazione in modalità `default`, come le letture di file all'interno delle directory di lavoro; gli strumenti connector [impostati dalla vostra organizzazione su `ask`](/docs/it/mcp#organization-controls-on-connector-tools) e gli strumenti che richiedono interazione dell'utente vengono negati anche se li avete pre-approvati, così come le rimozioni `rm` e `rmdir` che interessano un [percorso critico](/docs/it/permission-modes#critical-paths). `canUseTool` non viene mai chiamato |
130| `acceptEdits` | Accetta automaticamente le modifiche ai file | Le modifiche ai file e le [operazioni del filesystem](#accept-edits-mode-acceptedits) (`mkdir`, `rm`, `mv`, ecc.) vengono approvate automaticamente |130| `acceptEdits` | Accetta automaticamente le modifiche ai file | Le modifiche ai file e le [operazioni del filesystem](#accept-edits-mode-acceptedits) (`mkdir`, `rm`, `mv`, ecc.) vengono approvate automaticamente |
131| `bypassPermissions` | Ignora i controlli di permesso | Gli strumenti vengono eseguiti senza richieste di permesso, ad eccezione delle [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves). Usare con cautela |131| `bypassPermissions` | Ignora i controlli di autorizzazione | Gli strumenti vengono eseguiti senza richieste di autorizzazione, ad eccezione delle [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves). Utilizzare con cautela |
132| `plan` | Modalità di pianificazione | Claude esplora e pianifica senza modificare i tuoi file sorgente; le modifiche ai file non vengono mai approvate automaticamente e richiedono il tuo callback `canUseTool` |132| `plan` | Modalità di pianificazione | Claude esplora e pianifica senza modificare i file sorgente; le modifiche ai file non vengono mai approvate automaticamente e richiedono il callback `canUseTool` |
133| `auto` | Approvazioni classificate dal modello | Un classificatore di modello approva o nega le richieste di permesso. Vedi [Auto mode](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) per la disponibilità |133| `auto` | Approvazioni classificate dal modello | Un classificatore del modello approva o nega le richieste di autorizzazione. Vedere [Modalità Auto](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) per la disponibilità |
134 134
135<Warning>135<Warning>
136 **Eredità del subagente:** Un subagente viene eseguito nella modalità di permesso della sessione genitore a meno che tu non imposti `permissionMode` sulla sua [`AgentDefinition`](/docs/it/agent-sdk/typescript#agentdefinition) e la sessione genitore sia in modalità `default`, `dontAsk` o `plan`. Anche in questo caso, Claude Code non applica mai un valore `"bypassPermissions"`. Un subagente viene eseguito in modalità `bypassPermissions` solo quando la sessione genitore stessa lo fa. L'eccezione `bypassPermissions` richiede Claude Code v2.1.267 o successivo.136 **Ereditarietà dei subagent:** Un subagent viene eseguito nella modalità di autorizzazione della sessione padre a meno che non si imposti `permissionMode` sulla sua [`AgentDefinition`](/docs/it/agent-sdk/typescript#agentdefinition) e la sessione padre sia in modalità `default`, `dontAsk` o `plan`. Anche in questo caso, Claude Code non applica mai un valore `"bypassPermissions"`. Un subagent viene eseguito in modalità `bypassPermissions` solo quando la sessione padre stessa lo fa. L'eccezione `bypassPermissions` richiede Claude Code v2.1.267 o successivo.
137 137
138 I subagenti possono avere prompt di sistema diversi e comportamento meno vincolato rispetto al tuo agente principale, quindi ereditare `bypassPermissions` concede loro accesso completo e autonomo al sistema. Le [azioni che nessuna modalità approva automaticamente](/docs/it/permission-modes#actions-no-mode-auto-approves) si applicano comunque.138 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](/docs/it/permission-modes#actions-no-mode-auto-approves) si applicano comunque.
139</Warning>139</Warning>
140 140
141<h3 id="set-permission-mode">141<h3 id="set-permission-mode">
142 Impostare la modalità di permesso142 Impostare la modalità di autorizzazione
143</h3>143</h3>
144 144
145Puoi impostare la modalità di permesso una volta all'inizio di una query, o cambiarla dinamicamente mentre la sessione è attiva.145È possibile impostare la modalità di autorizzazione una volta all'avvio di una query, oppure modificarla dinamicamente mentre la sessione è attiva.
146 146
147<Tabs>147<Tabs>
148 <Tab title="Al momento della query">148 <Tab title="Al momento della query">
149 Passa `permission_mode` (Python) o `permissionMode` (TypeScript) quando crei una query. Questa modalità si applica per l'intera sessione a meno che non venga modificata dinamicamente.149 Passare `permission_mode` (Python) o `permissionMode` (TypeScript) quando si crea una query. Questa modalità si applica per l'intera sessione a meno che non venga modificata dinamicamente.
150 150
151 <CodeGroup>151 <CodeGroup>
152 ```python Python theme={null}152 ```python Python theme={null}
190 </Tab>190 </Tab>
191 191
192 <Tab title="Durante lo streaming">192 <Tab title="Durante lo streaming">
193 Chiama `set_permission_mode()` (Python) o `setPermissionMode()` (TypeScript) per cambiare la modalità a metà sessione. La nuova modalità ha effetto immediatamente per tutte le richieste di strumenti successive. Questo ti consente di iniziare in modo restrittivo e allentare i permessi man mano che la fiducia aumenta, ad esempio passando a `acceptEdits` dopo aver esaminato l'approccio iniziale di Claude.193 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.
194 194
195 <CodeGroup>195 <CodeGroup>
196 ```python Python theme={null}196 ```python Python theme={null}
254 Modalità accetta modifiche (`acceptEdits`)254 Modalità accetta modifiche (`acceptEdits`)
255</h4>255</h4>
256 256
257Approva automaticamente le operazioni su file in modo che Claude possa modificare il codice senza richiedere. Altri strumenti (come i comandi Bash che non sono operazioni del filesystem) richiedono comunque i permessi normali.257Approva 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.
258 258
259**Operazioni approvate automaticamente:**259**Operazioni approvate automaticamente:**
260 260
264Entrambi si applicano solo ai percorsi all'interno della directory di lavoro o `additionalDirectories`. In modalità `acceptEdits`, Claude Code non approva automaticamente la richiesta quando Claude:264Entrambi si applicano solo ai percorsi all'interno della directory di lavoro o `additionalDirectories`. In modalità `acceptEdits`, Claude Code non approva automaticamente la richiesta quando Claude:
265 265
266* Lavora su un percorso al di fuori di tale ambito266* Lavora su un percorso al di fuori di tale ambito
267* Scrive su un percorso protetto267* Scrive in un percorso protetto
268* Rimuove un [percorso critico](/docs/it/permission-modes#critical-paths) con `rm` o `rmdir`268* Rimuove un [percorso critico](/docs/it/permission-modes#critical-paths) con `rm` o `rmdir`
269 269
270**Usare quando:** ti fidi delle modifiche di Claude e desideri un'iterazione più veloce, ad esempio durante la prototipazione o quando lavori in una directory isolata.270**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.
271 271
272<h4 id="don’t-ask-mode-dontask">272<h4 id="don’t-ask-mode-dontask">
273 Modalità non chiedere (`dontAsk`)273 Modalità non chiedere (`dontAsk`)
274</h4>274</h4>
275 275
276Converte qualsiasi richiesta di permesso in una negazione, senza chiamare `canUseTool`. Gli strumenti pre-approvati da `allowed_tools`, regole di consentimento di `settings.json` o un hook vengono eseguiti normalmente, così come le chiamate che non necessitano di approvazione in modalità `default`, come le letture di file all'interno delle tue directory di lavoro e le chiamate a `Agent`. Gli strumenti del connettore [che la tua organizzazione ha impostato su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), gli strumenti che richiedono l'interazione dell'utente e le rimozioni `rm` e `rmdir` che puntano a un [percorso critico](/docs/it/permission-modes#critical-paths) vengono negati anche quando una regola di consentimento corrisponde. Un'autorizzazione di hook `PreToolUse` non cancella nemmeno una rimozione di percorso critico.276Converte qualsiasi richiesta di autorizzazione in una negazione, senza chiamare `canUseTool`. Gli strumenti pre-approvati da `allowed_tools`, regole di autorizzazione in `settings.json` o un hook vengono eseguiti normalmente, così come le chiamate che non richiedono approvazione in modalità `default`, come le letture di file all'interno delle directory di lavoro e le chiamate a `Agent`. Gli strumenti connector [impostati dalla vostra organizzazione su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), gli strumenti che richiedono interazione dell'utente e le rimozioni `rm` e `rmdir` che interessano un [percorso critico](/docs/it/permission-modes#critical-paths) vengono negati anche quando una regola di autorizzazione corrisponde. Un'autorizzazione del hook `PreToolUse` non cancella nemmeno una rimozione di percorso critico.
277 277
278**Usare quando:** desideri una superficie di strumenti fissa ed esplicita per un agente headless e preferisci una negazione definitiva rispetto a un affidamento silenzioso su `canUseTool` assente.278**Utilizzare quando:** si desidera una superficie di strumenti fissa ed esplicita per un agente headless e si preferisce un rifiuto netto rispetto all'affidamento silenzioso all'assenza di `canUseTool`.
279 279
280<h4 id="bypass-permissions-mode-bypasspermissions">280<h4 id="bypass-permissions-mode-bypasspermissions">
281 Modalità ignora permessi (`bypassPermissions`)281 Modalità ignora autorizzazioni (`bypassPermissions`)
282</h4>282</h4>
283 283
284Approva automaticamente gli usi degli strumenti senza richiedere, ad eccezione dei casi elencati nell'avvertenza di seguito. Gli hook vengono comunque eseguiti e possono bloccare le operazioni se necessario.284Approva automaticamente gli usi degli strumenti senza richiedere conferma, ad eccezione dei casi elencati nell'avviso di seguito. I hook vengono comunque eseguiti e possono bloccare le operazioni se necessario.
285 285
286<Warning>286<Warning>
287 Usare con estrema cautela. Claude ha accesso completo al sistema in questa modalità. Usare solo in ambienti controllati in cui ti fidi di tutte le operazioni possibili.287 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.
288 288
289 `allowed_tools` non vincola questa modalità. Ogni strumento viene approvato, non solo quelli che hai elencato. Questi controlli si applicano comunque:289 `allowed_tools` non vincola questa modalità. Ogni strumento è approvato, non solo quelli che avete elencato. Questi controlli si applicano comunque:
290 290
291 * Le regole di negazione, le regole esplicite `ask` e gli hook vengono valutati prima del controllo della modalità e possono comunque bloccare uno strumento.291 * Le regole di negazione, le regole esplicite `ask` e i hook vengono valutati prima del controllo della modalità e possono comunque bloccare uno strumento.
292 * Gli strumenti del connettore [che la tua organizzazione ha impostato su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), gli strumenti che richiedono l'interazione dell'utente e le rimozioni `rm` e `rmdir` che puntano a un [percorso critico](/docs/it/permission-modes#critical-paths) continuano a passare al tuo callback `canUseTool`.292 * Gli strumenti connector [impostati dalla vostra organizzazione su `ask`](/docs/it/mcp#organization-controls-on-connector-tools), gli strumenti che richiedono interazione dell'utente e le rimozioni `rm` e `rmdir` che interessano un [percorso critico](/docs/it/permission-modes#critical-paths) continuano a passare al callback `canUseTool`.
293 * I [safeguard di messaggistica tra sessioni](/docs/it/permission-modes#skip-all-checks-with-bypasspermissions-mode) si applicano comunque.293 * Le [protezioni della messaggistica tra sessioni](/docs/it/permission-modes#skip-all-checks-with-bypasspermissions-mode) si applicano comunque.
294</Warning>294</Warning>
295 295
296<h4 id="plan-mode-plan">296<h4 id="plan-mode-plan">
297 Modalità piano (`plan`)297 Modalità pianificazione (`plan`)
298</h4>298</h4>
299 299
300Claude esplora la base di codice e produce un piano senza modificare i tuoi file sorgente. Gli strumenti di sola lettura vengono eseguiti come in modalità `default`.300Claude esplora la base di codice e produce un piano senza modificare i file sorgente. Gli strumenti di sola lettura vengono eseguiti come nella modalità di autorizzazione `default`.
301 301
302Le modifiche ai file non vengono mai approvate automaticamente in modalità piano, anche quando una regola di consentimento corrisponde. Richiedono il tuo callback `canUseTool` invece. Su Claude Code v2.1.212 o successivo, i comandi shell che modificano file, come `touch` e `rm`, raggiungono il tuo callback `canUseTool` allo stesso modo.302Le modifiche ai file non vengono mai approvate automaticamente in modalità plan, anche quando una regola di autorizzazione corrisponde. Invece, richiedono il callback `canUseTool`. Su Claude Code v2.1.212 o successivo, i comandi shell che modificano i file, come `touch` e `rm`, raggiungono il callback `canUseTool` allo stesso modo.
303 303
304Claude può utilizzare `AskUserQuestion` per chiarire i requisiti prima di finalizzare il piano. Vedi [Gestire approvazioni e input dell'utente](/docs/it/agent-sdk/user-input#handle-clarifying-questions) per gestire queste richieste.304Claude può utilizzare `AskUserQuestion` per chiarire i requisiti prima di finalizzare il piano. Vedere [Gestire approvazioni e input dell'utente](/docs/it/agent-sdk/user-input#handle-clarifying-questions) per la gestione di queste richieste.
305 305
306**Usare quando:** desideri che Claude proponga modifiche senza eseguirle, ad esempio durante la revisione del codice o quando hai bisogno di approvare le modifiche prima che vengano apportate.306**Utilizzare quando:** si desidera che Claude proponga modifiche senza eseguirle, ad esempio durante la revisione del codice o quando è necessario approvare le modifiche prima che vengano apportate.
307 307
308<h2 id="related-resources">308<h2 id="related-resources">
309 Risorse correlate309 Risorse correlate
310</h2>310</h2>
311 311
312Per gli altri passaggi nel flusso di valutazione dei permessi:312Per gli altri passaggi nel flusso di valutazione delle autorizzazioni:
313 313
314* [Gestire approvazioni e input dell'utente](/docs/it/agent-sdk/user-input): richieste di approvazione interattive e domande di chiarimento314* [Gestire approvazioni e input dell'utente](/docs/it/agent-sdk/user-input): prompt di approvazione interattivi e domande di chiarimento
315* [Guida agli hook](/docs/it/agent-sdk/hooks): esegui codice personalizzato nei punti chiave del ciclo di vita dell'agente315* [Guida hooks](/docs/it/agent-sdk/hooks): eseguire codice personalizzato nei punti chiave del ciclo di vita dell'agente
316* [Regole di permesso](/docs/it/settings-reference#permission-settings): regole dichiarative di consentimento/negazione in `settings.json`316* [Regole di autorizzazione](/docs/it/settings-reference#permission-settings): regole dichiarative di consentimento/negazione in `settings.json`