shadow-claw 1.23.3 → 1.24.0

package/src/subsystems/providers/litert-lm-provider.test.ts

@@ -1,15 +1,41 @@
 import { jest } from "@jest/globals";
 
-import {
+const mockCreateConversation = jest.fn<any>().mockResolvedValue({
+  sendMessage: jest.fn<any>().mockResolvedValue(undefined),
+  sendMessageStreaming: jest.fn<any>().mockImplementation(async function* () {
+    yield {
+      content: [
+        {
+          text: JSON.stringify({
+            type: "response",
+            response: "Hello from LiteRT!",
+          }),
+        },
+      ],
+    };
+  }),
+});
+
+jest.unstable_mockModule("@litert-lm/core", () => ({
+  Engine: {
+    create: jest.fn<any>().mockResolvedValue({
+      createConversation: mockCreateConversation,
+      delete: jest.fn<any>().mockResolvedValue(undefined),
+    }),
+  },
+}));
+
+const {
   isLiteRtLmSupported,
   loadLiteRtModelStream,
   parseModelSpecificToolCall,
   parseLiteRtStructured,
-} from "./litert-lm-provider.js";
+  invokeWithLiteRtLm,
+} = await import("./litert-lm-provider.js");
 
 // jsdom does not implement Blob fully, so we mock it for the tests
-if (typeof global !== "undefined") {
-  (global as any).Blob = class MockBlob {
+if (typeof globalThis !== "undefined") {
+  (globalThis as any).Blob = class MockBlob {
     private parts: any[];
     public size: number;
     constructor(parts: any[]) {
@@ -64,8 +90,6 @@ if (typeof global !== "undefined") {
   };
 }
 
-// TextEncoder / TextDecoder are not available in every Jest environment;
-// fall back to Node's Buffer.
 function encodeText(s: string): Uint8Array {
   if (typeof TextEncoder !== "undefined") {
     return new TextEncoder().encode(s);
@@ -82,10 +106,6 @@ function decodeBytes(b: Uint8Array): string {
   return Buffer.from(b).toString("utf8");
 }
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 function makeBodyStream(data: Uint8Array): ReadableStream<Uint8Array> {
   return new ReadableStream<Uint8Array>({
     start(controller) {
@@ -114,14 +134,9 @@ function makeFetchResponse(
   };
 }
 
-// ---------------------------------------------------------------------------
-// isLiteRtLmSupported
-// ---------------------------------------------------------------------------
-
 describe("LiteRT-LM Provider", () => {
   describe("isLiteRtLmSupported", () => {
     let originalNavigator: any;
-
     let originalWebAssembly: any;
 
     beforeEach(() => {
@@ -204,13 +219,8 @@ describe("LiteRT-LM Provider", () => {
     });
   });
 
-  // ---------------------------------------------------------------------------
-  // loadLiteRtModelStream — full integration of cache + network
-  // ---------------------------------------------------------------------------
-
   describe("loadLiteRtModelStream", () => {
     let mockFetch: jest.Mock<any>;
-    // cache storage: key -> { body: Uint8Array | null, headers: Headers }
     const cacheStore = new Map<
       string,
       { body: Uint8Array | null; headers: Headers }
@@ -222,9 +232,6 @@ describe("LiteRT-LM Provider", () => {
     }
 
     function makeCacheApi() {
-      // A single cache object backed by `cacheStore`; shared across all
-      // `caches.open()` calls so that writes from one call site are visible
-      // to reads from another.
       const cacheObject = {
         put: jest.fn<any>(async (key: string, response: any) => {
           const headers = response.init
@@ -310,11 +317,8 @@ describe("LiteRT-LM Provider", () => {
       }
     });
 
-    // -- Complete meta hit (after a previous successful download) ---------------
-
     it("returns stream from cached chunks when meta is complete (no network)", async () => {
       const chunk0 = new Uint8Array([1, 2, 3, 4]);
-      // Populate the cache as if a previous download completed
       cacheStore.set("http://model?__sc_meta=1", {
         body: encodeText(
           JSON.stringify({
@@ -335,11 +339,9 @@ describe("LiteRT-LM Provider", () => {
       const onProgress = jest.fn<any>();
       const stream = await loadLiteRtModelStream("http://model", onProgress);
 
-      // Should read from cache — no network calls
       expect(mockFetch).not.toHaveBeenCalled();
       expect(onProgress).toHaveBeenCalledWith(4, 4, true);
 
-      // Stream should yield the cached bytes
       const reader = stream.getReader();
       const collected: number[] = [];
       while (true) {
@@ -354,10 +356,7 @@ describe("LiteRT-LM Provider", () => {
       expect(collected).toEqual([1, 2, 3, 4]);
     });
 
-    // -- Fresh download (no meta) -----------------------------------------------
-
     it("downloads model and writes chunks + meta to CacheStorage", async () => {
-      // 3 bytes fits in a single chunk (way below 16MB flush threshold)
       const modelData = new Uint8Array([10, 20, 30]);
       mockFetch.mockResolvedValueOnce(makeFetchResponse(200, modelData) as any);
 
@@ -372,25 +371,19 @@ describe("LiteRT-LM Provider", () => {
         if (done) break;
       }
 
-      // At least one chunk entry should have been written
       const chunkEntry = cacheStore.get("http://model?__sc_chunk=0");
       expect(chunkEntry).toBeDefined();
 
-      // Meta should exist and be marked complete
       const metaRaw = cacheStore.get("http://model?__sc_meta=1");
       expect(metaRaw).toBeDefined();
       const meta = JSON.parse(decodeBytes(metaRaw!.body!));
       expect(meta.complete).toBe(true);
       expect(meta.received).toBe(3);
 
-      // Progress callback should have fired
       expect(onProgress).toHaveBeenCalled();
     });
 
-    // -- Resume after crash -----------------------------------------------------
-
     it("resumes download from partial meta offset after crash", async () => {
-      // Partial state: 4 bytes already cached in chunk 0, 4 more bytes remain
       const partialBytes = new Uint8Array([1, 2, 3, 4]);
       cacheStore.set("http://model?__sc_meta=1", {
         body: encodeText(
@@ -409,7 +402,6 @@ describe("LiteRT-LM Provider", () => {
         headers: new Headers({ "content-length": "4" }),
       });
 
-      // Server returns the remaining 4 bytes via 206
       const remaining = new Uint8Array([5, 6, 7, 8]);
       mockFetch.mockResolvedValueOnce({
         status: 206,
@@ -425,7 +417,6 @@ describe("LiteRT-LM Provider", () => {
       const onProgress = jest.fn<any>();
       const stream = await loadLiteRtModelStream("http://model", onProgress);
 
-      // Must have issued a Range request
       expect(mockFetch).toHaveBeenCalledTimes(1);
       const [, fetchInit] = mockFetch.mock.calls[0] as any[];
       expect(fetchInit.headers["Range"]).toBe("bytes=4-");
@@ -436,17 +427,13 @@ describe("LiteRT-LM Provider", () => {
         if (done) break;
       }
 
-      // Meta should now be complete
       const metaRaw = cacheStore.get("http://model?__sc_meta=1");
       const meta = JSON.parse(decodeBytes(metaRaw!.body!));
       expect(meta.complete).toBe(true);
       expect(meta.received).toBe(8);
     });
 
-    // -- Resume when server ignores Range (returns 200) -------------------------
-
     it("restarts from scratch when server ignores Range request (200 instead of 206)", async () => {
-      // Partial state exists in cache
       cacheStore.set("http://model?__sc_meta=1", {
         body: encodeText(
           JSON.stringify({
@@ -464,7 +451,6 @@ describe("LiteRT-LM Provider", () => {
         headers: new Headers({ "content-length": "4" }),
       });
 
-      // Server returns 200 (ignores Range) with full data
       const fullData = new Uint8Array([10, 20, 30, 40, 50, 60, 70, 80]);
       mockFetch.mockResolvedValueOnce(makeFetchResponse(200, fullData) as any);
 
@@ -479,15 +465,12 @@ describe("LiteRT-LM Provider", () => {
         if (done) break;
       }
 
-      // Final meta should reflect the full 8 bytes, not 4+4
       const metaRaw = cacheStore.get("http://model?__sc_meta=1");
       const meta = JSON.parse(decodeBytes(metaRaw!.body!));
       expect(meta.complete).toBe(true);
       expect(meta.received).toBe(8);
     });
 
-    // -- Retry on 500 -----------------------------------------------------------
-
     it("retries on 500 error", async () => {
       const modelData = new Uint8Array([1, 2, 3]);
       mockFetch
@@ -511,8 +494,6 @@ describe("LiteRT-LM Provider", () => {
       expect(meta.complete).toBe(true);
     });
 
-    // -- Abort ------------------------------------------------------------------
-
     it("aborts download if signal is aborted", async () => {
       mockFetch.mockRejectedValue(
         new DOMException("Aborted", "AbortError") as any,
@@ -530,6 +511,188 @@ describe("LiteRT-LM Provider", () => {
       ).rejects.toThrow("Aborted");
     });
   });
+
+  describe("invokeWithLiteRtLm", () => {
+    it("emits error when LiteRT is unsupported in current environment", async () => {
+      const emit: any = jest.fn();
+      await invokeWithLiteRtLm(
+        {} as any,
+        "g1",
+        "system",
+        [{ role: "user", content: "hello" }],
+        1000,
+        emit,
+        undefined,
+        "litert-community/gemma-4-E2B-it-litert-lm",
+      );
+
+      expect(emit).toHaveBeenCalledWith({
+        type: "response",
+        payload: {
+          groupId: "g1",
+          text: expect.stringContaining(
+            "LiteRT-LM requires WebGPU and WebAssembly.Suspending",
+          ),
+        },
+      });
+    });
+
+    it("handles model failure when supported but initialization fails", async () => {
+      Object.defineProperty(global, "navigator", {
+        value: { gpu: {} },
+        configurable: true,
+        writable: true,
+      });
+      Object.defineProperty(global, "WebAssembly", {
+        value: { Suspending: class {} },
+        configurable: true,
+        writable: true,
+      });
+
+      const emitted: any[] = [];
+      const emit = jest.fn((msg: any) => {
+        emitted.push(msg);
+      });
+
+      // Pass an unsupported model ID
+      await invokeWithLiteRtLm(
+        {} as any,
+        "g1",
+        "system",
+        [{ role: "user", content: "hello" }],
+        1000,
+        emit,
+        undefined,
+        "unsupported-model-id",
+      );
+
+      expect(
+        emitted.some(
+          (m) =>
+            m.type === "model-download-progress" &&
+            m.payload.status === "error",
+        ),
+      ).toBe(true);
+      expect(
+        emitted.some(
+          (m) =>
+            m.type === "response" &&
+            m.payload.text.includes("LiteRT-LM failed to initialize"),
+        ),
+      ).toBe(true);
+    });
+
+    it("handles aborted signal gracefully during model download", async () => {
+      Object.defineProperty(global, "navigator", {
+        value: { gpu: {} },
+        configurable: true,
+        writable: true,
+      });
+      Object.defineProperty(global, "WebAssembly", {
+        value: { Suspending: class {} },
+        configurable: true,
+        writable: true,
+      });
+
+      const abortController = new AbortController();
+      abortController.abort();
+
+      const emitted: any[] = [];
+      const emit = jest.fn((msg: any) => {
+        emitted.push(msg);
+      });
+
+      await invokeWithLiteRtLm(
+        {} as any,
+        "g1",
+        "system",
+        [{ role: "user", content: "hello" }],
+        1000,
+        emit,
+        abortController.signal,
+        "litert-community/gemma-4-E2B-it-litert-lm",
+      );
+
+      expect(
+        emitted.some(
+          (m) =>
+            m.type === "model-download-progress" &&
+            m.payload.status === "error",
+        ),
+      ).toBe(true);
+    });
+
+    it("emits warning response when LiteRT-LM is not supported in browser", async () => {
+      Object.defineProperty(global, "navigator", {
+        value: {},
+        configurable: true,
+        writable: true,
+      });
+
+      const emitted: any[] = [];
+      const emit = jest.fn((msg: any) => {
+        emitted.push(msg);
+      });
+
+      await invokeWithLiteRtLm(
+        {} as any,
+        "g1",
+        "system",
+        [{ role: "user", content: "hello" }],
+        1000,
+        emit,
+        undefined,
+        "litert-community/gemma-4-E2B-it-litert-lm",
+      );
+
+      expect(
+        emitted.some(
+          (m) =>
+            m.type === "response" &&
+            m.payload.text.includes("LiteRT-LM requires WebGPU"),
+        ),
+      ).toBe(true);
+    });
+
+    it("successfully creates conversation and streams response when supported", async () => {
+      Object.defineProperty(global, "navigator", {
+        value: { gpu: {} },
+        configurable: true,
+        writable: true,
+      });
+      Object.defineProperty(global, "WebAssembly", {
+        value: { Suspending: class {} },
+        configurable: true,
+        writable: true,
+      });
+
+      global.fetch = jest.fn<any>().mockResolvedValue({
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-length": "100" }),
+        body: makeBodyStream(new Uint8Array(100)),
+      });
+
+      const emitted: any[] = [];
+      const emit = jest.fn((msg: any) => {
+        emitted.push(msg);
+      });
+
+      await invokeWithLiteRtLm(
+        {} as any,
+        "g1",
+        "system",
+        [{ role: "user", content: "hello" }],
+        1000,
+        emit,
+        undefined,
+        "litert-community/gemma-4-E2B-it-litert-lm",
+      );
+
+      expect(emitted.some((m) => m.type === "streaming-chunk")).toBe(true);
+      expect(emitted.some((m) => m.type === "streaming-done")).toBe(true);
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -547,7 +710,6 @@ describe("parseModelSpecificToolCall", () => {
   });
 
   it('parses a Gemma 4 native tool call with encoded quote tokens <|"|">', () => {
-    // Standard inline output
     const rawInline =
       '<|tool_call>call:web_search{queries:[<|"|>Blueberries latest details<|"|>]}<tool_call|>';
     const resultInline = parseModelSpecificToolCall(rawInline);
@@ -555,7 +717,6 @@ describe("parseModelSpecificToolCall", () => {
     expect(resultInline!.name).toBe("web_search");
     expect(resultInline!.input.queries[0]).toBe("Blueberries latest details");
 
-    // Real-world variant: The model frequently injects a newline before the closing tag
     const rawWithNewline =
       '<|tool_call>call:web_search{queries:[<|"|>Blueberries latest details<|"|>]}\n<tool_call|>';
     const resultWithNewline = parseModelSpecificToolCall(rawWithNewline);

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

@@ -1,3 +1,4 @@
+import { jest } from "@jest/globals";
 import { modelRegistry } from "./model-registry.js";
 
 describe("ModelRegistry", () => {
@@ -259,4 +260,118 @@ describe("ModelRegistry", () => {
       (globalThis as any).fetch = originalFetch;
     }
   });
+
+  it("should clear registered models", () => {
+    modelRegistry.registerModelInfo("model-to-clear", {
+      contextWindow: 4096,
+      maxOutput: 1024,
+    });
+    expect(modelRegistry.getModelInfo("model-to-clear")).not.toBeNull();
+    modelRegistry.clear();
+    expect(modelRegistry.getModelInfo("model-to-clear")).toBeNull();
+  });
+
+  it("should do nothing when provider has no modelsUrl", async () => {
+    await expect(
+      modelRegistry.fetchModelInfo({ id: "no-url" } as any),
+    ).resolves.toBeUndefined();
+  });
+
+  it("should handle apiKeyHeader, apiKeyHeaderFormat, headers, and extraHeaders", async () => {
+    const originalFetch = (globalThis as any).fetch;
+    let sentHeaders: any = null;
+
+    (globalThis as any).fetch = async (_url: string, opts: any) => {
+      sentHeaders = opts.headers;
+      return {
+        ok: true,
+        json: async () => ({
+          data: [{ id: "test-auth-model", context_length: 16000 }],
+        }),
+      };
+    };
+
+    try {
+      await modelRegistry.fetchModelInfo(
+        {
+          id: "hf-provider",
+          modelsUrl: "https://api.hf.co/models",
+          headers: { "X-Custom": "CustomVal" },
+          apiKeyHeader: "Authorization",
+          apiKeyHeaderFormat: "Bearer {key}",
+        } as any,
+        "secret-key",
+        { "X-Extra": "ExtraVal" },
+      );
+
+      expect(sentHeaders.get("Authorization")).toBe("Bearer secret-key");
+      expect(sentHeaders.get("X-Custom")).toBe("CustomVal");
+      expect(sentHeaders.get("X-Extra")).toBe("ExtraVal");
+      expect(modelRegistry.getModelInfo("test-auth-model")).toEqual({
+        contextWindow: 16000,
+        maxOutput: null,
+      });
+    } finally {
+      (globalThis as any).fetch = originalFetch;
+    }
+  });
+
+  it("should handle error when fetch response is not ok", async () => {
+    const originalFetch = (globalThis as any).fetch;
+    const consoleSpy = jest
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    (globalThis as any).fetch = async () => ({
+      ok: false,
+      status: 403,
+      statusText: "Forbidden",
+    });
+
+    try {
+      await modelRegistry.fetchModelInfo({
+        id: "fail-provider",
+        modelsUrl: "https://fail.com/models",
+      } as any);
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "[ModelRegistry] Error fetching models for fail-provider:",
+        expect.any(Error),
+      );
+      expect(modelRegistry.loading).toBe(false);
+    } finally {
+      (globalThis as any).fetch = originalFetch;
+      consoleSpy.mockRestore();
+    }
+  });
+
+  it("should parse text->image architecture modality string", async () => {
+    const originalFetch = (globalThis as any).fetch;
+    (globalThis as any).fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        data: [
+          {
+            id: "vision-model",
+            context_length: 32000,
+            architecture: {
+              modality: "text+image->text",
+            },
+          },
+        ],
+      }),
+    });
+
+    try {
+      await modelRegistry.fetchModelInfo({
+        id: "vision-provider",
+        modelsUrl: "https://vision.com/models",
+      } as any);
+
+      expect(
+        modelRegistry.getModelInfo("vision-model")?.supportsImageInput,
+      ).toBe(true);
+    } finally {
+      (globalThis as any).fetch = originalFetch;
+    }
+  });
 });

package/src/subsystems/providers/providers.test.ts

@@ -5,6 +5,7 @@ import {
   formatRequest,
   getAdapter,
   getContextLimit,
+  normalizeMeshLlmResult,
   parseResponse,
 } from "./providers.js";
 
@@ -64,10 +65,47 @@ describe("providers.js", () => {
     it("should return correct limit for Claude 3 models", () => {
       expect(getContextLimit("claude-3-opus")).toBe(200000);
       expect(getContextLimit("claude-3-haiku")).toBe(200000);
+      expect(getContextLimit("claude-opus-4")).toBe(1000000);
     });
 
-    it("should return correct limit for GPT-4", () => {
+    it("should return correct limit for GPT-4 and reasoning models", () => {
       expect(getContextLimit("gpt-4")).toBe(8192);
+      expect(getContextLimit("o1-preview")).toBe(200000);
+      expect(getContextLimit("o3-mini")).toBe(200000);
+    });
+
+    it("should return correct limit for Gemini models", () => {
+      expect(getContextLimit("gemini-1.5-pro")).toBe(2097152);
+      expect(getContextLimit("gemini-2.0-flash")).toBe(1048576);
+      expect(getContextLimit("gemini-1.0-pro")).toBe(32768);
+      expect(getContextLimit("gemini-nano")).toBe(4096);
+    });
+
+    it("should return correct limit for Llama, Gemma, and Mistral models", () => {
+      expect(getContextLimit("llama-3.1-70b")).toBe(128000);
+      expect(getContextLimit("llama-3-8b")).toBe(8192);
+      expect(getContextLimit("gemma-4-12b")).toBe(256000);
+      expect(getContextLimit("gemma-4-e2b")).toBe(128000);
+      expect(getContextLimit("gemma-3-12b")).toBe(128000);
+      expect(getContextLimit("gemma-3-1b")).toBe(32000);
+      expect(getContextLimit("gemma-2-9b")).toBe(8192);
+      expect(getContextLimit("mistral-large")).toBe(128000);
+      expect(getContextLimit("mistral-small")).toBe(32000);
+    });
+
+    it("should return correct limit for Bedrock, Phi, Qwen, and Mesh models", () => {
+      expect(getContextLimit("amazon.nova-micro")).toBe(128000);
+      expect(getContextLimit("amazon.nova-pro")).toBe(300000);
+      expect(getContextLimit("amazon.titan-text")).toBe(8192);
+      expect(getContextLimit("cohere.command-r")).toBe(128000);
+      expect(getContextLimit("phi-4-mini")).toBe(128000);
+      expect(getContextLimit("phi-4")).toBe(16384);
+      expect(getContextLimit("phi-3.5")).toBe(128000);
+      expect(getContextLimit("phi-3")).toBe(4096);
+      expect(getContextLimit("qwen3.5-9b")).toBe(262144);
+      expect(getContextLimit("qwen3-0.6b")).toBe(40960);
+      expect(getContextLimit("qwen3-8b")).toBe(128000);
+      expect(getContextLimit("mesh")).toBe(242144);
     });
 
     it("should return default limit for unknown models", () => {
@@ -1157,4 +1195,59 @@ describe("providers.js", () => {
       expect(headers["X-Token"]).toBe("Token abc123");
     });
   });
+
+  describe("normalizeMeshLlmResult & MeshLlmAdapter", () => {
+    it("returns unchanged for empty or invalid results", () => {
+      expect(normalizeMeshLlmResult(null)).toBeNull();
+      expect(normalizeMeshLlmResult(undefined)).toBeUndefined();
+      expect(normalizeMeshLlmResult({ content: "not-an-array" })).toEqual({
+        content: "not-an-array",
+      });
+    });
+
+    it("normalizes mesh-llm result stripping thought tags and parsing tool calls", () => {
+      const result = {
+        content: [
+          {
+            type: "text",
+            text: '<|channel>Thinking deeply...<channel|>Hello user!<|tool_call>call:search{"q":"test"}<tool_call|>',
+          },
+          { type: "image", data: "123" },
+        ],
+        stop_reason: "end_turn",
+      };
+
+      const normalized = normalizeMeshLlmResult(result);
+      expect(normalized.content).toEqual([
+        { type: "text", text: "Hello user!" },
+        expect.objectContaining({
+          type: "tool_use",
+          name: "search",
+          input: { q: "test" },
+        }),
+        { type: "image", data: "123" },
+      ]);
+      expect(normalized.stop_reason).toBe("tool_use");
+    });
+
+    it("returns MeshLlmAdapter for mesh-llm provider format", () => {
+      const provider: any = { format: "mesh-llm" };
+      const adapter = getAdapter(provider);
+      expect(adapter.constructor.name).toBe("MeshLlmAdapter");
+
+      const response = {
+        choices: [
+          {
+            message: {
+              content: "<|channel>reasoning<channel|>Result text",
+            },
+            finish_reason: "stop",
+          },
+        ],
+      };
+
+      const parsed = parseResponse(provider, response);
+      expect(parsed.content).toEqual([{ type: "text", text: "Result text" }]);
+    });
+  });
 });