> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Esegui chiamate agli strumenti dal codice con Code Mode

> Prova Code Mode, una funzionalità sperimentale in cui Claude scrive JavaScript che effettua diverse chiamate agli strumenti in un unico passaggio.

Code Mode cambia il modo in cui Claude usa i suoi [strumenti](https://code.claude.com/docs/it/tools-reference.md). Senza Code Mode, Claude richiede direttamente chiamate agli strumenti come Bash, Read o Edit e legge ogni risultato prima di decidere cosa fare dopo. Con Code Mode, Claude scrive un frammento di JavaScript che effettua le chiamate agli strumenti, e Claude Code esegue quel codice nella tua sessione.

> [!NOTE]
>
> Code Mode è sperimentale e disattivato per impostazione predefinita. Potrebbe cambiare o essere rimosso in qualsiasi release. Per condividere un feedback, esegui `/feedback`.

## Come funziona Code Mode

In una sessione Code Mode descrivi comunque la tua attività in un prompt, e Claude scrive JavaScript per portarla a termine. Un singolo frammento di codice può eseguire comandi in parallelo, usare un risultato nella chiamata successiva e restituire la parte dell'output che Claude deve leggere.

Ad esempio, se chiedi a Claude di aumentare un limite di nuovi tentativi, Claude potrebbe scrivere questo codice per trovare il file, modificarlo ed eseguire i test. L'ultima riga restituisce a Claude il percorso del file e l'output dei test:

```javascript theme={null}
const files = await $`rg -l "function retryPolicy" src`.text();
const target = files.trim().split("\n")[0];
await edit(target, "maxAttempts: 3", "maxAttempts: 5");
({ edited: target, tests: $`npm test -- retryPolicy`.nothrow() });
```

Nella conversazione vedi le chiamate agli strumenti, come il diff della modifica, e non il codice. Per leggere il codice, premi `Ctrl+O` per aprire il [visualizzatore della trascrizione](https://code.claude.com/docs/it/interactive-mode.md#transcript-viewer). Ogni frammento di codice vi appare come una riga **Code** compressa, con un suggerimento su come espanderla.

### Quando usare Code Mode

Prova Code Mode su attività che richiedono molte chiamate agli strumenti correlate, come:

* Una modifica che si ripete in molti file
* Una ricerca i cui risultati devono essere filtrati prima che Claude li legga
* Diversi comandi indipendenti che possono essere eseguiti contemporaneamente

### Limitazioni di Code Mode

Prima di attivare Code Mode, verifica di poter accettare questi limiti:

* **Ripresa**: puoi riprendere una sessione Code Mode solo nel terminale, con Code Mode attivo
* **Modalità auto**: il classificatore della modalità auto [esamina il codice, non ogni chiamata a uno strumento](#permission-checks)
* **Codice di lunga durata**: tranne quando [il codice può essere eseguito in background](#long-running-code), devi attendere che finisca, e si interrompe dopo dieci minuti
* **Hook**: puoi vedere [chiamate agli strumenti rifiutate](#tool-call-refused-by-a-hook) quando un hook `PreToolUse` non può essere eseguito o va in timeout, e [output del codice bloccato](#code-output-withheld-by-a-hook) da un hook `UserPromptSubmit`
* **Funzionalità non disponibili**: non puoi usare [Remote Control](https://code.claude.com/docs/it/remote-control.md), [Claude in Chrome](https://code.claude.com/docs/it/chrome.md) o [computer use](https://code.claude.com/docs/it/computer-use.md)
* **Spostamento della sessione**: non puoi spostare la sessione nell'app Desktop né trasformarla in una [sessione in background](https://code.claude.com/docs/it/agent-view.md), e `/fork` non può avviare una copia in background

## Requisiti

* **Versione**: Claude Code v2.1.323 o successiva, su uno qualsiasi dei due [canali di release](https://code.claude.com/docs/it/setup.md#configure-release-channel). Una versione precedente si avvia senza Code Mode, con o senza il motivo `it isn't open to your account yet`
* **Account**: un abbonamento Claude o un account Console. Non puoi usare Code Mode tramite un gateway, Amazon Bedrock, Claude Platform on AWS, Agent Platform di Google Cloud o Microsoft Foundry
* **Organizzazione**: la tua organizzazione non usa la [configurazione HIPAA](https://code.claude.com/docs/it/hipaa-setup.md) né la [conservazione zero dei dati](https://code.claude.com/docs/it/zero-data-retention.md)
* **Modello**: Claude Opus 5.5, Sonnet 5.5, Haiku 5.5 o Fable 5.2
* **Superficie**: una sessione `claude` interattiva in un terminale. Code Mode non funziona con `-p`, l'Agent SDK, il pannello di VS Code, l'app Desktop o le sessioni cloud
* **Installazione**: la [build nativa](https://code.claude.com/docs/it/setup.md) di Claude Code
* **Windows**: [Git for Windows](https://git-scm.com/downloads/win) è installato

Inoltre, non puoi avviare Code Mode con alcune impostazioni attive, come un helper per la chiave API, i team di agenti, l'esportazione OpenTelemetry o `DISABLE_TELEMETRY`. Per la soluzione relativa a ciascuna, consulta [Code Mode non si avvia](#code-mode-doesnt-start).

## Prova Code Mode

Attiva Code Mode, assegna un'attività a Claude e guarda il codice che Claude ha scritto.

**1. Controlla la tua versione**

Esegui `claude --version`. Se la versione è precedente alla v2.1.323, esegui `claude update`. Se sei sul canale `stable` e l'aggiornamento non raggiunge la v2.1.323, attendi che `stable` si allinei oppure [passa a `latest`](https://code.claude.com/docs/it/setup#configure-release-channel).

**2. Avvia Claude Code con Code Mode attivo**

Imposta la variabile d'ambiente [`CLAUDE_CODE_EXPERIMENTAL_CODE_MODE`](https://code.claude.com/docs/it/env-vars#variables) su `1`. Per provare Code Mode, impostala nella tua shell. Per attivare Code Mode per ogni nuova sessione, impostala nelle tue impostazioni utente.

> [tab] macOS, Linux, WSL
>
> ```bash theme={null}
> CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude
> ```

> [tab] Windows PowerShell
>
> ```powershell theme={null}
> $env:CLAUDE_CODE_EXPERIMENTAL_CODE_MODE = "1"
> claude
> ```

> [tab] settings.json
>
> Salva questo blocco `env` in `~/.claude/settings.json` e avvia `claude`:
>
> ```json theme={null}
> {
>   "env": {
>     "CLAUDE_CODE_EXPERIMENTAL_CODE_MODE": "1"
>   }
> }
> ```
>
> Claude Code [ignora questa variabile nei file di impostazioni di un progetto](https://code.claude.com/docs/it/settings-reference.md#variables-claude-code-ignores-in-env), quindi un repository che cloni non può attivare Code Mode al posto tuo.

**3. Conferma che vuoi Code Mode**

Claude Code ti chiede di confermare prima della tua prima sessione Code Mode. Seleziona **Yes, turn on Code Mode**. Claude Code si riavvia e mostra questa riga vicino all'inizio della sessione:

```text theme={null}
Code Mode (experimental) is on · this session can be resumed only with Code Mode on
```

Se vedi una riga diversa o nessuna riga, consulta [Code Mode non si avvia](#code-mode-doesnt-start).

**4. Assegna a Claude un'attività con molte chiamate agli strumenti**

In un progetto che conosci, invia un prompt come questo:

```text theme={null}
Read every Markdown file in this project and list the links that point to local files that don't exist.
```

**5. Leggi il codice che Claude ha scritto**

Premi `Ctrl+O` ed espandi una riga **Code** per vedere il JavaScript dietro le chiamate agli strumenti. Premi di nuovo `Ctrl+O` per tornare alla conversazione.

> [!WARNING]
>
> Per riprendere in seguito una sessione Code Mode, mantieni `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` impostata su `1` quando esegui `claude --continue` o `claude --resume`. Con Code Mode disattivato, Claude Code si rifiuta di riprendere la sessione. Le sessioni che hai avviato senza Code Mode riprendono senza Code Mode, anche con la variabile impostata.

### Disattiva Code Mode

Rimuovi `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` dalla tua shell e da `~/.claude/settings.json`, quindi avvia una nuova sessione. Puoi anche mantenere la variabile e cambiarne il valore in `0` in uno dei due posti. Con uno `0` in un posto, Code Mode resta disattivato anche se imposti `1` nell'altro.

### Blocca Code Mode per la tua organizzazione

Aggiungi `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` con il valore `0` alle tue [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) in modo che nessuno nella tua organizzazione possa usare Code Mode:

```json theme={null}
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_CODE_MODE": "0"
  }
}
```

Gli utenti che si trovano in una sessione Code Mode vi rimangono finché non escono o riavviano Claude Code. Dopodiché, i tuoi utenti si avviano senza Code Mode e non possono riprendere le loro sessioni Code Mode finché lo `0` è in vigore. Non puoi attivare Code Mode per i tuoi utenti dalle impostazioni gestite.

## Permessi e codice di lunga durata

La tua modalità di permesso determina come viene controllato il codice di Claude e se puoi parlare con Claude mentre il codice è in esecuzione.

### Controlli dei permessi

Ogni chiamata a uno strumento effettuata dal codice di Claude passa attraverso le tue [regole di permesso](https://code.claude.com/docs/it/permissions.md) `deny` e `ask` e i tuoi [hook `PreToolUse`](https://code.claude.com/docs/it/hooks#pretooluse). Non devi modificare una regola o un matcher per uno strumento come `Bash`. Oltre a regole e hook, in modalità auto un classificatore esamina il codice, e nelle modalità che chiedono conferma rispondi alle richieste di permesso:

* **[Modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode)**: il classificatore esamina ogni frammento di codice prima che venga eseguito, non ogni chiamata a uno strumento. Non vede i valori calcolati in fase di esecuzione, come un percorso preso dall'output di una ricerca, quindi mantieni regole o hook per le chiamate che devi controllare. Ti può comunque essere [chiesta conferma quando nuovo codice si avvia mentre è in esecuzione codice precedente](#permission-prompt-with-a-countdown)
* **Altre [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md)**: il codice si avvia senza revisione, e ti viene chiesta conferma per ogni chiamata a uno strumento per cui te la chiederebbe quella modalità

Per controllare il codice stesso, scrivi un hook `PreToolUse` che corrisponda a `REPL`, lo strumento che esegue il codice di Claude, e leggi il JavaScript da `tool_input.code`.

> [!WARNING]
>
> Le regole Bash corrispondono al testo dei comandi, quindi Claude può eseguire un comando negato [in una forma a cui la regola non corrisponde](https://code.claude.com/docs/it/permissions.md#bash-rule-limits), con o senza Code Mode. Per limiti che non dipendono dal testo dei comandi, consulta [sandboxing](https://code.claude.com/docs/it/sandboxing.md).

### Codice di lunga durata

Mentre il codice esegue una build o un test lunghi, Claude lo attende oppure lo lascia proseguire in background:

* **Attesa**: Claude risponde dopo che il codice è terminato, e il codice si interrompe dopo dieci minuti, incluso il tempo che passi sulle richieste di permesso
* **Background**: puoi continuare a parlare con Claude, e il codice può essere eseguito per un massimo di due ore

Per il codice in background, avvia la sessione in modalità auto o `bypassPermissions`. Se Claude continua ad attendere, controlla la modalità corrente e come hai avviato la sessione:

* **Sei passato a un'altra modalità**: premi `Shift+Tab` finché non torni alla modalità in cui hai iniziato
* **Hai iniziato in un'altra modalità, oppure hai scelto la sessione dall'elenco di `claude --resume`**: se la [modalità auto è disponibile](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) per te, esci, quindi esegui `claude --continue --permission-mode auto` con Code Mode attivo
* **Hai passato nomi di strumenti a `--tools`**: riavvia in modalità auto senza quel flag

## Risoluzione dei problemi

### Code Mode non si avvia

`Code Mode (experimental) isn't available` vicino all'inizio della sessione significa che Claude Code si è avviato senza Code Mode. Il motivo segue sulla stessa riga, e viene mostrato anche da `/status`. Trova il motivo in questa tabella, apporta la modifica e avvia una nuova sessione. Per un motivo non elencato, controlla i [requisiti](#requirements).

| Il motivo include | Cosa fare |
| :- | :- |
| `it isn't open to your account yet` | Se la tua versione è precedente alla v2.1.323, [aggiorna](#try-code-mode). Altrimenti, controlla la connessione di rete e riavvia. Se il motivo persiste, riprova un altro giorno |
| `it only works with the Anthropic API` | Rimuovi le impostazioni che instradano le richieste tramite un provider cloud, un gateway o un `ANTHROPIC_BASE_URL` personalizzato |
| `it doesn't work with an API key helper` | Rimuovi `apiKeyHelper`, `ANTHROPIC_AUTH_TOKEN` e qualsiasi header `Authorization` o `X-Api-Key` in `ANTHROPIC_CUSTOM_HEADERS`. Quindi accedi o imposta `ANTHROPIC_API_KEY` |
| `it only works with Opus 5.5, Sonnet 5.5 and later models` | Avvia con un [modello supportato](#requirements), ad esempio con `--model opus`. Funzionano anche Haiku 5.5 e Fable 5.2 |
| `it doesn't work in background jobs` | Avvia in primo piano, senza `--remote-control` |
| `it needs settings that Claude Code downloads from Anthropic` | Rimuovi la variabile che [disattiva il recupero dei feature flag](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), come `DISABLE_TELEMETRY` |
| `OpenTelemetry is on` | Rimuovi `CLAUDE_CODE_ENABLE_TELEMETRY` e `ENABLE_BETA_TRACING_DETAILED` se puoi lavorare senza l'[esportazione OpenTelemetry](https://code.claude.com/docs/it/monitoring-usage.md) |
| `it doesn't yet work with an installed mod` | Disattiva il [mod](https://code.claude.com/docs/it/plugins/mods/overview.md) che controlla le chiamate agli strumenti |
| `it can't be used together with agent teams yet` | Rimuovi `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` |
| `this launch's tool options` | Avvia senza `--restricted`, aggiungi `REPL` a `--tools` e rimuovi `REPL` da `--disallowedTools` e dalle tue regole `deny` |
| `couldn't save your answer` | Rendi `~/.claude.json` scrivibile |
| `your organization's settings don't allow it` | Chiedi al tuo amministratore dell'[impostazione gestita](#block-code-mode-for-your-organization) |

Se non vedi alcuna riga relativa a Code Mode, esegui `claude --version`. Se la tua versione è precedente alla v2.1.323, aggiorna. Quindi verifica che `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` sia `1` nella tua shell o nelle impostazioni utente, e rimuovi qualsiasi `0` da queste e da qualsiasi file `--settings`.

### Richiesta di permesso con un conto alla rovescia

Quando Claude avvia altro codice in modalità auto mentre del codice precedente è ancora in esecuzione, il codice precedente perde la revisione del classificatore. Claude Code ti chiede quindi conferma per le chiamate rimanenti del codice precedente che richiederebbero una revisione. Senza alcun IDE connesso, la richiesta mostra un conto alla rovescia:

```text theme={null}
Claude Code will automatically block this request in 1:59, to avoid holding up an unattended session
```

Rispondi prima che il conto alla rovescia termini. Altrimenti quella chiamata viene rifiutata, e le chiamate successive che mostrerebbero un conto alla rovescia vengono rifiutate senza richiesta. Per vedere di nuovo le richieste, invia un messaggio a Claude.

### Chiamata a uno strumento rifiutata da un hook

Se Claude segnala una chiamata a uno strumento rifiutata, chiedigli il testo dell'errore. Questi errori indicano che un hook `PreToolUse` non ha fornito una decisione, il che rifiuta la chiamata anche quando [`onFailure`](https://code.claude.com/docs/it/hooks#block-the-action-when-a-hook-fails) non è impostato:

* **`the hook failed`**: su una chiamata dal codice di Claude, il tuo hook non è riuscito ad avviarsi, è stato terminato, è uscito con 126, 127 o un codice superiore a 128, oppure ha restituito un errore HTTP o un output non valido. Correggi l'hook
* **`the hook did not finish`**: il tuo hook è andato in timeout su una chiamata dal codice di Claude, oppure su qualsiasi altra chiamata a uno strumento dopo che Claude ha eseguito codice nella sessione. Aumenta il [`timeout`](https://code.claude.com/docs/it/hooks#common-fields) dell'hook

Per consentire alle chiamate di procedere quando un hook `command` o `http` fallisce o va in timeout, imposta `"onFailure": "continue"` su di esso. Se un hook `command` esce con un codice ordinario come 1, la chiamata procede a meno che tu non imposti `"onFailure": "block"`.

### Output del codice trattenuto da un hook

Se Claude riporta il motivo di blocco di un hook dove ti aspettavi l'output del codice di Claude, controlla i tuoi hook [`UserPromptSubmit`](https://code.claude.com/docs/it/hooks#userpromptsubmit). Quando [il codice può essere eseguito in background](#long-running-code), gli hook `command`, `http` e `mcp_tool` su quell'evento vengono eseguiti anche sull'output del codice. Per lasciar passare l'output, modifica l'hook in modo che non blocchi quando `source` nel suo input è `poll_event`.

## Risorse correlate

* [Modalità di permesso](https://code.claude.com/docs/it/permission-modes.md): confronta la modalità auto con le modalità che ti chiedono conferma
* [Riferimento degli hook](https://code.claude.com/docs/it/hooks.md): scrivi hook `PreToolUse` e `UserPromptSubmit`
* [Impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md): applica un'unica configurazione a un'intera organizzazione