dialogbrain
Server Details
Unified inbox MCP for WhatsApp, Telegram, Email, voice — read/send messages, search, AI agents.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- saloprj/dialogbrain-mcp
- GitHub Stars
- 0
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 346 tools
Most tools are organized by domain and have detailed descriptions, but the set is so large that boundaries blur across search/research, agent-vs-prompt history, and conversation threads vs Meta Threads. There are also visible duplicates such as calls_meet_browser and browser_attach_meet for attaching to a Meet bot browser, plus several LinkedIn tools marked unavailable.
The set overwhelmingly uses snake_case with domain prefixes (agents_, browser_, channels_, messages_), making most names predictable and readable. Minor deviations exist: agent_handoff is singular while most agent tools use agents_, threads_* is overloaded between conversation threads and Meta Threads, verbs vary (get/info/profile/recall), and web__local_search uses a double underscore.
346 tools is far beyond any practical MCP surface and qualifies as an extreme mismatch under the rubric. Even though the platform is broad, this many tools overwhelms tool selection and makes consistent discovery, permissions, and documentation unrealistic.
Lifecycle coverage is unusually deep across agents, channels, browser automation, calendar, files, groups, contacts, messaging, and social publishing, so agents can accomplish most workflows. Some gaps and dead ends remain, such as unavailable LinkedIn operations, no obvious contact-delete tool, and missing standalone trigger-list coverage.
Available Tools
346 toolsagent_handoffARead-onlyIdempotentInspect
Delegate a multi-step task (research, composing messages, booking, scheduling) to the full agentic planner. Use when a user ask needs more than a direct answer. The specialist runs synchronously — its response is already shown to the user in real-time. Summarize the OUTCOME in past tense (e.g. 'The Media Creator generated your video' or 'The Document Composer failed because...'). Do NOT say 'I will delegate' — the delegation already happened. If status is timeout or error, explain what went wrong and offer to retry.
Inputs: task_description (required), mode, payload, agent_id, +2 more.
agents_activityARead-onlyIdempotentInspect
See what you — or another agent in your workspace — actually did over a time window: messages sent, documents created, calls made, plus a summary (run counts, per-day, top tools). Use this to answer 'what did I do today / yesterday / last week / in the last hour?' or 'what did do?' with real data instead of guessing.
Omit agent for your own activity, or pass another workspace agent's name, slug, or id. Pass since/until as ISO datetimes (e.g. '2026-06-03T09:00:00') for sub-day windows like the last hour, or plain dates ('2026-06-03') for whole days — compute them from the current date/time you were given. Defaults to the last 24h. Traces are retained 30 days.
Times are interpreted as UTC — if the current time you were given is in another timezone, convert to UTC before passing since/until.
Inputs: agent, limit, since, until, +1 more.
agents_add_fileAInspect
Attach a file to this agent's private knowledge (agent-specific files, not shared with other agents).
Workflow:
Upload the file with files_upload (pass source_url for remote files)
Index it with files_ingest (pass the file_id)
Call this tool with agent_id + file_id
Returns chunk_count — shows 0 while still processing. Call agents.list_files later to see the final chunk count once indexing completes.
Inputs: file_id (required), agent_id (required), in_workspace.
agents_approve_draftADestructiveInspect
Approve a pending agent draft and send the message.
The draft will be sent to the conversation it was generated for. You can optionally edit the text before sending.
Use this when user says:
'Approve this draft'
'Send this reply'
'Approve and send'
'Looks good, send it'
IMPORTANT: This will send a message to a real person.
Inputs: draft_id (required), edited_text, in_workspace.
agents_askAInspect
Send a message to an AI agent and get its response.
The agent runs with its configured prompt, tools, and knowledge. Use this to test agents or have them process a task.
Returns: {status: 'replied'|'silent', response_text, messages[], full_reply, model_used, tokens_*, send_mode, execution_mode, tool_calls[]}. tool_calls[] is the per-tool trace in call order — each {tool, success, error, duration_ms} — so you can see which tool the agent ran and why it failed (e.g. a workbench script error) directly from this response, no trace lookup needed. messages[] carries each messages.send invocation the agent made (text, subject, reply_to_message_id, timestamp, message_id, attachments=[{file_id,name,mime}]). full_reply concatenates text only — attachment-only sends show up in messages but not full_reply. status='silent' iff both response_text is empty AND messages is empty.
Execution may take 10-60s depending on agent complexity. For runs that may exceed ~2 minutes (heavy multi-step agents), pass background=true: the call returns immediately with status='started' and the run continues server-side, detached from this connection — poll agents.traces_list / agents.trace_get for the outcome and agents.list_drafts for produced drafts.
Inputs: message (required), agent_id (required), send_mode, background, +3 more.
agents_createAInspect
Create a new AI agent in the workspace.
Execution modes:
ai_assisted (default): Two-phase AI — fast pre-classifier (Haiku) for keyword filtering and simple replies, then full AI with tools for complex messages.
agentic: Autonomous multi-step agent with planning and tool execution.
rule_based: Simple pattern matching without AI.
Keyword filtering is available in ai_assisted mode via keywords in trigger conditions (free, deterministic) and/or auto_reply_rules (LLM-based) set through agents.update.
Pass prompt_text for the agent's instructions (stored inline on the agent) or prompt_id to link an existing prompt row, not both.
Tools: a new agent starts with the standard tool set (knowledge base lookup, replying, lead capture, reading files, handoff, plus the default voice-call tools). Pass allowed_tools to replace that set.
From a template: pass template (e.g. 'dm-auto-reply') to create the agent AND its built-in trigger in one call — deterministic, no need to add a trigger separately. When template is set, name/text_engine/send_mode come from the template.
Inputs: name (required), model, runtime, template, +11 more.
agents_deleteADestructiveIdempotentInspect
Permanently delete an AI agent.
WARNING: This cannot be undone. The agent and all its triggers will be removed.
Inputs: agent_id (required), in_workspace.
agents_getARead-onlyIdempotentInspect
Get detailed information about a specific AI agent.
Returns full agent config including:
Execution configuration
Tool configuration
Knowledge configuration
Escalation configuration
Triggers list
Knowledge collections
Custom AI instructions (prompt_text)
Auto-reply rules override (auto_reply_rules)
Inputs: agent_id (required), in_workspace.
agents_get_draftARead-onlyIdempotentInspect
Get one agent draft with its FULL text, whatever its status (pending, approved, rejected, expired...).
agents.list_drafts cuts the reply and the trigger message short; this returns both in full, so a long draft can be read or edited. Returns draft_id, thread_id, status, response_text, trigger_text, created_at.
Use this when user asks:
'Show me the whole draft'
'What exactly does draft 123 say?'
Inputs: draft_id (required), in_workspace.
agent_silenceARead-onlyIdempotentInspect
End this turn without sending any message. Use when the thread is owned by a human operator after job.escalate, when the guest is self-resolving, when the message is a duplicate, or for observation-only turns. Calling this tool is the ONLY correct way to stay silent — narrated silence text (e.g. '(Staying silent…)', 'Internal:…') would be delivered to the guest verbatim.
Inputs: reason (required), in_workspace.
agents_listARead-onlyIdempotentInspect
List all AI agents configured in the workspace.
Returns agents with their basic info, trigger count, and knowledge collection count.
Each agent's description field tells you when that agent is useful. If you're a router-style agent deciding whether to delegate via agent.handoff, read descriptions and pick the best fit.
Use this to:
See all configured AI agents
Filter by status (active/paused/archived)
Get agent IDs for further operations
Inputs: status, in_workspace.
agents_list_draftsARead-onlyIdempotentInspect
List pending agent drafts awaiting approval.
Shows drafts that have been generated by AI agents but not yet sent. Each draft includes:
Thread/conversation info
Trigger message (what prompted the reply)
Generated response text
Creation time and expiration
Use this when user asks:
'Show pending agent drafts'
'What messages are waiting for approval?'
'List drafts to approve'
Inputs: limit, thread_id, in_workspace.
agents_list_filesARead-onlyIdempotentInspect
List files directly attached to this agent (agent-specific files, not shared collections).
Returns file_id, title, status, and chunk_count for each file. chunk_count shows how many indexed chunks were created — 0 means the file is still processing.
Use agents.add_file to attach a new file, or agents.remove_file to detach one.
Inputs: agent_id (required), in_workspace.
agents_list_integrationsARead-onlyIdempotentInspect
List the workspace integrations enabled (or available) for an AI agent, with each one's workspace_integration_id, provider, enabled flag, and count of denied tools. Use this to see what an agent can call before toggling with agents_set_integration.
Inputs: agent_id (required), in_workspace.
agents_prompt_historyARead-onlyIdempotentInspect
List past versions of an agent's prompt_text. Every edit to the agent's prompt is snapshotted to an append-only table — use this tool to browse history, find a prior known-good version, and copy it into agents.prompt_restore.
Inputs: agent_id (required), limit, in_workspace, before_version.
agents_prompt_restoreAInspect
Restore a past version of an agent's prompt_text by version_number. Creates a new version pointing at the restored content — history is preserved. Use agents.prompt_history first to find the version_number you want.
Inputs: agent_id (required), version_number (required), reason, in_workspace.
agents_reject_draftAInspect
Reject a pending agent draft without sending.
The draft will be marked as rejected and won't be sent. Use this when the generated response isn't appropriate.
Use this when user says:
'Reject this draft'
'Don't send this'
'Cancel this reply'
'Delete this draft'
'This response is wrong'
Inputs: draft_id (required), reason, in_workspace.
agents_remove_fileAInspect
Remove a file from this agent's private knowledge.
The file itself is not deleted — it's just detached from this agent. Use agents.list_files to find the file_id to remove.
Inputs: file_id (required), agent_id (required), in_workspace.
agents_set_integrationAInspect
Enable or disable a connected workspace integration on an AI agent — this controls which ext_ integration tools the agent (and its sandboxed workbench runs) may call. Use integrations_list to get the workspace_integration_id.
When enabling with no explicit denied_tools, WRITE-class tools are auto-disabled by default (read tools stay on); pass denied_tools=[] to force-allow everything, or a list of ext slugs / bare tool names to block specific ones. Idempotent upsert — safe to call repeatedly.
Inputs: agent_id (required), workspace_integration_id (required), enabled, denied_tools, +1 more.
agents_simulate_inboundBRead-onlyIdempotentInspect
Replay an inbound message on a thread through the real trigger pipeline and return what would have happened. The router auto-picks the winning enabled agent + trigger by priority/specificity (same logic as production). By default send_mode='draft' so no real message is sent; pass send_mode='auto' on a test account to let the matched agent actually deliver (drafts get overwritten by the next draft, so 'auto' is the only way to verify Telegram/email delivery end-to-end).
Use to verify routing for a thread: which agent answers, which trigger wins, or — when nothing matches — the structured skip reason. Pass blockchain_tx_data instead of message_text to simulate a wallet event on the thread.
Returns: {matched: true, matched_agent: {id, name, execution_mode}, matched_trigger: {id, trigger_type, conditions, specificity_score}, routing_reason, response_text, messages[], execution_mode, send_mode, model_used, tokens_input, tokens_output, latency_ms, } on a hit, or {matched: false, skip_reason, simulator_warnings} on a miss.
Inputs: send_mode, thread_id, in_workspace, message_text, +5 more.
agents_task_completeBInspect
Report that an agent run handed to you by DialogBrain is over: a Claude Code agent task, or a run started in an external agent. Call this when you finish processing it.
Inputs: trace_id (required), success, summary, in_workspace.
agents_trace_getARead-onlyIdempotentInspect
Fetch the full execution detail for a single trace — tool executions, events timeline, LLM call spans (with error_message on failures), and what the run cost.
cost_usd is the run's billed cost in USD, recorded even when the workspace pays with its own vendor key; 0 means nothing billable was recorded, null means the lookup could not run. Per-token detail is on each LLM span (input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens).
Use after agents.traces_list identifies a specific trace of interest (failed run, slow run, unexpected outcome).
By default LLM system_prompt and prompt_messages are stripped — set include_llm_bodies=true to fetch them when diagnosing prompt engineering issues (emits a WARNING audit log). Set full=true to disable all field truncation. completion_text on failed LLM calls is always returned (capped at 8 KB).
Inputs: agent_id (required), trace_id (required), full, in_workspace, +1 more.
agents_traces_listARead-onlyIdempotentInspect
List recent execution traces for an agent — the same data as /admin/requests, scoped to one agent and readable by an LLM.
Use this when an agent call timed out, drafted the wrong response, or you want to know which tool/LLM call burned the latency. Pair with agents.trace_get for full detail on a specific trace.
Filters: status, success, source (single value or comma-separated: agent,voice), date_from/date_to (ISO-8601), pagination via limit/offset.
Returns returned_count, dropped_on_page (should be 0 — positive means the backend agent_id predicate let something through), and has_more. Edge case: a raw page of all-dedup-dropped rows yields returned_count=0, has_more=true; re-call with offset += limit.
Inputs: agent_id (required), limit, offset, source, +5 more.
agents_traces_statsARead-onlyIdempotentInspect
Aggregated trace statistics for one agent over the last N days — total runs, success rate, avg duration, error breakdown, top tools used, runs-per-day histogram, and what the agent spent.
spend totals the agent's LLM usage over the same window: llm_calls, tokens_input, tokens_output, cost_usd, and own_key_cost_usd (the slice paid with the workspace's own vendor key, included in cost_usd rather than added to it). It covers usage recorded since per-agent attribution shipped, so it reads 0 for older runs; null means the lookup could not run.
Use this when you want a bird's-eye view of an agent's health before diving into individual traces with agents.traces_list / agents.trace_get. Scoped to the target agent (exact match, no substring bleed). days is capped at 30 — matches the ClickHouse request_traces TTL.
Inputs: agent_id (required), days, in_workspace.
agents_trigger_createBInspect
Create a new trigger for an AI agent.
Triggers determine when the agent activates.
Trigger types:
incoming_message: Activates on new incoming messages
schedule: Activates on a schedule
webhook: Activates on webhook events
blockchain_event: Activates when something happens on a crypto wallet address (funds arrive or leave, its risk grows, it is sanctioned or frozen). Saving the trigger is the whole setup: the address starts being watched
event: Activates on system events
Inputs: agent_id (required), trigger_type (required), enabled, priority, +7 more.
agents_trigger_deleteADestructiveIdempotentInspect
Delete a trigger from an AI agent.
WARNING: This cannot be undone.
Inputs: agent_id (required), trigger_id (required), in_workspace.
agents_trigger_updateCInspect
Update an existing AI agent trigger.
All parameters are optional — only provided fields will be updated.
Inputs: agent_id (required), trigger_id (required), enabled, priority, +8 more.
agents_updateBInspect
Update an existing AI agent's configuration.
All parameters are optional — only provided fields will be updated.
Use this to:
Enable or disable an agent
Change agent name or description
Assign or detach a prompt
Change default send mode
Replace knowledge collections
Update agent status
Change agent priority for trigger matching (lower number = higher priority)
Override which tools the agent can/can't call on triggered runs
Override which context sections (situation, communication style, job state, conversation history, thread summary) the agent receives
Opt into boilerplate prompt sections (safety guidelines, data confidentiality, factual accuracy) — all default OFF
Inputs: agent_id (required), name, model, script, +88 more.
agents_update_from_templateAInspect
Update a forked agent's instructions (prompt) to the latest version of the system template it was created from.
Use when the platform has improved a template and the user wants their forked agent to pick up the new prompt. This OVERWRITES the agent's prompt_text with the template's current prompt — any customizations to the prompt are replaced (recoverable via prompt history). Tool/model/execution settings are NOT changed. Only works on agents forked from a template (not from-scratch agents or templates themselves).
Inputs: agent_id (required), in_workspace.
ai_filters_createAInspect
Create a new AI filter for semantic intent-based message matching.
AI filters use vector embeddings (via Voyage AI) to detect whether an incoming message matches a specific intent or topic. The filter's description is embedded as a reference vector at creation time. When a message arrives, its embedding is compared against this reference using cosine similarity.
The description field is the most important part — it becomes the reference embedding that all incoming messages are compared against. Write it as a clear statement of what kind of messages should match:
'Customer asking about pricing, subscription plans, or billing'
'User reporting a bug, crash, or unexpected behavior in the product'
'Inbound sales lead expressing interest in purchasing or trialing'
The threshold controls sensitivity: 0.5 is a balanced default, lower values (0.3) cast a wider net, higher values (0.8) require closer matches.
Note: This tool calls the Voyage AI embedding API to generate the reference vector.
Inputs: name (required), description (required), threshold, in_workspace.
ai_filters_deleteADestructiveIdempotentInspect
Permanently delete an AI filter.
When to use:
User wants to remove a filter they no longer need
This action cannot be undone. Any triggers that reference this filter by ID will no longer match it — review and update those triggers after deletion.
Inputs: filter_id (required), in_workspace.
ai_filters_listARead-onlyIdempotentInspect
List all AI filters for the current workspace.
AI filters are semantic intent-based message filters that use embeddings (vector representations) to detect whether an incoming message matches a specific intent or topic. Unlike keyword filters, they understand meaning: 'I need help with my order' and 'my package hasn't arrived' both match a 'shipping support' filter even without shared keywords.
Each filter stores a reference embedding of its description. When a message arrives, its embedding is compared via cosine similarity against the filter's reference vector. If the similarity exceeds the threshold, the filter matches.
When to use:
Check which semantic filters already exist before creating a new one
Get filter IDs for use in trigger conditions
Review thresholds and active status of existing filters
Returns all filters with id, name, description, threshold, and is_active.
Inputs: in_workspace.
ai_filters_testARead-onlyIdempotentInspect
Test a message against an AI filter to check whether it would match.
This tool embeds the provided message using Voyage AI and computes the cosine similarity between the message vector and the filter's stored reference vector. It returns the similarity score, whether the message would match (similarity >= threshold), and the filter's threshold value.
Use this to:
Verify a filter works as intended before using it in a trigger
Tune the threshold by testing borderline messages
Debug why a message did or did not match a filter in production
Returns: {similarity: float, matched: bool, threshold: float}
Note: This tool calls the Voyage AI embedding API to embed the test message.
Inputs: message (required), filter_id (required), in_workspace.
ai_filters_updateAInspect
Update an existing AI filter's name, description, threshold, or active state.
When to use:
User wants to rename a filter
User wants to refine the filter description to improve match accuracy
User wants to adjust the similarity threshold (higher = stricter matching)
User wants to enable or disable a filter without deleting it
Provide only the fields you want to change. At least one field is required.
Note: If the description is changed, this tool calls the Voyage AI embedding API to re-generate the reference vector with the new description text.
Inputs: filter_id (required), name, is_active, threshold, +2 more.
ai_tags_add_to_threadAInspect
Apply one or more AI tags to a thread (manually).
When to use:
User wants to label a conversation with one or more tags
User asks to categorize or tag a thread
Provide the thread_id (integer) and an array of tag_ids to apply. Tag ids are the workspace's own (ai_tags.list); an id that is not a tag of this workspace is rejected, and a call where every id is rejected fails and names the tags that exist. Never guess an id. If a tag is already applied it will be updated to is_manual=true.
Inputs: tag_ids (required), thread_id (required), in_workspace.
ai_tags_createAInspect
Create a new AI tag (automatic message filter).
AI tags are lightweight classifiers that run on every incoming message. When a message matches the tag's description/criteria, the thread is automatically labelled — so AI agents can cheaply pre-filter threads instead of running full LLM analysis on everything. Good descriptions are the key: they tell the classifier exactly when to apply this tag.
When to use:
User wants to auto-classify incoming messages (e.g. bug reports, sales leads, support requests)
User wants to reduce AI agent costs by pre-filtering threads by topic or intent
Tips for the description field:
Be specific: 'Messages reporting errors, crashes, or unexpected behavior in the product'
Include examples of what qualifies and what doesn't
Limit: 20 active personal tags / 50 active team tags.
Inputs: name (required), icon, color, applies_to, +2 more.
ai_tags_deleteADestructiveIdempotentInspect
Delete a personal AI tag. All thread associations are removed automatically.
When to use:
User wants to permanently remove a tag they no longer need
This cannot be undone. Threads are NOT deleted — they just lose this tag.
Inputs: tag_id (required), in_workspace.
ai_tags_listARead-onlyIdempotentInspect
List all personal AI tags.
AI tags are automatic message filters: the system runs a lightweight classifier on every incoming message and applies matching tags to threads. This lets AI agents skip expensive full analysis on most messages — they only act on threads that match relevant tags, dramatically cutting LLM costs.
When to use:
Check which auto-classification filters exist before creating one
Get tag IDs for add_to_thread / remove_from_thread
See how many threads each tag currently matches
Returns all tags with thread counts (non-archived, included threads only).
Inputs: applies_to, in_workspace.
ai_tags_remove_from_threadAInspect
Remove a specific AI tag from a thread.
When to use:
User wants to un-label or remove a specific tag from a conversation
User wants to correct an incorrectly applied tag
Provide both thread_id and tag_id.
Inputs: tag_id (required), thread_id (required), in_workspace.
ai_tags_updateAInspect
Update an existing personal AI tag's name, description, icon, color, or active state.
When to use:
User wants to rename a tag
User wants to change a tag's icon, color, or description
User wants to enable or disable a tag
Provide only the fields you want to change. At least one field is required.
Inputs: tag_id (required), icon, name, color, +4 more.
analytics_queryARead-onlyIdempotentInspect
Answer analytics questions about this workspace's own data (conversations, messages, voice calls) — e.g. 'how many new conversations this week by channel' or 'inbound vs outbound messages per day this month'. Returns rows plus a chart hint. Read-only and scoped to the current workspace.
Inputs: question (required), in_workspace.
android_close_appADestructiveInspect
Close an app on the Android device (safe method: HOME key + am kill). Never uses am force-stop (corrupts PackageManager). Example: 'com.whatsapp'.
Inputs: package (required), in_workspace, channel_account_id.
android_current_appBRead-onlyIdempotentInspect
Get the currently focused app and activity on the Android device.
Inputs: in_workspace, channel_account_id.
android_install_apkADestructiveInspect
Install an app on the Android device from an APK or split bundle (XAPK/APKS — how most large modern apps ship). Provide apk_url (an https link the device downloads itself — preferred, and the only workable option for real apps) or, for tiny payloads, as apk_base64. Max 300MB. Large apps can take several minutes; if this call times out the install keeps running on the device — verify with the app-list tool instead of re-installing. Use reinstall=true to uninstall then install (for signature changes).
Inputs: apk_url, package, reinstall, apk_base64, +2 more.
android_keyBDestructiveInspect
Send a key event to the Android device. Use keycode (e.g., '3' for HOME, '4' for BACK) or common name (e.g., 'HOME').
Inputs: code (required), in_workspace, channel_account_id.
android_launch_appBDestructiveInspect
Launch an app on the Android device by package name. Example: 'com.whatsapp'. Returns success status and process ID if launched.
Inputs: package (required), in_workspace, channel_account_id.
android_list_appsARead-onlyIdempotentInspect
List installed apps on the Android device. By default returns third-party apps; use all=true for all apps.
Inputs: all, in_workspace, channel_account_id.
android_screenshotBRead-onlyIdempotentInspect
Capture a screenshot from the Android device. Returns JPEG image data encoded as base64.
Inputs: in_workspace, channel_account_id.
android_shellBRead-onlyIdempotentInspect
Run an allowlisted shell command on the Android device. First element of cmd array must be allowlisted: input, pm, dumpsys, am, getprop, screencap, monkey, uiautomator, settings, wm, cmd, content, ls, cat, pidof, ps, echo, service.
Inputs: cmd (required), in_workspace, channel_account_id.
android_swipeBDestructiveInspect
Swipe/drag on the Android device screen from one coordinate to another. Use for scrolling, opening app drawer, etc.
Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +3 more.
android_tapBDestructiveInspect
Tap on the Android device screen at specified coordinates. Coordinates are in device pixels.
Inputs: x (required), y (required), in_workspace, channel_account_id.
android_typeCDestructiveInspect
Type text on the Android device keyboard.
Inputs: text (required), in_workspace, channel_account_id.
android_ui_dumpARead-onlyIdempotentInspect
Get UI structure dump from the Android device. Uses dumpsys (uiautomator OOM-kills on this build). Returns window list and focused activity for frame-based clicking.
Inputs: in_workspace, channel_account_id.
artifacts_createInspect
Host a self-contained HTML page at a stable, default-private, shareable URL — the Artifact experience, in-app.
Pass exactly one of:
html— the full page: your<body>plus any<style>/<script>. Unlike documents.create, the page is served live (JavaScript runs), so charts, interactivity, and small tools work.file_id— a workspace file whose contents are already the HTML page.analytics_card_ids— ids of saved analytics dashboard cards; the platform re-runs their queries and composes one designed report page (static charts, snapshot at build time). Best way to give someone a shareable analytics report.
The page runs in a locked-down sandbox: a dedicated origin + a strict CSP. That means it is fully self-contained — it CANNOT call out to the network (fetch/XHR/WebSocket are blocked; the one exception is the press counter below, which the platform adds itself). Scripts, styles and fonts may load from cdnjs.cloudflare.com, cdn.jsdelivr.net/npm/, unpkg.com, cdn.tailwindcss.com and code.jquery.com (always pin an exact version, e.g. Chart.js from cdnjs), fonts also from Google Fonts; nothing else. Images must be inline data: URIs. A PDF export renders offline with JavaScript off: anything loaded from a CDN (scripts, CSS, fonts, Tailwind) is missing there, so a page meant for PDF keeps its CSS inline and draws charts as inline SVG.
Counting presses. To know what visitors press on a shared page, put data-track="<name>" on the element (a link, a button, or anything around them): <a href="https://wa.me/..." data-track="whatsapp">. Each press is recorded with its name and time and read back with artifacts.get (events). From a script, DialogBrain.count("<name>") does the same. A name is one word: letters, digits and _ . : -, up to 64 characters, no spaces; a page may use up to 100 different names. Write each name as a literal in the page (data-track="whatsapp", DialogBrain.count("whatsapp")): only names written that way are counted, one a script builds at run time is not. Nothing about the visitor is recorded, so give each person their own page when you need to know WHO pressed. Presses made inside the app's own viewer are not counted.
access_level defaults to 'private' (viewable only in-app). Set 'shared' to make the unguessable link itself the capability (anyone-with-link). You can flip this later with artifacts.set_access.
Returns {artifact_id, slug, url, app_url, version, access_level}. app_url always opens for workspace members, in the app. url is the public link and is set ONLY for a shared artifact (a private one has no public page: handed out bare, the public link answers "not available"). Republish with artifacts.update — both links stay the same.
Inputs: title (required), html, favicon, file_id, +5 more.
artifacts_export_pdfAInspect
Snapshot an artifact's current version to a PDF saved in the workspace. NOTE: the PDF is a STATIC capture rendered with JavaScript disabled — interactive or JS-drawn content (charts on , script-generated SVG) will not appear. Author charts as static SVG if they must show in the PDF. Returns the file_id; deliver it with messages.send(attachments=[file_id]).
Inputs: artifact_id (required), in_workspace.
artifacts_getARead-onlyIdempotentInspect
Fetch an artifact's metadata by id or slug — title, access level, version, view count, URL, and events: what visitors pressed on the published page (elements marked data-track, see artifacts.create), per name with count and first/last time. Set recent_events to also get the last presses one by one. Set include_html=true to also return the latest HTML body (so you can read-then-edit before calling artifacts.update).
Inputs: slug, artifact_id, in_workspace, include_html, +1 more.
artifacts_listARead-onlyIdempotentInspect
List the workspace's artifacts (most-recently-updated first): title, url, access level, version, view count, and how many presses visitors made on it (event_count, last_event_at; details in artifacts.get). Soft-deleted artifacts are excluded.
Inputs: in_workspace.
artifacts_refreshAInspect
Publish a new version of an artifact at the SAME URL, without sending HTML. Two kinds of artifact: one built from saved analytics cards (artifacts.create/update with analytics_card_ids) is rebuilt by passing artifact_id alone — its cards' queries re-run and the charts are redrawn; one created/updated with a template (HTML with {{placeholder}} tokens) takes data, a flat map of placeholder -> value (e.g. {"leads": "3 200", "date": "15 июля 2026"}), and every placeholder must have a value. Ideal for a scheduled refresh of live numbers.
Inputs: artifact_id (required), data, label, in_workspace.
artifacts_set_accessAInspect
Change an artifact's access level. 'shared' makes the unguessable link the capability (anyone-with-link); 'private' revokes that — the link 404s for anyone not signed into the workspace. Existing shared links keep the same URL when re-shared.
Inputs: artifact_id (required), access_level, in_workspace, telegram_web_app_agent_id, +1 more.
artifacts_updateAInspect
Republish an existing artifact with new HTML. The slug and URL stay the SAME; a new version is stored (older versions are retained up to a cap). Use this to refresh a shared dashboard — anyone with the link sees the new snapshot.
Inputs: artifact_id (required), html, label, template, +2 more.
background_runAInspect
Run ANOTHER tool off the critical path: returns INSTANTLY while the target tool runs in the background, so a slow write/log/notify never delays your reply. Pass tool (the id of a tool you already have) and args (the target tool's arguments as a JSON object STRING). Optional serialize_key serializes background runs that share the key (e.g. the spreadsheet id when appending rows). Use ONLY for tools whose result you don't need this turn (logging, side-effect writes). Cannot run a tool you don't already have, cannot run a tool that requires approval, and cannot run a tool that deletes data — call those directly. Only callable from within an agent turn.
Inputs: args (required), tool (required), in_workspace, serialize_key.
browser_add_init_scriptARead-onlyIdempotentInspect
Register JavaScript that runs BEFORE the page's own code, at document start, on every page opened afterwards in this identity's context. Use when browser.evaluate is too late — most often to hook window.fetch/XMLHttpRequest and capture a SPA's request bodies, which network_requests cannot show. Does NOT affect already-open pages: add the script first, then browser.open. Cannot be removed once added; it lives until the context is evicted or browser.close is called, and is put back by itself when the browser service restarts in between. Adding the same script again answers already_present and changes nothing.
Inputs: script (required), in_workspace, identity_name.
browser_attach_identityARead-onlyIdempotentInspect
Switch an open page to another browser identity: the page is reopened at its current address in that identity's own browser (its cookies and storage), under the same page_id. What was typed or loaded on the page is not kept. For a first navigation, pass identity_name to browser.open instead.
Inputs: page_id (required), identity_name (required), in_workspace.
browser_attach_meetARead-onlyIdempotentInspect
Attach to THIS meet's bot browser and return a page_id for its live Google Meet tab. Then use the normal browser.* tools (browser.snapshot to see the page, browser.click to press a control, browser.take_screenshot, browser.evaluate, browser.console_messages, browser.network_requests) with that page_id to inspect why the bot isn't visibly joining (lobby/blocked/admitted) and to recover a stalled join. Call with no arguments from inside a meet.
Inputs: in_workspace.
browser_checkBRead-onlyIdempotentInspect
Set a checkbox or radio button to checked (default) or unchecked (checked=false) and verify it. ref is an aria-ref or CSS selector; frame = CSS selector of the it is in.
Inputs: ref (required), page_id (required), frame, checked, +1 more.
browser_clickARead-onlyIdempotentInspect
Click an element. ref is either an aria-ref token from browser.snapshot ('e7') OR a CSS selector ('button.submit'). Prefer the aria-ref token. frame (optional): CSS selector of an a CSS ref lives in (nested: 'outer >>> inner'); aria-refs need no frame. Optional: button left|right|middle (right = context menu), double for a double-click, modifiers held during the click (any of Alt, Control, Meta, Shift — e.g. ['Control'] to open a link in a new tab).
Inputs: ref (required), page_id (required), frame, button, +3 more.
browser_clipboardBRead-onlyIdempotentInspect
Read (action='read') or write (action='write', text) the browser's clipboard as text, for pages that copy something to it (a 'Copy link' button) or paste from it. Grants the page's origin clipboard permission first.
Inputs: action (required), page_id (required), text, in_workspace.
browser_closeBRead-onlyIdempotentInspect
Close a page opened by browser.open.
Inputs: page_id (required), in_workspace.
browser_console_messagesARead-onlyIdempotentInspect
Return console.log/warn/error events captured since the last drain. Filter by level ('log'|'info'|'warning'|'error'|'debug') and/or pattern (regex). Buffer caps at 500 entries; oldest are dropped first. Set clear=false to peek without draining.
Inputs: page_id (required), clear, level, pattern, +1 more.
browser_create_identityAInspect
Create a browser identity for a website the person must sign in to (or sign up on) themselves, and get back a link to give them. Opening the link shows a live browser on the site; when they have signed in they press 'I'm logged in, save session' and the identity becomes active, after which browser.open / browser.attach_identity work with it. Use browser.handoff instead for an identity that already exists and is active. For a plain username + password sign-in form WITHOUT captcha or 2FA, pass username, password and confirm_sign_in_stored=true and the platform signs in itself (admin or owner only): the answer is status 'active' on success, or the reason plus the human link when the site wanted more (a captcha, a code). When the site refuses the username or password, an identity created by this call is deleted again (status 'deleted'); one that already existed is left as it was. The password is kept encrypted in the workspace's secret store and used to sign in again when the session expires.
Inputs: name (required), origin (required), url, password, +3 more.
browser_delete_identityADestructiveIdempotentInspect
Delete a browser identity of this workspace. Give EXACTLY ONE of identity_id (the id) or name (the identity's name); the older identity (name or id) is still accepted. The saved session, the stored sign-in (if any) and a sign-in window still open for it are removed, and it disappears from /connections. Only the identity's creator or a workspace admin/owner may delete it. Cannot be undone: the person has to sign in again to get it back. Use it to clean up a pending identity that was never completed, or one that is no longer needed.
Inputs: name, identity, identity_id, in_workspace.
browser_dragARead-onlyIdempotentInspect
Drag one element onto another. source_ref is the element to grab; target_ref is where to drop. Both are CSS selectors. Used for slider captchas, kanban, drag-and-drop uploads.
Inputs: page_id (required), source_ref (required), target_ref (required), in_workspace.
browser_emulateARead-onlyIdempotentInspect
Change what the page can observe about the environment. Any of: latitude + longitude (+ accuracy m) — geolocation, granted to the page's origin; grant_permissions — list of permission names (geolocation, notifications, camera, microphone, clipboard-read, clipboard-write, ...) granted to the page's origin; clear_permissions; color_scheme light|dark|no-preference; media screen|print; offline true/false. reset undoes geolocation, permissions, colour scheme and media. These apply to the whole browser context (every tab of this identity) until reset. Locale and time zone are the identity's own and are not changed.
Inputs: page_id (required), media, reset, offline, +7 more.
browser_evaluateARead-onlyIdempotentInspect
Run JavaScript in the page context and return the result. Use for state not in the a11y tree, captcha iframe inspection, DOM events. Expression is either a plain JS value ('document.title') or a zero-arg IIFE ('(() => { … })()'). Inline any runtime values into the expression itself. Result is JSON-serialized; non-serializable values become strings. 256KB cap on output.
Inputs: page_id (required), expression (required), in_workspace.
browser_file_uploadBRead-onlyIdempotentInspect
Attach files to an . Pass either local_paths (absolute host paths), data (list of {name, mime, base64} blobs written to /tmp; 25MB cap per file) or urls (http(s) URLs fetched with this browser session's cookies and uploaded; no cap of ours). frame = CSS selector of the the input lives in.
Inputs: ref (required), page_id (required), data, urls, +3 more.
browser_fillARead-onlyIdempotentInspect
Fill an input or textarea with the given value. ref is either an aria-ref token from browser.snapshot ('e7') OR a CSS selector ('input[name=email]'). Prefer the aria-ref token — it's stable and matches exactly what snapshot returned. frame (optional): CSS selector of an a CSS ref lives in (nested: 'outer >>> inner').
Inputs: ref (required), value (required), page_id (required), frame, +1 more.
browser_fill_formARead-onlyIdempotentInspect
Fill multiple form fields in one call. fields is a list of {ref, value} dicts. ref is a CSS selector; value is a string (text) or boolean (checkbox). Saves N round-trips vs calling browser.fill repeatedly.
Inputs: fields (required), page_id (required), in_workspace.
browser_framesARead-onlyIdempotentInspect
List the page's frames (the main frame and every ): index, name, url, whether it is the main frame, and a CSS selector matching its element only (inside its parent document: for a nested frame join the ancestors' selectors with ' >>> ', outermost first). Use the selector as frame on click / fill / type / hover / get / save_page. aria-refs from browser.snapshot work in iframes without it.
Inputs: page_id (required), in_workspace.
browser_getARead-onlyIdempotentInspect
Read one element without writing JS. what: 'text' (innerText), 'html' (outerHTML), 'value' (input value), 'attribute' (needs name), 'box' (x, y, width, height in the viewport), 'state' (visible, enabled, editable, checked). ref is an aria-ref or CSS selector; frame = CSS selector of the it is in.
Inputs: ref (required), page_id (required), name, what, +2 more.
browser_handle_dialogARead-onlyIdempotentInspect
Respond to a pending JS dialog (alert/confirm/prompt). Pass accept=true for OK or false for Cancel. For prompt() dialogs also pass prompt_text. Dialogs are queued at page-open time; returns {pending: false} if none is waiting.
Inputs: accept (required), page_id (required), prompt_text, in_workspace.
browser_handoffARead-onlyIdempotentInspect
When a site asks for verification (2FA, captcha, identity check, re-login) that only the person can do, call this tool with the browser identity name and the URL that needs them. Returns a link to give the person — clicking it opens their browser identity already on that page. When they finish they press Done, and you can continue. For several pages in a row, navigate the SAME prepared window rather than preparing a new one: the person keeps watching one window.
With prepare=True (optional): start the identity's browser server-side on the URL, attach it for form-filling, and return a page_id. Use the page_id with browser.fill / browser.click to fill the form in the live browser before giving the person the link — they will see it already filled and only need to review and complete verification steps that only they can do (CAPTCHA, consent, 2FA code). The window stays open for 30 minutes; if you do not send the link within that time, the window closes and the person must start over.
A PENDING identity (just made with browser.create_identity, nobody signed in yet) when the person gave you what the sign-in needs (e.g. a one-time code they forwarded): call with prepare=true and confirm_agent_sign_in=true. Its sign-in window opens server-side and you get a page_id; sign in there yourself, check the page shows the signed-in state, then call browser.save_session(page_id): the identity becomes active and keeps the session. Nobody has to open a link.
Inputs: identity (required), url, close, reason, +3 more.
browser_hoverARead-onlyIdempotentInspect
Hover the mouse over an element (reveals tooltips + hover menus). ref is an aria-ref token from browser.snapshot or a CSS selector; frame (optional) is the CSS selector of an a CSS ref lives in.
Inputs: ref (required), page_id (required), frame, in_workspace.
browser_keyboardARead-onlyIdempotentInspect
Keyboard at the focused element, beyond a whole press (browser.press_key): action 'down' / 'up' hold or release key (e.g. 'Shift', 'Control', 'a'; hold a modifier, press other keys, then release), 'insert_text' pastes text in one step without key events (fast, like a paste).
Inputs: action (required), page_id (required), key, text, +1 more.
browser_list_identitiesARead-onlyIdempotentInspect
List this workspace's browser identities (the /connections page, over MCP). Use it to SEE what sign-ins already exist before creating, re-authenticating or deleting one, so you never guess a name or make a duplicate. Each row has identity_id, name, origin, registrable_domain, status ('pending' | 'active' | 'expired'), last_used_at and last_known_good_at (an 'active' row whose last_known_good_at is old likely needs a re-login via browser.handoff), has_credentials, can_delete, and the channel accounts signed in through it with their health. Revoked identities are not listed. Optional site filters by origin/domain substring (e.g. 'websummit').
Inputs: site, in_workspace.
browser_mouseARead-onlyIdempotentInspect
Low-level mouse at VIEWPORT coordinates (pixels from the top left), for canvases, maps, sliders and anything a selector cannot reach. action: 'move', 'down', 'up', 'click', 'dblclick' (x and y needed for move/click/dblclick; down/up use the current position), 'wheel' (delta_x, delta_y). button: left | right | middle. steps > 1 makes 'move' a smooth path. A drag is: move, down, move, up.
Inputs: action (required), page_id (required), x, y, +5 more.
browser_network_requestsARead-onlyIdempotentInspect
List HTTP requests the page made since open or last drain. Optional filters: method (GET/POST/...), url_pattern (regex), status_min (e.g. 400 for errors). Captures up to 200 most recent requests per page.
Inputs: page_id (required), clear, method, status_min, +2 more.
browser_openARead-onlyIdempotentInspect
Open a URL in a remote browser. Saved login cookies are auto-attached when the URL domain matches a claimed browser identity. Pass identity_name to override auto-matching or force a specific identity. The result's identity field names which saved login the page opened under (null = anonymous).
Inputs: url (required), in_workspace, identity_name.
browser_press_keyARead-onlyIdempotentInspect
Press a keyboard key (e.g., 'Enter', 'Tab', 'Escape', 'ArrowDown') or a single character. Shortcuts with modifiers are written with '+': 'Control+A', 'Shift+Tab', 'Control+Shift+ArrowLeft', 'Meta+Enter'. Optional ref focuses an element first — aria-ref token from browser.snapshot ('e7') or a CSS selector (frame = CSS selector of the it lives in).
Inputs: key (required), page_id (required), ref, frame, +1 more.
browser_resizeARead-onlyIdempotentInspect
Resize the page viewport. Useful when a site serves different HTML based on viewport width (mobile vs desktop) or when an anti-bot scores risk by viewport dimensions.
Inputs: width (required), height (required), page_id (required), in_workspace.
browser_save_fileARead-onlyIdempotentInspect
Save a file from the page into the workspace's files and get its file_id (use it with messages.send attachment_file_ids or any files.* tool). The bytes move server-side, never through your context, so size is not a problem. source is one of: 'expression' — expression is JS that evaluates (promises are awaited) to a Blob/File, ArrayBuffer, typed array, Response, 'data:'/'blob:' URL or string, e.g. a recording kept in the page: 'window.__recordedBlob' or 'fetch("/export").then(r => r.blob())'; 'url' — url is fetched with this browser session's cookies (headers optional); 'download' — a download the page starts: pass ref to click the button that starts it, or omit ref to take the newest download the page already started (or wait for the next, up to timeout_ms). Optional filename and mime_type override what the page or server reports. Returns {file_id, name, mime, size}.
Inputs: source (required), page_id (required), ref, url, +7 more.
browser_save_pageARead-onlyIdempotentInspect
Save the current page (or one element) into the workspace's files and get its file_id. format: 'pdf' (printed page; optional paper letter|legal|tabloid|a3|a4|a5 — default the page's own CSS size —, landscape, print_background, scale), 'html' (current DOM, or the outerHTML of ref), 'mhtml' (one self-contained offline copy with styles and images), 'png' or 'jpeg' (screenshot of the viewport, full_page, or ref), 'text' (visible text of the page or ref). ref is an aria-ref token or CSS selector (frame = CSS selector of the it lives in). Returns {file_id, name, mime, size, url, title}.
Inputs: page_id (required), ref, frame, paper, +7 more.
browser_save_sessionAInspect
Save the sign-in of an OPEN page into the browser identity the page was opened with (browser.open with identity), the same as a person's "I'm logged in, save session" button. Without it a sign-in made in a browser.open page is lost when the page closes, and everything that reads the identity (channels.reconnect, integrations) keeps the old session. Call it ONLY after checking the page shows the signed-in state (a logged-out page would replace a working session), before closing it. Refused when the page was opened without an identity, when the identity is not active or expired, or when the page is not signed in to the identity's own site. For a PENDING identity, pass the page_id browser.handoff(prepare=true, confirm_agent_sign_in=true) returned, after you signed in there: the identity becomes active and that window closes (the page_id stops working; continue with browser.open(identity=...)). Nothing secret is returned. Needs the member, admin or owner role.
Inputs: page_id (required), in_workspace.
browser_scrollARead-onlyIdempotentInspect
Scroll. With ref (aria-ref or CSS selector; frame = iframe selector): by default scrolls that element into view; with delta_x/delta_y it wheel-scrolls over it. With no ref: to = 'top' | 'bottom' scrolls the page to its end, otherwise the page is wheel-scrolled by delta_x/delta_y pixels (positive y = down). Returns the resulting scroll position.
Inputs: page_id (required), to, ref, frame, +3 more.
browser_select_optionBRead-onlyIdempotentInspect
Pick option(s) in a native dropdown. Pass value (matches the option's value attr) OR label (matches its visible text). Lists allowed for multi-select.
Inputs: ref (required), page_id (required), frame, label, +2 more.
browser_set_headersARead-onlyIdempotentInspect
Set extra HTTP headers sent with every request of THIS tab (e.g. {'X-Requested-With': 'XMLHttpRequest'}). Replaces the previous set; an empty object clears it. Does not touch the identity's own browser headers.
Inputs: headers (required), page_id (required), in_workspace.
browser_snapshotARead-onlyIdempotentInspect
Return a YAML aria_snapshot of the page DOM. Each interactive node is tagged with [ref=eN] (e.g. [ref=e7]). Pass that exact token as the ref arg to browser.click / browser.fill / browser.type / browser.press_key. Do NOT pass the role name ('combobox', 'button') as ref — only the eN token. Truncated at 32KB.
Inputs: page_id (required), in_workspace.
browser_storageARead-onlyIdempotentInspect
Read or change browser storage of the page's origin. area: 'cookies' | 'local' (localStorage) | 'session' (sessionStorage). action: 'get' | 'set' | 'remove' | 'clear'. local/session: key (+ value for set); 'get' without key returns every entry. cookies: 'get' lists the cookies the page's URL (or url) would send — values of HttpOnly cookies are withheld; 'set' needs key (name) and value, optional url/domain+path, expires (unix seconds), secure, http_only, same_site (strict|lax|none); 'remove'/'clear' delete the cookie named key / all cookies, but ONLY those the current page's URL would send (its domain and path); pass domain explicitly to reach other sites' cookies.
Inputs: area (required), action (required), page_id (required), key, +9 more.
browser_tabsBRead-onlyIdempotentInspect
Manage tabs within the same BrowserContext as page_id. action ∈ {list, switch, close, new}. For list, returns all open tab metadata; for new, returns the new tab's page_id.
Inputs: action (required), page_id (required), url, tab_id, +1 more.
browser_take_screenshotARead-onlyIdempotentInspect
Capture a PNG screenshot of the page or a specific element. Returns base64-encoded image bytes AND a file_id (persisted in DialogBrain files storage). Pass file_id straight to messages.send(attachment_file_ids=[file_id]) — do NOT call files.upload again. Use sparingly — favor browser.snapshot for structured DOM understanding.
Inputs: page_id (required), ref, full_page, in_workspace, +1 more.
browser_traceARead-onlyIdempotentInspect
Record a Playwright trace (timeline of actions with screenshots, DOM snapshots and network) of this tab's browser context. action='start' (optional name, screenshots, snapshots, sources), then do the work, then 'stop': the trace .zip is stored in the workspace files and its file_id returned. Open it at trace.playwright.dev. Covers every tab of the context; stop before browser.close.
Inputs: action (required), page_id (required), name, sources, +4 more.
browser_typeARead-onlyIdempotentInspect
Type text into an element with per-keystroke delay (organic). Each character dispatches keydown/keypress/keyup, unlike browser.fill which replaces .value instantly. Use when the page listens to keystroke events or for typing-speed fingerprint checks. ref is an aria-ref token from browser.snapshot ('e7') or a CSS selector. delay_ms defaults to 50. The element is emptied first unless clear is false, which appends at its end. frame (optional): CSS selector of an a CSS ref lives in.
Inputs: ref (required), text (required), page_id (required), clear, +3 more.
browser_wait_forARead-onlyIdempotentInspect
Wait for a selector to appear OR a navigation URL to match a glob pattern. Provide ref (aria-ref or selector; frame = CSS selector of the it lives in) OR url_pattern (glob).
Inputs: page_id (required), ref, frame, timeout_ms, +2 more.
browser_wait_for_responseARead-onlyIdempotentInspect
Wait for ONE network response whose URL matches url_pattern (substring, a glob with '*', or 're:') and optionally method/status, then return its status, safe headers and body. To catch a response caused by an action, pass trigger_ref — that element is clicked while waiting (otherwise the response must arrive after this call starts). Text bodies come back inline (256 KB cap); with save=true the body is stored as a workspace file instead (use for binary or large bodies) and file_id is returned.
Inputs: page_id (required), url_pattern (required), save, frame, +7 more.
calendar_check_availabilityARead-onlyIdempotentInspect
Check when you have free time in the connected calendar (Google, Outlook or a CalDAV calendar). Shows busy periods and free slots in a given time range. Useful for finding meeting times or checking schedule conflicts.
Inputs: end_time, timezone, account_id, start_time, +4 more.
calendar_create_eventBInspect
Create a new event in the connected calendar (Google, Outlook or a CalDAV calendar). Specify the title, start time, end time, and optionally invite attendees. Use ISO 8601 format for dates (e.g., 2024-12-15T14:00:00).
Inputs: end, start, title, summary, +15 more.
calendar_delete_eventBDestructiveIdempotentInspect
Delete an event from the connected calendar (Google, Outlook or a CalDAV calendar). This action cannot be undone. Use with caution.
Inputs: event_id (required), account_id, calendar_id, in_workspace, +1 more.
calendar_list_eventsBRead-onlyIdempotentInspect
List events from the connected calendar (Google, Outlook or a CalDAV calendar). Shows upcoming events by default. Can filter by date range and search query.
Inputs: query, date_to, date_from, account_id, +3 more.
calendar_meet_policyAInspect
Read or change whether a meeting bot joins the Google Meet calls of a connected Google Calendar. With no setting given it only READS the current policy: auto_join_enabled, auto_join_transcribe_only, default_meet_agent_id, meet_caption_language. Settings given are changed, the rest stay. auto_join_enabled=true needs auto_join_transcribe_only=true (the bot only writes the transcript, never speaks) or a default_meet_agent_id (the agent the bot acts as). Changing needs the editor, admin or owner role and is written to the workspace access journal.
Inputs: account_id, in_workspace, auto_join_enabled, default_meet_agent_id, +2 more.
calendar_update_eventAInspect
Update an existing event in the connected calendar (Google, Outlook or a CalDAV calendar). Can modify title, time, location, description, and attendees, add an online meeting link (Google Meet or Teams) to an event that has none, and move the event to another calendar of the same account. Only specified fields will be updated.
Inputs: event_id (required), end, start, summary, +13 more.
calls_agent_duelAInspect
Start an agent-vs-agent VOICE test call: two AI voice agents share one LiveKit room — a 'caller' persona agent pursues a task brief against the 'callee' business agent under test. Use to evaluate booking flows, latency, and conversation quality without a human caller.
The CALLER agent should have an EMPTY voice_greeting (it must stay silent until the callee greets) and voice_filler_enabled=false.
Afterwards inspect both call_ids with agents.traces_list / calls.get_transcript. A subscribe-only listen token is returned for listening in live.
Inputs: task (required), callee_agent_id (required), caller_agent_id (required), in_workspace, +1 more.
calls_dismiss_agentARead-onlyIdempotentInspect
Take the AI agent OFF a running call while the bot stays in the call and keeps transcribing (Google Meet / Teams bot, Telegram group voice chat, WhatsApp group call). Use it to remove or replace the agent without ending the call. To bring an agent back, call calls.dispatch_agent with the same session UUID (or thread_id); it receives the full call transcript so far. To end the whole call and make the bot leave use calls.hangup instead. Identify the call by target (live session UUID from calls.list_active) or thread_id of the running call. Waits up to ~15 s for the agent to confirm it has left; fails if no agent is active on the call.
Inputs: reason, target, thread_id, in_workspace.
calls_dispatch_agentARead-onlyIdempotentInspect
Send a workspace AI agent into a live call — ONE tool for every surface; target decides where: a Google Meet, Microsoft Teams or Zoom link → meeting bot; a Telegram @group / t.me link / chat_id / t.me/call slug → Telegram group voice chat or conference; 'new' → creates a NEW Telegram conference call and returns its shareable link; a WhatsApp group JID (digits@g.us) → WhatsApp group call; a live session UUID (from calls.list_active), or thread_id of a running call → WAKES the agent on the bot already in that call instead of spawning a second one. For a meeting link the router also checks for a bot already in that meeting and wakes it rather than double-joining. Always pass agent_id (from agents.list). For a live TRANSLATOR use calls.dispatch_translator instead. agent_id must be an ACTIVE agent of this workspace — a system template is refused (create an agent from it first with agents.create). To take the agent off the call again while the bot keeps transcribing, use calls.dismiss_agent.
Inputs: agent_id (required), title, target, greeting, +6 more.
calls_dispatch_translatorARead-onlyIdempotentInspect
Send a live speech translator to a call. target decides where: a Google Meet, Microsoft Teams or Zoom link → meeting bot; a Telegram @group / t.me link / chat_id → Telegram group voice chat; 'new' (or omitted) → creates a native DialogBrain meeting with translation on and returns the join + guest links; a native meeting call_id or /meeting/ URL → enables translation on that running meeting. Always pass target_language (ISO code); optional app_languages (extra subtitle-only languages), sentence_length (short|medium|long, native only), silent (subtitles without voice), source_language (the meeting's spoken language, ISO code — improves recognition; omit for autodetect), tts_provider + tts_voice (the translator's voice; omit for the workspace default).
Inputs: target_language (required), title, silent, target, +9 more.
calls_get_transcriptARead-onlyIdempotentInspect
Get the structured transcript and final state of a voice call by call_id. Returns per-turn rows in chronological order, call status (active/completed/failed/abandoned), duration, and an outcome field telling whether the recipient picked up (answered/no_answer/busy/declined/failed/unknown). answered_at is non-null once the recipient picked up. Returns active turns if the call is still in progress.
Inputs: call_id (required), in_workspace.
calls_hangupARead-onlyIdempotentInspect
Hang up an active voice call by call_id. Use after calls.make when the agent decides to terminate before the callee does, or to abort a stuck call. Idempotent: returns success if the call is already terminal.
Inputs: call_id (required), reason, in_workspace.
calls_list_activeARead-onlyIdempotentInspect
List active voice calls in this workspace. Use before calls.make on a Telegram account (only one MTProto call per account at a time) to check whether the line is free.
Inputs: channel, in_workspace, channel_account_id.
calls_list_historyARead-onlyIdempotentInspect
Search historical voice calls in this workspace by participant name, contact_id, thread, channel, source, and/or date range. Returns one row per call (NOT per turn) with call_id, duration_seconds, outcome, direction, started_at, source, channel_label, and parent_thread_id (the originating chat thread for Telegram-group / Twilio-outbound / Meet calls). Pair with calls.get_transcript(call_id) for the full per-turn transcript. Use this instead of messages.read_history for cross-thread call queries — group calls and Meet sessions live on per-call sub-threads, not on the parent chat thread.
Inputs: limit, since, until, source, +5 more.
calls_makeADestructiveInspect
Place an outbound AUDIO/VOICE phone call via Twilio (PSTN) or Telegram (MTProto 1:1 call). Use this any time the user asks to 'call', 'ring', 'phone', 'dial', or have a spoken conversation. Do NOT use messages.send when the user asks to call someone — a call is real-time voice, not a text message. You conduct the conversation as the voice agent using the provided greeting and instructions.
Inputs: greeting (required), app, channel, contact_id, +12 more.
calls_meet_browserARead-onlyIdempotentInspect
Attach to a Google Meet bot's live browser to diagnose and recover a bot that isn't visibly joining. Pass the meet session's call_id; returns a page_id. Then drive the bot's Meet page with the generic browser tools (browser.snapshot / browser.click / browser.take_screenshot / browser.evaluate / browser.console_messages / browser.network_requests) using that page_id — read the snapshot to see whether the bot is in the lobby, blocked, or admitted, and click guest-side controls to recover a stalled join. Note: host admission ('Admit') happens in the host's own browser and is not present on the bot's page.
Inputs: call_id (required), in_workspace.
calls_mute_translation_ttsARead-onlyIdempotentInspect
Mute or unmute an active call's live-translation TTS. scope='call' (default, Google Meet sessions ONLY): the translator goes silent INSIDE the call — participants hear no bot voice, in-flight audio is cut immediately, but translation audio + subtitles remain available in the app (listen overlay). scope='everywhere' (any channel): stop synthesizing entirely from the next utterance — subtitles only, no audio anywhere. muted=false reverses either. Translation itself keeps running throughout.
Inputs: muted (required), call_id (required), scope, in_workspace.
calls_set_translation_languageBRead-onlyIdempotentInspect
Change the target language of an active voice/Meet call's live translator on the fly — no hangup or re-dispatch (also arms translator mode if it isn't already on). Pass the call_id and an ISO language code, e.g. 'th' (Thai), 'ru' (Russian), 'es' (Spanish), 'en' (English). Takes effect within ~10ms — speak and the translation switches to the new language.
Inputs: call_id (required), language (required), in_workspace.
calls_set_translation_languagesARead-onlyIdempotentInspect
Set the EXTRA target languages an active voice/Meet call's translator produces for the APP ONLY (subtitles + listenable audio in the inbox — NOT spoken into the call). Operators switch between them in the UI. Pass call_id and app_languages (ISO codes, e.g. ['de','fr']); pass [] to drop all extras. Max 4. The primary spoken language is managed by calls.set_translation_language. Takes effect within ~10ms; new languages translate NEW speech only.
Inputs: call_id (required), app_languages (required), in_workspace.
calls_transferARead-onlyIdempotentInspect
Transfer the current phone call to a person on another number (e.g. 'let me put you through to a manager'). Only works on a live PHONE call, and only to a number the operator has pre-approved for this agent. Say one short sentence to the caller first ('connecting you now'), THEN call this. It rings the destination and returns when they pick up — which can take most of a minute — and only then do you leave the call. If nobody answers you are told so and are still on the line with the caller.
Inputs: to (required), call_id, in_workspace.
calls_waitARead-onlyIdempotentInspect
Block until a voice call ends (status changes from 'active') or timeout elapses. Returns ended=true with final state when the call has ended; ended=false on timeout (re-issue to keep waiting). The returned state includes outcome so callers can branch on pickup vs. no-answer (answered/no_answer/busy/declined/failed/unknown). Default timeout 90s; cap 110s — bounded by nginx proxy_read_timeout 120s on /mcp.
Inputs: call_id (required), in_workspace, timeout_seconds.
campaigns_cancelCRead-onlyIdempotentInspect
Cancel a campaign — no further numbers are dialed.
Inputs: campaign_id (required), in_workspace.
campaigns_createBRead-onlyIdempotentInspect
Start a bulk outbound call campaign: dial a list of phone numbers with a voice agent, at a bounded concurrency, retrying no-answers. Phone network only (twilio/telnyx). It begins dialing on its own — no separate start.
Inputs: name (required), phone_numbers (required), channel, agent_id, +7 more.
campaigns_listBRead-onlyIdempotentInspect
List this workspace's campaigns, newest first.
Inputs: limit, offset, in_workspace.
campaigns_pauseCRead-onlyIdempotentInspect
Pause a campaign — stop starting new calls; in-flight ones finish.
Inputs: campaign_id (required), in_workspace.
campaigns_resumeCRead-onlyIdempotentInspect
Resume a paused campaign.
Inputs: campaign_id (required), in_workspace.
campaigns_statusBRead-onlyIdempotentInspect
Progress of one campaign: status and per-number counts.
Inputs: campaign_id (required), in_workspace.
channels_connectAInspect
🔌 Connect a messaging channel to this workspace, or find out how.
Call with no channel for the catalogue: every channel, its connect_mode and its link.
Call with channel only to learn what to ask the person for (credential_fields).
Call with channel + credentials to connect a credentials channel: email over IMAP with an app password, telegram_bot with a bot token, line with the channel access token and channel secret, avito.
Channels that need a QR scan, a phone code or a browser sign-in (telegram, whatsapp, instagram, facebook, email (Google sign-in), youtube, tiktok, x, threads, linkedin, zalo, maxru, the voice carriers) cannot be connected from here: the tool answers success with needs_person=true and the link https://dialogbrain.com/connect/, which opens the connection dialog for that channel. Give the person that link; do not tell them to look for it in settings. A website widget is not connected here at all: use widgets.create.
channel='google_drive' (owner/admin) creates the workspace's Google Drive address, or returns it when it exists: the person shares a folder (or a Shared Drive) with that address as Editor, then drive.folders(action='add', link=) registers it.
Inputs: channel, credentials, display_name, in_workspace.
channels_connect_session_cancelAInspect
Stop a connect session that is still waiting. Returns the session with cancelled.
Only a waiting session is cancelled. On a session that is already connected this does nothing (cancelled: false, status stays connected): it never disconnects a number.
Inputs: session_id (required), in_workspace.
channels_connect_session_getARead-onlyIdempotentInspect
Where a connect session stands. Poll every 2-3 seconds.
Returns {status, qr, qr_expires_at, expires_at, pairing_code, account_id, phone, name, external_ref, error}. qr is always the current code: draw whatever the latest answer carries and keep nothing. A value that starts with data: is a picture to show as it is (Viber); anything else is a string to draw. qr_expires_at is null when the channel does not say (WhatsApp, Viber).
After the number is connected the session keeps answering connected with account_id, phone and name for 15 minutes. A session of another workspace or key is not found.
Statuses: waiting_scan: show qr (it changes; always draw the one from the latest get; null means the code is not ready yet, keep polling). need_phone: submit the phone number. need_code: submit the code Telegram sent. need_password: submit the Telegram two-step verification password. need_pairing_code: show pairing_code; the person types it in WhatsApp > Linked devices > Link with phone number. connected: account_id, phone, name are set. expired: start a new session. error: error says why.
Inputs: session_id (required), in_workspace.
channels_connect_session_optionsARead-onlyIdempotentInspect
Which channels a connect session can connect right now, and the methods of each: {channels: {whatsapp: [qr, pairing_code], telegram: [qr, phone], viber: [qr]}}. A channel that is not listed is refused by channels.connect_session.start with unsupported_channel. Read this instead of hard-coding the list: channels and methods are added over time.
Inputs: in_workspace.
channels_connect_session_startAInspect
🔌 Start connecting a WhatsApp, Telegram or Viber number from your own screen, with no DialogBrain login for the person who owns the number.
Returns {session_id, status, qr, qr_expires_at, expires_at}. qr is the RAW string to draw as a QR code, not a picture. Viber is the exception: its qr is a data:image/png;base64,... URL, the picture of the code Viber itself draws; show it as an image. It is null for the first seconds, while Viber starts. Then poll channels.connect_session.get every 2-3 seconds.
Methods (channels.connect_session.options lists what is supported right now): whatsapp qr or pairing_code; telegram qr or phone; viber qr (scanned in Viber on the phone: More > Settings > Account > Desktop and Tablets). For pairing_code and phone the session starts at need_phone and the number is sent with channels.connect_session.submit.
The account will belong to the user behind the API key. external_ref is your own label (an employee id, a row id): it comes back in get, on the account in channels.list and in the channel.connected webhook.
A workspace with no way to pay for the channel is refused here with error_type billing_required, before any code is shown. Other refusals: permission_denied, unsupported_channel, rate_limited (10 starts per 10 minutes).
Statuses: waiting_scan: show qr (it changes; always draw the one from the latest get; null means the code is not ready yet, keep polling). need_phone: submit the phone number. need_code: submit the code Telegram sent. need_password: submit the Telegram two-step verification password. need_pairing_code: show pairing_code; the person types it in WhatsApp > Linked devices > Link with phone number. connected: account_id, phone, name are set. expired: start a new session. error: error says why.
Inputs: channel (required), method, external_ref, in_workspace.
channels_connect_session_submitAInspect
Hand a connect session what the person typed: exactly ONE of phone, code, password.
need_phone →
phone(international format). WhatsApp answers need_pairing_code with the 8-characterpairing_codeto type on the phone; Telegram sends a code and answers need_code.need_code →
code(Telegram). Answers connected, or need_password when the account has two-step verification.need_password →
password(Telegram two-step verification).
A mistyped code or password is refused with error_type validation and the session stays where it is: submit again. 10 submits per session, then rate_limited and the session ends. Nothing submitted here is logged or stored after the session ends.
Inputs: session_id (required), code, phone, password, +1 more.
channels_connect_telegram_botAInspect
🤖 Connect a Telegram Bot (Bot API) channel from its bot token.
When to use:
After a bot was created via @BotFather and you have its token.
The token alone is sufficient — no Telegram user account is needed.
Validates the token, creates the channel account, and registers the webhook so the bot starts receiving messages immediately.
Inputs: bot_token (required), in_workspace.
channels_contactsAInspect
👥 Load people into a custom channel account, so its conversations are titled with names and each person has a card in the workspace's contacts.
contacts is a list of {contact_id, display_name, conversation_id?, avatar_url?, details?}. contact_id is the platform's id for the person. details may carry email, phone, about, company, job_title, linkedin, website. Give conversation_id for people the account already has a conversation with.
import_history: 'answered' reads into the inbox only the conversations in which the other side wrote; 'all' reads every conversation; omit it to load names only. The import runs in the background; a second request while one runs is queued, not lost. Check progress with channels.list(account_id=...): history_import.skipped counts the conversations left out and not_imported names the first 100 with the reason. Up to 5000 contacts per call; loading again is safe.
Inputs: contacts (required), account_id (required), in_workspace, import_history.
channels_get_profileARead-onlyIdempotentInspect
🪪 Read a connected channel's current bot profile: display name, long description, short description, the / command menu and the persistent menu button.
Pass language_code to read back a localized variant instead of the default one.
Inputs: channel_account_id (required), in_workspace, language_code.
channels_listARead-onlyIdempotentInspect
📋 The messaging channels connected to this workspace and whether they are working.
One row per channel account: channel, display_name, status, error, and reconnect_url when the account needs repair. A channel in status 'error' is NOT receiving messages — say so plainly and give the person reconnect_url; it opens the repair directly, so do not tell them to look for it in settings and do not build a link of your own.
An account connected through channels.connect_session carries the external_ref it was started with.
Pass only_broken=true to check for outages without listing the healthy channels.
Inputs: chats, account_id, only_broken, chats_offset, +1 more.
channels_reconnectAInspect
🔌 Bring a disconnected account back on its own, when the channel allows it.
Use it when channels.list shows an account as not connected / needs_reauth, or a send answers that the account is offline. A LinkedIn or Discord account connected through a browser login takes the session that login holds now (nothing is opened or typed on the site; the session must belong to the same member). When it cannot (no session in the browser, the same dead session, another channel), the answer says what a person has to do. Needs the member, admin or owner role.
Inputs: account_id (required), page_id, in_workspace.
channels_subscribeAInspect
💳 Choose how this workspace pays for a paid channel, so it can be connected.
When to use: a connect tool answered billing_required (e.g. channels.connect_telegram_bot, channels.connect).
OMIT
methodto see the monthly price and which payment methods work right now (nothing is charged).method: "credits"pays from the workspace credit balance: the first month is charged when the channel is connected, then monthly from the balance. Then call the connect tool again.method: "stripe_card"(or another card/crypto method) returnsredirect_url, a checkout page the person must open and pay; connect after they have paid. Spends the workspace's money: use it when the person asked to connect the channel.
Inputs: channel_type (required), method, in_workspace.
channels_sync_settingsAInspect
⚙️ Change how large a group can be and still sync on one connected account.
Groups and channels with large_group_threshold members or more are left out of sync (default 50; 0 = never leave a group out for its size). The current value is in channels.list(account_id=...). Raising it brings back the chats left out for their size that are now under it, with their recent history (not on an account set to sync only new messages; on one set to 'selected chats' they come back waiting to be picked). Lowering it applies to chats found from now on and never switches a chat off. One chat can also be switched on alone with threads.update(synced=true). Changing it needs the channel's owner or a workspace owner/admin.
Inputs: account_id (required), large_group_threshold (required), in_workspace.
channels_update_profileAInspect
🪪 Update a connected channel's bot profile: display name, long description (the "What can this bot do?" card), short description, the / command menu, and the persistent menu button next to the input field.
Every field is optional — pass only what you want to change; any field you omit is left exactly as it is.
menu_button with type="web_app" is what puts a persistent button next to the input field that opens a Mini App page bound to this bot (pass the page's https URL as menu_button.url).
Two things this tool CANNOT set, because the Bot API does not expose them — both stay BotFather-only: the bot's AVATAR, and registering a NAMED Mini App (t.me/bot/appname). menu_button.web_app and any web_app message button work off a direct URL and need no such registration.
Inputs: channel_account_id (required), name, commands, description, +4 more.
clipboard_copyARead-onlyIdempotentInspect
Copy a secret (a Telegram bot token, an API key or a password someone sent in a chat, a browser identity's sign-in password) WITHOUT seeing it, to paste it into a tool in this or another workspace.
Returns a handle clip:<id>, never the value. Pass the handle where a tool's parameter says it takes one: channels.connect_telegram_bot(bot_token="clip:...", in_workspace=), browser.create_identity(password="clip:...", username=<the copy's username>, origin=<the copy's origin>, in_workspace=), channels.connect(channel='email', credentials={..., password="clip:..."}), integrations.set_auth(integration_id=, auth={type: 'bearer', token="clip:..."}). The server puts the secret in for that run and takes it out of the answer; any other parameter refuses a handle.
source, exactly one of:
{message_id, pattern?}: a token inside a message, by its numeric id from messages.read_history; pattern 'telegram_bot_token' (the default: BotFather's answer) or 'password' (a message that is the password alone, one word with no spaces) or 'api_key' (the one key in the message, with or without words around it: 16 to 512 characters, letters and digits; a UUID or hex id beside a key is not taken for it; a message with two keys is refused).
{channel_account_id}: a connected Telegram bot's token. A bot still connected in another workspace is refused there until it is disconnected: a bot has one webhook.
{identity_id}: the password a browser identity signs in with (browser.list_identities). The answer also names its origin and username (not secrets); the password is pasted only for that same origin.
Rules: owner or admin of the workspace the secret is in, and of the workspace it is pasted into; the handle is yours alone, lasts 15 minutes and is spent by the first run that succeeds with it.
Inputs: source (required), in_workspace.
collections_add_fileAInspect
Add a file to a knowledge collection.
The file must be uploaded and indexed first (files_upload + files_ingest). If the file was previously removed, it is re-enabled.
Inputs: file_id (required), collection_id (required), in_workspace.
collections_add_websiteAInspect
Add a website to a knowledge collection. Its pages are indexed in the background (sitemap first, else links on the same host) and kept current.
Pass path_prefix (e.g. '/help') to index only one section. Check progress with collections.list_websites.
Inputs: url (required), collection_id (required), max_pages, path_prefix, +2 more.
collections_assign_agentAInspect
Assign a knowledge collection to an AI agent.
Once assigned, the agent's knowledge.query will automatically scope RAG search to files in its assigned collections.
Inputs: agent_id (required), collection_id (required), in_workspace.
collections_createAInspect
Create a named knowledge collection.
Collections group files for RAG search. After creating, add files with collections.add_file and assign to agents with collections.assign_agent.
Inputs: name (required), description, in_workspace.
collections_deleteADestructiveIdempotentInspect
Delete a knowledge collection.
If the collection is assigned to agents, prompts, or channels, pass force=true to delete anyway. CASCADE removes all assignments automatically.
Inputs: collection_id (required), force, in_workspace.
collections_listARead-onlyIdempotentInspect
List all knowledge collections in the workspace.
Collections are named groups of files used for RAG search. Auto-created collections (per-agent, per-prompt) are hidden by default.
Inputs: in_workspace, include_inactive.
collections_list_filesARead-onlyIdempotentInspect
List all files in a knowledge collection with their indexing status and chunk counts. Each returned file has a file_id (integer) that can be passed to messages.send as attachments=[file_id] to send the file to a contact, or to files.read to read its text content.
Inputs: collection_id (required), in_workspace.
collections_list_websitesARead-onlyIdempotentInspect
List the websites of a knowledge collection with indexing status, pages indexed / found, last indexed time and last error.
Inputs: collection_id (required), in_workspace.
collections_refresh_websiteAInspect
Queue a website of a collection for re-indexing now. Unchanged pages are skipped.
Inputs: source_id (required), collection_id (required), in_workspace.
collections_remove_fileAInspect
Remove a file from a knowledge collection.
The file itself is not deleted — only the collection membership is removed.
Inputs: file_id (required), collection_id (required), in_workspace.
collections_remove_websiteADestructiveIdempotentInspect
Remove a website from a knowledge collection and DELETE every page file indexed from it. Cannot be undone.
Inputs: source_id (required), collection_id (required), in_workspace.
collections_unassign_agentAInspect
Remove a knowledge collection from an AI agent.
The collection and its files are not deleted — only the agent assignment is removed.
Inputs: agent_id (required), collection_id (required), in_workspace.
contacts_add_channelAInspect
🔗 Link a channel identity (email, phone, Telegram/WhatsApp handle) to an existing contact.
When to use:
User learns a contact's email or phone and wants to save it
Adding a second channel for an existing person
Email/phone are stamped as the contact's identity keys, so channel sync attaches the matching conversation to the same contact automatically. If the identity already belongs to a DIFFERENT contact, the call fails unless merge_if_linked=true — which IRREVERSIBLY merges the two contacts into one. Requires contact_id (entity_id) from contacts.find.
Inputs: value (required), channel (required), contact_id (required), display_name, +2 more.
contacts_capture_leadAInspect
📝 Save the current contact's details as a structured lead (contact + Contacts tab).
When to use:
In a website-chat OR voice-call conversation, as soon as the person has given at least ONE way to reach or identify them — a name, a phone number or an email (plus company / use case if mentioned) — e.g. when booking a demo or a class. A phone number with no name is still a lead: capture it, then ask for the name if you need it.
Call it once you have the details; then continue (e.g. share the booking link).
Creates/links a contact record and a lead entry in the workspace's lead inbox. Works in any conversation thread (website chat, voice call, DM).
Inputs: name, email, phone, company, +2 more.
contacts_discoverARead-onlyIdempotentInspect
Search for a contact on a live channel (Telegram, WhatsApp, etc.) before adding them. Use this to look up a person by username or phone number before calling contacts.sync. This is the right tool when asked to add or find a specific person by @username or phone (use contacts.sync afterwards to actually add them) — not group_discovery.
Inputs: query (required), channel (required), in_workspace.
contacts_findARead-onlyIdempotentInspect
👤 Search for contacts in your address book by name or username.
When to use:
User asks 'find contact X' or 'who is Y?'
User wants to know someone's username or ID
Before sending a message to verify contact exists
To get contact's channel reference for messaging
Examples: ❓ User: 'find contact named [name]' → contacts_search(query='[name]', limit=5)
❓ User: 'who is [full name]?' → contacts_search(query='[full name]', limit=1)
❓ User: 'search for @username' → contacts_search(query='username', limit=10)
A single first name ('Dima') also finds private chats where the owner wrote that name (match_type='addressed_in_outgoing', with evidence): people are often saved under a nickname but called by name in the chat.
Returns: name, username, channel, channel_ref, similarity_score, match_type. Plus:
entity_id: local DB key — pass to contacts.profile. Null for live-discovered contacts (skip contacts.profile for those).
telegram_user_id (when channel='telegram'): the Telegram user ID — pass to calls.make / messages.send. NOT entity_id.
Inputs: query (required), limit, channel, in_workspace.
contacts_groupsARead-onlyIdempotentInspect
👥 Every group and channel a person is in together with us: Telegram's own 'groups in common' list, asked from each Telegram account of the workspace.
Pass contact_id (entity_id from contacts.find), or telegram_user_id, or a Telegram @username. Each group has its title, kind (group/channel), members, which of our accounts is in it, and thread_id when we keep it as a chat (read it with messages.read_history).
Groups none of our accounts is in cannot be seen; Telegram does not show them.
Inputs: username, contact_id, in_workspace, telegram_user_id.
contacts_mergeAInspect
🧬 Merge two contacts into one: all channel identities, scores and summaries of the second contact move onto the first, and the second contact record is deleted.
When to use:
contacts.find shows the same person twice (e.g. a messenger contact and an email contact)
The user explicitly asks to merge two specific contacts
Both ids are entity_id values from contacts.find. The merge is recorded in Review Duplicates and can be undone there (undo is heuristic, not guaranteed). Never merge on name similarity alone — confirm the pair is really one person first.
Inputs: contact_id_keep (required), contact_id_merge (required), in_workspace.
contacts_profileARead-onlyIdempotentInspect
👤 Get full profile for a contact: all channel identities, notes, role, capabilities, birthday.
When to use:
After contacts.find to get complete info about a specific person
To see all channels a contact is reachable on
To read notes, role, or capabilities for a contact
Requires contact_id (entity_id) from contacts.find.
Inputs: contact_id (required), in_workspace.
contacts_researchARead-onlyIdempotentInspect
Research a person before outreach: returns a synthesized profile (current role, company, location, career history, education, LinkedIn/social URLs) plus a candidates array for disambiguating namesakes. Use to personalize a first touch or brief before a meeting. Does NOT return contact channels (email/phone/telegram) — use contacts.discover to add a reachable channel, or the LinkedIn URL from the result for a connection request.
Inputs: query (required), in_workspace.
contacts_syncAInspect
Add a discovered contact and open a conversation thread. Returns thread_id for the new conversation, plus entity_id — the canonical handle to pass as contacts.update's contact_id. Call contacts.discover first to verify the contact exists.
Inputs: channel (required), identifier (required), in_workspace, from_account_id.
contacts_updateAInspect
✏️ Update a contact's profile: name, notes, role, capabilities, birthday, preferred channel.
When to use:
User wants to add notes about a contact
User wants to set/update role or capabilities for a contact
User wants to rename a contact or update birthday
Requires contact_id — the entity_id returned by contacts.find or contacts.sync. At least one optional field must be provided.
Inputs: contact_id (required), role, notes, birthday_day, +6 more.
db_createAInspect
Provision this workspace's own database (one per workspace). Returns the connection string and password ONCE — relay them to the user immediately; they cannot be retrieved later. Errors if the workspace already has a database. Use db.schema / db.query / db.execute to work with it afterwards.
Inputs: in_workspace.
db_executeAInspect
Run SQL (CREATE TABLE / INSERT / UPDATE / DELETE / ALTER) against this workspace's own database. Use db.schema first to see what exists, and db.query to read.
Inputs: sql (required), in_workspace.
db_mirrorAInspect
Change this workspace's read-only platform-data mirror (views in schema dialogbrain_v1 of its own database, read with db.query). action=enable migrates the mirror schemas and takes a full snapshot (needs a database from db.create; admin/owner only). It is NOT idempotent: every call re-migrates and re-snapshots, so it is also how a failed mirror is recovered. The work runs in the background and the call returns at once with status 'snapshotting'; poll db.mirror_status until it is healthy. action=resync reconciles with the platform now (admin/owner, only when enabled and not snapshotting; also runs in the background). Example once healthy: db.query sql="SELECT id, title, last_message_preview FROM dialogbrain_v1.threads WHERE channel_account_id = AND last_message_is_outgoing = false".
Inputs: action (required), in_workspace.
db_mirror_statusARead-onlyIdempotentInspect
Show whether this workspace's read-only platform-data mirror is on: enabled, status, synced_at, last_error, and the views in schema dialogbrain_v1 that db.query can read (threads, messages, contacts, entities, channel_accounts, files, agents, calls, campaigns, campaign_items). Example once healthy: db.query sql="SELECT id, title, last_message_preview FROM dialogbrain_v1.threads WHERE channel_account_id = AND last_message_is_outgoing = false". Turn it on with db.mirror.
Inputs: in_workspace.
db_queryARead-onlyIdempotentInspect
Read from this workspace's own database. Pass either a natural-language question (e.g. 'how many records were added this week') or a raw SQL SELECT. Read-only; returns rows plus a chart hint.
Inputs: sql, question, in_workspace.
db_schemaARead-onlyIdempotentInspect
List the tables and columns of this workspace's own database. Call this before db.query or db.execute to learn what exists.
Inputs: in_workspace.
documents_createAInspect
Render a document (PDF / HTML / PPTX / DOCX) and save it to the workspace.
This tool has two input pipelines — pass exactly one of content_html or content_markdown.
Pipeline A — content_html (canonical for decks, proposals, designed pages)
You author full HTML+CSS. A baked-in design-system preamble ships first
(<style> with Inter/Manrope as data-URI fonts, CSS-variable palette tokens,
8px spacing scale, and pre-styled layout helpers); your markup and any of
your own <style> blocks land after the preamble so you can override
anything. Chromium renders the assembled document into a static PDF —
JavaScript is disabled and DNS is blackholed, so external font / image /
script fetches will fail by configuration.
Required when this pipeline is used:
title— human-readable, used for PDF metadata and the saved filename.content_html— the<body>and any custom<style>blocks. The renderer wraps this in<html>…</html>and injects the preamble + a canonical<meta charset>+<title>. Do NOT emit<script>,<iframe>,<object>,<embed>,<meta>,<link>,<base>,<form>, or event handlers — the sanitizer strips them.output_type—"pdf"or"html". ("pptx"and"docx"requirecontent_markdownsince they need structured markdown intermediates.)
Optional:
page_preset—"slide_16_9"(default for any deck),"a4"(default for flowing documents — used if omitted),"letter", or"none"(you declare your own@pagerule). For a web-styled page (dark background, full-bleed sections) use"none"and declare@page { margin: 0 }, set the background onhtmlas well asbody, and addprint-color-adjust: exact— the a4/letter presets keep 24mm paper margins, which paint as a white frame around dark designs.design_tokens— flat dict overriding the preamble's CSS variables. Whitelisted keys:brand_primary,accent,surface_dark(hex color),font_display,font_body(font name from ['Inter', 'Manrope', 'monospace', 'sans-serif', 'serif', 'system-ui', 'ui-monospace', 'ui-sans-serif', 'ui-serif']).language— BCP-47 tag (default"en"). Drives<html lang>.
Slide structure (page_preset="slide_16_9")
Each slide is <section class="slide …">…</section>. The base .slide
class is what sizes it to the viewport and forces the page break — do
not drop it. Composable variants (apply alongside .slide):
.slide-cover— gradient hero, big display title..slide-split— two equal columns, image + narrative..slide-stats— three-up KPI cards (use<div class="stat">with.stat-value+.stat-labelinside)..slide-quote— centered pull quote +<cite>attribution.
Layout helpers (work in any preset): .grid-2, .grid-3, .split,
.stack, .cluster, .callout, .muted, .kbd.
Speaker notes
<aside class="notes">…text…</aside> inside a <section class="slide">.
The sanitizer strips them from the rendered PDF and returns them as
slide_notes[] (parallel to slide order). Orphan notes outside any slide
are dropped with a warning.
Images
Only these src schemes resolve:
file:NNN— workspacefile_id.data:image/...;base64,...— inline.https://<host>where<host>∈DOCUMENTS_MEDIA_URL_ALLOWLIST. Other URLs are dropped and replaced with an HTML comment placeholder.
Pipeline B — content_markdown (invoice / contract only)
Required:
title,content_markdown,output_type.
Optional:
theme—"invoice"or"contract". Triggers the corresponding exemplar styling and (for invoices) the arithmetic validator that fail-closes on missing or mismatched totals.language— BCP-47 (default"en").
Delivery contract (CRITICAL)
After this tool returns file_id, deliver the file with
messages.send(attachments=[file_id], text="<short caption>"). Embedding
the file_id in a markdown link, sandbox: URL, or /api/files/<id>/download
text will render as plain text on the recipient's channel — the
attachments parameter is the only way the file actually attaches.
Exemplars
INVOICE (English):
Invoice INV-{YYYYMMDD-HHMMSS}
From: {Issuer Legal Name}, {Address}, {Tax ID} To: {Customer Name}, {Customer Address}, {Customer Tax ID} Issue date: {YYYY-MM-DD} Due date: {YYYY-MM-DD}
Description | Qty | Unit price | Total |
{Service 1} | 1 | 1500.00 | 1500.00 |
{Service 2} | 2 | 500.00 | 1000.00 |
Subtotal: USD 2500.00 Tax (20%): USD 500.00 Total: USD 3000.00
Payment: {bank details OR crypto wallet — never both}
INVOICE (Russian):
Счёт-фактура № INV-{YYYYMMDD-HHMMSS}
От: {Юридическое название организации}, {Адрес}, ИНН {Tax ID} Кому: {Название клиента}, {Адрес клиента}, ИНН {Tax ID} Дата: {YYYY-MM-DD} Срок оплаты: {YYYY-MM-DD}
Описание | Кол-во | Цена | Сумма |
{Услуга 1} | 1 | 1500.00 | 1500.00 |
{Услуга 2} | 2 | 500.00 | 1000.00 |
Подытог: USD 2500.00 НДС (20%): USD 500.00 Итого: USD 3000.00
Реквизиты: {банковские реквизиты ИЛИ криптокошелёк — не оба сразу}
CONTRACT (English):
Service Agreement
Between: {Provider Legal Name}, {Address} ("Provider") And: {Client Legal Name}, {Address} ("Client") Effective date: {YYYY-MM-DD}
1. Scope of services
{Concise description of what Provider agrees to deliver.}
2. Term
This Agreement begins on the Effective date and continues until {termination condition or end date}.
3. Compensation
Client pays Provider {amount and currency} according to {payment schedule}.
4. Confidentiality
Both parties agree to keep proprietary information of the other party confidential during and after the term of this Agreement.
5. Termination
Either party may terminate with {N} days' written notice.
6. Governing law
{Jurisdiction}.
Provider: ____________________ Client: ____________________ {Provider signatory name} {Client signatory name}
CONTRACT (Russian):
Договор оказания услуг
Между: {Юридическое название Исполнителя}, {Адрес} ("Исполнитель") И: {Юридическое название Заказчика}, {Адрес} ("Заказчик") Дата вступления в силу: {YYYY-MM-DD}
1. Предмет договора
{Краткое описание услуг, которые Исполнитель обязуется оказать.}
2. Срок действия
Договор вступает в силу с указанной даты и действует до {условие прекращения или дата окончания}.
3. Стоимость и порядок оплаты
Заказчик оплачивает услуги Исполнителя в размере {сумма и валюта} в порядке {график платежей}.
4. Конфиденциальность
Стороны обязуются сохранять конфиденциальность сведений, полученных в ходе исполнения настоящего Договора, в течение срока его действия и после его прекращения.
5. Расторжение
Любая из сторон вправе расторгнуть Договор, направив письменное уведомление не менее чем за {N} дней.
6. Применимое право
{Юрисдикция}.
Исполнитель: ____________________ Заказчик: ____________________ {ФИО подписанта Исполнителя} {ФИО подписанта Заказчика}
Inputs: title (required), output_type (required), theme, language, +5 more.
drive_appendAInspect
Add text at the end of a Google Doc in the registered Google Drive folders, as a new paragraph. For a spreadsheet use drive.append_rows. file is a Drive id or a pasted link.
Inputs: file (required), text (required), in_workspace.
drive_append_rowsAInspect
Add rows after the last row of a Google Sheet in the registered Google Drive folders. Values are entered as if typed (numbers, dates and formulas are recognised). For a Google Doc use drive.append.
Inputs: file (required), rows (required), sheet, in_workspace.
drive_create_docAInspect
Create a new Google Doc (or Sheet, with kind='sheet') inside a folder of a Shared Drive that is registered for this workspace, optionally with starting text. In a folder of someone's My Drive the file is made through the workspace's Google Workspace integration (it needs one connected) and moved into the folder.
Inputs: name (required), folder (required), kind, text, +1 more.
drive_foldersARead-onlyIdempotentInspect
Manage which Google Drive folders the Drive tools work in.
action='list' (default): the workspace's Drive address, the registered folders (with
reachable) andnot_added: what is shared with the address but not registered yet.action='add' + link: register a folder, file or Shared Drive the owner shared with the address (a pasted Drive link or id). The first one activates the connection.
action='remove' + link: unregister it (the share in Google stays). Not connected yet: channels.connect(channel='google_drive') creates the address to share with.
Inputs: link, action, in_workspace.
drive_importAInspect
Bring a file from the registered Google Drive folders into the workspace's files, where search, knowledge and files.read can use it. A Google Doc is stored as .docx, a Sheet as .xlsx, Slides as .pdf (up to 10 MB); any other file as it is. A file up to 50 MB is there when the call answers. A LARGER file (a video of several gigabytes) is copied in the background: the call answers at once with status: "importing" and the file_id; call drive.import with the same file again to see bytes_done, and when the copy is over it answers with the finished file (status: "ready"), whose download link files.info gives. Such a file is stored only: it is not searchable. Importing the same file again after it changed in Drive adds a new version of the same file_id; if it has not changed, nothing is downloaded (unchanged: true). A change made in Google Docs by someone else in the last few minutes may not be seen as a change yet; importing again a few minutes later picks it up. file is a Drive id or a pasted link.
Inputs: file (required), in_workspace.
drive_listARead-onlyIdempotentInspect
List the Google Drive folders registered for this workspace, or the contents of one folder inside them (id, name, type, modified, size, link). Omit folder to get the registered roots. folder is a Drive id or a pasted link. Page with page_token from the previous answer's next_page_token.
Inputs: kind, folder, page_token, in_workspace.
drive_readARead-onlyIdempotentInspect
Read a file from the registered Google Drive folders: a Google Doc or Slides file as text, a Sheet as rows of values (the first sheet, or range such as 'Sheet1'!A1:D20), or a plain-text file. Up to 2 MB of text. PDF and Office files are not read here: use drive.import to bring them into the workspace's files. file is a Drive id or a pasted link.
Inputs: file (required), range, in_workspace.
drive_renameBInspect
Change the name of a file or folder in the registered Google Drive folders. file is a Drive id or a pasted link.
Inputs: file (required), name (required), in_workspace.
drive_replaceAInspect
Replace every occurrence of a text in a Google Doc (all its tabs) in the registered Google Drive folders. Answers how many were replaced; 0 means the text was not found and nothing changed. To change a spreadsheet use drive.update_range.
Inputs: file (required), find (required), replace (required), match_case, +1 more.
drive_searchARead-onlyIdempotentInspect
Search the workspace's registered Google Drive folders by words in the name or the text. Only files inside a registered folder are returned. folder narrows the search to ONE registered root (pass the root's id or link); to look inside a sub-folder use drive.list on it. truncated: true means the search stopped before Google ran out of results: narrow the query. Search by text may not see changes made in the last few minutes (names are found at once); drive.read always reads the current text.
Inputs: query (required), limit, folder, in_workspace.
drive_update_rangeAInspect
Overwrite a range of a Google Sheet in the registered Google Drive folders, such as 'Sheet1'!B2:C3. Values are entered as if typed. To add rows at the end use drive.append_rows.
Inputs: file (required), range (required), values (required), in_workspace.
drive_uploadAInspect
Upload a file from this workspace's files (by file_id) into a Google Drive folder e.g. a client's receipt or contract. Returns the new file's id and link. The folder must be shared with the workspace's Drive address as Editor (drive.folders shows the address). A folder in a Shared Drive is written by the Drive address; a folder in a personal My Drive needs Google connected in the workspace's integrations (the file is then uploaded as that person and moved in). Files up to 100 MB. Uploading twice creates two files: after outcome_unknown check the folder first.
Inputs: folder (required), file_id (required), name, mime_type, +1 more.
feedback_saveAInspect
Save a behavioral rule, preference, or correction that should guide future agent behavior. Use this when the user gives explicit guidance like 'always reply in Russian', 'don't suggest meetings before 11am', or 'invoice link goes via email, not chat'. Structure the rule as: the rule itself, why it matters (if stated), and how to apply it. Scope: 'workspace' for org-wide rules, 'agent' for per-agent overrides, 'person' for per-contact preferences. Prefer feedback.save over notes.save for anything that's instructive rather than informational.
Inputs: key (required), rule (required), scope (required), why, +4 more.
files_complete_uploadAInspect
Finish an upload started with files_create_upload_url, after the bytes have been PUT to the upload_url.
Verifies the object actually landed and matches the size (and sha256, when one was declared), then makes the file usable: from here file_id works in messages_send, messages_send_email attachments, documents.create, and the rest.
A file over 100 MB is stored only: it can be sent, downloaded or passed on by file_id, but its contents are not indexed for search (indexed: false).
Returns: file_id, status, byte_size, mime_type, indexed (on the call that completes the upload).
Inputs: file_id (required), in_workspace.
files_create_upload_urlAInspect
Get a URL to upload a local file DIRECTLY to storage, without passing its bytes through this conversation.
Use this for any file you already have on disk — it is the only way to send one without spending tokens on its contents, and the only way to send anything above ~50 KB at all.
Three steps:
files_create_upload_url(filename, mime_type, size_bytes, sha256)
curl -X PUT --data-binary @/path/to/file <upload_url> (send every header from
headersverbatim)files_complete_upload(file_id) -> the file is ready
Pass sha256 when you can: if the workspace already holds that exact file you get its file_id back immediately with deduplicated=true and no upload at all.
Returns: file_id, upload_url, method, headers, expires_at.
Inputs: filename (required), size_bytes (required), title, sha256, +2 more.
files_deleteADestructiveIdempotentInspect
Permanently delete files from this workspace by their IDs (generated documents, uploads, screenshots, etc.).
IRREVERSIBLE: removes the DB record, detaches every reference (knowledge collections, thread pins, message attachments), and deletes the stored blob. There is no undo.
Use to clean up leftover / superseded generated files. Only files that belong to this workspace are touched; unknown or other-workspace ids are returned under not_found. Max 20 per call.
Inputs: file_ids (required), in_workspace.
files_get_base64ARead-onlyIdempotentInspect
Download one or more files server-side and return their content as base64-encoded strings. Use this to inspect images, PDFs, or any binary file attached to messages when you cannot access presigned S3 URLs directly. Supports up to 5 files per call, max 15 MB each. For large files batch in groups of 1-2 to avoid oversized responses. For images, pass variants to get processed copies instead of the original: rotate (clockwise) a photo taken sideways or upside down, enhance a faded print, or crop and enlarge a region with small text. Ask for both rotate 90 and 270 in one call when the text runs vertically and you cannot tell which way is up. An MCP client shows at most 5 images per response; the rest are listed, not shown.
Inputs: file_ids (required), variants, in_workspace.
files_infoARead-onlyIdempotentInspect
Get metadata and download URLs for files by their IDs.
When to use:
After messages_read_history returns attachment_file_ids
To get a presigned download URL to read a received file
Returns: filename, mime_type, byte_size, download_url (1-hour presigned URL).
Inputs: file_ids (required), in_workspace.
files_ingestAInspect
Save and index a file into the knowledge base. Use this when the user asks to save, store, or remember a document. The file will be processed (OCR if needed) and indexed for future search.
Inputs: file_id (required), tags, title, thread_id, +2 more.
files_readARead-onlyIdempotentInspect
Read text content of an attached file. Works for: .txt, .md, .json, code files, and documents (PDF, .docx, .xlsx, .pptx, .odt, .rtf); a document still being indexed is awaited briefly. DO NOT call on binary files — for IMAGES use files.get_base64, for AUDIO/VIDEO use files.transcribe (transcript + key frames). Calling on a binary mime-type returns an error — saves you a turn to read the routing hint before deciding.
Inputs: file_id (required), encoding, max_chars, summarize, +1 more.
files_transcribeARead-onlyIdempotentInspect
Understand an AUDIO or VIDEO file (voice note, recording, clip): returns the spoken text as a transcript and, for video, a few evenly spaced key frames as images, so you can describe what the video shows and says. Max duration 30 minutes (longer files are refused). The transcript is cached, a second call is free. If partial is true the transcript covers only the beginning of the file. For images use files.get_base64, for text and documents files.read.
Inputs: file_id (required), max_chars, max_frames, in_workspace.
files_uploadAInspect
Upload a file to DialogBrain and get a file_id for use in messages_send.
When to use:
User wants to send a file/image to a contact
Before calling messages_send with an attachment
For a file that already exists on disk, use files_create_upload_url instead: content here travels through the conversation twice (once read, once written back), so it is only sensible up to about 50 KB. source_url is fine at any size — the fetch happens server-side.
Returns: file_id (integer) to pass to messages_send attachments parameter.
Inputs: title, content, filename, mime_type, +2 more.
folders_createAInspect
📁 Create a new inbox folder to organize threads.
When to use:
User wants to create a folder to group related conversations
User wants to organize threads by topic, project, or contact type
After creating a folder, use threads.update with folder_id to move threads into it.
Inputs: name (required), icon, in_workspace.
folders_deleteADestructiveIdempotentInspect
🗑️ Delete an inbox folder. Threads inside become unfiled (not deleted).
When to use:
User wants to remove a folder they no longer need
User wants to clean up their inbox organization
Threads inside the folder are NOT deleted — they simply move back to the inbox.
Inputs: folder_id (required), in_workspace.
group_addAInspect
Add a specific group to your discovery list by @username or invite link (Telegram t.me/..., WhatsApp chat.whatsapp.com/...). Nothing is joined yet: run group.join with the returned id to join and start syncing.
Groups and channels only — this does NOT add an individual person/contact. To add a person by @username (e.g. a customer or lead), use contacts.discover then contacts.sync instead.
When to use:
You already know the group's @username or invite link
Adding a known group without searching
Returns: group metadata including id, title, member_count.
Inputs: link (required), channel (required), account_id, in_workspace.
group_add_memberAInspect
Add a member to an existing group on Telegram or WhatsApp.
What this does:
Adds the specified member to the group
Resolves the member by username, phone number, or JID
Reports if the member is already in the group
Returns: success, chat_id, member, already_member. On WhatsApp a person whose privacy settings forbid being added comes back success=false, error_type privacy, with invite_link to send them instead.
Inputs: member (required), channel (required), chat_id (required), account_id, +1 more.
group_adminsARead-onlyIdempotentInspect
List administrators of a group on Telegram (or other channels).
Returns admin metadata including:
Admin rank (creator or admin)
Username and real name
Can they post (for restricted groups)
Bot status
Use this to understand group leadership before outreach or evaluation. Returns: group_id, title, admins list, total admin count.
Inputs: group_id (required), account_id, in_workspace.
group_createAInspect
Create a new group on a channel: a Telegram group, a WhatsApp group, or a Discord SERVER (a community with text channels inside; Discord calls it a guild) owned by the connected account. Returns the new group's chat ID and invite link.
What this does:
Creates a new group with the specified title
Returns chat_id, invite_link, and channel_ref for further operations
Optionally registers the group in your inbox for monitoring
Discord: also makes the text
channelsasked for (beside #general) and one permanent invite link; chat_id is the server id, channel_ref the #general thread,channelslists every text channel with its thread_ref (messages.send posts into one). People cannot be added to a server: send them invite_link. A step Discord refused after the server was made (a channel, the invite) is inproblems; the server exists. Nothing is hosted by DialogBrain: the server lives at Discord.Telegram: group_type='channel' makes a BROADCAST CHANNEL; add username='' to make it public (public_link in the answer). A Telegram broadcast channel: group.create(channel='telegram', group_type='channel', title=..., username=...); then write into it with messages.send(thread_id=). Steps refused after the chat was made (username, invite link) are in
problems; the chat exists.
Returns: success, chat_id, channel_ref, title, thread_id, invite_link, public_link, problems.
Inputs: title (required), channel (required), about, channels, +6 more.
group_get_invite_linkAInspect
Get an invite link for an existing group (Telegram, WhatsApp) or Discord server.
What this does:
Telegram: mints a FRESH link (e.g. t.me/+...) on every call; previously issued links stay valid
WhatsApp: returns the group's EXISTING link, the same one each time. Do not describe it to anyone as newly issued
Discord: mints a permanent discord.gg/... link into a server the account is in (chat_id: the server id, a channel id, or a channel's thread ref); the account needs Create Invite there
Requires the connected account to be the group's owner or an admin with invite rights
When to use:
A member can't be added directly because their privacy settings block invites (group.add_member fails with a privacy error) — send them this link instead
Onboarding people to a private group
Returns: success, chat_id, invite_link.
Inputs: channel (required), chat_id (required), account_id, in_workspace.
group_joinAInspect
Join a group and start syncing its messages to your inbox. The group must be in your discovery list (use group.search or group.add first).
What this does:
Joins the group on Telegram or WhatsApp (WhatsApp: personal QR-paired accounts, by the invite link given to group.add; a group whose admins must approve members is only requested, not joined)
Creates a thread in your inbox for syncing messages
Optionally enables AI auto-reply drafts
Returns: success, thread_id, auto_reply_enabled.
Inputs: group_id (required), account_id, in_workspace, enable_auto_reply.
group_leaveAInspect
Leave a group and stop syncing its messages to your inbox.
Name the group with ONE of:
thread_id: the DialogBrain conversation id of the group chat (primary way)
group_id: the discovered-group id from group.list Platform chat ids (Telegram -100...) are NOT accepted. If both are given they must be the same group.
The leave always runs as one concrete account: account_id if given, else the account the conversation / discovered group belongs to. There is no fallback to another account.
What this does:
Leaves the group on Telegram (or other channel)
Stops syncing new messages
Disables any AI auto-reply drafts for this group
Keeps a discovered group in the discovery list (not deleted)
Returns: success, thread_id.
Inputs: group_id, thread_id, account_id, in_workspace.
group_listARead-onlyIdempotentInspect
List groups in this workspace's DISCOVERY/SCORING list (the discovered_group table).
⚠️ This is NOT your messageable inbox. It is a subset used for discovery + quality scoring. Absence here does NOT mean a chat isn't joined or can't be messaged. Each row includes thread_channel_ref — the ref a synced thread carries — so you can match rows against search_threads results. To get a thread_id you can send to, use search_threads.
Lifecycle values:
discovered: found but not yet evaluated
bookmarked: saved for later
monitored: joined and actively syncing messages
dismissed: hidden
By default, dismissed groups are excluded. Returns: id, title, member_count, lifecycle, scan_status, overall_score, is_member, can_post, my_rank.
Inputs: limit, offset, channel, lifecycle, +3 more.
group_moderateAInspect
Run ONE moderation action on a group: a Telegram bot group, a Telegram group or channel the connected Telegram ACCOUNT created, a Discord SERVER the connected account administers, or a WhatsApp group the connected number is a member of.
Telegram account actions (channel='telegram'; the person's own account, not a bot; chat_id = the chat id (-100...), its telegram: ref or our thread id; params.account_id names the account when the workspace has several and the chat has no conversation in the inbox; only an account connected in THIS workspace, never one shared in; the caller must be a workspace owner or admin):
delete: the OWNER (creator) deletes the group, supergroup or broadcast channel for everyone. Irreversible: params.confirm_name must be the chat's exact current title as Telegram has it (ask the person; a mismatch is refused and names the title Telegram has). The inbox conversation is archived, its messages kept. error_type outcome_unknown means it may have been deleted: check before retrying
history_visible: params: visible (true/false). Whether NEW members see the messages sent before they joined. Supergroups only (a basic group has no such switch; a broadcast channel always shows its history); the account must be an admin allowed to change the info
topics: params: enabled (true/false), optional layout ('list', the default, or 'tabs'). Switches a supergroup's topics (forum mode) on or off; a basic group or a broadcast channel is refused
set_title: params: title. set_description: params: description ("" clears it). Both need those admin rights too; safe to repeat
Discord actions (channel='discord'; chat_id = the server id, a channel id, a channel's thread ref or our thread id; params.account_id names the account when the workspace has several and chat_id does not; only an account connected in THIS workspace, never one shared in):
community: switch Community mode on (rules screening and announcement channels become possible). params: rules_channel (default #rules), updates_channel (where Discord posts its notices to the team; default a hidden #moderator-only, made when missing), announcement_channel (the one turned into an announcement channel, default #announcements; false for none); channels by id, ref or #name. Discord's conditions change server defaults (verification level at least low, media filter for everyone, notifications to mentions only): the answer lists them in settings_changed; tell the person
icon: params: file_id of a PNG/JPEG/GIF/WebP in this workspace
set_title: params: title. set_description: params: description (community servers only)
role: params: name, permissions (names such as view_channel, send_messages, manage_messages, kick_members, moderate_members, administrator, or Discord's bitfield as a number), color (#rrggbb), hoist, mentionable. Not idempotent: a retry makes a second role
slowmode: params: channel (id, ref or #name) and seconds (0 to 21600; 0 turns it off), both required
delete: the OWNER deletes the server. Irreversible: params.confirm_name must be the server's exact name (ask the person); with two-factor on, Discord wants params.mfa_code, the current authenticator code the person reads out (redacted from every log and trace) Every Discord action needs the caller to be a workspace owner or admin. Discord refusals are worded: no_permission (not an admin), mfa_required, not_community, bad_request (a value Discord rejected).
WhatsApp actions (channel='whatsapp'; chat_id = the group JID (...@g.us), its whatsapp: ref or our thread id; only the workspace's own numbers, not one shared in; the number that is in the group is used):
set_title: params: title (at most 100 characters). Any member may rename unless the group's admins locked its info; WhatsApp's refusal is passed through. Needs edit rights in the workspace. When two of the workspace's numbers are in the group, params.account_id is required. The inbox thread takes the new name.
Telegram BOT actions (channel='telegram_bot'):
invite_link: mint a fresh invite link; older links stay valid. Optional params: name, member_limit, expire_date, creates_join_request
revoke_invite_link: params: invite_link
admins: list administrators (user_id, username, name, status)
member_count: how many members the group has
member_status: one member's status. params: user_id
promote / demote: params: user_id, optional rights {can_*: bool}
ban / unban: params: user_id, optional revoke_messages
mute / unmute: params: user_id, optional until_date (unix ts)
pin / unpin: params: message_id (omit on unpin for the latest), optional silent
set_title: params: title
set_description: params: description
⚠️ A Telegram BOT cannot add a member or create a group — the Bot API has no method for either. To bring someone in, mint an invite_link and send it to them.
Telegram rules that surprise callers (all verified against a live group):
A bot may only promote/demote admins IT promoted. Check
can_be_editedin member_status first: false means demote will answer 'not enough rights', and that is Telegram, not a failure on our side.promote additionally needs the bot to hold can_promote_members in the group; plain admin rights are not enough.
After unmute the status stays 'restricted' while every can_send_* is true. That is Telegram labelling anyone who carries an explicit permission set — it does NOT mean still muted. Read the permissions, not the status.
unban lifts the ban but does not bring the person back: the status becomes 'left' and they must rejoin.
Returns: success plus the action's own keys (invite_link, admins, member_count, status) and result, Telegram's own payload.
Inputs: action (required), channel (required), chat_id (required), params, +1 more.
group_preview_messagesARead-onlyIdempotentInspect
Read recent public messages from a group without joining it. Only works for groups where can_preview_history=true.
Use this to manually evaluate message quality before deciding to join. For an automated quality score, use group.scan instead.
Returns: list of recent messages with sender identity (username, name, admin flag), text (150-char previews; pass full_text=true for untruncated), date, is_reply.
Inputs: group_id (required), limit, full_text, account_id, +1 more.
group_promote_adminAInspect
Promote a member to admin in an existing group on Telegram or WhatsApp.
What this does:
Gives the specified member admin status in the group
On Telegram, this grants visibility of all group messages (even if not a bot)
Defaults to minimal/empty rights; specify custom rights if needed
Returns: success, chat_id, member.
Inputs: member (required), channel (required), chat_id (required), rights, +2 more.
group_scanAInspect
Scan a group to evaluate its quality before joining. Fetches recent messages, analyzes activity, spam, and engagement, then returns a quality score and plain-English verdict.
When to use:
After finding groups with group.search
Before deciding which groups to join
Returns: overall_score (0-1), is_disqualified, disqualify_reasons, individual scores, and a verdict string.
Inputs: group_id (required), account_id, in_workspace.
group_searchAInspect
Search for public groups or channels by topic on Telegram (or other channels). Returns matching groups with title, member count, and whether messages can be previewed.
Finds public groups/channels by topic — NOT individual people. To find or add a specific person by @username, use contacts.discover / contacts.find instead.
When to use:
Finding groups related to a topic or niche
Building a list of groups for outreach or monitoring
After searching, use group.scan to evaluate quality before joining.
Inputs: channel (required), keywords (required), limit, account_id, +1 more.
images_generateAInspect
Generates a PNG image from a text prompt using Gemini 2.5 Flash Image. Returns a file_id consumable by messages.send(attachments=[...]) and other file-aware tools. Supports up to 12 reference image file_ids for subject-consistent edits and composition (use file IDs from the [ATTACHMENTS] block, files.search, or search.files). Latency: ~8-10s per image. Output: 1024×1024 PNG.
Inputs: prompt (required), aspect_ratio, in_workspace, reference_file_ids.
images_searchARead-onlyIdempotentInspect
Searches images in this workspace by visual content using vector embeddings (Voyage multimodal-3). Pass a text description; returns ranked file_ids with cosine scores and presigned download URLs. Up to 50 results.
Inputs: query (required), limit, mime_type, in_workspace, +2 more.
instagram_list_mediaARead-onlyIdempotentInspect
List photos and Reels on the connected Instagram Business/Creator account. Returns id, caption, media_type, permalink, thumbnail_url, timestamp. With stories=true it lists the account's stories that are live now (Instagram keeps a story 24 hours): id, media_type, media_url, permalink, thumbnail_url, timestamp. Posts and Reels never include stories, so this is how to check whether a story went out: a story has no caption, so find yours by its timestamp (the time of the publish) and its media_type.
Inputs: after, limit, stories, account_id, +1 more.
instagram_list_tagged_mediaARead-onlyIdempotentInspect
List posts in which OTHER Instagram users tagged the connected Business/Creator account (tagged photos, Reels and carousels, including collaborative posts). instagram.list_media shows only the account's own posts, so a contest's entries tagging the brand or a partner's collab post are found here. Returns id, caption, media_type, permalink, media_url, thumbnail_url, timestamp, username of the author, like_count, comments_count.
Inputs: after, limit, account_id, in_workspace.
instagram_update_mediaADestructiveInspect
Update the caption of a published Instagram photo or Reel. Only caption is editable after publish (Instagram limitation).
Inputs: caption (required), media_id (required), account_id, in_workspace.
integrations_add_endpointsAInspect
Add one or more API endpoints to an HTTP-API integration as callable tools, merged additively into the integration for base_url (created if none exists). Each endpoint becomes a tool with params + request/response schemas inferred from the samples you pass; give an endpoint a description (what the agent reads) and a request_schema (exact JSON body schema) to set them yourself. When CREATING a new integration, provide auth: either identity (saved Browser Identity name/id) for cookie-session APIs, OR an auth block for token/header APIs, e.g. {type:'bearer', token:'...'} or {type:'api_key', token:'...', header_name:'X-API-Key'}. Updates keep the existing auth unless a new auth is passed. Returns the new tool count and names. Refresh the tools list afterwards to use them.
Inputs: base_url (required), endpoints (required), auth, name, +6 more.
integrations_capture_sessionAInspect
Restore an expired integration session by capturing the LIVE auth of an open browser page — works for COOKIE sessions (browser_identity) AND TOKEN/HEADER sessions (bearer / api_key / custom_headers, e.g. Devise access-token/client/uid). First call browser_open(url, identity_name) for the integration's site (the page must be logged in AND have called its API), then pass that page_id here with integration_id or base_url. For cookie sessions it captures the full storage_state (incl httpOnly cookies page JS can't read) into the bound identity; for token sessions it captures the auth headers the page sends to the API host and binds them. Re-connects the integration. The captured secret never leaves the server (returns counts only). Generic — any site, any auth scheme, no local Playwright.
Inputs: page_id (required), base_url, in_workspace, integration_id.
integrations_connect_linkAInspect
Create a one-time link that lets a person WITHOUT a DialogBrain account connect their own Google account to this workspace's Google integration (for example so the workspace can create files in that person's Google Drive). The person opens the link, reads who is asking, signs in with Google and the access is stored on the integration; the link then stops working. If a Google account is already connected, the new one replaces it. Returns url and expires_at (default 24 hours, at most 7 days). Send the link only to the person it is for. For a person's own client with the admin role; an agent cannot call it.
Inputs: integration_id (required), expires_in, in_workspace.
integrations_execute_toolAInspect
Run a connected integration tool by its ext_ slug (from integrations_search_tools) with the given arguments. Discovers + executes WITHOUT changing the tool list — so the catalog can grow without an MCP reload.
Inputs: arguments (required), tool_name (required), in_workspace.
integrations_get_endpointsARead-onlyIdempotentInspect
List every endpoint (operationId, method, path, and description when it has one) registered on an HTTP-API integration. Identify it by integration_id or base_url. Use this to review what tools exist before integrations.remove_endpoints or add_endpoints.
Inputs: base_url, in_workspace, integration_id.
integrations_get_tool_schemaARead-onlyInspect
Get the full input schema(s) for external tool slugs returned by integrations_search_tools, before executing them.
Inputs: tool_names (required), in_workspace.
integrations_listARead-onlyIdempotentInspect
List the workspace's external integrations (HTTP-API + MCP), each with its id, provider name, base_url, transport, status, and registered tool count. Use before integrations.add_endpoints to find the integration id / base_url.
Inputs: in_workspace.
integrations_remove_endpointsAInspect
Remove endpoints (tools) from an HTTP-API integration — e.g. junk paths like static assets, /socket.io, or SPA routes that aren't real API calls. Identify the integration by integration_id or base_url, and the endpoints to drop by operation_ids (e.g. getSocketIo) and/or paths (e.g. /socket.io/). Re-registers the catalog so the removed tools disappear. Returns removed + remaining counts.
Inputs: paths, base_url, in_workspace, operation_ids, +1 more.
integrations_search_toolsARead-onlyInspect
Search your connected integrations for tools by intent. Returns matching tool slugs (ext_) + summaries + required params. Then call integrations_get_tool_schema for full input schemas, and integrations_execute_tool to run one. Use this instead of guessing tool names for external actions.
Inputs: query (required), limit, in_workspace.
integrations_set_authAInspect
Set or update the authentication on an HTTP-API integration, generically. Identify it by integration_id or base_url. Pass auth = {type: bearer|api_key|basic|query|custom_headers|browser_identity|none, ...}: bearer/basic → {token}; api_key → {token, header_name?} (key rides in a HEADER); query → {token, param_name} (key rides in the QUERY STRING, e.g. param_name='api_key' → ?api_key=…); custom_headers → {headers:{name:value,...}}; browser_identity → {identity_id|identity_name, extract}; an extract block that echoes a percent-encoded cookie (Laravel's XSRF-TOKEN; a 419 means this) takes value_format:'urlencoded'. Token values are encrypted; nothing is stored in cleartext. To only refresh a browser_identity session, OMIT auth and pass cookies (and/or local_storage) — they are merged into the bound identity without touching its config. (oauth2 / service_account use the REST settings flow.)
Inputs: auth, cookies, base_url, in_workspace, +2 more.
integrations_set_realtimeAInspect
Add, replace or remove the realtime (websocket) connector of an HTTP-API integration, leaving the rest of its configuration and its credentials untouched. realtime is the whole block: {protocol: 'actioncable' | 'raw_json', ws_url, auth: {type, placement: 'header' | 'query', query_param, token_mint: {method, path, token_path}}, channel_template, actions: [{name, description, is_write, input_schema, frame}]}. Its actions become tools of the integration. To remove the connector pass remove=true and no block. Needs the admin or owner role.
Inputs: integration_id (required), remove, realtime, in_workspace.
integrations_set_thread_contextAInspect
Turn signed thread context on or off for an HTTP-API integration. When on, each call an agent makes to it from inside a conversation carries the conversation's DialogBrain thread id, a timestamp and an HMAC-SHA256 signature made with secret (headers X-DialogBrain-Thread-Id, X-DialogBrain-Timestamp, X-DialogBrain-Context-Signature), so the integration can trust which chat the call comes from. secret (32-128 characters, generated by the integration) is required to turn it on, stored encrypted and never shown back. For a person's own client (API key or MCP) with the admin role; an agent cannot call it.
Inputs: enabled (required), integration_id (required), secret, in_workspace.
integrations_sync_knowledgeAInspect
Refresh a knowledge collection from an integration's endpoints, for content too large to return in a tool response (a 300KB+ catalogue an agent could never fit in one call). Pass sources + collection to configure and run in one step — they are stored on the integration, so later runs need only integration_id. Every run is a FULL refresh; a source whose rendered text is unchanged is skipped (reported unchanged) rather than re-uploaded. Returns a per-source report: created / updated / unchanged / no_records / error.
Inputs: integration_id (required), force, sources, collection, +2 more.
job_completeAInspect
Mark the job as completed. This sanitizes PII from the context and records a completion summary. Use when all tasks in the job are done.
Inputs: job_id, summary, trace_id, in_workspace.
job_escalateAInspect
Escalate the job to a human. Use when you cannot resolve an issue, someone is not responding, or a situation requires human judgment.
Inputs: reason (required), job_id, trace_id, in_workspace.
job_read_contextCInspect
Read the current job context. Returns the full state of your active job including assignments, escalations, and any data you previously stored.
Inputs: job_id, trace_id, in_workspace.
job_update_contextAInspect
Update the job context by merging new data. Existing keys are preserved unless explicitly overwritten. Use this to record progress, update assignment statuses, or store intermediate results.
Inputs: updates (required), job_id, trace_id, in_workspace.
kg_find_entityARead-onlyIdempotentInspect
Find an entity by name in the Knowledge Graph.
USE WHEN user mentions a person, project, company by name and you need:
To resolve a name to entity_id for subsequent queries
'Кто работает над X?' → find X first
'Расскажи про Y' → find Y first
RETURNS entity_id for use in kg.get_relationships or kg.explore. ALWAYS use this as the FIRST step in KG query chains.
Inputs: name (required), limit, entity_type, in_workspace.
kg_get_relationshipsARead-onlyIdempotentInspect
Get relationships for a specific entity from Knowledge Graph.
USE WHEN:
'Кто работает над X?' - filter by works_on
'С кем общался Y?' - filter by discussed_with
'Кто из компании Z?' - filter by member_of
'Что связано с W?' - no filter, get all
REQUIRES: entity_id from previous kg.find_entity step. Use: {{step_N.entity_id}} where N is the find_entity step number.
Inputs: entity_id (required), limit, direction, in_workspace, +1 more.
knowledge_gaps_answerAInspect
Answer a question from knowledge.gaps_list. Your title and answer are published as a knowledge article the asking agents will find next time; nothing is sent to the customer. Answering again replaces the previous answer.
Inputs: answer (required), gap_id (required), question (required), in_workspace.
knowledge_gaps_listARead-onlyIdempotentInspect
List the questions agents could not answer from the knowledge base, merged by meaning and ordered by how often they were asked. Answer one with knowledge.gaps_answer.
Inputs: limit, status, agent_id, in_workspace.
knowledge_queryARead-onlyIdempotentInspect
Answer questions using knowledge base (uploaded documents, handbooks, files).
Use for QUESTIONS that need an answer synthesized from documents or messages. Returns an evidence pack with source citations, KG entities, and extracted numbers.
Modes:
'auto' (default): Smart routing — works for most questions
'rag': Semantic search across documents & messages
'entity': Entity-centric queries (e.g., 'Tell me about [entity]')
'relationship': Two-entity queries (e.g., 'How is [entity A] related to [entity B]?')
Examples:
'What did we discuss about the budget?' → knowledge.query
'Tell me about [entity]' → knowledge.query mode=entity
'How is [A] related to [B]?' → knowledge.query mode=relationship
NOT for finding/listing files, threads, or links — use search.files / search.threads / search.links for that.
Inputs: question (required), date_to, file_ids, date_from, +5 more.
linkedin_add_commentADestructiveInspect
Add a comment to a LinkedIn post. Use post_id from search results or thread data. Not available in this version.
Inputs: text (required), post_id (required), in_workspace.
linkedin_get_companyBRead-onlyIdempotentInspect
Get a LinkedIn company profile by company ID or vanity name. Returns company name, description, industry, size, and other details. Not available in this version.
Inputs: identifier (required), in_workspace.
linkedin_get_profileARead-onlyIdempotentInspect
Get a LinkedIn user profile by ID, public identifier (vanity name), or profile URL. Returns name, headline, location, and other profile information.
Inputs: identifier (required), in_workspace, from_account_id.
linkedin_inviteADestructiveInspect
Send a connection invitation to a LinkedIn user. Optionally include a personalized message (max 300 characters). Answers invited, member_urn, with_note and LinkedIn's invitation_urn when it names one; an invitation already pending is refused as already_invited; an account that reached LinkedIn's invitation limit is refused as rate_limited (do not retry today).
Inputs: member_urn (required), message, in_workspace, from_account_id.
linkedin_list_connectionsARead-onlyIdempotentInspect
List your LinkedIn connections, newest first (LinkedIn's "recently added"), each with first and last name, headline, public profile id and URL, and when you connected. Pass since (an ISO date) to get only the people who connected from then on, e.g. this week's new connections. names_included=false means LinkedIn answered without names.
Inputs: limit, since, cursor, in_workspace, +1 more.
linkedin_list_invitations_sentARead-onlyIdempotentInspect
List your pending sent connection invitations on LinkedIn.
Inputs: limit, cursor, in_workspace, from_account_id.
linkedin_list_reactionsBRead-onlyIdempotentInspect
List all reactions (likes, celebrates, etc.) on a specific LinkedIn post. Not available in this version.
Inputs: post_id (required), limit, in_workspace.
linkedin_raw_requestBRead-onlyIdempotentInspect
Send an arbitrary LinkedIn API request. Only GET and POST methods are allowed. WARNING: This bypasses structured rate limiting and can perform destructive actions. Use this only when no other LinkedIn tool covers the needed functionality. Not available in this version.
Inputs: request_url (required), body, method, in_workspace, +1 more.
linkedin_searchARead-onlyIdempotentInspect
Search LinkedIn for people (other categories are not available yet). Returns name, headline, location, connection degree, profile URL and member_urn (what linkedin.invite takes), up to 50 per page; pass the answer's next_page as cursor for more. Put a role, company or place in keywords (e.g. 'procurement manager Bangkok'); location and industry take LinkedIn's numeric ids only, network_distance F/S/O, role filters by title.
Inputs: api, role, limit, cursor, +7 more.
linkedin_search_filtersARead-onlyIdempotentInspect
Get LinkedIn search filter parameter IDs. LinkedIn uses internal IDs instead of text for search filters (location, industry, etc.). Call this before linkedin.search to resolve filter keywords to their LinkedIn parameter IDs. Not available in this version.
Inputs: type (required), keywords (required), limit, in_workspace.
linkedin_update_profileBInspect
Update the authenticated user's own LinkedIn profile. Supports adding/editing experience entries (role, company, skills, dates). Also supports updating location. Headline, summary, education are NOT supported by the API. Not available in this version.
Inputs: location, experience, in_workspace.
linkedin_withdraw_invitationADestructiveIdempotentInspect
Withdraw PENDING sent connection invitations by invitation_urn (up to 25 per call; call again for more). IRREVERSIBLE: a withdrawn invitation cannot be restored, and LinkedIn does not let you invite the same person again for a while (it says up to 3 weeks). First list with linkedin.list_invitations_sent and pick by sent_at (its invitation_urn values are what this takes). Each withdrawal is spaced 1-4 seconds, so a full batch takes a minute or two. Answers a result per urn: withdrawn, not_found (not pending any more), lookup_incomplete (the sent list could not be read to its end; may still be pending), failed (with LinkedIn's http_status/code) or not_attempted (the batch stopped on an expired session or a rate limit; see stopped; the call then answers an error with the per-urn data), plus totals. Nothing is retried.
Inputs: in_workspace, invitation_urn, from_account_id, invitation_urns.
meetings_createAInspect
Create an online video meeting on the workspace's own Zoom account and get its join link. Needs the workspace's Zoom connected (channels.connect with channel='zoom' gives the sign-in link); without it the tool refuses. Anyone with the link enters directly (no waiting room). Give start_time for a scheduled meeting, or omit it for one that can be joined right now. This does NOT put anything in a calendar or invite anyone: send the join_url to the participants, or use calendar.create_event with online_meeting_provider='zoom' to also book it.
Inputs: topic (required), agenda, provider, timezone, +4 more.
messages_deleteADestructiveIdempotentInspect
Delete a message from a thread. Supports Telegram, WhatsApp, and other connected channels. Note: Some channels have time limits on message deletion. On an IMAP/SMTP e-mail mailbox the message is MOVED TO THE MAILBOX'S TRASH folder (never erased) and then removed from the inbox here.
Inputs: thread_id (required), message_id (required), in_workspace.
messages_editAInspect
Edit the text of a message you already sent, in place. Supported on Telegram, WhatsApp, LiveChat, Max.ru, LINE, WeChat and similar channels; NOT supported on Gmail, Instagram, or LinkedIn (their platforms forbid editing) — those return an explicit error. Note: channels impose their own limits (own messages only, edit time windows such as ~48h on Telegram / ~15min on WhatsApp).
Get the message_id from messages.read_history (each row's id).
To REPLACE the photo or file of a message that already has one, pass attachment_file_id (a DialogBrain file id, as messages.send takes in attachments); new_text then becomes the new caption and may be omitted to keep the caption. Supported on Telegram (user accounts and bots) only; a message without media is refused.
Inputs: thread_id (required), message_id (required), mentions, new_text, +2 more.
messages_forwardADestructiveInspect
Forward a message from one thread to another. Supports native Telegram forwarding (preserves original sender attribution) and text-based forwarding for cross-channel scenarios.
Inputs: source_thread_id (required), source_message_id (required), in_workspace, dest_thread_id, +1 more.
messages_moveAInspect
Move an e-mail message to another folder of the real mailbox (the provider's own Archive, Inbox or a folder by its exact name). Works on mailboxes connected over IMAP/SMTP (e.g. Yahoo); other channels, and Gmail accounts connected read-only, refuse. To delete a message use messages.delete (it moves to the Trash).
Inputs: folder (required), message_id (required), in_workspace.
messages_press_buttonADestructiveInspect
Press a button under a message in a Telegram chat, as the connected Telegram account: the inline menus bots such as @BotFather reply with. Name the button by its exact label.
Returns the message as it looks after the press (bots usually edit it into the next menu) and anything the bot sent after it, each with its own buttons and a message_id you can pass back to press the next one.
Mini Apps: a button of kind web_app is opened in the workspace's hosted browser, signed in as the connected account; the result is {opened, page_id, title, host} and you continue with browser.snapshot, browser.click and browser.type on that page_id. Some settings of a bot exist only in its Mini App (for example @BotFather's Bot Settings): in that bot's thread pass open_main_app=true, with no message_id or button_text, to open the bot's main app (the Open button beside the input). The address of the app is a login and is never shown.
Refused: buttons that need the account's cloud password (the owner confirms those in the Telegram app), and buttons that share a phone number or location or pay. A link button is not pressed; its URL is returned. A label that matches no button returns the buttons that exist.
Get the message_id from messages.read_history. Telegram user accounts only; a bot account cannot press buttons.
Inputs: thread_id (required), message_id, button_text, in_workspace, +1 more.
messages_reactADestructiveInspect
Put an emoji reaction (👍, ❤️, 🔥, 😂, 🙏 ...) on a message, as the connected account, or take one back with remove=true. Use it where a short acknowledgement fits better than a reply.
Get the message_id from messages.read_history (the message must be in the given thread). Works on channels that support reactions: Telegram user accounts, Telegram bots (in a group only when the bot is an administrator; a bot holds one reaction per message, a new one replaces it) and WhatsApp personal numbers; any other channel is refused with the reason, nothing is sent. Telegram accepts only its own set of reaction emoji (a group may narrow it further) and refuses others.
Inputs: emoji (required), thread_id (required), message_id (required), remove, +1 more.
messages_read_historyARead-onlyIdempotentInspect
Read messages from a conversation thread. Use text_contains to find specific messages by content; media_type (photo, document, video, voice, link), date_from/date_to (YYYY-MM-DD, inclusive) and direction (incoming, outgoing) narrow the search and work without text: a photo with no caption sent by the other side in a given month is media_type='photo', direction='incoming' and the dates. A search runs over the loaded part of the conversation and, when that is not all of it, asks the channel's own server (Telegram) to search the rest and stores the hits (a search with text_contains also stores the neighbouring messages of its first 20 hits; one without words stores the hits alone). search_coverage says which: complete = true with a source, or complete = false with the reason, in which case an empty list is not proof the text is absent. sync.loaded_from is the date since which EVERY message is stored (null when unknown); sync.oldest_stored_at is the oldest message stored at all, gaps or not. Returns the most recent messages, including sender info and timestamps. A message in a forum topic (Telegram supergroup with Topics) carries topic_id and, when known, topic (its name); pass that topic_id to messages.send to post into the same topic. A message people reacted to carries reactions (which emoji, who, when): a reaction is often the answer itself, e.g. a thumbs-up under a draft.
Voice calls: each row carries a meta object with allowlisted keys (event_type ∈ 'call_started'|'call_ended'|null, source ∈ 'voice_transcript'|null, call_id, speaker_display_name, duration_seconds, outcome, direction) plus per-message channel. To find calls without scanning every row, use calls.list_history instead.
A file that was never received carries meta.media_skipped (reason, e.g. 'too_large', size_bytes, limit_bytes): the channel did not let us download it, so there is no file to read; the sender can send a link instead.
Usage:
Get thread_id from threads.list first, OR
Use contact_name to auto-resolve thread_id
Examples:
User: 'show me messages from chat with [contact]' → read_history(contact_name='[contact]', limit=10)
User: 'last 5 messages from thread 571' → read_history(thread_id=571, limit=5)
Inputs: limit, before, offset, date_to, +10 more.
messages_sendADestructiveInspect
Send a message to a thread, channel, or contact. Supports Telegram, Email, LinkedIn, and other connected channels. For LinkedIn posts (comment_thread kind), this posts a comment on the post. Can automatically resolve recipients and channels when not specified. In a Telegram bot supergroup with Topics, a reply stays in its topic and topic_id posts into one without replying. Can send files/images/documents as attachments — pass attachments=[file_id, ...] with integer file IDs obtained from collections.list_files, search.files, or files.search. text is optional when attachments are provided.
Inputs: text, format, silent, buttons, +13 more.
messages_send_emailADestructiveInspect
Compose and send an email — with subject, CC/BCC, and attachments. Use for email; for chat messages (Telegram/WhatsApp/livechat) use messages.send instead.
Inputs: cc, bcc, text, subject, +4 more.
messages_unsubscribeADestructiveInspect
Unsubscribe from the mailing list an e-mail message came from, using the sender's own List-Unsubscribe header: a one-click request when offered, else an unsubscribe e-mail sent from the same mailbox. A plain web link is returned, never opened automatically. Works on mailboxes connected over IMAP/SMTP; other channels refuse. The answer says which method was used and the sender's HTTP status.
Inputs: message_id (required), in_workspace.
notes_deleteADestructiveIdempotentInspect
Delete a note by ID from the target notebook. Same identity rules as notes.save — agents can only delete from their own notebook.
Inputs: note_id (required), in_workspace, target_agent_id.
notes_recallARead-onlyIdempotentInspect
Recall notes from your notebook. By default returns only your own notes (all scopes, newest first). Pass filter_agent_id= to read another agent's notebook, or filter_agent_id="all" (or "*") to read across every agent in the workspace. Pass scope to narrow to global/thread/person. Each result includes agent_id and agent_name of the author.
Inputs: key, limit, scope, format, +4 more.
notes_saveAInspect
Save a fact or note into the agent's memory. Use scope to choose visibility: 'workspace' = visible to every agent in this workspace (use for shared facts, project conventions); 'agent' = private to this agent (use for personal working notes); 'thread' = scoped to one conversation (use for thread-specific reminders); 'person' = scoped to one contact (use for per-contact context). If a note with the same key+scope exists it will be updated. Do NOT use this tool for behavioral rules or corrections — use feedback.save for those.
Inputs: key (required), scope (required), value (required), pinned, +5 more.
notes_searchARead-onlyIdempotentInspect
Full-text search in your notebook. By default searches only your own notes. Pass filter_agent_id= to search another agent's notebook, or "all" (or "*") for workspace-wide. Or list all notes for a person/thread by scope_ref_id.
Inputs: limit, query, scope, in_workspace, +2 more.
onboarding_start_signupAInspect
🚪 Start a person's own DialogBrain account without a password.
Creates the account if the email is new (it keeps no password, like a Google sign-in), mails a 6-digit sign-in code to that address, and returns the link to send them. Use it for a lead who ASKED to try the product themselves, or who ticked 'create my account' on a form — never for someone who did not ask.
Tell them the code is in the email and give them the returned link: they enter the code and land on the screen that connects their channel. Do NOT ask them for a password and do not send one; there is none. The code is not returned to you, so you cannot read it out — if they say it never arrived, call again after a minute (a second call inside 60s is refused with rate_limited).
Inputs: email (required), channel, in_workspace.
owner_askAInspect
Ask the workspace owner a question when you cannot decide something yourself. The owner gets ONE message where they actually are (their messenger, else e-mail) and the question is kept as a task on the board. This call does NOT wait: it returns at once, so name a safe default (for example the option that sends nothing) and continue your work on it. The answer comes back later as an owner_answered event that starts the asking agent through its own trigger, and is always written as a comment on the task. Never put the question into a customer's conversation, and never stop to wait for a person at a terminal.
Inputs: question (required), default, options, task_id, +4 more.
owner_contact_threadAInspect
Read or choose YOUR contact chat in this workspace: the conversation that gets owner.ask questions (when you are the workspace owner) and the notices that need a person (an agent paused, a session not answering). With no parameters it answers what is in force. thread_id chooses any conversation of this workspace, for example a team group the workspace's bot is in, so questions are asked where the people who decide read them; an answer written there by a workspace member (a reply to the question, or the option's number) comes back to the asking agent. clear: true goes back to the automatic choice (your own chat with a workspace bot, else e-mail). A chat that is not your own needs the member, admin or owner role, and an agent in its own run cannot choose. Do not choose a customer's conversation: every question and notice would be sent into it.
Inputs: clear, thread_id, in_workspace.
posts_deleteADestructiveIdempotentInspect
Delete a post this account published, on any channel that allows it through its API: X, YouTube (the video) and Facebook (a Page post). Name the post by the post_id posts.publish answered or its link (an x.com, youtube.com / youtu.be or numeric facebook.com link), and the account with account_id or the channel. Other channels answer not_supported. Delete only when the user explicitly asks for this post: it cannot be undone.
Inputs: post_id (required), channel, account_id, in_workspace.
posts_publishADestructiveInspect
Publish a post (or a video) on a connected account: Instagram, YouTube, TikTok, X, Threads, LinkedIn, Facebook (a Page) or Skool. Name the account with account_id (from channels.list), or name only the channel when the workspace has one account there. What a post may carry differs by channel and the answer says what was refused: YouTube and TikTok take one video, Instagram one image, one video (a Reel), 2-10 images (a carousel) or, with options.media_type "story", one image or video as a story (no text, alt_text, location_id or share_to_feed), X up to 4 media, LinkedIn one image (up to 20 MB) or one video (up to 100 MB), Facebook text with a link, up to 10 images or one video. Publish only when the user explicitly asks for this post: it is public and cannot be taken back. A failure of type outcome_unknown may already be live: check before publishing again.
Inputs: text, title, channel, options, +6 more.
present_statusARead-onlyIdempotentInspect
Ask what the room is ACTUALLY seeing on the screen-share right now. Returns presenting plus the page_id, url and title read live from the shared tab. Use it before telling participants what is on screen, and whenever you are not certain the share still points at the tab you meant — pressing keys or scrolling does NOT change which tab is shared, only present_tab does.
Inputs: in_workspace.
present_stopARead-onlyIdempotentInspect
Take whatever is on the call's screen-share back down, so the room sees nobody presenting. Takes no arguments — it stops whatever THIS call is showing. Use it when you are done with a tab and the room should stop looking at it; present_tab with a different page_id switches the share instead, and browser.close on the shared tab also ends it. Stopping when nothing is being shared is a success, not an error — the room already sees nothing. Returns presenting=false once the share is down; present_status will then report nothing on screen. If it comes back ok=false the share may STILL BE UP — do not tell the room you stopped it; retry, or call present_status to see what the room can actually see.
Inputs: in_workspace.
present_tabARead-onlyIdempotentInspect
Put one of the agent's browser tabs on the live call's screen-share. Pass the page_id you got from browser.open. Only usable while the agent is in an active voice call. THIS IS THE ONLY WAY TO CHANGE WHAT THE ROOM SEES — scrolling or pressing keys changes the page, never which tab is shared. The shared tab stays the active share until you call present_tab with a different page_id, call present_stop to take it down, close the tab via browser.close, or the call ends. Returns the page_id, url and title actually on screen; check them before telling anyone what they are looking at, and use present_status to re-check later.
Inputs: page_id (required), in_workspace.
prompts_blocks_getARead-onlyIdempotentInspect
Read the stored prompt-block overrides. Without agent_id: the workspace level (applies to every agent). With agent_id: that agent's own layer (beats the workspace per field) plus its legacy include_* toggles. Missing keys and null fields mean 'inherit'.
Inputs: agent_id, in_workspace.
prompts_blocks_previewARead-onlyIdempotentInspect
Assemble an agent's system prompt through the REAL builder and return it block by block with attribution (id, kind, cache phase, token estimate), the cached-prefix/dynamic-suffix split, and any ignored stale overrides or missing translations. Byte-equality with the production assembly is verified — the preview cannot lie. Use after prompts.blocks_update to see the effect.
Inputs: agent_id (required), thread_id, in_workspace.
prompts_blocks_registryARead-onlyIdempotentInspect
List every block the platform assembles into agent system prompts: id, kind (fact = platform data, guidance = platform text you can rewrite or disable, user = your own text), cache phase, order, the fact labels you can reference from your instructions (e.g. thread_id in [SITUATION]), which labels are locked by enabled tools, and each guidance text's platform default with its md5. Read this before prompts.blocks_update.
Inputs: in_workspace.
prompts_blocks_updateAInspect
Replace the stored prompt-block overrides at one level (workspace when agent_id is omitted, else that agent). prompt_blocks is the FULL desired object for the level: {"<block_id>": {"enabled": bool|null, "text": str|null (guidance blocks only), "order": int|null (reorders within the block's cache tier), "hidden_rows": [label, ...] (fact blocks only)}}. Pass null for an entry to remove it (inherit). Fails loudly: unknown block/label ids, editing a fact block's text, empty text, size caps, and newly hiding a fact row that an enabled tool consumes are all rejected with the full error list — read prompts.blocks_registry for valid ids. Pre-existing stored state is never re-validated (grandfathered).
Inputs: prompt_blocks (required), agent_id, in_workspace.
prompts_getARead-onlyIdempotentInspect
Get full content of a prompt template: system instructions (prompt_text) and auto-reply rules.
Run prompts.list first to find the prompt_id.
Inputs: prompt_id (required), in_workspace.
prompts_listARead-onlyIdempotentInspect
List all prompt templates in this workspace.
Returns id + name + description + category so you know which prompt_id to use in prompts.get or prompts.update.
Inputs: in_workspace.
prompts_prompt_historyARead-onlyIdempotentInspect
List past versions of a prompt template's prompt_text. Every edit is snapshotted to an append-only table — use this to browse history and find a version_number for prompts.prompt_restore.
Inputs: prompt_id (required), limit, in_workspace, before_version.
prompts_prompt_restoreAInspect
Restore a past version of a prompt template by version_number. Creates a new version pointing at the restored content — history is preserved. Fans out to every agent using this template without a per-agent override; the response includes affected_agents as a receipt of the fan-out.
Inputs: prompt_id (required), version_number (required), reason, in_workspace.
prompts_updateAInspect
Update a prompt template's name, system instructions, or auto-reply rules.
Changes affect every agent using this template, unless the agent has its own override (set via agents.update → prompt_text).
All parameters except prompt_id are optional — only provided fields are updated.
Inputs: prompt_id (required), name, description, prompt_text, +2 more.
reminder_cancelBInspect
Cancel an active reminder by its trigger ID.
Inputs: trigger_id (required), agent_id, in_workspace.
reminder_listBRead-onlyIdempotentInspect
List your active reminders (both one-time and recurring).
Inputs: limit, agent_id, thread_id, in_workspace, +1 more.
reminder_setAInspect
Schedule a reminder. One-time reminders fire at a specific datetime. Recurring reminders fire on a schedule (daily, weekly, every N days, or every N minutes). Optionally scope to a thread or target another agent.
Inputs: reason (required), schedule_type (required), time, agent_id, +8 more.
search_filesARead-onlyIdempotentInspect
Search files and attachments across the workspace — by content, filename, document type, or origin. For message content use search.messages; for links use search.links.
Inputs: limit, query, file_origin, in_workspace, +4 more.
search_linksARead-onlyIdempotentInspect
Search links/URLs shared across the workspace — by type, owner, or associated contact. For files use search.files; for message content use search.messages.
Inputs: limit, owner, query, link_kind, +2 more.
search_messagesARead-onlyIdempotentInspect
Search message content across all chats — semantic + keyword. Use to find what was said: quotes, topics, info exchanged. Also finds captionless photos/screenshots by what they show or the words read from them: such a hit carries match_reason ('image' or 'attachment_text') and file_id — open that attachment. Pass direction, chat_kind or per_chat for an EXACT text search instead: who wrote it (outgoing = the owner), private chats or groups, one result per chat with the number of matches. That is the way to find the chat of a person by how the owner addresses them, e.g. query='Дима', direction='outgoing', chat_kind='dm', per_chat=true. For chats/threads themselves use search.threads; for files use search.files; for links use search.links.
Inputs: limit, query, channel, date_to, +11 more.
search_threadsARead-onlyIdempotentInspect
Find or list chat threads/conversations — by topic, participant, unread/unanswered status, or recency. Omit query to list threads by filter. For message content use search.messages; for files use search.files. since filters by recency and pairs with only_unread / only_unanswered. Each thread names the LINE it speaks from (account: id, channel, name, phone, email) and whether the owner ever really wrote there (has_real_outgoing; imported history does not count). The same person can appear once per connected number — pick the thread by account, not by title, before you messages.send.
Inputs: limit, query, since, offset, +7 more.
skool_groupsARead-onlyIdempotentInspect
List the Skool communities (groups) the connected account is a member of: id, name and display name of each. Pass group_id to also get that community's rules (the titles of its rules page) - read them before posting. Use the ids as posts.publish's destination and in messages.send recipients 'skool:user:@'.
Inputs: account_id (required), group_id, in_workspace.
system_sleepARead-onlyIdempotentInspect
Pause execution for a given number of seconds (max 30). Use when you need to wait for an external process to complete before retrying — e.g. message sync, backfill, or API propagation. Total sleep per run is capped at 60 seconds.
Inputs: seconds (required), reason, in_workspace.
tasks_commentAInspect
Post a comment on a task. Attach files (screenshots, documents) by uploading them with files.upload first and passing the file IDs.
Inputs: body (required), task_id (required), agent_id, in_workspace, +1 more.
tasks_createAInspect
Create a task in this workspace. Leave the assignee empty to put it in the backlog, or name someone to hand it over.
Inputs: title (required), due_at, tag_ids, agent_id, +14 more.
tasks_deleteADestructiveIdempotentInspect
Delete a task. Only its creator or a workspace owner/admin may do this; to close a task instead, set status='cancelled'.
Inputs: task_id (required), agent_id, in_workspace.
tasks_getARead-onlyIdempotentInspect
Read one task in full: its fields, attachments, and the whole comment thread including recorded status and assignee changes. Pass agent_id when you are acting as an agent, and the reply says assigned_to_me so you need not infer it from matching ids.
Inputs: task_id (required), agent_id, in_workspace.
tasks_listARead-onlyIdempotentInspect
List tasks in this workspace. Defaults to everything a person can see; an agent calling this sees its own tasks. Filter by assignee, status, or overdue to narrow it down.
Inputs: limit, offset, status, tag_id, +10 more.
tasks_updateAInspect
Update a task. Set status='done' to complete it, 'cancelled' to cancel. Reassign with assignee. Status and assignee changes are recorded in the task's comment thread.
Inputs: task_id (required), title, due_at, status, +15 more.
threads_channel_account_statsARead-onlyIdempotentInspect
Get the connected Meta Threads account's profile (username, name, avatar) and account-level insights (followers, views, likes, replies, reposts, quotes).
Inputs: account_id, in_workspace.
threads_channel_hide_replyAInspect
Hide a reply on a Meta Threads post owned by the connected account. Also hides every nested reply beneath it.
Inputs: reply_id (required), account_id, in_workspace.
threads_channel_list_postsARead-onlyIdempotentInspect
List posts published by the connected Meta Threads account. Returns id, text, permalink, media_type and timestamp. Paginate with the returned after cursor.
Inputs: after, limit, since, until, +2 more.
threads_channel_post_insightsARead-onlyIdempotentInspect
Get engagement metrics for one Meta Threads post: views, likes, replies, reposts and quotes.
Inputs: post_id (required), account_id, in_workspace.
threads_channel_unhide_replyAInspect
Unhide a previously hidden reply on a Meta Threads post owned by the connected account. Also unhides its nested replies.
Inputs: reply_id (required), account_id, in_workspace.
threads_deleteADestructiveIdempotentInspect
🗑️ PERMANENTLY delete conversation thread(s) and their messages + user-facing state (tags, assignments, drafts, reminders, RAG chunks). Destructive and NOT undoable — requires confirm=true.
Pass thread_id for one, or thread_ids for a bulk delete. Kept intentionally: call history (voice_sessions), usage/billing, traces, and outreach dedup are NOT removed. Note: for a live synced channel (Telegram/WhatsApp) this clears the LOCAL copy; a new inbound can re-create the thread on next sync. For livechat/voice/test/duel threads it's effectively permanent.
Inputs: confirm (required), thread_id, thread_ids, in_workspace.
threads_get_agent_statusARead-onlyIdempotentInspect
Says whether the AI agent is on hold in one conversation: paused, who paused it ("operator" for a person's Pause / take-over; null for a pause a manual reply set) and since when (UTC).
Inputs: thread_id (required), in_workspace.
threads_set_agent_pausedAInspect
Puts the AI agent on hold in ONE conversation so a person can answer it (paused=true), or hands the conversation back to the agent (paused=false). The same as the Pause / Resume button in the inbox: while paused the agent does not answer that conversation, and no resume policy lifts the pause — only paused=false or the Resume button does. Other conversations and the agent itself keep working. For a person's own client (API key or MCP); an agent cannot call it.
Inputs: paused (required), thread_id (required), in_workspace.
threads_updateAInspect
✏️ Update a conversation thread: rename it, add notes/description, move it to a folder, or take it out of sync.
When to use:
User wants to rename a chat or group
User wants to add notes/context about a conversation
User wants to organize threads into folders
User wants a chat to stop showing up and stop syncing (
synced=false) — e.g. the personal chats on an account that is only in the workspace for its work groups. Nothing is deleted;synced=truebrings it back.
For DM threads, renaming also updates the linked contact's display name by default. Pass thread_id for one thread, or thread_ids to apply the same change to several. Ids come from threads.list / search.threads.
Inputs: title, synced, folder_id, thread_id, +4 more.
tiktok_account_statsARead-onlyIdempotentInspect
Get the connected TikTok account's profile (username, display name, avatar) and stats (followers, following, likes, videos).
Inputs: in_workspace.
tiktok_creator_infoARead-onlyIdempotentInspect
Read the connected TikTok account's posting options before publishing: nickname and avatar, the privacy levels it offers, whether comments/duets/stitches are switched off in its TikTok settings, and the longest video it may post. Call it before posts.publish and let the user pick the privacy level.
Inputs: in_workspace, channel_account_id.
tiktok_list_videosARead-onlyIdempotentInspect
List videos on the connected TikTok account. Returns id, title, share_url, view/like/comment/share counts. Paginate via cursor.
Inputs: cursor, max_count, in_workspace.
videos_generateAInspect
Generate a short video (5-10s) from a text prompt using BytePlus Seedance. Optionally accepts up to 12 image file IDs from the user's attached files (visible in the [ATTACHMENTS] block) as reference_file_ids for style and composition. Returns immediately with a job_id; the video is delivered back via continuation when the job completes (~30-90s for fast model, ~2-5min for pro). Reference images reach the video provider through short-lived signed links — don't submit confidential references. Seedance runs on the workspace's own GEngen or BytePlus key when one is set in Settings → API keys (no credits charged); otherwise it needs the workspace video opt-in and credits.
Inputs: prompt (required), seed, model, style, +9 more.
web_fetchAInspect
Fetches a single URL and returns its content. Use this when you have a specific URL in mind — for example, after web.search returns a link you want to read, or when the user pastes a URL.
Modes (extract):
'auto' (default): picks the right mode based on response content type.
'markdown': for HTML pages; returns cleaned markdown plus the page .
'text': for JSON/XML/plaintext APIs; returns the raw decoded body.
'file': for images, PDFs, audio, video, archives, or any binary — ingests the bytes into the user's file storage and returns a file_id you can pass to messages.send (to send as an attachment), agents.add_file (to add to agent knowledge), or files.read.
Use web.fetch (not files.upload) when you need the file_id immediately for the next tool call — files.upload(source_url=…) is async and won't have the file ready in the same turn.
Use web.search (not web.fetch) when you don't have a specific URL yet and need to find one.
Inputs: url (required), extract, in_workspace.
webhooks_configure_enrichmentAInspect
Enable enrichment on an agent's webhook trigger so reference-only webhook payloads are resolved to full data before the agent runs. One tool for every provider — choose provider and pass its config.
Providers & required config:
meta_leadgen (Meta/Facebook Lead Ads): config = {app_id, app_secret, user_access_token}. The user token needs pages_show_list + leads_retrieval (+ pages_manage_metadata; add business_management to auto-discover Business-Manager pages that /me/accounts omits). Stores all page tokens encrypted per workspace and resolves each lead's name/email/phone. Reuses the existing webhook URL (no token rotation); creates a webhook trigger if the agent has none.
tiktok_leadgen (TikTok Instant Form and direct-message leads): config = {access_token, advertiser_ids?}. access_token is a TikTok Marketing API advertiser token issued to DialogBrain's Business app; without advertiser_ids every ad account the token reaches is subscribed. Adds a separate webhook trigger on the agent (a Meta-wired trigger is left alone) and subscribes it to LEAD events; each lead arrives with its answers, signature-verified.
Inputs: config (required), agent_id (required), provider (required), in_workspace.
web__local_searchARead-onlyIdempotentInspect
Multi-source web research with citations. Returns a synthesized answer with numbered [^1] markers and a citations array of {url, title, snippet, index}. Use for evidence-backed synthesis (competitive analysis, regulatory summary, whitepaper section). For quick fact lookups use web.search instead.
Inputs: query (required), language, num_sources, in_workspace.
web_researchARead-onlyIdempotentInspect
Answer a research question from live web sources in one call — returns a synthesized answer with numbered [N] citation markers and a citations array of {url, title, index}. Supports recency and domain filters. Use for questions needing current, sourced information (news about a company, market state, comparisons). For raw search result links use web.search; mode='deep' runs minutes-long exhaustive research — only when explicitly requested.
Inputs: query (required), mode, domains, recency, +1 more.
web_searchARead-onlyIdempotentInspect
Search the web for current information, news, facts, prices, or events. Use this when the user asks about something that requires up-to-date information from the internet, or when internal knowledge base doesn't have the answer. Examples: recent news, stock prices, weather, product information, current events.
Inputs: query (required), time_range, num_results, search_type, +1 more.
widgets_createBInspect
Create a new livechat widget for your website.
The widget will be created with default settings. You can customize theme, auto-reply mode, and more.
Use this when user wants to add a chat widget to their site.
Inputs: name (required), position, allow_voice, display_mode, +5 more.
widgets_deleteADestructiveIdempotentInspect
Delete a livechat widget permanently.
This will remove the widget and its embed code will stop working. Its conversations and their messages are deleted with it: the widget IS the channel, and thread.channel_account_id cascades.
Use this when user wants to remove a chat widget.
Inputs: widget_id (required), in_workspace.
widgets_getARead-onlyIdempotentInspect
Get full configuration of a single livechat widget.
Returns all settings including theme, identification, actions, and more.
Use this when user wants to see or verify a specific widget's settings.
Inputs: widget_id (required), in_workspace.
widgets_get_embed_codeARead-onlyIdempotentInspect
Get the embed code snippet for a livechat widget.
Returns HTML/JavaScript code to add to your website. The code should be placed before the closing tag.
Use this when user wants to install the chat widget on their site.
Inputs: widget_id (required), in_workspace.
widgets_listARead-onlyIdempotentInspect
List all livechat widgets.
Returns widgets with their configuration, embed code, and status.
Use this when user wants to see their widgets or chat widgets.
Inputs: active_only, in_workspace.
widgets_updateAInspect
Update an existing livechat widget configuration.
You can change name, theme, auto-reply mode, and other settings. Only provided fields will be updated.
Use this when user wants to modify their chat widget settings.
Inputs: widget_id (required), name, position, is_active, +27 more.
workbench_run_pythonARead-onlyIdempotentInspect
Run Python in an isolated sandbox to process LARGE or paginated tool results without pulling every row into the conversation. Inside the code, call your connected integration tools with call_tool('ext<id>_<name>', {..}), or this agent's own platform tools by their dotted id (e.g. call_tool('db.query', {'sql': 'SELECT ...'})) — a platform tool must be in the agent's allowed_tools, and calling one requires an agent context. RETURN SHAPE: call_tool ALWAYS returns a dict with a boolean r['success']. The payload key DIFFERS by tool kind: integration (ext*) results are under r['body'] (e.g. r['body']['results']), platform tools are under r['data'] (e.g. r['data']['rows'] for db.query). Reading the wrong key returns nothing even though the call SUCCEEDED — so when in doubt print(r) once and inspect before extracting. On FAILURE r['success'] is False and r['error'] explains. Aggregate/filter/paginate in the sandbox, then assign ONLY the small summary you want back to a variable named result. FIRST discover exact tool slugs with integrations_search_tools, THEN write code that calls them. pandas/numpy available.
Inputs: code (required), agent_id, in_workspace.
workspace_createAInspect
Create a new team workspace owned by the calling user. Returns its id and slug — pass either to workspace.switch to start working inside it. slug is derived from name when omitted. NOT idempotent: calling twice with the same name yields two workspaces (the second gets a -1 slug suffix), so check workspace.list first if the workspace may already exist.
Inputs: name (required), slug, description, in_workspace.
workspace_currentARead-onlyIdempotentInspect
Return the workspace this MCP API key is currently routed to, with the caller's role inside it. Use this to confirm context before/after workspace.switch.
Inputs: in_workspace.
workspace_desktopsARead-onlyIdempotentInspect
List the Claude Code sessions currently connected to this workspace over a channel. Each one can be handed a task by name. Use this before assigning work to a claude_channels agent when more than one session may be open, so the task goes to the machine you mean.
Inputs: in_workspace.
workspace_inviteAInspect
Invite a person to the active workspace (or one named by workspace_id) by email address. Requires owner or admin role. The backend emails them a join link and the invite expires in 7 days; the same link is returned as invite_url so you can pass it on yourself. Inviting an address that already has an account works too — they see the invitation in the app once logged in. Use workspace.invites to see what is still pending.
Inputs: email (required), role, in_workspace, workspace_id.
workspace_invite_revokeADestructiveIdempotentInspect
Revoke a pending invitation to the active workspace (or one named by workspace_id) so its link stops working. Requires owner or admin role. Get the invite id from workspace.invites. An invite that is already accepted, expired or revoked answers not_found.
Inputs: invite_id (required), in_workspace, workspace_id.
workspace_invitesARead-onlyIdempotentInspect
List the invitations to the active workspace (or one named by workspace_id) that are still pending — who was invited, as what role, and when the invite expires. Requires owner or admin role. Join links are not returned; revoke with workspace.invite_revoke or re-send with workspace.invite.
Inputs: in_workspace, workspace_id.
workspace_listARead-onlyIdempotentInspect
List every workspace the caller is a member of, with is_current marking the workspace this MCP key is currently routed to. Pair with workspace.switch to change the active workspace without reconnecting.
Inputs: in_workspace.
workspace_member_removeADestructiveIdempotentInspect
Remove a person from the active workspace (or one named by workspace_id), and revoke the channel shares they had granted into it. Requires owner or admin role. Name them by email, username or numeric user id — workspace.members lists them. The workspace owner cannot be removed.
Inputs: member (required), in_workspace, workspace_id.
workspace_membersARead-onlyIdempotentInspect
List the members of the current workspace with their roles, so you know who can be assigned a task. Set include_agents to also list the workspace's AI agents, which can hold tasks too.
Inputs: in_workspace, include_agents.
workspace_member_updateAInspect
Change a member's role in the active workspace (or one named by workspace_id). Requires owner or admin role. Name the person by email, username or numeric user id — workspace.members lists them. Promoting to 'admin' also grants member management; ownership is moved separately and cannot be set here.
Inputs: role (required), member (required), in_workspace, workspace_id.
workspace_provider_keysAInspect
Manage this workspace's OWN provider API keys (bring your own key). action: list (default) shows every provider: configured, enabled for this workspace, when uploaded, never the key; set stores api_key for provider after the provider confirms it works, and enables it for THIS workspace; enable / disable switch this workspace's use of the key; delete removes the stored key. For video use provider gengen or byteplus: videos.generate then runs on your account, not the platform's. A key stored inside an integration is NOT used by these features. api_key also takes a clip: handle from clipboard.copy (pattern 'api_key'): a key someone sent in a chat is stored without anyone reading it. Needs ADMIN or OWNER in the workspace (list: any member). Where it is stored: keys live on the WORKSPACE OWNER's row and serve every workspace that owner owns. The owner may always set, replace or delete. An admin who is not the owner may set when the owner has no key for that provider, and may replace or delete only while no other workspace of the owner has the provider enabled; otherwise it is refused and the owner must do it. enable / disable touch only this workspace's switch.
Inputs: action, api_key, provider, in_workspace.
workspace_switchAInspect
Switch the workspace THIS MCP session works in. Pass exactly one of workspace_id or slug (find them via workspace.list). Takes effect on the very next tool call — no MCP reconnect, no new API key. The switch is scoped to the current MCP session (the response says scope: session), or, for a client that sends no MCP session id, to that client (scope: client: every conversation of that client on this key moves together). Other sessions using the same API key are not affected, and the key's own workspace stays the default for new sessions. Sequential checkpoint: do not parallelize tool calls across a switch — calls already in flight when the switch commits will run against the previous workspace. Keys created with workspace_locked=true refuse to switch in either scope (they are pinned to their workspace); use a key belonging to the target workspace instead.
Inputs: slug, workspace_id.
workspace_updateAInspect
Edit the active workspace (or one named by workspace_id): its name, description, logo_url, and/or settings. Requires ADMIN role in that workspace. settings is MERGED, not replaced — send only the keys you want to change (e.g. {"translation_glossary": "..."} or {"translation_tts_provider": "cartesia"}); other keys are left intact. Omit workspace_id to target the workspace this MCP key is currently routed to (see workspace.current).
Inputs: name, logo_url, settings, description, +2 more.
youtube_delete_commentADestructiveIdempotentInspect
Permanently delete a YouTube comment by id (or 'youtube:comment:'). Cannot be undone. Costs 50 quota units.
Inputs: comment_id (required), account_id, in_workspace.
youtube_delete_videoADestructiveIdempotentInspect
Permanently delete a YouTube video by id (or 'youtube:video:'). Cannot be undone. Costs 50 quota units. Caller must own the channel.
Inputs: video_id (required), account_id, in_workspace.
youtube_list_commentsARead-onlyIdempotentInspect
List comment threads on a YouTube video. Pass video_id (e.g. 'dQw4w9WgXcQ') or channel_ref ('youtube:video:'). Returns top-level comments with inline replies.
Inputs: video_id (required), account_id, page_token, max_results, +1 more.
youtube_list_videosARead-onlyIdempotentInspect
List videos on the connected YouTube channel. Returns id, title, published_at, view_count. Paginate via page_token.
Inputs: account_id, page_token, max_results, in_workspace.
youtube_moderate_commentBInspect
Apply a moderation status to a YouTube comment. Allowed status values: heldForReview, published, rejected, spam. Costs 50 quota units.
Inputs: status (required), comment_id (required), account_id, in_workspace.
youtube_post_comment_replyADestructiveInspect
Post a comment on a YouTube video, or reply to an existing comment. Pass video_id for a top-level comment, OR parent_comment_id to reply. AI-disclosure suffix appended automatically when configured.
Inputs: text (required), video_id, account_id, in_workspace, +1 more.
youtube_update_videoADestructiveInspect
Update title, description, privacy, or tags on a YouTube video. Costs 1600 quota units. Only fields provided are changed.
Inputs: video_id (required), tags, title, privacy, +3 more.
youtube_video_queryARead-onlyIdempotentInspect
Ask Gemini about a YouTube video. Pass a video URL and any prompt — verbatim transcript with timestamps, summary, targeted Q&A about content or visuals, translation, etc. Works on any public/unlisted video.
Inputs: url (required), prompt (required), in_workspace.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Unified messaging MCP server: WhatsApp, Instagram, Telegram, SMS, Messenger & email support inbox
Read, search and answer your messages on WhatsApp, iMessage, Slack, Telegram and 17 more networks.
CRM and unified inbox: Telegram, WhatsApp, Instagram, email, deals, social posts and ad reports.
Send and read WhatsApp, email and SMS from Claude, ChatGPT, Cursor or any MCP client, from your own accounts: your WhatsApp number (linked by QR code), your mailbox (IMAP/SMTP) and your Android phone (SMS from its SIM). Tools: list-accounts, get-account, add-account, add-email-account, list-messages, send-message (one channel or several in one call). Hosted, OAuth 2.1, nothing to install. Free plan with unlimited messages; paid plans from 19 EUR/month remove the footer and add media and webhooks. Docs and client configs: github.com/UnlimitedMessaging/unlimited-messaging-mcp
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceWhatsApp, Instagram, Telegram, SMS, Messenger & email in one AI-ready inbox. Manage conversations, send omnichannel messages, run campaigns, sync contacts, and query your knowledge base — 42 tools over a hosted, OAuth-secured MCP server.2MIT
- AlicenseNot gradedqualityCmaintenanceEnables agents and local applications to access messaging, contacts, history, search, media, transcription, and message preparation across Telegram, WhatsApp, Bitrix, email exports, and call archives through a unified MCP interface. It also supports scoped permissions, routing, delivery verification, and background subscriptions.MIT
- AlicenseBqualityBmaintenanceMCP server for Gmail shared inboxes and WhatsApp — read, reply, search, and organize your team's email from Claude, ChatGPT, or Cursor. 47 tools covering email threads, WhatsApp messaging, boards, contacts, knowledge base, analytics, and automations.4784 npm1MIT

SendAPI MCP Serverofficial
AlicenseAqualityDmaintenanceEnables any MCP-compatible AI agent to send WhatsApp messages, SMS, OTP codes, and email through a single REST API.18MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.