denchclaw 2.4.5 → 2.5.0

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

@@ -0,0 +1,281 @@
+import { 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";
+
+describe("dench-ai-gateway composio bridge", () => {
+  const originalFetch = globalThis.fetch;
+  let workspaceDir: string | undefined;
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.restoreAllMocks();
+    if (workspaceDir) {
+      rmSync(workspaceDir, { recursive: true, force: true });
+      workspaceDir = undefined;
+    }
+  });
+
+  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();
+
+    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,
+      });
+
+      return new Response(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          result: {
+            structuredContent: {
+              messages: [{ id: "m1", subject: "Hello" }],
+            },
+          },
+        }),
+        {
+          status: 200,
+          headers: {
+            "content-type": "application/json",
+          },
+        },
+      );
+    }) 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,
+      },
+    };
+
+    register(api);
+
+    expect(providers).toHaveLength(1);
+    expect(services).toHaveLength(1);
+    expect(tools.map((tool) => tool.name)).toEqual([
+      "GMAIL_FETCH_EMAILS",
+      "GMAIL_SEND_EMAIL",
+    ]);
+    expect(api.config.mcp).toBeUndefined();
+
+    const result = await tools[0].execute("call-1", {
+      label_ids: ["INBOX"],
+      max_results: 10,
+    });
+
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(result.details).toMatchObject({
+      composioBridge: true,
+      mcpServer: "composio",
+      mcpTool: "GMAIL_FETCH_EMAILS",
+    });
+    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",
+              },
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      "utf-8",
+    );
+
+    const tools: any[] = [];
+    const api: any = {
+      config: {
+        agents: {
+          defaults: {
+            workspace: workspaceDir,
+          },
+        },
+        models: {
+          providers: {
+            "dench-cloud": {
+              apiKey: "dc-key",
+            },
+          },
+        },
+        plugins: {
+          entries: {
+            "dench-ai-gateway": {
+              config: {
+                enabled: true,
+                gatewayUrl: "https://gateway.example.com",
+              },
+            },
+          },
+        },
+      },
+      registerProvider() {},
+      registerTool(tool: any) {
+        tools.push(tool);
+      },
+      registerService() {},
+      logger: {
+        info: vi.fn(),
+      },
+    };
+
+    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.",
+        },
+      },
+    });
+  });
+});

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

@@ -1,6 +1,4 @@
 import {
-  buildDenchCloudAgentModelEntries,
-  buildDenchCloudProviderModels,
   buildDenchGatewayApiBaseUrl,
   buildDenchGatewayCatalogUrl,
   cloneFallbackDenchCloudModels,
@@ -11,6 +9,12 @@ import {
   resolveDenchCloudModel,
   type DenchCloudCatalogModel,
 } from "./models.js";
+import {
+  buildDenchCloudConfigPatch,
+  buildDenchCloudProviderConfig,
+} from "./config-patch.js";
+import { registerCuratedComposioBridge } from "./composio-bridge.js";
+export { buildDenchCloudConfigPatch } from "./config-patch.js";
 
 export const id = "dench-ai-gateway";
 
@@ -55,39 +59,6 @@ function resolveEnvApiKey(): string | undefined {
   return undefined;
 }
 
-function buildProviderConfig(
-  gatewayUrl: string,
-  apiKey: string,
-  models: DenchCloudCatalogModel[],
-) {
-  return {
-    baseUrl: buildDenchGatewayApiBaseUrl(gatewayUrl),
-    apiKey,
-    api: "openai-completions",
-    models: buildDenchCloudProviderModels(models),
-  };
-}
-
-export function buildDenchCloudConfigPatch(params: {
-  gatewayUrl: string;
-  apiKey: string;
-  models: DenchCloudCatalogModel[];
-}) {
-  return {
-    models: {
-      mode: "merge",
-      providers: {
-        [PROVIDER_ID]: buildProviderConfig(params.gatewayUrl, params.apiKey, params.models),
-      },
-    },
-    agents: {
-      defaults: {
-        models: buildDenchCloudAgentModelEntries(params.models),
-      },
-    },
-  };
-}
-
 async function promptForApiKey(prompter: any): Promise<string> {
   if (typeof prompter?.secret === "function") {
     return String(
@@ -285,7 +256,7 @@ function buildDiscoveryProvider(api: any, gatewayUrl: string) {
   }
 
   const models = cloneFallbackDenchCloudModels();
-  return buildProviderConfig(gatewayUrl, apiKey, models);
+  return buildDenchCloudProviderConfig({ gatewayUrl, apiKey, models });
 }
 
 export default function register(api: any) {
@@ -340,6 +311,8 @@ export default function register(api: any) {
     },
   } as any);
 
+  registerCuratedComposioBridge(api, gatewayUrl);
+
   api.registerService({
     id: "dench-ai-gateway",
     start: () => {

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

@@ -15,7 +15,7 @@ export type DenchCloudCatalogModel = {
   displayName: string;
   provider: string;
   transportProvider: string;
-  api: "openai-completions";
+  api: "openai-completions" | "openai-responses";
   input: Array<"text" | "image">;
   reasoning: boolean;
   contextWindow: number;
@@ -127,7 +127,7 @@ export const FALLBACK_DENCH_CLOUD_MODELS: DenchCloudCatalogModel[] = [
     displayName: "Claude Opus 4.6",
     provider: "anthropic",
     transportProvider: "bedrock",
-    api: "openai-completions",
+    api: "openai-responses",
     input: ["text", "image"],
     reasoning: false,
     contextWindow: 200000,
@@ -150,7 +150,7 @@ export const FALLBACK_DENCH_CLOUD_MODELS: DenchCloudCatalogModel[] = [
     displayName: "GPT-5.4",
     provider: "openai",
     transportProvider: "openai",
-    api: "openai-completions",
+    api: "openai-responses",
     input: ["text", "image"],
     reasoning: false,
     contextWindow: 128000,
@@ -173,7 +173,7 @@ export const FALLBACK_DENCH_CLOUD_MODELS: DenchCloudCatalogModel[] = [
     displayName: "Claude Sonnet 4.6",
     provider: "anthropic",
     transportProvider: "bedrock",
-    api: "openai-completions",
+    api: "openai-responses",
     input: ["text", "image"],
     reasoning: false,
     contextWindow: 200000,
@@ -237,7 +237,7 @@ export function normalizeDenchCloudCatalogModel(input: unknown): DenchCloudCatal
     displayName,
     provider,
     transportProvider,
-    api: "openai-completions",
+    api: record.api === "openai-completions" ? "openai-completions" : "openai-responses",
     input: normalizeInputKinds(record.input, supportsImages),
     reasoning: supportsReasoning,
     contextWindow,

package/extensions/dench-identity/composio-cheat-sheet.test.ts

@@ -0,0 +1,146 @@
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { describe, expect, it, afterEach } from "vitest";
+import {
+  formatComposioToolCheatSheetFromIndex,
+  loadComposioToolCheatSheetMarkdown,
+} from "./composio-cheat-sheet.js";
+
+describe("formatComposioToolCheatSheetFromIndex", () => {
+  it("renders markdown with tool table and gotchas", () => {
+    const md = formatComposioToolCheatSheetFromIndex({
+      generated_at: "2025-01-01T00:00:00.000Z",
+      connected_apps: [
+        {
+          toolkit_slug: "gmail",
+          toolkit_name: "Gmail",
+          account_count: 2,
+          tools: [
+            {
+              name: "GMAIL_FETCH_EMAILS",
+              title: "Fetch emails",
+              description_short: "List messages.",
+              required_args: [],
+              arg_hints: {
+                label_ids: 'Use ["INBOX"]',
+              },
+            },
+          ],
+          recipes: {
+            "Read recent emails": "GMAIL_FETCH_EMAILS",
+          },
+        },
+      ],
+    });
+
+    expect(md).toContain("### Gmail (2 accounts connected)");
+    expect(md).toContain("GMAIL_FETCH_EMAILS");
+    expect(md).toContain("Read recent emails");
+    expect(md).toContain("label_ids");
+    expect(md).toContain("Composio MCP");
+  });
+});
+
+describe("loadComposioToolCheatSheetMarkdown", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("reads composio-tool-index.json from workspace dir", () => {
+    tmp = path.join(
+      os.tmpdir(),
+      `dench-composio-index-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    writeFileSync(
+      path.join(tmp, "composio-tool-index.json"),
+      JSON.stringify({
+        generated_at: "2025-01-02T00:00:00.000Z",
+        connected_apps: [
+          {
+            toolkit_slug: "slack",
+            toolkit_name: "Slack",
+            account_count: 1,
+            tools: [
+              {
+                name: "SLACK_SEND_MESSAGE",
+                title: "Send",
+                description_short: "Send a message.",
+                required_args: ["channel", "text"],
+                arg_hints: {},
+              },
+            ],
+            recipes: {},
+          },
+        ],
+      }),
+      "utf-8",
+    );
+
+    const md = loadComposioToolCheatSheetMarkdown(tmp);
+    expect(md).toContain("Slack (1 account connected)");
+    expect(md).toContain("SLACK_SEND_MESSAGE");
+    expect(md).toContain("composio_resolve_tool");
+  });
+
+  it("only claims verified MCP availability when the status file says so", () => {
+    tmp = path.join(
+      os.tmpdir(),
+      `dench-composio-status-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    writeFileSync(
+      path.join(tmp, "composio-tool-index.json"),
+      JSON.stringify({
+        generated_at: "2025-01-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: "List inbox messages.",
+                required_args: [],
+                arg_hints: {},
+                default_args: { label_ids: ["INBOX"], max_results: 10 },
+              },
+            ],
+            recipes: { "Read recent emails": "GMAIL_FETCH_EMAILS" },
+          },
+        ],
+      }),
+      "utf-8",
+    );
+    writeFileSync(
+      path.join(tmp, "composio-mcp-status.json"),
+      JSON.stringify({
+        summary: {
+          verified: false,
+          message: "Composio MCP is configured and the gateway is reachable, but live agent visibility has not been verified yet.",
+        },
+      }),
+      "utf-8",
+    );
+
+    const md = loadComposioToolCheatSheetMarkdown(tmp);
+    expect(md).toContain("configured integration layer");
+    expect(md).not.toContain("verified MCP tools available");
+  });
+
+  it("returns null when file is missing", () => {
+    tmp = path.join(
+      os.tmpdir(),
+      `dench-composio-empty-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmp, { recursive: true });
+    expect(loadComposioToolCheatSheetMarkdown(tmp)).toBeNull();
+  });
+});