Crevio

npx add-mcp 'https://mcp.crevio.co/mcp'

Serveur MCP

Connectez Claude, Cursor ou tout agent compatible MCP à votre compte Crevio : déléguez le travail à l'agent Crevio avec ask_crevio, suivez et poursuivez les exécutions, et exécutez des scripts sur l'ensemble de l'API Crevio et de vos intégrations.

Le serveur MCP Crevio permet à tout agent compatible MCP de déléguer du travail à Crevio — et, lorsqu'il souhaite disposer lui-même des contrôles, d'exécuter des scripts sur l'ensemble de l'API Crevio et de vos intégrations. Un seul serveur, deux surfaces :

• Délégation — ask_crevio confie à l'agent Crevio une tâche en langage naturel (« rembourse la dernière commande de jane@… », « rédige et planifie les publications de cette semaine ») et renvoie le résultat. Les tâches plus longues s'exécutent en arrière-plan ; vous les suivez en tant qu'exécutions, poursuivez la conversation, répondez aux étapes d'approbation et lisez la transcription.
• Scripts — list_integrations et list_integration_tools montrent ce qu'un script peut appeler, et run_script exécute du JavaScript sur l'ordinateur Crevio de votre compte, sur chaque point de terminaison REST et chaque intégration connectée, avec la même autorisation et la même validation que l'API.

URL	https://mcp.crevio.co/mcp
Transport	Streamable HTTP (sans état — chaque requête est autonome)
Authentification	Authorization: Bearer <API token> — le même jeton d'API que celui utilisé pour REST — ou X-Api-Key: <API token> pour les clients qui ne peuvent définir qu'un en-tête personnalisé. OAuth 2.1 est également pris en charge ; voir Connexion.
Découverte	https://mcp.crevio.co/mcp/server-card

[!NOTE]

Vous découvrez le modèle agentique de Crevio ? Commencez par la vue d'ensemble IA & Agents pour voir comment MCP, Tasks et Events s'articulent. En coulisses, une tâche déléguée est une Task avec une seule exécution, donc tout ce qui figure ici est également visible dans votre tableau de bord et via /v1/tasks et /v1/task_runs.

Configuration

1. Créez un jeton d'API

Dans Crevio, allez dans Settings → Developers → API tokens et créez-en un. Une connexion MCP dispose exactement des permissions du jeton qui la sous-tend — tout ce que le compte peut faire.

2. Configurez votre client

Claude Code

claude mcp add --transport http crevio https://mcp.crevio.co/mcp \
  --header "Authorization: Bearer $CREVIO_API_TOKEN"

Claude Desktop / Cursor / autres clients — ajoutez à la configuration MCP du client (claude_desktop_config.json, ~/.cursor/mcp.json, …) :

{
  "mcpServers": {
    "crevio": {
      "url": "https://mcp.crevio.co/mcp",
      "headers": {
        "Authorization": "Bearer <CREVIO_API_TOKEN>"
      }
    }
  }
}

Les étapes propres à chaque client, OAuth et des exemples bruts de curl se trouvent sur la page Connexion.

3. Vérifiez avec whoami

Demandez à l'agent connecté d'appeler whoami. Il renvoie le compte et l'utilisateur derrière le jeton, les informations d'identification, le forfait, le solde de crédits, la limite de débit, les limites d'attente et la liste des outils — sans argument, sans effet de bord. Si whoami fonctionne, tout le reste fonctionnera.

{
  "object": "whoami",
  "account": { "id": "acct_7k2m…", "name": "Jane's Studio", "slug": "janes-studio" },
  "user": { "id": "user_9qx…", "email": "jane@example.com", "name": "Jane Doe" },
  "credential": { "type": "api_key", "id": "token_3fa…", "name": "Claude Desktop", "expires_at": null },
  "plan": "Pro",
  "credits": 1840,
  "rate_limit": { "limit": 600, "window_seconds": 60 },
  "limits": { "ask_timeout_default_seconds": 300, "ask_timeout_max_seconds": 300, "message_max_chars": 10000 },
  "tools": ["whoami", "ask_crevio", "start_chat", "wait_for_run", "get_run", "list_chats", "get_chat", "send_message", "resolve_approvals", "cancel_run", "list_runs", "list_messages", "list_integrations", "list_integration_tools", "run_script", "wait_for_script_run", "get_script_run", "cancel_script_run"]
}

Flux de travail recommandés

Tâches ponctuelles : ask_crevio

Pour le travail qui nécessite du jugement ou de la rédaction. Un seul appel démarre une exécution, l'attend et renvoie l'exécution avec la réponse finale de l'agent dans result. Chaque tâche est une exécution complète de l'agent, de trente secondes à plusieurs minutes — pour lire ou modifier directement des données, un script prend quelques secondes.

{
  "name": "ask_crevio",
  "arguments": {
    "message": "Which three products made the most revenue this month, and how does that compare to last month?",
    "idempotency_key": "monthly-top-products-2026-08"
  }
}

{
  "object": "task_run",
  "id": "trun_8d1k…",
  "task_id": "task_2nq…",
  "task_name": "Which three products made the most revenue this month, and how does that…",
  "chat_id": "aichat_5pz…",
  "status": "completed",
  "summary": "Top three by revenue this month: …",
  "result": "Top three by revenue this month:\n1. Lightroom Presets Vol. 2 — $2,140 (+18% vs July)\n2. …",
  "error_message": null,
  "pending_approval_ids": [],
  "credits_consumed": 4,
  "started_at": "2026-08-20T09:14:02Z",
  "completed_at": "2026-08-20T09:14:31Z",
  "created_at": "2026-08-20T09:14:01Z"
}

• L'attente est par défaut, et plafonnée, à 300 secondes lorsque votre client accepte une réponse en flux (Accept: text/event-stream, que les clients MCP envoient par défaut), et à 90 secondes sinon. Une réponse en flux envoie une notification de progression toutes les 10 secondes pendant l'attente — passez un progressToken dans _meta pour les recevoir. Passez timeout_seconds pour attendre moins longtemps.
• Si l'exécution est toujours en cours à la fin de l'attente, la réponse n'est pas une erreur : c'est l'exécution avec wait_timed_out: true. Appelez wait_for_run avec son id pour continuer à attendre, et n'appelez pas ask_crevio à nouveau — cela relancerait la tâche une seconde fois. Rien n'est perdu ; l'exécution se poursuit du côté de Crevio.
• idempotency_key rend les nouvelles tentatives sûres : la même clé renvoie l'exécution démarrée par le premier appel au lieu d'en démarrer (et d'en payer) une autre. Passez-en toujours une.
• speed: "faster" fait réfléchir l'agent moins longtemps, pour les tâches simples où une réponse plus rapide compte plus que la profondeur. La valeur par défaut est smarter.
• response_format accepte un JSON Schema (ou le {type: "json_schema", json_schema: {schema}} d'OpenAI) lorsque votre programme a besoin d'un objet plutôt que de prose. Le schéma est communiqué à l'agent, et l'exécution terminée porte la valeur analysée dans json, validée par rapport à celui-ci, ou la raison de l'échec dans json_error. start_chat et send_message l'acceptent aussi.
• Les fichiers livrés par l'agent pendant l'exécution reviennent dans artifacts. Échangez le id d'un artefact contre un lien de téléchargement avec get_file_download_url.
• approval_mode vaut autonomous par défaut. supervised fait mettre l'exécution en pause dans needs_input avant chaque écriture soumise à validation jusqu'à ce que vous répondiez à son pending_approval_ids (une exécution sans rien à approuver se termine avec sa proposition ; répondez avec send_message pour agir dessus) ; read_only interdit les écritures.

Tâches de longue durée : start_chat → wait_for_run → send_message

Pour tout ce sur quoi vous ne voulez pas rester bloqué — la construction d'un site, une tâche de recherche, une migration en masse :

1. start_chat met le travail en file d'attente et renvoie immédiatement l'exécution.
2. wait_for_run (avec limite) ou get_run (instantané) jusqu'à ce que status soit completed, failed ou needs_input.
3. send_message poursuit la conversation — instructions de suivi, corrections, réponses à une question posée par l'agent. L'agent conserve son contexte. Sur une exécution terminée, cela démarre une nouvelle exécution dans la même conversation ; sur une exécution needs_input, cela la reprend. Passez timeout_seconds pour attendre la réponse dans le même appel, et un idempotency_key pour qu'un appel réessayé renvoie l'exécution démarrée par le premier (reused: true) au lieu d'envoyer le message deux fois.
4. resolve_approvals lorsqu'une exécution est en pause sur une action d'intégration (needs_input avec pending_approval_ids) — approuvez ou refusez tous les identifiants en attente d'un coup et l'exécution reprend.
5. cancel_run pour arrêter une exécution en attente, en cours ou en pause.

Un chat est la conversation et une exécution est un tour de travail à l'intérieur de celle-ci. list_runs affiche toutes les exécutions du compte (passez chat_id pour les exécutions d'une seule conversation) — tâches déléguées et Tasks planifiées confondues — tandis que list_chats et get_chat parcourent les conversations elles-mêmes, et list_messages lit la transcription complète d'un chat, pas seulement la réponse finale.

Scripts : run_script

Lorsque l'agent connecté veut opérer Crevio lui-même plutôt que déléguer — ou a besoin de données exactes en retour — il écrit un script. run_script exécute du JavaScript sur l'ordinateur Crevio de votre compte avec bun, sans tour d'agent. Le script peut appeler l'API Crevio et chaque intégration connectée à votre compte, enchaîner autant d'appels qu'il le souhaite et transformer les données avant qu'elles ne reviennent.

Découvrir

list_integrations nomme chaque espace de noms qu'un script peut appeler : crevioApi (toute l'API Crevio, une fonction par opération), platform (les propres outils de Crevio) et un par intégration connectée (pdGmail, mcpLinear, …). list_integration_tools liste les fonctions d'un espace de noms, chacune avec ses paramètres sous forme de type TypeScript, si elle ne fait que lire, si elle nécessite une approbation, et un extrait que run_script accepte une fois complété. crevioApi compte des centaines d'opérations, alors restreignez-le avec search :

{ "namespace": "crevioApi", "search": "price variant create" }

Exécuter

tools.<namespace>.<function>(args) effectue un appel. Le await de premier niveau fonctionne, chaque appel renvoie son résultat et lève une exception en cas d'échec, et la dernière expression du script est son résultat.

const product = await tools.crevioApi.createProduct({ body: { name: "My Course", slug: "my-course" } });
await tools.crevioApi.createPriceVariant({
  body: { product: product.id, name: "Standard", amount_type: "fixed", amount: 4900, currency: "usd", billing_type: "one_time" },
});
await tools.crevioApi.updateProduct({ id_or_slug: product.id, body: { status: "active" } });
product.id

Les lectures prennent leurs paramètres directement (listOrders({ status: "succeeded" })) ; les écritures passent le corps de la requête sous body, avec les paramètres de chemin à côté.

Passez des valeurs avec args (jusqu'à 16 chaînes) ; le script les lit depuis la variable globale args. Les fichiers écrits dans le répertoire nommé par la variable globale outputDir reviennent sous forme de artifacts sur l'exécution :

const { data } = await tools.crevioApi.listOrders({ status: "succeeded", limit: Number(args[0]) });
await Bun.write(`${outputDir}/orders.csv`, data.map((o) => o.id).join("\n"));
data.length

Une exécution renvoie une exécution de script (srun_…) : son status (queued → in_progress → completed, failed, cancelled ou timed_out), le result, ce que le script a affiché dans output, son error, et calls — chaque appel d'outil effectué avec son statut HTTP, afin qu'un script ayant intercepté une erreur montre tout de même quel appel a échoué. run_script attend aussi longtemps que ask_crevio le peut (300 secondes sur une réponse en flux, 90 sinon ; passez wait_seconds pour attendre moins longtemps). Une exécution plus longue revient avec wait_timed_out: true et son identifiant — ce n'est pas une erreur : continuez d'attendre avec wait_for_script_run. Appeler run_script à nouveau exécuterait le script deux fois, sauf si vous passez le même idempotency_key.

Les appels crevioApi passent par les mêmes contrôleurs que api.crevio.co, donc les conventions de l'API s'appliquent sans changement : les associations sont des noms bruts avec des identifiants préfixés (product: "prod_abc", pas product_id), les montants sont en centimes, les points de terminaison de liste renvoient {object: "list", data: [...]}, et un produit a besoin d'une variante de prix avant de pouvoir passer active. Les cours et autres contenus sont des expériences (listExperiences), pas des produits.

Limites :

• Qui : administrateurs de compte uniquement. Le script s'exécute en votre nom — vos intégrations personnelles comprises — sur un ordinateur partagé par toute votre équipe.
• Délai d'expiration : timeout_seconds de 1 à 600 (300 par défaut). L'ordinateur peut devoir se réveiller d'abord, ce qui peut ajouter jusqu'à environ 20 secondes.
• Concurrence : au plus 4 exécutions en cours par utilisateur et 8 par compte.
• Approbations : un script ne peut pas s'arrêter pour demander une approbation. Un appel qui en nécessite une (requires_approval dans la liste) échoue avec approval_required : configurez cette action pour qu'elle s'exécute automatiquement dans Settings → Integrations, ou déléguez la tâche avec ask_crevio à la place.
• Annulation : seule une exécution queued peut être annulée. Un script en cours s'exécute jusqu'à sa fin ou son délai d'expiration.
• Fichiers de sortie : au plus 20 par exécution, chacun au plus 50 Mo. Les fichiers plus volumineux sont omis.

Référence complète des outils

Outil	Objectif	Arguments
whoami	Identifier le compte, l'utilisateur, les identifiants, le forfait, les crédits, les limites et les outils	—
ask_crevio	Déléguer une tâche et attendre le résultat	message (obligatoire), timeout_seconds, approval_mode, speed, response_format, idempotency_key
start_chat	Déléguer une tâche sans attendre	message (obligatoire), approval_mode, speed, response_format, idempotency_key
wait_for_run	Attendre (de manière bornée) qu'une exécution se termine	run_id (obligatoire), timeout_seconds
get_run	Récupérer le statut, le résumé, les approbations en attente et la réponse finale d'une exécution	run_id (obligatoire)
list_chats	Lister les conversations du compte, de la plus récente à la plus ancienne	search, limit, starting_after, ending_before
get_chat	Récupérer le titre, le type et la dernière exécution d'une conversation	chat_id (obligatoire)
send_message	Poursuivre une conversation ; attendre éventuellement la réponse	chat_id, message (obligatoire), timeout_seconds, response_format, idempotency_key
resolve_approvals	Approuver/refuser les actions d'intégration sur lesquelles une exécution est en pause	run_id, approvals: [{id, approved, reason}] (obligatoire)
cancel_run	Arrêter une exécution en attente, en cours ou en pause	run_id (obligatoire)
list_runs	Lister les exécutions du compte, de la plus récente à la plus ancienne	status, task_id, chat_id, limit, starting_after, ending_before
list_messages	Lire les messages d'une conversation, du plus ancien au plus récent	chat_id (obligatoire), limit, ending_before
list_integrations	Nommer tous les espaces de noms qu'un script peut appeler	—
list_integration_tools	Lister les fonctions d'un espace de noms avec leurs paramètres et extraits de code	namespace (obligatoire), search, limit, offset
run_script	Exécuter du JavaScript sur l'ordinateur du compte et attendre le résultat	code (obligatoire), args, timeout_seconds, wait_seconds, idempotency_key
wait_for_script_run	Attendre (de manière bornée) qu'une exécution de script se termine	run_id (obligatoire), wait_seconds
get_script_run	Lire le statut et le résultat d'une exécution de script	run_id (obligatoire)
cancel_script_run	Annuler une exécution de script qui n'a pas commencé	run_id (obligatoire)
get_file_download_url	Échanger un identifiant d'artefact (art_…) contre un lien de téléchargement valable 15 minutes	file_id (obligatoire)
list_audit_events	Lister les événements d'audit du compte, du plus récent au plus ancien. Forfait Enterprise uniquement. Nécessite la portée audit:read, et un administrateur lorsque l'identifiant agit en tant que personne	action, actor_type, entity_type, entity_id, after, limit, starting_after, ending_before

Les outils qu'une connexion voit dépendent de ses identifiants :

Les clés API et les jetons OAuth partagent les mêmes portées, et une connexion voit les outils que les portées de ses identifiants autorisent :

• read pour les outils de lecture, write pour les autres, sauf si l'outil nécessite l'une des portées ci-dessous.
• agent:run pour ask_crevio, start_chat, send_message et cancel_run, et resolve_approvals avec write également. Sans write, le travail délégué s'exécute en lecture seule.
• scripts:run pour run_script, wait_for_script_run, get_script_run et cancel_script_run. Une clé d'équipe ne voit jamais ces outils, et sans write, un script ne peut rien modifier.
• files:read pour get_file_download_url, et audit:read pour list_audit_events.
• whoami n'en nécessite aucune.

Un jeton OAuth accordé avec read_only (la valeur par défaut lorsqu'un client ne demande aucune portée) détient read ; un jeton accordé avec read_write détient toutes les portées et voit tous les outils. Il en va de même pour une clé API créée avant l'existence des portées.

Un outil que le jeton ne peut pas utiliser n'apparaît pas dans tools/list, et l'appeler renvoie « Tool not found ». Au-delà des portées, limitez ce qu'un agent peut faire en lui donnant un jeton sur un compte dont vous acceptez qu'il touche les données, et en choisissant approval_mode sur les tâches déléguées.

L'objet run

Les outils de délégation renvoient un run (trun_…), le même objet que GET /v1/task_runs/:id plus result et chat_id :

Champ	Signification
status	pending → running → completed / failed, ou needs_input lorsque l'agent attend votre réponse
result	La réponse finale de l'agent, jusqu'à 24 000 caractères (présente une fois l'exécution terminée)
json, json_error	Avec un response_format : la réponse analysée et validée, ou la raison pour laquelle elle n'était pas un JSON valide pour le schéma
artifacts	Les fichiers livrés par l'exécution, chacun avec {id, filename, content_type, size} ; à télécharger avec get_file_download_url
summary	Les 500 premiers caractères de la réponse — ce que le tableau de bord et les webhooks affichent
pending_approval_ids	Lorsque needs_input : les approbations d'intégration bloquant l'exécution, pour resolve_approvals
error_message	La raison de l'échec d'une exécution failed ("Cancelled by the caller" après cancel_run)
wait_timed_out, next_step	Présents lorsque l'attente s'est terminée avant la fin de l'exécution — elle est toujours en cours ; next_step indique comment la suivre
credits_consumed	Ce que l'exécution a coûté, en crédits IA
task_id, chat_id	La tâche et la conversation sous-jacentes, pour l'API REST et le tableau de bord

Les exécutions déclenchent également les webhooks task_run.completed, task_run.failed et task_run.needs_input, et peuvent être diffusées en flux via SSE à l'adresse GET /v1/task_runs/:id/stream.

Tâches MCP et elicitation

Il s'agit de fonctionnalités de protocole de votre client MCP, distinctes des Tâches propres à Crevio. Avec elles, un client suit les tâches longues et répond lui-même aux approbations au lieu d'appeler wait_for_run et resolve_approvals. Les deux nécessitent le protocole 2026-07-28, que votre client choisit. Sans elles, chaque outil se comporte comme décrit ci-dessus.

Appels d'outils asynchrones

Le serveur implémente l'extension MCP Tasks (io.modelcontextprotocol/tasks), annoncée dans server/discover sur /mcp et /chatgpt. Lorsqu'une requête la déclare dans _meta["io.modelcontextprotocol/clientCapabilities"].extensions, ces outils attendent au maximum 5 secondes puis renvoient un handle de tâche ("resultType": "task") au lieu de garder la requête ouverte : ask_crevio, wait_for_run, send_message avec un timeout_seconds, run_script et wait_for_script_run. Une exécution qui se termine dans ces 5 secondes reçoit une réponse immédiate.

• tasks/get renvoie le status de la tâche. working signifie que l'exécution est toujours en cours. Une fois qu'elle est completed, result contient exactement ce que l'outil aurait renvoyé sans les tâches. Interrogez à pollIntervalMs : 3 secondes pour les exécutions d'agent, 1 seconde pour les scripts.
• tasks/update répond au inputRequests de la tâche (voir ci-dessous).
• tasks/cancel arrête l'exécution, comme cancel_run ou cancel_script_run.

Une tâche est l'exécution elle-même, elle dure donc aussi longtemps que l'exécution (ttlMs vaut null). Une exécution qui se termine en failed termine tout de même la tâche : lisez son status et son error_message dans result. Le statut failed propre à la tâche est réservé aux erreurs de protocole. Un identifiant de tâche est impossible à deviner, et seuls le compte et l'utilisateur ayant lancé l'exécution peuvent le lire. Un identifiant inconnu ou étranger renvoie -32602, et une requête qui ne déclare pas l'extension renvoie -32021.

Approbations et questions

Lorsqu'un client déclare l'elicitation de formulaire (_meta["io.modelcontextprotocol/clientCapabilities"].elicitation), une exécution en pause dans needs_input interroge directement l'utilisateur :

L'exécution attend	Le client est sollicité	Accepter	Refuser ou ignorer
L'approbation d'actions d'intégration	Un formulaire par action, identifié par son ID d'approbation (apr_…), décrivant ce qui serait envoyé	L'approuve	La refuse
Une réponse à la question de l'agent	Un formulaire avec un champ reply	Envoie la réponse et l'exécution continue	Clôt l'exécution comme terminée

Une approbation ignorée vaut refus, donc rien ne s'exécute sans un oui explicite. Vous pouvez répondre aux formulaires dans n'importe quel ordre et plusieurs à la fois. L'exécution reprend une fois que chacun a une réponse, et l'agent reçoit toutes les décisions ensemble.

• Avec les tâches : la tâche passe à input_required avec les formulaires dans inputRequests. Répondez-y avec tasks/update.
• Sans les tâches : l'outil renvoie "resultType": "input_required" avec les formulaires et un requestState. Appelez à nouveau le même outil avec les mêmes arguments, plus inputResponses et ce requestState exact. L'état est scellé, lié à l'outil et à ses arguments, et expire au bout d'une heure.
• Sans elicitation de formulaire : rien ne change. L'exécution revient en needs_input avec pending_approval_ids pour resolve_approvals, y compris en tant que tâche terminée.

Événements

Le serveur implémente l'extension MCP Events à l'état de brouillon (io.modelcontextprotocol/events), afin qu'un client puisse s'abonner à ce qui se passe dans le compte, comme order.paid ou email_message.received, et réagir sans interroger. Elle est annoncée dans server/discover sur /mcp et /chatgpt.

Les types d'événements sont les mêmes que ceux des webhooks, et la charge utile aussi : data.object est la ressource exactement telle que son point de terminaison API la renvoie. events/list liste chaque type avec son payloadSchema.

S'abonner

{
  "jsonrpc": "2.0", "id": 2, "method": "events/subscribe",
  "params": {
    "name": "order.paid",
    "arguments": {},
    "delivery": { "mode": "webhook", "url": "https://hooks.example.com/crevio", "secret": "whsec_<base64 of 24–64 random bytes>" },
    "cursor": null,
    "ttlMs": 86400000
  }
}

La réponse contient l'id d'abonnement (mcpsub_…), stable pour les mêmes identifiants, URL, événement et arguments, ainsi que refreshBefore. Appelez à nouveau events/subscribe avec les mêmes valeurs avant refreshBefore pour le conserver ; events/unsubscribe avec name, arguments et delivery.url y met fin immédiatement.

• Vérification. Avant la première livraison à une URL, Crevio y envoie une requête POST {"type":"verification","challenge":"<nonce>"}. Répondez avec un 2xx et {"challenge":"<nonce>"} dans les 5 secondes. Chaque identifiant vérifie chaque URL une fois.
• Durée de vie. Sans ttlMs, un abonnement dure un jour. Un ttlMs suggéré est conservé entre une minute et un jour. "ttlMs": null demande l'absence d'expiration, et Crevio l'accorde.
• Rotation du secret. Envoyez un nouveau delivery.secret lors d'un rafraîchissement. Pendant 10 minutes, les livraisons portent les signatures des deux secrets.
• Limites. 100 abonnements actifs par compte. S'abonner ne fait que lire, donc un jeton read_only peut le faire.

Livraisons

Chaque événement est un POST de {"eventId", "name", "timestamp", "data"}, signé selon Standard Webhooks avec votre secret (webhook-id, webhook-timestamp, webhook-signature) et portant X-MCP-Subscription-Id. Vérifiez la signature avant de faire confiance au corps, et dédupliquez sur eventId.

Ce que fait votre point de terminaison	Ce qui se passe
Répond 2xx	Livré
Répond 410 ou 413	Abandonné sans nouvelle tentative
Échoue ou expire (5 secondes)	Réessayé jusqu'à 4 fois de plus sur environ 12 minutes, puis abandonné
Continue d'échouer pendant une heure	Les livraisons s'arrêtent jusqu'à ce que votre prochain rafraîchissement les réactive
Continue d'échouer pendant 3 jours sur un abonnement sans expiration	Crevio envoie un POST {"type":"terminated",…} et supprime l'abonnement

Si les identifiants perdent l'accès au compte (clé supprimée ou expirée, accès OAuth révoqué, utilisateur retiré du compte), l'événement suivant met fin à l'abonnement avec une enveloppe terminated portant l'erreur -32024.

Ce qu'il ne peut pas faire

• Livraison par webhook uniquement, par conception pour l'instant. events/poll et events/stream répondent -32026. Utilisez l'API webhooks ou list_runs et les endpoints REST lorsque vous ne pouvez pas recevoir de POST.
• Pas de rejeu. cursor vaut toujours null : les événements survenus pendant qu'un abonnement était interrompu ne sont pas livrés ultérieurement. Relisez l'état actuel via les outils après une interruption.
• Pas de filtres. Les types d'événements n'acceptent aucun arguments. Un abonnement reçoit tous les événements de son type dans le compte.

Les erreurs utilisent les codes de l'extension : -32602 paramètres invalides (URL, secret ou arguments incorrects), -32023 événement ou abonnement inconnu, -32024 aucun principal authentifié ou accès perdu, -32025 limite d'abonnements atteinte, -32026 mode de livraison non proposé, et -32027 la vérification du callback a échoué, avec data.reason parmi connection_refused, timeout, tls_error, http_4xx, http_5xx ou challenge_failed.

Erreurs

Les échecs d'authentification sont des HTTP 401/403 sur la requête elle-même (WWW-Authenticate pointe vers les métadonnées OAuth). Les échecs d'outil reviennent sous forme de résultat d'outil avec isError: true et un corps JSON :

{ "error": "run_busy", "message": "Run trun_8d1k… is still in progress; wait for it to settle before sending more.", "http_status": 409 }

error	Signification	Que faire
run_busy	Une exécution dans cette conversation est encore en cours	Attendez-la, puis send_message
account_at_capacity	Le compte a déjà 5 exécutions en cours (http_status: 429)	Réessayez après retry_after_seconds
idempotency_error	Un idempotency_key réutilisé avec un message différent	Passez une nouvelle clé pour un nouveau message
run_not_active	cancel_run sur une exécution déjà terminée	Rien — lisez son result
run_not_resumable	L'exécution n'a pas de conversation à poursuivre	Démarrez une nouvelle tâche avec ask_crevio
approvals_pending	send_message sur une exécution bloquée par des approbations	resolve_approvals d'abord
stale_resolution	Les approbations soumises ne correspondent pas à l'ensemble en attente	get_run, puis soumettez à nouveau chaque entrée pending_approval_ids
insufficient_credits	Le compte n'a plus de crédits IA	Ajoutez des crédits dans Crevio
resource_missing	Aucune exécution/tâche avec cet id sur ce compte	Vérifiez l'id — les exécutions sont limitées au compte
validation_failed	Un argument invalide (par ex. un approval_mode inconnu)	Corrigez l'argument
rate_limit_exceeded	600 requêtes par minute par propriétaire, partagées avec l'API REST — ou trop d'exécutions de script en cours	Attendez jusqu'à X-RateLimit-Reset (limites de débit), ou attendez qu'une exécution de script se termine
forbidden	run_script par quelqu'un qui n'est pas administrateur du compte	Demandez à un administrateur, ou déléguez avec ask_crevio
run_not_cancellable	cancel_script_run sur une exécution déjà démarrée	Attendez-la avec wait_for_script_run

Un script qui lève une exception revient tout de même comme une exécution de script, avec status: "failed", son error, et le calls qu'il a produit — run_script lui-même ne renvoie d'erreur que si l'exécution n'a pas pu démarrer ou si l'attente s'est terminée.

Sécurité

Chaque outil s'exécute à l'intérieur de la frontière de locataire de votre compte. Les tâches déléguées exécutent l'agent Crevio avec les permissions dont votre compte dispose déjà. run_script s'exécute sur l'ordinateur Crevio de votre compte en tant qu'administrateur appelant ; ses appels tools passent par les mêmes paramètres d'approbation auxquels l'agent obéit et les mêmes contrôleurs d'API que api.crevio.co, de sorte que l'autorisation, la validation et les messages d'erreur sont identiques aux appels d'API directs. Les jetons sont aussi puissants que votre compte : ne connectez que des agents en lesquels vous avez confiance, et révoquez un jeton depuis Settings → Developers pour couper une connexion instantanément.

Étapes suivantes

Connexion

Configuration client par client, OAuth et exemples curl.

Tâches (votre main-d'œuvre IA)

Le modèle Task / Task Run sur lequel repose chaque tâche déléguée — et comment planifier un travail récurrent.

Vue d'ensemble de l'IA et des agents

Comment MCP, Tasks et Events forment le modèle agentique de Crevio.

Conventions de l'API

Les formes, préfixes et pièges que crevioApi partage avec REST.

Cette documentation est construite et hébergée sur Mintlify, une plateforme de documentation pour développeurs.