@customclaw/composio 0.0.5 → 0.0.6

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/package.json

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