Guida alla chiamata di funzioni di GPT-6 Astra: Schemi, Validazione, Ripetizioni e Risultati degli Strumenti

La funzione di chiamata permette a GPT-6 Astra di richiedere codice controllato dalla tua applicazione. Il modello sceglie una funzione e propone gli argomenti; il tuo runtime li convalida, esegue l'operazione e invia il risultato. L'affidabilità dipende meno da una descrizione intelligente dello strumento che da un ciclo di esecuzione disciplinato.

Definisci un contratto rigoroso

OpenAI raccomanda strict: true. Gli schemi rigorosi richiedono additionalProperties: false e ogni proprietà deve apparire in required. Rappresenta un valore opzionale come un'unione che include null.

const tools = [{
  type: "function",
  name: "lookup_order",
  description: "Restituisce lo stato corrente di un ordine visibile all'utente.",
  strict: true,
  parametri: {
    type: "object",
    proprietà: {
      order_id: { type: "string", description: "ID ordine canonico" },
      include_events: { type: ["booleano", "null"] }
    },
    obbligatorio: ["order_id", "include_events"],
    additionalProperties: false
  }
}];

Mantieni le funzioni piccole e i nomi concreti. Un grande strumento manage_account con molte modalità favorisce combinazioni non valide e nasconde i rischi. Preferisci get_account, update_shipping_address e close_account, con approvazione per le operazioni consequenziali.

Il ciclo di esecuzione

Nell'API delle Risposte, una chiamata richiesta appare in response.output come un elemento con type: "function_call", call_id, name e arguments in formato JSON stringa. L'applicazione analizza e convalida gli argomenti, esegue codice affidabile, poi continua con un function_call_output corrispondente.

const first = await client.responses.create({ model: "gpt-6-astra", strumenti, input: "Dov'è l'ordine ORD-1042?" });

const outputs = []; for (const item of first.output) { if (item.type !== "function_call") continue; const args = JSON.parse(item.arguments); const result = await lookupOrder(args); outputs.push({ type: "function_call_output", call_id: item.call_id, output: JSON.stringify(result) }); }

const final = await client.responses.create({ model: "gpt-6-astra", previous_response_id: first.id, input: output });

Non eseguire mai nomi arbitrari provenienti dal modello. Risolvi rispetto a un registro fisso. Convalida nuovamente nel codice dell'applicazione anche con modalità rigorosa: la validità dello schema non prova l'autorizzazione, l'esistenza del record, la conformità alle regole aziendali o la sicurezza.

## Risultati degli strumenti di progettazione utili

Restituisci il risultato completo più piccolo. Includi identificatori stabili, stato, campi tipizzati e codici di errore leggibili dalla macchina. Evita di scaricare un'intera riga di database o una traccia dello stack.

```json
{
  "headers": {
    "row1": "Ciao, come stai?",
    "row2": "Sto bene, grazie."
  },
  "videourl": "https://example.com/video.mp4"
}

{ "ok": false, "error": { "code": "ORDER_NOT_VISIBLE", "message": "L'ordine non è stato trovato nell'account del chiamante.", "retryable": false } }

Il messaggio aiuta il modello a spiegare; il codice aiuta il livello di orchestrazione a decidere. Non rivelare se un altro tenant possiede un identificatore nascosto.

## I nuovi tentativi richiedono due criteri

I tentativi di trasporto gestiscono i timeout delle API, gli errori 429 e i fallimenti transitori 5xx. I tentativi degli strumenti gestiscono i fallimenti delle tue dipendenze. Separali.

Le letture sicure possono di solito riprovare con backoff esponenziale e jitter. Le scritture necessitano di una chiave di idempotenza e riconciliazione. Se la connessione scompare dopo `create_refund`, verifica se il rimborso esiste prima di chiamare di nuovo. Assegna a ogni azione logica un ID operazione stabile e memorizza l'ID della chiamata dello strumento insieme al risultato.

Non chiedere mai al modello da solo se il tentativo è sicuro. Il registro degli strumenti deve dichiarare la classe di ripetizione, il timeout e il livello di effetti collaterali.

## Chiamate parallele e ordinamento

Il modello può richiedere più chiamate di funzione. L'esecuzione parallela è utile per letture indipendenti, come controllare il meteo in tre città. Non è sicura quando la chiamata B dipende dalla chiamata A o quando due scritture riguardano lo stesso record.

Raccogli ogni elemento di chiamata di funzione; non presupporre che ce ne sia solo uno. Costruisci un esecutore consapevole delle dipendenze, oppure disabilita/evita il comportamento parallelo dove l'ordine è importante. Restituisci ogni risultato usando il proprio `call_id`.

## Selezione dello strumento di controllo

`tool_choice` può consentire la selezione automatica, richiedere uno strumento, impedire strumenti o forzare una funzione nominata. Usa `auto` per agenti aperti, forza uno strumento quando un'operazione API è lo scopo esplicito dell'endpoint e scegli `none` quando l'elaborazione deve rimanere solo basata sul modello.

Per le azioni rivolte all'utente, un pattern a due fasi è efficace: prima preparare e mostrare una modifica proposta; poi eseguire uno strumento separato confermato. Questo impedisce che una frase amichevole diventi un'autorizzazione implicita.

## Testa il contratto

Crea casi per campi mancanti, opzionali nulli, enum non validi, ID non autorizzati, timeout, invii duplicati, fallimenti parziali, chiamate multiple, output enormi e stringhe dannose all'interno dei risultati degli strumenti. Valuta se la risposta finale riflette accuratamente un fallimento invece di dichiarare un successo.

Versione dello schema di log, ID chiamata, nome dello strumento, argomenti sanificati, durata, esito e numero di tentativi. Mantieni segreti e contenuti sensibili fuori dalla telemetria.

## Elenco di controllo per la revisione del design dello schema

Rivedi ogni strumento come se fosse un'API pubblica. Gli enum dovrebbero riflettere valori supportati reali, invece di chiedere al modello di inventare stringhe. Le date necessitano di un formato e un fuso orario dichiarati. I campi numerici necessitano di unità e limiti. Gli identificatori dovrebbero essere canonici, non nomi di clienti in formato libero quando un passaggio di ricerca può risolvere ambiguità. Le descrizioni dovrebbero specificare precondizioni e cosa la funzione non fa.

Evita le trappole booleane come `force`, `override` o `skip_checks`. Esse comprimono importanti decisioni politiche in un singolo bit generato dal modello. Se un'operazione eccezionale è legittima, esponila come uno strumento separato ad alto rischio con autorizzazione e approvazione più forti.

Contratti con versione incompatibile. Le catene di risposta in esecuzione potrebbero ancora contenere chiamate o risultati modellati da uno schema più vecchio. Il tuo esecutore dovrebbe rifiutare esplicitamente le versioni non supportate e restituire un errore recuperabile piuttosto che indovinare come tradurre una richiesta sensibile.

Infine, confronta il risultato della funzione con l'affermazione rivolta all'utente. Uno strumento che restituisce `{ok:false}` non deve mai diventare "Fatto." Le valutazioni automatiche dovrebbero ispezionare sia la traccia delle chiamate che la prosa finale, perché un livello di strumento operativamente corretto può comunque essere travisato dal modello.

## FAQ

### La modalità strict elimina il codice di validazione?

No. Migliora l'aderenza strutturale. La tua applicazione continua a imporre permessi, intervalli, invarianti e policy aziendali.

### L'output dello strumento deve essere in JSON?

Il campo di output è una stringa, quindi JSON è una convenzione pratica per risultati strutturati. Mantieni il contratto coerente.

### Quando dovrei forzare uno strumento?

Quando lo scopo dell'endpoint richiede tale operazione e l'utente l'ha autorizzata. Non forzare chiamate non necessarie solo per rendere il comportamento deterministico.

### GPT-6 Astra può eseguire la mia funzione da sola?

No. Emette la richiesta di chiamata; la tua applicazione esegue la funzione e restituisce il risultato.

## Conclusione

La chiamata affidabile di funzioni è un protocollo: schema rigoroso, registro fisso, validazione dell'applicazione, autorizzazione, esecuzione controllata, risultato strutturato e continuazione verificata. Aggiungi idempotenza e classificazione dei tentativi prima di abilitare le scritture. Il modello propone; il tuo sistema rimane responsabile per ogni effetto.