# Eseguire attività di agente ricorrenti

Riutilizzare l'accesso approvato, eseguire una ricerca per evento programmato, e recuperare senza accidentalmente presentare lo stesso lavoro di nuovo.

Riferimento canonico: https://flashdata.dev/it/docs/guides/recurring-tasks
Recensito: 2026-11-05 da FlashData

<a id="choose"></a>

## Scegli come funziona l'attività

Il vostro agente host o OS scheduler fornisce i tempi. FlashData fornisce i dati. Scegliere un percorso di esecuzione e testarlo nell'ambiente che verrà eseguito incustodito.

| Uso | Per | Stato di conservazione |
| --- | --- | --- |
| CLI | Un agente con accesso terminale, cron, o uno script programmato. | Il profilo CLI, la directory di stato e l'esecuzione originale ID. |
| MCP | Un host agente con un server FlashData collegato. | Le credenziali dell'host, il record di avvenimento, il lavoro IDs e i risultati. |

- [task CLI](https://flashdata.dev/it/docs/guides/recurring-tasks/reference.md#input)
- [task MCP](https://flashdata.dev/it/docs/guides/recurring-tasks/reference.md#mcp)
- [Costruisci un briefing giornaliero](https://flashdata.dev/it/docs/guides/daily-research-briefing/reference.md)

<a id="prepare"></a>

## Controllare l'accesso nell'ambiente programmato

Riutilizzare una connessione proprietaria esistente con il permesso google_search. Prevenire l'accesso temporaneo prima dell'uso ricorrente. Provare da un processo o una sessione programmati freschi, non solo uno interattivo.

### CLI

Utilizzare Bash e jq (Git Bash su Windows), sotto l'utente OS che ha salvato la chiave. Imposta il nome del tuo profilo esistente e la directory di stato assoluta di seguito. Eseguire entrambi i blocchi nello stesso terminale; il corridore riutilizza queste impostazioni.

Il controllo di accesso deve stampare true. Confronta availableCredits con estimatedCredits prima della prima ricerca. Questi assegni non presentano una query.

#### Impostare la connessione salvata

```bash
# Use the profile and state directory that already hold your owner key.
export FLASHDATA_PROFILE='research'
export FLASHDATA_STATE_DIR='/absolute/path/to/existing/flashdata-state'
export FLASHDATA_BIN="$(command -v flashdata)"
unset FLASHDATA_API_KEY
```

#### Accesso gratuito, saldo e assegni di prezzo

```bash
set -euo pipefail
export FLASHDATA_BIN="${FLASHDATA_BIN:-$(command -v flashdata)}"
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
test -d "$FLASHDATA_STATE_DIR" || { echo 'Existing state directory not found.' >&2; exit 1; }
"$FLASHDATA_BIN" --version
jq --version
"$FLASHDATA_BIN" auth status --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
  jq -e '.ok and .data.accessVerified
    and (.data.identity.identity.recurringAllowed == true)
    and (.data.identity.permittedSources | index("google_search") != null)'
"$FLASHDATA_BIN" account balance --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
"$FLASHDATA_BIN" account pricing --source google_search --request-count 1 \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
```


### MCP

Eseguire questo in una sessione di programma fresca. Lascia che l'host riutilizza e aggiorni le sue credenziali OAuth approvate. Deve essere in grado di raggiungere FlashData senza un login interattivo ad ogni corsa.

#### Controllo host gratuito

```text
Riutilizzare la connessione FlashData MCP esistente in questo ambiente pianificato.
Chiama get_balance con {}.
Chiama get_pricing con {"source":"google_search","request_count":1}.
Segnala l'equilibrio e il prezzo stimato. Non cercare o creare nuovi accessi.
```


- [Installare la CLI](https://flashdata.dev/it/docs/guides/flashdata-cli/reference.md#install)
- [Collegare MCP](https://flashdata.dev/it/docs/integrations/mcp-clients/reference.md)
- [Accesso alla prova di richiesta](https://flashdata.dev/it/docs/guides/agent-onboarding/reference.md#claim)

<a id="input"></a>

## CLI: salvare un'attività per avvenimento

Creare la cartella di attività qui sotto, quindi salvare request.json e run-research.sh dentro di essa. Tenere questa cartella separata dalla directory di stato delle credenziali esistenti. Una data rappresenta una query Google; num imposta il numero di risultati. Dare un flusso di lavoro diverso il proprio prefisso run-ID prima della sua prima esecuzione.

### Creare la cartella di attività

```bash
mkdir -p flashdata-research
cd flashdata-research
```

### request.json

```json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
```


<a id="runner"></a>

### Salvare run-research.sh

Creare run-research.sh accanto a request.json nella cartella delle attività. Copiare lo script completo qui sotto e salvarlo prima di eseguire o programmare l'attività.

Lo script congela l'ingresso per ogni data e mantiene un file di ricezione, risultato e errore per ogni tentativo. Solo tentativi di successo pubblicano result.json e receipt.json al livello superiore della cartella datata. --recurring controlla l'accesso del proprietario; non crea un programma.

#### run-research.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
slot=${1:?Pass the scheduled date as YYYY-MM-DD}
[[ "$slot" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || exit 2
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
cd -- "$(dirname -- "$0")"
dir="runs/$slot"
mkdir -p "$dir"
if [[ -e "$dir/request.json" ]]; then
  cmp -s request.json "$dir/request.json" || {
    echo 'Input changed for this slot. Inspect its saved run.' >&2; exit 1;
  }
else
  (set -C; cat request.json > "$dir/request.json")
fi
attempt=$(mktemp -d "$dir/attempt.XXXXXX")
if ! "$FLASHDATA_BIN" query --input "$dir/request.json" --recurring \
  --run-id "scheduled-research:$slot:Asia-Shanghai" \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" \
  --output "$attempt/result.json" --timeout 2m --json --non-interactive \
  > "$attempt/receipt.json" 2> "$attempt/error.json"; then
  cat "$attempt/error.json" >&2
  exit 1
fi
jq -e '.ok == true' "$attempt/receipt.json" >/dev/null
jq -e '.source == "google_search" and .status == "done"
  and (.results[0].organic | type == "array")' "$attempt/result.json" >/dev/null
# Publish a stable path only after the query and its receipt both succeed.
cp "$attempt/result.json" "$dir/result.next.json"
mv "$dir/result.next.json" "$dir/result.json"
cp "$attempt/receipt.json" "$dir/receipt.next.json"
mv "$dir/receipt.next.json" "$dir/receipt.json"
jq '{runId, cached, usage}' "$attempt/receipt.json"
printf 'Saved result: %s\n' "$dir/result.json"
```


<a id="slot"></a>

### Eseguire una volta, quindi testare una nuova procedura

Eseguire dalla cartella di attività. Il primo comando invia una ricerca. Il secondo utilizza lo stesso account, input, profilo e stato per leggere il risultato salvato dopo aver controllato che l'accesso è ancora valido.

#### Un evento · due processi iniziano

```bash
# Use the date of the intended occurrence, including on retries.
bash run-research.sh 2026-11-04

# Same account, input, profile and state: reuse the completed run.
bash run-research.sh 2026-11-04
```


<a id="result"></a>

### Confermare il risultato è stato riutilizzato

La seconda ricevuta dovrebbe mostrare cache: true. Il suo utilizzo appartiene alla ricerca originale. Un array organico vuoto può ancora essere un risultato di successo.

#### Ispezionare il risultato e la ricevuta salvati

```bash
jq '{ok, runId, cached, usage}' runs/2026-11-04/receipt.json
jq '.results[0].organic | map({title, link})' runs/2026-11-04/result.json
```

#### Seconda ricevuta · estrattore

```json
{
  "schemaVersion": 1,
  "ok": true,
  "runId": "scheduled-research:2026-11-04:Asia-Shanghai",
  "cached": true
}
```


<a id="files"></a>

### Mantenere i file tra le operazioni

| File | Uso |
| --- | --- |
| runs/DATE/request.json | Input esatto per quel verificarsi; cambiandolo rende il runner stop. |
| runs/DATE/result.json + receipt.json | L'ultimo tentativo di successo. Solo consumarli dopo che il comando corrente esce con successo. |
| runs/DATE/attempt.*/ | Risultato, ricevuta ed errore per ogni tentativo, compresi i guasti. |
| FLASHDATA_STATE_DIR | Le credenziali protette e i record di esecuzione CLI. Mantenere lo stesso profilo e utente OS. |

- [Recuperare una corsa interrotta](https://flashdata.dev/it/docs/guides/agent-recovery/reference.md)

<a id="mcp"></a>

## MCP: persistere il verificarsi e il lavoro ID

Utilizzare questo corpo di compito con un host che mantiene lo stato di attività durevole e consente un'esecuzione attiva per avvenimento. Salvare il lavoro restituito ID immediatamente; dopo un riavvio, leggere il lavoro accettato invece di cercare di nuovo.

### MCP operazione di ricorsio · salvare come recurring-task.txt

```text
Utilizzare l'evento originale del programmatore ID e l'orario di programma.
Riutilizzare la connessione FlashData MCP esistente e salvare il record di occorrenza.
1. Se questo evento è completo, restituire il suo risultato salvato senza cercare.
2. Se ha un lavoro ID, chiama get_job con quella job_id per leggere il lavoro esistente.
3. Se una presentazione è iniziata ma non ha risultato o lavoro ID, fermarsi per la recensione.
4. Per una nuova occorrenza, controllare get_balance e get_pricing per uno google_search.
   Continuare solo all'interno del bilancio per-task approvato e del saldo disponibile.
5. Persist submission_started prima di chiamare google_search una volta con:
   {"query":"battery recycling pilot plant announcements","num":5,"gl":"us","hl":"en","tbs":"qdr:w","mode":"async"}
6. Salvare il lavoro restituito ID immediatamente. Leggilo con get_job fino al terminale; fermati al fallimento.
   Mantenere lo ID attraverso i timeout e smettere di aspettare al termine dell'host.
7. Salvare il risultato, fonte URLs e l'utilizzo, quindi contrassegnare questo evento completo.
Su 401, 403, 402, 429 o un risultato sconosciuto, arrestare e segnalare il record salvato.
Honor Retry-After. Non creare l'accesso sostitutivo o un'altra domanda a pagamento.
Mantenere il report locale; utilizzare una destinazione di consegna solo se configurata separatamente.
```

- [Strumenti MCP](https://flashdata.dev/it/docs/mcp/reference.md)
- [Leggi un lavoro accettato](https://flashdata.dev/it/docs/mcp/reference.md#jobs)

<a id="mcp-retries"></a>

### Ciò che l'ospite deve persistere

Un prompt da solo non può impedire duplicati. Le chiamate MCP non ereditano la protezione CLI run-ID. Il vostro host deve persistere l'evento originale, lo stato di presentazione e il lavoro ID. Se non può, utilizzare il runner CLI per la fase dei dati. Questo record di esempio appartiene al vostro host; non è una richiesta MCP.

#### Registrazione host · illustrativo

```json
{
  "occurrence": "research:2026-11-04:Asia-Shanghai",
  "state": "accepted",
  "job_id": "<returned job ID>",
  "output": null
}
```


<a id="schedule"></a>

## Pianificare l'attività testata

L'esempio seguente utilizza OpenClaw a 09:00 Asia/Shanghai. Creare il lavoro disabilitato, eseguire quel lavoro salvato manualmente, ispezionare la sua uscita, quindi abilitarlo. Per un altro programmatore, seguire la stessa sequenza con i suoi controlli di prova.

| Impostazione | Uso |
| --- | --- |
| Convalida | Un'esecuzione attiva per questo flusso di lavoro, con stato durevole. |
| Tempo di esecuzione | Utilizzare lo stesso utente OS e percorsi assoluti per lo stato CLI, cartella delle attività e credenziali. Le esportazioni terminali non vengono automaticamente ereditate da un gateway in esecuzione. |
| Ritiri | Mantenere l'evento originale e la data prevista, tra cui dopo mezzanotte. Un test manuale utilizza la sua data di invocazione in Asia/Shanghai. |
| Avvenimenti mancati | Scegliere se saltare o recuperare. Una ricerca eseguita oggi restituisce i dati attuali, anche se etichettato con la data di ieri. |
| Consegna | Salvare localmente prima. Configurare una politica di destinazione e notifica prima di inviare report. |

- [Preparare un server o un contenitore](https://flashdata.dev/it/docs/guides/production-deployment/reference.md)

<a id="cli-task"></a>

### CLI task body per un host agente

Sostituisci i segnaposto del profilo e del percorso, quindi salva recurring-task.txt nella cartella dell'attività. Utilizzare questo corpo per l'esecuzione CLI, o il corpo MCP sopra per l'esecuzione MCP. Un programmatore OS diretto può eseguire lo script Bash con queste variabili di ambiente senza un modello.

#### recurring-task.txt

```text
Eseguire l'operazione di ricerca FlashData approvata sotto l'utente OS che ha salvato la chiave.
Runner: <absolute path to run-research.sh>
Impostare queste variabili di ambiente per il processo di corridore:
FLASHDATA_BIN: <absolute path to flashdata>
FLASHDATA_PROFILE: <existing profile name>
FLASHDATA_STATE_DIR: <esistente directory di stato assoluta>
Mantenere FLASHDATA_API_KEY unset per riutilizzare le credenziali salvate.
Utilizzare la data prevista originale in Asia/Shanghai, come YYYY-MM-DD.
Per un funzionamento manuale, salvare la sua data di invocazione prima dell'esecuzione.
Esegui: bash "<absolute path to run-research.sh>" YYYY-MM-DD
Tieni quel appuntamento sui retries, anche dopo mezzanotte. Consentire un'esecuzione attiva.
Mantenere lo stesso profilo, request.json e directory di stato.
Leggere solo la datata result.json dopo che il comando esce con successo.
Segnala i collegamenti sorgente, esegui ID e l'utilizzo. Mantenere gli output locali.
Su errore, arrestare e segnalare l'errore salvato. Non avviare il lavoro di sostituzione o creare un nuovo accesso.
```


<a id="openclaw-schedule"></a>

### 1. Creare un lavoro OpenClaw disabilitato

Utilizzare un gateway in esecuzione e un agente esistente che ha superato il controllo di accesso. I comandi sottostanti utilizzano OpenClaw 2026.10.10; aggiornano i client più vecchi se --wait non è disponibile. Nella cartella contenente recurring-task.txt, impostare OPENCLAW_AGENT_ID su ID di quell'agente.

Il comando salva openclaw-job.json senza sovrascrivere un file esistente. Leggilo e imposta OPENCLAW_JOB_ID al lavoro restituito ID. Se la creazione perde la sua risposta, ispeziona l'elenco delle automazioni --all --json prima di creare un altro lavoro. --no-deliver disabilita l'annuncio automatico; l'ente di compito mantiene anche i rapporti locali.

#### Bash · crea un lavoro disabilitato

```bash
: "${OPENCLAW_AGENT_ID:?Set the existing OpenClaw agent ID}"
test -s recurring-task.txt || exit 1
# Keep the receipt. An existing file blocks accidental recreation.
(
  set -o noclobber
  openclaw automations add --name flashdata-daily-research \
    --agent "$OPENCLAW_AGENT_ID" \
    --cron "0 9 * * *" --tz Asia/Shanghai --exact \
    --session isolated --disabled --no-deliver \
    --message "$(cat recurring-task.txt)" --json > openclaw-job.json
)
```

- [Configurazione OpenClaw](https://flashdata.dev/it/docs/integrations/openclaw/reference.md)
- [OpenClaw riferimento di programmazione](https://docs.openclaw.ai/cli/cron)

<a id="test-schedule"></a>

### 2. Testare il lavoro salvato prima di abilitarlo

Eseguire il lavoro salvato una volta, mentre il suo programma rimane disabilitato. Bilancio per una ricerca di prova e costi del modello; un evento CLI completato corrispondente può riutilizzare il suo risultato. Questo comando aspetta fino a minuti 10.

Aspetto completionStatus: riuscito, quindi controllare il risultato salvato, i collegamenti di origine e l'utilizzo. Per CLI, leggere runs/DATE/result.json e receipt.jsonPer i MCP, leggere l'evento salvato dell'host e il risultato del lavoro. true da solo significa accettato, non completato.

#### Eseguire una volta · salvare la ricevuta del test

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
# Run the saved job once; its schedule stays disabled.
(
  set -o noclobber
  openclaw automations run "$OPENCLAW_JOB_ID" \
    --wait --wait-timeout 10m --json > openclaw-test-run.json
)
```

#### Leggi la ricevuta del test

```bash
cat openclaw-test-run.json
```


<a id="inspect-test"></a>

### Ispezione di un test tempestivo o fallito

Un timeout smette di aspettare, non l'attività Gateway. Leggi la storia recente se la ricevuta è vuota. Impostare OPENCLAW_RUN_ID al OpenClaw runId dalla ricevuta o la cronologia, quindi ispezionare l'esecuzione. Non ripetere il comando run per controllare i progressi.

Questa è l'esecuzione del programmatore ID, non il FlashData corsa ricorrente ID o MCP lavoro dei dati ID. Se l'agente non poteva accedere o eseguire l'attività dei dati, mantenere il programma disabilitato e riparare il passaggio prima.

#### Ispezionare la stessa esecuzione

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
cat openclaw-test-run.json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json

# Set this from the receipt or history; this is OpenClaw's run ID.
: "${OPENCLAW_RUN_ID:?Set the OpenClaw test run ID}"
openclaw automations runs "$OPENCLAW_JOB_ID" \
  --run-id "$OPENCLAW_RUN_ID" --json
```

- [Recuperare la fase di dati FlashData](https://flashdata.dev/it/docs/guides/agent-recovery/reference.md)

<a id="manage-schedule"></a>

### 3. Abilitare dopo aver controllato l'output

Rivedere l'agente salvato, programma, fuso orario e test completato. Abilita solo dopo che l'uscita è corretta e il costo ricorrente è approvato. Disabilitare in seguito arresta le invocazioni future; non cancella una domanda già presentata.

#### Rivedere il lavoro salvato e la cronologia dei test

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
openclaw automations show "$OPENCLAW_JOB_ID" --json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json
```

#### Abilitare il programma giornaliero

```bash
openclaw automations enable "$OPENCLAW_JOB_ID"
```

#### Pause futuro corre quando necessario

```bash
openclaw automations disable "$OPENCLAW_JOB_ID"
```


<a id="budget"></a>

## Impostare le regole sui costi e sui guasti

| Situazione | Azione |
| --- | --- |
| Pianificazione dei costi | Prezzo per query × eventi pianificati. Aggiungi i costi del modello e dell'host separatamente; il conteggio dei risultati non è il conteggio delle query. |
| Bilancio conto condiviso | Fornire il vostro budget nel programmatore o host. Questi esempi non impongono un tappo di spesa chiave separato. |
| 401 / 403 / 402 | Pausa future spedizioni. Fissare le credenziali, il permesso o l'equilibrio; riprendere con il verificarsi originale e stato salvato. |
| 429 | Rispetto Retry-After. Ispezionare l'esecuzione CLI o il verificarsi MCP prima di decidere se una nuova presentazione è sicura. |
| Esito di presentazione sconosciuto | Tenere lo stato salvato e fermarsi. Recuperare un lavoro noto ID; non creare una nuova esecuzione ID per bypassare l'incertezza. |

- [Prezzi correnti](https://flashdata.dev/it/pricing)
- [Decisioni di recupero](https://flashdata.dev/it/docs/guides/agent-recovery/reference.md)

<a id="stop"></a>

## Interrompere il programma e revocare l'accesso separatamente

1. Pausa il programmatore per fermare le invocazioni future.
2. Rivoca la connessione dell'agente, l'app OAuth o la chiave API nella console. La rivocazione blocca il nuovo uso autenticato; non cancella i file esportati.
3. Ripetere il controllo di accesso gratuito da un processo fresco. Dovrebbe fallire dopo la revoca. CLI auth logout rimuove solo le credenziali locali; non revoca l'accesso remoto.

- [Connected apps e agenti](https://flashdata.dev/app/settings/connections)
- [chiavi API](https://flashdata.dev/app/api-keys)
- [Il ciclo di vita di accesso](https://flashdata.dev/it/docs/guides/agent-access/reference.md)
