COMPOSIO_GET_TOOL_SCHEMAS
ChatGPTRetrieve 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.
COMPOSIO_MANAGE_CONNECTIONS
ChatGPTCreate or manage connections to user's apps. Supports multiple accounts per toolkit. 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. Actions: - "add" (default): Add a connection. Always creates a new auth link. Enforces max account limit. - "rename": Rename the alias on an existing account. Requires account_id and alias. - "list": List all connected accounts for a toolkit. Returns account IDs, aliases, and statuses. No side effects. - "remove": Remove/delete a connected account. Requires account_id. 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, call COMPOSIO_MANAGE_CONNECTIONS with action="list" and check that the newly added account is active before continuing. - Begin executing tools only after the connection is confirmed Active.
COMPOSIO_MANAGE_SKILL
ChatGPTCreate, update, or delete a Skill when the user explicitly asks. Pass exactly one of create (a new Skill), update (change an existing Skill), or delete (only for an explicit deletion request). For updates and deletions, copy the exact Skill ID returned by COMPOSIO_SEARCH_SKILLS or COMPOSIO_USE_SKILL; never invent an ID or pass a slug as an ID. If the target is ambiguous, ask the user to choose. Load the existing Skill with COMPOSIO_USE_SKILL before editing. Update never creates a Skill; if the ID is not found, search again or ask the user, never fall back to create. Preserve the title unless the user requests a rename. Pass the complete SKILL.md, preserving frontmatter and unrelated instructions; inspect for secrets or machine-specific paths before saving. Create only selected Skills. Never delete duplicates automatically.
COMPOSIO_MULTI_EXECUTE_TOOL
ChatGPTFast 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.
COMPOSIO_REMOTE_BASH_TOOL
ChatGPTExecute 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
COMPOSIO_REMOTE_WORKBENCH
ChatGPTUse 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, , account: str = None) -> tuple[Dict[str, Any], str]: Execute a known Composio **app** tool in loops, parallel, or bulk. Use an exact known name and schema; pass an account ID or alias to select an account. 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.
COMPOSIO_SEARCH_SKILLS
ChatGPTSearch reusable Skills in the current organization before doing a task that may have an existing workflow.
COMPOSIO_SEARCH_TOOLS
ChatGPTTool 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. - User has manually connected the apps: gmail, slack. Prefer these apps when intent is unclear. 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 …
COMPOSIO_SUBMIT_FEEDBACK
ChatGPTReport a Composio tool execution that returned empty or incorrect results, failed transiently, or exposed a missing capability. Use the tool_slug of the execution being reported; the most recent execution of that tool in this session is what gets reported. Keep the explanation concise and do not include tool arguments, response payloads, credentials, or other sensitive data.
COMPOSIO_USE_SKILL
ChatGPTLoad one organization Skill by its exact slug. Keep its Markdown in task context and follow it as guidance while using normal Composio tools.
COMPOSIO_WAIT_FOR_CONNECTIONS
ChatGPTWait 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" }
