shadow-claw 1.23.4 → 1.24.1

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" }]);
+    });
+  });
 });

package/src/subsystems/providers/transformers-js-provider.test.ts

@@ -0,0 +1,279 @@
+import { jest } from "@jest/globals";
+
+describe("Transformers.js Provider", () => {
+  let mockWorkerInstance: any;
+  let mockGetConfig: jest.Mock<any>;
+  let mockExecuteTool: jest.Mock<any>;
+  let mockSetPostHandler: jest.Mock<any>;
+
+  beforeEach(() => {
+    jest.resetModules();
+
+    mockGetConfig = jest.fn().mockResolvedValue("auto" as never);
+    mockExecuteTool = jest
+      .fn()
+      .mockResolvedValue("tool success result" as never);
+    mockSetPostHandler = jest.fn();
+
+    mockWorkerInstance = {
+      postMessage: jest.fn((msg: any) => {
+        const { type, payload } = msg;
+        if (type === "load") {
+          setTimeout(() => {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "progress",
+                payload: {
+                  groupId: payload.groupId,
+                  status: "progress",
+                  loaded: 50,
+                  total: 100,
+                },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "progress",
+                payload: { groupId: payload.groupId, status: "done" },
+              },
+            });
+          }, 0);
+        } else if (type === "generate") {
+          setTimeout(() => {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "chunk",
+                payload: { groupId: payload.groupId, text: "Hello " },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "thinking-chunk",
+                payload: {
+                  groupId: payload.groupId,
+                  text: "thinking deeply...",
+                },
+              },
+            });
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: "Hello world response",
+                },
+              },
+            });
+          }, 0);
+        }
+      }),
+      onmessage: null,
+    };
+
+    (globalThis as any).Worker = jest
+      .fn()
+      .mockImplementation(() => mockWorkerInstance);
+
+    jest.unstable_mockModule("../../db/getConfig.js", () => ({
+      getConfig: mockGetConfig,
+    }));
+
+    jest.unstable_mockModule("../../worker/utils/executeTool.js", () => ({
+      executeTool: mockExecuteTool,
+    }));
+
+    jest.unstable_mockModule("../../worker/utils/post.js", () => ({
+      post: jest.fn(),
+      setPostHandler: mockSetPostHandler,
+    }));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("loads model, streams chunks and completes simple response", async () => {
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    const messages = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Hello" },
+          {
+            type: "attachment",
+            mediaType: "image",
+            fileName: "pic.png",
+            mimeType: "image/png",
+          },
+        ],
+      },
+    ];
+
+    await invokeWithTransformersJs(
+      {} as any,
+      "g1",
+      "You are a helpful assistant.",
+      messages,
+      2048,
+      emit,
+      undefined,
+      [],
+      "Xenova/Qwen1.5-0.5B-Chat",
+    );
+
+    expect(emitted.some((e) => e.type === "model-download-progress")).toBe(
+      true,
+    );
+    expect(emitted.some((e) => e.type === "streaming-start")).toBe(true);
+    expect(
+      emitted.some(
+        (e) => e.type === "streaming-chunk" && e.payload.text === "Hello ",
+      ),
+    ).toBe(true);
+    expect(emitted.some((e) => e.type === "streaming-done")).toBe(true);
+    expect(
+      emitted.some(
+        (e) =>
+          e.type === "response" && e.payload.text === "Hello world response",
+      ),
+    ).toBe(true);
+  });
+
+  it("handles XML <tool_call> output, executes tool, and iterates loop", async () => {
+    let callCount = 0;
+    mockWorkerInstance.postMessage = jest.fn((msg: any) => {
+      const { type, payload } = msg;
+      if (type === "load") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "progress",
+              payload: { groupId: payload.groupId, status: "done" },
+            },
+          });
+        }, 0);
+      } else if (type === "generate") {
+        callCount++;
+        setTimeout(() => {
+          if (callCount === 1) {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: '<tool_call>{"name": "web_search", "arguments": {"query": "weather"}}</tool_call>',
+                },
+              },
+            });
+          } else {
+            mockWorkerInstance.onmessage?.({
+              data: {
+                type: "done",
+                payload: {
+                  groupId: payload.groupId,
+                  text: '{"type":"response","response":"The weather is sunny."}',
+                },
+              },
+            });
+          }
+        }, 0);
+      }
+    });
+
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    const tools: any[] = [
+      {
+        name: "web_search",
+        description: "Search web",
+        input_schema: { type: "object", properties: {} },
+      },
+    ];
+
+    await invokeWithTransformersJs(
+      {} as any,
+      "g2",
+      "System prompt",
+      [{ role: "user", content: "What is the weather?" }],
+      1024,
+      emit,
+      undefined,
+      tools,
+      "model-id",
+    );
+
+    expect(mockExecuteTool).toHaveBeenCalledWith(
+      {},
+      "web_search",
+      { query: "weather" },
+      "g2",
+      expect.objectContaining({ allowedTools: tools }),
+    );
+    expect(
+      emitted.some(
+        (e) =>
+          e.type === "response" && e.payload.text === "The weather is sunny.",
+      ),
+    ).toBe(true);
+  });
+
+  it("handles worker error rejection during generation", async () => {
+    mockWorkerInstance.postMessage = jest.fn((msg: any) => {
+      const { type, payload } = msg;
+      if (type === "load") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "progress",
+              payload: { groupId: payload.groupId, status: "done" },
+            },
+          });
+        }, 0);
+      } else if (type === "generate") {
+        setTimeout(() => {
+          mockWorkerInstance.onmessage?.({
+            data: {
+              type: "error",
+              payload: { groupId: payload.groupId, error: "Out of memory" },
+            },
+          });
+        }, 0);
+      }
+    });
+
+    const { invokeWithTransformersJs } =
+      await import("./transformers-js-provider.js");
+
+    const emitted: any[] = [];
+    const emit = (msg: any) => {
+      emitted.push(msg);
+    };
+
+    await expect(
+      invokeWithTransformersJs(
+        {} as any,
+        "g3",
+        "System prompt",
+        [{ role: "user", content: "Hi" }],
+        512,
+        emit,
+        undefined,
+        [],
+        "model-id",
+      ),
+    ).rejects.toBe("Out of memory");
+  });
+});

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

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { createModelCacheFetch } from "./createModelCacheFetch.js";
 
 // Mock Blob and Response for Jest/jsdom
-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[]) {

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

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { downloadModelToCache } from "./downloadModelToCache.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[]) {

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

@@ -2,8 +2,8 @@ import { jest } from "@jest/globals";
 import { loadModelStream } from "./loadModelStream.js";
 
 // Mock Blob and Response for Jest/jsdom
-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[]) {

package/src/subsystems/skills/activateSkill.test.ts

@@ -0,0 +1,101 @@
+import { jest } from "@jest/globals";
+
+const mockLoadSkill = jest.fn() as any;
+
+jest.unstable_mockModule("./discoverSkills.js", () => ({
+  loadSkill: mockLoadSkill,
+}));
+
+const { executeActivateSkill } = await import("./activateSkill.js");
+
+describe("executeActivateSkill", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when skill name is missing or empty", async () => {
+    const res1 = await executeActivateSkill({} as any, {}, "group-1");
+    expect(res1).toBe("Error: activate_skill requires a skill name.");
+
+    const res2 = await executeActivateSkill(
+      {} as any,
+      { name: "   " },
+      "group-1",
+    );
+    expect(res2).toBe("Error: activate_skill requires a skill name.");
+  });
+
+  it("returns error when skill is not found", async () => {
+    mockLoadSkill.mockResolvedValue(null);
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "my-skill" },
+      "group-1",
+    );
+    expect(res).toBe(
+      'Error: skill "my-skill" was not found in this conversation workspace.',
+    );
+  });
+
+  it("returns error when skill disables model invocation", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "secret-skill",
+      disableModelInvocation: true,
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "secret-skill" },
+      "group-1",
+    );
+    expect(res).toBe(
+      'Error: skill "secret-skill" is not available for model-driven activation.',
+    );
+  });
+
+  it("formats skill content without resources", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "summarize",
+      body: "Instructions for summarizing texts.",
+      basePath: ".agents/skills/summarize",
+      resources: [],
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "summarize" },
+      "group-1",
+    );
+    expect(res).toContain('<skill_content name="summarize">');
+    expect(res).toContain("Instructions for summarizing texts.");
+    expect(res).toContain("Skill directory: .agents/skills/summarize");
+    expect(res).not.toContain("<skill_resources>");
+    expect(res).toContain("</skill_content>");
+  });
+
+  it("formats skill content with fallback body and resources", async () => {
+    mockLoadSkill.mockResolvedValue({
+      name: "data-analysis",
+      body: "",
+      basePath: ".agents/skills/data-analysis",
+      resources: [
+        ".agents/skills/data-analysis/template.py",
+        ".agents/skills/data-analysis/data.csv",
+      ],
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "data-analysis" },
+      "group-1",
+    );
+    expect(res).toContain("(This skill has no instructions.)");
+    expect(res).toContain("<skill_resources>");
+    expect(res).toContain(
+      "<file>.agents/skills/data-analysis/template.py</file>",
+    );
+    expect(res).toContain("<file>.agents/skills/data-analysis/data.csv</file>");
+    expect(res).toContain("</skill_resources>");
+  });
+});