shadow-claw 1.52.0 → 1.52.1

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

@@ -2,6 +2,7 @@ import {
   parseLocalModelToolCall,
   parseLocalModelToolCalls,
   convertToolSchemasToOpenAI,
+  createToolCallStreamFilter,
 } from "./parseLocalModelToolCall.js";
 
 describe("parseLocalModelToolCall", () => {
@@ -342,4 +343,60 @@ describe("convertToolSchemasToOpenAI", () => {
     expect(typeof params.properties.dataModel.properties).toBe("object");
     expect(params.properties.value.type).toBe("string");
   });
+
+  describe("createToolCallStreamFilter", () => {
+    it("handles undefined onToken callback gracefully", () => {
+      const filter = createToolCallStreamFilter();
+      expect(() => {
+        filter.onToken("token");
+        filter.finalize(false);
+      }).not.toThrow();
+    });
+
+    it("suppresses tokens when a tool call prefix is detected", () => {
+      const emitted: string[] = [];
+      const filter = createToolCallStreamFilter((t) => emitted.push(t));
+
+      filter.onToken("call");
+      filter.onToken(":fetch_url");
+      filter.onToken('{"url":"https://example.com"}');
+      filter.finalize(true);
+
+      expect(emitted).toEqual([]);
+    });
+
+    it("emits normal text after buffering non-prefix token", () => {
+      const emitted: string[] = [];
+      const filter = createToolCallStreamFilter((t) => emitted.push(t));
+
+      filter.onToken("The ");
+      filter.onToken("weather ");
+      filter.onToken("is sunny.");
+      filter.finalize(false);
+
+      expect(emitted.join("")).toBe("The weather is sunny.");
+    });
+
+    it("flushes remaining buffered text on finalize when not a tool call", () => {
+      const emitted: string[] = [];
+      const filter = createToolCallStreamFilter((t) => emitted.push(t));
+
+      filter.onToken("c");
+      filter.onToken("at");
+      filter.finalize(false);
+
+      expect(emitted.join("")).toBe("cat");
+    });
+
+    it("suppresses <|tool_call and other XML-style prefixes", () => {
+      const emitted: string[] = [];
+      const filter = createToolCallStreamFilter((t) => emitted.push(t));
+
+      filter.onToken("<|tool_call");
+      filter.onToken(">call:bash{}");
+      filter.finalize(true);
+
+      expect(emitted).toEqual([]);
+    });
+  });
 });

package/src/worker/tools/builtin-ai/builtin-ai.test.ts

@@ -11,6 +11,7 @@ let executeRewriteText: any;
 let executeProofreadText: any;
 let executeDetectLanguage: any;
 let executeTranslateText: any;
+let executeEmbedText: any;
 
 describe("builtin-ai worker tools", () => {
   beforeAll(async () => {
@@ -21,6 +22,7 @@ describe("builtin-ai worker tools", () => {
     executeProofreadText = mod.executeProofreadText;
     executeDetectLanguage = mod.executeDetectLanguage;
     executeTranslateText = mod.executeTranslateText;
+    executeEmbedText = mod.executeEmbedText;
   });
 
   beforeEach(() => {
@@ -45,6 +47,19 @@ describe("builtin-ai worker tools", () => {
     });
   };
 
+  const mockMainThreadReject = (err: any) => {
+    mockPost.mockImplementationOnce((msg: any) => {
+      if (msg.type === "request-native-ai-task") {
+        setTimeout(() => {
+          const resolvers = (globalThis as any).pendingNativeAiResolvers;
+          if (resolvers && resolvers[msg.payload.id]) {
+            resolvers[msg.payload.id].reject(err);
+          }
+        }, 0);
+      }
+    });
+  };
+
   describe("executeSummarizeText", () => {
     it("returns error message when text is missing", async () => {
       const res = await executeSummarizeText({});
@@ -264,5 +279,78 @@ describe("builtin-ai worker tools", () => {
         }),
       );
     });
+
+    it("handles error during translate", async () => {
+      mockMainThreadReject(new Error("Translation failed"));
+      const res = await executeTranslateText({
+        text: "Hello",
+        sourceLanguage: "en",
+        targetLanguage: "fr",
+      });
+      expect(res).toContain("Error translating text: Translation failed");
+    });
+  });
+
+  describe("executeEmbedText", () => {
+    it("returns error message when text is missing", async () => {
+      const res1 = await executeEmbedText({});
+      expect(res1).toBe("Error: text is required for embed_text");
+
+      const res2 = await executeEmbedText({ text: [] });
+      expect(res2).toBe("Error: text is required for embed_text");
+    });
+
+    it("posts request to main thread and returns output", async () => {
+      mockMainThreadResponse([0.1, 0.2, 0.3]);
+      const res = await executeEmbedText({
+        text: "Embed this",
+        taskType: "query",
+      });
+      expect(JSON.parse(res)).toEqual([0.1, 0.2, 0.3]);
+      expect(mockPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "request-native-ai-task",
+          payload: expect.objectContaining({
+            taskType: "semantic-embedder",
+            input: expect.objectContaining({
+              text: "Embed this",
+              taskType: "query",
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("handles error during embedding", async () => {
+      mockMainThreadReject(new Error("Model unavailable"));
+      const res = await executeEmbedText({ text: "Embed this" });
+      expect(res).toContain("Error generating embeddings: Model unavailable");
+    });
+  });
+
+  describe("error handling for remaining tools", () => {
+    it("handles write text rejection", async () => {
+      mockMainThreadReject(new Error("Write error"));
+      const res = await executeWriteText({ prompt: "Write something" });
+      expect(res).toContain("Error writing text: Write error");
+    });
+
+    it("handles rewrite text rejection", async () => {
+      mockMainThreadReject(new Error("Rewrite error"));
+      const res = await executeRewriteText({ text: "Rewrite something" });
+      expect(res).toContain("Error rewriting text: Rewrite error");
+    });
+
+    it("handles proofread rejection", async () => {
+      mockMainThreadReject(new Error("Proofread error"));
+      const res = await executeProofreadText({ text: "Proofread something" });
+      expect(res).toContain("Error proofreading text: Proofread error");
+    });
+
+    it("handles detect language rejection", async () => {
+      mockMainThreadReject(new Error("Detect error"));
+      const res = await executeDetectLanguage({ text: "Detect something" });
+      expect(res).toContain("Error detecting language: Detect error");
+    });
   });
 });

package/src/worker/tools/email/email.test.ts

@@ -463,6 +463,364 @@ describe("worker/tools/email", () => {
     expect(deleteMsgResult).toContain('"deleted": [');
   });
 
+  it("send_message handles missing SMTP host, attachment read failure, and oauth 401 retry", async () => {
+    // Missing SMTP host
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-no-smtp",
+      pluginId: "imap",
+      enabled: true,
+      config: {},
+      credentialRef: {
+        authType: "basic_userpass",
+        encryptedSecret: "enc:pw",
+        username: "user@example.com",
+      },
+    });
+
+    const noSmtpResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "send_message",
+        connection_id: "conn-no-smtp",
+        to: ["a@b.com"],
+        subject: "Test",
+        body: "Hello",
+      },
+      "group-1",
+    );
+    expect(noSmtpResult).toContain("missing SMTP host");
+
+    // Attachment read error
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-att-fail",
+      pluginId: "imap",
+      enabled: true,
+      config: { smtpHost: "smtp.example.com" },
+      credentialRef: {
+        authType: "basic_userpass",
+        encryptedSecret: "enc:pw",
+        username: "user@example.com",
+      },
+    });
+    mockReadGroupFileBytes.mockRejectedValueOnce(new Error("File not found"));
+
+    const attFailResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "send_message",
+        connection_id: "conn-att-fail",
+        to: ["a@b.com"],
+        subject: "Test",
+        body: "Hello",
+        attachments: ["missing.txt"],
+      },
+      "group-1",
+    );
+    expect(attFailResult).toContain(
+      "Attachment file not found or unreadable: missing.txt",
+    );
+
+    // OAuth 401 retry
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-oauth-send",
+      pluginId: "imap",
+      enabled: true,
+      config: { smtpHost: "smtp.example.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acct-send",
+        providerId: "google",
+        username: "user@example.com",
+      },
+    });
+    mockResolveServiceCredentials
+      .mockResolvedValueOnce({ token: "token-s1" })
+      .mockResolvedValueOnce({ token: "token-s2" });
+
+    (global.fetch as any)
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        json: async () => ({ error: "unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: async () => ({ sent: true, refreshed: true }),
+      });
+
+    const retrySendResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "send_message",
+        connection_id: "conn-oauth-send",
+        to: ["target@example.com"],
+        subject: "Test",
+        body: "Hello",
+      },
+      "group-1",
+    );
+    expect(retrySendResult).toContain('"refreshed": true');
+  });
+
+  it("download_attachments handles missing IMAP host, oauth 401 retry, and failed response", async () => {
+    // Missing IMAP host
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-no-imap",
+      pluginId: "imap",
+      enabled: true,
+      config: {},
+      credentialRef: {
+        authType: "basic_userpass",
+        encryptedSecret: "enc:pw",
+        username: "user@example.com",
+      },
+    });
+
+    const noImapResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "download_attachments",
+        connection_id: "conn-no-imap",
+        message_uid: 10,
+      },
+      "group-1",
+    );
+    expect(noImapResult).toContain("missing IMAP host");
+
+    // OAuth 401 retry & download failure response
+    mockGetEmailConnection.mockResolvedValue({
+      id: "conn-oauth-dl",
+      pluginId: "imap",
+      enabled: true,
+      config: { host: "imap.example.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acct-dl",
+        providerId: "google",
+        username: "user@example.com",
+      },
+    });
+    mockResolveServiceCredentials
+      .mockResolvedValueOnce({ token: "token-dl1" })
+      .mockResolvedValueOnce({ token: "token-dl2" });
+
+    (global.fetch as any)
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        json: async () => ({ error: "unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: "Server Error",
+        json: async () => ({ error: "disk error" }),
+      });
+
+    const failDlResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "download_attachments",
+        connection_id: "conn-oauth-dl",
+        message_uid: 10,
+      },
+      "group-1",
+    );
+    expect(failDlResult).toContain(
+      "IMAP attachment download failed (500): disk error",
+    );
+  });
+
+  it("mark_as_read handles oauth 401 retry and failed response", async () => {
+    mockGetEmailConnection.mockResolvedValue({
+      id: "conn-oauth-mark",
+      pluginId: "imap",
+      enabled: true,
+      config: { host: "imap.example.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acct-mark",
+        providerId: "google",
+        username: "user@example.com",
+      },
+    });
+    mockResolveServiceCredentials
+      .mockResolvedValueOnce({ token: "token-m1" })
+      .mockResolvedValueOnce({ token: "token-m2" });
+
+    (global.fetch as any)
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        json: async () => ({ error: "unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: "Bad Request",
+        json: async () => ({ error: "invalid uids" }),
+      });
+
+    const failMarkResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "mark_as_read",
+        connection_id: "conn-oauth-mark",
+        message_uids: [999],
+      },
+      "group-1",
+    );
+    expect(failMarkResult).toContain("IMAP modify failed (400): invalid uids");
+
+    // Plugin doesn't support messages.read
+    mockGetEmailPluginManifest.mockReturnValueOnce({
+      id: "imap",
+      name: "IMAP",
+      actions: ["messages.send"],
+    });
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-unsupported",
+      pluginId: "imap",
+      enabled: true,
+      config: { host: "imap.example.com" },
+      credentialRef: {
+        authType: "basic_userpass",
+        username: "u",
+        encryptedSecret: "enc:pw",
+      },
+    });
+    const unsuppResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "mark_as_read",
+        connection_id: "conn-unsupported",
+        message_uids: [1],
+      },
+      "group-1",
+    );
+    expect(unsuppResult).toContain("does not support inbox message updates");
+
+    // Missing IMAP host in mark_as_read
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-no-host",
+      pluginId: "imap",
+      enabled: true,
+      config: {},
+      credentialRef: {
+        authType: "basic_userpass",
+        username: "u",
+        encryptedSecret: "enc:pw",
+      },
+    });
+    const noHostResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "mark_as_read",
+        connection_id: "conn-no-host",
+        message_uids: [1],
+      },
+      "group-1",
+    );
+    expect(noHostResult).toContain("missing IMAP host");
+
+    // OAuth 401 retry where refreshedAuth returns an error string
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-oauth-fail-refresh",
+      pluginId: "imap",
+      enabled: true,
+      config: { host: "imap.example.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acc-refresh",
+        username: "u",
+      },
+    });
+    mockResolveServiceCredentials
+      .mockResolvedValueOnce({ token: "initial-token" })
+      .mockResolvedValueOnce(null); // Second resolve fails
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      statusText: "Unauthorized",
+      json: async () => ({}),
+    });
+    const refreshFailResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "mark_as_read",
+        connection_id: "conn-oauth-fail-refresh",
+        message_uids: [1],
+      },
+      "group-1",
+    );
+    expect(refreshFailResult).toContain("OAuth account reconnect required");
+  });
+
+  it("download_attachments validates missing uid, disabled connection, and not found", async () => {
+    // Missing uid
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-uid",
+      pluginId: "imap",
+      enabled: true,
+      config: {},
+    });
+    const noUid = await executeManageEmailTool(
+      {} as any,
+      { action: "download_attachments", connection_id: "conn-uid" },
+      "group-1",
+    );
+    expect(noUid).toContain("requires message_uid");
+
+    // Disabled connection
+    mockGetEmailConnection.mockResolvedValueOnce({
+      id: "conn-disabled",
+      pluginId: "imap",
+      enabled: false,
+      config: {},
+    });
+    const disabledRes = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "download_attachments",
+        connection_id: "conn-disabled",
+        message_uid: 1,
+      },
+      "group-1",
+    );
+    expect(disabledRes).toContain("is disabled");
+
+    // Not found
+    mockGetEmailConnection.mockResolvedValueOnce(null);
+    mockListEmailConnections.mockResolvedValueOnce([]);
+    const notFoundRes = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "download_attachments",
+        connection_id: "conn-missing",
+        message_uid: 1,
+      },
+      "group-1",
+    );
+    expect(notFoundRes).toContain(
+      "Integration connection not found: conn-missing",
+    );
+  });
+
+  it("returns error on unsupported manage_email action", async () => {
+    const result = await executeManageEmailTool(
+      {} as any,
+      { action: "unknown_action" },
+      "group-1",
+    );
+    expect(result).toBe(
+      "Error: Unsupported manage_email action: unknown_action",
+    );
+  });
+
   it("parses email attachment inputs and guesses mime types correctly", async () => {
     const { asEmailAttachmentInputs } =
       await import("./utils/asEmailAttachmentInputs.js");

package/src/worker/tools/email/utils/resolveIntegrationEmailAuth.test.ts

@@ -0,0 +1,120 @@
+import { jest } from "@jest/globals";
+
+let resolveIntegrationEmailAuth: any;
+let mockResolveServiceCredentials: any;
+let mockDecryptValue: any;
+
+describe("resolveIntegrationEmailAuth", () => {
+  beforeEach(async () => {
+    jest.resetModules();
+    mockDecryptValue = jest.fn(async () => "password123");
+    mockResolveServiceCredentials = jest.fn();
+
+    jest.unstable_mockModule("../../../../security/crypto.js", () => ({
+      decryptValue: mockDecryptValue,
+    }));
+
+    jest.unstable_mockModule(
+      "../../../../subsystems/accounts/service-accounts.js",
+      () => ({
+        resolveServiceCredentials: mockResolveServiceCredentials,
+      }),
+    );
+
+    const mod = await import("./resolveIntegrationEmailAuth.js");
+    resolveIntegrationEmailAuth = mod.resolveIntegrationEmailAuth;
+  });
+
+  it("returns error when username is missing", async () => {
+    const conn: any = {
+      id: "conn-1",
+      config: {},
+    };
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toBe(
+      "Error: Integration connection conn-1 is missing username credentials.",
+    );
+  });
+
+  it("handles OAuth connection missing linked accountId", async () => {
+    const conn: any = {
+      id: "conn-2",
+      config: { username: "user@test.com" },
+      credentialRef: { authType: "oauth" },
+    };
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toBe(
+      "Error: Integration connection conn-2 is missing linked OAuth account.",
+    );
+  });
+
+  it("handles OAuth reconnect required when creds cannot be resolved or lack token", async () => {
+    mockResolveServiceCredentials.mockResolvedValueOnce(null);
+
+    const conn: any = {
+      id: "conn-3",
+      config: { username: "user@test.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acc-1",
+        providerId: "google",
+      },
+    };
+
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toContain(
+      "OAuth account reconnect required for integration conn-3",
+    );
+    expect(result).toContain("Connect OAuth for google");
+  });
+
+  it("handles OAuth success", async () => {
+    mockResolveServiceCredentials.mockResolvedValueOnce({
+      token: "oauth-tok-123",
+    });
+
+    const conn: any = {
+      id: "conn-oauth-ok",
+      config: { username: "user@test.com" },
+      credentialRef: {
+        authType: "oauth",
+        accountId: "acc-1",
+        providerId: "google",
+      },
+    };
+
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toEqual({
+      authType: "oauth",
+      username: "user@test.com",
+      accessToken: "oauth-tok-123",
+    });
+  });
+
+  it("returns error when basic password credentials are missing", async () => {
+    mockDecryptValue.mockResolvedValueOnce(null);
+    const conn: any = {
+      id: "conn-4",
+      config: { username: "user@test.com" },
+      credentialRef: { authType: "basic_userpass" },
+    };
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toBe(
+      "Error: Integration connection conn-4 is missing password credentials.",
+    );
+  });
+
+  it("resolves basic auth with password", async () => {
+    const conn: any = {
+      id: "conn-5",
+      config: { username: "user@test.com" },
+      credentialRef: { authType: "basic_userpass", encryptedSecret: "enc:pw" },
+    };
+    const result = await resolveIntegrationEmailAuth({} as any, conn, {});
+    expect(result).toEqual({
+      authType: "basic_userpass",
+      username: "user@test.com",
+      password: "password123",
+    });
+  });
+});