# Guide : n8n

Deux façons de brancher le téléphone dans n8n :

- **Un workflow classique** (recommandé pour l'automatisation) : un nœud **HTTP Request** lance l'appel, un nœud
  **Webhook** reçoit les événements signés (question, fin d'appel…).
- **Un agent IA n8n** : le nœud **AI Agent** utilise nos outils via le nœud **MCP Client Tool**.

## Avant de commencer

1. Crée ton compte sur `/app/`, vérifie ton numéro de mobile par SMS (5 minutes offertes), puis crée une clé API
   (`tel_…`) dans **Clés API**.
2. Récupère ton **secret de webhook** (`whsec_…`, propre à ton compte) : il sert à vérifier que les événements viennent
   bien de nous. Il n'est pas encore affiché dans l'espace client : demande-le au support en attendant.
3. Dans n8n, crée un identifiant (credential) **Header Auth** : nom `Authorization`, valeur `Bearer tel_…`.

## 1. Lancer un appel (HTTP Request)

| Paramètre | Valeur |
|---|---|
| Method | `POST` |
| URL | `https://api.dialyne.com/v1/missions` |
| Authentication | Generic Credential Type › Header Auth (l'identifiant ci-dessus) |
| Send Body | JSON |

```json
{
  "numero": "+33142000000",
  "mission": "Demande si la commande 4521 est prête et à quelle heure on peut passer la chercher, au nom de Moha K.",
  "webhook_url": "https://ton-n8n.exemple.fr/webhook/telephone"
}
```

La réponse (201) contient l'`id` de la mission. L'appel continue en arrière-plan : la suite arrive par webhook.

## 2. Recevoir les événements (Webhook)

1. Ajoute un nœud **Webhook** : méthode `POST`, chemin `telephone`. Dans ses options, active **Raw Body** : la
   signature se calcule sur le corps brut, octet pour octet.
2. Mets l'URL de production de ce nœud dans `webhook_url` (HTTPS public obligatoire).
3. Ajoute un nœud **Code** juste après pour vérifier la signature (voir aussi [Webhooks](webhooks.md)) :

```js
// n8n auto-hébergé : autorise le module crypto avec NODE_FUNCTION_ALLOW_BUILTIN=crypto
const crypto = require('crypto');
const SECRET = $env.DIALYNE_WEBHOOK_SECRET;            // whsec_…
const headers = $input.first().json.headers;
const ts = headers['x-webhook-timestamp'] ?? '';
const sig = headers['x-webhook-signature'] ?? '';
const raw = await this.helpers.getBinaryDataBuffer(0, 'data'); // corps brut (option Raw Body)

const attendu = 'sha256=' + crypto.createHmac('sha256', SECRET).update(ts + '.').update(raw).digest('hex');
const ok = /^\d+$/.test(ts) && Math.abs(Date.now() / 1000 - Number(ts)) <= 300
  && sig.length === attendu.length && crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(attendu));
if (!ok) throw new Error('Signature invalide');
return [{ json: JSON.parse(raw.toString('utf8')) }];
```

4. Ajoute un nœud **Switch** sur `{{ $json.type }}` :
   - `appel.question` : la question est dans `data.question`, l'identifiant dans `data.question_id`, l'échéance dans
     `data.expires_at`. Réponds avec un HTTP Request `POST /v1/missions/{{ $json.mission_id }}/answer` et le corps
     `{"reponse": "…", "question_id": "{{ $json.data.question_id }}"}`. Si la réponse doit venir d'une personne
     (Telegram, Slack…), commence par `POST /v1/missions/{{ $json.mission_id }}/question/prolonger`.
   - `appel.fin` : résultat dans `data.resultat`, résumé dans `data.resume`.
   - `appel.rappel_suggere` : l'interlocuteur veut être rappelé ; relance avec `POST /v1/missions/{id}/rappeler`.

Réponds vite (le nœud Webhook répond 200 tout de suite par défaut) : au-delà de 10 s, nous réessayons l'envoi.

## 3. Variante : un agent IA n8n

1. Ajoute un nœud **AI Agent** et un modèle de chat.
2. Branche un sous-nœud **MCP Client Tool** :
   - Endpoint : `https://mcp.dialyne.com/mcp` (selon ta version de n8n, le champ s'appelle
     « Endpoint » ou « SSE Endpoint » ; choisis le transport **HTTP Streamable** s'il t'est proposé) ;
   - Authentication : **Bearer**, avec ta clé `tel_…` ;
   - Tools to Include : **All**.
3. L'agent dispose alors de `place_phone_call`, `get_call`, `answer_call_question`, `hold_call_question`… Dis-lui de
   suivre l'appel avec `get_call` jusqu'à `done = true`.

Pour une automatisation sans humain, la variante HTTP Request + Webhook est plus fiable : chaque étape est
explicite et rejouable.