denchclaw 2.5.3 → 2.5.4

package/extensions/dench-ai-gateway/index.test.ts

@@ -1,114 +1,123 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import register from "./index.js";
 
+function writeAuthProfiles(stateDir: string, key: string): void {
+  const authDir = path.join(stateDir, "agents", "main", "agent");
+  mkdirSync(authDir, { recursive: true });
+  writeFileSync(
+    path.join(authDir, "auth-profiles.json"),
+    JSON.stringify({
+      version: 1,
+      profiles: {
+        "dench-cloud:default": { type: "api_key", provider: "dench-cloud", key },
+      },
+    }),
+  );
+}
+
+function createApi(params?: { gatewayUrl?: string; withMcp?: boolean }) {
+  const gatewayUrl = params?.gatewayUrl ?? "https://gateway.example.com";
+  const providers: any[] = [];
+  const tools: any[] = [];
+  const services: any[] = [];
+  const info = vi.fn();
+
+  const api: any = {
+    config: {
+      ...(params?.withMcp
+        ? {
+            mcp: {
+              servers: {
+                composio: {
+                  url: `${gatewayUrl}/v1/composio/mcp`,
+                  transport: "streamable-http",
+                  headers: {
+                    Authorization: "Bearer dc-key",
+                  },
+                },
+              },
+            },
+          }
+        : {}),
+      plugins: {
+        entries: {
+          "dench-ai-gateway": {
+            config: {
+              enabled: true,
+              gatewayUrl,
+            },
+          },
+        },
+      },
+    },
+    registerProvider(provider: any) {
+      providers.push(provider);
+    },
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+    registerService(service: any) {
+      services.push(service);
+    },
+    logger: {
+      info,
+    },
+  };
+
+  return { api, providers, tools, services, info };
+}
+
 describe("dench-ai-gateway composio bridge", () => {
   const originalFetch = globalThis.fetch;
-  let workspaceDir: string | undefined;
+  const originalStateDir = process.env.OPENCLAW_STATE_DIR;
+  let stateDir: string | undefined;
 
   afterEach(() => {
     globalThis.fetch = originalFetch;
     vi.restoreAllMocks();
-    if (workspaceDir) {
-      rmSync(workspaceDir, { recursive: true, force: true });
-      workspaceDir = undefined;
+    if (stateDir) {
+      rmSync(stateDir, { recursive: true, force: true });
+      stateDir = undefined;
+    }
+    if (originalStateDir !== undefined) {
+      process.env.OPENCLAW_STATE_DIR = originalStateDir;
+    } else {
+      delete process.env.OPENCLAW_STATE_DIR;
     }
   });
 
-  it("strips the raw composio MCP server and registers curated direct tools", async () => {
-    workspaceDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-"));
-    writeFileSync(
-      path.join(workspaceDir, "composio-tool-index.json"),
-      JSON.stringify(
-        {
-          generated_at: "2026-04-02T00:00:00.000Z",
-          connected_apps: [
-            {
-              toolkit_slug: "gmail",
-              toolkit_name: "Gmail",
-              account_count: 1,
-              tools: [
-                {
-                  name: "GMAIL_FETCH_EMAILS",
-                  title: "Fetch emails",
-                  description_short: "Fetch recent Gmail messages.",
-                  required_args: [],
-                  arg_hints: {
-                    label_ids: 'Must be an array like ["INBOX"].',
-                  },
-                  default_args: { label_ids: ["INBOX"], max_results: 10 },
-                  input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                      label_ids: {
-                        type: "array",
-                        items: { type: "string" },
-                      },
-                      max_results: {
-                        type: "number",
-                      },
-                    },
-                  },
-                },
-                {
-                  name: "GMAIL_SEND_EMAIL",
-                  title: "Send email",
-                  description_short: "Send a Gmail message.",
-                  required_args: ["to", "subject", "body"],
-                  arg_hints: {},
-                  input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                      to: { type: "string" },
-                      subject: { type: "string" },
-                      body: { type: "string" },
-                    },
-                    required: ["to", "subject", "body"],
-                  },
-                },
-              ],
-              recipes: {
-                "Read recent emails": "GMAIL_FETCH_EMAILS",
-                "Send email": "GMAIL_SEND_EMAIL",
-              },
-            },
-          ],
-        },
-        null,
-        2,
-      ),
-      "utf-8",
-    );
-
-    const providers: any[] = [];
-    const tools: any[] = [];
-    const services: any[] = [];
-    const info = vi.fn();
+  it("strips the raw composio MCP server and registers the Dench Integrations execute bridge", async () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
 
     globalThis.fetch = vi.fn(async (input, init) => {
       const url = typeof input === "string" ? input : input.url;
-      const payload = JSON.parse(String(init?.body ?? "{}"));
-      expect(url).toBe("https://gateway.example.com/v1/composio/mcp");
-      expect(payload.method).toBe("tools/call");
-      expect(payload.params.name).toBe("GMAIL_FETCH_EMAILS");
-      expect(payload.params.arguments).toEqual({
-        label_ids: ["INBOX"],
-        max_results: 10,
+      expect(url).toBe("https://gateway.example.com/v1/composio/tools/execute");
+      expect(init?.method).toBe("POST");
+      expect(init?.headers).toMatchObject({
+        "content-type": "application/json",
+        accept: "application/json",
+        authorization: "Bearer dc-key",
+      });
+      expect(JSON.parse(String(init?.body ?? "{}"))).toEqual({
+        tool_slug: "GMAIL_FETCH_EMAILS",
+        arguments: {
+          label_ids: ["INBOX"],
+          max_results: 10,
+        },
       });
 
       return new Response(
         JSON.stringify({
-          jsonrpc: "2.0",
-          id: 1,
-          result: {
-            structuredContent: {
-              messages: [{ id: "m1", subject: "Hello" }],
-            },
+          data: {
+            messages: [{ id: "m1", subject: "Hello" }],
           },
+          error: null,
+          log_id: "log_gmail_1",
         }),
         {
           status: 200,
@@ -119,163 +128,214 @@ describe("dench-ai-gateway composio bridge", () => {
       );
     }) as typeof fetch;
 
-    const api: any = {
-      config: {
-        agents: {
-          defaults: {
-            workspace: workspaceDir,
-          },
-        },
-        models: {
-          providers: {
-            "dench-cloud": {
-              apiKey: "dc-key",
-            },
-          },
-        },
-        mcp: {
-          servers: {
-            composio: {
-              url: "https://gateway.example.com/v1/composio/mcp",
-              transport: "streamable-http",
-              headers: {
-                Authorization: "Bearer dc-key",
-              },
-            },
-          },
-        },
-        plugins: {
-          entries: {
-            "dench-ai-gateway": {
-              config: {
-                enabled: true,
-                gatewayUrl: "https://gateway.example.com",
-              },
-            },
-          },
-        },
-      },
-      registerProvider(provider: any) {
-        providers.push(provider);
-      },
-      registerTool(tool: any) {
-        tools.push(tool);
-      },
-      registerService(service: any) {
-        services.push(service);
-      },
-      logger: {
-        info,
-      },
-    };
-
+    const { api, providers, tools, services, info } = createApi({ withMcp: true });
     register(api);
 
     expect(providers).toHaveLength(1);
     expect(services).toHaveLength(1);
-    expect(tools.map((tool) => tool.name)).toEqual([
-      "GMAIL_FETCH_EMAILS",
-      "GMAIL_SEND_EMAIL",
-    ]);
+    expect(tools.map((tool) => tool.name)).toEqual(["dench_execute_integrations"]);
     expect(api.config.mcp).toBeUndefined();
+    expect(info).toHaveBeenCalledWith(
+      "[dench-ai-gateway] registered dench_execute_integrations bridge tool",
+    );
 
     const result = await tools[0].execute("call-1", {
-      label_ids: ["INBOX"],
-      max_results: 10,
+      tool_slug: "GMAIL_FETCH_EMAILS",
+      arguments: {
+        label_ids: ["INBOX"],
+        max_results: 10,
+      },
     });
 
     expect(globalThis.fetch).toHaveBeenCalledTimes(1);
     expect(result.details).toMatchObject({
-      composioBridge: true,
-      mcpServer: "composio",
-      mcpTool: "GMAIL_FETCH_EMAILS",
+      denchIntegrations: true,
+      tool_slug: "GMAIL_FETCH_EMAILS",
+      logId: "log_gmail_1",
+      structuredContent: {
+        messages: [{ id: "m1", subject: "Hello" }],
+      },
     });
     expect(result.content[0]?.text).toContain('"subject": "Hello"');
   });
 
-  it("falls back to a permissive object schema when the index lacks input_schema", () => {
-    workspaceDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-"));
-    writeFileSync(
-      path.join(workspaceDir, "composio-tool-index.json"),
-      JSON.stringify(
-        {
-          generated_at: "2026-04-02T00:00:00.000Z",
-          connected_apps: [
-            {
-              toolkit_slug: "gmail",
-              toolkit_name: "Gmail",
-              account_count: 1,
-              tools: [
-                {
-                  name: "GMAIL_FETCH_MESSAGE_BY_MESSAGE_ID",
-                  title: "Fetch message",
-                  description_short: "Fetch one Gmail message.",
-                  required_args: ["message_id"],
-                  arg_hints: {
-                    message_id: "Use the Gmail message id.",
-                  },
-                },
-              ],
-              recipes: {
-                "Read one email": "GMAIL_FETCH_MESSAGE_BY_MESSAGE_ID",
-              },
-            },
-          ],
+  it("registers a stable generic schema for dench_execute_integrations", () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
+
+    const { api, tools } = createApi();
+    register(api);
+
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe("dench_execute_integrations");
+    expect(tools[0].parameters).toMatchObject({
+      type: "object",
+      additionalProperties: false,
+      required: ["tool_slug"],
+      properties: {
+        tool_slug: {
+          type: "string",
         },
-        null,
-        2,
-      ),
-      "utf-8",
-    );
+        arguments: {
+          type: "object",
+          additionalProperties: true,
+        },
+        connected_account_id: {
+          type: "string",
+        },
+      },
+    });
+  });
 
-    const tools: any[] = [];
-    const api: any = {
-      config: {
-        agents: {
-          defaults: {
-            workspace: workspaceDir,
-          },
+  it("passes connected_account_id through to gateway execution when provided", async () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
+
+    globalThis.fetch = vi.fn(async (input, init) => {
+      const url = typeof input === "string" ? input : input.url;
+      expect(url).toBe("https://gateway.example.com/v1/composio/tools/execute");
+      expect(JSON.parse(String(init?.body ?? "{}"))).toEqual({
+        tool_slug: "STRIPE_LIST_SUBSCRIPTIONS",
+        arguments: {
+          limit: 100,
         },
-        models: {
-          providers: {
-            "dench-cloud": {
-              apiKey: "dc-key",
-            },
+        connected_account_id: "acct_primary",
+      });
+
+      return new Response(
+        JSON.stringify({
+          data: {
+            data: [{ id: "sub_123" }],
           },
-        },
-        plugins: {
-          entries: {
-            "dench-ai-gateway": {
-              config: {
-                enabled: true,
-                gatewayUrl: "https://gateway.example.com",
-              },
-            },
+          error: null,
+          log_id: "log_stripe_1",
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json",
           },
         },
+      );
+    }) as typeof fetch;
+
+    const { api, tools } = createApi();
+    register(api);
+
+    const result = await tools[0].execute("call-1", {
+      tool_slug: "STRIPE_LIST_SUBSCRIPTIONS",
+      connected_account_id: "acct_primary",
+      arguments: {
+        limit: 100,
       },
-      registerProvider() {},
-      registerTool(tool: any) {
-        tools.push(tool);
-      },
-      registerService() {},
-      logger: {
-        info: vi.fn(),
-      },
-    };
+    });
+
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(result.details).toMatchObject({
+      denchIntegrations: true,
+      tool_slug: "STRIPE_LIST_SUBSCRIPTIONS",
+      connectedAccountId: "acct_primary",
+      logId: "log_stripe_1",
+    });
+    expect(result.content[0]?.text).toContain('"sub_123"');
+  });
 
+  it("surfaces account selection required responses from the gateway", async () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
+
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          error: {
+            code: "composio_account_selection_required",
+            message: "Stripe requires an explicit account selection.",
+          },
+        }),
+        {
+          status: 400,
+          headers: {
+            "content-type": "application/json",
+          },
+        },
+      )) as typeof fetch;
+
+    const { api, tools } = createApi();
     register(api);
 
-    expect(tools).toHaveLength(1);
-    expect(tools[0].parameters).toMatchObject({
-      type: "object",
-      additionalProperties: true,
-      required: ["message_id"],
-      properties: {
-        message_id: {
-          description: "Use the Gmail message id.",
+    const result = await tools[0].execute("call-1", {
+      tool_slug: "STRIPE_LIST_SUBSCRIPTIONS",
+      arguments: {},
+    });
+
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(result.details).toMatchObject({
+      status: "error",
+      errorCode: "composio_account_selection_required",
+      tool_slug: "STRIPE_LIST_SUBSCRIPTIONS",
+    });
+    expect(result.content[0]?.text).toContain("requires an explicit account selection");
+    expect(result.content[0]?.text).toContain("connected_account_id");
+  });
+
+  it("surfaces not-connected responses from the gateway", async () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
+
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          error: {
+            code: "composio_not_connected",
+            message: "Slack is not connected.",
+          },
+        }),
+        {
+          status: 400,
+          headers: {
+            "content-type": "application/json",
+          },
         },
-      },
+      )) as typeof fetch;
+
+    const { api, tools } = createApi();
+    register(api);
+
+    const result = await tools[0].execute("call-1", {
+      tool_slug: "SLACK_LIST_CHANNELS",
+      arguments: {},
+    });
+
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(result.details).toMatchObject({
+      status: "error",
+      errorCode: "composio_not_connected",
+      tool_slug: "SLACK_LIST_CHANNELS",
     });
+    expect(result.content[0]?.text).toContain("Slack is not connected.");
+    expect(result.content[0]?.text).toContain('"not_connected": true');
+  });
+
+  it("requires tool_slug and skips gateway execution when it is missing", async () => {
+    stateDir = mkdtempSync(path.join(os.tmpdir(), "dench-ai-gateway-state-"));
+    process.env.OPENCLAW_STATE_DIR = stateDir;
+    writeAuthProfiles(stateDir, "dc-key");
+
+    globalThis.fetch = vi.fn() as typeof fetch;
+
+    const { api, tools } = createApi();
+    register(api);
+
+    const result = await tools[0].execute("call-1", {
+      arguments: {},
+    });
+
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+    expect(result.content[0]?.text).toContain("The `tool_slug` field is required");
+    expect(result.content[0]?.text).toContain("dench_search_integrations");
   });
 });

package/extensions/dench-ai-gateway/index.ts

@@ -13,7 +13,7 @@ import {
   buildDenchCloudConfigPatch,
   buildDenchCloudProviderConfig,
 } from "./config-patch.js";
-import { registerCuratedComposioBridge } from "./composio-bridge.js";
+import { registerDenchIntegrationsBridge } from "./composio-bridge.js";
 export { buildDenchCloudConfigPatch } from "./config-patch.js";
 
 export const id = "dench-ai-gateway";
@@ -311,7 +311,7 @@ export default function register(api: any) {
     },
   } as any);
 
-  registerCuratedComposioBridge(api, gatewayUrl);
+  registerDenchIntegrationsBridge(api, gatewayUrl);
 
   api.registerService({
     id: "dench-ai-gateway",