shadow-claw 1.32.0 → 1.33.0

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 }),
         });
       }