shadow-claw 1.31.0 → 1.33.0

package/src/subsystems/git/types.ts

@@ -33,6 +33,13 @@ export interface GitToolDeps {
   getProxyUrl: (
     pref: "local" | "public" | "custom",
     customUrl?: string,
+    loc?: {
+      protocol?: string;
+      host?: string;
+      hostname?: string;
+      origin?: string;
+      href?: string;
+    },
   ) => string;
   getRemoteUrl: (input: {
     groupRoot?: FileSystemDirectoryHandle;

package/src/subsystems/mcp/webmcp.test.ts

@@ -330,10 +330,33 @@ describe("webmcp integration", () => {
 
     expect(listTasksRegistration).toBeDefined();
     expect(listTasksRegistration.annotations).toEqual({
-      readOnlyHint: false,
+      readOnlyHint: true,
+      consequentialHint: false,
       untrustedContentHint: true,
     });
 
+    // Verify consequential tools receive consequentialHint: true
+    const consequentialToolNames = [
+      "bash",
+      "delete_file",
+      "delete_task",
+      "git_delete_repo",
+      "git_delete_branch",
+      "git_reset",
+      "git_push",
+      "email_send_message",
+      "clear_chat",
+    ];
+
+    for (const toolName of consequentialToolNames) {
+      const reg = mockRegisterTool.mock.calls
+        .map((args: any[]) => args[0])
+        .find((r: any) => r.name === toolName);
+      expect(reg).toBeDefined();
+      expect(reg.annotations.consequentialHint).toBe(true);
+      expect(reg.annotations.readOnlyHint).toBe(false);
+    }
+
     // Test that execute sends a postMessage
     const executePromise = listTasksRegistration.execute({ foo: "bar" });
 
@@ -486,4 +509,233 @@ describe("webmcp integration", () => {
     await registerWebMcpTools(null, jest.fn(), "group-webmcp");
     expect(mockRegisterTool.mock.calls.length).toBe(firstCount * 2);
   });
+
+  describe("executeWebMcpTool", () => {
+    it("executes tool passing JavaScript object directly on Chrome 155+ (PR #246/#251)", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const mockModelContext = {
+        executeTool: jest.fn(async (tool: any, input: any) => {
+          expect(tool).toBe(mockTool);
+          expect(typeof input).toBe("object");
+          expect(input).toEqual({ answer: 42 });
+          return "result-ok";
+        }),
+      };
+
+      const res = await executeWebMcpTool(mockModelContext, mockTool, {
+        answer: 42,
+      });
+      expect(res).toBe("result-ok");
+      expect(mockModelContext.executeTool).toHaveBeenCalledTimes(1);
+      expect(mockModelContext.executeTool).toHaveBeenCalledWith(
+        mockTool,
+        { answer: 42 },
+        undefined,
+      );
+    });
+
+    it("falls back to stringified JSON when executeTool throws 'Failed to parse input' (Chrome < 155 / polyfill)", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const calls: any[] = [];
+      const mockModelContext = {
+        executeTool: jest.fn(async (tool: any, input: any) => {
+          calls.push({ tool, input });
+          if (typeof input !== "string") {
+            throw new Error(
+              "Failed to parse input arguments: expected DOMString",
+            );
+          }
+          return "legacy-result";
+        }),
+      };
+
+      const res = await executeWebMcpTool(mockModelContext, mockTool, {
+        answer: 42,
+      });
+
+      expect(res).toBe("legacy-result");
+      expect(calls).toHaveLength(2);
+      expect(calls[0].input).toEqual({ answer: 42 });
+      expect(calls[1].input).toBe(JSON.stringify({ answer: 42 }));
+    });
+
+    it("falls back to stringified JSON when executeTool throws TypeError (WebIDL parameter rejection)", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const calls: any[] = [];
+      const mockModelContext = {
+        executeTool: jest.fn(async (_tool: any, input: any) => {
+          calls.push(input);
+          if (typeof input !== "string") {
+            throw new TypeError(
+              "Failed to execute 'executeTool' on 'ModelContext': parameter 2 is not of type 'DOMString'",
+            );
+          }
+          return "typeerror-fallback-result";
+        }),
+      };
+
+      const res = await executeWebMcpTool(mockModelContext, mockTool, {
+        param: "value",
+      });
+
+      expect(res).toBe("typeerror-fallback-result");
+      expect(calls).toHaveLength(2);
+      expect(calls[0]).toEqual({ param: "value" });
+      expect(calls[1]).toBe(JSON.stringify({ param: "value" }));
+    });
+
+    it("normalizes string input and executes with parsed object first then string fallback", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const calls: any[] = [];
+      const mockModelContext = {
+        executeTool: jest.fn(async (_tool: any, input: any) => {
+          calls.push(input);
+          if (typeof input !== "string") {
+            throw new Error("Failed to parse input");
+          }
+          return "string-input-result";
+        }),
+      };
+
+      const res = await executeWebMcpTool(
+        mockModelContext,
+        mockTool,
+        '{"foo":"bar"}',
+      );
+
+      expect(res).toBe("string-input-result");
+      expect(calls).toHaveLength(2);
+      expect(calls[0]).toEqual({ foo: "bar" });
+      expect(calls[1]).toBe('{"foo":"bar"}');
+    });
+
+    it("handles undefined/null input by passing empty object then empty JSON string on fallback", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const calls: any[] = [];
+      const mockModelContext = {
+        executeTool: jest.fn(async (_tool: any, input: any) => {
+          calls.push(input);
+          if (typeof input !== "string") {
+            throw new Error("Failed to parse input");
+          }
+          return "empty-result";
+        }),
+      };
+
+      const res = await executeWebMcpTool(mockModelContext, mockTool);
+
+      expect(res).toBe("empty-result");
+      expect(calls).toHaveLength(2);
+      expect(calls[0]).toEqual({});
+      expect(calls[1]).toBe("{}");
+    });
+
+    it("propagates other errors without attempting string fallback", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const mockModelContext = {
+        executeTool: jest.fn(async () => {
+          throw new Error("Tool internal execution failed");
+        }),
+      };
+
+      await expect(
+        executeWebMcpTool(mockModelContext, mockTool, { foo: "bar" }),
+      ).rejects.toThrow("Tool internal execution failed");
+
+      expect(mockModelContext.executeTool).toHaveBeenCalledTimes(1);
+    });
+
+    it("passes execution options or signal context to executeTool", async () => {
+      const { executeWebMcpTool } = await import("./webmcp.js");
+
+      const mockTool = { name: "my_tool" };
+      const controller = new AbortController();
+      const mockModelContext = {
+        executeTool: jest.fn(async (_tool: any, _input: any, options: any) => {
+          expect(options).toEqual({ signal: controller.signal });
+          return "with-signal";
+        }),
+      };
+
+      const res = await executeWebMcpTool(
+        mockModelContext,
+        mockTool,
+        { foo: "bar" },
+        { signal: controller.signal },
+      );
+
+      expect(res).toBe("with-signal");
+    });
+  });
+
+  describe("resolveWebMcpToolAnnotations", () => {
+    it("marks destructive and high-stakes tools with consequentialHint: true", async () => {
+      const { resolveWebMcpToolAnnotations, CONSEQUENTIAL_TOOL_NAMES } =
+        await import("./webmcp.js");
+
+      for (const toolName of CONSEQUENTIAL_TOOL_NAMES) {
+        const annotations = resolveWebMcpToolAnnotations(toolName);
+        expect(annotations.consequentialHint).toBe(true);
+        expect(annotations.readOnlyHint).toBe(false);
+        expect(annotations.untrustedContentHint).toBe(true);
+      }
+    });
+
+    it("marks read-only query tools with readOnlyHint: true and consequentialHint: false", async () => {
+      const { resolveWebMcpToolAnnotations, READ_ONLY_TOOL_NAMES } =
+        await import("./webmcp.js");
+
+      for (const toolName of READ_ONLY_TOOL_NAMES) {
+        const annotations = resolveWebMcpToolAnnotations(toolName);
+        expect(annotations.readOnlyHint).toBe(true);
+        expect(annotations.consequentialHint).toBe(false);
+        expect(annotations.untrustedContentHint).toBe(true);
+      }
+    });
+
+    it("marks regular state-mutating tools with readOnlyHint: false and consequentialHint: false", async () => {
+      const { resolveWebMcpToolAnnotations } = await import("./webmcp.js");
+
+      const mutatingTools = [
+        "write_file",
+        "patch_file",
+        "create_task",
+        "update_task",
+        "show_toast",
+        "send_notification",
+      ];
+
+      for (const toolName of mutatingTools) {
+        const annotations = resolveWebMcpToolAnnotations(toolName);
+        expect(annotations.readOnlyHint).toBe(false);
+        expect(annotations.consequentialHint).toBe(false);
+        expect(annotations.untrustedContentHint).toBe(true);
+      }
+    });
+
+    it("allows custom annotations to override defaults", async () => {
+      const { resolveWebMcpToolAnnotations } = await import("./webmcp.js");
+
+      const custom = resolveWebMcpToolAnnotations("read_file", {
+        consequentialHint: true,
+        customMeta: "important",
+      });
+
+      expect(custom.consequentialHint).toBe(true);
+      expect(custom.readOnlyHint).toBe(true);
+      expect(custom.customMeta).toBe("important");
+    });
+  });
 });

package/src/subsystems/mcp/webmcp.ts

@@ -235,6 +235,72 @@ export async function getWebMcpTools(): Promise<
   }
 }
 
+/**
+ * Gracefully execute a WebMCP tool on a ModelContext instance with backwards compatibility.
+ *
+ * Starting in Chrome 155.0.8052.0 (PR #246, PR #251), `document.modelContext.executeTool()`
+ * accepts an optional JavaScript object directly instead of a JSON DOMString.
+ * In Chrome < 155 and earlier polyfills, `executeTool()` required a stringified JSON arguments string.
+ *
+ * This function practices graceful degradation:
+ * 1. Prepares both an `inputObject` (for Chrome 155+) and an `inputStr` (for Chrome < 155 & polyfills).
+ * 2. Attempts to execute `executeTool(tool, inputObject, options)` first.
+ * 3. Catches errors starting with "Failed to parse input" (or TypeErrors from WebIDL DOMString checks)
+ *    and retries transparently with `JSON.stringify(inputObject)`.
+ * 4. Re-throws any unrelated execution errors.
+ */
+export async function executeWebMcpTool(
+  modelContext: any,
+  tool: any,
+  input?: unknown,
+  options?: WebMcpExecuteContext | AbortSignal,
+): Promise<unknown> {
+  if (!modelContext || typeof modelContext.executeTool !== "function") {
+    throw new Error("ModelContext executeTool is not available");
+  }
+
+  let inputObject: Record<string, unknown>;
+  let inputStr: string;
+
+  if (typeof input === "string") {
+    inputStr = input;
+    try {
+      const parsed = JSON.parse(input);
+      inputObject =
+        parsed && typeof parsed === "object" && !Array.isArray(parsed)
+          ? (parsed as Record<string, unknown>)
+          : {};
+    } catch {
+      inputObject = {};
+    }
+  } else if (input && typeof input === "object" && !Array.isArray(input)) {
+    inputObject = input as Record<string, unknown>;
+    try {
+      inputStr = JSON.stringify(input);
+    } catch {
+      inputStr = "{}";
+    }
+  } else {
+    inputObject = {};
+    inputStr = "{}";
+  }
+
+  try {
+    return await modelContext.executeTool(tool, inputObject, options);
+  } catch (err: any) {
+    const isParseError =
+      typeof err?.message === "string" &&
+      err.message.startsWith("Failed to parse input");
+    const isTypeError = err instanceof TypeError;
+
+    if (isParseError || isTypeError) {
+      return await modelContext.executeTool(tool, inputStr, options);
+    }
+
+    throw err;
+  }
+}
+
 /**
  * Feature detection for the WebMCP imperative API.
  *
@@ -246,6 +312,83 @@ export function isWebMcpSupported(): boolean {
   return !!getModelContextApi();
 }
 
+/**
+ * Consequential tools that perform high-stakes, irreversible, or external real-world actions
+ * (such as deleting data, executing arbitrary system commands, or transmitting live communications).
+ * Signals consuming agents to require explicit user confirmation prior to execution (Chrome 154.0.8017.0+).
+ */
+export const CONSEQUENTIAL_TOOL_NAMES: ReadonlySet<string> = new Set([
+  "bash",
+  "clear_chat",
+  "delete_file",
+  "delete_task",
+  "email_send_message",
+  "git_delete_branch",
+  "git_delete_repo",
+  "git_push",
+  "git_reset",
+]);
+
+/**
+ * Read-only tools that query information without mutating state.
+ */
+export const READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
+  "ask_user",
+  "detect_language",
+  "diff_files",
+  "email_read_messages",
+  "fetch_url",
+  "get_current_time",
+  "git_branches",
+  "git_diff",
+  "git_list_repos",
+  "git_log",
+  "git_read_file_at_ref",
+  "git_show",
+  "git_status",
+  "list_components",
+  "list_files",
+  "list_room_members",
+  "list_tasks",
+  "list_tool_profiles",
+  "proofread_text",
+  "read_file",
+  "remote_mcp_list_tools",
+  "rewrite_text",
+  "search_files",
+  "summarize_text",
+  "translate_text",
+  "web_search",
+  "write_text",
+]);
+
+export interface WebMcpToolAnnotations {
+  readOnlyHint?: boolean;
+  consequentialHint?: boolean;
+  untrustedContentHint?: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * Resolve annotations for a WebMCP tool registration.
+ * Allows custom annotations (from declarative or customized tool definitions)
+ * to override defaults.
+ */
+export function resolveWebMcpToolAnnotations(
+  toolName: string,
+  customAnnotations?: Record<string, unknown>,
+): WebMcpToolAnnotations {
+  const isConsequential = CONSEQUENTIAL_TOOL_NAMES.has(toolName);
+  const isReadOnly = !isConsequential && READ_ONLY_TOOL_NAMES.has(toolName);
+
+  return {
+    readOnlyHint: isReadOnly,
+    consequentialHint: isConsequential,
+    untrustedContentHint: true,
+    ...(customAnnotations || {}),
+  };
+}
+
 /**
  * Register ShadowClaw tools with the WebMCP ModelContext API.
  *
@@ -292,10 +435,10 @@ export async function registerWebMcpTools(
         name: def.name,
         description: def.description,
         inputSchema: parseWebMcpInputSchema(def.input_schema),
-        annotations: {
-          readOnlyHint: false,
-          untrustedContentHint: true,
-        },
+        annotations: resolveWebMcpToolAnnotations(
+          def.name,
+          (def as any).annotations,
+        ),
         execute: (
           input: Record<string, unknown>,
           context?: WebMcpExecuteContext | AbortSignal,

package/src/subsystems/providers/model-registry.test.ts

@@ -19,11 +19,150 @@ describe("ModelRegistry", () => {
     });
   });
 
+  it("should register and get model info with supportsPromptCaching", () => {
+    modelRegistry.registerModelInfo("test-cached-model", {
+      contextWindow: 128000,
+      maxOutput: 4096,
+      supportsPromptCaching: true,
+    });
+
+    const info = modelRegistry.getModelInfo("test-cached-model");
+    expect(info).toEqual({
+      contextWindow: 128000,
+      maxOutput: 4096,
+      supportsPromptCaching: true,
+    });
+  });
+
+  it("should extract supportsPromptCaching from supported_parameters in fetchModelInfo", async () => {
+    const mockData: any = {
+      data: [
+        {
+          id: "custom/cached-model",
+          context_length: 128000,
+          supported_parameters: ["tools", "cache_control"],
+        },
+        {
+          id: "custom/non-cached-model",
+          context_length: 32000,
+          supported_parameters: ["tools"],
+        },
+        {
+          id: "custom/explicit-cached-model",
+          context_length: 64000,
+          supports_prompt_caching: true,
+        },
+      ],
+    };
+
+    const originalFetch = (globalThis as any).fetch;
+    (globalThis as any).fetch = async () => ({
+      ok: true,
+      json: async () => mockData,
+    });
+
+    try {
+      await modelRegistry.fetchModelInfo({
+        id: "openrouter",
+        modelsUrl: "https://openrouter.ai/api/v1/models",
+        headers: {},
+      } as any);
+
+      expect(
+        modelRegistry.getModelInfo("custom/cached-model")
+          ?.supportsPromptCaching,
+      ).toBe(true);
+      expect(
+        modelRegistry.getModelInfo("custom/non-cached-model")
+          ?.supportsPromptCaching,
+      ).toBeUndefined();
+      expect(
+        modelRegistry.getModelInfo("custom/explicit-cached-model")
+          ?.supportsPromptCaching,
+      ).toBe(true);
+    } finally {
+      (globalThis as any).fetch = originalFetch;
+    }
+  });
+
   it("should return null for unknown model", () => {
     const info = modelRegistry.getModelInfo("unknown");
     expect(info).toBeNull();
   });
 
+  it("should resolve models with prefix aliases, without prefixes, and with tag suffixes", () => {
+    modelRegistry.registerModelInfo("anthropic/claude-3.7-sonnet", {
+      contextWindow: 200000,
+      maxOutput: 8192,
+      supportsPromptCaching: true,
+    });
+    modelRegistry.registerModelInfo("gpt-4o", {
+      contextWindow: 128000,
+      maxOutput: 4096,
+    });
+
+    // Lookup bare name when registered with provider prefix
+    expect(
+      modelRegistry.getModelInfo("claude-3.7-sonnet")?.supportsPromptCaching,
+    ).toBe(true);
+    // Lookup with tag suffix
+    expect(
+      modelRegistry.getModelInfo("anthropic/claude-3.7-sonnet:thinking")
+        ?.supportsPromptCaching,
+    ).toBe(true);
+    // Lookup with provider prefix when registered as bare name
+    expect(modelRegistry.getModelInfo("openai/gpt-4o")?.contextWindow).toBe(
+      128000,
+    );
+  });
+
+  it("should update alias metadata when a model is re-registered with updated capabilities", () => {
+    modelRegistry.registerModelInfo("provider/dynamic-model", {
+      contextWindow: 100000,
+      maxOutput: 4096,
+      supportsPromptCaching: false,
+    });
+
+    expect(
+      modelRegistry.getModelInfo("dynamic-model")?.supportsPromptCaching,
+    ).toBe(false);
+
+    // Re-register with updated capabilities (e.g. on provider model refresh)
+    modelRegistry.registerModelInfo("provider/dynamic-model", {
+      contextWindow: 128000,
+      maxOutput: 8192,
+      supportsPromptCaching: true,
+    });
+
+    expect(
+      modelRegistry.getModelInfo("dynamic-model")?.supportsPromptCaching,
+    ).toBe(true);
+    expect(modelRegistry.getModelInfo("dynamic-model")?.contextWindow).toBe(
+      128000,
+    );
+  });
+
+  it("should not retain stale alias lookups when models map is cleared directly", () => {
+    modelRegistry.registerModelInfo("provider/temp-model", {
+      contextWindow: 100000,
+      maxOutput: 4096,
+    });
+
+    expect(modelRegistry.getModelInfo("temp-model")).not.toBeNull();
+
+    // Directly clear models Map as done in external test setups
+    modelRegistry.models.clear();
+
+    // Re-register a different model
+    modelRegistry.registerModelInfo("provider/other-model", {
+      contextWindow: 50000,
+      maxOutput: 2048,
+    });
+
+    expect(modelRegistry.getModelInfo("temp-model")).toBeNull();
+    expect(modelRegistry.getModelInfo("other-model")).not.toBeNull();
+  });
+
   it("should fetch model info from OpenRouter format", async () => {
     const mockData: any = {
       data: [

package/src/subsystems/providers/model-registry.ts

@@ -18,6 +18,7 @@ export interface ModelMetadata {
   supportsVideoInput?: boolean;
   supportsDocumentInput?: boolean;
   routesByRequestFeatures?: boolean;
+  supportsPromptCaching?: boolean;
 }
 
 /**
@@ -34,10 +35,48 @@ class ModelRegistry {
   models: Map<string, ModelMetadata> = new Map();
 
   /**
-   * Get metadata for a model ID. Lookup is case-insensitive.
+   * Get metadata for a model ID. Lookup is case-insensitive and resilient
+   * to provider prefixes (e.g. "anthropic/claude-3.7-sonnet" vs "claude-3.7-sonnet")
+   * and variant tags (e.g. ":thinking").
    */
   getModelInfo(modelId: string): ModelMetadata | null {
-    return this.models.get(modelId.toLowerCase()) ?? null;
+    if (!modelId || typeof modelId !== "string") {
+      return null;
+    }
+
+    const key = modelId.toLowerCase().trim();
+    const direct = this.models.get(key);
+    if (direct) {
+      return direct;
+    }
+
+    // Try without provider prefix (e.g. "anthropic/claude-3.7-sonnet" -> "claude-3.7-sonnet")
+    if (key.includes("/")) {
+      const bare = key.split("/").pop();
+      if (bare && this.models.has(bare)) {
+        return this.models.get(bare)!;
+      }
+    } else {
+      // Or if key doesn't have provider prefix, find a registered model ending in "/<key>".
+      // Note: Assumes bare model names are reasonably unique across registered providers.
+      // If duplicates exist, the first registered match is returned.
+      for (const [regKey, meta] of this.models.entries()) {
+        if (regKey.endsWith(`/${key}`)) {
+          return meta;
+        }
+      }
+    }
+
+    // Try stripping tag/variant suffix (e.g. "anthropic/claude-3.7-sonnet:thinking" -> "anthropic/claude-3.7-sonnet")
+    if (key.includes(":")) {
+      const withoutTag = key.split(":")[0];
+      const match = this.getModelInfo(withoutTag);
+      if (match) {
+        return match;
+      }
+    }
+
+    return null;
   }
 
   /**
@@ -158,6 +197,18 @@ class ModelRegistry {
             "structured",
           );
         const reasoning = this.extractReasoning(model);
+        const supportsPromptCaching =
+          typeof model.supports_prompt_caching === "boolean"
+            ? model.supports_prompt_caching
+            : typeof model.supportsPromptCaching === "boolean"
+              ? model.supportsPromptCaching
+              : this.supportedParametersInclude(
+                    model,
+                    "cache_control",
+                    "prompt_caching",
+                  )
+                ? true
+                : undefined;
 
         // HuggingFace Router structure nests info inside `providers` array
         if (
@@ -179,6 +230,7 @@ class ModelRegistry {
           ...(supportsVideoInput !== undefined && { supportsVideoInput }),
           ...(reasoning && { reasoning }),
           ...(routesByRequestFeatures && { routesByRequestFeatures }),
+          ...(supportsPromptCaching !== undefined && { supportsPromptCaching }),
         });
       }