@customclaw/composio 0.0.5 → 0.0.7

package/README.md

@@ -22,6 +22,7 @@ openclaw plugins install @customclaw/composio
         "enabled": true,
         "config": {
           "apiKey": "your-api-key",
+          "defaultUserId": "my-app-user-123",
           "allowedToolkits": ["gmail", "sentry"]
         }
       }
@@ -41,16 +42,19 @@ The plugin gives your agent two tools:
 - `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 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,9 +62,22 @@ 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 |
 
+## 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
 
 ```bash

package/dist/cli.js

@@ -7,13 +7,14 @@ export function registerComposioCli({ program, client, config, logger }) {
     composio
         .command("list")
         .description("List available Composio toolkits")
-        .action(async () => {
+        .option("-u, --user-id <userId>", "User ID for session scoping")
+        .action(async (options) => {
         if (!config.enabled) {
             logger.error("Composio plugin is disabled");
             return;
         }
         try {
-            const toolkits = await client.listToolkits();
+            const toolkits = await client.listToolkits(options.userId);
             console.log("\nAvailable Composio Toolkits:");
             console.log("─".repeat(40));
             for (const toolkit of toolkits.sort()) {
@@ -50,12 +51,59 @@ export function registerComposioCli({ program, client, config, logger }) {
                     console.log(`  ${icon} ${status.toolkit}: ${state}`);
                 }
             }
+            if (toolkit && statuses.length === 1 && !statuses[0]?.connected) {
+                const currentUserId = options.userId || config.defaultUserId || "default";
+                const activeUserIds = await client.findActiveUserIdsForToolkit(toolkit);
+                const otherUserIds = activeUserIds.filter((uid) => uid !== currentUserId);
+                if (otherUserIds.length > 0) {
+                    console.log(`\n  Hint: '${toolkit}' is connected under other user_id(s): ${otherUserIds.join(", ")}`);
+                    console.log(`  Try: openclaw composio status ${toolkit} --user-id <user-id>`);
+                    console.log(`  Discover accounts: openclaw composio accounts ${toolkit}`);
+                }
+            }
             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) => {
+        if (!config.enabled) {
+            logger.error("Composio plugin is disabled");
+            return;
+        }
+        try {
+            const statuses = String(options.statuses || "")
+                .split(",")
+                .map(s => s.trim())
+                .filter(Boolean);
+            const accounts = await client.listConnectedAccounts({
+                toolkits: toolkit ? [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>")
@@ -67,7 +115,9 @@ export function registerComposioCli({ program, client, config, logger }) {
             return;
         }
         try {
+            const currentUserId = options.userId || config.defaultUserId || "default";
             console.log(`\nInitiating connection to ${toolkit}...`);
+            console.log(`Using user_id: ${currentUserId}`);
             const result = await client.createConnection(toolkit, options.userId);
             if ("error" in result) {
                 logger.error(`Failed to create connection: ${result.error}`);
@@ -77,7 +127,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 ${toolkit} --user-id ${currentUserId}' to verify.\n`);
             // Try to open URL in browser
             try {
                 const { exec } = await import("node:child_process");

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,7 +14,9 @@ export declare class ComposioClient {
     /**
      * Get or create a Tool Router session for a user
      */
+    private makeSessionCacheKey;
     private getSession;
+    private clearUserSessionCache;
     /**
      * Check if a toolkit is allowed based on config
      */
@@ -34,11 +36,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()
      */