Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Compilare moduli e fare clic

Lezione 6 di 14 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. L’interazione più comune
  2. Fare clic prima di digitare
  3. Svuotare un campo prima di compilarlo
  4. Menu, caselle di controllo e pulsanti di opzione
  5. Moduli su più schermate
  6. Reagire agli errori di convalida
  7. Caricamento file, un caso speciale
  8. Punti chiave

Lezione aggiornata il 3 novembre 2026 sulla base delle linee guida di conferma di OpenAI e della documentazione di Playwright: il ritardo di digitazione non è più presentato come un metodo per eludere il rilevamento anti-bot; la selezione utilizza ControlOrMeta+a, che funziona anche su macOS; un page.screenshot() non mostra la finestra di dialogo nativa di apertura file, contrariamente a quanto affermato nella versione precedente; le linee guida vengono passate tramite il parametro instructions. Fonti: Conferma e consenso · Playwright, Tastiera.

L’interazione più comune

Se devi padroneggiare un solo gesto, che sia questo. Inviare una richiesta di contatto, compilare un preventivo, inserire un record cliente in un CRM senza API: i moduli sono il punto di passaggio obbligato per la maggior parte delle automazioni. È anche qui che gli agenti configurati male falliscono più spesso, per ragioni molto concrete che questa lezione affronta una per una.

Fare clic prima di digitare

L’azione type non scrive in un campo; scrive nel campo attualmente attivo. Dimentichi questa sfumatura una sola volta: senza un clic preliminare, il tuo testo finisce nel vuoto o, più insidiosamente, si aggiunge al campo precedente. La sequenza è quindi invariabile: un clic per attivare, poi la digitazione.

# Nel tuo esecutore di azioni
def execute_type(page, text: str):
    """Digita il testo nel campo attivo."""
    page.keyboard.type(text, delay=50)

Il parametro delay=50 merita attenzione. keyboard.type invia già eventi di tastiera carattere per carattere, ma senza ritardo li concatena il più velocemente possibile; con cinquanta millisecondi tra ogni tasto, la velocità scende a venti caratteri al secondo. I campi che reagiscono a ogni tasto premuto—autocompletamento, maschere di input per numeri di telefono—hanno così il tempo di stare al passo. Questa impostazione non serve a sembrare umani: un sito che cerca di bloccare i bot esprime una volontà che deve essere rispettata (Lezione 14).

Svuotare un campo prima di compilarlo

Un modulo precompilato—ripresa di sessione, valore predefinito, autocompletamento del browser—trasforma il tuo input in una concatenazione assurda: digitare “Dupont” dopo “Martin” produce “MartinDupont”, e il modulo lo accetta senza errori. Seleziona tutto prima di digitare.

def clear_and_type(page, text: str):
    """Seleziona tutto il contenuto del campo, poi digita."""
    page.keyboard.press("ControlOrMeta+a")  # Ctrl+A, o Cmd+A su macOS
    page.keyboard.type(text, delay=50)

Il modello decide le sue azioni in base al prompt: ricordagli la regola, altrimenti digiterà direttamente nel campo già occupato.

task = """
Compila il modulo di contatto:
- Campo "Nome": Dupont
- Campo "Email": [email protected]
- Campo "Messaggio": Richiesta di preventivo per 50 licenze

IMPORTANTE: Prima di digitare in ogni campo, 
seleziona tutto il testo esistente (Ctrl+A) per sostituirlo.
Dopo aver compilato tutti i campi, fai clic sul pulsante Invia.
"""

Un menu a discesa <select> richiede tre passaggi: un clic per aprirlo, un’attesa che le opzioni appaiano e un secondo clic sull’opzione desiderata. La buona notizia è che i menu JavaScript personalizzati—quelli che non sono veri elementi <select> e che danno tanti problemi agli script classici—sono gestiti esattamente allo stesso modo, poiché l’agente vede solo il rendering visivo: fa clic, scopre le opzioni nello screenshot successivo e clicca quella giusta.

Le caselle di controllo (checkbox) e i pulsanti di opzione (radio button) sembrano più semplici, con un solo clic sufficiente per attivarli. La trappola è altrove: una casella già selezionata viene deselezionata al clic, e il tuo agente ha appena revocato il consenso che doveva dare. Deve quindi leggere lo stato prima di agire, e tu devi chiederglielo esplicitamente. Tieni anche presente che accettare termini o creare un account impegna la persona per cui lavora l’agente: affidagli queste azioni solo se quella persona le ha richieste esplicitamente.

task = """
Nel modulo di registrazione:
1. Spunta la casella "Accetto i termini" se non è già selezionata
2. Seleziona "Azienda" nel tipo di account
3. Fai clic su "Crea account"

Verifica lo stato di ogni elemento PRIMA di fare clic.
"""

Moduli su più schermate

Un tunnel di registrazione di tre pagine non è tre volte più difficile di un modulo semplice, a patto di strutturare le istruzioni pagina per pagina e di segnare le transizioni. L’agente sa così quando una sezione è terminata e quale pulsante porta alla successiva. L’esempio gestisce dati personali fittizi; con dati reali, ricorda che OpenAI considera l’inserimento di informazioni sensibili in un modulo come una trasmissione, che richiede l’approvazione dell’interessato.

task = """
Compila il modulo di registrazione in 3 passaggi:

PASSAGGIO 1 - Informazioni personali:
- Nome: Jean
- Cognome: Dupont
- Data di nascita: 15/03/1985
→ Fai clic su "Avanti"

PASSAGGIO 2 - Dettagli di contatto:
- Email: [email protected]
- Telefono: 06 12 34 56 78
- Indirizzo: 12 rue de la Paix, 75002 Paris
→ Fai clic su "Avanti"

PASSAGGIO 3 - Conferma:
- Verifica che tutte le informazioni siano corrette
- Spunta "Accetto i Termini di Servizio"
→ Fai clic su "Convalida"
"""

Reagire agli errori di convalida

Un formato telefonico rifiutato, un campo obbligatorio mancante, una password giudicata troppo corta: il modulo restituisce un messaggio e attende una correzione. È esattamente qui che Computer Use supera uno script, poiché l’agente sa leggere l’errore visualizzato invece di inciamparci. Devi comunque chiedergli di cercare gli errori e limitare i suoi tentativi, affinché un campo definitivamente rifiutato non lo faccia entrare in un loop infinito. Queste regole vanno nel parametro instructions, restituito con ogni richiesta (Lezione 5).

INSTRUCTIONS = """
Dopo aver inviato un modulo:
1. Fai uno screenshot per vedere il risultato
2. Se compaiono messaggi di errore (in rosso, riquadrati), 
   leggili e correggi i campi pertinenti
3. Invia di nuovo il modulo
4. Ripeti finché il modulo non viene accettato 
   o hai provato 3 volte
"""

Caricamento file, un caso speciale

C’è un limite che nessun prompt supererà: la finestra di dialogo di apertura file appartiene al sistema operativo, non alla pagina. L’agente non la vede nemmeno—page.screenshot() cattura solo il contenuto della pagina—e le coordinate che produce si applicano alla pagina, non a una finestra nativa. Delega l’operazione a Playwright, che bypassa completamente questa finestra di dialogo.

def handle_file_upload(page, file_path: str, selector: str):
    """Carica un file tramite Playwright (non tramite Computer Use)."""
    page.locator(selector).set_input_files(file_path)

Puoi anche lasciare che l’agente faccia clic su “Sfoglia” come un utente e intercettare il selettore di file nel momento in cui si apre: il flusso di lavoro rimane naturale dall’inizio alla fine, con la parte di sistema gestita dietro le quinte. In entrambi i casi, è il tuo codice a scegliere il file, mai il modello; e l’invio di file è tra le azioni che OpenAI ti permette di pre-approvare nella richiesta iniziale, o di confermare altrimenti.

# L'agente fa clic su "Sfoglia", poi tu intercetti
page.on("filechooser", lambda fc: fc.set_files("/path/to/file.pdf"))

Punti chiave

  • Fai sempre clic su un campo prima di digitare al suo interno
  • Usa Ctrl+A (ControlOrMeta+a in Playwright) per svuotare un campo prima di digitare
  • I menu a discesa richiedono un clic per aprirli, poi un clic per selezionare
  • Prevedi la gestione degli errori di convalida nel prompt
  • Il caricamento dei file deve essere gestito da Playwright, non da Computer Use