denchclaw 2.4.6 → 2.5.1

package/apps/web/.next/standalone/extensions/dench-ai-gateway/models.ts

@@ -0,0 +1,325 @@
+export const DEFAULT_DENCH_CLOUD_GATEWAY_URL = "https://gateway.merseoriginals.com";
+export const DEFAULT_DENCH_CLOUD_MARGIN_PERCENT = 0.35;
+
+export type DenchCloudCatalogCost = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  marginPercent?: number;
+};
+
+export type DenchCloudCatalogModel = {
+  id: string;
+  stableId: string;
+  displayName: string;
+  provider: string;
+  transportProvider: string;
+  api: "openai-completions" | "openai-responses";
+  input: Array<"text" | "image">;
+  reasoning: boolean;
+  contextWindow: number;
+  maxTokens: number;
+  supportsStreaming: boolean;
+  supportsImages: boolean;
+  supportsResponses: boolean;
+  supportsReasoning: boolean;
+  cost: DenchCloudCatalogCost;
+};
+
+type UnknownRecord = Record<string, unknown>;
+
+function roundUsd(value: number): number {
+  return Number(value.toFixed(8));
+}
+
+function markupCost(value: number): number {
+  return roundUsd(value * (1 + DEFAULT_DENCH_CLOUD_MARGIN_PERCENT));
+}
+
+function asRecord(value: unknown): UnknownRecord | undefined {
+  return value && typeof value === "object" ? (value as UnknownRecord) : undefined;
+}
+
+function readString(input: UnknownRecord, ...keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function readNumber(input: UnknownRecord, ...keys: string[]): number | undefined {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return undefined;
+}
+
+function readBoolean(input: UnknownRecord, ...keys: string[]): boolean | undefined {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function isNonEmptyString(value: string | undefined): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function normalizeInputKinds(input: unknown, supportsImages: boolean): Array<"text" | "image"> {
+  if (!Array.isArray(input)) {
+    return supportsImages ? ["text", "image"] : ["text"];
+  }
+
+  const kinds = new Set<"text" | "image">();
+  for (const value of input) {
+    if (value === "text" || value === "image") {
+      kinds.add(value);
+    }
+  }
+
+  if (!kinds.has("text")) {
+    kinds.add("text");
+  }
+  if (supportsImages) {
+    kinds.add("image");
+  }
+  return [...kinds];
+}
+
+export function normalizeDenchGatewayUrl(value: string | undefined): string {
+  const raw = (value || DEFAULT_DENCH_CLOUD_GATEWAY_URL).trim();
+  const withProtocol = raw.startsWith("http://") || raw.startsWith("https://")
+    ? raw
+    : `https://${raw}`;
+  return withProtocol.replace(/\/+$/, "").replace(/\/v1$/u, "");
+}
+
+export function buildDenchGatewayApiBaseUrl(gatewayUrl: string | undefined): string {
+  return `${normalizeDenchGatewayUrl(gatewayUrl)}/v1`;
+}
+
+export function buildDenchGatewayCatalogUrl(gatewayUrl: string | undefined): string {
+  return `${normalizeDenchGatewayUrl(gatewayUrl)}/v1/public/models`;
+}
+
+export const RECOMMENDED_DENCH_CLOUD_MODEL_ID = "claude-opus-4.6";
+
+export const FALLBACK_DENCH_CLOUD_MODELS: DenchCloudCatalogModel[] = [
+  {
+    id: "claude-opus-4.6",
+    stableId: "anthropic.claude-opus-4-6-v1",
+    displayName: "Claude Opus 4.6",
+    provider: "anthropic",
+    transportProvider: "bedrock",
+    api: "openai-responses",
+    input: ["text", "image"],
+    reasoning: false,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsResponses: true,
+    supportsReasoning: false,
+    cost: {
+      input: markupCost(5),
+      output: markupCost(25),
+      cacheRead: 0,
+      cacheWrite: 0,
+      marginPercent: DEFAULT_DENCH_CLOUD_MARGIN_PERCENT,
+    },
+  },
+  {
+    id: "gpt-5.4",
+    stableId: "gpt-5.4",
+    displayName: "GPT-5.4",
+    provider: "openai",
+    transportProvider: "openai",
+    api: "openai-responses",
+    input: ["text", "image"],
+    reasoning: false,
+    contextWindow: 128000,
+    maxTokens: 128000,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsResponses: true,
+    supportsReasoning: false,
+    cost: {
+      input: markupCost(2.5),
+      output: markupCost(15),
+      cacheRead: 0,
+      cacheWrite: 0,
+      marginPercent: DEFAULT_DENCH_CLOUD_MARGIN_PERCENT,
+    },
+  },
+  {
+    id: "claude-sonnet-4.6",
+    stableId: "anthropic.claude-sonnet-4-6-v1",
+    displayName: "Claude Sonnet 4.6",
+    provider: "anthropic",
+    transportProvider: "bedrock",
+    api: "openai-responses",
+    input: ["text", "image"],
+    reasoning: false,
+    contextWindow: 200000,
+    maxTokens: 64000,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsResponses: true,
+    supportsReasoning: false,
+    cost: {
+      input: markupCost(3),
+      output: markupCost(15),
+      cacheRead: 0,
+      cacheWrite: 0,
+      marginPercent: DEFAULT_DENCH_CLOUD_MARGIN_PERCENT,
+    },
+  },
+];
+
+export function cloneFallbackDenchCloudModels(): DenchCloudCatalogModel[] {
+  return FALLBACK_DENCH_CLOUD_MODELS.map((model) => ({
+    ...model,
+    input: [...model.input],
+    cost: { ...model.cost },
+  }));
+}
+
+export function normalizeDenchCloudCatalogModel(input: unknown): DenchCloudCatalogModel | null {
+  const record = asRecord(input);
+  if (!record) {
+    return null;
+  }
+
+  const publicId = readString(record, "id", "publicId", "public_id");
+  const stableId = readString(record, "stableId", "stable_id") || publicId;
+  const displayName = readString(record, "name", "displayName", "display_name");
+  const provider = readString(record, "provider");
+  const transportProvider = readString(record, "transportProvider", "transport_provider");
+  if (!publicId || !stableId || !displayName || !isNonEmptyString(provider) || !isNonEmptyString(transportProvider)) {
+    return null;
+  }
+
+  const supportsImages = readBoolean(record, "supportsImages", "supports_images") ?? false;
+  const supportsStreaming = readBoolean(record, "supportsStreaming", "supports_streaming") ?? true;
+  const supportsResponses = readBoolean(record, "supportsResponses", "supports_responses") ?? true;
+  const supportsReasoning = readBoolean(record, "supportsReasoning", "supports_reasoning")
+    ?? readBoolean(record, "reasoning")
+    ?? false;
+  const contextWindow = readNumber(record, "contextWindow", "context_window") ?? 200000;
+  const maxTokens = readNumber(record, "maxTokens", "max_tokens", "maxOutputTokens", "max_output_tokens") ?? 64000;
+
+  const costRecord = asRecord(record.cost) ?? {};
+  const inputCost = readNumber(costRecord, "input") ?? 0;
+  const outputCost = readNumber(costRecord, "output") ?? 0;
+  const cacheRead = readNumber(costRecord, "cacheRead", "cache_read") ?? 0;
+  const cacheWrite = readNumber(costRecord, "cacheWrite", "cache_write") ?? 0;
+  const marginPercent = readNumber(costRecord, "marginPercent", "margin_percent");
+
+  return {
+    id: publicId,
+    stableId,
+    displayName,
+    provider,
+    transportProvider,
+    api: record.api === "openai-completions" ? "openai-completions" : "openai-responses",
+    input: normalizeInputKinds(record.input, supportsImages),
+    reasoning: supportsReasoning,
+    contextWindow,
+    maxTokens,
+    supportsStreaming,
+    supportsImages,
+    supportsResponses,
+    supportsReasoning,
+    cost: {
+      input: inputCost,
+      output: outputCost,
+      cacheRead,
+      cacheWrite,
+      ...(marginPercent !== undefined ? { marginPercent } : {}),
+    },
+  };
+}
+
+export function normalizeDenchCloudCatalogResponse(payload: unknown): DenchCloudCatalogModel[] {
+  const root = asRecord(payload);
+  const data = root?.data;
+  if (!Array.isArray(data)) {
+    return [];
+  }
+
+  const models: DenchCloudCatalogModel[] = [];
+  const seen = new Set<string>();
+  for (const entry of data) {
+    const normalized = normalizeDenchCloudCatalogModel(entry);
+    if (!normalized || seen.has(normalized.stableId)) {
+      continue;
+    }
+    seen.add(normalized.stableId);
+    models.push(normalized);
+  }
+  return models;
+}
+
+export function buildDenchCloudProviderModels(models: DenchCloudCatalogModel[]) {
+  return models.map((model) => ({
+    id: model.stableId,
+    name: `${model.displayName} (Dench Cloud)`,
+    reasoning: model.reasoning,
+    input: [...model.input],
+    cost: {
+      input: model.cost.input,
+      output: model.cost.output,
+      cacheRead: model.cost.cacheRead,
+      cacheWrite: model.cost.cacheWrite,
+    },
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+  }));
+}
+
+export function buildDenchCloudAgentModelEntries(models: DenchCloudCatalogModel[]) {
+  return Object.fromEntries(
+    models.map((model) => [
+      `dench-cloud/${model.stableId}`,
+      { alias: `${model.displayName} (Dench Cloud)` },
+    ]),
+  );
+}
+
+export function resolveDenchCloudModel(
+  models: DenchCloudCatalogModel[],
+  requestedId: string | undefined,
+): DenchCloudCatalogModel | undefined {
+  const normalized = requestedId?.trim();
+  if (!normalized) {
+    return (
+      models.find((model) => model.id === RECOMMENDED_DENCH_CLOUD_MODEL_ID) ||
+      models[0]
+    );
+  }
+
+  return models.find((model) => model.id === normalized || model.stableId === normalized);
+}
+
+export function formatDenchCloudModelHint(model: DenchCloudCatalogModel): string {
+  const parts: string[] = [model.provider];
+  if (model.reasoning) parts.push("reasoning");
+  if (model.id === RECOMMENDED_DENCH_CLOUD_MODEL_ID) parts.push("recommended");
+  return parts.join(" · ");
+}

package/apps/web/.next/standalone/extensions/dench-ai-gateway/openclaw.plugin.json

@@ -0,0 +1,27 @@
+{
+  "id": "dench-ai-gateway",
+  "name": "Dench AI Gateway",
+  "version": "1.0.0",
+  "description": "Registers Dench Cloud as an OpenClaw model provider with live gateway-backed model discovery.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "gatewayUrl": {
+        "type": "string",
+        "default": "https://gateway.merseoriginals.com"
+      },
+      "enabled": {
+        "type": "boolean",
+        "default": true
+      }
+    },
+    "required": []
+  },
+  "uiHints": {
+    "gatewayUrl": {
+      "label": "Dench Gateway URL",
+      "placeholder": "https://gateway.merseoriginals.com"
+    }
+  }
+}

package/apps/web/.next/standalone/extensions/dench-ai-gateway/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@denchclaw/dench-ai-gateway",
+  "version": "1.0.0",
+  "private": true,
+  "openclaw": {
+    "extensions": ["./index.ts"]
+  }
+}

package/apps/web/.next/standalone/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();
+  });
+});

package/apps/web/.next/standalone/extensions/dench-identity/composio-cheat-sheet.ts

@@ -0,0 +1,197 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * Shape written by `apps/web/lib/composio-tool-index.ts` to
+ * `<workspace>/composio-tool-index.json`. Kept in the extension package so the
+ * agent runtime can format the cheat sheet without importing the Next app.
+ */
+export type ComposioToolIndexFile = {
+  generated_at: string;
+  connected_apps: Array<{
+    toolkit_slug: string;
+    toolkit_name: string;
+    account_count: number;
+    tools: Array<{
+      name: string;
+      title: string;
+      description_short: string;
+      required_args: string[];
+      arg_hints: Record<string, string>;
+      default_args?: Record<string, unknown>;
+      example_args?: Record<string, unknown>;
+      example_prompts?: string[];
+      input_schema?: Record<string, unknown>;
+    }>;
+    recipes: Record<string, string>;
+  }>;
+};
+
+type ComposioMcpStatusFile = {
+  summary?: {
+    verified?: boolean;
+    message?: string;
+  };
+  config?: {
+    status?: "pass" | "fail" | "unknown";
+  };
+  gatewayTools?: {
+    status?: "pass" | "fail" | "unknown";
+  };
+  liveAgent?: {
+    status?: "pass" | "fail" | "unknown";
+  };
+};
+
+function isComposioToolIndexFile(value: unknown): value is ComposioToolIndexFile {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const rec = value as Record<string, unknown>;
+  if (typeof rec.generated_at !== "string" || !Array.isArray(rec.connected_apps)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Build markdown for the identity system prompt from a parsed index file.
+ */
+export function formatComposioToolCheatSheetFromIndex(index: ComposioToolIndexFile): string {
+  return formatComposioToolCheatSheet(index, null);
+}
+
+function formatComposioToolCheatSheet(
+  index: ComposioToolIndexFile,
+  status: ComposioMcpStatusFile | null,
+): string {
+  const verified = status?.summary?.verified === true;
+  const summaryMessage = typeof status?.summary?.message === "string" ? status.summary.message : null;
+  const lines: string[] = [
+    "## Connected App Tools (via Composio MCP)",
+    "",
+    verified
+      ? "You have verified MCP tools available for these connected apps. Call them directly."
+      : "Composio MCP is the configured integration layer for these connected apps. If the MCP tools are missing in this session, stop and report the Composio MCP repair status instead of bypassing it.",
+    "",
+    "- Use `composio_resolve_tool` first when the exact Composio tool name or argument shape is not already obvious.",
+    "- Never use `gog`, shell CLIs, curl, or raw `/v1/composio/*` HTTP as a fallback for these connected apps.",
+    "- If a Composio tool fails because of argument shape, fix the JSON arguments and retry once.",
+    "",
+  ];
+  if (summaryMessage) {
+    lines.push(`Current verification status: ${summaryMessage}`, "");
+  }
+
+  for (const app of index.connected_apps) {
+    const title =
+      app.account_count > 1
+        ? `### ${app.toolkit_name} (${app.account_count} accounts connected)`
+        : `### ${app.toolkit_name} (1 account connected)`;
+    lines.push(title, "");
+    lines.push("| Intent | Tool | Key args |");
+    lines.push("|--------|------|----------|");
+
+    const recipeByTool = Object.fromEntries(
+      Object.entries(app.recipes).map(([intent, tool]) => [tool, intent]),
+    );
+
+    for (const tool of app.tools) {
+      const intent = recipeByTool[tool.name] ?? "—";
+      const keyParts: string[] = [];
+      for (const a of tool.required_args.slice(0, 4)) {
+        keyParts.push(a);
+      }
+      const hintSample = Object.entries(tool.arg_hints).slice(0, 2);
+      for (const [k, v] of hintSample) {
+        keyParts.push(`${k}: ${v}`);
+      }
+      if (tool.default_args && Object.keys(tool.default_args).length > 0) {
+        keyParts.push(`defaults: ${JSON.stringify(tool.default_args)}`);
+      }
+      const keyArgs = keyParts.length ? keyParts.join("; ") : "—";
+      lines.push(`| ${intent} | \`${tool.name}\` | ${keyArgs} |`);
+    }
+
+    const gotchas = Object.entries(
+      app.tools.reduce<Record<string, string>>((acc, t) => {
+        for (const [k, v] of Object.entries(t.arg_hints)) {
+          if (!acc[k]) {
+            acc[k] = v;
+          }
+        }
+        return acc;
+      }, {}),
+    );
+    if (gotchas.length > 0) {
+      lines.push("");
+      lines.push(
+        "**Known gotchas:**",
+        ...gotchas.map(([k, v]) => `- \`${k}\`: ${v}`),
+      );
+    }
+
+    const extraRecipes = Object.entries(app.recipes).filter(
+      ([, toolName]) => !app.tools.some((t) => t.name === toolName),
+    );
+    if (extraRecipes.length > 0) {
+      lines.push("");
+      lines.push("**More intents (tool may be outside the curated direct-tool list):**");
+      for (const [intent, toolName] of extraRecipes) {
+        lines.push(`- ${intent}: \`${toolName}\``);
+      }
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd() + "\n";
+}
+
+function readComposioToolIndex(workspaceDir: string): ComposioToolIndexFile | null {
+  const filePath = path.join(workspaceDir, "composio-tool-index.json");
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8")) as unknown;
+    return isComposioToolIndexFile(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readComposioToolIndexFile(workspaceDir: string): ComposioToolIndexFile | null {
+  return readComposioToolIndex(workspaceDir);
+}
+
+function readComposioMcpStatus(workspaceDir: string): ComposioMcpStatusFile | null {
+  const filePath = path.join(workspaceDir, "composio-mcp-status.json");
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8")) as unknown;
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return raw as ComposioMcpStatusFile;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function readComposioMcpStatusFile(workspaceDir: string): ComposioMcpStatusFile | null {
+  return readComposioMcpStatus(workspaceDir);
+}
+
+/**
+ * Loads and formats the cheat sheet, or returns null if no index file / invalid JSON.
+ */
+export function loadComposioToolCheatSheetMarkdown(workspaceDir: string): string | null {
+  const index = readComposioToolIndex(workspaceDir);
+  if (!index || index.connected_apps.length === 0) {
+    return null;
+  }
+  return formatComposioToolCheatSheet(index, readComposioMcpStatus(workspaceDir));
+}