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

# Riferimento dei comandi

> Riferimento per i comandi della CLI di CometAPI, inclusi chat, models, model info, run, balance, account, stats, tokens, logs, tasks, doctor, config e repl.

Usa `cometapi -h` o `cometapi <command> -h` per controllare gli argomenti e le opzioni esatti della versione installata.

## Panoramica dei comandi

| Command           | Description                                                               | Auth                      |
| ----------------- | ------------------------------------------------------------------------- | ------------------------- |
| `chat [MESSAGE]`  | Invia un messaggio chat o avvia la chat REPL                              | Chiave API                |
| `models`          | Elenca e filtra i metadati del catalogo dei modelli                       | Chiave API                |
| `model info <id>` | Esamina i metadati pubblici di un modello                                 | Chiave API                |
| `run [MODEL]`     | Invia una richiesta tramite i formati chat, responses, anthropic o gemini | Chiave API                |
| `balance`         | Mostra il saldo dell'account o della chiave API corrente                  | Chiave API o access token |
| `account`         | Mostra il profilo dell'account                                            | Access token              |
| `stats`           | Mostra le statistiche di utilizzo                                         | Access token              |
| `tokens`          | Elenca e cerca le chiavi API                                              | Access token              |
| `logs`            | Sfoglia i log di utilizzo con filtri                                      | Access token              |
| `tasks`           | Mostra i log delle attività asincrone                                     | Access token              |
| `init`            | Esegue la procedura guidata di configurazione                             | Nessuno                   |
| `doctor`          | Esegue la diagnostica                                                     | Chiave API                |
| `config`          | Gestisce la configurazione locale                                         | Nessuno                   |
| `repl`            | Avvia una shell di comandi interattiva                                    | Dipende dal comando usato |

I comandi contrassegnati con **Access token** richiedono la variabile d'ambiente `COMETAPI_ACCESS_TOKEN` o la chiave di configurazione `access_token`. Per i dettagli, consulta la [guida alla configurazione](/it/libraries/cli/configuration).

## Chat

Invia un singolo messaggio o avvia la chat REPL multi-turno.

```bash theme={null}
cometapi chat "Explain CometAPI in one sentence."
cometapi chat "Summarize this" --model your-model-id --system "Be concise."
cometapi chat "Hello" --no-stream
cometapi chat "Hello" --json
cometapi chat
```

| Option                 | Short | Description                         |
| ---------------------- | ----- | ----------------------------------- |
| `--model`              | `-m`  | Modello da usare                    |
| `--system`             | `-s`  | Prompt di sistema                   |
| `--temperature`        | `-t`  | Temperatura di sampling             |
| `--max-tokens`         |       | Numero massimo di token di risposta |
| `--stream/--no-stream` |       | Abilita o disabilita lo streaming   |
| `--format`             | `-f`  | Formato di output                   |
| `--json`               |       | Output in formato JSON              |

## Models

Per impostazione predefinita elenca i modelli dal catalogo pubblico. L'output del catalogo include model ID, provider, tipo di modello, funzionalità, endpoint, prezzi, lunghezza del contesto e token massimi di completamento.

```bash theme={null}
cometapi models
cometapi models --search gpt --limit 10
cometapi models --provider openai --type chat --limit 10
cometapi models --feature image --endpoint responses --json
cometapi models --refresh
cometapi models --source openai --search gpt
```

| Option                      | Short | Description                                                         |
| --------------------------- | ----- | ------------------------------------------------------------------- |
| `--search`                  | `-s`  | Filtra per ID, codice, nome, descrizione o provider                 |
| `--provider`                |       | Filtra per nome o codice del provider                               |
| `--type`, `--modality`      |       | Filtra per tipo di modello o modalità                               |
| `--feature`, `--capability` |       | Filtra per funzionalità o capacità                                  |
| `--endpoint`                |       | Filtra per nome, metodo o percorso dell'endpoint                    |
| `--limit`                   | `-l`  | Numero massimo di risultati                                         |
| `--source`                  |       | Usa i metadati `catalog` o l'elenco `openai` compatibile con OpenAI |
| `--refresh`                 |       | Aggiorna la cache del catalogo di un'ora                            |
| `--no-cache`                |       | Ignora la cache del catalogo per questo comando                     |
| `--format`                  | `-f`  | Formato di output                                                   |
| `--json`                    |       | Output in formato JSON                                              |

La cache del catalogo è memorizzata in `~/.cache/cometapi/models.json`.

## Informazioni sul model

Ispeziona i metadati pubblici di un model. Il comando risolve il model tramite il catalogo pubblico, quindi carica i metadati di dettaglio per il codice del catalogo.

```bash theme={null}
cometapi model info your-model-id
cometapi model info your-model-id --json
cometapi model info your-model-id --refresh
```

| Option       | Short | Description                                        |
| ------------ | ----- | -------------------------------------------------- |
| `--refresh`  |       | Aggiorna la cache del catalogo prima della ricerca |
| `--no-cache` |       | Ignora la cache del catalogo per questo comando    |
| `--format`   | `-f`  | Formato di output                                  |
| `--json`     |       | Restituisce il JSON grezzo dei dettagli del model  |

L'output tabellare include provider, tipo di model, funzionalità, endpoint, prezzi, lunghezza del contesto, token massimi di completamento, URL della documentazione e panoramica.

## Esegui

Invia una richiesta tramite un formato di endpoint selezionato. Usa `--input-file` per un body JSON, valori `-i key=value` ripetuti per le sostituzioni e `-p/--prompt` come scorciatoia per un prompt.

```bash theme={null}
cometapi run your-model-id -p "Write one sentence about CometAPI."
cometapi run your-model-id --endpoint responses -p "Reply with OK only." -i max_output_tokens=32 --json
cometapi run your-model-id --endpoint anthropic -p "Reply with OK only." -i max_tokens=32
cometapi run your-model-id --endpoint gemini -p "Reply with OK only." -i generationConfig.maxOutputTokens=32
cometapi run your-model-id --endpoint responses --input-file body.json -i temperature=0.2 --json
```

| Option         | Short | Description                                                        |
| -------------- | ----- | ------------------------------------------------------------------ |
| `--endpoint`   | `-e`  | Formato dell'endpoint: `chat`, `responses`, `anthropic` o `gemini` |
| `--input-file` |       | Body della richiesta come oggetto JSON                             |
| `--input`      | `-i`  | Input della richiesta come `key=value`; ripeti per più valori      |
| `--prompt`     | `-p`  | Scorciatoia per il prompt                                          |
| `--json`       |       | Restituisce la risposta JSON grezza                                |

Mappatura degli endpoint:

| Endpoint    | Request path                               | Auth                                                     |
| ----------- | ------------------------------------------ | -------------------------------------------------------- |
| `chat`      | `POST /v1/chat/completions`                | Chiave API Bearer                                        |
| `responses` | `POST /v1/responses`                       | Chiave API Bearer                                        |
| `anthropic` | `POST /v1/messages`                        | Chiave API `x-api-key` e header della versione Anthropic |
| `gemini`    | Percorso del model Gemini Generate Content | Chiave API `x-goog-api-key`                              |

L'ordine di unione del body è `--input-file`, valori `-i key=value` ripetuti, scorciatoia per il prompt e infine `MODEL` posizionale. I valori inline vengono interpretati come JSON quando possibile. Le chiavi con notazione puntata creano oggetti annidati.

## Saldo

Mostra il saldo del tuo account CometAPI o la vista di fatturazione della chiave API corrente.

```bash theme={null}
cometapi balance
cometapi balance --source account
cometapi balance --source key
cometapi balance --json
```

| Option     | Short | Description                         |
| ---------- | ----- | ----------------------------------- |
| `--source` | `-s`  | Origine dei dati: `account` o `key` |
| `--format` | `-f`  | Formato di output                   |
| `--json`   |       | Output in formato JSON              |

## Account

Mostra il profilo del tuo account. Richiede un access token.

```bash theme={null}
cometapi account
cometapi account --json
```

## Statistiche

Mostra le statistiche di utilizzo. Richiede un access token.

```bash theme={null}
cometapi stats
cometapi stats --json
```

## Tokens

Elenca e cerca le chiavi API. Richiede un access token.

```bash theme={null}
cometapi tokens
cometapi tokens --search project
cometapi tokens --json
```

| Option     | Short | Description              |
| ---------- | ----- | ------------------------ |
| `--search` | `-s`  | Parola chiave di ricerca |
| `--page`   | `-p`  | Numero di pagina         |
| `--limit`  | `-l`  | Risultati per pagina     |
| `--format` | `-f`  | Formato di output        |
| `--json`   |       | Output in formato JSON   |

## Log

Esplora i log di utilizzo con filtri. Richiede un token di accesso.

```bash theme={null}
cometapi logs
cometapi logs --model your-model-id
cometapi logs --start 2026-04-01 --end 2026-04-14
cometapi logs --type consume
cometapi logs --export > usage.csv
cometapi logs --limit 50 --json
cometapi logs --request-id 20260617165550885561292gJBlzjtp
```

| Option         | Short | Description                                         |
| -------------- | ----- | --------------------------------------------------- |
| `--model`      | `-m`  | Filtra per model ID                                 |
| `--token-name` | `-t`  | Filtra per nome della API key                       |
| `--type`       |       | Tipo di log                                         |
| `--search`     | `-s`  | Parola chiave di ricerca                            |
| `--start`      |       | Data di inizio                                      |
| `--end`        |       | Data di fine                                        |
| `--group`      | `-g`  | Filtra per gruppo di API key                        |
| `--request-id` |       | Cerca una richiesta tramite `X-Cometapi-Request-Id` |
| `--page`       | `-p`  | Numero di pagina                                    |
| `--limit`      | `-l`  | Risultati per pagina                                |
| `--export`     |       | Esporta il CSV lato server su stdout                |
| `--format`     | `-f`  | Formato di output                                   |
| `--json`       |       | Output in formato JSON                              |

`logs --request-id` esegue una ricerca indicizzata sull'endpoint dei log dell'operatore e
accetta solo una corrispondenza esatta di `request_id`. La CLI non esegue la scansione delle pagine di log di fallback,
perché l'endpoint self-log non applica il filtro `request_id`.

## Task

Mostra i log dei task asincroni. Richiede un token di accesso.

```bash theme={null}
cometapi tasks
cometapi tasks --platform kling
cometapi tasks --status SUCCESS
cometapi tasks --json
```

| Option       | Short | Description               |
| ------------ | ----- | ------------------------- |
| `--platform` | `-p`  | Filtra per piattaforma    |
| `--task-id`  |       | Filtra per ID del task    |
| `--status`   | `-s`  | Filtra per stato          |
| `--action`   | `-a`  | Filtra per tipo di azione |
| `--start`    |       | Data di inizio            |
| `--end`      |       | Data di fine              |
| `--page`     |       | Numero di pagina          |
| `--limit`    | `-l`  | Risultati per pagina      |
| `--format`   | `-f`  | Formato di output         |
| `--json`     |       | Output in formato JSON    |

## Doctor

Esegui la diagnostica per verificare la configurazione e la connettività API.

```bash theme={null}
cometapi doctor
cometapi doctor --json
```

## Config

Gestisci la configurazione della CLI archiviata in `~/.config/cometapi/config.toml`.

```bash theme={null}
cometapi config show
cometapi config set api_key "$COMETAPI_KEY"
cometapi config set default_model your-model-id
cometapi config unset api_key
cometapi config path
```

Consulta la [guida alla configurazione](/it/libraries/cli/configuration) per tutte le chiavi disponibili.

## Init

Esegui la procedura guidata di configurazione interattiva:

```bash theme={null}
cometapi init
```

## Repl

Avvia una shell di comando interattiva completa:

```bash theme={null}
cometapi repl
```

## Formati di output

La maggior parte dei comandi relativi ai dati supporta `--json` o `--format`:

```bash theme={null}
cometapi models --json
cometapi models --format yaml
cometapi stats --format csv
cometapi account --format markdown
```

| Format     | Description                    |
| ---------- | ------------------------------ |
| `table`    | Tabella avanzata nel terminale |
| `json`     | Output JSON                    |
| `yaml`     | Output YAML                    |
| `csv`      | Valori separati da virgole     |
| `markdown` | Tabella Markdown               |
