@customclaw/composio 0.0.4 → 0.0.6

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

@@ -2,6 +2,7 @@ import { describe, it, expect, vi } from "vitest";
 import { ComposioClient } from "./client.js";
 import { parseComposioConfig } from "./config.js";
 import { createComposioExecuteTool } from "./tools/execute.js";
+import { createComposioConnectionsTool } from "./tools/connections.js";
 // Mock the Composio SDK
 vi.mock("@composio/core", () => ({
     Composio: vi.fn().mockImplementation(() => ({
@@ -15,6 +16,7 @@ vi.mock("@composio/core", () => ({
                         { slug: "gmail", name: "Gmail", connection: { isActive: true } },
                         { slug: "sentry", name: "Sentry", connection: { isActive: false } },
                         { slug: "github", name: "GitHub", connection: { isActive: true } },
+                        { slug: "affinity", name: "Affinity", connection: { isActive: false } },
                     ],
                 }),
                 experimental: { assistivePrompt: "" },
@@ -182,3 +184,43 @@ describe("execute tool string arguments (GLM-5 workaround)", () => {
         expect(result.details).toHaveProperty("success", true);
     });
 });
+describe("connections tool", () => {
+    function makeConnectionsTool() {
+        const client = makeClient();
+        const config = parseComposioConfig({ config: { apiKey: "test-key" } });
+        return createComposioConnectionsTool(client, config);
+    }
+    it("list action passes user_id to client", async () => {
+        const tool = makeConnectionsTool();
+        const result = await tool.execute("test", { action: "list", user_id: "custom-user" });
+        const details = result.details;
+        expect(details).toHaveProperty("action", "list");
+        expect(details.toolkits).toBeInstanceOf(Array);
+    });
+    it("status probes API-key toolkit and flips to connected on success", async () => {
+        const tool = makeConnectionsTool();
+        const result = await tool.execute("test", { action: "status", toolkit: "affinity" });
+        const details = result.details;
+        const conn = details.connections.find((c) => c.toolkit === "affinity");
+        expect(conn.connected).toBe(true);
+    });
+    it("status does not probe toolkits without a defined probe", async () => {
+        const tool = makeConnectionsTool();
+        const result = await tool.execute("test", { action: "status", toolkit: "sentry" });
+        const details = result.details;
+        const conn = details.connections.find((c) => c.toolkit === "sentry");
+        expect(conn.connected).toBe(false);
+    });
+    it("status keeps disconnected when probe fails", async () => {
+        const tool = makeConnectionsTool();
+        // Get the latest Composio instance (the one this tool's client is using)
+        const { Composio } = await import("@composio/core");
+        const mockResults = Composio.mock.results;
+        const instance = mockResults[mockResults.length - 1].value;
+        instance.client.tools.execute.mockRejectedValueOnce(new Error("probe failed"));
+        const result = await tool.execute("test", { action: "status", toolkit: "affinity" });
+        const details = result.details;
+        const conn = details.connections.find((c) => c.toolkit === "affinity");
+        expect(conn.connected).toBe(false);
+    });
+});

package/dist/index.js

@@ -73,22 +73,6 @@ const composioPlugin = {
             config,
             logger: api.logger,
         }), { commands: ["composio"] });
-        // Inject agent instructions via before_agent_start hook
-        api.on("before_agent_start", () => {
-            return {
-                prependContext: `<composio-tools>
-You have access to Composio tools for third-party integrations (Gmail, Sentry, etc.).
-
-## Usage
-1. Use \`composio_search_tools\` to find tools and their parameter schemas.
-2. Use \`composio_manage_connections\` with action="status" to check if a toolkit is connected. Use action="create" to generate an auth URL if needed.
-3. Use \`composio_execute_tool\` with the tool_slug and arguments from search results.
-
-Always search first to get the correct parameter schema before executing a tool.
-Tool slugs are uppercase. If a tool fails with auth errors, prompt the user to connect the toolkit.
-</composio-tools>`,
-            };
-        });
         api.logger.info("[composio] Plugin registered with 3 tools and CLI commands");
     },
 };

package/dist/tools/connections.js

@@ -1,4 +1,10 @@
 import { Type } from "@sinclair/typebox";
+const CONNECTION_PROBES = {
+    affinity: {
+        toolSlug: "AFFINITY_GET_METADATA_ON_ALL_LISTS",
+        args: { limit: 1 },
+    },
+};
 /**
  * Tool parameters for composio_manage_connections
  */
@@ -23,8 +29,9 @@ export function createComposioConnectionsTool(client, _config) {
     return {
         name: "composio_manage_connections",
         label: "Composio Manage Connections",
-        description: "Manage Composio toolkit connections. Check connection status, create new auth links, " +
-            "or list available toolkits. Use this before executing tools to ensure authentication.",
+        description: "Manage Composio toolkit connections. Use action='status' to check if a toolkit is connected, " +
+            "action='create' to generate an auth URL when disconnected, or action='list' to see available toolkits. " +
+            "Check connection status before executing tools with composio_execute_tool.",
         parameters: ComposioManageConnectionsToolSchema,
         async execute(_toolCallId, params) {
             const action = String(params.action || "status");
@@ -32,7 +39,7 @@ export function createComposioConnectionsTool(client, _config) {
             try {
                 switch (action) {
                     case "list": {
-                        const toolkits = await client.listToolkits();
+                        const toolkits = await client.listToolkits(userId);
                         const response = {
                             action: "list",
                             count: toolkits.length,
@@ -82,6 +89,25 @@ export function createComposioConnectionsTool(client, _config) {
                             toolkitsToCheck = params.toolkits.filter((t) => typeof t === "string" && t.trim() !== "");
                         }
                         const statuses = await client.getConnectionStatus(toolkitsToCheck, userId);
+                        // Fallback probe for API-key style integrations where
+                        // connection.isActive can be false despite successful tool execution
+                        if (toolkitsToCheck && toolkitsToCheck.length > 0) {
+                            for (const status of statuses) {
+                                if (status.connected)
+                                    continue;
+                                const probe = CONNECTION_PROBES[String(status.toolkit || "").toLowerCase()];
+                                if (!probe)
+                                    continue;
+                                try {
+                                    const probeResult = await client.executeTool(probe.toolSlug, probe.args, userId);
+                                    if (probeResult?.success)
+                                        status.connected = true;
+                                }
+                                catch {
+                                    // keep false if probe fails
+                                }
+                            }
+                        }
                         const response = {
                             action: "status",
                             count: statuses.length,

package/dist/tools/execute.js

@@ -20,8 +20,9 @@ export function createComposioExecuteTool(client, _config) {
     return {
         name: "composio_execute_tool",
         label: "Composio Execute Tool",
-        description: "Execute a single Composio tool. Use composio_search_tools first to find the tool slug " +
-            "and parameter schema. The tool must be connected (use composio_manage_connections to check).",
+        description: "Execute a single Composio tool. Use composio_search_tools first to find the UPPERCASE tool slug " +
+            "and parameter schema. The toolkit must be connected — use composio_manage_connections to check " +
+            "status or create an auth link. If execution fails with auth errors, prompt the user to reconnect.",
         parameters: ComposioExecuteToolSchema,
         async execute(_toolCallId, params) {
             const toolSlug = String(params.tool_slug || "").trim();

package/dist/tools/search.js

@@ -23,8 +23,9 @@ export function createComposioSearchTool(client, _config) {
     return {
         name: "composio_search_tools",
         label: "Composio Search Tools",
-        description: "Search for tools across 1000+ integrations (Gmail, Slack, GitHub, Notion, etc.) " +
-            "by describing what you want to accomplish. Returns matching tools with their schemas.",
+        description: "Search for Composio tools across 1000+ integrations (Gmail, Slack, GitHub, Notion, etc.) " +
+            "by describing what you want to accomplish. Returns matching tools with their UPPERCASE slugs and parameter schemas. " +
+            "Always search first before executing a tool with composio_execute_tool.",
         parameters: ComposioSearchToolSchema,
         async execute(_toolCallId, params) {
             const query = String(params.query || "").trim();

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.4",
+  "version": "0.0.6",
   "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,
-                };
-            }
-        },
-    };
-}