Koskamo

Crevio MCP

The Crevio MCP server allows agents to delegate business operations to the Crevio AI or run scripts against the Crevio API and integrations. It supports one-off jobs via ask_crevio, long-running tasks, and direct API scripting for tasks like payments, CRM, and site management.

Endpoint and access

OAuth sign-in: the first time you connect, your client opens the vendor's own authorization prompt in a browser.

Crevio MCP logo, by CrevioVendor evidenceStreamable HTTPOAuth sign-inEndpoint checked 2026-11-06Operated by Crevio
You need:Authorization: Bearer <API token>X-Api-Key: <API token>OAuth 2.1 is also supported
MCP endpoint (Streamable HTTP)
https://mcp.crevio.co/mcp
Vendor documentation

What its tools do

20 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

20 of 20 have a description · 20 of 20 declare behavior hints · 17 of 18 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to crevio.co ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Delegate business tasks to the Crevio AI agent
  • Run JavaScript scripts against the Crevio API
  • Manage payments, CRM, and email operations
  • Monitor and control long-running agent tasks

Source and maintenance

Vendor evidenceRegistry 2.0.1
Maintenance checked

Protocol and capabilities

Server
crevio-api 2.0.0
MCP protocol negotiated in check
2025-11-25
Tools
20 advertised
Resources
Sign-in required
Resource templates
Sign-in required
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {},
  "resources": {},
  "extensions": {
    "io.modelcontextprotocol/tasks": {},
    "io.modelcontextprotocol/events": {},
    "io.modelcontextprotocol/skills": {}
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Crevio MCP server — run the user's Crevio business. The person you are helping usually runs the business and is not a developer: talk about their products, customers, orders and emails in plain words, and leave ids, tool names, scripts, flags and API details out of replies unless they ask for them. Asked what you can do, describe jobs for their business (set up a discount, find the best customers, write and send a campaign), not the tools behind them. Two ways in: Scripts, for reading or changing data directly (seconds): `list_integrations` and `list_integration_tools` show what a script can call; `run_script` runs JavaScript on the account's computer, where `tools.<namespace>.<function>(args)` makes a call and the last expression is the result, e.g. `(await tools.crevioApi.listProducts({ limit: 100 })).data.map((p) => p.name)`. Delegation, for work that needs judgement or writing (a minute or more): `ask_crevio` hands the Crevio agent a job and waits; `start_chat` queues one without waiting. Always pass an `idempotency_key` when starting work. A reply with `wait_timed_out: true` is not an error — the work is still running: follow it with `wait_for_run` (or `wait_for_script_run`) and never start it again. Continue a chat with `send_message`, read it with `list_messages`, answer approval gates with `resolve_approvals`. `whoami` shows the account, credits, and limits. Products are for sale; Experiences are the content (courses, downloads, links). Everything is scoped to the authenticated account.

Tools

20 advertised

whoami
Advertised by the server during the last successful anonymous check.
Advertised read-only

Identify the account, user, and credential behind this connection, with plan, credit balance, rate limits, and the tools available. Only needed to troubleshoot the connection or check credits and limits — other tools already act on this account.

whoami input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
whoami output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "account",
    "credential",
    "plan",
    "credits",
    "tools"
  ],
  "properties": {
    "plan": {
      "type": "string"
    },
    "user": {
      "type": [
        "object",
        "null"
      ],
      "required": [
        "id",
        "email"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "name": {
          "type": [
            "string",
            "null"
          ]
        },
        "email": {
          "type": "string"
        }
      }
    },
    "tools": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "limits": {
      "type": "object",
      "required": [
        "ask_timeout_default_seconds",
        "ask_timeout_max_seconds",
        "message_max_chars"
      ],
      "properties": {
        "message_max_chars": {
          "type": "integer"
        },
        "ask_timeout_max_seconds": {
          "type": "integer",
          "description": "Longer when this connection accepts a streamed reply."
        },
        "ask_timeout_default_seconds": {
          "type": "integer"
        }
      },
      "description": "Bounds the delegation tools enforce."
    },
    "object": {
      "type": "string",
      "const": "whoami"
    },
    "account": {
      "type": "object",
      "required": [
        "id",
        "name"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "slug": {
          "type": [
            "string",
            "null"
          ]
        },
        "set_up": {
          "type": "boolean",
          "description": "False until Crevio has set the business up. While false, ask the person to describe their business and pass that to ask_crevio."
        }
      },
      "description": "The account every tool call is scoped to."
    },
    "credits": {
      "type": "number"
    },
    "credential": {
      "type": "object",
      "required": [
        "type"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "kind": {
          "enum": [
            "personal",
            "team"
          ],
          "type": "string"
        },
        "name": {
          "type": [
            "string",
            "null"
          ]
        },
        "type": {
          "enum": [
            "api_key",
            "oauth"
          ],
          "type": "string"
        },
        "scopes": {
          "type": [
            "array",
            "null"
          ],
          "items": {
            "type": "string"
          },
          "description": "The scopes it holds, OAuth's read_only and read_write expanded. Null for an API key made before scopes existed, which reaches every tool."
        },
        "expires_at": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        }
      },
      "description": "How this connection authenticated."
    },
    "rate_limit": {
      "type": "object",
      "required": [
        "limit",
        "window_seconds"
      ],
      "properties": {
        "limit": {
          "type": "integer"
        },
        "window_seconds": {
          "type": "integer"
        }
      },
      "description": "The API rate limit this credential is subject to."
    }
  },
  "description": "The account, user, and credential behind this connection, with the limits that apply to it."
}
whoami annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
list_integrations
Advertised by the server during the last successful anonymous check.
Advertised read-only

List what a script can call: the Crevio API (crevioApi), Crevio's own tools (platform), and every integration you can use, each as a namespace under `tools`, plus the account's other connected apps and their status. Then list a namespace's functions with list_integration_tools.

list_integrations input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
list_integrations output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "other_connections"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "namespace",
          "kind",
          "tool_count"
        ],
        "properties": {
          "kind": {
            "enum": [
              "native",
              "crevio_api",
              "connection",
              "public"
            ],
            "type": "string"
          },
          "label": {
            "type": [
              "string",
              "null"
            ],
            "description": "Which connected account, when the app is connected more than once or personally."
          },
          "namespace": {
            "type": "string",
            "description": "The module a script calls it through: tools.<namespace>.<function>."
          },
          "tool_count": {
            "type": "integer"
          }
        }
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "other_connections": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "app",
          "status"
        ],
        "properties": {
          "app": {
            "type": "string"
          },
          "label": {
            "type": [
              "string",
              "null"
            ]
          },
          "status": {
            "type": "string"
          }
        }
      },
      "description": "Connected apps without a namespace of their own: expired ones need reconnecting in Crevio, social accounts are reached through crevioApi, and the rest serve Crevio itself (Slack for chat, GitHub for sites)."
    }
  }
}
list_integrations annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
list_integration_tools
Advertised by the server during the last successful anonymous check.
Advertised read-only

List one namespace's functions — the name a script calls, its parameters, whether it only reads, whether it needs approval, and a snippet run_script accepts. crevioApi has hundreds of operations: narrow it with `search`.

list_integration_tools input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "namespace"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Default 10."
    },
    "offset": {
      "type": "integer",
      "minimum": 0,
      "description": "Skip this many matches — the count already seen."
    },
    "search": {
      "type": "string",
      "description": "Keywords, best match first — ranked over name, description and parameters, so not every word has to match."
    },
    "namespace": {
      "type": "string",
      "description": "A namespace from list_integrations, e.g. crevioApi or pdGmail."
    }
  }
}
list_integration_tools output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "has_more"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "parameters",
          "read_only",
          "requires_approval",
          "disabled",
          "snippet"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "What a script calls: tools.<namespace>.<function>."
          },
          "returns": {
            "type": "string",
            "description": "What a read resolves to, as a TypeScript type; objects past two levels show as Record<string, unknown>."
          },
          "snippet": {
            "type": "string",
            "description": "A script run_script accepts as-is once the placeholders are filled."
          },
          "disabled": {
            "type": "boolean"
          },
          "read_only": {
            "type": "boolean"
          },
          "parameters": {
            "type": "string",
            "description": "The argument object, as a TypeScript type."
          },
          "description": {
            "type": [
              "string",
              "null"
            ]
          },
          "requires_approval": {
            "type": "boolean",
            "description": "A script's call does not run: it resolves to {pending: true, draft_id, approval} and runs once a person approves it."
          }
        }
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "has_more": {
      "type": "boolean"
    }
  }
}
list_integration_tools annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
run_script
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Run JavaScript on the account's computer with bun — no agent turn — and wait for its result. `tools.<namespace>.<function>(args)` calls anything list_integration_tools shows (every call returns its result and throws on failure; top-level await works), and the script's last expression is its result. Chain calls and transform data in one run, e.g. `const { data } = await tools.crevioApi.listOrders({ status: "succeeded" }); data.length`. A function marked requires_approval: true does not run: the call resolves to `{pending: true, draft_id, approval}` (check `result.pending`), the script carries on, and the run lists it in `pending_approval_ids`. Approving it in Crevio, with resolve_approvals, or in the reply when this client can show a form runs that one frozen call, never the script again. Runs as you, and only for account admins. If the wait ends first the reply has wait_timed_out: true and the run id: continue with wait_for_script_run — calling run_script again runs it twice unless you reuse the idempotency_key. Run ids do not expire, and only the user who started a run can read it. At most 4 runs in flight per user. `args` reach the script as the global `args` (and process.argv). Files the script writes into the directory named by the global `outputDir` (20 at most, 50 MB each) come back as `artifacts`; get a download link with get_file_download_url.

run_script input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "code"
  ],
  "properties": {
    "args": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 2000
      },
      "maxItems": 16,
      "description": "Values the script reads from the global `args`."
    },
    "code": {
      "type": "string",
      "maxLength": 100000,
      "description": "The JavaScript to run."
    },
    "wait_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 0,
      "description": "How long to wait for the script to finish before returning. Defaults to, and is capped at, 300 s when your client accepts a streamed reply (text/event-stream), 90 s otherwise. The script keeps going when the wait ends first."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 255,
      "description": "Always pass one, unique to this request. Retrying with the same key within an hour returns the run the first call started instead of doing the job twice."
    },
    "timeout_seconds": {
      "type": "integer",
      "maximum": 600,
      "minimum": 1,
      "description": "How long the script may run (default 300)."
    }
  }
}
run_script output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "status",
    "calls",
    "timeout_seconds",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "calls": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "role"
        ],
        "properties": {
          "role": {
            "type": "string"
          },
          "status": {
            "type": "integer"
          },
          "read_only": {
            "type": "boolean"
          },
          "error_code": {
            "type": "string"
          },
          "approval_id": {
            "type": "string",
            "description": "Set on a 202: the approval this call is waiting for."
          }
        }
      },
      "description": "Every tool call the script made, in order."
    },
    "error": {
      "type": [
        "string",
        "null"
      ]
    },
    "object": {
      "type": "string",
      "const": "script_run"
    },
    "output": {
      "type": [
        "string",
        "null"
      ],
      "description": "What the script printed: its start and end when long, with the cut marked."
    },
    "result": {
      "description": "The script's last expression, as JSON."
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "queued",
        "in_progress",
        "completed",
        "failed",
        "cancelled",
        "timed_out"
      ],
      "type": "string"
    },
    "approvals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "status",
          "kind",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "error": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "object": {
            "type": "string",
            "const": "approval"
          },
          "reason": {
            "type": [
              "string",
              "null"
            ],
            "description": "Why it was denied, or that it expired."
          },
          "result": {
            "description": "What the approved call returned."
          },
          "status": {
            "enum": [
              "draft",
              "pending_approval",
              "approved",
              "executed",
              "failed",
              "denied"
            ],
            "type": "string"
          },
          "chat_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "app_slug": {
            "type": [
              "string",
              "null"
            ]
          },
          "tool_name": {
            "type": [
              "string",
              "null"
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "action_type": {
            "type": [
              "string",
              "null"
            ]
          },
          "approval_id": {
            "type": "string"
          },
          "resolved_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          }
        },
        "description": "A gated action, frozen as it was called, and where it stands. Approving runs it once: then `result` or `error` holds the outcome."
      },
      "description": "What the script's gated calls froze, as each stands now."
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      },
      "description": "Files the script wrote to outputDir."
    },
    "next_step": {
      "type": "string"
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "timeout_seconds": {
      "type": "integer"
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Approvals still waiting for a decision: answer them with resolve_approvals."
    }
  },
  "description": "One script run on the account's computer."
}
run_script annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
wait_for_script_run
Advertised by the server during the last successful anonymous check.
Advertised read-only

Wait for a script run to finish and return its result. If it is still running when the wait ends, the reply has wait_timed_out: true — call again. A finished run whose calls wait for approval asks for them here when this client can show a form.

wait_for_script_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A script run id (srun_...)."
    },
    "wait_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 0,
      "description": "How long to wait for the script to finish before returning. Defaults to, and is capped at, 300 s when your client accepts a streamed reply (text/event-stream), 90 s otherwise. The script keeps going when the wait ends first."
    }
  }
}
wait_for_script_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "status",
    "calls",
    "timeout_seconds",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "calls": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "role"
        ],
        "properties": {
          "role": {
            "type": "string"
          },
          "status": {
            "type": "integer"
          },
          "read_only": {
            "type": "boolean"
          },
          "error_code": {
            "type": "string"
          },
          "approval_id": {
            "type": "string",
            "description": "Set on a 202: the approval this call is waiting for."
          }
        }
      },
      "description": "Every tool call the script made, in order."
    },
    "error": {
      "type": [
        "string",
        "null"
      ]
    },
    "object": {
      "type": "string",
      "const": "script_run"
    },
    "output": {
      "type": [
        "string",
        "null"
      ],
      "description": "What the script printed: its start and end when long, with the cut marked."
    },
    "result": {
      "description": "The script's last expression, as JSON."
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "queued",
        "in_progress",
        "completed",
        "failed",
        "cancelled",
        "timed_out"
      ],
      "type": "string"
    },
    "approvals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "status",
          "kind",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "error": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "object": {
            "type": "string",
            "const": "approval"
          },
          "reason": {
            "type": [
              "string",
              "null"
            ],
            "description": "Why it was denied, or that it expired."
          },
          "result": {
            "description": "What the approved call returned."
          },
          "status": {
            "enum": [
              "draft",
              "pending_approval",
              "approved",
              "executed",
              "failed",
              "denied"
            ],
            "type": "string"
          },
          "chat_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "app_slug": {
            "type": [
              "string",
              "null"
            ]
          },
          "tool_name": {
            "type": [
              "string",
              "null"
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "action_type": {
            "type": [
              "string",
              "null"
            ]
          },
          "approval_id": {
            "type": "string"
          },
          "resolved_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          }
        },
        "description": "A gated action, frozen as it was called, and where it stands. Approving runs it once: then `result` or `error` holds the outcome."
      },
      "description": "What the script's gated calls froze, as each stands now."
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      },
      "description": "Files the script wrote to outputDir."
    },
    "next_step": {
      "type": "string"
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "timeout_seconds": {
      "type": "integer"
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Approvals still waiting for a decision: answer them with resolve_approvals."
    }
  },
  "description": "One script run on the account's computer."
}
wait_for_script_run annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_script_run
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a script run's status, and its result once it has finished.

get_script_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A script run id (srun_...)."
    }
  }
}
get_script_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "status",
    "calls",
    "timeout_seconds",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "calls": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "role"
        ],
        "properties": {
          "role": {
            "type": "string"
          },
          "status": {
            "type": "integer"
          },
          "read_only": {
            "type": "boolean"
          },
          "error_code": {
            "type": "string"
          },
          "approval_id": {
            "type": "string",
            "description": "Set on a 202: the approval this call is waiting for."
          }
        }
      },
      "description": "Every tool call the script made, in order."
    },
    "error": {
      "type": [
        "string",
        "null"
      ]
    },
    "object": {
      "type": "string",
      "const": "script_run"
    },
    "output": {
      "type": [
        "string",
        "null"
      ],
      "description": "What the script printed: its start and end when long, with the cut marked."
    },
    "result": {
      "description": "The script's last expression, as JSON."
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "queued",
        "in_progress",
        "completed",
        "failed",
        "cancelled",
        "timed_out"
      ],
      "type": "string"
    },
    "approvals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "status",
          "kind",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "error": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "object": {
            "type": "string",
            "const": "approval"
          },
          "reason": {
            "type": [
              "string",
              "null"
            ],
            "description": "Why it was denied, or that it expired."
          },
          "result": {
            "description": "What the approved call returned."
          },
          "status": {
            "enum": [
              "draft",
              "pending_approval",
              "approved",
              "executed",
              "failed",
              "denied"
            ],
            "type": "string"
          },
          "chat_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "app_slug": {
            "type": [
              "string",
              "null"
            ]
          },
          "tool_name": {
            "type": [
              "string",
              "null"
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "action_type": {
            "type": [
              "string",
              "null"
            ]
          },
          "approval_id": {
            "type": "string"
          },
          "resolved_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          }
        },
        "description": "A gated action, frozen as it was called, and where it stands. Approving runs it once: then `result` or `error` holds the outcome."
      },
      "description": "What the script's gated calls froze, as each stands now."
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      },
      "description": "Files the script wrote to outputDir."
    },
    "next_step": {
      "type": "string"
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "timeout_seconds": {
      "type": "integer"
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Approvals still waiting for a decision: answer them with resolve_approvals."
    }
  },
  "description": "One script run on the account's computer."
}
get_script_run annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
cancel_script_run
Advertised by the server during the last successful anonymous check.
Advertised destructive

Cancel a script run that has not started yet. A running script runs to its end or its timeout.

cancel_script_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A script run id (srun_...)."
    }
  }
}
cancel_script_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "status",
    "calls",
    "timeout_seconds",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "calls": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "role"
        ],
        "properties": {
          "role": {
            "type": "string"
          },
          "status": {
            "type": "integer"
          },
          "read_only": {
            "type": "boolean"
          },
          "error_code": {
            "type": "string"
          },
          "approval_id": {
            "type": "string",
            "description": "Set on a 202: the approval this call is waiting for."
          }
        }
      },
      "description": "Every tool call the script made, in order."
    },
    "error": {
      "type": [
        "string",
        "null"
      ]
    },
    "object": {
      "type": "string",
      "const": "script_run"
    },
    "output": {
      "type": [
        "string",
        "null"
      ],
      "description": "What the script printed: its start and end when long, with the cut marked."
    },
    "result": {
      "description": "The script's last expression, as JSON."
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "queued",
        "in_progress",
        "completed",
        "failed",
        "cancelled",
        "timed_out"
      ],
      "type": "string"
    },
    "approvals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "status",
          "kind",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "error": {
            "type": [
              "string",
              "null"
            ]
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "object": {
            "type": "string",
            "const": "approval"
          },
          "reason": {
            "type": [
              "string",
              "null"
            ],
            "description": "Why it was denied, or that it expired."
          },
          "result": {
            "description": "What the approved call returned."
          },
          "status": {
            "enum": [
              "draft",
              "pending_approval",
              "approved",
              "executed",
              "failed",
              "denied"
            ],
            "type": "string"
          },
          "chat_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "app_slug": {
            "type": [
              "string",
              "null"
            ]
          },
          "tool_name": {
            "type": [
              "string",
              "null"
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "action_type": {
            "type": [
              "string",
              "null"
            ]
          },
          "approval_id": {
            "type": "string"
          },
          "resolved_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          }
        },
        "description": "A gated action, frozen as it was called, and where it stands. Approving runs it once: then `result` or `error` holds the outcome."
      },
      "description": "What the script's gated calls froze, as each stands now."
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      },
      "description": "Files the script wrote to outputDir."
    },
    "next_step": {
      "type": "string"
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "timeout_seconds": {
      "type": "integer"
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Approvals still waiting for a decision: answer them with resolve_approvals."
    }
  },
  "description": "One script run on the account's computer."
}
cancel_script_run annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
ask_crevio
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Delegate a job to the Crevio agent and wait for the result. The agent works your account through the Crevio API and every connected integration (products, customers, orders, email, socials, sites, research) and replies in `result`. Each job is a full agent run that takes from half a minute to several minutes, so use it for work that needs judgement or writing. If the run is still going when the wait ends, the reply has wait_timed_out: true — then call wait_for_run with its id and never call ask_crevio again, which would do the job twice. Run ids do not expire, and only the user who started a run can read it.

ask_crevio input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "message"
  ],
  "properties": {
    "speed": {
      "enum": [
        "faster",
        "smarter"
      ],
      "type": "string",
      "description": "faster thinks less, for simple jobs where latency matters more than depth; smarter (default) thinks it through."
    },
    "message": {
      "type": "string",
      "maxLength": 10000,
      "description": "What you want done, in natural language, with all the context needed — the agent does not see your conversation."
    },
    "approval_mode": {
      "enum": [
        "autonomous",
        "supervised",
        "read_only"
      ],
      "type": "string",
      "description": "autonomous (default) acts without review; supervised pauses in needs_input for your approval before each gated write (pending_approval_ids) and otherwise finishes with its proposal; read_only forbids writes."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 255,
      "description": "Always pass one, unique to this request. Retrying with the same key within an hour returns the run the first call started instead of doing the job twice."
    },
    "response_format": {
      "type": "object",
      "description": "Ask for a JSON reply instead of prose: a JSON Schema, or OpenAI's {type: \"json_schema\", json_schema: {schema}}. The settled run then carries the parsed value in `json`, validated against the schema, or why it failed in `json_error`."
    },
    "timeout_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 0,
      "description": "How long to wait for the run to finish before returning. Defaults to, and is capped at, 300 s when your client accepts a streamed reply (text/event-stream), 90 s otherwise. The run keeps going when the wait ends first."
    }
  }
}
ask_crevio output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
ask_crevio annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
start_chat
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Open a chat with the Crevio agent and queue a run, without waiting. Returns the run immediately. Its `chat_id` is the conversation to continue with send_message, but it stays null until the run starts; send_message takes the run id in its place. Follow the run with wait_for_run or get_run.

start_chat input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "message"
  ],
  "properties": {
    "speed": {
      "enum": [
        "faster",
        "smarter"
      ],
      "type": "string",
      "description": "faster thinks less, for simple jobs where latency matters more than depth; smarter (default) thinks it through."
    },
    "message": {
      "type": "string",
      "maxLength": 10000,
      "description": "What you want done, in natural language, with all the context needed — the agent does not see your conversation."
    },
    "approval_mode": {
      "enum": [
        "autonomous",
        "supervised",
        "read_only"
      ],
      "type": "string",
      "description": "autonomous (default) acts without review; supervised pauses in needs_input for your approval before each gated write (pending_approval_ids) and otherwise finishes with its proposal; read_only forbids writes."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 255,
      "description": "Always pass one, unique to this request. Retrying with the same key within an hour returns the run the first call started instead of doing the job twice."
    },
    "response_format": {
      "type": "object",
      "description": "Ask for a JSON reply instead of prose: a JSON Schema, or OpenAI's {type: \"json_schema\", json_schema: {schema}}. The settled run then carries the parsed value in `json`, validated against the schema, or why it failed in `json_error`."
    }
  }
}
start_chat output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
start_chat annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
list_chats
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the account's chats, newest first.

list_chats input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Default 20."
    },
    "search": {
      "type": "string",
      "description": "Only chats whose title matches."
    },
    "ending_before": {
      "type": "string",
      "description": "Return the page before this id — the first id from the previous page."
    },
    "starting_after": {
      "type": "string",
      "description": "Return the page after this id — the last id from the previous page."
    }
  }
}
list_chats output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "has_more"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "object": {
            "type": "string",
            "const": "chat"
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time"
          },
          "context_type": {
            "enum": [
              "general",
              "ai_builder",
              "customer_support",
              "onboarding",
              null
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "latest_run_id": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A chat — one conversation with the agent, across however many runs it took."
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "has_more": {
      "type": "boolean"
    }
  },
  "description": "A page of chats, newest first."
}
list_chats annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_chat
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get a chat's title, kind, and latest run.

get_chat input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "chat_id"
  ],
  "properties": {
    "chat_id": {
      "type": "string",
      "description": "A chat id (aichat_...). A run id works too — it resolves to that run's chat."
    }
  }
}
get_chat output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "title": {
      "type": [
        "string",
        "null"
      ]
    },
    "object": {
      "type": "string",
      "const": "chat"
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "updated_at": {
      "type": "string",
      "format": "date-time"
    },
    "context_type": {
      "enum": [
        "general",
        "ai_builder",
        "customer_support",
        "onboarding",
        null
      ],
      "type": [
        "string",
        "null"
      ]
    },
    "latest_run_id": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "description": "A chat — one conversation with the agent, across however many runs it took."
}
get_chat annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
send_message
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Continue a chat with follow-up instructions or answers — the agent keeps its context. Resumes a run waiting in needs_input, or queues a new run when the last one finished. Returns run_busy while a run is still in progress. Optionally waits for the reply.

send_message input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "chat_id",
    "message"
  ],
  "properties": {
    "chat_id": {
      "type": "string",
      "description": "A chat id (aichat_...). A run id works too — it resolves to that run's chat."
    },
    "message": {
      "type": "string",
      "maxLength": 10000,
      "description": "The follow-up to send into the conversation."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 255,
      "description": "Always pass one, unique to this message. Retrying with the same key returns the run the first call started instead of sending the message twice."
    },
    "response_format": {
      "type": "object",
      "description": "Ask for a JSON reply instead of prose: a JSON Schema, or OpenAI's {type: \"json_schema\", json_schema: {schema}}. The settled run then carries the parsed value in `json`, validated against the schema, or why it failed in `json_error`."
    },
    "timeout_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 0,
      "description": "Seconds to wait for the reply before returning (default 0: return the new run immediately). Capped like ask_crevio's wait."
    }
  }
}
send_message output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
send_message annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
list_messages
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a chat's messages, oldest first. Returns the most recent `limit` messages; page back through older ones with ending_before.

list_messages input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "chat_id"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 200,
      "minimum": 1,
      "description": "Default 50."
    },
    "chat_id": {
      "type": "string",
      "description": "A chat id (aichat_...). A run id works too — it resolves to that run's chat."
    },
    "ending_before": {
      "type": "string",
      "description": "Return the messages older than this id — the first id of the previous page. Paging walks backwards through history, since the default page is the tail."
    }
  }
}
list_messages output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "has_more"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "role",
          "content",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "role": {
            "enum": [
              "user",
              "assistant"
            ],
            "type": "string"
          },
          "content": {
            "type": "string"
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          }
        },
        "description": "One message in a run's conversation."
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "has_more": {
      "type": "boolean"
    }
  },
  "description": "A page of conversation messages, oldest first."
}
list_messages annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
wait_for_run
Advertised by the server during the last successful anonymous check.
Advertised read-only

Wait for a run to settle (completed, failed, cancelled, or needs_input) and return it with the agent's final reply. If it is still running when the wait ends, the reply has wait_timed_out: true — call wait_for_run again.

wait_for_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A run id (trun_...)."
    },
    "timeout_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 0,
      "description": "How long to wait for the run to finish before returning. Defaults to, and is capped at, 300 s when your client accepts a streamed reply (text/event-stream), 90 s otherwise. The run keeps going when the wait ends first."
    }
  }
}
wait_for_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
wait_for_run annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_run
Advertised by the server during the last successful anonymous check.
Advertised read-only

Fetch a run's current status, summary, pending approvals, and (once settled) the agent's final reply.

get_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A run id (trun_...)."
    }
  }
}
get_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
get_run annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
list_runs
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the account's task runs, newest first — delegated jobs and scheduled tasks alike. Filter by status, task, or chat.

list_runs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Default 20."
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string",
      "description": "Only runs in this state."
    },
    "chat_id": {
      "type": "string",
      "description": "Only the runs of this chat (aichat_...): its first run and every send_message after it. A run id works too."
    },
    "task_id": {
      "type": "string",
      "description": "Only runs of this task (task_...)."
    },
    "ending_before": {
      "type": "string",
      "description": "Return the page before this id — the first id from the previous page."
    },
    "starting_after": {
      "type": "string",
      "description": "Return the page after this id — the last id from the previous page."
    }
  }
}
list_runs output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "has_more"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "task_id",
          "status",
          "created_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "json": {
            "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
          },
          "object": {
            "type": "string",
            "const": "task_run"
          },
          "result": {
            "type": [
              "string",
              "null"
            ]
          },
          "reused": {
            "type": "boolean"
          },
          "status": {
            "enum": [
              "pending",
              "running",
              "completed",
              "failed",
              "needs_input",
              "timed_out",
              "unknown",
              "skipped",
              "cancelled"
            ],
            "type": "string"
          },
          "chat_id": {
            "type": [
              "string",
              "null"
            ]
          },
          "summary": {
            "type": [
              "string",
              "null"
            ]
          },
          "task_id": {
            "type": "string"
          },
          "artifacts": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "object",
                "id",
                "filename",
                "size"
              ],
              "properties": {
                "id": {
                  "type": "string"
                },
                "size": {
                  "type": "integer"
                },
                "object": {
                  "type": "string",
                  "const": "artifact"
                },
                "filename": {
                  "type": "string"
                },
                "content_type": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              },
              "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
            }
          },
          "next_step": {
            "type": "string"
          },
          "task_name": {
            "type": [
              "string",
              "null"
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time"
          },
          "json_error": {
            "type": [
              "string",
              "null"
            ],
            "description": "Why the reply did not parse or validate against response_format."
          },
          "started_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "completed_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time"
          },
          "error_message": {
            "type": [
              "string",
              "null"
            ]
          },
          "wait_timed_out": {
            "type": "boolean",
            "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
          },
          "credits_consumed": {
            "type": "integer"
          },
          "cancel_requested_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time",
            "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
          },
          "pending_approval_ids": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "description": "A task run — one delegated job and what is known about its state."
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "has_more": {
      "type": "boolean"
    }
  },
  "description": "A page of task runs, newest first."
}
list_runs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
resolve_approvals
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Approve or deny actions waiting for a decision. With run_id: a run in needs_input; decide every one of its pending_approval_ids at once and it resumes in the background. Without run_id: approvals a script run or the API raised; each approved one runs its frozen call now and the reply carries its outcome. An approval nobody answers is denied after 7 days.

resolve_approvals input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "approvals"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "The paused run (trun_...). Omit it for approvals a script run or the API raised."
    },
    "approvals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "approved"
        ],
        "properties": {
          "id": {
            "type": "string",
            "description": "A pending approval id (apr_...)."
          },
          "reason": {
            "type": "string",
            "description": "Why it was denied (optional)."
          },
          "approved": {
            "type": "boolean",
            "description": "True to let the action run, false to deny it."
          }
        }
      },
      "minItems": 1,
      "description": "One decision per approval id. A run stays paused until every one of its pending ids is answered."
    }
  }
}
resolve_approvals output schema
{
  "type": "object",
  "anyOf": [
    {
      "type": "object",
      "required": [
        "object",
        "id",
        "task_id",
        "status",
        "created_at"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "json": {
          "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
        },
        "object": {
          "type": "string",
          "const": "task_run"
        },
        "result": {
          "type": [
            "string",
            "null"
          ]
        },
        "reused": {
          "type": "boolean"
        },
        "status": {
          "enum": [
            "pending",
            "running",
            "completed",
            "failed",
            "needs_input",
            "timed_out",
            "unknown",
            "skipped",
            "cancelled"
          ],
          "type": "string"
        },
        "chat_id": {
          "type": [
            "string",
            "null"
          ]
        },
        "summary": {
          "type": [
            "string",
            "null"
          ]
        },
        "task_id": {
          "type": "string"
        },
        "artifacts": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "object",
              "id",
              "filename",
              "size"
            ],
            "properties": {
              "id": {
                "type": "string"
              },
              "size": {
                "type": "integer"
              },
              "object": {
                "type": "string",
                "const": "artifact"
              },
              "filename": {
                "type": "string"
              },
              "content_type": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
          }
        },
        "next_step": {
          "type": "string"
        },
        "task_name": {
          "type": [
            "string",
            "null"
          ]
        },
        "created_at": {
          "type": "string",
          "format": "date-time"
        },
        "json_error": {
          "type": [
            "string",
            "null"
          ],
          "description": "Why the reply did not parse or validate against response_format."
        },
        "started_at": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "completed_at": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "error_message": {
          "type": [
            "string",
            "null"
          ]
        },
        "wait_timed_out": {
          "type": "boolean",
          "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
        },
        "credits_consumed": {
          "type": "integer"
        },
        "cancel_requested_at": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time",
          "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
        },
        "pending_approval_ids": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "description": "A task run — one delegated job and what is known about its state."
    },
    {
      "type": "object",
      "required": [
        "object",
        "data",
        "has_more"
      ],
      "properties": {
        "data": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "object",
              "id",
              "status",
              "kind",
              "created_at"
            ],
            "properties": {
              "id": {
                "type": "string"
              },
              "kind": {
                "type": "string"
              },
              "error": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "title": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "object": {
                "type": "string",
                "const": "approval"
              },
              "reason": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "Why it was denied, or that it expired."
              },
              "result": {
                "description": "What the approved call returned."
              },
              "status": {
                "enum": [
                  "draft",
                  "pending_approval",
                  "approved",
                  "executed",
                  "failed",
                  "denied"
                ],
                "type": "string"
              },
              "chat_id": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "app_slug": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "tool_name": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "created_at": {
                "type": "string",
                "format": "date-time"
              },
              "action_type": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "approval_id": {
                "type": "string"
              },
              "resolved_at": {
                "type": [
                  "string",
                  "null"
                ],
                "format": "date-time"
              }
            },
            "description": "A gated action, frozen as it was called, and where it stands. Approving runs it once: then `result` or `error` holds the outcome."
          }
        },
        "object": {
          "type": "string",
          "const": "list"
        },
        "has_more": {
          "type": "boolean"
        }
      },
      "description": "The approvals answered, as each stands now."
    }
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
resolve_approvals annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
cancel_run
Advertised by the server during the last successful anonymous check.
Advertised destructive

Stop a run that is pending, running, or waiting for input, and its media generations still in flight. A run mid-step finishes that step first: it returns with cancel_requested_at set and settles as cancelled moments later (wait_for_run to confirm). Repeating it while the run stops is harmless; once it has settled, cancelled included, it returns run_not_active.

cancel_run input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "run_id"
  ],
  "properties": {
    "run_id": {
      "type": "string",
      "description": "A run id (trun_...)."
    }
  }
}
cancel_run output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "id",
    "task_id",
    "status",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "json": {
      "description": "The reply parsed as JSON and validated against response_format. Present only when one was given."
    },
    "object": {
      "type": "string",
      "const": "task_run"
    },
    "result": {
      "type": [
        "string",
        "null"
      ]
    },
    "reused": {
      "type": "boolean"
    },
    "status": {
      "enum": [
        "pending",
        "running",
        "completed",
        "failed",
        "needs_input",
        "timed_out",
        "unknown",
        "skipped",
        "cancelled"
      ],
      "type": "string"
    },
    "chat_id": {
      "type": [
        "string",
        "null"
      ]
    },
    "summary": {
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "type": "string"
    },
    "artifacts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "object",
          "id",
          "filename",
          "size"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "size": {
            "type": "integer"
          },
          "object": {
            "type": "string",
            "const": "artifact"
          },
          "filename": {
            "type": "string"
          },
          "content_type": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "description": "A file the work produced. Exchange its id for a download link with get_file_download_url."
      }
    },
    "next_step": {
      "type": "string"
    },
    "task_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "json_error": {
      "type": [
        "string",
        "null"
      ],
      "description": "Why the reply did not parse or validate against response_format."
    },
    "started_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completed_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "error_message": {
      "type": [
        "string",
        "null"
      ]
    },
    "wait_timed_out": {
      "type": "boolean",
      "description": "The wait ended first. The work is still running: follow it with the tool next_step names."
    },
    "credits_consumed": {
      "type": "integer"
    },
    "cancel_requested_at": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time",
      "description": "Set once a stop was requested; the run stays running until it reaches its next step, then settles as cancelled."
    },
    "pending_approval_ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "A task run — one delegated job and what is known about its state."
}
cancel_run annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
get_file_download_url
Advertised by the server during the last successful anonymous check.
Advertised read-only

Exchange an artifact id (art_...) from a run's or script run's `artifacts` for a download link. The link needs no credentials and expires after 15 minutes; ask again for a fresh one.

get_file_download_url input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "file_id"
  ],
  "properties": {
    "file_id": {
      "type": "string",
      "description": "An artifact id (art_...)."
    }
  }
}
get_file_download_url output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "file_id",
    "filename",
    "url",
    "expires_at"
  ],
  "properties": {
    "url": {
      "type": "string"
    },
    "object": {
      "type": "string",
      "const": "file_download_url"
    },
    "file_id": {
      "type": "string"
    },
    "filename": {
      "type": "string"
    },
    "expires_at": {
      "type": "string",
      "format": "date-time"
    }
  }
}
get_file_download_url annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
list_audit_events
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the account's audit events, newest first: access and configuration changes, approvals, API key use, and (at the full capture level) the agent's tool calls.

list_audit_events input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "after": {
      "type": "string",
      "description": "ISO-8601 time; only events at or after it."
    },
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Default 50."
    },
    "action": {
      "type": "string",
      "description": "Only this action, e.g. connection.execute or approval.approve."
    },
    "entity_id": {
      "type": "string"
    },
    "actor_type": {
      "enum": [
        "agent",
        "user",
        "api",
        "system"
      ],
      "type": "string"
    },
    "entity_type": {
      "type": "string",
      "description": "Only events about this kind of record, e.g. integration_approval."
    },
    "ending_before": {
      "type": "string",
      "description": "Return the page before this id — the first id from the previous page."
    },
    "starting_after": {
      "type": "string",
      "description": "Return the page after this id — the last id from the previous page."
    }
  }
}
list_audit_events output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "object",
    "data",
    "has_more"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "object": {
      "type": "string",
      "const": "list"
    },
    "has_more": {
      "type": "boolean"
    }
  },
  "description": "A page of audit events, newest first."
}
list_audit_events annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Sign-in required

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (3 of 3 answered).

  1. 2026-11-06: 1 of 1 checks answered
  2. 2026-11-07: 2 of 2 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
751 ms
95th percentile latency
751 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 751 ms · metadata changed · refuses unauthenticated resources/list (HTTP 401)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http crevio-mcp https://mcp.crevio.co/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add crevio-mcp --url https://mcp.crevio.co/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable crevio-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "crevio-mcp": {
      "url": "https://mcp.crevio.co/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "crevio-mcp": {
      "type": "streamableHttp",
      "url": "https://mcp.crevio.co/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start crevio-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "crevio-mcp": {
      "type": "http",
      "url": "https://mcp.crevio.co/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http crevio-mcp https://mcp.crevio.co/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://mcp.crevio.co/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "crevio-mcp": {
      "serverUrl": "https://mcp.crevio.co/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Crevio MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Do you run Crevio MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing