shadow-claw 1.40.0 → 1.40.1

package/src/core/orchestrator/utils/handleWorkerMessage.test.ts

@@ -1,4 +1,7 @@
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import type { ProviderConfig } from "../../../config/config.js";
+import type { ShadowClawDatabase } from "../../../db/db.js";
+import type { Orchestrator } from "../orchestrator.js";
 
 jest.unstable_mockModule("./operations/channel.js", () => ({
   applyAllChannelRunningStates: jest.fn(),
@@ -13,10 +16,12 @@ jest.unstable_mockModule("./operations/channel.js", () => ({
   shouldRunChannel: jest.fn(),
 }));
 
-const mockDeliverResponse = (jest.fn() as any).mockResolvedValue(undefined);
-const mockDeliverIntermediateResponse = (jest.fn() as any).mockResolvedValue(
-  undefined,
-);
+const mockDeliverResponse = jest
+  .fn<(...args: unknown[]) => Promise<unknown>>()
+  .mockResolvedValue(undefined);
+const mockDeliverIntermediateResponse = jest
+  .fn<(...args: unknown[]) => Promise<unknown>>()
+  .mockResolvedValue(undefined);
 
 jest.unstable_mockModule("./deliverResponse.js", () => ({
   deliverResponse: mockDeliverResponse,
@@ -32,25 +37,33 @@ jest.unstable_mockModule("./operations/room.js", () => ({
   listRooms: jest.fn(),
 }));
 
-const mockIsLlamafileResolutionError = jest.fn() as any;
-const mockDetectProviderHelpType = jest.fn() as any;
-const mockIsTransformersJsResolutionError = jest.fn() as any;
-
-const mockDeleteTask = jest.fn() as any;
-const mockGetAllTasks = jest.fn() as any;
-const mockRoomIdFromGroupId = jest.fn() as any;
-const mockSaveTask = jest.fn() as any;
-const mockGetOrCreateSubscriberId = jest.fn() as any;
-
-const mockSyncTaskToServer = jest.fn() as any;
-const mockDeleteTaskFromServer = jest.fn() as any;
-
-const mockGetRemoteMcpConnection = jest.fn() as any;
-const mockReconnectMcpOAuth = jest.fn() as any;
-const mockGetPushUrl = jest.fn() as any;
-const mockGetConfig = jest.fn() as any;
-
-const mockShowToast = jest.fn() as any;
+const mockIsLlamafileResolutionError =
+  jest.fn<(...args: unknown[]) => boolean>();
+const mockDetectProviderHelpType =
+  jest.fn<(...args: unknown[]) => string | null>();
+const mockIsTransformersJsResolutionError =
+  jest.fn<(...args: unknown[]) => boolean>();
+
+const mockDeleteTask = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockGetAllTasks = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockRoomIdFromGroupId = jest.fn<(...args: unknown[]) => string>();
+const mockSaveTask = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockGetOrCreateSubscriberId =
+  jest.fn<(...args: unknown[]) => Promise<string>>();
+
+const mockSyncTaskToServer =
+  jest.fn<(...args: unknown[]) => Promise<boolean>>();
+const mockDeleteTaskFromServer =
+  jest.fn<(...args: unknown[]) => Promise<boolean>>();
+
+const mockGetRemoteMcpConnection =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockReconnectMcpOAuth =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockGetPushUrl = jest.fn<(...args: unknown[]) => Promise<string>>();
+const mockGetConfig = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+
+const mockShowToast = jest.fn<(...args: unknown[]) => unknown>();
 
 jest.unstable_mockModule(
   "../../../components/common/help/llamafile.js",
@@ -111,14 +124,14 @@ jest.unstable_mockModule("../../../db/rooms.js", () => ({
   roomIdFromGroupId: mockRoomIdFromGroupId,
   ROOM_PREFIX: "room:",
   roomGroupId: (id: string) => `room:${id}`,
-  getRoomMetadata: (jest.fn() as any).mockResolvedValue([]),
-  saveRoomMetadata: (jest.fn() as any).mockResolvedValue(undefined),
-  getRoom: (jest.fn() as any).mockResolvedValue(null),
-  upsertRoom: (jest.fn() as any).mockResolvedValue(undefined),
-  createRoom: (jest.fn() as any).mockResolvedValue({}),
-  addRoomMember: (jest.fn() as any).mockResolvedValue(null),
-  removeRoomMember: (jest.fn() as any).mockResolvedValue(null),
-  deleteRoom: (jest.fn() as any).mockResolvedValue(undefined),
+  getRoomMetadata: jest.fn<() => Promise<unknown[]>>().mockResolvedValue([]),
+  saveRoomMetadata: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+  getRoom: jest.fn<() => Promise<null>>().mockResolvedValue(null),
+  upsertRoom: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+  createRoom: jest.fn<() => Promise<unknown>>().mockResolvedValue({}),
+  addRoomMember: jest.fn<() => Promise<null>>().mockResolvedValue(null),
+  removeRoomMember: jest.fn<() => Promise<null>>().mockResolvedValue(null),
+  deleteRoom: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
 }));
 
 jest.unstable_mockModule("../../../db/saveTask.js", () => ({
@@ -129,10 +142,16 @@ jest.unstable_mockModule("../../../db/getOrCreateSubscriberId.js", () => ({
   getOrCreateSubscriberId: mockGetOrCreateSubscriberId,
 }));
 
+interface MockOrchestratorStore {
+  runTask: jest.Mock;
+}
+
+const mockOrchestratorStore: MockOrchestratorStore = {
+  runTask: jest.fn(),
+};
+
 jest.unstable_mockModule("../../../stores/orchestrator.js", () => ({
-  orchestratorStore: {
-    runTask: jest.fn(),
-  },
+  orchestratorStore: mockOrchestratorStore,
 }));
 
 jest.unstable_mockModule(
@@ -144,8 +163,8 @@ jest.unstable_mockModule(
 );
 
 const mockToolsStore = {
-  activateProfile: jest.fn(),
-  setToolEnabled: jest.fn(),
+  activateProfile: jest.fn<(...args: unknown[]) => Promise<void>>(),
+  setToolEnabled: jest.fn<(...args: unknown[]) => Promise<void>>(),
   enabledTools: ["t1"],
   systemPromptOverride: "override",
 };
@@ -156,7 +175,9 @@ jest.unstable_mockModule("../../../stores/tools.js", () => ({
 
 jest.unstable_mockModule("../../../subsystems/mcp/mcp-connections.js", () => ({
   getRemoteMcpConnection: mockGetRemoteMcpConnection,
-  listRemoteMcpConnections: (jest.fn() as any).mockResolvedValue([]),
+  listRemoteMcpConnections: jest
+    .fn<() => Promise<unknown[]>>()
+    .mockResolvedValue([]),
 }));
 
 jest.unstable_mockModule("../../../subsystems/mcp/mcp-reconnect.js", () => ({
@@ -178,9 +199,12 @@ jest.unstable_mockModule("../../../db/getConfig.js", () => ({
   getConfig: mockGetConfig,
 }));
 
-const mockGetApiKeyForRequest = jest.fn() as any;
-const mockGetProviderRuntimeHeaders = jest.fn() as any;
-const mockStopTransformersProgressPolling = jest.fn() as any;
+const mockGetApiKeyForRequest =
+  jest.fn<(...args: unknown[]) => Promise<string | null>>();
+const mockGetProviderRuntimeHeaders =
+  jest.fn<(...args: unknown[]) => Record<string, string>>();
+const mockStopTransformersProgressPolling =
+  jest.fn<(...args: unknown[]) => unknown>();
 
 jest.unstable_mockModule("./operations/provider.js", () => ({
   getApiKeyForRequest: mockGetApiKeyForRequest,
@@ -191,26 +215,30 @@ jest.unstable_mockModule("./operations/provider.js", () => ({
   startTransformersProgressPolling: jest.fn(),
 }));
 
-const mockBuildHeaders = jest.fn() as any;
-const mockFormatRequest = jest.fn() as any;
-const mockParseResponse = jest.fn() as any;
+const mockBuildHeaders =
+  jest.fn<(...args: unknown[]) => Record<string, string>>();
+const mockFormatRequest =
+  jest.fn<(...args: unknown[]) => Record<string, unknown>>();
+const mockParseResponse =
+  jest.fn<(...args: unknown[]) => Record<string, unknown>>();
 
 jest.unstable_mockModule("../../../subsystems/providers/providers.js", () => ({
   buildHeaders: mockBuildHeaders,
   formatRequest: mockFormatRequest,
   getContextLimit: jest.fn().mockReturnValue(128000),
-  normalizeMeshLlmResult: jest.fn().mockImplementation((r: any) => r),
+  normalizeMeshLlmResult: jest.fn().mockImplementation((r) => r),
   parseResponse: mockParseResponse,
 }));
 
-const mockSummarizeText = jest.fn() as any;
-const mockWriteText = jest.fn() as any;
-const mockRewriteText = jest.fn() as any;
-const mockProofreadText = jest.fn() as any;
-const mockDetectLanguage = jest.fn() as any;
-const mockTranslateText = jest.fn() as any;
-const mockEmbedText = jest.fn() as any;
-const mockEnsureBuiltinAiPolyfills = jest.fn() as any;
+const mockSummarizeText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockWriteText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockRewriteText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockProofreadText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockDetectLanguage = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockTranslateText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockEmbedText = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockEnsureBuiltinAiPolyfills =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
 
 jest.unstable_mockModule(
   "../../../subsystems/providers/builtin-ai-tasks.js",
@@ -223,10 +251,12 @@ jest.unstable_mockModule(
     summarizeText: mockSummarizeText,
     translateText: mockTranslateText,
     writeText: mockWriteText,
-    createTaskInstanceWithFallback: (jest.fn() as any).mockResolvedValue({}),
-    getPromptApiFallbackModel: (jest.fn() as any).mockResolvedValue(
-      "onnx-community/Qwen3-0.6B-ONNX",
-    ),
+    createTaskInstanceWithFallback: jest
+      .fn<() => Promise<unknown>>()
+      .mockResolvedValue({}),
+    getPromptApiFallbackModel: jest
+      .fn<() => Promise<string>>()
+      .mockResolvedValue("onnx-community/Qwen3-0.6B-ONNX"),
     PROMPT_API_POLYFILL_MODEL: "onnx-community/Qwen3-0.6B-ONNX",
   }),
 );
@@ -235,28 +265,58 @@ const { handleWorkerMessage } = await import("./handleWorkerMessage.js");
 const { createRoom, inviteToRoom, leaveRoom } =
   await import("./operations/room.js");
 
+interface PendingResolver {
+  resolve: (value: unknown) => void;
+  reject: (reason: unknown) => void;
+}
+
+const globalNativeAi = globalThis as typeof globalThis & {
+  pendingNativeAiResolvers?: Record<string, PendingResolver>;
+  LanguageModel?: {
+    create: () => Promise<{
+      prompt: (p?: string) => Promise<string>;
+      destroy: () => void;
+    }>;
+  };
+};
+
+const dummyProviderConfig: ProviderConfig = {
+  id: "test-prov",
+  name: "Test Provider",
+  baseUrl: "https://api.test.example/v1",
+  format: "openai",
+  requiresApiKey: true,
+  apiKeyHeader: "Authorization",
+  headers: {},
+  supportsStreaming: true,
+  defaultModel: "test-model",
+};
+
 describe("handleWorkerMessage", () => {
-  let mockOrchestrator: any;
-  let mockDb: any;
+  let mockOrchestrator: Orchestrator;
+  let mockDb: ShadowClawDatabase;
 
   beforeEach(() => {
     jest.clearAllMocks();
     mockSyncTaskToServer.mockResolvedValue(true);
     mockDeleteTaskFromServer.mockResolvedValue(true);
     mockGetOrCreateSubscriberId.mockResolvedValue("sub-test");
-    mockDb = {};
+
+    mockDb = {} as unknown as ShadowClawDatabase;
     mockOrchestrator = {
-      transformersProgressPollers: new Map(),
+      transformersProgressPollers: new Map<string, unknown>(),
       clearProviderRequest: jest.fn(),
-      inFlightTriggerByGroup: new Map(),
-      inFlightEffectiveProviderByGroup: new Map(),
-      deliverResponse: (jest.fn() as any).mockResolvedValue(undefined),
-      deliverIntermediateResponse: (jest.fn() as any).mockResolvedValue(
-        undefined,
-      ),
+      inFlightTriggerByGroup: new Map<string, string>(),
+      inFlightEffectiveProviderByGroup: new Map<string, unknown>(),
+      deliverResponse: jest
+        .fn<(...args: unknown[]) => Promise<unknown>>()
+        .mockResolvedValue(undefined),
+      deliverIntermediateResponse: jest
+        .fn<(...args: unknown[]) => Promise<unknown>>()
+        .mockResolvedValue(undefined),
       setState: jest.fn(),
       events: { emit: jest.fn() },
-      schedulerTriggeredGroups: new Set(),
+      schedulerTriggeredGroups: new Set<string>(),
       createRoom: jest.fn(),
       inviteToRoom: jest.fn(),
       leaveRoom: jest.fn(),
@@ -264,14 +324,23 @@ describe("handleWorkerMessage", () => {
       providerConfig: { requiresApiKey: true },
       router: {
         setTyping: jest.fn(),
-        send: (jest.fn() as any).mockResolvedValue(undefined),
+        send: jest
+          .fn<(...args: unknown[]) => Promise<unknown>>()
+          .mockResolvedValue(undefined),
         findChannel: jest.fn(),
       },
-      newSession: (jest.fn() as any).mockResolvedValue(undefined),
-      handleCompactDone: (jest.fn() as any).mockResolvedValue(undefined),
+      newSession: jest
+        .fn<(...args: unknown[]) => Promise<unknown>>()
+        .mockResolvedValue(undefined),
+      handleCompactDone: jest
+        .fn<(...args: unknown[]) => Promise<unknown>>()
+        .mockResolvedValue(undefined),
       agentWorker: { postMessage: jest.fn() },
       roomManager: { broadcastA2UI: jest.fn() },
-    };
+      maxTokens: 1000,
+      provider: "test-provider",
+      model: "test-model",
+    } as unknown as Orchestrator;
 
     mockGetPushUrl.mockResolvedValue("http://push");
     mockGetAllTasks.mockResolvedValue([]);
@@ -283,11 +352,17 @@ describe("handleWorkerMessage", () => {
     mockParseResponse.mockReturnValue({
       content: [{ type: "text", text: "parsed result" }],
     });
-    global.fetch = (jest.fn() as any).mockResolvedValue({} as any) as any;
+    global.fetch = jest
+      .fn<(...args: unknown[]) => Promise<unknown>>()
+      .mockResolvedValue({} as unknown as Response) as typeof global.fetch;
   });
 
-  const send = async (msg: any) =>
-    handleWorkerMessage(mockOrchestrator, mockDb, msg);
+  const send = async (msg: { type: string; payload?: unknown }) =>
+    handleWorkerMessage(
+      mockOrchestrator,
+      mockDb,
+      msg as Record<string, unknown>,
+    );
 
   it("handles response", async () => {
     mockOrchestrator.inFlightTriggerByGroup.set("g1", "x");
@@ -344,15 +419,21 @@ describe("handleWorkerMessage", () => {
     );
   });
 
-  it("handles tasks (create, update, delete)", async () => {
-    // blocked by recursion
+  it("handles run-task", async () => {
+    await send({ type: "run-task", payload: { task: { id: "t1" } } });
+    expect(mockOrchestratorStore.runTask).toHaveBeenCalledWith(
+      { id: "t1" },
+      true,
+    );
+  });
+
+  it("handles task-created success and failures", async () => {
     mockOrchestrator.schedulerTriggeredGroups.add("g1");
     await send({ type: "task-created", payload: { task: { groupId: "g1" } } });
     expect(mockShowToast).toHaveBeenCalledWith(
       expect.stringContaining("blocked"),
       expect.any(Object),
     );
-
     mockOrchestrator.schedulerTriggeredGroups.clear();
 
     await send({ type: "task-created", payload: { task: { groupId: "g2" } } });
@@ -363,14 +444,64 @@ describe("handleWorkerMessage", () => {
       "sub-test",
     );
 
+    // Sync to server failed
+    mockSyncTaskToServer.mockResolvedValueOnce(false);
+    await send({ type: "task-created", payload: { task: { groupId: "g2" } } });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      "Failed to sync task to server — task was not saved.",
+      { type: "error" },
+    );
+
+    // Save task throws error
+    mockSaveTask.mockRejectedValueOnce(new Error("Save failed"));
+    await send({ type: "task-created", payload: { task: { groupId: "g2" } } });
+    expect(mockShowToast).toHaveBeenCalledWith("Failed to save task.", {
+      type: "error",
+    });
+  });
+
+  it("handles update-task success and failures", async () => {
+    mockOrchestrator.schedulerTriggeredGroups.add("g1");
+    await send({ type: "update-task", payload: { task: { groupId: "g1" } } });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      expect.stringContaining("Task update blocked"),
+      expect.any(Object),
+    );
+    mockOrchestrator.schedulerTriggeredGroups.clear();
+
     await send({ type: "update-task", payload: { task: { groupId: "g2" } } });
-    expect(mockSaveTask).toHaveBeenCalledTimes(2);
+    expect(mockSaveTask).toHaveBeenCalled();
     expect(mockSyncTaskToServer).toHaveBeenLastCalledWith(
       mockOrchestrator,
       { groupId: "g2" },
       "sub-test",
     );
 
+    // Sync to server failed
+    mockSyncTaskToServer.mockResolvedValueOnce(false);
+    await send({ type: "update-task", payload: { task: { groupId: "g2" } } });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      "Failed to sync task update to server — task was not updated.",
+      { type: "error" },
+    );
+
+    // Update throws error
+    mockSaveTask.mockRejectedValueOnce(new Error("Update failed"));
+    await send({ type: "update-task", payload: { task: { groupId: "g2" } } });
+    expect(mockShowToast).toHaveBeenCalledWith("Failed to update task.", {
+      type: "error",
+    });
+  });
+
+  it("handles delete-task success and failures", async () => {
+    mockOrchestrator.schedulerTriggeredGroups.add("g1");
+    await send({ type: "delete-task", payload: { id: "t1", groupId: "g1" } });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      expect.stringContaining("Task deletion blocked"),
+      expect.any(Object),
+    );
+    mockOrchestrator.schedulerTriggeredGroups.clear();
+
     await send({ type: "delete-task", payload: { id: "t1", groupId: "g2" } });
     expect(mockDeleteTask).toHaveBeenCalled();
     expect(mockDeleteTaskFromServer).toHaveBeenCalledWith(
@@ -378,15 +509,50 @@ describe("handleWorkerMessage", () => {
       "t1",
       "sub-test",
     );
+
+    // Server deletion failed
+    mockDeleteTaskFromServer.mockResolvedValueOnce(false);
+    await send({ type: "delete-task", payload: { id: "t1", groupId: "g2" } });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      "Failed to delete task from server — task kept in view.",
+      { type: "error" },
+    );
+
+    // Delete task throws
+    mockDeleteTask.mockRejectedValueOnce(new Error("Delete failed"));
+    await send({ type: "delete-task", payload: { id: "t1", groupId: "g2" } });
   });
 
-  it("handles room actions", async () => {
+  it("handles task-list-request filtering by groupId", async () => {
+    mockGetAllTasks.mockResolvedValue([
+      { id: "t1", groupId: "g1" },
+      { id: "t2", groupId: "g2" },
+    ]);
+
+    await send({ type: "task-list-request", payload: { groupId: "g1" } });
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
+      type: "task-list-response",
+      payload: {
+        groupId: "g1",
+        tasks: [{ id: "t1", groupId: "g1" }],
+      },
+    });
+  });
+
+  it("handles room actions and edge cases", async () => {
     await send({
       type: "room-action",
       payload: { action: "create", name: "r1" },
     });
     expect(createRoom).toHaveBeenCalledWith(mockOrchestrator, "r1");
 
+    await send({
+      type: "room-action",
+      payload: { action: "create" },
+    });
+    expect(createRoom).toHaveBeenCalledWith(mockOrchestrator, "");
+
     await send({
       type: "room-action",
       payload: { action: "invite", roomId: "r1", peerId: "p1" },
@@ -398,9 +564,24 @@ describe("handleWorkerMessage", () => {
       payload: { action: "leave", roomId: "r1" },
     });
     expect(leaveRoom).toHaveBeenCalledWith(mockOrchestrator, "r1");
+
+    // Unknown action does not crash
+    await send({
+      type: "room-action",
+      payload: { action: "unknown" },
+    });
+
+    // Thrown error is caught cleanly
+    (leaveRoom as jest.Mock).mockImplementationOnce(() => {
+      throw new Error("Leave error");
+    });
+    await send({
+      type: "room-action",
+      payload: { action: "leave", roomId: "r1" },
+    });
   });
 
-  it("handles errors", async () => {
+  it("handles errors and context limit warnings", async () => {
     await send({
       type: "error",
       payload: { groupId: "g1", error: "tokens_limit_reached" },
@@ -411,12 +592,25 @@ describe("handleWorkerMessage", () => {
       "g1",
       expect.stringContaining("context window"),
     );
+
+    // Non-context error
+    await send({
+      type: "error",
+      payload: { groupId: "g1", error: "Unrelated provider fault" },
+    });
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "g1",
+      "⚠️ Error: Unrelated provider fault",
+    );
   });
 
-  it("handles llamafile error", async () => {
+  it("handles llamafile error and transformers_js_local error", async () => {
     mockOrchestrator.inFlightEffectiveProviderByGroup.set("g1", {
       providerId: "llamafile",
       model: "llamafile-model",
+      providerConfig: dummyProviderConfig,
     });
     mockIsLlamafileResolutionError.mockReturnValue(true);
     await send({
@@ -427,12 +621,50 @@ describe("handleWorkerMessage", () => {
       "provider-help",
       expect.objectContaining({ providerId: "llamafile" }),
     );
+
+    mockOrchestrator.inFlightEffectiveProviderByGroup.set("g2", {
+      providerId: "transformers_js_local",
+      model: "local-model",
+      providerConfig: dummyProviderConfig,
+    });
+    mockIsTransformersJsResolutionError.mockReturnValue(true);
+    await send({
+      type: "error",
+      payload: { groupId: "g2", error: "transformers local error" },
+    });
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("provider-help", {
+      providerId: "transformers_js_local",
+      reason: "transformers local error",
+    });
+  });
+
+  it("handles generic provider help detection", async () => {
+    mockOrchestrator.inFlightEffectiveProviderByGroup.set("g1", {
+      providerId: "openai",
+      model: "gpt-4",
+      providerConfig: dummyProviderConfig,
+    });
+    mockIsLlamafileResolutionError.mockReturnValue(false);
+    mockIsTransformersJsResolutionError.mockReturnValue(false);
+    mockDetectProviderHelpType.mockReturnValue("api_key_missing");
+
+    await send({
+      type: "error",
+      payload: { groupId: "g1", error: "Invalid API key" },
+    });
+
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("provider-help", {
+      providerId: "openai",
+      reason: "Invalid API key",
+      helpType: "api_key_missing",
+    });
   });
 
-  it("handles simple events", async () => {
+  it("handles simple events and tool activities", async () => {
     await send({ type: "typing", payload: { groupId: "g1" } });
-    expect(mockOrchestrator.router.setTyping).toHaveBeenCalledWith("g1", true);
+    expect(mockOrchestrator.router?.setTyping).toHaveBeenCalledWith("g1", true);
 
+    // write_file done
     await send({
       type: "tool-activity",
       payload: { groupId: "g1", tool: "write_file", status: "done" },
@@ -441,6 +673,26 @@ describe("handleWorkerMessage", () => {
       groupId: "g1",
     });
 
+    // bash done
+    await send({
+      type: "tool-activity",
+      payload: { groupId: "g1", tool: "bash", status: "done" },
+    });
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("file-change", {
+      groupId: "g1",
+    });
+
+    // other tool / running status
+    (mockOrchestrator.events.emit as jest.Mock).mockClear();
+    await send({
+      type: "tool-activity",
+      payload: { groupId: "g1", tool: "read_file", status: "done" },
+    });
+    expect(mockOrchestrator.events.emit).not.toHaveBeenCalledWith(
+      "file-change",
+      expect.anything(),
+    );
+
     await send({
       type: "compact-done",
       payload: { groupId: "g1", summary: "s" },
@@ -451,56 +703,156 @@ describe("handleWorkerMessage", () => {
       "s",
     );
 
-    await send({ type: "task-list-request", payload: { groupId: "g1" } });
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalled();
-
     await send({ type: "clear-chat", payload: { groupId: "g1" } });
     expect(mockOrchestrator.newSession).toHaveBeenCalledWith(mockDb, "g1");
 
+    // Clear chat throws
+    (
+      mockOrchestrator.newSession as jest.Mock<
+        (...args: unknown[]) => Promise<unknown>
+      >
+    ).mockRejectedValueOnce(new Error("Clear error"));
+    await send({ type: "clear-chat", payload: { groupId: "g1" } });
+
     await send({ type: "show-toast", payload: { message: "msg" } });
-    expect(mockShowToast).toHaveBeenCalled();
+    expect(mockShowToast).toHaveBeenCalledWith("msg", {
+      type: "info",
+      duration: undefined,
+    });
+
+    await send({
+      type: "model-download-progress",
+      payload: { progress: 0.5 },
+    });
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
+      "model-download-progress",
+      { progress: 0.5 },
+    );
+
+    await send({ type: "thinking-log", payload: { text: "thinking..." } });
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("thinking-log", {
+      text: "thinking...",
+    });
+
+    await send({ type: "token-usage", payload: { tokens: 100 } });
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("token-usage", {
+      tokens: 100,
+    });
   });
 
-  it("handles manage-tools", async () => {
+  it("handles manage-tools with enable, disable, and default groupId", async () => {
     await send({
       type: "manage-tools",
       payload: { action: "activate_profile", profileId: "p1" },
     });
     expect(mockToolsStore.activateProfile).toHaveBeenCalledWith(mockDb, "p1");
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          groupId: "br:main",
+        }),
+      }),
+    );
 
     await send({
       type: "manage-tools",
-      payload: { action: "enable", toolNames: ["t1"] },
+      payload: { action: "enable", toolNames: ["t1"], groupId: "g1" },
     });
     expect(mockToolsStore.setToolEnabled).toHaveBeenCalledWith(
       mockDb,
       "t1",
       true,
     );
+
+    await send({
+      type: "manage-tools",
+      payload: { action: "disable", toolNames: ["t2"] },
+    });
+    expect(mockToolsStore.setToolEnabled).toHaveBeenCalledWith(
+      mockDb,
+      "t2",
+      false,
+    );
+
+    // Unrecognized action
+    await send({
+      type: "manage-tools",
+      payload: { action: "unknown_action" },
+    });
   });
 
-  it("handles push notifs", async () => {
+  it("handles push notifications and recursion guard", async () => {
+    mockOrchestrator.schedulerTriggeredGroups.add("g1");
+    await send({
+      type: "send-notification",
+      payload: { title: "t", body: "b", groupId: "g1" },
+    });
+    expect(mockShowToast).toHaveBeenCalledWith(
+      expect.stringContaining("Notification blocked"),
+      expect.any(Object),
+    );
+    mockOrchestrator.schedulerTriggeredGroups.clear();
+
     await send({
       type: "send-notification",
       payload: { title: "t", body: "b" },
     });
     expect(mockGetPushUrl).toHaveBeenCalled();
+
+    // Fetch error handling
+    (
+      global.fetch as jest.Mock<(...args: unknown[]) => Promise<unknown>>
+    ).mockRejectedValueOnce(new Error("Push network error"));
+    await send({
+      type: "send-notification",
+      payload: { title: "t", body: "b" },
+    });
+    await new Promise(process.nextTick);
   });
 
-  it("handles send-file", async () => {
+  it("handles send-file variations", async () => {
     await send({
       type: "send-file",
       payload: { groupId: "g1", path: "test.txt" },
     });
-    // Need a tick since it's fire-and-forget IIFE
     await new Promise(process.nextTick);
-    expect(mockOrchestrator.router.send).toHaveBeenCalled();
-  });
+    expect(mockOrchestrator.router?.send).toHaveBeenCalledWith("g1", "", [
+      expect.objectContaining({ fileName: "test.txt" }),
+    ]);
 
-  it("handles send-file rejection", async () => {
-    mockOrchestrator.router.send.mockRejectedValueOnce(
-      new Error("Send failed"),
+    // Empty path fallback
+    await send({
+      type: "send-file",
+      payload: { groupId: "g1", path: "" },
+    });
+    await new Promise(process.nextTick);
+    expect(mockOrchestrator.router?.send).toHaveBeenCalledWith("g1", "", [
+      expect.objectContaining({ fileName: "" }),
+    ]);
+
+    // Rejection with non-Error
+    (
+      mockOrchestrator.router?.send as jest.Mock<
+        (...args: unknown[]) => Promise<unknown>
+      >
+    ).mockRejectedValueOnce("raw string rejection");
+    await send({
+      type: "send-file",
+      payload: { groupId: "g1", path: "fail.txt" },
+    });
+    await new Promise(process.nextTick);
+    expect(mockShowToast).toHaveBeenCalledWith(
+      "Failed to send file to peer: raw string rejection",
+      expect.any(Object),
     );
+  });
+
+  it("handles send-file rejection with Error", async () => {
+    (
+      mockOrchestrator.router?.send as jest.Mock<
+        (...args: unknown[]) => Promise<unknown>
+      >
+    ).mockRejectedValueOnce(new Error("Send failed"));
     const consoleError = jest
       .spyOn(console, "error")
       .mockImplementation(() => {});
@@ -530,8 +882,8 @@ describe("handleWorkerMessage", () => {
   });
 
   it("handles render-component", async () => {
-    mockOrchestrator.router.findChannel.mockReturnValue({
-      sendA2UI: (jest.fn() as any).mockResolvedValue(undefined),
+    (mockOrchestrator.router?.findChannel as jest.Mock).mockReturnValue({
+      sendA2UI: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
     });
     mockRoomIdFromGroupId.mockReturnValue("r1");
 
@@ -549,11 +901,20 @@ describe("handleWorkerMessage", () => {
       expect.any(Object),
     );
     expect(mockOrchestrator.roomManager.broadcastA2UI).toHaveBeenCalled();
+
+    // peer: group where channel does not implement sendA2UI
+    (mockOrchestrator.router?.findChannel as jest.Mock).mockReturnValue({});
+    await send({
+      type: "render-component",
+      payload: { groupId: "peer:g2", envelope: {} },
+    });
   });
 
   it("handles render-component sendA2UI rejection", async () => {
-    mockOrchestrator.router.findChannel.mockReturnValue({
-      sendA2UI: (jest.fn() as any).mockRejectedValue(new Error("err")),
+    (mockOrchestrator.router?.findChannel as jest.Mock).mockReturnValue({
+      sendA2UI: jest
+        .fn<() => Promise<void>>()
+        .mockRejectedValue(new Error("err")),
     });
     const consoleError = jest
       .spyOn(console, "error")
@@ -564,7 +925,6 @@ describe("handleWorkerMessage", () => {
       payload: { groupId: "peer:g1", envelope: {} },
     });
 
-    // Wait for the fire-and-forget catch block
     await new Promise(process.nextTick);
 
     expect(consoleError).toHaveBeenCalledWith(
@@ -618,7 +978,7 @@ describe("handleWorkerMessage", () => {
     );
   });
 
-  it("handles mcp-reauth-required", async () => {
+  it("handles mcp-reauth-required success, retry action, and popup success/failure", async () => {
     mockGetRemoteMcpConnection.mockResolvedValue({
       autoReconnectOAuth: true,
       label: "conn",
@@ -631,10 +991,49 @@ describe("handleWorkerMessage", () => {
     });
 
     expect(mockReconnectMcpOAuth).toHaveBeenCalled();
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "mcp-reauth-result",
       payload: { connectionId: "c1", success: true },
     });
+
+    // Reauth silent attempt fails -> triggers popup action
+    mockGetRemoteMcpConnection.mockResolvedValue({
+      autoReconnectOAuth: true,
+    });
+    mockReconnectMcpOAuth.mockResolvedValueOnce({
+      success: false,
+      error: "Token expired",
+    });
+
+    await send({
+      type: "mcp-reauth-required",
+      payload: { connectionId: "c2" },
+    });
+
+    const failedToastCall = mockShowToast.mock.calls[
+      mockShowToast.mock.calls.length - 1
+    ] as [string, { action?: { onClick?: () => Promise<void> } }];
+    const onClick = failedToastCall[1]?.action?.onClick;
+    expect(typeof onClick).toBe("function");
+
+    // Click popup reconnect -> success
+    mockReconnectMcpOAuth.mockResolvedValueOnce({ success: true });
+    await onClick!();
+    expect(mockShowToast).toHaveBeenCalledWith(
+      '🔑 OAuth reconnected for "c2"',
+      expect.objectContaining({ type: "success" }),
+    );
+
+    // Click popup reconnect -> failure
+    mockReconnectMcpOAuth.mockResolvedValueOnce({
+      success: false,
+      error: "User cancelled",
+    });
+    await onClick!();
+    expect(mockShowToast).toHaveBeenCalledWith(
+      '🔑 OAuth reconnect failed for "c2": User cancelled',
+      expect.objectContaining({ type: "error" }),
+    );
   });
 
   it("handles mcp-reauth-required without auto-reconnect", async () => {
@@ -645,7 +1044,7 @@ describe("handleWorkerMessage", () => {
       payload: { connectionId: "c1" },
     });
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "mcp-reauth-result",
       payload: { connectionId: "c1", success: false },
     });
@@ -658,7 +1057,7 @@ describe("handleWorkerMessage", () => {
 
       const localResolve = jest.fn();
       const localReject = jest.fn();
-      (globalThis as any).pendingNativeAiResolvers = {
+      globalNativeAi.pendingNativeAiResolvers = {
         task_123: { resolve: localResolve, reject: localReject },
       };
 
@@ -676,7 +1075,6 @@ describe("handleWorkerMessage", () => {
         },
       });
 
-      // Wait for the async IIFE inside handleWorkerMessage
       await new Promise(process.nextTick);
 
       expect(mockTranslateText).toHaveBeenCalledWith(
@@ -688,30 +1086,69 @@ describe("handleWorkerMessage", () => {
       );
       expect(localResolve).toHaveBeenCalledWith("tres");
       expect(
-        (globalThis as any).pendingNativeAiResolvers["task_123"],
+        globalNativeAi.pendingNativeAiResolvers?.["task_123"],
       ).toBeUndefined();
-      expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+      expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
         type: "native-ai-task-response",
         payload: { id: "task_123", response: "tres" },
       });
     });
 
+    it("handles onProgress callback and task execution without groupId", async () => {
+      mockGetConfig.mockResolvedValue("local");
+      mockSummarizeText.mockImplementation(
+        async (_text: unknown, options: unknown) => {
+          const opts = options as { onProgress?: (p: unknown) => void };
+          opts.onProgress?.({
+            status: "downloading",
+            progress: 0.5,
+            message: "downloading model",
+          });
+          return "summary result";
+        },
+      );
+      mockGetApiKeyForRequest.mockResolvedValueOnce(null);
+
+      await send({
+        type: "request-native-ai-task",
+        payload: {
+          id: "task_no_group",
+          taskType: "summarize",
+          input: { text: "text without group" },
+        },
+      });
+
+      await new Promise(process.nextTick);
+
+      expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
+        type: "native-ai-task-response",
+        payload: { id: "task_no_group", response: "summary result" },
+      });
+    });
+
     it("handles active_provider preference with Prompt API and resolves local resolvers", async () => {
       mockGetConfig.mockResolvedValue("active_provider");
       mockOrchestrator.provider = "prompt_api";
 
-      const mockPrompt = jest.fn(async (_prompt?: string) => "tres");
+      const mockPrompt = jest.fn<(_p?: string) => Promise<string>>(
+        async () => "tres",
+      );
       const mockDestroy = jest.fn();
-      const mockCreate = jest.fn(async () => ({
+      const mockCreate = jest.fn<
+        () => Promise<{
+          prompt: typeof mockPrompt;
+          destroy: typeof mockDestroy;
+        }>
+      >(async () => ({
         prompt: mockPrompt,
         destroy: mockDestroy,
       }));
 
-      (globalThis as any).LanguageModel = { create: mockCreate };
+      globalNativeAi.LanguageModel = { create: mockCreate };
 
       const localResolve = jest.fn();
       const localReject = jest.fn();
-      (globalThis as any).pendingNativeAiResolvers = {
+      globalNativeAi.pendingNativeAiResolvers = {
         task_456: { resolve: localResolve, reject: localReject },
       };
 
@@ -737,15 +1174,15 @@ describe("handleWorkerMessage", () => {
       );
       expect(mockDestroy).toHaveBeenCalled();
       expect(localResolve).toHaveBeenCalledWith("tres");
-      expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+      expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
         type: "native-ai-task-response",
         payload: { id: "task_456", response: "tres" },
       });
 
-      delete (globalThis as any).LanguageModel;
+      delete globalNativeAi.LanguageModel;
     });
 
-    it("rejects local resolvers and sends error message on failure", async () => {
+    it("rejects local resolvers and sends error message on failure with Error and non-Error", async () => {
       mockGetConfig.mockResolvedValue("local");
       mockSummarizeText.mockRejectedValue(
         new Error("Summarizer out of memory"),
@@ -753,7 +1190,7 @@ describe("handleWorkerMessage", () => {
 
       const localResolve = jest.fn();
       const localReject = jest.fn();
-      (globalThis as any).pendingNativeAiResolvers = {
+      globalNativeAi.pendingNativeAiResolvers = {
         task_err: { resolve: localResolve, reject: localReject },
       };
 
@@ -773,64 +1210,113 @@ describe("handleWorkerMessage", () => {
         expect.objectContaining({ message: "Summarizer out of memory" }),
       );
       expect(
-        (globalThis as any).pendingNativeAiResolvers["task_err"],
+        globalNativeAi.pendingNativeAiResolvers?.["task_err"],
       ).toBeUndefined();
-      expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+      expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
         type: "native-ai-task-response",
         payload: { id: "task_err", error: "Summarizer out of memory" },
       });
+
+      // Non-Error rejection without groupId
+      mockSummarizeText.mockRejectedValueOnce("raw string failure");
+      const stringResolve = jest.fn();
+      const stringReject = jest.fn();
+      globalNativeAi.pendingNativeAiResolvers = {
+        task_string_err: { resolve: stringResolve, reject: stringReject },
+      };
+
+      await send({
+        type: "request-native-ai-task",
+        payload: {
+          id: "task_string_err",
+          taskType: "summarize",
+          input: { text: "Long text" },
+        },
+      });
+
+      await new Promise(process.nextTick);
+
+      expect(stringReject).toHaveBeenCalledWith(
+        expect.objectContaining({ message: "raw string failure" }),
+      );
+      expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
+        type: "native-ai-task-response",
+        payload: { id: "task_string_err", error: "raw string failure" },
+      });
+
+      // Non-Error rejection WITH groupId
+      mockSummarizeText.mockRejectedValueOnce("raw string failure with group");
+      const stringResolveGroup = jest.fn();
+      const stringRejectGroup = jest.fn();
+      globalNativeAi.pendingNativeAiResolvers = {
+        task_string_group: {
+          resolve: stringResolveGroup,
+          reject: stringRejectGroup,
+        },
+      };
+
+      await send({
+        type: "request-native-ai-task",
+        payload: {
+          id: "task_string_group",
+          groupId: "g1",
+          taskType: "summarize",
+          input: { text: "Long text" },
+        },
+      });
+
+      await new Promise(process.nextTick);
+
+      expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
+        "model-download-progress",
+        expect.objectContaining({
+          groupId: "g1",
+          status: "error",
+          message: "raw string failure with group",
+        }),
+      );
     });
   });
 
-  /**
-   * Regression test for the missing `model` field on inFlightEffectiveProviderByGroup.
-   *
-   * Before the fix, `executeActiveProviderTask` resolved the model via:
-   *   inFlightInfo?.providerConfig?.defaultModel || o.model
-   *
-   * This meant the conversation-pinned model was ignored and the provider's
-   * config-level defaultModel was silently substituted. The fix adds a `model`
-   * field directly to the in-flight entry so the resolved model is always used.
-   */
   describe("request-native-ai-task uses inFlightEffectiveProviderByGroup.model", () => {
     it("passes the in-flight resolved model to formatRequest, not providerConfig.defaultModel", async () => {
       const { getProvider } = await import("../../../config/config.js");
-      (getProvider as jest.MockedFunction<any>).mockReturnValue({
+      (getProvider as unknown as jest.Mock).mockReturnValue({
         name: "Test Provider",
         baseUrl: "https://api.test.example/v1",
         format: "openai",
         requiresApiKey: true,
         supportsStreaming: false,
-        defaultModel: "provider-default-model", // should NOT be used
+        defaultModel: "provider-default-model",
       });
 
       mockGetConfig.mockResolvedValue("active_provider");
       mockOrchestrator.provider = "test-provider";
-      mockOrchestrator.model = "orchestrator-fallback-model"; // should NOT be used
+      mockOrchestrator.model = "orchestrator-fallback-model";
 
-      // The resolved (pinned) model recorded when the invocation started
       const resolvedModel = "claude-sonnet-4-5-pinned";
       mockOrchestrator.inFlightEffectiveProviderByGroup.set("g1", {
         providerId: "test-provider",
         providerConfig: {
+          ...dummyProviderConfig,
           name: "Test Provider",
           baseUrl: "https://api.test.example/v1",
           format: "openai",
           requiresApiKey: true,
           defaultModel: "provider-default-model",
         },
-        // ← This field was missing before the fix; without it, formatRequest
-        //   would have received 'provider-default-model' or 'orchestrator-fallback-model'.
         model: resolvedModel,
       });
 
-      global.fetch = (jest.fn() as any).mockResolvedValue({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            choices: [{ message: { content: "Summarized." } }],
-          }),
-      }) as any;
+      global.fetch = jest
+        .fn<(...args: unknown[]) => Promise<Response>>()
+        .mockResolvedValue({
+          ok: true,
+          json: () =>
+            Promise.resolve({
+              choices: [{ message: { content: "Summarized." } }],
+            }),
+        } as unknown as Response);
 
       mockParseResponse.mockReturnValue({
         content: [{ type: "text", text: "Summarized." }],
@@ -848,8 +1334,6 @@ describe("handleWorkerMessage", () => {
 
       await new Promise(process.nextTick);
 
-      // formatRequest must have been called with the resolved pinned model,
-      // not providerConfig.defaultModel or o.model.
       expect(mockFormatRequest).toHaveBeenCalledWith(
         expect.anything(),
         expect.anything(),
@@ -857,5 +1341,41 @@ describe("handleWorkerMessage", () => {
         expect.objectContaining({ model: resolvedModel }),
       );
     });
+
+    it("falls back to providerConfig.defaultModel when inFlightInfo.model is not set", async () => {
+      mockGetConfig.mockResolvedValue("active_provider");
+      mockOrchestrator.inFlightEffectiveProviderByGroup.set("g1", {
+        providerId: "test-provider",
+        providerConfig: {
+          ...dummyProviderConfig,
+          defaultModel: "provider-config-default-model",
+        },
+        model: "",
+      });
+
+      await send({
+        type: "request-native-ai-task",
+        payload: {
+          id: "model-fallback-task",
+          groupId: "g1",
+          taskType: "summarize",
+          input: { text: "A very long article…" },
+        },
+      });
+
+      await new Promise(process.nextTick);
+
+      expect(mockFormatRequest).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ model: "provider-config-default-model" }),
+      );
+    });
+  });
+
+  it("safely ignores unrecognized worker message types", async () => {
+    await send({ type: "unknown-type-xyz", payload: {} });
+    expect(mockOrchestrator.events.emit).not.toHaveBeenCalled();
   });
 });