@customclaw/composio 0.0.6 → 0.0.8

package/README.md

@@ -12,7 +12,13 @@ openclaw plugins install @customclaw/composio
 
 1. Get an API key from [platform.composio.dev/settings](https://platform.composio.dev/settings)
 
-2. Add to `~/.openclaw/openclaw.json`:
+2. Run the guided setup:
+
+```bash
+openclaw composio setup
+```
+
+Or add manually to `~/.openclaw/openclaw.json`:
 
 ```json
 {
@@ -22,6 +28,7 @@ openclaw plugins install @customclaw/composio
         "enabled": true,
         "config": {
           "apiKey": "your-api-key",
+          "defaultUserId": "my-app-user-123",
           "allowedToolkits": ["gmail", "sentry"]
         }
       }
@@ -30,27 +37,41 @@ openclaw plugins install @customclaw/composio
 }
 ```
 
-Or set `COMPOSIO_API_KEY` as an environment variable.
+You can also set `COMPOSIO_API_KEY` as an environment variable.
 
 3. Restart the gateway.
 
+If you upgraded from an older config shape where keys like `defaultUserId` or `allowedToolkits`
+were placed directly under `plugins.entries.composio`, rerun:
+
+```bash
+openclaw composio setup
+```
+
+Legacy mixed entry-level config keys are now rejected at runtime.
+
 ## What it does
 
-The plugin gives your agent two tools:
+The plugin gives your agent three tools:
 
+- `composio_search_tools` — discovers relevant Composio actions from natural-language intent
 - `composio_execute_tool` — runs a Composio action (e.g. `GMAIL_FETCH_EMAILS`, `SENTRY_LIST_ISSUES`)
 - `composio_manage_connections` — checks connection status and generates OAuth links when a toolkit isn't connected yet
 
+`composio_execute_tool` also accepts optional `user_id` and `connected_account_id` fields for deterministic account selection when multiple accounts exist.
+
 The agent handles the rest. Ask it to "check my latest emails" and it will call the right tool, prompt you to connect Gmail if needed, and fetch the results.
 
 ## CLI
 
 ```bash
-openclaw composio list                          # list available toolkits
-openclaw composio status                        # check what's connected
-openclaw composio connect gmail                 # open OAuth link
-openclaw composio disconnect gmail              # remove a connection
-openclaw composio search "send email"           # find tool slugs
+openclaw composio setup                                 # interactive setup for ~/.openclaw/openclaw.json
+openclaw composio list --user-id user-123               # list available toolkits for a user scope
+openclaw composio status [toolkit] --user-id user-123   # check connection status in a user scope
+openclaw composio accounts [toolkit]                    # inspect connected accounts (id/user_id/status)
+openclaw composio connect gmail --user-id user-123      # open OAuth link for a specific user scope
+openclaw composio disconnect gmail --user-id user-123   # remove a connection in that user scope
+openclaw composio search "send email" --user-id user-123
 ```
 
 ## Config options
@@ -58,8 +79,25 @@ openclaw composio search "send email"           # find tool slugs
 | Key | Description |
 |-----|-------------|
 | `apiKey` | Composio API key (required) |
+| `defaultUserId` | Default Composio `user_id` scope when `--user-id` is not provided |
 | `allowedToolkits` | Only allow these toolkits (e.g. `["gmail", "sentry"]`) |
 | `blockedToolkits` | Block specific toolkits |
+| `readOnlyMode` | Blocks likely-destructive actions by token matching (delete/update/create/send/etc.); use `allowedToolSlugs` to override safe exceptions |
+| `sessionTags` | Optional Tool Router tags (`readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint`) |
+| `allowedToolSlugs` | Optional explicit allowlist of UPPERCASE tool slugs |
+| `blockedToolSlugs` | Explicit denylist of UPPERCASE tool slugs |
+
+## User ID Scope (Important)
+
+Composio connections are scoped by `user_id`. If a toolkit is connected in the dashboard
+under one user ID but OpenClaw checks another (for example `default`), status and execution
+may look disconnected.
+
+Tips:
+
+- Set `defaultUserId` in plugin config for your app's primary identity.
+- Use `--user-id` explicitly when checking status/connect/disconnect.
+- Use `openclaw composio accounts <toolkit>` to discover which `user_id` owns active connections.
 
 ## Updating
 
@@ -78,6 +116,24 @@ npm run build
 npm test
 ```
 
+### Live Integration Tests (Optional)
+
+```bash
+COMPOSIO_LIVE_TEST=1 \
+COMPOSIO_API_KEY=your_key \
+npm run test:live
+```
+
+Optional env vars for execution/disconnect paths:
+
+- `COMPOSIO_LIVE_USER_ID`
+- `COMPOSIO_LIVE_TOOLKIT` (default: `gmail`)
+- `COMPOSIO_LIVE_TOOL_SLUG`
+- `COMPOSIO_LIVE_TOOL_ARGS` (JSON)
+- `COMPOSIO_LIVE_CONNECTED_ACCOUNT_ID`
+- `COMPOSIO_LIVE_EXPECT_EXECUTE_SUCCESS=1`
+- `COMPOSIO_LIVE_ALLOW_DISCONNECT=1` (destructive, opt-in)
+
 ## Acknowledgments
 
 Based on the Composio plugin from [openclaw-composio](https://github.com/ComposioHQ/openclaw-composio) by ComposioHQ. See [THIRD-PARTY-NOTICES](./THIRD-PARTY-NOTICES).

package/dist/cli.d.ts

@@ -7,12 +7,12 @@ interface PluginLogger {
 }
 interface RegisterCliOptions {
     program: any;
-    client: ComposioClient;
+    getClient?: () => ComposioClient;
     config: ComposioConfig;
     logger: PluginLogger;
 }
 /**
  * Register Composio CLI commands
  */
-export declare function registerComposioCli({ program, client, config, logger }: RegisterCliOptions): void;
+export declare function registerComposioCli({ program, getClient, config, logger }: RegisterCliOptions): void;
 export {};

package/dist/cli.js

@@ -1,19 +1,253 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+import { isRecord, normalizeToolkitList, normalizeToolkitSlug, stripLegacyFlatConfigKeys, } from "./utils.js";
+const DEFAULT_OPENCLAW_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
+const COMPOSIO_PLUGIN_ID = "composio";
+function parseCsvToolkits(value) {
+    if (!value)
+        return undefined;
+    return normalizeToolkitList(value.split(","));
+}
+function parseBooleanLike(value) {
+    const raw = value.trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    if (["1", "true", "yes", "y"].includes(raw))
+        return true;
+    if (["0", "false", "no", "n"].includes(raw))
+        return false;
+    return undefined;
+}
+function normalizePluginIdList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const normalized = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return Array.from(new Set(normalized));
+}
+async function readOpenClawConfig(configPath) {
+    try {
+        const raw = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch (err) {
+        const nodeErr = err;
+        if (nodeErr?.code === "ENOENT")
+            return {};
+        throw err;
+    }
+}
 /**
  * Register Composio CLI commands
  */
-export function registerComposioCli({ program, client, config, logger }) {
+export function registerComposioCli({ program, getClient, config, logger }) {
     const composio = program.command("composio").description("Manage Composio Tool Router connections");
+    const requireClient = () => {
+        if (!config.enabled) {
+            logger.error("Composio plugin is disabled");
+            return null;
+        }
+        if (!getClient) {
+            logger.error("Composio API key is not configured. Run 'openclaw composio setup' first.");
+            return null;
+        }
+        try {
+            return getClient();
+        }
+        catch (err) {
+            logger.error(`Failed to initialize Composio client: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    };
+    // openclaw composio setup
+    composio
+        .command("setup")
+        .description("Create or update Composio config in ~/.openclaw/openclaw.json")
+        .option("-c, --config-path <path>", "OpenClaw config file path", DEFAULT_OPENCLAW_CONFIG_PATH)
+        .option("--api-key <apiKey>", "Composio API key")
+        .option("--default-user-id <userId>", "Default user ID for Composio user scoping")
+        .option("--allowed-toolkits <toolkits>", "Comma-separated allowed toolkit slugs")
+        .option("--blocked-toolkits <toolkits>", "Comma-separated blocked toolkit slugs")
+        .option("--read-only <enabled>", "Enable read-only mode (true/false)")
+        .option("-y, --yes", "Skip prompts and use defaults/provided values")
+        .action(async (options) => {
+        const configPath = path.resolve(options.configPath || DEFAULT_OPENCLAW_CONFIG_PATH);
+        try {
+            const openClawConfig = await readOpenClawConfig(configPath);
+            const plugins = isRecord(openClawConfig.plugins) ? { ...openClawConfig.plugins } : {};
+            let updatedPluginSystemEnabled = false;
+            let addedToAllowlist = false;
+            let removedFromDenylist = false;
+            if (plugins.enabled === false) {
+                plugins.enabled = true;
+                updatedPluginSystemEnabled = true;
+            }
+            const allow = normalizePluginIdList(plugins.allow);
+            if (allow && allow.length > 0) {
+                const hasExactComposio = allow.includes(COMPOSIO_PLUGIN_ID);
+                const normalizedAllow = allow.filter((id) => id.toLowerCase() !== COMPOSIO_PLUGIN_ID);
+                normalizedAllow.push(COMPOSIO_PLUGIN_ID);
+                plugins.allow = Array.from(new Set(normalizedAllow));
+                if (!hasExactComposio) {
+                    addedToAllowlist = true;
+                }
+            }
+            const deny = normalizePluginIdList(plugins.deny);
+            if (deny && deny.length > 0) {
+                const filteredDeny = deny.filter((id) => id.toLowerCase() !== COMPOSIO_PLUGIN_ID);
+                if (filteredDeny.length !== deny.length) {
+                    removedFromDenylist = true;
+                }
+                if (filteredDeny.length > 0) {
+                    plugins.deny = filteredDeny;
+                }
+                else {
+                    delete plugins.deny;
+                }
+            }
+            const entries = isRecord(plugins.entries) ? { ...plugins.entries } : {};
+            const existingComposioEntry = isRecord(entries.composio) ? { ...entries.composio } : {};
+            const existingComposioConfig = isRecord(existingComposioEntry.config)
+                ? { ...existingComposioEntry.config }
+                : {};
+            let apiKey = String(options.apiKey || "").trim() ||
+                String(existingComposioConfig.apiKey || "").trim() ||
+                String(config.apiKey || "").trim() ||
+                String(process.env.COMPOSIO_API_KEY || "").trim();
+            let defaultUserId = String(options.defaultUserId || "").trim() ||
+                String(existingComposioConfig.defaultUserId || "").trim() ||
+                String(config.defaultUserId || "").trim();
+            let allowedToolkits = parseCsvToolkits(options.allowedToolkits) ||
+                (Array.isArray(existingComposioConfig.allowedToolkits)
+                    ? normalizeToolkitList(existingComposioConfig.allowedToolkits)
+                    : normalizeToolkitList(config.allowedToolkits));
+            let blockedToolkits = parseCsvToolkits(options.blockedToolkits) ||
+                (Array.isArray(existingComposioConfig.blockedToolkits)
+                    ? normalizeToolkitList(existingComposioConfig.blockedToolkits)
+                    : normalizeToolkitList(config.blockedToolkits));
+            let readOnlyMode = typeof existingComposioConfig.readOnlyMode === "boolean"
+                ? existingComposioConfig.readOnlyMode
+                : Boolean(config.readOnlyMode);
+            if (options.readOnly !== undefined) {
+                const parsedReadOnly = parseBooleanLike(options.readOnly);
+                if (parsedReadOnly === undefined) {
+                    logger.error("Invalid value for --read-only. Expected one of: true/false/yes/no/1/0.");
+                    return;
+                }
+                readOnlyMode = parsedReadOnly;
+            }
+            if (!options.yes) {
+                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                    const apiKeyPrompt = await rl.question(`Composio API key${apiKey ? " [configured]" : ""}: `);
+                    if (apiKeyPrompt.trim())
+                        apiKey = apiKeyPrompt.trim();
+                    const defaultUserPrompt = await rl.question(`Default user ID${defaultUserId ? ` [${defaultUserId}]` : " (optional)"}: `);
+                    if (defaultUserPrompt.trim())
+                        defaultUserId = defaultUserPrompt.trim();
+                    const allowedDefault = allowedToolkits && allowedToolkits.length > 0
+                        ? ` [${allowedToolkits.join(",")}]`
+                        : " (optional)";
+                    const allowedPrompt = await rl.question(`Allowed toolkits${allowedDefault}: `);
+                    if (allowedPrompt.trim()) {
+                        allowedToolkits = parseCsvToolkits(allowedPrompt) || [];
+                    }
+                    const blockedDefault = blockedToolkits && blockedToolkits.length > 0
+                        ? ` [${blockedToolkits.join(",")}]`
+                        : " (optional)";
+                    const blockedPrompt = await rl.question(`Blocked toolkits${blockedDefault}: `);
+                    if (blockedPrompt.trim()) {
+                        blockedToolkits = parseCsvToolkits(blockedPrompt) || [];
+                    }
+                    const readOnlyPrompt = await rl.question(`Enable read-only safety mode? (y/N) [${readOnlyMode ? "Y" : "N"}]: `);
+                    const parsedReadOnlyPrompt = parseBooleanLike(readOnlyPrompt);
+                    if (parsedReadOnlyPrompt !== undefined) {
+                        readOnlyMode = parsedReadOnlyPrompt;
+                    }
+                    else if (readOnlyPrompt.trim()) {
+                        logger.warn("Invalid read-only input. Keeping existing readOnlyMode value.");
+                    }
+                }
+                finally {
+                    rl.close();
+                }
+            }
+            if (!apiKey) {
+                logger.error("Composio API key is required. Provide --api-key or set COMPOSIO_API_KEY.");
+                return;
+            }
+            const mergedComposioConfig = {
+                ...existingComposioConfig,
+                apiKey,
+                readOnlyMode,
+            };
+            if (defaultUserId) {
+                mergedComposioConfig.defaultUserId = defaultUserId;
+            }
+            else {
+                delete mergedComposioConfig.defaultUserId;
+            }
+            if (allowedToolkits && allowedToolkits.length > 0) {
+                mergedComposioConfig.allowedToolkits = allowedToolkits;
+            }
+            else {
+                delete mergedComposioConfig.allowedToolkits;
+            }
+            if (blockedToolkits && blockedToolkits.length > 0) {
+                mergedComposioConfig.blockedToolkits = blockedToolkits;
+            }
+            else {
+                delete mergedComposioConfig.blockedToolkits;
+            }
+            entries.composio = {
+                ...stripLegacyFlatConfigKeys(existingComposioEntry),
+                enabled: true,
+                config: mergedComposioConfig,
+            };
+            plugins.entries = entries;
+            openClawConfig.plugins = plugins;
+            await mkdir(path.dirname(configPath), { recursive: true });
+            await writeFile(configPath, `${JSON.stringify(openClawConfig, null, 2)}\n`, "utf8");
+            console.log("\nComposio setup saved.");
+            console.log("─".repeat(40));
+            console.log(`Config: ${configPath}`);
+            console.log(`defaultUserId: ${defaultUserId || "default"}`);
+            console.log(`readOnlyMode: ${readOnlyMode ? "enabled" : "disabled"}`);
+            if (updatedPluginSystemEnabled) {
+                console.log("plugins.enabled: set to true");
+            }
+            if (addedToAllowlist) {
+                console.log("plugins.allow: added 'composio'");
+            }
+            if (removedFromDenylist) {
+                console.log("plugins.deny: removed 'composio'");
+            }
+            console.log("\nNext steps:");
+            console.log("  1) openclaw gateway restart");
+            console.log("  2) openclaw composio status --user-id <user-id>");
+            console.log();
+        }
+        catch (err) {
+            logger.error(`Failed to run setup: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
     // openclaw composio list
     composio
         .command("list")
         .description("List available Composio toolkits")
-        .action(async () => {
-        if (!config.enabled) {
-            logger.error("Composio plugin is disabled");
+        .option("-u, --user-id <userId>", "User ID for session scoping")
+        .action(async (options) => {
+        const composioClient = requireClient();
+        if (!composioClient)
             return;
-        }
         try {
-            const toolkits = await client.listToolkits();
+            const toolkits = await composioClient.listToolkits(options.userId);
             console.log("\nAvailable Composio Toolkits:");
             console.log("─".repeat(40));
             for (const toolkit of toolkits.sort()) {
@@ -31,13 +265,13 @@ export function registerComposioCli({ program, client, config, logger }) {
         .description("Check connection status for toolkits")
         .option("-u, --user-id <userId>", "User ID for session scoping")
         .action(async (toolkit, options) => {
-        if (!config.enabled) {
-            logger.error("Composio plugin is disabled");
+        const composioClient = requireClient();
+        if (!composioClient)
             return;
-        }
         try {
-            const toolkits = toolkit ? [toolkit] : undefined;
-            const statuses = await client.getConnectionStatus(toolkits, options.userId);
+            const toolkitSlug = toolkit ? normalizeToolkitSlug(toolkit) : undefined;
+            const toolkits = toolkitSlug ? [toolkitSlug] : undefined;
+            const statuses = await composioClient.getConnectionStatus(toolkits, options.userId);
             console.log("\nComposio Connection Status:");
             console.log("─".repeat(40));
             if (statuses.length === 0) {
@@ -50,25 +284,73 @@ export function registerComposioCli({ program, client, config, logger }) {
                     console.log(`  ${icon} ${status.toolkit}: ${state}`);
                 }
             }
+            if (toolkitSlug && statuses.length === 1 && !statuses[0]?.connected) {
+                const currentUserId = options.userId || config.defaultUserId || "default";
+                const activeUserIds = await composioClient.findActiveUserIdsForToolkit(toolkitSlug);
+                const otherUserIds = activeUserIds.filter((uid) => uid !== currentUserId);
+                if (otherUserIds.length > 0) {
+                    console.log(`\n  Hint: '${toolkitSlug}' is connected under other user_id(s): ${otherUserIds.join(", ")}`);
+                    console.log(`  Try: openclaw composio status ${toolkitSlug} --user-id <user-id>`);
+                    console.log(`  Discover accounts: openclaw composio accounts ${toolkitSlug}`);
+                }
+            }
             console.log();
         }
         catch (err) {
             logger.error(`Failed to get status: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
+    // openclaw composio accounts [toolkit]
+    composio
+        .command("accounts [toolkit]")
+        .description("List connected accounts (account IDs, user IDs, and statuses)")
+        .option("-u, --user-id <userId>", "Filter by user ID")
+        .option("-s, --statuses <statuses>", "Comma-separated statuses (default: ACTIVE)", "ACTIVE")
+        .action(async (toolkit, options) => {
+        const composioClient = requireClient();
+        if (!composioClient)
+            return;
+        try {
+            const statuses = String(options.statuses || "")
+                .split(",")
+                .map(s => s.trim())
+                .filter(Boolean);
+            const accounts = await composioClient.listConnectedAccounts({
+                toolkits: toolkit ? [normalizeToolkitSlug(toolkit)] : undefined,
+                userIds: options.userId ? [options.userId] : undefined,
+                statuses: statuses.length > 0 ? statuses : ["ACTIVE"],
+            });
+            console.log("\nComposio Connected Accounts:");
+            console.log("─".repeat(80));
+            if (accounts.length === 0) {
+                console.log("  No connected accounts found");
+                console.log();
+                return;
+            }
+            for (const account of accounts) {
+                console.log(`  ${account.id} | toolkit=${account.toolkit} | status=${account.status || "unknown"} | user_id=${account.userId || "hidden"}`);
+            }
+            console.log(`\nTotal: ${accounts.length} connected accounts\n`);
+        }
+        catch (err) {
+            logger.error(`Failed to list connected accounts: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
     // openclaw composio connect <toolkit>
     composio
         .command("connect <toolkit>")
         .description("Connect to a Composio toolkit (opens auth URL)")
         .option("-u, --user-id <userId>", "User ID for session scoping")
         .action(async (toolkit, options) => {
-        if (!config.enabled) {
-            logger.error("Composio plugin is disabled");
+        const composioClient = requireClient();
+        if (!composioClient)
             return;
-        }
         try {
-            console.log(`\nInitiating connection to ${toolkit}...`);
-            const result = await client.createConnection(toolkit, options.userId);
+            const toolkitSlug = normalizeToolkitSlug(toolkit);
+            const currentUserId = options.userId || config.defaultUserId || "default";
+            console.log(`\nInitiating connection to ${toolkitSlug}...`);
+            console.log(`Using user_id: ${currentUserId}`);
+            const result = await composioClient.createConnection(toolkitSlug, options.userId);
             if ("error" in result) {
                 logger.error(`Failed to create connection: ${result.error}`);
                 return;
@@ -77,7 +359,7 @@ export function registerComposioCli({ program, client, config, logger }) {
             console.log("─".repeat(40));
             console.log(result.authUrl);
             console.log("\nOpen this URL in your browser to authenticate.");
-            console.log("After authentication, run 'openclaw composio status' to verify.\n");
+            console.log(`After authentication, run 'openclaw composio status ${toolkitSlug} --user-id ${currentUserId}' to verify.\n`);
             // Try to open URL in browser
             try {
                 const { exec } = await import("node:child_process");
@@ -103,15 +385,15 @@ export function registerComposioCli({ program, client, config, logger }) {
         .description("Disconnect from a Composio toolkit")
         .option("-u, --user-id <userId>", "User ID for session scoping")
         .action(async (toolkit, options) => {
-        if (!config.enabled) {
-            logger.error("Composio plugin is disabled");
+        const composioClient = requireClient();
+        if (!composioClient)
             return;
-        }
         try {
-            console.log(`\nDisconnecting from ${toolkit}...`);
-            const result = await client.disconnectToolkit(toolkit, options.userId);
+            const toolkitSlug = normalizeToolkitSlug(toolkit);
+            console.log(`\nDisconnecting from ${toolkitSlug}...`);
+            const result = await composioClient.disconnectToolkit(toolkitSlug, options.userId);
             if (result.success) {
-                console.log(`Successfully disconnected from ${toolkit}\n`);
+                console.log(`Successfully disconnected from ${toolkitSlug}\n`);
             }
             else {
                 logger.error(`Failed to disconnect: ${result.error}`);
@@ -129,14 +411,13 @@ export function registerComposioCli({ program, client, config, logger }) {
         .option("-l, --limit <limit>", "Maximum results", "10")
         .option("-u, --user-id <userId>", "User ID for session scoping")
         .action(async (query, options) => {
-        if (!config.enabled) {
-            logger.error("Composio plugin is disabled");
+        const composioClient = requireClient();
+        if (!composioClient)
             return;
-        }
         try {
             const limit = parseInt(options.limit, 10) || 10;
-            const toolkits = options.toolkit ? [options.toolkit] : undefined;
-            const results = await client.searchTools(query, {
+            const toolkits = options.toolkit ? [normalizeToolkitSlug(options.toolkit)] : undefined;
+            const results = await composioClient.searchTools(query, {
                 toolkits,
                 limit,
                 userId: options.userId,

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ComposioConfig, ToolSearchResult, ToolExecutionResult, ConnectionStatus } from "./types.js";
+import type { ComposioConfig, ToolSearchResult, ToolExecutionResult, ConnectionStatus, ConnectedAccountSummary } from "./types.js";
 /**
  * Composio client wrapper using Tool Router pattern
  */
@@ -14,11 +14,19 @@ export declare class ComposioClient {
     /**
      * Get or create a Tool Router session for a user
      */
+    private makeSessionCacheKey;
+    private normalizeConnectedAccountsOverride;
+    private buildToolRouterBlockedToolsConfig;
+    private buildSessionConfig;
     private getSession;
+    private shouldRetrySessionWithoutToolkitFilters;
+    private clearUserSessionCache;
     /**
      * Check if a toolkit is allowed based on config
      */
     private isToolkitAllowed;
+    private isLikelyDestructiveToolSlug;
+    private getToolSlugRestrictionError;
     /**
      * Execute a Tool Router meta-tool
      */
@@ -34,11 +42,41 @@ export declare class ComposioClient {
     /**
      * Execute a single tool using COMPOSIO_MULTI_EXECUTE_TOOL
      */
-    executeTool(toolSlug: string, args: Record<string, unknown>, userId?: string): Promise<ToolExecutionResult>;
+    executeTool(toolSlug: string, args: Record<string, unknown>, userId?: string, connectedAccountId?: string): Promise<ToolExecutionResult>;
+    private tryExecutionRecovery;
+    private tryDirectExecutionFallback;
+    private executeDirectTool;
+    private tryHintedIdentifierRetry;
+    private shouldFallbackToDirectExecution;
+    private shouldRetryFromServerHint;
+    private extractServerHintLiteral;
+    private buildRetryArgsFromHint;
+    private extractSingleMissingField;
+    private buildCombinedErrorText;
+    private extractNestedMetaError;
+    private resolveConnectedAccountForExecution;
     /**
      * Get connection status for toolkits using session.toolkits()
      */
     getConnectionStatus(toolkits?: string[], userId?: string): Promise<ConnectionStatus[]>;
+    private getToolkitStateMap;
+    private getActiveConnectedAccountToolkits;
+    private normalizeStatuses;
+    /**
+     * List connected accounts with optional filters.
+     * Uses raw API first to preserve user_id in responses, then falls back to SDK-normalized output.
+     */
+    listConnectedAccounts(options?: {
+        toolkits?: string[];
+        userIds?: string[];
+        statuses?: string[];
+    }): Promise<ConnectedAccountSummary[]>;
+    /**
+     * Find user IDs that have an active connected account for a toolkit.
+     */
+    findActiveUserIdsForToolkit(toolkit: string): Promise<string[]>;
+    private listConnectedAccountsRaw;
+    private listConnectedAccountsFallback;
     /**
      * Create an auth connection for a toolkit using session.authorize()
      */