call_context_source_operation
ChatGPTCall one read-only operation on an agent context source. Get source_index, operation names, and parameter schemas from list_agent_context_sources first. Custom API connections expose their configured GET endpoints as operations; results are JSON capped at 200KB with a truncated flag.
cancel_agent_job
ChatGPTCancel one pending/running async agent job. DESTRUCTIVE. On success returns {job_id, status: "cancelled"}. Follow with get_agent_job_status; settled jobs should reach 5 CANCELLED. Already-terminal jobs may return a structured error.
cancel_all_agent_jobs
ChatGPTRequest cancellation of EVERY in-flight async job for one agent. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. Targets all pending/running jobs scheduled against the agent — for selective cancellation, call cancel_agent_job per job_id instead. ASYNCHRONOUS: the Roe API only enqueues the revocation, so NOTHING is cancelled yet when this tool returns. Returns {agent_id, task_id, targeted_count, note}; targeted_count is how many non-terminal jobs were targeted, and targeted_count: 0 with task_id: null means the agent had nothing running (no work was queued). The cancelled job_ids are not enumerated — poll get_agent_jobs_status_batch to confirm individual jobs settled to 5 CANCELLED.
cancel_skill_set_generation
ChatGPTCancel the specified skill-set generation if still running and stop tracking that run. Does not delete a version already committed. Use the run_id returned by generate_skill_set_version or get_skill_set_generation.
create_agent
ChatGPTCreate a new Roe agent. The first version is created implicitly from engine_class_id + engine_config + input_definitions. Use create_agent_version to add subsequent versions. Returns the full agent object (id, name, current_version, etc.). Navigation for config/model discovery: call list_agent_engine_types to find valid production engine_class_id values plus the engine-specific config schema/hints. Call list_supported_models to see the available model ids before setting engine_config.model. For complete working examples, call list_agents then get_current_agent_version on an agent with the engine class you want and template from its engine_config and input_definitions. Models and config can be found with those discovery tools, then made here by passing engine_class_id, engine_config, and input_definitions. Multi-step workflows: to chain agents into a pipeline (engine_class_id WorkflowOrchestrator — loops, if-branches, merges), call get_help with topic workflows FIRST; the engine schema alone is not enough to author a correct workflow config. Cold-start tip: each engine's schema/hints from list_agent_engine_types determine which keys engine_config needs. Start from that response or template from get_current_agent_version; do not invent engine_class_id, config keys, or model ids from memory.
create_agent_version
ChatGPTCreate a new version of an existing agent — the version becomes the agent's current_version and serves all subsequent runs. Use to iterate on engine_config or input_definitions while keeping agent history. Returns the new version object. Engine class is INHERITED from the parent agent — do NOT pass engine_class_id. Versions can swap engine_config and input_definitions only; to change the engine class itself, create a new agent with create_agent. Navigation for config/model discovery: call get_current_agent_version to inspect the current engine_config and input_definitions you are changing. Call list_agent_engine_types to find config-shape hints for the parent engine class. Call list_supported_models to see valid model ids before changing engine_config.model. Models and config can be found with those tools, then made here by passing new engine_config and/or input_definitions. For WorkflowOrchestrator agents, call get_help with topic workflows first for the authoring contract (node shapes, input_mapping syntax, loop/if/merge configs).
create_policy
ChatGPTCreate a new Roe policy with an initial version. A policy is the rulebook a policy-driven agent reasons against — every investigation engine (AMLInvestigationEngine, KYCInvestigationEngine, FraudInvestigationEngine, MerchantRiskEngine, ProductPolicyEngine, StrategyEngine) requires one via engine_config.policy_version_id. Returns the created policy object, including current_version_id, which is the id to put in engine_config. content is NOT free-form. It must match the structured schema below. Content that omits guidelines.categories is rejected, because an agent built on it fails at run time with SOP guidelines.categories is required to build plan steps — the policy also renders as empty in the Roe UI. Minimal valid content: {"guidelines": {"categories": [{"title": "Prohibited products", "description": "What the merchant may not sell.", "rules": [{"title": "No nicotine", "description": "Reject if the site sells vapes, e-cigarettes or nicotine pouches.", "flag": "RED_FLAG"}]}]}, "dispositions": {"classifications": [{"name": "Reject", "description": "Sells a prohibited product."}, {"name": "Approve", "description": "Nothing prohibited found."}]}, "instructions": "Review the merchant website against the categories below."} Field reference: - guidelines.categories[] (REQUIRED, at least one): {title (required, non-empty), description, rules[]}. Group related rules under one category. - categories[].rules[]: {title (required, non-empty), description, flag, sub_rules[]}. flag is RED_FLAG or GREEN_FLAG or omitted. Put the actual decision logic in description. - rules[].sub_rules[]: {title (required), description}. Optional; only for genuinely nested conditions. - dispositions.classifications[]: {name (required, non-empty), description, prompt}. These are the allowed verdicts the agent may return — define them whenever the agent must reach a decision, and name them exactly as the customer says them. - instructions: free text prepended to the agent's reasoning. Scope and tone, not rules. - summary_template.template: optional handlebars-style report template. - Do NOT invent top-level keys. A flat dict of your own keys (for example {"verdicts": [...], "prohibited_items": [...]}) is the legacy shape, is not readable by the Roe UI, and will fail at run time. - Omit id and content_uuid everywhere; the backend assigns them. Copy the shape from a working policy with list_policies then get_policy_version before authoring one from scratch. Iterate with create_policy_version.
create_policy_version
ChatGPTCreate a new version of an existing policy — the version becomes the policy's current_version and serves all subsequent lookups. Use to iterate on policy content while preserving history. Returns the new version object (server re-fetches the full record after POST). To fork from a non-current version, set base_version_id to a version from list_policy_versions, get_policy_version, or create_policy_version. Default is the current version. content follows the same structured schema as create_policy — see that tool's description for the full field reference. It requires guidelines.categories[] with at least one category; content that omits it is rejected, because agents built on it fail at run time with SOP guidelines.categories is required to build plan steps. Editing an existing policy: read the current content with get_policy_version, change the categories, rules or dispositions you need, and send the WHOLE document back. This is a replace, not a merge — anything you leave out is gone from the new version. Agents do not follow the change on their own: an agent pins engine_config.policy_version_id, so after creating a version you must also call create_agent_version with the new id for the change to take effect.
create_skill_set
ChatGPTCreate an organization skill set, seeded with the built-in base skill as version 0. Use create_skill_set_version to customize its complete Markdown file collection.
create_skill_set_version
ChatGPTCreate an immutable version from the COMPLETE file collection and make it current. A root SKILL.md is required; paths must be unique and relative. Agents following this set pick up the new current version.
delete_agent
ChatGPTPermanently delete an agent and all its versions. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. The agent and its run history are removed; in-flight async jobs may continue but their results become unrecoverable. Returns {agent_id, deleted: true} on success.
delete_agent_version
ChatGPTDelete one version of an agent. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. Deleting the agent's CURRENT version is allowed and does NOT fail: the backend silently promotes the next-newest remaining version to current, so the agent immediately starts serving a different config — re-check get_current_agent_version afterwards. The one refusal is the agent's ONLY version (400); delete the whole agent with delete_agent instead. This is NOT a rollback tool — to go back to an older config, re-submit that config with create_agent_version. Returns {agent_id, version_id, deleted: true} on success.
delete_connection
ChatGPTPermanently delete one saved connection and its stored credentials. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. Use list_connections first to confirm the id and name. Returns {connection_id, deleted: true} on success.
delete_policy
ChatGPTPermanently delete a policy and all its versions. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. The policy and its version history are removed; any agent currently referencing this policy will see its lookups start failing. Returns {policy_id, deleted: true} on success.
delete_skill_set
ChatGPTPermanently delete a skill set and all its versions after explicit user confirmation. Returns a conflict when agents still reference the set; update those agents first.
delete_table
ChatGPTPermanently delete one Roe table in the caller's organization. DESTRUCTIVE. Requires confirm=true after explicit user confirmation. Drops the underlying table and removes table-link metadata such as project table links and dataset table sync rows.
describe_table
ChatGPTDescribe one Roe table in the caller's organization without reading rows. Returns column metadata, the total row count when ClickHouse can determine it cheaply, and the latest metadata-modification timestamp (updated_at) when available. Use after list_tables to inspect a table's schema and size before previewing or querying it.
download_job_reference
ChatGPTDownload a resource referenced by an async job's output (e.g. a small text/JSON artifact emitted by the agent). Returns {job_id, resource_id, byte_count, encoding: "base64", content_base64}. Use this ONLY for small text-like references (≤~190 KiB raw, ~256 KiB base64). For large binaries — PDFs, images, audio, video — do NOT use this tool: the base64 inflation will trip the MCP response size cap and return a truncation envelope instead. Prefer reading the trace_url field from get_agent_job_result and showing the user a link they can open in a browser. Set as_attachment=true if you want the backend to include a Content-Disposition: attachment hint (does not affect the bytes returned — useful only if a downstream tool consumes the disposition).
duplicate_agent
ChatGPTClone an existing agent — copies its config and current version into a new agent owned by the caller's org. Useful for forking a template agent before modifying it. Returns the new duplicated agent object; the top-level id is the id to use with get_agent, run_agent, update_agent, and delete_agent.
generate_skill_set_version
ChatGPTStart asynchronous skill generation from a use case and organization tables or uploaded files, with an optional policy. At least one table name or attachment is required; a use case or policy alone is not a data source. Returns run_id and stream location. Poll get_skill_set_generation. By default the draft is only available for review through the Roe UI/stream; set auto_commit=true only when the user wants the generated version saved and made current automatically. After auto-commit succeeds, read the version through get_skill_set_version using the set id. This may incur model usage and create tables when importing CSV attachments.
get_agent
ChatGPTFetch one agent's full record by id. Use when you already have the agent_id (e.g. from list_agents) and need its config / current version / metadata. Returns the full agent object.
get_agent_job_artifact
ChatGPTFetch the result content of a tool-result artifact produced during an agent job. Use this to expand an artifact key found in get_agent_job_result output — e.g. an evidence_data value like MerchantRiskEngine-<job-id>/extraction_<...>.json — into the underlying extraction/analysis it points to.
get_agent_job_result
ChatGPTFetch the stored result of a terminal async agent job (3 SUCCESS, 4 FAILURE, 5 CANCELLED, or 6 CACHED). Output data is normally present for 3 SUCCESS and 6 CACHED jobs; 4 FAILURE and 5 CANCELLED jobs are terminal but may have no stored output, so this call can return an error envelope — use get_agent_job_status to read why a job failed or was cancelled. Returns {job_id, output, tokens, cost, trace_url, ended_at}; cost and token fields may be absent — treat an absent field as unavailable, never as zero.
get_agent_job_status
ChatGPTGet the status of an async agent job from trigger_agent_run or run_batch_agent_jobs. Use to poll until the job reaches a terminal state. Returns {job_id, status, progress?, started_at, ended_at?}. status is the raw integer code used by roe-main job status: 0 PENDING — queued, not yet picked up 1 STARTED — running 2 RETRY — backend is retrying after a transient failure (not terminal) 3 SUCCESS — complete, call get_agent_job_result for the output 4 FAILURE — terminal, get_agent_job_result returns the error 5 CANCELLED — terminal, was cancelled via cancel_agent_job 6 CACHED — terminal, result served from the agent's run cache Terminal set: {3, 4, 5, 6}. Stop polling on any of those.
get_agent_jobs_result_batch
ChatGPTFetch stored results for many terminal async jobs in one call (each 3 SUCCESS, 4 FAILURE, 5 CANCELLED, or 6 CACHED). Returns {results: [{job_id, output, tokens, cost, ...}, ...]} preserving input order; cost and token fields may be absent — treat an absent field as unavailable, never as zero. Output data is normally present for 3 SUCCESS and 6 CACHED jobs; 4 FAILURE and 5 CANCELLED jobs may have no stored output, so those entries can come back as error envelopes — read get_agent_jobs_status_batch for why. Each result may contain the full agent output. Keep len(job_ids) ≤ 25 per call so the combined payload remains within the MCP response limit. Truncation returns a {truncated: true, ...} envelope.
get_agent_jobs_status_batch
ChatGPTFetch the status of many async jobs in a single call. Use this when polling a batch returned by run_batch_agent_jobs. Returns {statuses: [{job_id, status, ...}, ...]} preserving input order. status values are the integer codes documented on get_agent_job_status (terminal set: {3, 4, 5, 6}). Roe processes up to 1000 ids in server-side chunks. Keep len(job_ids) ≤ 100 per call so the response remains within the MCP response limit. Responses past the limit return a {truncated: true, ...} envelope.
get_agent_version
ChatGPTFetch one specific version of an agent. Use when comparing versions or inspecting a historical config. get_supports_eval=true includes the eval-support flag. Returns the full version object.
get_connection
ChatGPTFetch one saved connection by id. Returns non-secret connection metadata, including whether credentials are configured, without returning secret values.
get_connection_setup
ChatGPTFetch one setup on a connection, including its config, selected operation ids, status and revision. A higher revision means the setup changed. Setups never hold credentials.
get_current_agent_version
ChatGPTFetch the agent's current live version. Use this when the active engine_config and input_definitions are needed before creating a new version or running the agent. Returns the version object.
get_help
ChatGPTExplain how the Roe MCP works end-to-end and how to get started, with a link to the official docs. Call this when a request is ambiguous or you are unsure which tool to use. Returns guidance plus docs_url. Pass topic to focus on one of: overview, getting-started, auth, tools, workflows, troubleshooting. Call get_help with topic workflows before building or editing a multi-step workflow (WorkflowOrchestrator) — it returns the full authoring contract plus a docs link. This is a local tool — it makes no backend call and needs no arguments.
get_policy
ChatGPTFetch one policy's full record by id. Use when you already have the policy_id (e.g. from list_policies) and need its metadata / current_version. To inspect the policy's actual rule content, fetch the version via get_policy_version or list_policy_versions. Returns the full policy object.
get_policy_version
ChatGPTFetch one specific version of a policy, including its full content. Use when comparing versions, inspecting a historical config, or templating content for a new policy. Returns the full version object.
get_skill_set
ChatGPTRead skill-set metadata and its current_version_id. To read the actual Markdown files, call get_skill_set_version with that version id.
get_skill_set_generation
ChatGPTRead the latest tracked generation status and stream location for a skill set. Returns generation=null when none is tracked. After an auto-commit run succeeds, get_skill_set_version with the set id reads the committed files; this status response does not contain an uncommitted draft.
get_skill_set_version
ChatGPTRead a skill-set version with its full Markdown file collection. Pass a version UUID to pin it, or a skill-set UUID to resolve its current version. Use the returned version id as agent engine_config.skill_set_version_id.
get_table_query_result
ChatGPTPoll or fetch a table SQL query result. Use the table_query_id returned by query_tables. If the job is still running, returns {table_query_id, status, error} with no rows. If complete, returns {table_query_id, status, columns, rows, row_count, truncated, execution_time_ms}. Rows are JSON objects keyed by column name. truncated: true means the result hit the row limit, backend result byte cap, or an individual huge cell was shortened; oversized cells may be returned as shortened strings even when the original ClickHouse value was a nested object or array.
import_csv_file
ChatGPTImport an uploaded CSV (file_<uuid>, e.g. a chat attachment) into a new Roe table. Roe reads the file server-side, up to 100 MB; no file content passes through this call. Call inspect_csv_file first and pass its options.delimiter and options.has_header. Every column is stored as text. Before proposing a table_name, or using one the person gives, check that it is free: call list_tables and make sure the name isn't in it (if that list comes back truncated, use describe_table, where not found means free). If it is taken, offer the first free variant (orders_2, orders_3, …) and say the original name is in use. An import never replaces a table, so a taken name fails with TABLE_EXISTS. Returns {status, already_imported, table_name, file_ref, file_name, options, input_rows, imported_rows, skipped_rows, skipped_line_numbers, column_count, columns, preview}, read back from the new table: - status: completed, or completed_with_skipped_rows when malformed rows were left out. Never call the second a complete import; say how many rows were skipped. - input_rows (data rows in the file) = imported_rows (counted in the table) + skipped_rows. - columns: the table's columns with the source_header each came from; for a wide table only the first ones, with column_count giving the total. Names over 200 characters are shortened with … here only; use describe_table for full names. preview: its first rows, each a list of cells in the order of preview.columns. - already_imported: true: this repeats an import that had already finished; it is the same table, not a new one. Errors, each with a code; nothing is imported unless stated: - MALFORMED_ROWS: rows with the wrong number of fields; the message gives the real count and lines. Tell the person that count and those lines, and ask whether to skip them. Only after they agree, call again with malformed_rows_to_skip set to that count. A count that differs from the file's imports nothing. - TABLE_EXISTS: the name is taken, and an existing table is never replaced. Ask the person for another name. - IMPORT_IN_PROGRESS: this import is still running. Call again with the same arguments shortly. - UNPARSEABLE (including broken quoting, which cannot be skipped), EMPTY_FILE, FILE_TOO_LARGE: the file needs fixing or splitting and uploading again. - IMPORT_FAILED: nothing was kept. Retry once with the same arguments; if it fails again, tell the person the import failed. If a reply is lost or times out, call again with exactly the same arguments: a finished import returns its table instead of creating another. Never retry under a different table name.
inspect_csv_file
ChatGPTInspect an uploaded CSV by its file_ref (file_<uuid>, e.g. a chat attachment) without loading the file into context. Roe reads the file server-side and returns a bounded summary; the full content is never returned. Use this before importing a CSV, and whenever a CSV is too large to read directly. Returns {file_ref, file_name, file_size_bytes, status, options, columns, sample, whole_file, warnings}: - status: ok, empty (no rows), or unparseable (e.g. an unclosed quote; cannot be imported as is). - options: the delimiter, has_header and encoding the file was read with, each with a *_source of detected or provided. Pass the same values to the import. - columns: proposed column names (source_header → name), an inferred_type hint, and the conversion the import applies. Import stores every column as text; cast in queries. Names over 200 characters are shortened with … here only. - sample: the first rows only. Do not state counts or distributions from it. - whole_file: facts from scanning the file (up to 100 MB): row_count when count_status is exact, otherwise null with rows_scanned; malformed_rows and their first line numbers. - warnings: {code, message} for anything the person should know before importing. If the person says the header or delimiter is wrong, call again with has_header or delimiter set; the result then reports them as provided. Describe only that new result: column names, types and counts can all change.
list_agent_context_sources
ChatGPTList current-version context sources for an agent, with each source's callable read-only operations inlined (name, description, params_schema, response_hint). Use the returned source_index plus an operation name with call_context_source_operation; indexes are not stable IDs. Sources without operations include an unsupported_reason.
list_agent_engine_types
ChatGPTList the production agent engine types that can be used as engine_class_id when calling create_agent. Use this to find available engines and engine-specific config schema before creating or versioning an agent; use list_supported_models separately to list valid model ids. Do not guess engine names from examples. Returns {engine_types, total_count, engines} where engine_types is the compact list of valid ids and engines contains the richer live workflow metadata, including input schema, default configuration hints, and categories when the backend exposes them. EXCEPTION: for WorkflowOrchestrator (multi-step workflows) the schema is NOT sufficient — utility-node configs and ordering rules are not expressed in it; call get_help with topic workflows for the authoring contract before constructing that config. Each engine's input_schema is slimmed for LLM context budgets: structural fields (type, properties, required, enum, default, items, oneOf/anyOf/allOf, additionalProperties) are preserved verbatim so a valid engine_config can be constructed from the response, while docs-only fields (examples, title, $schema, $id) are dropped and long property descriptions are truncated.
list_agent_jobs
ChatGPTBrowse the async run (job) history for ONE agent. cost and token fields may be absent from a result; treat an absent field as unavailable, never as zero. ordering=cost / -cost can be rejected with 400 when cost is unavailable, so fall back to another ordering. Use to find past runs, inspect their outcomes, or locate a job_id to pass to get_agent_job_status / get_agent_job_result. Returns {results: [...], page, page_size, total, next, previous} paginated. Defaults to first page of 20. For "failed jobs in the last 7 days", set status_code="4" and created_from to the ISO-8601 timestamp seven days ago. Stop paging when len(results) < page_size or page * page_size >= total — requesting beyond the last page returns an empty results list, not an error. Filters combine as AND across distinct parameters, with OR WITHIN a single comma-separated parameter. status_code accepts job status codes (0 PENDING, 1 STARTED, 2 RETRY, 3 SUCCESS, 4 FAILURE, 5 CANCELLED, 6 CACHED; terminal set {3,4,5,6}) — use status_code="4" for failed jobs, or status_code="4,5" for failed OR cancelled jobs. version_name accepts comma-separated version names (OR). metadata takes key:value pairs (k1:v1,k2:v2 is AND across pairs). search substring-matches the job id, display name, or serialized inputs. created_from / created_to bound created_at; pass ISO-8601 datetimes with timezone, e.g. 2024-01-01T00:00:00Z. ordering sorts (prefix - for descending); default is -created_at. limit caps the most-recent jobs considered and counted (default 100000) so total stays cheap for agents with very large histories.
list_agent_versions
ChatGPTList the full version history for one agent. Returns every version, newest first. Use to compare configurations or to find an older config to restore. Returns {results: [...], total: N} — the Roe versions endpoint does not paginate, so this returns all versions in a single response. ROLLBACK: MCP cannot promote an existing version to current. To roll back, read the old version's engine_config / input_definitions (here or via get_agent_version) and re-submit them with create_agent_version, which makes that config the new current version. Do NOT try to roll back by deleting newer versions with delete_agent_version — that destroys history, and the promotion it triggers is by newest-remaining created_at, not by your choice.
list_agents
ChatGPTList agents in the caller's Roe organization. Use this to discover agents before running one. Use get_agent when the agent id is already known. Returns {results: [...], page, page_size, total, next, previous} paginated. Defaults to the first page of 20.
list_connection_setups
ChatGPTList the setups saved on one connection. A setup is a named, reusable context-source configuration (instructions, scope, defaults and selected operation ids) that agents can use. Returns each setup's status (ready or needs_configuration) and revision; setups never hold credentials.
list_connections
ChatGPTList saved connections in the caller's Roe organization. Use this to discover connection ids before viewing, testing, or deleting a connection. Returns paginated non-secret connection metadata.
list_policies
ChatGPTList policies in the caller's Roe organization. Use to discover which policies exist before fetching one — do NOT use to fetch a single policy you already have the id for (use get_policy). Returns {results: [...], page, page_size, total, next, previous} paginated. Defaults to first page of 20. Stop paging when len(results) < page_size or page * page_size >= total — requesting beyond the last page returns an empty results list, not an error.
list_policy_versions
ChatGPTList the version history for one policy, including each version's content. Returns {results, page, page_size, total, next, previous} paginated. Defaults to first page of 20. Stop paging when len(results) < page_size or page * page_size >= total. Use to find a previous version to roll back to (via create_policy_version with base_version_id) or compare versions.
list_skill_set_versions
ChatGPTList immutable versions of a skill set, including their complete Markdown files, newest first. Use page and page_size to browse version history.
list_skill_sets
ChatGPTList skill sets in your organization, with current_version_id. Use search to find a named skill set; results are paginated.
list_supported_models
ChatGPTList non-deprecated LLM model ids that can be used in agent engine_config.model. Use this before setting or repairing a model value in create_agent or create_agent_version; do not hardcode stale model names from examples. Returns {models, total_count, tenant_scope} where each model includes the canonical id plus capability, provider, context/output token limits, and feature flags such as JSON mode, structured output, vision, audio, tools, and reasoning support when available. Optional capability filters the list to image-, audio-, or video-capable models (text-capable models are always included).
list_tables
ChatGPTList Roe tables in the caller's organization, including each table's column names and ClickHouse column types. Use this before preview_table or when discovering table names created by upload_table. Returns {results: [...], total}.
preview_table
ChatGPTPreview one Roe table in the caller's organization. Returns column metadata plus up to limit sample rows keyed by column name. Use after list_tables to inspect small examples without running an arbitrary SQL query. Defaults to 3 rows, allows at most 50, and accepts limit: 0 when you only need table and column metadata without reading sample rows.
purge_agent_job_data
ChatGPTIrreversibly purge uploaded inputs, workflow artifacts, and stored blob data (outputs, steps, logs, trace) for one job while retaining DB metadata. DESTRUCTIVE. Requires confirm=true after explicit user confirmation.
query_tables
ChatGPTSubmit one bounded read-only ClickHouse SQL query over Roe tables in the caller's organization. Use after list_tables, describe_table, and usually preview_table. SQL format: pass exactly one SELECT or WITH ... SELECT statement. Do not include multiple statements. Mutating SQL (INSERT, UPDATE, DELETE, CREATE, DROP, ALTER, etc.), database-qualified names, eval tables, system tables, and Roe SQL functions such as run_agent are rejected. Request shape: {sql, limit?}. limit defaults to 1000 and maxes at 1000. Returns {table_query_id, status, created_at}. Then call get_table_query_result with table_query_id; keep polling that same tool until status is terminal.
run_agent
ChatGPTRun one Roe agent synchronously when completion is expected within about 25 seconds. Use trigger_agent_run for longer work. Inputs must match the selected agent version and must not contain secrets or regulated personal data. Returns the completed result in the same call without a job id.
run_batch_agent_jobs
ChatGPTStart multiple asynchronous jobs for one agent using its current version. Use this when several input maps should be processed as a batch. Inputs must match the current version and must not contain secrets or regulated personal data. Returns job ids for batch status and result retrieval.
set_current_skill_set_version
ChatGPTSelect an existing version of this skill set as current, for example to roll back. Agents following the set pick up this version; agents pinned to a specific version stay pinned.
test_connection
ChatGPTTest an existing saved connection using access already configured in Roe. Use this to verify that Roe can reach the connected external service. The tool does not expose or accept secret values.
trigger_agent_run
ChatGPTStart one asynchronous Roe agent job. Use this for work expected to exceed about 25 seconds or when job tracking is required. Inputs must match the selected agent version and must not contain secrets or regulated personal data. Returns a job id for status and result retrieval.
update_agent
ChatGPTUpdate an agent's top-level metadata (name, cache flags). To change engine config / inputs, create a new version with create_agent_version instead — agent versions are immutable once created. Returns the updated agent object.
update_agent_version
ChatGPTUpdate mutable metadata on a version (version_name, description). Sends PATCH, so a field you omit is left unchanged and an explicit null clears it. This does not promote the version or change the agent's current/live version; it only edits name/description metadata. Engine config and input definitions are immutable — to change those, use create_agent_version. Returns {agent_id, version_id, updated: true}.
update_policy
ChatGPTUpdate a policy's top-level metadata (name, description) only. To change policy content, create a new version with create_policy_version; existing policy versions are immutable. Returns the updated policy object.
update_skill_set
ChatGPTUpdate the name or description of a skill set. Omitted fields are preserved; an empty description clears it. File content is changed by creating an immutable version.
whoami
ChatGPTReturn the authenticated Roe user's profile. Use this as a connection check before listing or running agents. Returns {user_id, org_id, email, source}.
