> ## Documentation Index
> Fetch the complete documentation index at: https://composio-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Composio

> Composio enables AI Agents and LLMs to authenticate and integrate with various tools via function calling.

![Composio logo](https://mintcdn.com/composio-preview/NPf8agM6UrvZD-Iu/images/toolkits/composio.svg?fit=max\&auto=format\&n=NPf8agM6UrvZD-Iu\&q=85\&s=ba7a3e81ee6d1d5a8304e0114957b895)

* **Category:** ai agents
* **Auth:** NO\_AUTH
* **Composio-managed OAuth available?** N/A
* **Tools:** 19
* **Triggers:** 0
* **Slug:** `COMPOSIO`
* **Version:** 20260917\_00

## Tools

> [accordion] Check active connection (deprecated)
>
> **Slug:** `COMPOSIO_CHECK_ACTIVE_CONNECTION`
>
> Deprecated: use check active connections instead for bulk operations. check active connection status for a toolkit or specific connected account id. returns connection details if active, or required parameters for establishing connection if none exists. active connections enable agent actions on the toolkit.
>
> #### Input Parameters
>
> **connected\_account\_id** `string`
>
> Specific connected account ID to check status for
>
> **toolkit** `string`
>
> Name of the toolkit to check
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Check multiple active connections
>
> **Slug:** `COMPOSIO_CHECK_ACTIVE_CONNECTIONS`
>
> Check active connection status for multiple toolkits or specific connected account ids. returns connection details if active, or required parameters for establishing connection if none exists. active connections enable agent actions on toolkits.
>
> #### Input Parameters
>
> **requests** `array` *required*
>
> List of connection check requests
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Create Plan
>
> **Slug:** `COMPOSIO_CREATE_PLAN`
>
> IMPORTANT - ALWAYS CALL THIS AFTER MANAGE CONNECTIONS TOOL IS EXECUTED. You are an efficient workflow builder, your job is to guide the LLM to create a plan for the given use\_case
>
> #### Input Parameters
>
> **use\_case** `string` *required*
>
> Detailed explanation of the use case the user is trying to accomplish. Include as many details as possible for a better plan
>
> **reasoning** `string` *required*
>
> Reasoning from the search about the use case and how the selected tools can accomplish it
>
> **difficulty** `string ("easy" | "medium" | "hard")` *required*
>
> Difficulty level for the plan. Choose "easy" for simple tasks (send email to known email id), "medium" for moderate complexity (summarize slack messages from last day), and "hard" for complex tasks requiring multiple steps or advanced logic (create personalized draft for 100 emails).
>
> **session\_id** `string`
>
> CRITICAL: Session identifier for workflow correlation and tracking across multiple tool calls. While technically optional, this parameter should ALWAYS be passed from RUBE\_SEARCH\_TOOLS response. Used to maintain context and enable proper workflow execution monitoring across the entire workflow chain.
>
> **known\_fields** `string` *required*
>
> Provide any workflow inputs you already know (e.g. channel name, user email, timezone). This helps the tool infer or look up missing details (for example, finding channel\_id from a given channel\_name). Keep values short and structured—do not include long texts like full messages. Example: \["channel\_name:pod-sdk", "channel\_id:123", "user\_name:John", "timezone:Asia/Kolkata"]
>
> **primary\_tool\_slugs** `array` *required*
>
> List of primary tool slugs that can accomplish the main task. For example: \['GITHUB\_LIST\_PULL\_REQUESTS', 'SLACK\_SEND\_MESSAGE']
>
> **related\_tool\_slugs** `array`
>
> List of related/supporting tool slugs that might be useful. These are optional tools that could help with the task.
>
> #### Output
>
> **data** `string` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Enable trigger
>
> **Slug:** `COMPOSIO_ENABLE_TRIGGER`
>
> Enable a specific trigger for the authenticated user.
>
> #### Input Parameters
>
> **config\_params** `object`
>
> Configuration parameters for the trigger
>
> **connected\_account\_id** `string` *required*
>
> Connected account ID to enable trigger for
>
> **toolkit\_slug** `string` *required*
>
> Slug of the toolkit
>
> **trigger\_name** `string` *required*
>
> Name of the trigger to enable
>
> **user\_id** `string`
>
> User ID for the trigger
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Execute Composio Tool
>
> **Slug:** `COMPOSIO_EXECUTE_TOOL`
>
> Execute a tool using the composio api.
>
> #### Input Parameters
>
> **allow\_destructive** `boolean`
>
> Whether to allow destructive tools to be executed. If true, the tool will be executed even if it is destructive.
>
> **arguments** `object` *required*
>
> The arguments to be passed to the tool. The schema of the arguments is present in the retrieve\_actions response
>
> **connected\_account\_id** `string`
>
> The ID of the connected account to use. If not provided, uses the first active connection for the toolkit
>
> **tool\_slug** `string` *required*
>
> The slug of the tool to execute, to be used from the list of tools retrieved using retrieve\_actions
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Get Tool Dependency Graph
>
> **Slug:** `COMPOSIO_GET_DEPENDENCY_GRAPH`
>
> Get the dependency graph for a given tool, showing related parent tools that might be useful. this action calls the composio labs dependency graph api to retrieve tools that are commonly used together with or before the specified tool. this helps discover related tools and understand common workflows.
>
> #### Input Parameters
>
> **tool\_name** `string` *required*
>
> The name of the tool to get dependency graph for
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Get required parameters for connection
>
> **Slug:** `COMPOSIO_GET_REQUIRED_PARAMETERS`
>
> Gets the required parameters for connecting to a toolkit via initiate connection. returns the exact parameter names and types needed for initiate connection's parameters field. supports api keys, oauth credentials, connection fields, and hybrid authentication scenarios. if has default credentials is true, you can call initiate connection with empty parameters for seamless oauth flow.
>
> #### Input Parameters
>
> **toolkit** `string` *required*
>
> Name of the toolkit to analyze for authentication requirements. Returns parameters for API keys, OAuth credentials, or connection fields needed by initiate\_connection.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Get response schema
>
> **Slug:** `COMPOSIO_GET_RESPONSE_SCHEMA`
>
> Retrieves the response schema for a specified composio tool. this action fetches the complete response schema definition for any valid composio tool, returning it as a dictionary that describes the expected response structure.
>
> #### Input Parameters
>
> **tool** `string` *required*
>
> Name of the tool. For example: GITHUB\_LIST\_PULL\_REQUESTS. You can find the relevant tool names using COMPOSIO\_RETRIEVE\_ACTIONS tool.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Initiate connection
>
> **Slug:** `COMPOSIO_INITIATE_CONNECTION`
>
> Initiate a connection to a toolkit with comprehensive authentication support. supports all authentication scenarios: 1. composio default oauth (no parameters needed) 2. custom oauth (user's client id/client secret) 3. api key/bearer token authentication 4. basic auth (username/password) 5. hybrid scenarios (oauth + connection fields like site name) 6. connection-only fields (subdomain, api key at connection level) 7. no authentication required automatically detects and validates auth config vs connection fields, provides helpful error messages for missing parameters.
>
> #### Input Parameters
>
> **parameters** `object`
>
> Authentication parameters for the connection. Structure depends on auth type:                  API Key Auth: \{"generic\_api\_key": "your\_key"}         Bearer Token: \{"bearer\_token": "your\_token"} or \{"access\_token": "your\_token"}         Basic Auth: \{"username": "user", "password": "pass"}         Custom OAuth: \{"client\_id": "your\_id", "client\_secret": "your\_secret"}         Connection Fields: \{"subdomain": "your\_subdomain", "site\_name": "your\_site"}                   Examples:         - Exa: \{"generic\_api\_key": "your\_exa\_api\_key"}         - GitHub (token): \{"access\_token": "ghp\_xxxxx"}         - Google Super (OAuth): \{"client\_id": "xxx.apps.googleusercontent.com", "client\_secret": "GOCSPX-xxx"}         - SharePoint (hybrid): \{"client\_id": "your\_id", "client\_secret": "your\_secret", "site\_name": "your\_site"}         - Zendesk (connection only): \{"subdomain": "your\_subdomain"}                  Leave empty \{} for default OAuth flow (if supported by toolkit).         Use get\_required\_parameters action to see exact parameter names and requirements.
>
> **toolkit** `string` *required*
>
> Name of the toolkit to connect (e.g., 'gmail', 'exa', 'github', 'linear')
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] List toolkits
>
> **Slug:** `COMPOSIO_LIST_TOOLKITS`
>
> List all the available toolkits on composio with filtering options.
>
> #### Input Parameters
>
> **category** `string`
>
> Filter toolkits by category
>
> **min\_tools** `integer`
>
> Filter toolkits by minimum number of tools
>
> **name\_filter** `string`
>
> Filter toolkits by name/slug
>
> **no\_auth\_only** `boolean`
>
> Only return toolkits that don't require authentication
>
> **size** `integer`
>
> Limit the number of results returned
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] List triggers
>
> **Slug:** `COMPOSIO_LIST_TRIGGERS`
>
> List available triggers and their configuration schemas.
>
> #### Input Parameters
>
> **toolkit\_names** `array`
>
> List of toolkit names to filter triggers (optional), if not provided/empty, all triggers will be returned
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Manage connections
>
> **Slug:** `COMPOSIO_MANAGE_CONNECTIONS`
>
> Create or manage connections to user's apps. Returns a branded authentication link that works for OAuth, API keys, and all other auth types.
>
> Call policy:
>
> * First call COMPOSIO\_SEARCH\_TOOLS for the user's query.
> * If COMPOSIO\_SEARCH\_TOOLS indicates there is no active connection for a toolkit, call COMPOSIO\_MANAGE\_CONNECTIONS with the exact toolkit name(s) returned.
> * Use exact toolkit slugs returned by COMPOSIO\_SEARCH\_TOOLS; never invent toolkit names.
> * NEVER execute any toolkit tool without an ACTIVE connection.
>
> Tool Behavior:
>
> * If a connection is Active, the tool returns the connection details. Always use this to verify connection status and fetch metadata.
> * If a connection is not Active, returns a authentication link (redirect\_url) to create new connection.
> * If reinitiate\_all is true, the tool forces reconnections for all toolkits, even if they already have active connections.
>
> Workflow after initiating connection:
>
> * Always show the returned redirect\_url as a FORMATTED MARKDOWN LINK in your final response for this turn as intermediate messages may be hidden or summarized by the chat interface, so the user may not see the link there. Ask the user to click on the link to finish authentication and reply when done.
> * After the user replies, use COMPOSIO\_MANAGE\_CONNECTIONS to verify that the connection they just authorized is active.
> * Begin executing tools only after the connection for that toolkit is confirmed Active.
>
> #### Input Parameters
>
> **toolkits** `array` *required*
>
> Toolkit slugs to check or connect. Must be valid toolkit slugs; never invent. Missing connections initiate auth. Examples: \['gmail', 'github', 'slack', 'googlesheets', 'outlook'].
>
> **reinitiate\_all** `boolean`
>
> Force reconnection for all listed toolkits, even if active connections already exist. Use when credentials may be stale, you need fresh credentials/settings, or you are troubleshooting connection issues. This replaces existing active connections with new auth-link flows. Default false.
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Multi Execute Composio Tools
>
> **Slug:** `COMPOSIO_MULTI_EXECUTE_TOOL`
>
> Fast and parallel tool executor for tools discovered through COMPOSIO\_SEARCH\_TOOLS. Use this tool to execute up to 50 tools in parallel across apps only when they're logically independent (no ordering/output dependencies). Response contains structured outputs ready for immediate analysis - avoid reprocessing them via remote bash/workbench tools.
>
> Prerequisites:
>
> * Always use valid tool slugs and their arguments. NEVER invent tool slugs or argument fields. ALWAYS pass STRICTLY schema-compliant arguments with each tool execution.
> * Ensure an ACTIVE connection exists for the toolkits that are going to be executed. If none exists, MUST initiate one via COMPOSIO\_MANAGE\_CONNECTIONS before execution.
> * Only batch tools that are logically independent - no ordering, no output-to-input dependencies, and no intra-call chaining (tools in one call can't use each other's outputs). DO NOT pass dummy or placeholder inputs; always resolve required inputs using appropriate tools first.
>
> Usage guidelines:
>
> * If COMPOSIO\_SEARCH\_TOOLS returns a tool that can perform the task, prefer calling it via this executor. Do not write custom API calls or ad-hoc scripts for tasks that can be completed by available Composio tools.
> * Prefer parallel execution: group independent tools into a single multi-execute call where possible.
> * Predictively set sync\_response\_to\_workbench=true if the response may be large or needed for later scripting. It still shows response inline; if the actual response data turns out small and easy to handle, keep everything inline and SKIP workbench usage.
> * Responses contain structured outputs for each tool. RULE: Small data - process yourself inline; large data - process in the workbench.
> * ALWAYS include inline references/links to sources in MARKDOWN format directly next to the relevant text. Eg provide slack thread links alongside with summary, render document links instead of raw IDs.
>
> Restrictions: Some tools or toolkits may be disabled in this environment. If the response indicates a restriction, inform the user and STOP execution immediately. Do NOT attempt workarounds or speculative actions.
>
> * CRITICAL: You MUST always include the 'memory' parameter - never omit it. Even if you think there's nothing to remember, include an empty object \{} for memory.
>
> Memory Storage:
>
> * CRITICAL FORMAT: Memory must be a dictionary where keys are app names (strings) and values are arrays of strings. NEVER pass nested objects or dictionaries as values.
> * CORRECT format: \{"slack": \["Channel general has ID C1234567"], "gmail": \["John's email is [john@example.com](mailto:john@example.com)"]}
> * Write memory entries in natural, descriptive language - NOT as key-value pairs. Use full sentences that clearly describe the relationship or information.
> * ONLY store information that will be valuable for future tool executions - focus on persistent data that saves API calls.
> * STORE: ID mappings, entity relationships, configs, stable identifiers.
> * DO NOT STORE: Action descriptions, temporary status updates, logs, or "sent/fetched" confirmations.
> * Examples of GOOD memory (store these):
>   * "The important channel in Slack has ID C1234567 and is called #general"
>   * "The team's main repository is owned by user 'teamlead' with ID 98765"
>   * "The user prefers markdown docs with professional writing, no emojis" (user\_preference)
> * Examples of BAD memory (DON'T store these):
>   * "Successfully sent email to [john@example.com](mailto:john@example.com) with message hi"
>   * "Fetching emails from last day (Sep 6, 2025) for analysis"
> * Do not repeat the memories stored or found previously.
>
> #### Input Parameters
>
> **tools** `array` *required*
>
> List of logically independent tools to execute in parallel.
>
> **thought** `string`
>
> One-sentence, concise, high-level rationale (no step-by-step).
>
> **sync\_response\_to\_workbench** `boolean` *required*
>
> Predictively set true when the response may be large or needed for later scripting. Saves the full response to the workbench while returning an inline preview. If the result is small, keep it inline. Default false.
>
> **memory** `object`
>
> CRITICAL: Memory must be a dictionary with app names as keys and string arrays as values. NEVER use nested objects. Format: \{"app\_name": \["string1", "string2"]}. Store durable facts - stable IDs, mappings, roles, preferences. Exclude ephemeral data like message IDs or temp links. Use full sentences describing relationships. Always include this parameter.
>
> **current\_step** `string`
>
> Short enum for current step of the workflow execution. Eg FETCHING\_EMAILS, GENERATING\_REPLIES. Always include to keep execution aligned with the workflow.
>
> **current\_step\_metric** `string`
>
> Progress metrics for the current step - use to track how far execution has advanced. Format as a string "done/total units" - example "10/100 emails", "0/n messages", "3/10 pages".
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Run bash commands
>
> **Slug:** `COMPOSIO_REMOTE_BASH_TOOL`
>
> Execute bash commands in a REMOTE sandbox for file operations, data processing, and system tasks. Essential for handling large tool responses saved to remote files. **Hard 3-minute (180s) execution limit** — break large tasks into smaller commands. PRIMARY USE CASES:
>
> * Process large tool responses saved by COMPOSIO\_MULTI\_EXECUTE\_TOOL to remote sandbox
> * File system operations, extract specific information from JSON with shell tools like jq, awk, sed, grep, etc.
> * Commands run from /home/user directory by default
>
> #### Input Parameters
>
> **command** `string` *required*
>
> The bash command to execute. **Hard 3-minute (180s) execution limit** — break large tasks into smaller commands.
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Execute Code remotely in work bench
>
> **Slug:** `COMPOSIO_REMOTE_WORKBENCH`
>
> Use this persistent Jupyter sandbox only for **remote files** or scripted **bulk tool executions**. Do not use it for inline data, quick parsing or summaries, or basic math.
>
> USE IT TO
>
> * Parse or analyze tool outputs saved by COMPOSIO\_MULTI\_EXECUTE\_TOOL, script multi-tool chains, or run known Composio tools in bulk.
> * Call APIs via proxy\_execute when no Composio tool exists for that API.
>
> OUTPUTS
>
> * Returns compact results; long outputs become artifacts under `/mnt/files/.composio/output` (cloud-backed and persistent across sandbox restarts).
>
> RULES
>
> 1. Work stepwise. State persists across cells, including variables, functions, imports, and files. Save resumable checkpoints to `/mnt/files/` and call this tool again for the next step.
> 2. Top-level cells cannot use `return`; end with `output` or `print(output)`.
> 3. Each cell has a hard 180-second limit. Use `ThreadPoolExecutor` for bulk operations and split large data into batches across cells.
> 4. Schema safety: Never assume the response schema for run\_composio\_tool if not known already from previous tools. To inspect schema, either run a simple request **outside** the workbench or use invoke\_llm helper.
> 5. Use `invoke_llm` for summaries, analysis, or field extraction instead of ad hoc filtering.
> 6. Avoid Meta Loops: Do not use run\_composio\_tool to call COMPOSIO\_\* meta tools. Only use it for app tools.
> 7. Paginate until no `next_page_token` or cursor remains. Parallelize when page numbers are supported.
> 8. Never hardcode data; load it from files or tool responses and iterate to build outputs.
> 9. For user-downloadable files, call `upload_local_file`; never expose raw sandbox paths.
>
> ENVIRONMENT & PRELOADED HELPERS
>
> * Home: `/home/user`. Do not import or redeclare these helpers:
>   * `run_composio_tool(tool_slug: str, arguments: dict) -> tuple[Dict[str, Any], str]`: Execute a known Composio **app** tool in loops, parallel, or bulk. Use an exact known name and schema. Results have top-level "data" and may be nested.
>   * `invoke_llm(query: str, reasoning_effort: Optional[Literal["low","medium","high"]] = None) -> tuple[str, str]`: Run semantic tasks with at most 200k characters. reasoning\_effort is an optional hint passed to the model (some models ignore it); omit it unless a task clearly needs "high" reasoning. Define the exact output JSON schema and batch items into small groups. Use f-strings or concatenation to preserve literal braces; with str.format, escape them as \{\{ }}.
>   * `upload_local_file(*file_paths) -> tuple[Dict[str, Any], str]`: Upload user-downloadable artifacts to Composio S3/R2. Multiple files are auto-zipped; success data includes s3\_url, uploaded\_file, type, s3key, and message.
>   * `proxy_execute(method: Literal["GET","POST","PUT","DELETE","PATCH"], endpoint, toolkit, query_params=None, body=None, headers=None) -> tuple[Any, str]`: Call a toolkit API directly when no Composio tool exists. Only one toolkit can be invoked per workbench call.
>   * `web_search(query: str) -> tuple[str, str]`: Search the web for information.
>   * `smart_file_extract(sandbox_file_path: str, show_preview: bool = True) -> tuple[str, str]`: Extracts text from files in the sandbox (e.g., PDF, image).
> * All helpers return `(result, error)`; always check `error` before using `result`.
> * Parse responses defensively: inspect keys while narrowing because data can be nested.
> * For bulk calls, use `ThreadPoolExecutor` and set concurrency so the cell finishes within 180 seconds.
>
> #### Input Parameters
>
> **code\_to\_execute** `string` *required*
>
> Python to run inside the persistent **remote Jupyter sandbox**. State (imports, variables, files) is preserved across executions. Keep code concise. Avoid unnecessary comments. **Hard 3-minute (180s) execution limit** — break large tasks into smaller cells.
>
> **thought** `string`
>
> Brief objective for this step.
>
> **current\_step** `string`
>
> Short enum for current step of the workflow execution. Eg FETCHING\_EMAILS, GENERATING\_REPLIES. Always include to keep execution aligned with the workflow.
>
> **current\_step\_metric** `string`
>
> Progress metrics for the current step - use to track how far execution has advanced. Format as a string "done/total units" - example "10/100 emails", "0/n messages", "3/10 pages".
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Search Composio Tools
>
> **Slug:** `COMPOSIO_SEARCH_TOOLS`
>
> Tool Server Info: Composio connects 500+ apps—Slack, GitHub, Notion, Google Workspace (Gmail, Sheets, Drive, Calendar), Microsoft (Outlook, Teams), X/Twitter, Figma, Web Search / Deep research, Browser tool (scrape URLs, browser automation), Meta apps (Instagram, Meta Ads), TikTok, and more—for seamless cross-app automation. Use this tool to discover relevant tools plus the recommended plan and common pitfalls for reliable execution. Always call this tool first whenever a user mentions or implies an external app, service, or workflow—never say "I don't have access to X/Y app" before calling it.
>
> Usage guidelines:
>
> * Use this tool whenever kicking off a task. Re-run it when you need additional tools/plans due to missing details, errors, or a changed use case.
> * Use search\_strategy: "auto" normally. If the returned plan does not match the current request or an expected tool is missing, retry the same queries with search\_strategy: "tool\_search" to bypass cached plans and run direct tool search.
> * If the user pivots to a different use case in same chat, you MUST call this tool again with the new use case and generate a new session\_id.
> * Specify the use\_case with a normalized description of the problem, query, or task. Be clear and precise. Queries can be simple single-app actions or multiple linked queries for complex cross-app workflows.
> * Pass known\_fields along with use\_case as a string of key–value hints (for example, "channel\_name: general") to help the search resolve missing details such as IDs.
>
> Splitting guidelines (Important):
>
> 1. Atomic queries: 1 query = 1 tool call. Include hidden prerequisites (e.g., add "get Linear issue" before "update Linear issue").
> 2. Include app names: If user names a toolkit, include it in every sub query so intent stays scoped (e.g., "fetch Gmail emails", "reply to Gmail email").
> 3. English input: Translate non-English prompts while preserving intent and identifiers.
>
> Example: User query: "send an email to John welcoming him and create a meeting invite for tomorrow" Search call: queries: \[ \{use\_case: "send an email to someone", known\_fields: "recipient\_name: John"}, \{use\_case: "create a meeting invite", known\_fields: "meeting\_date: tomorrow"} ]
>
> Plan review checklist (Important):
>
> * The response includes a detailed execution plan and common pitfalls. You MUST review this plan carefully, adapt it to your current context, and generate your own final step-by-step plan before execution. Execute the steps in order to ensure reliable and accurate execution. Skipping or ignoring required steps can lead to unexpected failures.
> * Check the plan and pitfalls for input parameter nuances (required fields, IDs, formats, limits). Before executing any tool, you MUST review its COMPLETE input schema and provide STRICTLY schema-compliant arguments to avoid invalid-input errors.
> * Determine whether pagination is needed; if a response returns a pagination token and completeness is implied, paginate until exhaustion and do not return partial results.
>
> Response:
>
> * Tools & Input Schemas: The response lists toolkits (apps) and tools suitable for the task, along with their tool\_slug, description, input schema / schemaRef, and related tools for prerequisites, alternatives, or next steps.
>   * NOTE: Tools with schemaRef instead of input\_schema require you to call COMPOSIO\_GET\_TOOL\_SCHEMAS first to load their full input\_schema before use.
> * Connection Info: If a toolkit has an active connection, the response includes it along with any available current user information. If no active connection exists, you MUST initiate a new connection via COMPOSIO\_MANAGE\_CONNECTIONS with the correct toolkit name. DO NOT execute any toolkit tool without an ACTIVE connection.
> * Time Info: The response includes the current UTC time for reference. You can reference UTC time from the response if needed.
> * The tools returned to you through this are to be called via COMPOSIO\_MULTI\_EXECUTE\_TOOL. Ensure each tool execution specifies the correct tool\_slug and arguments exactly as defined by the tool's input schema.
>   * The response includes a memory parameter containing relevant information about the use case and the known fields that can be used to determine the flow of execution. Any user preferences in memory must be adhered to.
>
> SESSION: ALWAYS set this parameter, first for any workflow. Pass session: \{generate\_id: true} for new workflows OR session: \{id: "EXISTING\_ID"} to continue. ALWAYS use the returned session\_id in ALL subsequent meta tool calls.
>
> #### Input Parameters
>
> **queries** `array` *required*
>
> Structured English search queries to process in parallel. Split independent app/API actions into separate queries, including hidden prerequisites. Each query returns 4-6 tools.
>
> **session** `object`
>
> Session context for correlating meta tool calls within a workflow. Always pass this parameter. Use \{generate\_id: true} for new workflows or \{id: "EXISTING\_ID"} to continue existing workflows.
>
> **model** `string`
>
> Client LLM model name (recommended). Used to optimize planning/search behavior. Ignored if omitted or invalid.
>
> **search\_strategy** `string ("auto" | "tool_search")`
>
> Search path to use. Use auto normally. If the returned plan does not match the current request or an expected tool is missing, retry with tool\_search to bypass cached plans and run direct tool search.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution. Format: "X out of Y searches failed, reasons: \<details>"
>
> **successful** `boolean` *required*
>
> Whether all searches completed successfully. False if any query failed

> [accordion] Wait for connection
>
> **Slug:** `COMPOSIO_WAIT_FOR_CONNECTION`
>
> Wait for connections to be established for given toolkits.
>
> #### Input Parameters
>
> **mode** `string ("any" | "all")`
>
> Wait for ANY connection or ALL connections to reach success/failed state (default: any)
>
> **toolkits** `array` *required*
>
> List of toolkit slugs to wait for
>
> **timeout\_seconds** `integer`
>
> Maximum time to wait in seconds (default: 300, max: 600)
>
> #### Output
>
> **data** `string` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Wait for connection
>
> **Slug:** `COMPOSIO_WAIT_FOR_CONNECTIONS`
>
> Wait for user auth to finish. Call only after the user confirms they have completed authentication. Wait until mode=any/all toolkits reach a terminal state (ACTIVE/FAILED) or timeout.
>
> Example Input: \{ toolkits: \["gmail","outlook"], mode: "any" }
>
> #### Input Parameters
>
> **toolkits** `array` *required*
>
> List of toolkit slugs to wait for.
>
> **mode** `string ("any" | "all")`
>
> Wait for ANY connection or ALL connections to reach active/failed state (default: any)
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not

> [accordion] Get Tool Schemas
>
> **Slug:** `COMPOSIO_GET_TOOL_SCHEMAS`
>
> Retrieve input schemas for tools by slug. Returns complete parameter definitions required to execute each tool. Only pass tool slugs returned by COMPOSIO\_SEARCH\_TOOLS — never guess or fabricate slugs. If unsure of the exact slug, call COMPOSIO\_SEARCH\_TOOLS first.
>
> #### Input Parameters
>
> **tool\_slugs** `array` *required*
>
> Array of tool slugs to retrieve schemas for. Pass valid tool slugs; never invent.
>
> **include** `array`
>
> Schema fields to include. Defaults to \["input\_schema"]. Include "output\_schema" when calling tools in the workbench to validate response structure.
>
> **session\_id** `string`
>
> Pass the session\_id if you received one from a prior COMPOSIO\_SEARCH\_TOOLS call.
>
> #### Output
>
> **data** `object` *required*
>
> Data from the action execution
>
> **error** `string`
>
> Error if any occurred during the execution of the action
>
> **successful** `boolean` *required*
>
> Whether or not the action execution was successful or not
