Crevio

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

Servidor MCP

Conecta Claude, Cursor o cualquier agente compatible con MCP a tu cuenta de Crevio: delega trabajo al agente de Crevio con ask_crevio, sigue y continúa las ejecuciones, y ejecuta scripts contra toda la API de Crevio y tus integraciones.

El servidor MCP de Crevio permite que cualquier agente compatible con MCP delegue trabajo a Crevio — y, cuando quiere tomar los controles por sí mismo, ejecute scripts contra toda la API de Crevio y tus integraciones. Un servidor, dos superficies:

• Delegación — ask_crevio entrega al agente de Crevio un trabajo en lenguaje natural ("reembolsa el último pedido de jane@…", "escribe y programa las publicaciones de esta semana") y devuelve el resultado. Los trabajos más largos se ejecutan en segundo plano; los sigues como ejecuciones, continúas la conversación, respondes a las solicitudes de aprobación y lees la transcripción.
• Scripts — list_integrations y list_integration_tools muestran qué puede llamar un script, y run_script ejecuta JavaScript en el ordenador de Crevio de tu cuenta contra cada endpoint REST y cada integración conectada, con la misma autorización y validación que la API.

URL	https://mcp.crevio.co/mcp
Transporte	Streamable HTTP (sin estado — cada solicitud es autocontenida)
Autenticación	Authorization: Bearer <API token> — el mismo token de API que usas para REST — o X-Api-Key: <API token> para clientes que solo pueden establecer una cabecera personalizada. También se admite OAuth 2.1; consulta Conexión.
Descubrimiento	https://mcp.crevio.co/mcp/server-card

[!NOTE]

¿Eres nuevo en el modelo agéntico de Crevio? Empieza con la descripción general de IA y agentes para ver cómo encajan MCP, Tareas y Eventos. En esencia, un trabajo delegado es una Tarea con una ejecución, así que todo lo que hay aquí también es visible en tu panel y a través de /v1/tasks y /v1/task_runs.

Configuración

1. Crea un token de API

En Crevio ve a Settings → Developers → API tokens y crea uno. Una conexión MCP tiene exactamente los permisos del token que la respalda — todo lo que la cuenta puede hacer.

2. Configura tu cliente

Claude Code

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

Claude Desktop / Cursor / otros clientes — añade a la configuración MCP del cliente (claude_desktop_config.json, ~/.cursor/mcp.json, …):

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

Los pasos específicos de cada cliente, OAuth y ejemplos de curl sin procesar están en la página Conexión.

3. Verifica con whoami

Pide al agente conectado que llame a whoami. Devuelve la cuenta y el usuario detrás del token, la credencial, el plan, el saldo de créditos, el límite de velocidad, los límites de espera y la lista de herramientas — sin argumentos, sin efectos secundarios. Si whoami funciona, todo lo demás también lo hará.

{
  "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"]
}

Flujos de trabajo recomendados

Trabajos puntuales: ask_crevio

Para trabajo que requiere criterio o redacción. Una llamada inicia una ejecución, la espera y devuelve la ejecución con la respuesta final del agente en result. Cada trabajo es una ejecución completa del agente, desde medio minuto hasta varios minutos — para leer o cambiar datos directamente, un script tarda segundos.

{
  "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"
}

• La espera es de 300 segundos por defecto y como máximo cuando tu cliente acepta una respuesta transmitida (Accept: text/event-stream, que los clientes MCP envían por defecto), y de 90 segundos en caso contrario. Una respuesta transmitida envía una notificación de progreso cada 10 segundos mientras espera — pasa un progressToken en _meta para recibirlas. Pasa timeout_seconds para esperar menos.
• Si la ejecución sigue en curso cuando termina la espera, la respuesta no es un error: es la ejecución con wait_timed_out: true. Llama a wait_for_run con su id para seguir esperando, y no vuelvas a llamar a ask_crevio — eso iniciaría el trabajo por segunda vez. No se pierde nada; la ejecución continúa en el lado de Crevio.
• idempotency_key hace seguros los reintentos: la misma clave devuelve la ejecución que inició la primera llamada en lugar de iniciar (y pagar por) otra. Pásala siempre.
• speed: "faster" hace que el agente piense menos, para trabajos simples donde una respuesta más rápida importa más que la profundidad. El valor por defecto es smarter.
• response_format acepta un JSON Schema (o el {type: "json_schema", json_schema: {schema}} de OpenAI) cuando tu programa necesita un objeto en lugar de prosa. Se le indica el esquema al agente, y la ejecución finalizada lleva el valor analizado en json, validado contra él, o el motivo del fallo en json_error. start_chat y send_message también lo aceptan.
• Los archivos que el agente entregó durante la ejecución vuelven en artifacts. Canjea el id de un artefacto por un enlace de descarga con get_file_download_url.
• approval_mode es autonomous por defecto. supervised hace que la ejecución se pause en needs_input antes de cada escritura sujeta a aprobación hasta que respondas a su pending_approval_ids (una ejecución sin nada que aprobar termina con su propuesta; responde con send_message para actuar sobre ella); read_only prohíbe las escrituras.

Trabajos de larga duración: start_chat → wait_for_run → send_message

Para cualquier cosa en la que no quieras bloquear: la construcción de un sitio, una tarea de investigación, una migración masiva:

1. start_chat pone el trabajo en cola y devuelve la ejecución de inmediato.
2. wait_for_run (con límite) o get_run (instantáneo) hasta que status sea completed, failed o needs_input.
3. send_message continúa la conversación — instrucciones de seguimiento, correcciones, respuestas a una pregunta que hizo el agente. El agente conserva su contexto. En una ejecución terminada, esto inicia una nueva ejecución en la misma conversación; en una ejecución needs_input, la reanuda. Pasa timeout_seconds para esperar la respuesta en la misma llamada, y un idempotency_key para que una llamada reintentada devuelva la ejecución que inició la primera (reused: true) en lugar de enviar el mensaje dos veces.
4. resolve_approvals cuando una ejecución está pausada en una acción de integración (needs_input con pending_approval_ids) — aprueba o deniega todos los ids pendientes a la vez y la ejecución se reanuda.
5. cancel_run para detener una ejecución que está pendiente, en curso o en espera.

Un chat es la conversación y una ejecución es un turno de trabajo dentro de ella. list_runs muestra cada ejecución de la cuenta (pasa chat_id para solo las ejecuciones de una conversación) — tanto los trabajos delegados como tus Tareas programadas — mientras que list_chats y get_chat exploran las conversaciones mismas, y list_messages lee la transcripción completa de un chat, no solo la respuesta final.

Scripts: run_script

Cuando el agente conectado quiere operar Crevio por sí mismo en lugar de delegar — o necesita datos exactos de vuelta — escribe un script. run_script ejecuta JavaScript en el ordenador de Crevio de tu cuenta con bun, sin un turno del agente. El script puede llamar a la API de Crevio y a cada integración que tu cuenta tenga conectada, encadenar tantas llamadas como quiera y transformar los datos antes de que vuelvan.

Descubrir

list_integrations nombra cada espacio de nombres que un script puede llamar: crevioApi (toda la API de Crevio, una función por operación), platform (las propias herramientas de Crevio) y uno por cada integración conectada (pdGmail, mcpLinear, …). list_integration_tools lista las funciones de un espacio de nombres, cada una con sus parámetros como tipo de TypeScript, si solo lee, si necesita aprobación y un fragmento que run_script acepta una vez que lo completes. crevioApi tiene cientos de operaciones, así que redúcelo con search:

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

Ejecutar

tools.<namespace>.<function>(args) hace una llamada. El await de nivel superior funciona, cada llamada devuelve su resultado y lanza una excepción en caso de fallo, y la última expresión del script es su resultado.

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

Las lecturas toman sus parámetros directamente (listOrders({ status: "succeeded" })); las escrituras pasan el cuerpo de la solicitud bajo body, con los parámetros de ruta al lado.

Pasa valores con args (hasta 16 cadenas); el script los lee desde el global args. Los archivos escritos en el directorio indicado por el global outputDir vuelven como artifacts en la ejecución:

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

Una ejecución devuelve una ejecución de script (srun_…): su status (queued → in_progress → completed, failed, cancelled o timed_out), el result, lo que el script imprimió en output, su error y calls — cada llamada de herramienta que hizo con su estado HTTP, de modo que un script que capturó un error sigue mostrando qué llamada falló. run_script espera tanto como puede ask_crevio (300 segundos en una respuesta transmitida, 90 en caso contrario; pasa wait_seconds para esperar menos). Una ejecución que tarda más vuelve con wait_timed_out: true y su id — no es un error: sigue esperando con wait_for_script_run. Volver a llamar a run_script ejecutaría el script dos veces, a menos que pases el mismo idempotency_key.

Las llamadas de crevioApi pasan por los mismos controladores que api.crevio.co, así que las convenciones de la API se aplican sin cambios: las asociaciones son nombres simples con ids con prefijo (product: "prod_abc", no product_id), el dinero está en centavos, los endpoints de lista devuelven {object: "list", data: [...]}, y un producto necesita una variante de precio antes de poder pasar a active. Los cursos y otros contenidos son experiencias (listExperiences), no productos.

Límites:

• Quién: solo administradores de la cuenta. El script se ejecuta como tú — incluidas tus integraciones personales — en un ordenador que comparte todo tu equipo.
• Tiempo de espera: timeout_seconds de 1 a 600 (por defecto 300). El ordenador puede necesitar despertarse primero, lo que puede añadir hasta unos 20 segundos.
• Concurrencia: como máximo 4 ejecuciones en curso por usuario y 8 por cuenta.
• Aprobaciones: un script no puede detenerse y pedir aprobación. Una llamada que la necesite (requires_approval en el listado) falla con approval_required: configura esa acción para que se ejecute automáticamente en Settings → Integrations, o delega el trabajo con ask_crevio en su lugar.
• Cancelación: solo se puede cancelar una ejecución queued. Un script en ejecución corre hasta su final o hasta su tiempo de espera.
• Archivos de salida: como máximo 20 por ejecución, cada uno de como máximo 50 MB. Los archivos más grandes se omiten.

Referencia completa de herramientas

Herramienta	Propósito	Argumentos
whoami	Identificar la cuenta, el usuario, la credencial, el plan, los créditos, los límites y las herramientas	—
ask_crevio	Delegar un trabajo y esperar el resultado	message (obligatorio), timeout_seconds, approval_mode, speed, response_format, idempotency_key
start_chat	Delegar un trabajo sin esperar	message (obligatorio), approval_mode, speed, response_format, idempotency_key
wait_for_run	Esperar (con límite) a que una ejecución se resuelva	run_id (obligatorio), timeout_seconds
get_run	Obtener el estado, el resumen, las aprobaciones pendientes y la respuesta final de una ejecución	run_id (obligatorio)
list_chats	Listar los chats de la cuenta, del más reciente al más antiguo	search, limit, starting_after, ending_before
get_chat	Obtener el título, el tipo y la última ejecución de un chat	chat_id (obligatorio)
send_message	Continuar un chat; opcionalmente, esperar la respuesta	chat_id, message (obligatorio), timeout_seconds, response_format, idempotency_key
resolve_approvals	Aprobar o denegar las acciones de integración por las que una ejecución está en pausa	run_id, approvals: [{id, approved, reason}] (obligatorio)
cancel_run	Detener una ejecución pendiente, en curso o en espera	run_id (obligatorio)
list_runs	Listar las ejecuciones de la cuenta, de la más reciente a la más antigua	status, task_id, chat_id, limit, starting_after, ending_before
list_messages	Leer los mensajes de un chat, del más antiguo al más reciente	chat_id (obligatorio), limit, ending_before
list_integrations	Nombrar cada espacio de nombres que un script puede llamar	—
list_integration_tools	Listar las funciones de un espacio de nombres con sus parámetros y fragmentos de código	namespace (obligatorio), search, limit, offset
run_script	Ejecutar JavaScript en el ordenador de la cuenta y esperar a que termine	code (obligatorio), args, timeout_seconds, wait_seconds, idempotency_key
wait_for_script_run	Esperar (con límite) a que termine una ejecución de script	run_id (obligatorio), wait_seconds
get_script_run	Leer el estado y el resultado de una ejecución de script	run_id (obligatorio)
cancel_script_run	Cancelar una ejecución de script que no ha comenzado	run_id (obligatorio)
get_file_download_url	Canjear un id de artefacto (art_…) por un enlace de descarga válido durante 15 minutos	file_id (obligatorio)
list_audit_events	Listar los eventos de auditoría de la cuenta, del más reciente al más antiguo. Solo en el plan Enterprise. Requiere el ámbito audit:read y un administrador cuando la credencial actúa como una persona	action, actor_type, entity_type, entity_id, after, limit, starting_after, ending_before

Las herramientas que ve una conexión dependen de su credencial:

Las claves de API y los tokens OAuth comparten los mismos ámbitos, y una conexión ve las herramientas que permiten los ámbitos de su credencial:

• read para las herramientas que leen, write para el resto, salvo que la herramienta necesite uno de los ámbitos siguientes.
• agent:run para ask_crevio, start_chat, send_message y cancel_run, y resolve_approvals con write también. Sin write, el trabajo delegado se ejecuta en modo de solo lectura.
• scripts:run para run_script, wait_for_script_run, get_script_run y cancel_script_run. Una clave de equipo nunca ve estas herramientas, y sin write un script no puede cambiar nada.
• files:read para get_file_download_url, y audit:read para list_audit_events.
• whoami no necesita ninguno.

Un token OAuth al que se le concede read_only (el valor predeterminado cuando un cliente no solicita ningún ámbito) posee read; uno al que se le concede read_write posee todos los ámbitos y ve todas las herramientas. Lo mismo ocurre con una clave de API creada antes de que existieran los ámbitos.

Una herramienta que el token no puede usar no aparece en tools/list, y llamarla responde "Tool not found". Más allá de los ámbitos, limita lo que un agente puede hacer dándole un token sobre una cuenta cuyos datos te parezca bien que toque, y eligiendo approval_mode en los trabajos delegados.

El objeto run

Las herramientas de delegación devuelven un run (trun_…), el mismo objeto que GET /v1/task_runs/:id más result y chat_id:

Campo	Significado
status	pending → running → completed / failed, o needs_input cuando el agente está esperándote
result	La respuesta final del agente, de hasta 24.000 caracteres (presente una vez que la ejecución se ha resuelto)
json, json_error	Con un response_format: la respuesta analizada y validada, o el motivo por el que no era JSON válido para el esquema
artifacts	Archivos que entregó la ejecución, cada uno con {id, filename, content_type, size}; descárgalos con get_file_download_url
summary	Los primeros 500 caracteres de la respuesta: lo que muestran el panel y los webhooks
pending_approval_ids	Cuando needs_input: las aprobaciones de integración que bloquean la ejecución, para resolve_approvals
error_message	Por qué falló una ejecución failed ("Cancelled by the caller" después de cancel_run)
wait_timed_out, next_step	Presentes cuando la espera terminó antes de que la ejecución se resolviera: sigue en curso; next_step indica cómo seguirla
credits_consumed	Lo que costó la ejecución, en créditos de IA
task_id, chat_id	La Task y la conversación subyacentes, para la API REST y el panel

Las ejecuciones también disparan los webhooks task_run.completed, task_run.failed y task_run.needs_input, y se pueden transmitir por SSE en GET /v1/task_runs/:id/stream.

Tareas MCP y elicitación

Estas son características de protocolo de tu cliente MCP, independientes de las Tasks propias de Crevio. Con ellas, un cliente sigue trabajos largos y responde a las aprobaciones por sí mismo en lugar de llamar a wait_for_run y resolve_approvals. Ambas requieren el protocolo 2026-07-28, que elige tu cliente. Sin ellas, cada herramienta se comporta como se describe arriba.

Llamadas a herramientas asíncronas

El servidor implementa la extensión MCP Tasks (io.modelcontextprotocol/tasks), anunciada en server/discover tanto en /mcp como en /chatgpt. Cuando una solicitud la declara en _meta["io.modelcontextprotocol/clientCapabilities"].extensions, estas herramientas esperan como máximo 5 segundos y luego devuelven un identificador de tarea ("resultType": "task") en lugar de mantener la solicitud abierta: ask_crevio, wait_for_run, send_message con un timeout_seconds, run_script y wait_for_script_run. Una ejecución que termina dentro de esos 5 segundos se responde en el acto.

• tasks/get devuelve el status de la tarea. working significa que la ejecución sigue en curso. Una vez que está completed, result contiene exactamente lo que la herramienta habría devuelto sin tareas. Consulta a intervalos de pollIntervalMs: 3 segundos para ejecuciones de agente, 1 segundo para scripts.
• tasks/update responde al inputRequests de la tarea (ver más abajo).
• tasks/cancel detiene la ejecución, como cancel_run o cancel_script_run.

Una tarea es la propia ejecución, así que dura lo que dure la ejecución (ttlMs es null). Una ejecución que termina failed igualmente completa la tarea: lee su status y error_message dentro de result. El estado failed propio de la tarea se reserva para errores de protocolo. Un ID de tarea es imposible de adivinar, y solo la cuenta y el usuario que iniciaron la ejecución pueden leerlo. Un ID desconocido o ajeno responde -32602, y una solicitud que no declara la extensión responde -32021.

Aprobaciones y preguntas

Cuando un cliente declara la elicitación de formularios (_meta["io.modelcontextprotocol/clientCapabilities"].elicitation), una ejecución en pausa en needs_input pregunta directamente al usuario:

La ejecución está esperando	Al cliente se le pide	Aceptar	Rechazar o descartar
Aprobación de acciones de integración	Un formulario por acción, identificado por su ID de aprobación (apr_…), que describe lo que se enviaría	La aprueba	La deniega
Una respuesta a la pregunta del agente	Un formulario con un campo reply	Envía la respuesta y la ejecución continúa	Cierra la ejecución como completada

Una aprobación descartada es una denegación, así que nada se ejecuta sin un sí explícito. Puedes responder a los formularios en cualquier orden y varios a la vez. La ejecución se reanuda una vez que todos tienen respuesta, y el agente recibe todas las decisiones juntas.

• Con tareas: la tarea pasa a input_required con los formularios en inputRequests. Respóndelos con tasks/update.
• Sin tareas: la herramienta devuelve "resultType": "input_required" con los formularios y un requestState. Vuelve a llamar a la misma herramienta con los mismos argumentos, más inputResponses y ese requestState exacto. El estado está sellado, vinculado a la herramienta y a sus argumentos, y caduca al cabo de una hora.
• Sin elicitación de formularios: nada cambia. La ejecución vuelve needs_input con pending_approval_ids para resolve_approvals, incluso como tarea completada.

Eventos

El servidor implementa la extensión MCP Events en borrador (io.modelcontextprotocol/events), de modo que un cliente puede suscribirse a cosas que ocurren en la cuenta, como order.paid o email_message.received, y reaccionar sin sondear. Se anuncia en server/discover tanto en /mcp como en /chatgpt.

Los tipos de evento son los mismos que los de los webhooks, y también lo es la carga útil: data.object es el recurso exactamente como lo devuelve su endpoint de API. events/list enumera cada tipo con su payloadSchema.

Suscripción

{
  "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 respuesta incluye el id de la suscripción (mcpsub_…), estable para la misma credencial, URL, evento y argumentos, y refreshBefore. Vuelve a llamar a events/subscribe con los mismos valores antes de refreshBefore para mantenerla; events/unsubscribe con name, arguments y delivery.url la finaliza de inmediato.

• Verificación. Antes de la primera entrega a una URL, Crevio envía un POST con {"type":"verification","challenge":"<nonce>"} a ella. Responde con un 2xx y {"challenge":"<nonce>"} en un plazo de 5 segundos. Cada credencial verifica cada URL una vez.
• Duración. Sin ttlMs, una suscripción dura un día. Un ttlMs sugerido se mantiene entre un minuto y un día. "ttlMs": null solicita que no caduque, y Crevio lo concede.
• Rotación del secreto. Envía un nuevo delivery.secret en una renovación. Durante 10 minutos, las entregas llevan firmas de ambos secretos.
• Límites. 100 suscripciones activas por cuenta. Suscribirse solo lee, así que un token read_only puede hacerlo.

Entregas

Cada evento es un POST de {"eventId", "name", "timestamp", "data"}, firmado según Standard Webhooks con tu secreto (webhook-id, webhook-timestamp, webhook-signature) y con X-MCP-Subscription-Id. Verifica la firma antes de fiarte del cuerpo, y deduplica por eventId.

Lo que hace tu endpoint	Lo que ocurre
Responde 2xx	Entregado
Responde 410 o 413	Descartado sin reintentar
Falla o se agota el tiempo (5 segundos)	Se reintenta hasta 4 veces más durante unos 12 minutos, y luego se descarta
Sigue fallando durante una hora	Las entregas se detienen hasta que tu siguiente renovación las reactive
Sigue fallando durante 3 días en una suscripción sin caducidad	Crevio envía un POST con {"type":"terminated",…} y elimina la suscripción

Si la credencial pierde el acceso a la cuenta (clave eliminada o caducada, acceso OAuth revocado, usuario eliminado de la cuenta), el siguiente evento finaliza la suscripción con un sobre terminated que lleva el error -32024.

Lo que no puede hacer

• Entrega solo por webhook, por diseño por ahora. events/poll y events/stream responden -32026. Usa la API de webhooks o list_runs y los endpoints REST cuando no puedas recibir POSTs.
• Sin reproducción. cursor siempre es null: los eventos que ocurren mientras una suscripción ha caducado no se entregan después. Lee el estado actual a través de las herramientas tras un intervalo.
• Sin filtros. Los tipos de evento no aceptan arguments. Una suscripción recibe todos los eventos de su tipo en la cuenta.

Los errores usan los códigos de la extensión: -32602 parámetros inválidos (URL, secreto o argumentos incorrectos), -32023 evento o suscripción desconocidos, -32024 sin principal autenticado o acceso perdido, -32025 límite de suscripciones, -32026 modo de entrega no ofrecido, y -32027 la verificación del callback falló, con data.reason uno de connection_refused, timeout, tls_error, http_4xx, http_5xx o challenge_failed.

Errores

Los fallos de autenticación son HTTP 401/403 en la propia solicitud (WWW-Authenticate apunta a los metadatos de OAuth). Los fallos de las herramientas vuelven como un resultado de herramienta con isError: true y un cuerpo JSON:

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

error	Significado	Qué hacer
run_busy	Una ejecución en esta conversación sigue en curso	Espera a que termine y luego send_message
account_at_capacity	La cuenta ya tiene 5 ejecuciones en marcha (http_status: 429)	Reintenta después de retry_after_seconds
idempotency_error	Un idempotency_key reutilizado con un mensaje diferente	Pasa una clave nueva para un mensaje nuevo
run_not_active	cancel_run en una ejecución que ya terminó	Nada — lee su result
run_not_resumable	La ejecución no tiene conversación que continuar	Inicia un trabajo nuevo con ask_crevio
approvals_pending	send_message en una ejecución bloqueada por aprobaciones	resolve_approvals primero
stale_resolution	Las aprobaciones que enviaste no coinciden con el conjunto pendiente	get_run, luego reenvía cada entrada de pending_approval_ids
insufficient_credits	La cuenta no tiene créditos de IA restantes	Añade créditos en Crevio
resource_missing	No hay ejecución/tarea con ese id en esta cuenta	Verifica el id — las ejecuciones están limitadas a la cuenta
validation_failed	Un argumento incorrecto (p. ej. un approval_mode desconocido)	Corrige el argumento
rate_limit_exceeded	600 solicitudes por minuto por propietario, compartidas con la API REST — o demasiadas ejecuciones de script en curso	Retrocede hasta X-RateLimit-Reset (límites de tasa), o espera a que termine una ejecución de script
forbidden	run_script por alguien que no es administrador de la cuenta	Pídeselo a un administrador, o delega con ask_crevio
run_not_cancellable	cancel_script_run en una ejecución que ya comenzó	Espera a que termine con wait_for_script_run

Un script que lanza una excepción sigue volviendo como una ejecución de script, con status: "failed", su error, y el calls que produjo — run_script en sí solo da error cuando la ejecución no pudo iniciarse o la espera terminó.

Seguridad

Cada herramienta se ejecuta dentro del límite de inquilino de tu cuenta. Los trabajos delegados ejecutan el agente de Crevio con los permisos que tu cuenta ya tiene. run_script se ejecuta en el ordenador de Crevio de tu cuenta como el administrador que llama; sus llamadas a tools pasan por la misma configuración de aprobaciones que obedece el agente y los mismos controladores de API que api.crevio.co, por lo que la autorización, la validación y los mensajes de error son idénticos a las llamadas directas a la API. Los tokens son tan poderosos como tu cuenta: conecta solo agentes de confianza y revoca un token desde Settings → Developers para cortar una conexión al instante.

Próximos pasos

Conexión

Configuración cliente por cliente, OAuth y ejemplos con curl.

Tareas (tu fuerza laboral de IA)

El modelo Task / Task Run sobre el que se construye cada trabajo delegado — y cómo programar trabajo recurrente.

Descripción general de IA y agentes

Cómo MCP, Tasks y Events forman el modelo agéntico de Crevio.

Convenciones de la API

Las formas, prefijos y trampas que crevioApi comparte con REST.

Esta documentación está creada y alojada en Mintlify, una plataforma de documentación para desarrolladores.