@customclaw/composio 0.0.3 → 0.0.5

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ComposioConfig, ToolSearchResult, ToolExecutionResult, MultiExecutionItem, MultiExecutionResult, ConnectionStatus } from "./types.js";
+import type { ComposioConfig, ToolSearchResult, ToolExecutionResult, ConnectionStatus } from "./types.js";
 /**
  * Composio client wrapper using Tool Router pattern
  */
@@ -35,10 +35,6 @@ export declare class ComposioClient {
      * Execute a single tool using COMPOSIO_MULTI_EXECUTE_TOOL
      */
     executeTool(toolSlug: string, args: Record<string, unknown>, userId?: string): Promise<ToolExecutionResult>;
-    /**
-     * Execute multiple tools in parallel using COMPOSIO_MULTI_EXECUTE_TOOL
-     */
-    multiExecute(executions: MultiExecutionItem[], userId?: string): Promise<MultiExecutionResult>;
     /**
      * Get connection status for toolkits using session.toolkits()
      */
@@ -62,31 +58,6 @@ export declare class ComposioClient {
         success: boolean;
         error?: string;
     }>;
-    /**
-     * Get the assistive prompt for the agent
-     */
-    getAssistivePrompt(userId?: string): Promise<string>;
-    /**
-     * Execute Python code in the remote workbench using COMPOSIO_REMOTE_WORKBENCH
-     */
-    executeWorkbench(code: string, options?: {
-        thought?: string;
-        currentStep?: string;
-        currentStepMetric?: string;
-        userId?: string;
-    }): Promise<{
-        success: boolean;
-        output?: unknown;
-        error?: string;
-    }>;
-    /**
-     * Execute bash commands in the remote sandbox using COMPOSIO_REMOTE_BASH_TOOL
-     */
-    executeBash(command: string, userId?: string): Promise<{
-        success: boolean;
-        output?: unknown;
-        error?: string;
-    }>;
 }
 /**
  * Create a Composio client instance

package/dist/client.js

@@ -150,60 +150,6 @@ export class ComposioClient {
             };
         }
     }
-    /**
-     * Execute multiple tools in parallel using COMPOSIO_MULTI_EXECUTE_TOOL
-     */
-    async multiExecute(executions, userId) {
-        const uid = this.getUserId(userId);
-        const session = await this.getSession(uid);
-        // Filter out blocked toolkits and limit to 50
-        const allowedExecutions = executions
-            .filter(exec => {
-            const toolkit = exec.tool_slug.split("_")[0]?.toLowerCase() || "";
-            return this.isToolkitAllowed(toolkit);
-        })
-            .slice(0, 50);
-        if (allowedExecutions.length === 0) {
-            return { results: [] };
-        }
-        try {
-            const response = await this.executeMetaTool("COMPOSIO_MULTI_EXECUTE_TOOL", {
-                tools: allowedExecutions.map(exec => ({
-                    tool_slug: exec.tool_slug,
-                    arguments: exec.arguments,
-                })),
-                session: { id: session.sessionId },
-                sync_response_to_workbench: false,
-            });
-            if (!response.successful) {
-                return {
-                    results: allowedExecutions.map(exec => ({
-                        tool_slug: exec.tool_slug,
-                        success: false,
-                        error: response.error || "Execution failed",
-                    })),
-                };
-            }
-            const apiResults = response.data?.results || [];
-            return {
-                results: apiResults.map(r => ({
-                    tool_slug: r.tool_slug,
-                    success: r.response.successful,
-                    data: r.response.data,
-                    error: r.response.error ?? undefined,
-                })),
-            };
-        }
-        catch (err) {
-            return {
-                results: allowedExecutions.map(exec => ({
-                    tool_slug: exec.tool_slug,
-                    success: false,
-                    error: err instanceof Error ? err.message : String(err),
-                })),
-            };
-        }
-    }
     /**
      * Get connection status for toolkits using session.toolkits()
      */
@@ -314,69 +260,6 @@ export class ComposioClient {
             };
         }
     }
-    /**
-     * Get the assistive prompt for the agent
-     */
-    async getAssistivePrompt(userId) {
-        const uid = this.getUserId(userId);
-        const session = await this.getSession(uid);
-        return session.experimental.assistivePrompt;
-    }
-    /**
-     * Execute Python code in the remote workbench using COMPOSIO_REMOTE_WORKBENCH
-     */
-    async executeWorkbench(code, options) {
-        const uid = this.getUserId(options?.userId);
-        const session = await this.getSession(uid);
-        try {
-            const response = await this.executeMetaTool("COMPOSIO_REMOTE_WORKBENCH", {
-                code_to_execute: code,
-                session_id: session.sessionId,
-                ...(options?.thought ? { thought: options.thought } : {}),
-                ...(options?.currentStep ? { current_step: options.currentStep } : {}),
-                ...(options?.currentStepMetric ? { current_step_metric: options.currentStepMetric } : {}),
-            });
-            if (!response.successful) {
-                return { success: false, error: response.error || "Workbench execution failed" };
-            }
-            return {
-                success: true,
-                output: response.data,
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
-    /**
-     * Execute bash commands in the remote sandbox using COMPOSIO_REMOTE_BASH_TOOL
-     */
-    async executeBash(command, userId) {
-        const uid = this.getUserId(userId);
-        const session = await this.getSession(uid);
-        try {
-            const response = await this.executeMetaTool("COMPOSIO_REMOTE_BASH_TOOL", {
-                command,
-                session_id: session.sessionId,
-            });
-            if (!response.successful) {
-                return { success: false, error: response.error || "Bash execution failed" };
-            }
-            return {
-                success: true,
-                output: response.data,
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
 }
 /**
  * Create a Composio client instance

package/dist/client.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from "vitest";
 import { ComposioClient } from "./client.js";
 import { parseComposioConfig } from "./config.js";
+import { createComposioExecuteTool } from "./tools/execute.js";
 // Mock the Composio SDK
 vi.mock("@composio/core", () => ({
     Composio: vi.fn().mockImplementation(() => ({
@@ -143,3 +144,41 @@ describe("session caching", () => {
         expect(instance.toolRouter.create).toHaveBeenCalledTimes(1);
     });
 });
+describe("execute tool string arguments (GLM-5 workaround)", () => {
+    function makeTool() {
+        const client = makeClient();
+        const config = parseComposioConfig({ config: { apiKey: "test-key" } });
+        return createComposioExecuteTool(client, config);
+    }
+    it("parses string arguments as JSON", async () => {
+        const tool = makeTool();
+        const result = await tool.execute("test", {
+            tool_slug: "GMAIL_FETCH_EMAILS",
+            arguments: '{"user_id": "me", "max_results": 5}',
+        });
+        expect(result.details).toHaveProperty("success", true);
+    });
+    it("handles object arguments normally", async () => {
+        const tool = makeTool();
+        const result = await tool.execute("test", {
+            tool_slug: "GMAIL_FETCH_EMAILS",
+            arguments: { user_id: "me", max_results: 5 },
+        });
+        expect(result.details).toHaveProperty("success", true);
+    });
+    it("falls back to empty args on invalid JSON string", async () => {
+        const tool = makeTool();
+        const result = await tool.execute("test", {
+            tool_slug: "GMAIL_FETCH_EMAILS",
+            arguments: "not valid json",
+        });
+        expect(result.details).toHaveProperty("success", true);
+    });
+    it("falls back to empty args when arguments is missing", async () => {
+        const tool = makeTool();
+        const result = await tool.execute("test", {
+            tool_slug: "GMAIL_FETCH_EMAILS",
+        });
+        expect(result.details).toHaveProperty("success", true);
+    });
+});

package/dist/tools/execute.js

@@ -31,8 +31,15 @@ export function createComposioExecuteTool(client, _config) {
                     details: { error: "tool_slug is required" },
                 };
             }
-            const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments)
-                ? params.arguments
+            let rawArgs = params.arguments;
+            if (typeof rawArgs === "string") {
+                try {
+                    rawArgs = JSON.parse(rawArgs);
+                }
+                catch { }
+            }
+            const args = rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)
+                ? rawArgs
                 : {};
             const userId = typeof params.user_id === "string" ? params.user_id : undefined;
             try {

package/dist/types.d.ts

@@ -20,27 +20,9 @@ export interface ToolExecutionResult {
     data?: unknown;
     error?: string;
 }
-export interface MultiExecutionItem {
-    tool_slug: string;
-    arguments: Record<string, unknown>;
-}
-export interface MultiExecutionResult {
-    results: Array<{
-        tool_slug: string;
-        success: boolean;
-        data?: unknown;
-        error?: string;
-    }>;
-}
 export interface ConnectionStatus {
     toolkit: string;
     connected: boolean;
     userId?: string;
     authUrl?: string;
 }
-export interface ComposioClientOptions {
-    apiKey: string;
-    defaultUserId?: string;
-    allowedToolkits?: string[];
-    blockedToolkits?: string[];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customclaw/composio",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "description": "Composio Tool Router plugin for OpenClaw — access 1000+ third-party integrations",
   "main": "dist/index.js",

package/dist/tools/bash.d.ts

@@ -1,42 +0,0 @@
-import type { ComposioClient } from "../client.js";
-import type { ComposioConfig } from "../types.js";
-/**
- * Tool parameters for composio_bash
- */
-export declare const CompositoBashSchema: import("@sinclair/typebox").TObject<{
-    command: import("@sinclair/typebox").TString;
-    user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/**
- * Create the composio_bash tool
- */
-export declare function createCompositoBashTool(client: ComposioClient, _config: ComposioConfig): {
-    name: string;
-    label: string;
-    description: string;
-    parameters: import("@sinclair/typebox").TObject<{
-        command: import("@sinclair/typebox").TString;
-        user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-    execute(_toolCallId: string, params: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            error: string;
-        };
-    } | {
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            output: unknown;
-            success: boolean;
-        } | {
-            error: string | undefined;
-            success: boolean;
-        };
-    }>;
-};

package/dist/tools/bash.js

@@ -1,59 +0,0 @@
-import { Type } from "@sinclair/typebox";
-/**
- * Tool parameters for composio_bash
- */
-export const CompositoBashSchema = Type.Object({
-    command: Type.String({
-        description: "Bash command to execute in the remote sandbox. " +
-            "Use for file operations, data processing with jq/awk/sed/grep, " +
-            "or handling large tool responses saved to remote files. " +
-            "Commands run from /home/user directory by default.",
-    }),
-    user_id: Type.Optional(Type.String({
-        description: "User ID for session scoping (uses default if not provided)",
-    })),
-});
-/**
- * Create the composio_bash tool
- */
-export function createCompositoBashTool(client, _config) {
-    return {
-        name: "composio_bash",
-        label: "Composio Remote Bash",
-        description: "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. " +
-            "Use shell tools like jq, awk, sed, grep for data extraction.",
-        parameters: CompositoBashSchema,
-        async execute(_toolCallId, params) {
-            const command = String(params.command || "").trim();
-            if (!command) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: "command is required" }, null, 2) }],
-                    details: { error: "command is required" },
-                };
-            }
-            const userId = typeof params.user_id === "string" ? params.user_id : undefined;
-            try {
-                const result = await client.executeBash(command, userId);
-                const response = {
-                    success: result.success,
-                    ...(result.success ? { output: result.output } : { error: result.error }),
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
-                    details: response,
-                };
-            }
-            catch (err) {
-                const errorResponse = {
-                    success: false,
-                    error: err instanceof Error ? err.message : String(err),
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                    details: errorResponse,
-                };
-            }
-        },
-    };
-}

package/dist/tools/multi-execute.d.ts

@@ -1,52 +0,0 @@
-import type { ComposioClient } from "../client.js";
-import type { ComposioConfig } from "../types.js";
-/**
- * Tool parameters for composio_multi_execute
- */
-export declare const ComposioMultiExecuteToolSchema: import("@sinclair/typebox").TObject<{
-    executions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        tool_slug: import("@sinclair/typebox").TString;
-        arguments: import("@sinclair/typebox").TUnknown;
-    }>>;
-    user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/**
- * Create the composio_multi_execute tool
- */
-export declare function createComposioMultiExecuteTool(client: ComposioClient, _config: ComposioConfig): {
-    name: string;
-    label: string;
-    description: string;
-    parameters: import("@sinclair/typebox").TObject<{
-        executions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-            tool_slug: import("@sinclair/typebox").TString;
-            arguments: import("@sinclair/typebox").TUnknown;
-        }>>;
-        user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-    execute(_toolCallId: string, params: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            error: string;
-        };
-    } | {
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            total: number;
-            succeeded: number;
-            failed: number;
-            results: {
-                tool_slug: string;
-                success: boolean;
-                data?: unknown;
-                error?: string;
-            }[];
-        };
-    }>;
-};

package/dist/tools/multi-execute.js

@@ -1,87 +0,0 @@
-import { Type } from "@sinclair/typebox";
-/**
- * Tool parameters for composio_multi_execute
- */
-export const ComposioMultiExecuteToolSchema = Type.Object({
-    executions: Type.Array(Type.Object({
-        tool_slug: Type.String({
-            description: "Tool slug from composio_search_tools results",
-        }),
-        arguments: Type.Unknown({
-            description: "Tool arguments matching the tool's parameter schema",
-        }),
-    }), {
-        description: "Array of tool executions to run in parallel (max 50)",
-        maxItems: 50,
-    }),
-    user_id: Type.Optional(Type.String({
-        description: "User ID for session scoping (uses default if not provided)",
-    })),
-});
-/**
- * Create the composio_multi_execute tool
- */
-export function createComposioMultiExecuteTool(client, _config) {
-    return {
-        name: "composio_multi_execute",
-        label: "Composio Multi Execute",
-        description: "Execute multiple Composio tools in parallel (up to 50). Use composio_search_tools first " +
-            "to find tool slugs and parameter schemas. All tools must be connected.",
-        parameters: ComposioMultiExecuteToolSchema,
-        async execute(_toolCallId, params) {
-            const executions = Array.isArray(params.executions) ? params.executions : [];
-            if (executions.length === 0) {
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify({ error: "executions array is required and cannot be empty" }, null, 2) },
-                    ],
-                    details: { error: "executions array is required and cannot be empty" },
-                };
-            }
-            // Validate and normalize executions
-            const normalizedExecutions = executions
-                .slice(0, 50)
-                .filter((exec) => exec &&
-                typeof exec === "object" &&
-                typeof exec.tool_slug === "string" &&
-                exec.tool_slug.trim() !== "")
-                .map((exec) => ({
-                tool_slug: exec.tool_slug.trim(),
-                arguments: exec.arguments && typeof exec.arguments === "object" && !Array.isArray(exec.arguments)
-                    ? exec.arguments
-                    : {},
-            }));
-            if (normalizedExecutions.length === 0) {
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify({ error: "No valid executions provided" }, null, 2) },
-                    ],
-                    details: { error: "No valid executions provided" },
-                };
-            }
-            const userId = typeof params.user_id === "string" ? params.user_id : undefined;
-            try {
-                const result = await client.multiExecute(normalizedExecutions, userId);
-                const response = {
-                    total: normalizedExecutions.length,
-                    succeeded: result.results.filter((r) => r.success).length,
-                    failed: result.results.filter((r) => !r.success).length,
-                    results: result.results,
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
-                    details: response,
-                };
-            }
-            catch (err) {
-                const errorResponse = {
-                    error: err instanceof Error ? err.message : String(err),
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                    details: errorResponse,
-                };
-            }
-        },
-    };
-}

package/dist/tools/workbench.d.ts

@@ -1,48 +0,0 @@
-import type { ComposioClient } from "../client.js";
-import type { ComposioConfig } from "../types.js";
-/**
- * Tool parameters for composio_workbench
- */
-export declare const ComposioWorkbenchSchema: import("@sinclair/typebox").TObject<{
-    code: import("@sinclair/typebox").TString;
-    thought: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    current_step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    current_step_metric: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-/**
- * Create the composio_workbench tool
- */
-export declare function createComposioWorkbenchTool(client: ComposioClient, _config: ComposioConfig): {
-    name: string;
-    label: string;
-    description: string;
-    parameters: import("@sinclair/typebox").TObject<{
-        code: import("@sinclair/typebox").TString;
-        thought: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        current_step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        current_step_metric: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-    execute(_toolCallId: string, params: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            error: string;
-        };
-    } | {
-        content: {
-            type: string;
-            text: string;
-        }[];
-        details: {
-            output: unknown;
-            success: boolean;
-        } | {
-            error: string | undefined;
-            success: boolean;
-        };
-    }>;
-};

package/dist/tools/workbench.js

@@ -1,76 +0,0 @@
-import { Type } from "@sinclair/typebox";
-/**
- * Tool parameters for composio_workbench
- */
-export const ComposioWorkbenchSchema = Type.Object({
-    code: Type.String({
-        description: "Python code to execute in the remote Jupyter sandbox. " +
-            "Helper functions available: run_composio_tool(slug, args), invoke_llm(query), " +
-            "upload_local_file(*paths), proxy_execute(method, endpoint, toolkit, ...), " +
-            "web_search(query), smart_file_extract(path). State persists across executions.",
-    }),
-    thought: Type.Optional(Type.String({
-        description: "Concise objective describing what the code should achieve",
-    })),
-    current_step: Type.Optional(Type.String({
-        description: "Short enum for current workflow step (e.g., FETCHING_EMAILS, GENERATING_REPLIES)",
-    })),
-    current_step_metric: Type.Optional(Type.String({
-        description: "Progress metrics for current step (e.g., '10/100 emails', '3/10 pages')",
-    })),
-    user_id: Type.Optional(Type.String({
-        description: "User ID for session scoping (uses default if not provided)",
-    })),
-});
-/**
- * Create the composio_workbench tool
- */
-export function createComposioWorkbenchTool(client, _config) {
-    return {
-        name: "composio_workbench",
-        label: "Composio Remote Workbench",
-        description: "Execute Python code in a remote Jupyter sandbox for processing large tool responses, " +
-            "scripting bulk operations, or running data analysis. Use when data is stored in remote files " +
-            "or when orchestrating multiple Composio tool calls. Has access to pandas, numpy, PIL, PyTorch, etc.",
-        parameters: ComposioWorkbenchSchema,
-        async execute(_toolCallId, params) {
-            const code = String(params.code || "").trim();
-            if (!code) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: "code is required" }, null, 2) }],
-                    details: { error: "code is required" },
-                };
-            }
-            const thought = typeof params.thought === "string" ? params.thought : undefined;
-            const currentStep = typeof params.current_step === "string" ? params.current_step : undefined;
-            const currentStepMetric = typeof params.current_step_metric === "string" ? params.current_step_metric : undefined;
-            const userId = typeof params.user_id === "string" ? params.user_id : undefined;
-            try {
-                const result = await client.executeWorkbench(code, {
-                    thought,
-                    currentStep,
-                    currentStepMetric,
-                    userId,
-                });
-                const response = {
-                    success: result.success,
-                    ...(result.success ? { output: result.output } : { error: result.error }),
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
-                    details: response,
-                };
-            }
-            catch (err) {
-                const errorResponse = {
-                    success: false,
-                    error: err instanceof Error ? err.message : String(err),
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(errorResponse, null, 2) }],
-                    details: errorResponse,
-                };
-            }
-        },
-    };
-}