shadow-claw 1.40.0 → 1.40.1

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

@@ -1,45 +1,59 @@
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-
-const mockBuildDynamicContext = jest.fn() as any;
-const mockEstimateTokens = jest.fn() as any;
-const mockBuildConversationMessages = jest.fn() as any;
-const mockGetConfig = jest.fn() as any;
-const mockListGroups = jest.fn() as any;
-const mockSaveMessage = jest.fn() as any;
-const mockReadGroupFile = jest.fn() as any;
-
-const mockInvokeWithLiteRtLm = jest.fn() as any;
-const mockIsLiteRtLmSupported = jest.fn() as any;
-
-const mockInvokeWithPromptApi = jest.fn() as any;
-const mockIsPromptApiSupported = jest.fn() as any;
-
-const mockGetContextLimit = jest.fn() as any;
-const mockGetProvider = jest.fn() as any;
-
-const mockInvokeWithTransformersJs = jest.fn() as any;
-const mockUlid = jest.fn() as any;
-const mockWorkerPost = jest.fn() as any;
-const mockRegisterSubagentCollector = jest.fn() as any;
-const mockUnregisterSubagentCollector = jest.fn() as any;
-const mockBuildSystemPrompt = jest.fn() as any;
-
-const mockGetChannelTypeForGroup = jest.fn() as any;
+import type { ShadowClawDatabase } from "../../../db/db.js";
+import type { Orchestrator } from "../orchestrator.js";
+import { activate_skill } from "../../../subsystems/skills/tool.js";
+
+const mockBuildDynamicContext = jest.fn<(...args: unknown[]) => unknown>();
+const mockEstimateTokens = jest.fn<(...args: unknown[]) => number>();
+const mockBuildConversationMessages =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockGetConfig = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockListGroups = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockSaveMessage = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockReadGroupFile = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+
+const mockInvokeWithLiteRtLm =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockIsLiteRtLmSupported = jest.fn<() => boolean>();
+
+const mockInvokeWithPromptApi =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockIsPromptApiSupported = jest.fn<() => boolean>();
+const mockEnsureBuiltinAiPolyfills = jest.fn<() => Promise<unknown>>();
+
+const mockGetContextLimit = jest.fn<(...args: unknown[]) => number>();
+const mockGetProvider = jest.fn<(...args: unknown[]) => unknown>();
+
+const mockInvokeWithTransformersJs =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockUlid = jest.fn<() => string>();
+const mockWorkerPost = jest.fn<(...args: unknown[]) => unknown>();
+const mockRegisterSubagentCollector =
+  jest.fn<(...args: unknown[]) => unknown>();
+const mockUnregisterSubagentCollector =
+  jest.fn<(...args: unknown[]) => unknown>();
+const mockBuildSystemPrompt = jest.fn<(...args: unknown[]) => string>();
+
+const mockGetChannelTypeForGroup = jest.fn<(...args: unknown[]) => unknown>();
 jest.unstable_mockModule("./operations/channel.js", () => ({
   getChannelTypeForGroup: mockGetChannelTypeForGroup,
 }));
 
-const mockLoadDeclarativeTools = jest.fn() as any;
-const mockFindDeclarativeTool = jest.fn() as any;
+const mockLoadDeclarativeTools =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockFindDeclarativeTool = jest.fn<(...args: unknown[]) => unknown>();
 jest.unstable_mockModule("../../../subsystems/tools/declarative.js", () => ({
   loadDeclarativeTools: mockLoadDeclarativeTools,
   findDeclarativeTool: mockFindDeclarativeTool,
 }));
 
-const mockGetApiKeyForRequest = jest.fn() as any;
-const mockGetProviderRuntimeHeaders = jest.fn() as any;
-const mockGetReasoningConfig = jest.fn() as any;
-const mockStartTransformersProgressPolling = jest.fn() as any;
+const mockGetApiKeyForRequest =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+const mockGetProviderRuntimeHeaders =
+  jest.fn<(...args: unknown[]) => unknown>();
+const mockGetReasoningConfig = jest.fn<(...args: unknown[]) => unknown>();
+const mockStartTransformersProgressPolling =
+  jest.fn<(...args: unknown[]) => unknown>();
 jest.unstable_mockModule("./operations/provider.js", () => ({
   getApiKeyForRequest: mockGetApiKeyForRequest,
   getProviderRuntimeHeaders: mockGetProviderRuntimeHeaders,
@@ -47,23 +61,48 @@ jest.unstable_mockModule("./operations/provider.js", () => ({
   startTransformersProgressPolling: mockStartTransformersProgressPolling,
 }));
 
-const mockCompactContext = jest.fn() as any;
+const mockCompactContext = jest.fn<(...args: unknown[]) => Promise<unknown>>();
 jest.unstable_mockModule("./compactContext.js", () => ({
   compactContext: mockCompactContext,
 }));
 
-const mockDeliverResponse = jest.fn() as any;
+const mockDeliverResponse = jest.fn<(...args: unknown[]) => Promise<unknown>>();
 jest.unstable_mockModule("./deliverResponse.js", () => ({
   deliverResponse: mockDeliverResponse,
 }));
 
-const mockHandleWorkerMessage = jest.fn() as any;
+const mockDispatchSubagentInvoke =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
+jest.unstable_mockModule("./dispatchSubagentInvoke.js", () => ({
+  dispatchSubagentInvoke: mockDispatchSubagentInvoke,
+}));
+
+const mockHandleWorkerMessage =
+  jest.fn<(...args: unknown[]) => Promise<unknown>>();
 jest.unstable_mockModule("./handleWorkerMessage.js", () => ({
   handleWorkerMessage: mockHandleWorkerMessage,
 }));
 
+const mockDiscoverSkills = jest.fn<(...args: unknown[]) => Promise<unknown>>();
+jest.unstable_mockModule(
+  "../../../subsystems/skills/discoverSkills.js",
+  () => ({
+    discoverSkills: mockDiscoverSkills,
+  }),
+);
+
+jest.unstable_mockModule(
+  "../../../subsystems/providers/builtin-ai-tasks.js",
+  () => ({
+    ensureBuiltinAiPolyfills: mockEnsureBuiltinAiPolyfills,
+  }),
+);
+
 jest.unstable_mockModule("../../../config/config.js", () => ({
-  CONFIG_KEYS: { STORAGE_HANDLE: "STORAGE_HANDLE" },
+  CONFIG_KEYS: {
+    STORAGE_HANDLE: "STORAGE_HANDLE",
+    PROMPT_API_FALLBACK_MODEL: "PROMPT_API_FALLBACK_MODEL",
+  },
   OPFS_ROOT: "shadowclaw",
   DEFAULT_GROUP_ID: "br:main",
   DEFAULT_MAX_ITERATIONS: 50,
@@ -121,7 +160,7 @@ jest.unstable_mockModule("../../../db/getConfig.js", () => ({
 }));
 
 jest.unstable_mockModule("../../../db/db.js", () => ({
-  getDb: jest.fn<any>().mockResolvedValue(null),
+  getDb: jest.fn<() => Promise<null>>().mockResolvedValue(null),
 }));
 
 jest.unstable_mockModule("../../../db/groups.js", () => ({
@@ -138,25 +177,40 @@ jest.unstable_mockModule("../../../storage/readGroupFile.js", () => ({
   readGroupFile: mockReadGroupFile,
 }));
 
+interface MockTokenUsage {
+  inputTokens?: number;
+  cacheReadTokens?: number;
+  outputTokens?: number;
+}
+
+const mockOrchestratorStore = {
+  getPeerState: jest.fn<() => Record<string, unknown> | undefined>(),
+  tokenUsage: null as MockTokenUsage | null,
+};
+
 jest.unstable_mockModule("../../../stores/orchestrator.js", () => ({
-  orchestratorStore: {
-    getPeerState: jest.fn(),
-    tokenUsage: null,
-  },
+  orchestratorStore: mockOrchestratorStore,
 }));
 
-jest.unstable_mockModule("../../../stores/tools.js", () => ({
-  toolsStore: {
-    allTools: [{ name: "tool1" }],
-    enabledTools: [{ name: "tool1" }],
-    refreshDeclarativeTools: jest.fn(async (db: any, groupId: any) => {
-      const res = await mockLoadDeclarativeTools(db, groupId);
+const mockToolsStore = {
+  allTools: [{ name: "tool1" }],
+  enabledTools: [{ name: "tool1" }],
+  systemPromptOverride: undefined as string | undefined,
+  refreshDeclarativeTools: jest.fn(
+    async (db: ShadowClawDatabase, groupId: string) => {
+      const res = (await mockLoadDeclarativeTools(db, groupId)) as {
+        tools?: Array<{ name: string }>;
+      };
       return res?.tools || [];
-    }),
-    isDeclarativeToolEnabled: jest.fn(
-      (name: string) => name !== "disabled_decl_tool",
-    ),
-  },
+    },
+  ),
+  isDeclarativeToolEnabled: jest.fn(
+    (name: string) => name !== "disabled_decl_tool",
+  ),
+};
+
+jest.unstable_mockModule("../../../stores/tools.js", () => ({
+  toolsStore: mockToolsStore,
 }));
 
 jest.unstable_mockModule(
@@ -208,17 +262,24 @@ jest.unstable_mockModule("../../../worker/utils/system-prompt.js", () => ({
 const { invokeAgent } = await import("./invokeAgent.js");
 
 describe("invokeAgent", () => {
-  let mockOrchestrator: any;
-  let mockDb: any;
+  let mockOrchestrator: Orchestrator;
+  let mockDb: ShadowClawDatabase;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    mockDb = {};
+    mockDb = {} as unknown as ShadowClawDatabase;
+    mockOrchestratorStore.tokenUsage = null;
+    mockOrchestratorStore.getPeerState.mockReturnValue(undefined);
+
+    mockToolsStore.allTools = [{ name: "tool1" }];
+    mockToolsStore.enabledTools = [{ name: "tool1" }];
+    mockToolsStore.systemPromptOverride = undefined;
+
     mockOrchestrator = {
-      inFlightTriggerByGroup: new Map(),
-      inFlightEffectiveProviderByGroup: new Map(),
-      pendingScheduledTasks: new Set(),
-      schedulerTriggeredGroups: new Set(),
+      inFlightTriggerByGroup: new Map<string, string>(),
+      inFlightEffectiveProviderByGroup: new Map<string, unknown>(),
+      pendingScheduledTasks: new Set<string>(),
+      schedulerTriggeredGroups: new Set<string>(),
       setState: jest.fn(),
       router: { setTyping: jest.fn() },
       events: { emit: jest.fn() },
@@ -229,14 +290,18 @@ describe("invokeAgent", () => {
       contextCompressionEnabled: false,
       maxTokens: 1000,
       maxIterations: 5,
-      getApiKeyForSpecificProvider: (jest.fn() as any).mockResolvedValue("key"),
+      getApiKeyForSpecificProvider: jest
+        .fn<() => Promise<string>>()
+        .mockResolvedValue("key"),
       rateLimitAutoAdapt: false,
       rateLimitCallsPerMinute: 60,
       streamingEnabled: true,
-      createProviderRequestId: jest.fn().mockReturnValue("req-123"),
+      createProviderRequestId: jest
+        .fn<() => string>()
+        .mockReturnValue("req-123"),
       agentWorker: { postMessage: jest.fn() },
-      promptControllers: new Map(),
-    };
+      promptControllers: new Map<string, AbortController>(),
+    } as unknown as Orchestrator;
 
     mockGetChannelTypeForGroup.mockReturnValue("web");
     mockGetApiKeyForRequest.mockResolvedValue("key");
@@ -244,7 +309,10 @@ describe("invokeAgent", () => {
     mockGetReasoningConfig.mockReturnValue({});
     mockCompactContext.mockResolvedValue(undefined);
     mockDeliverResponse.mockResolvedValue(undefined);
+    mockDispatchSubagentInvoke.mockResolvedValue(undefined);
     mockHandleWorkerMessage.mockResolvedValue(undefined);
+    mockDiscoverSkills.mockResolvedValue({ skills: [] });
+    mockEnsureBuiltinAiPolyfills.mockResolvedValue(undefined);
     mockStartTransformersProgressPolling.mockReturnValue(undefined);
 
     mockGetConfig.mockResolvedValue("storage-handle");
@@ -264,8 +332,8 @@ describe("invokeAgent", () => {
       tools: [],
       diagnostics: [],
     });
-    mockGetProvider.mockImplementation((id: string) => ({
-      defaultModel: "default-" + id,
+    mockGetProvider.mockImplementation((id: unknown) => ({
+      defaultModel: "default-" + String(id),
       supportsStreaming: true,
       format: "openai",
     }));
@@ -279,7 +347,7 @@ describe("invokeAgent", () => {
       "thinking",
       "group1",
     );
-    expect(mockOrchestrator.router.setTyping).toHaveBeenCalledWith(
+    expect(mockOrchestrator.router?.setTyping).toHaveBeenCalledWith(
       "group1",
       true,
     );
@@ -289,6 +357,21 @@ describe("invokeAgent", () => {
     });
   });
 
+  it("should gracefully handle readGroupFile errors", async () => {
+    mockReadGroupFile.mockRejectedValue(new Error("File not found"));
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "invoke",
+        payload: expect.objectContaining({
+          memory: "",
+        }),
+      }),
+    );
+  });
+
   it("should save scheduled task message", async () => {
     mockUlid.mockReturnValue("msg-id");
 
@@ -314,7 +397,7 @@ describe("invokeAgent", () => {
     );
   });
 
-  it("should auto-compact context if usage is high", async () => {
+  it("should auto-compact context if usage is high and trigger compactContext", async () => {
     mockBuildConversationMessages.mockResolvedValue(new Array(15).fill({}));
     mockBuildDynamicContext.mockReturnValue({
       messages: [],
@@ -330,7 +413,6 @@ describe("invokeAgent", () => {
       expect.any(Object),
     );
 
-    // Fast-forward microtasks
     await new Promise((resolve) => setTimeout(resolve, 0));
     expect(mockCompactContext).toHaveBeenCalledWith(
       mockOrchestrator,
@@ -340,10 +422,6 @@ describe("invokeAgent", () => {
   });
 
   it("should blend actual token usage to prevent meter regression", async () => {
-    const { orchestratorStore } =
-      await import("../../../stores/orchestrator.js");
-
-    // Set a baseline heuristic that is low (e.g. 50 + 100 = 150)
     mockBuildDynamicContext.mockReturnValue({
       messages: [],
       estimatedTokens: 50,
@@ -351,8 +429,7 @@ describe("invokeAgent", () => {
       truncatedCount: 0,
     });
 
-    // Mock the actual token usage from the API to be much higher (e.g. a huge cached prompt)
-    (orchestratorStore as any).tokenUsage = {
+    mockOrchestratorStore.tokenUsage = {
       inputTokens: 100,
       cacheReadTokens: 3000,
       outputTokens: 50,
@@ -360,28 +437,179 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    // The emitted context usage should use the actual token footprint (100 + 3000 + 50 = 3150)
-    // rather than falling back to the 150 heuristic
     expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
       "context-usage",
       expect.objectContaining({
         estimatedTokens: 3150,
       }),
     );
+  });
+
+  it("should handle token usage zero fallbacks when fields are undefined", async () => {
+    mockBuildDynamicContext.mockReturnValue({
+      messages: [],
+      estimatedTokens: 50,
+      usagePercent: 5,
+      truncatedCount: 0,
+    });
+
+    mockOrchestratorStore.tokenUsage = {};
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
+      "context-usage",
+      expect.objectContaining({
+        estimatedTokens: 250,
+      }),
+    );
+  });
+
+  it("should pass peer state to buildSystemPrompt when available", async () => {
+    mockOrchestratorStore.getPeerState.mockReturnValue({ peerId: "node-1" });
 
-    // Cleanup
-    (orchestratorStore as any).tokenUsage = null;
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockBuildSystemPrompt).toHaveBeenCalledWith(
+      "Assistant",
+      "memory content",
+      expect.any(Array),
+      undefined,
+      { peerId: "node-1" },
+      [],
+      { groupId: "group1" },
+    );
   });
 
-  it("should handle transformers_js_browser", async () => {
+  it("should append activate_skill to activeTools when skills are discovered", async () => {
+    mockDiscoverSkills.mockResolvedValue({
+      skills: [{ name: "weather-skill" }],
+    });
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          enabledTools: expect.arrayContaining([
+            expect.objectContaining({ name: "tool1" }),
+            activate_skill,
+          ]),
+        }),
+      }),
+    );
+  });
+
+  it("should not duplicate activate_skill if already in tools", async () => {
+    mockToolsStore.allTools = [{ name: activate_skill.name }];
+    mockToolsStore.enabledTools = [{ name: activate_skill.name }];
+    mockDiscoverSkills.mockResolvedValue({
+      skills: [{ name: "weather-skill" }],
+    });
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    const call = (
+      mockOrchestrator.agentWorker?.postMessage as unknown as jest.Mock
+    ).mock.calls[0][0] as {
+      payload: { enabledTools: Array<{ name: string }> };
+    };
+    const matching = call.payload.enabledTools.filter(
+      (t) => t.name === activate_skill.name,
+    );
+    expect(matching).toHaveLength(1);
+  });
+
+  it("should handle subagentModelSelectionMode manual", async () => {
+    mockListGroups.mockResolvedValue([
+      { groupId: "group1", subagentModelSelectionMode: "manual" },
+    ]);
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          subagentModelSelectionMode: "manual",
+        }),
+      }),
+    );
+  });
+
+  it("should resolve prompt_api fallback model when prompt api is not supported", async () => {
+    mockListGroups.mockResolvedValue([
+      {
+        groupId: "group1",
+        pinnedProvider: "prompt_api",
+        pinnedModel: "browser-built-in",
+      },
+    ]);
+    mockIsPromptApiSupported.mockReturnValue(false);
+    mockGetConfig.mockImplementation(async (...args: unknown[]) => {
+      const key = args[1] as string;
+      if (key === "PROMPT_API_FALLBACK_MODEL") {
+        return "custom-fallback-model";
+      }
+      return "storage-handle";
+    });
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockGetContextLimit).toHaveBeenCalledWith("custom-fallback-model");
+  });
+
+  it("should default prompt_api fallback model when config has no fallback", async () => {
+    mockListGroups.mockResolvedValue([
+      {
+        groupId: "group1",
+        pinnedProvider: "prompt_api",
+        pinnedModel: "",
+      },
+    ]);
+    mockIsPromptApiSupported.mockReturnValue(false);
+    mockGetConfig.mockImplementation(async (...args: unknown[]) => {
+      const key = args[1] as string;
+      if (key === "PROMPT_API_FALLBACK_MODEL") {
+        return "";
+      }
+      return "storage-handle";
+    });
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockGetContextLimit).toHaveBeenCalledWith(
+      "onnx-community/Qwen3-0.6B-ONNX",
+    );
+  });
+
+  it("should handle transformers_js_browser lifecycle, subagent invocation, and worker message", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "transformers_js_browser" },
     ]);
-    mockInvokeWithTransformersJs.mockResolvedValue(undefined);
+    mockInvokeWithTransformersJs.mockImplementation(
+      async (...args: unknown[]) => {
+        const onMessage = args[5] as (msg: unknown) => Promise<void>;
+        const ctx = args[9] as {
+          invokeSubagent: (payload: unknown) => Promise<void>;
+        };
+        await onMessage({ type: "chunk", data: "test" });
+        await ctx.invokeSubagent({ prompt: "spawn subagent" });
+      },
+    );
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
     expect(mockInvokeWithTransformersJs).toHaveBeenCalled();
+    expect(mockHandleWorkerMessage).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      { type: "chunk", data: "test" },
+    );
+    expect(mockDispatchSubagentInvoke).toHaveBeenCalledWith(
+      mockDb,
+      { prompt: "spawn subagent" },
+      expect.any(AbortSignal),
+    );
     expect(mockOrchestrator.promptControllers.has("group1")).toBe(false);
   });
 
@@ -396,9 +624,10 @@ describe("invokeAgent", () => {
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
     expect(mockDeliverResponse).not.toHaveBeenCalled();
+    expect(mockOrchestrator.promptControllers.has("group1")).toBe(false);
   });
 
-  it("should handle transformers_js_browser error", async () => {
+  it("should handle transformers_js_browser error and non-error thrown", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "transformers_js_browser" },
     ]);
@@ -414,21 +643,49 @@ describe("invokeAgent", () => {
       "group1",
       expect.stringContaining("Transformers error"),
     );
+
+    mockInvokeWithTransformersJs.mockRejectedValue("string failure");
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      expect.stringContaining("string failure"),
+    );
   });
 
-  it("should handle prompt_api", async () => {
+  it("should handle prompt_api lifecycle, subagent invocation, and worker message", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "prompt_api" },
     ]);
     mockIsPromptApiSupported.mockReturnValue(true);
-    mockInvokeWithPromptApi.mockResolvedValue(undefined);
+    mockInvokeWithPromptApi.mockImplementation(async (...args: unknown[]) => {
+      const onMessage = args[5] as (msg: unknown) => Promise<void>;
+      const ctx = args[8] as {
+        invokeSubagent: (payload: unknown) => Promise<void>;
+      };
+      await onMessage({ type: "prompt-chunk" });
+      await ctx.invokeSubagent({ prompt: "prompt-sub" });
+    });
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
     expect(mockInvokeWithPromptApi).toHaveBeenCalled();
+    expect(mockHandleWorkerMessage).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      { type: "prompt-chunk" },
+    );
+    expect(mockDispatchSubagentInvoke).toHaveBeenCalledWith(
+      mockDb,
+      { prompt: "prompt-sub" },
+      expect.any(AbortSignal),
+    );
+    expect(mockOrchestrator.promptControllers.has("group1")).toBe(false);
   });
 
-  it("should handle prompt_api not supported", async () => {
+  it("should polyfill and handle prompt_api unsupported error", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "prompt_api" },
     ]);
@@ -436,6 +693,7 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
+    expect(mockEnsureBuiltinAiPolyfills).toHaveBeenCalled();
     expect(mockDeliverResponse).toHaveBeenCalledWith(
       mockOrchestrator,
       mockDb,
@@ -444,16 +702,66 @@ describe("invokeAgent", () => {
     );
   });
 
-  it("should handle litert_lm_browser", async () => {
+  it("should handle prompt_api abort and errors", async () => {
+    mockListGroups.mockResolvedValue([
+      { groupId: "group1", pinnedProvider: "prompt_api" },
+    ]);
+    mockIsPromptApiSupported.mockReturnValue(true);
+
+    const abortErr = new Error("Abort");
+    abortErr.name = "AbortError";
+    mockInvokeWithPromptApi.mockRejectedValueOnce(abortErr);
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).not.toHaveBeenCalled();
+
+    mockInvokeWithPromptApi.mockRejectedValueOnce(new Error("Prompt crash"));
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      expect.stringContaining("Prompt crash"),
+    );
+
+    mockInvokeWithPromptApi.mockRejectedValueOnce("prompt string error");
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      expect.stringContaining("prompt string error"),
+    );
+  });
+
+  it("should handle litert_lm_browser lifecycle, subagent invocation, and worker message", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "litert_lm_browser" },
     ]);
     mockIsLiteRtLmSupported.mockReturnValue(true);
-    mockInvokeWithLiteRtLm.mockResolvedValue(undefined);
+    mockInvokeWithLiteRtLm.mockImplementation(async (...args: unknown[]) => {
+      const onMessage = args[5] as (msg: unknown) => Promise<void>;
+      const ctx = args[9] as {
+        invokeSubagent: (payload: unknown) => Promise<void>;
+      };
+      await onMessage({ type: "litert-chunk" });
+      await ctx.invokeSubagent({ prompt: "litert-sub" });
+    });
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
     expect(mockInvokeWithLiteRtLm).toHaveBeenCalled();
+    expect(mockHandleWorkerMessage).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      { type: "litert-chunk" },
+    );
+    expect(mockDispatchSubagentInvoke).toHaveBeenCalledWith(
+      mockDb,
+      { prompt: "litert-sub" },
+      expect.any(AbortSignal),
+    );
+    expect(mockOrchestrator.promptControllers.has("group1")).toBe(false);
   });
 
   it("should handle litert_lm_browser not supported", async () => {
@@ -472,10 +780,90 @@ describe("invokeAgent", () => {
     );
   });
 
+  it("should handle litert_lm_browser abort and errors", async () => {
+    mockListGroups.mockResolvedValue([
+      { groupId: "group1", pinnedProvider: "litert_lm_browser" },
+    ]);
+    mockIsLiteRtLmSupported.mockReturnValue(true);
+
+    const abortErr = new Error("Abort");
+    abortErr.name = "AbortError";
+    mockInvokeWithLiteRtLm.mockRejectedValueOnce(abortErr);
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).not.toHaveBeenCalled();
+
+    mockInvokeWithLiteRtLm.mockRejectedValueOnce(new Error("LiteRT crash"));
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      expect.stringContaining("LiteRT crash"),
+    );
+
+    mockInvokeWithLiteRtLm.mockRejectedValueOnce("litert string err");
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+    expect(mockDeliverResponse).toHaveBeenCalledWith(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      expect.stringContaining("litert string err"),
+    );
+  });
+
+  it("should stream when provider format is anthropic and streaming is enabled", async () => {
+    mockListGroups.mockResolvedValue([
+      { groupId: "group1", pinnedProvider: "anthropic-provider" },
+    ]);
+    mockGetProvider.mockImplementation(() => ({
+      defaultModel: "claude-3-haiku",
+      supportsStreaming: true,
+      format: "anthropic",
+    }));
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          streaming: true,
+        }),
+      }),
+    );
+  });
+
+  it("should not stream when streaming is disabled or provider does not support it", async () => {
+    mockOrchestrator.streamingEnabled = false;
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          streaming: false,
+        }),
+      }),
+    );
+  });
+
+  it("should mark isScheduledTask when group is in schedulerTriggeredGroups", async () => {
+    mockOrchestrator.schedulerTriggeredGroups.add("group1");
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          isScheduledTask: true,
+        }),
+      }),
+    );
+  });
+
   it("should post message to worker for other providers", async () => {
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "invoke",
       payload: expect.objectContaining({
         apiKey: "key",
@@ -508,22 +896,46 @@ describe("invokeAgent", () => {
     );
   });
 
-  it("should use pinned provider and model from group", async () => {
+  it("should use pinned provider and defaultModel when pinnedModel is not specified", async () => {
     mockListGroups.mockResolvedValue([
       {
         groupId: "group1",
         pinnedProvider: "pinned-provider",
-        pinnedModel: "pinned-model",
       },
     ]);
+    mockGetProvider.mockReturnValue({
+      defaultModel: "provider-default-model",
+      supportsStreaming: true,
+      format: "openai",
+    });
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "invoke",
       payload: expect.objectContaining({
         provider: "pinned-provider",
-        model: "pinned-model",
+        model: "provider-default-model",
+      }),
+    });
+  });
+
+  it("should fall back to orchestrator model when pinnedProvider lookup returns undefined", async () => {
+    mockListGroups.mockResolvedValue([
+      {
+        groupId: "group1",
+        pinnedProvider: "unknown-provider",
+      },
+    ]);
+    mockGetProvider.mockReturnValue(undefined);
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
+      type: "invoke",
+      payload: expect.objectContaining({
+        provider: "unknown-provider",
+        model: "test-model",
       }),
     });
   });
@@ -541,7 +953,7 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith(
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         type: "invoke",
         payload: expect.objectContaining({
@@ -566,7 +978,7 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith(
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         type: "invoke",
         payload: expect.objectContaining({
@@ -577,6 +989,29 @@ describe("invokeAgent", () => {
     );
   });
 
+  it("should fall back to orchestrator maxTokens when pinnedMaxTokens is invalid", async () => {
+    mockOrchestrator.maxTokens = 5000;
+    mockListGroups.mockResolvedValue([
+      {
+        groupId: "group1",
+        pinnedProvider: "test-provider",
+        pinnedModel: "test-model",
+        pinnedMaxTokens: -10,
+      },
+    ]);
+
+    await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
+
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "invoke",
+        payload: expect.objectContaining({
+          maxTokens: 5000,
+        }),
+      }),
+    );
+  });
+
   it("should start transformers local polling", async () => {
     mockListGroups.mockResolvedValue([
       { groupId: "group1", pinnedProvider: "transformers_js_local" },
@@ -589,10 +1024,10 @@ describe("invokeAgent", () => {
       mockOrchestrator.events,
       "group1",
     );
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalled();
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalled();
   });
 
-  it("should skip history when freshContext is true", async () => {
+  it("should skip history when freshContext is true and messages exist", async () => {
     mockBuildConversationMessages.mockResolvedValue([
       { role: "user", content: "old message 1" },
       { role: "assistant", content: "old message 2" },
@@ -613,10 +1048,27 @@ describe("invokeAgent", () => {
     );
   });
 
+  it("should seed freshContext with trigger message when conversation history is empty", async () => {
+    mockBuildConversationMessages.mockResolvedValue([]);
+
+    await invokeAgent(
+      mockOrchestrator,
+      mockDb,
+      "group1",
+      "first trigger",
+      true,
+    );
+
+    expect(mockBuildDynamicContext).toHaveBeenCalledWith(
+      [{ role: "user", content: "first trigger" }],
+      expect.any(Object),
+    );
+  });
+
   it("should pass subagentTask true when subagent is true", async () => {
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello", false, true);
 
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "invoke",
       payload: expect.objectContaining({
         subagentTask: true,
@@ -628,28 +1080,25 @@ describe("invokeAgent", () => {
     mockUlid.mockReturnValue("subagent-ulid");
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello", false, true);
 
-    // Assert that thinking state and typing indicators are set on the subagent group ID
     expect(mockOrchestrator.setState).toHaveBeenCalledWith(
       "thinking",
       "subagent:subagent-ulid",
     );
-    expect(mockOrchestrator.router.setTyping).toHaveBeenCalledWith(
+    expect(mockOrchestrator.router?.setTyping).toHaveBeenCalledWith(
       "subagent:subagent-ulid",
       true,
     );
 
-    // Assert that the parent group ID is NOT set to thinking or typing
     expect(mockOrchestrator.setState).not.toHaveBeenCalledWith(
       "thinking",
       "group1",
     );
-    expect(mockOrchestrator.router.setTyping).not.toHaveBeenCalledWith(
+    expect(mockOrchestrator.router?.setTyping).not.toHaveBeenCalledWith(
       "group1",
       true,
     );
 
-    // Assert that the agent worker is invoked with the subagent group ID
-    expect(mockOrchestrator.agentWorker.postMessage).toHaveBeenCalledWith({
+    expect(mockOrchestrator.agentWorker?.postMessage).toHaveBeenCalledWith({
       type: "invoke",
       payload: expect.objectContaining({
         groupId: "subagent:subagent-ulid",
@@ -675,10 +1124,12 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    const postCall = mockOrchestrator.agentWorker.postMessage.mock.calls[0][0];
-    const enabledToolNames = postCall.payload.enabledTools.map(
-      (t: any) => t.name,
-    );
+    const postCall = (
+      mockOrchestrator.agentWorker?.postMessage as unknown as jest.Mock
+    ).mock.calls[0][0] as {
+      payload: { enabledTools: Array<{ name: string }> };
+    };
+    const enabledToolNames = postCall.payload.enabledTools.map((t) => t.name);
     expect(enabledToolNames).toContain("generate_random_number");
     expect(enabledToolNames).toContain("tool1");
     expect(enabledToolNames).not.toContain("unpinned_declarative_tool");
@@ -700,10 +1151,12 @@ describe("invokeAgent", () => {
 
     await invokeAgent(mockOrchestrator, mockDb, "group1", "hello");
 
-    const postCall = mockOrchestrator.agentWorker.postMessage.mock.calls[0][0];
-    const enabledToolNames = postCall.payload.enabledTools.map(
-      (t: any) => t.name,
-    );
+    const postCall = (
+      mockOrchestrator.agentWorker?.postMessage as unknown as jest.Mock
+    ).mock.calls[0][0] as {
+      payload: { enabledTools: Array<{ name: string }> };
+    };
+    const enabledToolNames = postCall.payload.enabledTools.map((t) => t.name);
     expect(enabledToolNames).toContain("generate_random_number");
     expect(enabledToolNames).not.toContain("disabled_decl_tool");
   });