denchclaw 2.5.3 → 2.5.4

package/apps/web/.next/standalone/extensions/dench-identity/index.test.ts

@@ -5,6 +5,35 @@ import { buildIdentityPrompt, resolveWorkspaceDir } from "./index.ts";
 import register from "./index.ts";
 import path from "node:path";
 
+function getRegisteredTool(api: { registerTool: ReturnType<typeof vi.fn> }, name: string) {
+  return api.registerTool.mock.calls
+    .map((call) => call[0])
+    .find((tool) => tool?.name === name);
+}
+
+async function executeTool(tool: { execute: (toolCallId: string, input: Record<string, unknown>) => Promise<any> }, input: Record<string, unknown>) {
+  return await tool.execute("tool-call-1", input);
+}
+
+function mockGatewaySearch(responsePayload: Record<string, unknown>) {
+  process.env.DENCH_API_KEY = "dench-test-key";
+  process.env.DENCH_GATEWAY_URL = "https://gateway.example.com";
+  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/search");
+    expect(init?.method).toBe("POST");
+    return new Response(
+      JSON.stringify(responsePayload),
+      {
+        status: 200,
+        headers: {
+          "content-type": "application/json",
+        },
+      },
+    );
+  }) as typeof fetch;
+}
+
 describe("buildIdentityPrompt", () => {
   const workspaceDir = "/home/user/workspace";
 
@@ -31,24 +60,25 @@ describe("buildIdentityPrompt", () => {
     );
   });
 
-  it("includes composio-apps skill path and MCP tool preference", () => {
+  it("includes Dench Integrations skill path and guidance", () => {
     const prompt = buildIdentityPrompt(workspaceDir);
     expect(prompt).toContain(
-      path.join(workspaceDir, "skills", "composio-apps", "SKILL.md"),
+      path.join(workspaceDir, "skills", "dench-integrations", "SKILL.md"),
     );
-    expect(prompt).toContain("Composio MCP");
+    expect(prompt).toContain("Dench Integrations");
+    expect(prompt).not.toContain("Composio MCP");
     expect(prompt).toContain("Never");
-    expect(prompt).toContain("composio_resolve_tool");
+    expect(prompt).toContain("dench_search_integrations");
+    expect(prompt).toContain("dench_execute_integrations");
   });
 
   it("teaches the agent to emit direct composio connect links for any app", () => {
     const prompt = buildIdentityPrompt(workspaceDir);
     expect(prompt).toContain("ANY third-party app or service");
-    expect(prompt).toContain("always call `composio_resolve_tool`");
+    expect(prompt).toContain("always call `dench_search_integrations`");
     expect(prompt).toContain("action_link_markdown");
     expect(prompt).toContain("MUST end the assistant reply with that exact markdown link");
     expect(prompt).toContain("dench://composio/connect");
-    expect(prompt).toContain("dench://composio/reconnect");
     expect(prompt).toContain("connect_required");
   });
 
@@ -61,12 +91,11 @@ describe("buildIdentityPrompt", () => {
     expect(prompt).toContain("Use Apollo for structured CRM enrichment and Exa for broader web research");
   });
 
-  it("prefers Composio over gog even without a generated tool index", () => {
+  it("prefers Dench Integrations over gog without workspace cache files", () => {
     const prompt = buildIdentityPrompt(workspaceDir);
-    expect(prompt).toContain("Composio is the default integration layer");
+    expect(prompt).toContain("use the **Dench Integrations** tools directly");
     expect(prompt).toContain("Never use `gog`");
-    expect(prompt).toContain("If Composio MCP is unavailable in this session, stop");
-    expect(prompt).toContain("GMAIL_FETCH_EMAILS");
+    expect(prompt).toContain("live integration schema");
   });
 
   it("does not advertise the removed browser skill contract", () => {
@@ -90,16 +119,30 @@ describe("buildIdentityPrompt", () => {
   });
 });
 
-describe("buildIdentityPrompt composio-tool-index", () => {
+describe("buildIdentityPrompt composio cache files", () => {
   let tmp: string;
+  const originalFetch = globalThis.fetch;
+  const originalDenchApiKey = process.env.DENCH_API_KEY;
+  const originalDenchGatewayUrl = process.env.DENCH_GATEWAY_URL;
 
   afterEach(() => {
+    globalThis.fetch = originalFetch;
+    if (originalDenchApiKey !== undefined) {
+      process.env.DENCH_API_KEY = originalDenchApiKey;
+    } else {
+      delete process.env.DENCH_API_KEY;
+    }
+    if (originalDenchGatewayUrl !== undefined) {
+      process.env.DENCH_GATEWAY_URL = originalDenchGatewayUrl;
+    } else {
+      delete process.env.DENCH_GATEWAY_URL;
+    }
     if (tmp) {
       rmSync(tmp, { recursive: true, force: true });
     }
   });
 
-  it("includes Gmail tool names from composio-tool-index.json so the agent skips catalog discovery", () => {
+  it("does not expose cached tool-index contents in runtime integration guidance", () => {
     tmp = path.join(
       os.tmpdir(),
       `dench-identity-composio-${Date.now()}-${Math.random().toString(36).slice(2)}`,
@@ -133,10 +176,10 @@ describe("buildIdentityPrompt composio-tool-index", () => {
     );
 
     const prompt = buildIdentityPrompt(tmp);
-    expect(prompt).toContain("Connected App Tools (via Composio MCP)");
-    expect(prompt).toContain("GMAIL_FETCH_EMAILS");
-    expect(prompt).toContain("Read recent emails");
-    expect(prompt).toContain("label_ids");
+    expect(prompt).toContain("Connected App Tools (Dench Integrations)");
+    expect(prompt).toContain("live integration schema");
+    expect(prompt).toContain("dench_search_integrations");
+    expect(prompt).not.toContain("GMAIL_FETCH_EMAILS");
   });
 });
 
@@ -184,6 +227,24 @@ describe("resolveWorkspaceDir", () => {
 });
 
 describe("register", () => {
+  const originalFetch = globalThis.fetch;
+  const originalDenchApiKey = process.env.DENCH_API_KEY;
+  const originalDenchGatewayUrl = process.env.DENCH_GATEWAY_URL;
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    if (originalDenchApiKey !== undefined) {
+      process.env.DENCH_API_KEY = originalDenchApiKey;
+    } else {
+      delete process.env.DENCH_API_KEY;
+    }
+    if (originalDenchGatewayUrl !== undefined) {
+      process.env.DENCH_GATEWAY_URL = originalDenchGatewayUrl;
+    } else {
+      delete process.env.DENCH_GATEWAY_URL;
+    }
+  });
+
   it("hooks into before_prompt_build event when enabled", () => {
     const api = {
       config: { plugins: { entries: {} }, agents: { defaults: { workspace: "/ws" } } },
@@ -232,15 +293,15 @@ describe("register", () => {
     expect(result).toBeUndefined();
   });
 
-  it("registers the Composio resolver tool when the managed skill exists", () => {
+  it("registers the Dench Integrations search tool when the workspace is configured", () => {
     const tmp = path.join(
       os.tmpdir(),
       `dench-identity-register-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
-    mkdirSync(path.join(tmp, "skills", "composio-apps"), { recursive: true });
+    mkdirSync(path.join(tmp, "skills", "dench-integrations"), { recursive: true });
     writeFileSync(
-      path.join(tmp, "skills", "composio-apps", "SKILL.md"),
-      "# Composio connected apps\n",
+      path.join(tmp, "skills", "dench-integrations", "SKILL.md"),
+      "# Dench Integrations connected apps\n",
       "utf-8",
     );
 
@@ -253,38 +314,161 @@ describe("register", () => {
     register(api as any);
 
     expect(api.registerTool).toHaveBeenCalledWith(
-      expect.objectContaining({ name: "composio_resolve_tool" }),
+      expect.objectContaining({ name: "dench_search_integrations" }),
+    );
+    expect(getRegisteredTool(api as any, "dench_execute_integrations")).toBeUndefined();
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("searches GitHub integration tools for recent PR requests", async () => {
+    const tmp = path.join(
+      os.tmpdir(),
+      `dench-identity-github-search-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    mockGatewaySearch({
+      items: [
+        {
+          slug: "GITHUB_FIND_PULL_REQUESTS",
+          name: "Find pull requests",
+          description: "Find GitHub pull requests.",
+          toolkit: {
+            slug: "github",
+            name: "GitHub",
+          },
+          input_parameters: {
+            type: "object",
+            properties: {
+              state: {
+                type: "string",
+              },
+            },
+          },
+          connection_status: {
+            is_connected: true,
+            account_count: 1,
+            accounts: [],
+          },
+        },
+      ],
+      connected_toolkits: ["github"],
+    });
+
+    const api = {
+      config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
+      on: vi.fn(),
+      registerTool: vi.fn(),
+    };
+
+    register(api as any);
+
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "github",
+      query: "check my recent PRs",
+    });
+    const payload = JSON.parse(result.content[0].text);
+
+    expect(payload.toolkit_filter).toBe("github");
+    expect(payload.result_count).toBe(1);
+    expect(payload.results[0].tool_slug).toBe("GITHUB_FIND_PULL_REQUESTS");
+    expect(payload.instruction).toContain("dench_execute_integrations");
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("searches across connected apps and ranks the best tool matches", async () => {
+    const tmp = path.join(
+      os.tmpdir(),
+      `dench-identity-search-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
+    mkdirSync(tmp, { recursive: true });
+    mockGatewaySearch({
+      items: [
+        {
+          slug: "STRIPE_LIST_SUBSCRIPTIONS",
+          name: "List subscriptions",
+          description: "List Stripe subscriptions for billing analysis.",
+          toolkit: {
+            slug: "stripe",
+            name: "Stripe",
+          },
+          input_parameters: { type: "object", properties: {} },
+          connection_status: {
+            is_connected: true,
+            account_count: 1,
+            accounts: [],
+          },
+        },
+        {
+          slug: "GITHUB_FIND_PULL_REQUESTS",
+          name: "Find pull requests",
+          description: "Find GitHub pull requests.",
+          toolkit: {
+            slug: "github",
+            name: "GitHub",
+          },
+          input_parameters: { type: "object", properties: {} },
+          connection_status: {
+            is_connected: true,
+            account_count: 1,
+            accounts: [],
+          },
+        },
+      ],
+      connected_toolkits: ["stripe", "github"],
+    });
+
+    const api = {
+      config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
+      on: vi.fn(),
+      registerTool: vi.fn(),
+    };
+
+    register(api as any);
+
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      query: "find billing subscriptions for a customer",
+    });
+    const payload = JSON.parse(result.content[0].text);
+
+    expect(payload.result_count).toBeGreaterThan(0);
+    expect(payload.results[0].tool_slug).toBe("STRIPE_LIST_SUBSCRIPTIONS");
+    expect(payload.results[1].tool_slug).toBe("GITHUB_FIND_PULL_REQUESTS");
+    expect(payload.results[0].toolkit.slug).toBe("stripe");
 
     rmSync(tmp, { recursive: true, force: true });
   });
 
-  it("resolves recent GitHub PR requests through recipe-backed tools outside the direct tool slice", async () => {
+  it("returns gateway-backed Dench Integrations search results with full schemas", async () => {
     const tmp = path.join(
       os.tmpdir(),
-      `dench-identity-resolver-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      `dench-identity-gateway-search-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
     mkdirSync(tmp, { recursive: true });
     writeFileSync(
       path.join(tmp, "composio-tool-index.json"),
       JSON.stringify({
         generated_at: "2026-04-03T00:00:00.000Z",
+        managed_tools: ["dench_search_integrations", "dench_execute_integrations"],
         connected_apps: [
           {
-            toolkit_slug: "github",
-            toolkit_name: "GitHub",
+            toolkit_slug: "stripe",
+            toolkit_name: "Stripe",
             account_count: 1,
             tools: [
               {
-                name: "GITHUB_LIST_REPOSITORIES_FOR_THE_AUTHENTICATED_USER",
-                title: "List repositories",
-                description_short: "Lists repositories for the authenticated user.",
+                name: "STRIPE_LIST_SUBSCRIPTIONS",
+                title: "List subscriptions",
+                description_short: "List Stripe subscriptions.",
                 required_args: [],
                 arg_hints: {},
               },
             ],
             recipes: {
-              "Find pull requests": "GITHUB_FIND_PULL_REQUESTS",
+              "List subscriptions": "STRIPE_LIST_SUBSCRIPTIONS",
             },
           },
         ],
@@ -292,6 +476,136 @@ describe("register", () => {
       "utf-8",
     );
 
+    process.env.DENCH_API_KEY = "dench-test-key";
+    process.env.DENCH_GATEWAY_URL = "https://gateway.example.com";
+    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/search");
+      expect(init?.method).toBe("POST");
+      return new Response(
+        JSON.stringify({
+          items: [
+            {
+              slug: "STRIPE_LIST_SUBSCRIPTIONS",
+              name: "List subscriptions",
+              description: "List subscriptions.",
+              toolkit: {
+                slug: "stripe",
+                name: "Stripe",
+              },
+              input_parameters: {
+                type: "object",
+                properties: {
+                  limit: { type: "number" },
+                  starting_after: { type: "string" },
+                },
+              },
+              connection_status: {
+                is_connected: true,
+                account_count: 1,
+                accounts: [
+                  {
+                    id: "acct_primary",
+                    alias: "Primary Stripe",
+                    is_default: true,
+                    user_info: {
+                      email: "ops@example.com",
+                      name: "Primary Stripe",
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+          connected_toolkits: ["stripe"],
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json",
+          },
+        },
+      );
+    }) as typeof fetch;
+
+    const api = {
+      config: {
+        plugins: {
+          entries: {
+            "dench-ai-gateway": {
+              config: {
+                gatewayUrl: "https://gateway.example.com",
+              },
+            },
+          },
+        },
+        agents: { defaults: { workspace: tmp } },
+      },
+      on: vi.fn(),
+      registerTool: vi.fn(),
+    };
+
+    register(api as any);
+
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "stripe",
+      query: "list Stripe subscriptions for billing analysis",
+    });
+    const payload = JSON.parse(result.content[0].text);
+
+    expect(payload.result_count).toBe(1);
+    expect(payload.results[0].tool_slug).toBe("STRIPE_LIST_SUBSCRIPTIONS");
+    expect(payload.results[0].input_schema.properties.starting_after).toBeTruthy();
+    expect(payload.results[0].accounts).toHaveLength(1);
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("requires account selection when multiple connected accounts match the same app", async () => {
+    const tmp = path.join(
+      os.tmpdir(),
+      `dench-identity-multi-account-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    mockGatewaySearch({
+      items: [
+        {
+          slug: "STRIPE_LIST_SUBSCRIPTIONS",
+          name: "List subscriptions",
+          description: "List subscriptions.",
+          toolkit: {
+            slug: "stripe",
+            name: "Stripe",
+          },
+          input_parameters: { type: "object", properties: {} },
+          connection_status: {
+            is_connected: true,
+            account_count: 2,
+            accounts: [
+              {
+                id: "acct_prod",
+                alias: "Prod Stripe",
+                user_info: {
+                  email: "ops@example.com",
+                  name: "Prod Stripe",
+                },
+              },
+              {
+                id: "acct_test",
+                alias: "Test Stripe",
+                user_info: {
+                  email: "dev@example.com",
+                  name: "Test Stripe",
+                },
+              },
+            ],
+          },
+        },
+      ],
+      connected_toolkits: ["stripe"],
+    });
+
     const api = {
       config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
       on: vi.fn(),
@@ -300,41 +614,133 @@ describe("register", () => {
 
     register(api as any);
 
-    const resolver = api.registerTool.mock.calls[0][0];
-    const result = await resolver.execute({
-      app: "github",
-      intent: "check my recent PRs",
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "stripe",
+      query: "list subscriptions",
     });
     const payload = JSON.parse(result.content[0].text);
 
-    expect(payload.tool).toBe("GITHUB_FIND_PULL_REQUESTS");
-    expect(payload.directly_callable).toBe(true);
+    expect(payload.results[0].account_count).toBe(2);
+    expect(payload.results[0].accounts).toHaveLength(2);
+    expect(payload.instruction).toContain("multiple connected accounts");
 
     rmSync(tmp, { recursive: true, force: true });
   });
 
-  it("returns a direct connect link when the requested app is not connected", async () => {
+  it("forwards toolkit and limit filters to gateway-backed searches", async () => {
     const tmp = path.join(
       os.tmpdir(),
-      `dench-identity-resolver-missing-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      `dench-identity-filtered-search-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
     mkdirSync(tmp, { recursive: true });
-    writeFileSync(
-      path.join(tmp, "composio-tool-index.json"),
-      JSON.stringify({
-        generated_at: "2026-04-03T00:00:00.000Z",
-        connected_apps: [
-          {
-            toolkit_slug: "github",
-            toolkit_name: "GitHub",
-            account_count: 1,
-            tools: [],
-            recipes: {},
+    process.env.DENCH_API_KEY = "dench-test-key";
+    process.env.DENCH_GATEWAY_URL = "https://gateway.example.com";
+
+    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/search");
+      expect(init?.method).toBe("POST");
+      expect(JSON.parse(String(init?.body ?? "{}"))).toMatchObject({
+        query: "list Stripe subscriptions",
+        toolkit_slug: "stripe",
+        limit: 5,
+      });
+      return new Response(
+        JSON.stringify({
+          items: [
+            {
+              slug: "STRIPE_LIST_SUBSCRIPTIONS",
+              name: "List subscriptions",
+              description: "List subscriptions.",
+              toolkit: {
+                slug: "stripe",
+                name: "Stripe",
+              },
+              input_parameters: { type: "object", properties: {} },
+              connection_status: {
+                is_connected: true,
+                account_count: 1,
+                accounts: [],
+              },
+            },
+          ],
+          connected_toolkits: ["stripe"],
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json",
           },
-        ],
-      }),
-      "utf-8",
+        },
+      );
+    }) as typeof fetch;
+
+    const api = {
+      config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
+      on: vi.fn(),
+      registerTool: vi.fn(),
+    };
+
+    register(api as any);
+
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "stripe",
+      limit: 5,
+      query: "list Stripe subscriptions",
+    });
+    const payload = JSON.parse(result.content[0].text);
+
+    expect(payload.toolkit_filter).toBe("stripe");
+    expect(payload.result_count).toBe(1);
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns no-match guidance when a toolkit search has no matching tools", async () => {
+    const tmp = path.join(
+      os.tmpdir(),
+      `dench-identity-no-match-${Date.now()}-${Math.random().toString(36).slice(2)}`,
     );
+    mkdirSync(tmp, { recursive: true });
+    mockGatewaySearch({
+      items: [],
+      connected_toolkits: ["gmail"],
+    });
+
+    const api = {
+      config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
+      on: vi.fn(),
+      registerTool: vi.fn(),
+    };
+
+    register(api as any);
+
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "gmail",
+      query: "read my recent email",
+    });
+    const payload = JSON.parse(result.content[0].text);
+
+    expect(payload.result_count).toBe(0);
+    expect(payload.connected_toolkits).toEqual(["gmail"]);
+    expect(payload.instruction).toContain("No Gmail integration tools matched");
+
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns a direct connect link when the requested app is not connected", async () => {
+    const tmp = path.join(
+      os.tmpdir(),
+      `dench-identity-connect-required-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    mockGatewaySearch({
+      items: [],
+      connected_toolkits: [],
+    });
 
     const api = {
       config: { plugins: { entries: {} }, agents: { defaults: { workspace: tmp } } },
@@ -344,10 +750,10 @@ describe("register", () => {
 
     register(api as any);
 
-    const resolver = api.registerTool.mock.calls[0][0];
-    const result = await resolver.execute({
-      app: "slack",
-      intent: "check my slack",
+    const searchTool = getRegisteredTool(api as any, "dench_search_integrations");
+    const result = await executeTool(searchTool, {
+      toolkit: "slack",
+      query: "check my slack",
     });
     const payload = JSON.parse(result.content[0].text);