denchclaw 3.1.2 → 3.1.4

package/extensions/dench-identity/index.test.ts

@@ -311,6 +311,7 @@ describe("register", () => {
 
     expect(api.registerTool).toHaveBeenCalledWith(
       expect.objectContaining({ name: "dench_search_integrations" }),
+      { name: "dench_search_integrations", optional: true },
     );
     expect(getRegisteredTool(api as any, "dench_execute_integrations")).toBeUndefined();
 
@@ -694,7 +695,7 @@ describe("register", () => {
     rmSync(tmp, { recursive: true, force: true });
   });
 
-  it("returns no-match guidance when a toolkit search has no matching tools", async () => {
+  it("returns static fallback recipes when a connected toolkit search has no gateway matches", async () => {
     const tmp = path.join(
       os.tmpdir(),
       `dench-identity-no-match-${Date.now()}-${Math.random().toString(36).slice(2)}`,
@@ -720,9 +721,16 @@ describe("register", () => {
     });
     const payload = JSON.parse(result.content[0].text);
 
-    expect(payload.result_count).toBe(0);
+    expect(payload.result_count).toBe(1);
+    expect(payload.results[0].tool_slug).toBe("GMAIL_FETCH_EMAILS");
+    expect(payload.results[0].suggested_arguments).toEqual({
+      label_ids: ["INBOX"],
+      max_results: 10,
+    });
+    expect(payload.search_source).toBe("static_recipe_fallback");
     expect(payload.connected_toolkits).toEqual(["gmail"]);
-    expect(payload.instruction).toContain("No Gmail integration tools matched");
+    expect(payload.instruction).toContain("dench_execute_integrations");
+    expect(payload.instruction).toContain("Do NOT stop");
 
     rmSync(tmp, { recursive: true, force: true });
   });

package/extensions/dench-identity/index.ts

@@ -1213,6 +1213,80 @@ function chooseFallbackTool(app: string, queryText: string) {
   return best;
 }
 
+function buildStaticFallbackInputSchema(
+  recipe: (typeof STATIC_COMPOSIO_FALLBACK)[string][number],
+) {
+  const properties: Record<string, unknown> = {};
+  for (const arg of recipe.required_args ?? []) {
+    properties[arg] = { type: "string" };
+  }
+  for (const [key, hint] of Object.entries(recipe.arg_hints ?? {})) {
+    properties[key] = {
+      type: typeof hint === "number" ? "number" : Array.isArray(hint) ? "array" : "string",
+      description: Array.isArray(hint) ? JSON.stringify(hint) : String(hint),
+    };
+  }
+  return {
+    type: "object",
+    properties,
+    required: recipe.required_args ?? [],
+  };
+}
+
+function buildStaticFallbackSearchResults(toolkitSlug: string, queryText: string) {
+  const recipe = chooseFallbackTool(toolkitSlug, queryText);
+  if (!recipe) {
+    return [];
+  }
+
+  return [
+    {
+      tool_slug: recipe.tool,
+      name: recipe.intent,
+      description: `Known ${humanizeResolverApp(toolkitSlug)} recipe (local fallback because gateway search returned no matches).`,
+      toolkit: {
+        slug: toolkitSlug,
+        name: humanizeResolverApp(toolkitSlug),
+      },
+      input_schema: buildStaticFallbackInputSchema(recipe),
+      suggested_arguments: recipe.default_args ?? {},
+      is_connected: true,
+      account_count: null,
+      accounts: [],
+      match_source: "static_recipe_fallback",
+    },
+  ];
+}
+
+function buildEmptyConnectedSearchInstruction(params: {
+  normalizedToolkit: string;
+  query: string;
+  fallbackResults: Array<Record<string, unknown>>;
+}): string {
+  if (params.fallbackResults.length > 0) {
+    const top = params.fallbackResults[0] ?? {};
+    const slug = readString(top.tool_slug) ?? "the top fallback tool_slug";
+    const suggested = top.suggested_arguments;
+    const suggestedText =
+      suggested && typeof suggested === "object" && Object.keys(suggested as object).length > 0
+        ? ` and suggested_arguments ${JSON.stringify(suggested)}`
+        : "";
+    return [
+      `Gateway search returned no matches, but ${humanizeResolverApp(params.normalizedToolkit)} is connected.`,
+      "Do NOT stop the task, do NOT mention gog, and do NOT switch to shell CLIs.",
+      `Call ${DENCH_EXECUTE_INTEGRATIONS_NAME} immediately with tool_slug "${slug}"${suggestedText}.`,
+      `If execution fails, retry ${DENCH_SEARCH_INTEGRATIONS_NAME} with toolkit only (omit query) or a shorter query.`,
+    ].join(" ");
+  }
+
+  return [
+    `No ${humanizeResolverApp(params.normalizedToolkit)} integration tools matched gateway search.`,
+    "Do NOT stop — retry search with toolkit only (omit query), a shorter query, or a different keyword.",
+    `Then execute the best match with ${DENCH_EXECUTE_INTEGRATIONS_NAME}.`,
+    "Never fall back to gog while this app is connected.",
+  ].join(" ");
+}
+
 type ComposioSearchPresentationResult = {
   app: ComposioToolIndexFile["connected_apps"][number];
   search: ComposioToolSearchResult;
@@ -1832,11 +1906,36 @@ function createDenchSearchIntegrationsTool(api: OpenClawPluginApi): AnyAgentTool
         });
       }
 
-      const items = asRecordArray(gatewayResult.items) ?? [];
-      const connectedToolkits = Array.isArray(gatewayResult.connected_toolkits)
+      let items = asRecordArray(gatewayResult.items) ?? [];
+      let connectedToolkits = Array.isArray(gatewayResult.connected_toolkits)
         ? (gatewayResult.connected_toolkits as string[])
         : [];
 
+      if (
+        items.length === 0 &&
+        normalizedToolkit &&
+        query &&
+        connectedToolkits.includes(normalizedToolkit)
+      ) {
+        const retryResult = await postComposioGatewayJson({
+          api,
+          path: "/v1/composio/tools/search",
+          body: {
+            toolkit_slug: normalizedToolkit,
+            limit,
+          },
+        });
+        if (retryResult) {
+          const retryItems = asRecordArray(retryResult.items) ?? [];
+          if (retryItems.length > 0) {
+            items = retryItems;
+          }
+          if (Array.isArray(retryResult.connected_toolkits)) {
+            connectedToolkits = retryResult.connected_toolkits as string[];
+          }
+        }
+      }
+
       if (
         items.length === 0 &&
         normalizedToolkit &&
@@ -1858,15 +1957,29 @@ function createDenchSearchIntegrationsTool(api: OpenClawPluginApi): AnyAgentTool
       }
 
       if (items.length === 0) {
+        const fallbackResults =
+          normalizedToolkit && connectedToolkits.includes(normalizedToolkit)
+            ? buildStaticFallbackSearchResults(normalizedToolkit, query)
+            : [];
+
         return jsonResult({
           query,
           toolkit_filter: normalizedToolkit,
-          result_count: 0,
-          results: [],
+          result_count: fallbackResults.length,
+          results: fallbackResults,
           connected_toolkits: connectedToolkits,
-          instruction: normalizedToolkit
-            ? `No ${humanizeResolverApp(normalizedToolkit)} integration tools matched. Refine the query or try a broader search.`
-            : "No integration tools matched. Refine the query or specify a toolkit.",
+          search_source:
+            fallbackResults.length > 0 ? "static_recipe_fallback" : "gateway_tool_router",
+          instruction:
+            normalizedToolkit && connectedToolkits.includes(normalizedToolkit)
+              ? buildEmptyConnectedSearchInstruction({
+                  normalizedToolkit,
+                  query,
+                  fallbackResults,
+                })
+              : normalizedToolkit
+                ? `No ${humanizeResolverApp(normalizedToolkit)} integration tools matched. Refine the query or try a broader search.`
+                : "No integration tools matched. Refine the query or specify a toolkit.",
         });
       }
 
@@ -1927,6 +2040,7 @@ function buildComposioDefaultGuidance(composioAppsSkillPath: string): string {
     "- Missing first-time connection example: `[Connect Slack](dench://composio/connect?toolkit=slack&name=Slack)`.",
     '- If the search returns `availability: "connect_required"`, briefly explain the app is not connected and end with the connect link.',
     "- If an integration tool call fails because of argument shape, fix the arguments and retry once before considering any fallback.",
+    "- When search returns zero gateway matches but the app is connected, the tool may include `static_recipe_fallback` results with `suggested_arguments`. Execute the top match immediately — do NOT stop the turn or switch to gog.",
     "- When the user implicitly asks for the full dataset, keep paginating until the tool response no longer advertises more pages.",
     "",
   ].join("\n");
@@ -2081,7 +2195,13 @@ export default function register(api: any) {
     typeof api.registerTool === "function" &&
     shouldRegisterIntegrationTools(workspaceDir)
   ) {
-    api.registerTool(createDenchSearchIntegrationsTool(api));
+    api.registerTool(createDenchSearchIntegrationsTool(api), {
+      name: DENCH_SEARCH_INTEGRATIONS_NAME,
+      optional: true,
+    });
+    api.logger?.info?.(
+      `[dench-identity] registered ${DENCH_SEARCH_INTEGRATIONS_NAME} integration tool`,
+    );
   }
 
   api.on(

package/extensions/dench-identity/openclaw.plugin.json

@@ -3,6 +3,14 @@
   "name": "DenchClaw Identity",
   "version": "1.0.0",
   "description": "Injects the DenchClaw identity and behavioral contracts into the agent system prompt.",
+  "activation": {
+    "onStartup": true
+  },
+  "contracts": {
+    "tools": [
+      "dench_search_integrations"
+    ]
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/extensions/dench-identity/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./index.mjs"
     ]
   }
 }

package/extensions/exa-search/index.mjs

@@ -0,0 +1,333 @@
+// extensions/shared/dench-auth.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var DEFAULT_GATEWAY_URL = "https://gateway.merseoriginals.com";
+var AUTH_PROFILES_REL = path.join("agents", "main", "agent", "auth-profiles.json");
+function readDenchAuthProfileKey() {
+  const stateDir = process.env.OPENCLAW_STATE_DIR;
+  if (stateDir) {
+    const key = readKeyFromAuthProfiles(path.join(stateDir, AUTH_PROFILES_REL));
+    if (key) return key;
+  }
+  return envFallback();
+}
+function readKeyFromAuthProfiles(authPath) {
+  try {
+    if (!existsSync(authPath)) return void 0;
+    const raw = JSON.parse(readFileSync(authPath, "utf-8"));
+    const key = raw?.profiles?.["dench-cloud:default"]?.key;
+    return typeof key === "string" && key.trim() ? key.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function envFallback() {
+  return process.env.DENCH_CLOUD_API_KEY?.trim() || process.env.DENCH_API_KEY?.trim() || void 0;
+}
+function resolveDenchGatewayUrl(pluginConfig) {
+  const configured = pluginConfig?.gatewayUrl;
+  if (typeof configured === "string" && configured.trim()) return configured.trim();
+  return process.env.DENCH_GATEWAY_URL?.trim() || DEFAULT_GATEWAY_URL;
+}
+
+// extensions/exa-search/index.ts
+var id = "exa-search";
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function readTrimmedString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readStringList(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const items = value.map((item) => readTrimmedString(item)).filter((item) => Boolean(item));
+  return items.length > 0 ? items : void 0;
+}
+function jsonResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload
+  };
+}
+var SEARCH_TYPES = ["auto", "neural", "fast", "deep", "deep-reasoning", "instant"];
+var SEARCH_CATEGORIES = [
+  "company",
+  "research paper",
+  "news",
+  "personal site",
+  "financial report",
+  "people"
+];
+var ExaSearchParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    query: { type: "string", description: "Search query." },
+    searchType: { type: "string", enum: [...SEARCH_TYPES], description: "Exa search type." },
+    category: { type: "string", enum: [...SEARCH_CATEGORIES], description: "Exa search category." },
+    numResults: { type: "number", description: "Maximum number of results." },
+    includeDomains: {
+      type: "array",
+      items: { type: "string" },
+      description: "Only search these domains."
+    },
+    excludeDomains: {
+      type: "array",
+      items: { type: "string" },
+      description: "Exclude these domains."
+    },
+    startPublishedDate: { type: "string", description: "ISO date lower bound for published date." },
+    endPublishedDate: { type: "string", description: "ISO date upper bound for published date." },
+    text: { type: "boolean", description: "Include extracted page text." },
+    textMaxCharacters: { type: "number", description: "Maximum characters of extracted text." },
+    highlights: { type: "boolean", description: "Include highlights." },
+    highlightsMaxCharacters: { type: "number", description: "Maximum characters in highlights." },
+    summary: { type: "boolean", description: "Include a summary." },
+    summaryQuery: { type: "string", description: "Summary query prompt to send upstream." }
+  },
+  required: ["query"]
+};
+var ExaContentsParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    urls: { type: "array", items: { type: "string" }, description: "URLs to fetch content for." },
+    text: { type: "boolean", description: "Include extracted page text." },
+    textMaxCharacters: { type: "number", description: "Maximum characters of extracted text." },
+    highlights: { type: "boolean", description: "Include highlights." },
+    highlightsMaxCharacters: { type: "number", description: "Maximum characters in highlights." },
+    summary: { type: "boolean", description: "Include a summary." },
+    summaryQuery: { type: "string", description: "Summary query prompt to send upstream." }
+  },
+  required: ["urls"]
+};
+var ExaAnswerParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    query: { type: "string", description: "Question to answer." },
+    text: { type: "boolean", description: "Include extra answer text fields." }
+  },
+  required: ["query"]
+};
+function buildTextOption(params) {
+  if (typeof params.textMaxCharacters === "number") {
+    return { maxCharacters: params.textMaxCharacters };
+  }
+  if (params.text === true) {
+    return true;
+  }
+  return void 0;
+}
+function buildHighlightsOption(params) {
+  if (typeof params.highlightsMaxCharacters === "number") {
+    return { maxCharacters: params.highlightsMaxCharacters };
+  }
+  if (params.highlights === true) {
+    return true;
+  }
+  return void 0;
+}
+function buildSummaryOption(params) {
+  const query = readTrimmedString(params.summaryQuery);
+  if (query) {
+    return { query };
+  }
+  if (params.summary === true) {
+    return {};
+  }
+  return void 0;
+}
+function buildSearchBody(params) {
+  const body = {
+    query: params.query
+  };
+  const searchType = readTrimmedString(params.searchType);
+  const category = readTrimmedString(params.category);
+  const includeDomains = readStringList(params.includeDomains);
+  const excludeDomains = readStringList(params.excludeDomains);
+  const startPublishedDate = readTrimmedString(params.startPublishedDate);
+  const endPublishedDate = readTrimmedString(params.endPublishedDate);
+  const text = buildTextOption(params);
+  const highlights = buildHighlightsOption(params);
+  const summary = buildSummaryOption(params);
+  const contents = {};
+  if (searchType) {
+    body.type = searchType;
+  }
+  if (category) {
+    body.category = category;
+  }
+  if (typeof params.numResults === "number") {
+    body.numResults = params.numResults;
+  }
+  if (includeDomains) {
+    body.includeDomains = includeDomains;
+  }
+  if (excludeDomains) {
+    body.excludeDomains = excludeDomains;
+  }
+  if (startPublishedDate) {
+    body.startPublishedDate = startPublishedDate;
+  }
+  if (endPublishedDate) {
+    body.endPublishedDate = endPublishedDate;
+  }
+  if (text !== void 0) {
+    contents.text = text;
+  }
+  if (highlights !== void 0) {
+    contents.highlights = highlights;
+  }
+  if (summary !== void 0) {
+    contents.summary = summary;
+  }
+  if (Object.keys(contents).length > 0) {
+    body.contents = contents;
+  }
+  return body;
+}
+function buildContentsBody(params) {
+  const urls = readStringList(params.urls);
+  const body = {
+    urls: urls ?? []
+  };
+  const text = buildTextOption(params);
+  const highlights = buildHighlightsOption(params);
+  const summary = buildSummaryOption(params);
+  if (text !== void 0) {
+    body.text = text;
+  }
+  if (highlights !== void 0) {
+    body.highlights = highlights;
+  }
+  if (summary !== void 0) {
+    body.summary = summary;
+  }
+  return body;
+}
+async function parseResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+async function postJson(params) {
+  const response = await fetch(`${params.gatewayUrl}${params.path}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${params.apiKey}`
+    },
+    body: JSON.stringify(params.body)
+  });
+  if (!response.ok) {
+    const detail = await parseResponse(response).catch(() => "");
+    return jsonResult({
+      error: `Search request failed (HTTP ${response.status}).`,
+      detail: detail || void 0
+    });
+  }
+  return jsonResult(await parseResponse(response));
+}
+function createExaSearchTool(gatewayUrl, apiKey) {
+  return {
+    name: "exa_search",
+    label: "Exa Search",
+    description: "Search the web through Exa via the Dench Cloud gateway, with optional text extraction, highlights, and summary generation.",
+    parameters: ExaSearchParameters,
+    execute: async (_toolCallId, params) => {
+      try {
+        return await postJson({
+          gatewayUrl,
+          apiKey,
+          path: "/v1/search",
+          body: buildSearchBody(params)
+        });
+      } catch (err) {
+        return jsonResult({
+          error: "Search request failed.",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+function createExaContentsTool(gatewayUrl, apiKey) {
+  return {
+    name: "exa_get_contents",
+    label: "Exa Get Contents",
+    description: "Fetch page contents for one or more URLs through Exa via the Dench Cloud gateway.",
+    parameters: ExaContentsParameters,
+    execute: async (_toolCallId, params) => {
+      try {
+        const urls = readStringList(params.urls);
+        if (!urls) {
+          return jsonResult({ error: "At least one URL is required." });
+        }
+        return await postJson({
+          gatewayUrl,
+          apiKey,
+          path: "/v1/search/contents",
+          body: buildContentsBody({ ...params, urls })
+        });
+      } catch (err) {
+        return jsonResult({
+          error: "Contents request failed.",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+function createExaAnswerTool(gatewayUrl, apiKey) {
+  return {
+    name: "exa_answer",
+    label: "Exa Answer",
+    description: "Ask Exa for a citation-backed answer through the Dench Cloud gateway.",
+    parameters: ExaAnswerParameters,
+    execute: async (_toolCallId, params) => {
+      try {
+        return await postJson({
+          gatewayUrl,
+          apiKey,
+          path: "/v1/search/answer",
+          body: {
+            query: params.query,
+            ...params.text === true ? { text: true } : {}
+          }
+        });
+      } catch (err) {
+        return jsonResult({
+          error: "Answer request failed.",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+function register(api) {
+  const rootConfig = asRecord(api.config);
+  const pluginEntries = asRecord(asRecord(rootConfig?.plugins)?.entries);
+  const pluginConfig = asRecord(asRecord(pluginEntries?.[id])?.config);
+  if (pluginConfig?.enabled === false) {
+    return;
+  }
+  const gwPluginConfig = asRecord(asRecord(pluginEntries?.["dench-ai-gateway"])?.config);
+  const gatewayUrl = resolveDenchGatewayUrl(gwPluginConfig);
+  const apiKey = readDenchAuthProfileKey();
+  if (!apiKey) {
+    api.logger?.info?.("[exa-search] No Dench Cloud API key found; tools will not be registered.");
+    return;
+  }
+  api.registerTool(createExaSearchTool(gatewayUrl, apiKey));
+  api.registerTool(createExaContentsTool(gatewayUrl, apiKey));
+  api.registerTool(createExaAnswerTool(gatewayUrl, apiKey));
+}
+export {
+  register as default,
+  id
+};

package/extensions/exa-search/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./index.mjs"
     ]
   }
 }