@tyvm/knowhow 0.0.89 → 0.0.91

package/src/services/modules/types.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "../../plugins/types";
+import { Plugin, PluginContext } from "../../plugins/types";
 import { IAgent } from "../../agents/interface";
 import { Tool } from "../../clients/types";
 import { Config } from "../../types";
@@ -7,6 +7,7 @@ import { AgentService } from "../AgentService";
 import { PluginService } from "../../plugins/plugins";
 import { AIClient } from "../../clients";
 import { ToolsService } from "../Tools";
+import { MediaProcessorService } from "../MediaProcessorService";
 
 /*
  *
@@ -29,7 +30,8 @@ export interface ModuleTool {
 
 export type ModuleAgent = IAgent;
 
-export type ModulePlugin = { name: string; plugin: Plugin };
+export type PluginConstructor = new (context: PluginContext) => Plugin;
+export type ModulePlugin = { name: string; plugin: PluginConstructor };
 
 export type ModuleClient = {
   client: GenericClient;
@@ -47,6 +49,7 @@ export interface ModuleContext {
   Plugins: PluginService;
   Clients: AIClient;
   Tools: ToolsService;
+  MediaProcessor?: MediaProcessorService;
 }
 
 export interface KnowhowModule {

package/src/services/script-execution/ScriptExecutor.ts

@@ -96,7 +96,7 @@ export class ScriptExecutor {
 
     try {
       // Validate script
-      const validation = policyEnforcer.validateScript(request.script);
+      const validation = policyEnforcer.validateScript(request.script, policy.allowNetworkAccess);
       if (!validation.valid) {
         tracer.emitEvent("script_validation_failed", {
           issues: validation.issues,
@@ -240,8 +240,9 @@ export class ScriptExecutor {
       tracer.emitEvent("script_execution_start", {});
 
       // Execute the script and get the result
+      // Note: do NOT set timeout here — it kills the isolate while awaiting host async promises.
+      // The outer executeWithTimeout wrapper handles wall-clock timeout instead.
       const result = await compiledScript.run(vmContext, {
-        timeout: policyEnforcer.getQuotas().maxExecutionTimeMs,
         promise: true,
         copy: true,
       });
@@ -280,13 +281,29 @@ export class ScriptExecutor {
         `__host_${name}`,
         new ivm.Reference(async (...args: any[]) => {
           const result = await fn(...args);
-          return new ivm.ExternalCopy(result).copyInto();
+          const safeResult = result !== undefined ? result : null;
+          const plainResult =
+            safeResult !== null && typeof safeResult === 'object'
+              ? JSON.parse(JSON.stringify(safeResult))
+              : safeResult;
+          // copyInto() transfers the value into the isolate heap so it's directly usable
+          return new ivm.ExternalCopy(plainResult).copyInto();
         })
       );
+      // Use applySyncPromise so the script isolate suspends and yields the Node.js event loop
+      // back to the host while waiting for async host operations (MCP stdio calls etc.).
+      // Without this, the ivm isolate blocks the event loop and stdio-based MCP transports
+      // can never deliver their responses → deadlock.
       await vmContext.eval(`
         globalThis.${name} = (...a) =>
-          __host_${name}.apply(undefined, a,
-            { arguments: { copy: true }, result: { promise: true, copy: true } });
+          new Promise((resolve, reject) => {
+            try {
+              // applySyncPromise does not support result options — the Reference fn returns ExternalCopy
+              const result = __host_${name}.applySyncPromise(undefined, a,
+                { arguments: { copy: true } });
+              resolve(result);
+            } catch(e) { reject(e); }
+          });
       `);
     };
 
@@ -308,11 +325,13 @@ export class ScriptExecutor {
 
     // Expose async sandbox functions
     await exposeAsync("callTool", async (tool, params) => {
-      const { functionResp } = await sandboxContext.callTool(
-        tool as string,
-        params
-      );
-      return functionResp;
+      try {
+        const result = await sandboxContext.callTool(tool as string, params);
+        const { functionResp } = result;
+        return functionResp !== undefined ? functionResp : null;
+      } catch (err) {
+        throw err;
+      }
     });
     await exposeAsync("llm", (messages, options) =>
       sandboxContext.llm(messages, options || {})

package/src/services/script-execution/ScriptPolicy.ts

@@ -163,7 +163,7 @@ export class ScriptPolicyEnforcer {
   /**
    * Validate script content for security issues
    */
-  validateScript(scriptContent: string): { valid: boolean; issues: string[] } {
+  validateScript(scriptContent: string, allowNetworkAccess?: boolean): { valid: boolean; issues: string[] } {
     const issues: string[] = [];
 
     // Check for dangerous patterns
@@ -176,11 +176,15 @@ export class ScriptPolicyEnforcer {
       /Function\s*\(/gi,          // Function constructor
       /setTimeout/gi,             // setTimeout
       /setInterval/gi,            // setInterval
-      /fetch\s*\(/gi,             // Direct fetch calls
       /XMLHttpRequest/gi,         // XHR
       /WebSocket/gi,              // WebSocket
     ];
 
+    // Block direct fetch calls when network access is not explicitly allowed
+    if (!allowNetworkAccess) {
+      dangerousPatterns.push(/fetch\s*\(/gi);
+    }
+
     for (const pattern of dangerousPatterns) {
       if (pattern.test(scriptContent)) {
         issues.push(`Potentially dangerous pattern detected: ${pattern.source}`);

package/src/types.ts

@@ -265,6 +265,7 @@ export const Models = {
     Gemini_31_Pro_Preview: "gemini-3.1-pro-preview",
     Gemini_31_Flash_Image_Preview: "gemini-3.1-flash-image-preview",
     Gemini_31_Flash_Lite_Preview: "gemini-3.1-flash-lite-preview",
+    Gemini_31_Flash_Live_Preview: "gemini-3.1-flash-live-preview",
     Gemini_3_Flash_Preview: "gemini-3-flash-preview",
     Gemini_3_Pro_Image_Preview: "gemini-3-pro-image-preview",
     // Gemini 2.5

package/src/utils/http.ts

@@ -0,0 +1,127 @@
+/**
+ * Thin native-fetch wrapper that returns { data: T } for backward compatibility.
+ * Replaces axios throughout the codebase.
+ */
+
+export interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  headers: Headers;
+}
+
+export class HttpError extends Error {
+  constructor(
+    public status: number,
+    public response: Response,
+    message: string
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+async function parseBody<T>(response: Response, responseType?: string): Promise<T> {
+  if (responseType === "arraybuffer") {
+    return (await response.arrayBuffer()) as unknown as T;
+  }
+  if (responseType === "stream") {
+    return response.body as unknown as T;
+  }
+  const text = await response.text();
+  if (!text) return undefined as unknown as T;
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return text as unknown as T;
+  }
+}
+
+async function request<T = any>(
+  url: string,
+  options: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    responseType?: "json" | "arraybuffer" | "stream" | "text";
+    params?: Record<string, any>;
+    /** Timeout in milliseconds. Default: 30000 (30s). Use 0 to disable. */
+    timeout?: number;
+  } = {}
+): Promise<HttpResponse<T>> {
+  const { method = "GET", headers = {}, body, responseType, params, timeout = 30000 } = options;
+
+  let fullUrl = url;
+  if (params && Object.keys(params).length > 0) {
+    const searchParams = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined && v !== null) {
+        searchParams.set(k, String(v));
+      }
+    }
+    fullUrl = `${url}?${searchParams.toString()}`;
+  }
+
+  const fetchOptions: RequestInit = {
+    method,
+    headers: { ...headers },
+  };
+
+  if (body !== undefined && body !== null) {
+    if (body instanceof Buffer || body instanceof Uint8Array || typeof (body as any).pipe === "function") {
+      // Stream or buffer — pass directly, Node fetch supports ReadableStream
+      fetchOptions.body = body;
+    } else if (typeof body === "object" && !(body instanceof FormData)) {
+      fetchOptions.body = JSON.stringify(body);
+      (fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/json";
+    } else {
+      fetchOptions.body = body;
+    }
+  }
+
+  // Apply timeout via AbortController
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  if (timeout > 0) {
+    const controller = new AbortController();
+    fetchOptions.signal = controller.signal;
+    timeoutId = setTimeout(() => {
+      controller.abort();
+    }, timeout);
+  }
+
+  let response: Response;
+  try {
+    response = await fetch(fullUrl, fetchOptions);
+  } catch (e: any) {
+    if (e?.name === "AbortError") {
+      throw new HttpError(408, undefined as any, `Request timeout after ${timeout}ms: ${url}`);
+    }
+    throw e;
+  } finally {
+    if (timeoutId !== undefined) clearTimeout(timeoutId);
+  }
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new HttpError(response.status, response, `HTTP ${response.status}: ${text}`);
+  }
+
+  const data = await parseBody<T>(response, responseType);
+
+  return { data, status: response.status, headers: response.headers };
+}
+
+export const http = {
+  get: <T = any>(url: string, options?: Omit<Parameters<typeof request>[1], "method">) =>
+    request<T>(url, { ...options, method: "GET" }),
+  post: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
+    request<T>(url, { ...options, method: "POST", body }),
+  put: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
+    request<T>(url, { ...options, method: "PUT", body }),
+  patch: <T = any>(url: string, body?: any, options?: Omit<Parameters<typeof request>[1], "method" | "body">) =>
+    request<T>(url, { ...options, method: "PATCH", body }),
+  delete: <T = any>(url: string, options?: Omit<Parameters<typeof request>[1], "method">) =>
+    request<T>(url, { ...options, method: "DELETE" }),
+  isHttpError: (e: any): e is HttpError => e instanceof HttpError,
+};
+
+export default http;

package/src/workers/auth/PasskeySetup.ts

@@ -1,4 +1,4 @@
-import axios from "axios";
+import http from "../../utils/http";
 import { KNOWHOW_API_URL } from "../../services/KnowhowClient";
 import { openBrowser } from "../../auth/browserLogin";
 import { Spinner } from "../../auth/spinner";
@@ -93,21 +93,18 @@ export class PasskeySetupService {
 
   private async createSetupSession(jwt: string): Promise<PasskeySetupSession> {
     try {
-      const response = await axios.post<PasskeySetupSession>(
+      const response = await http.post<PasskeySetupSession>(
         `${this.baseUrl}/api/worker/passkey/setup/session`,
         {},
         {
           headers: { Authorization: `Bearer ${jwt}` },
-          timeout: 10000,
         }
       );
       return response.data;
     } catch (error) {
-      if (axios.isAxiosError(error)) {
+      if (http.isHttpError(error)) {
         throw new Error(
-          `Failed to create passkey setup session: ${
-            error.response?.data?.message || error.message
-          }`
+          `Failed to create passkey setup session: ${error.message}`
         );
       }
       throw error;
@@ -125,9 +122,8 @@ export class PasskeySetupService {
       attempt++;
 
       try {
-        const response = await axios.get<PasskeySetupStatus>(
-          `${this.baseUrl}/api/worker/passkey/setup/status/${sessionId}`,
-          { timeout: 10000 }
+        const response = await http.get<PasskeySetupStatus>(
+          `${this.baseUrl}/api/worker/passkey/setup/status/${sessionId}`
         );
 
         const { status, credential } = response.data;
@@ -140,7 +136,7 @@ export class PasskeySetupService {
           );
         }
       } catch (error) {
-        if (axios.isAxiosError(error) && error.code === "ECONNABORTED") {
+        if (http.isHttpError(error) && error.status === 408) {
           // Timeout — keep polling
         } else if (!(error instanceof Error && error.message.includes("expired"))) {
           // Re-throw non-timeout, non-expected errors

package/tests/clients/AIClient.test.ts

@@ -154,12 +154,18 @@ describe("AIClient", () => {
     });
 
     it("should find model by detection in registered providers", () => {
-      aiClient.registerClient("test", new FakeClient());
-      aiClient.registerModels("test", ["gpt-4-turbo", "gpt-4-vision"]);
+      // Register an explicit myopenai provider with a gpt-4 prefix model
+      aiClient.registerClient("myopenai", new FakeClient());
+      aiClient.registerModels("myopenai", ["gpt-4-turbo", "gpt-4-vision"]);
 
+      // "another" provider (registered in beforeEach) has exact "gpt-4" match
+      // "myopenai" has prefix-matches "gpt-4-turbo" and "gpt-4-vision"
+      // findModel finds the first provider with a model matching the prefix "gpt-4"
       const result = aiClient.detectProviderModel("", "gpt-4");
-      expect(result.provider).toBe("openai"); // Real openai provider takes precedence
-      expect(result.model).toBe("gpt-4.1-2025-04-14"); // Actual model found by prefix match
+      // Some provider should be found that has a gpt-4 model
+      expect(result.provider).toBeTruthy();
+      // The found model should start with "gpt-4"
+      expect(result.model).toMatch(/^gpt-4/);
     });
 
     it("should handle model with provider prefix when provider is empty", () => {
@@ -175,15 +181,16 @@ describe("AIClient", () => {
     });
 
     it("should detect real provider when model exists", () => {
-      aiClient.registerClient("test", new FakeClient());
-      aiClient.registerModels("test", ["claude-3-opus"]);
+      // Register an anthropic provider explicitly so we don't rely on env vars
+      aiClient.registerClient("anthropic", new FakeClient());
+      aiClient.registerModels("anthropic", ["claude-3-opus-20240229"]);
 
       // Test with provider prefix that gets stripped
       const result = aiClient.detectProviderModel(
         "",
         "anthropic/claude-3-opus-20240229"
       );
-      expect(result.provider).toBe("anthropic"); // Real anthropic provider found
+      expect(result.provider).toBe("anthropic"); // anthropic provider found
       expect(result.model).toBe("claude-3-opus-20240229");
     });
   });
@@ -208,15 +215,13 @@ describe("AIClient", () => {
       it("should return all registered models from all providers", () => {
         const allModels = aiClient.listAllModels();
         expect(typeof allModels).toBe("object");
-        // listAllModels() only returns models from real providers that have API keys
-        // Our test clients are not included in the listAllModels() output
-        // But we can verify real providers are present
+        // Verify our registered test providers are present
         expect(Object.keys(allModels).length).toBeGreaterThan(0);
-        // Real providers like openai, anthropic should be present
+        // The test providers registered in beforeEach should be present
         const providers = Object.keys(allModels);
         expect(
           providers.some((p) =>
-            ["openai", "anthropic", "google", "xai"].includes(p)
+            ["fake", "another"].includes(p)
           )
         ).toBe(true);
       });
@@ -470,8 +475,10 @@ describe("AIClient", () => {
     });
 
     it("should handle provider stripping with complex model names", () => {
-      // Test detection with real providers that exist in AIClient
-      // AIClient should find the real anthropic provider for claude models
+      // Register providers explicitly so we don't rely on env vars
+      aiClient.registerClient("anthropic", new FakeClient());
+      aiClient.registerModels("anthropic", ["claude-3-opus-20240229"]);
+
       const detection1 = aiClient.detectProviderModel(
         "",
         "anthropic/claude-3-opus-20240229"
@@ -484,14 +491,10 @@ describe("AIClient", () => {
         "",
         "openai/non-existent-model"
       );
-      // Should either return empty strings or fallback to defaults
+      // Should return original values when no match found
       expect(detection2).toBeDefined();
-      if (detection2?.provider === "") {
-        expect(detection2?.model).toBe("openai/non-existent-model");
-      } else {
-        expect(detection2?.provider).toBe("openai");
-        expect(detection2?.model).toBe("gpt-5");
-      }
+      expect(detection2?.provider).toBe("");
+      expect(detection2?.model).toBe("openai/non-existent-model");
     });
 
     it("should handle model prefix matching edge cases", () => {

package/tests/manual/file-edits/figma.test.ts

@@ -1,70 +1,3 @@
-import { FigmaPlugin } from "../../../src/plugins/figma";
-
-const figmaToken = "test_token"; // This should be the actual testing token
-const figmaPlugin = new FigmaPlugin();
-
-const exampleFigmaFileUrl =
-  "https://www.figma.com/file/iK2ggDLxl94Q4q0FKUdlmM/Guilds";
-const exampleNodeId = "52-717";
-const exampleNodeIds = [exampleNodeId];
-
-const expectedApiResponse = {
-  name: "Guilds",
-  nodes: { "52-717": { document: {} } },
-};
-
-describe("FigmaPlugin", () => {
-  describe("extractUrls", () => {
-    it("should extract Figma file URLs from a given text", () => {
-      const text = `Design can be found here: ${exampleFigmaFileUrl}`;
-      expect(figmaPlugin.extractUrls(text)).toEqual([exampleFigmaFileUrl]);
-    });
-  });
-
-  describe("extractFileIdFromUrl", () => {
-    it("should extract file ID from Figma URL", () => {
-      expect(figmaPlugin.extractFileIdFromUrl(exampleFigmaFileUrl)).toBe(
-        "iK2ggDLxl94Q4q0FKUdlmM"
-      );
-    });
-  });
-
-  describe("parseNodeIdsFromUrl", () => {
-    it("should extract node IDs from Figma URL", () => {
-      const urlWithNode = exampleFigmaFileUrl + "?node-id=" + exampleNodeId;
-      expect(figmaPlugin.parseNodeIdsFromUrl(urlWithNode)).toEqual(
-        exampleNodeIds
-      );
-    });
-  });
-
-  describe("loadFigmaData", () => {
-    it("should make an API call and return Figma data", async () => {
-      const data = await figmaPlugin.loadFigmaData(
-        exampleFigmaFileUrl + "?node-id=" + exampleNodeId
-      );
-      expect(data).toBeDefined;
-    });
-  });
-
-  describe("embed", () => {
-    it("should return a minimal embedding array", async () => {
-      const embeddings = await figmaPlugin.embed(
-        `Here's the design file: ${exampleFigmaFileUrl}?node-id=${exampleNodeId}`
-      );
-      expect(embeddings).toBeInstanceOf(Array);
-      expect(embeddings).toHaveLength(1);
-      const nodeId = exampleNodeId.replace("-", ":");
-      console.log(JSON.parse(embeddings[0].text));
-      /*
-       *expect(embeddings[0].text).toEqual(
-       *  JSON.stringify({
-       *    id: expectedApiResponse.name,
-       *    metadata: {},
-       *    text: JSON.stringify(expectedApiResponse),
-       *  })
-       *);
-       */
-    });
-  });
-});
+// FigmaPlugin tests moved to @tyvm/knowhow-plugin-figma package
+// Install and configure @tyvm/knowhow-plugin-figma to use Figma integration
+describe.skip("FigmaPlugin (moved to @tyvm/knowhow-plugin-figma)", () => {});

package/tests/plugins/language/languagePlugin-content-triggers.test.ts

@@ -18,6 +18,7 @@ jest.mock("../../../src/services/EventService", () => ({
   EventService: jest.fn().mockImplementation(() => ({
     on: jest.fn(),
     emit: jest.fn(),
+    log: jest.fn(),
   })),
 }));
 
@@ -54,6 +55,7 @@ describe("LanguagePlugin - Content-Based Triggering", () => {
         eventHandlers.set(event, handler);
       }),
       emit: jest.fn(),
+      log: jest.fn(),
     };
 
     mockPluginService = {

package/tests/plugins/language/languagePlugin.test.ts

@@ -73,6 +73,7 @@ describe("LanguagePlugin", () => {
     const mockEventService = {
       on: jest.fn(),
       emit: jest.fn(),
+      log: jest.fn(),
     };
     const mockListPlugins = jest.fn().mockReturnValue(["github", "asana"]);
     const mockCall = jest.fn().mockResolvedValue(["mocked plugin response"]);
@@ -362,6 +363,7 @@ describe("LanguagePlugin", () => {
     const mockEventService = {
       on: jest.fn(),
       emit: jest.fn(),
+      log: jest.fn(),
     };
     const mockPluginService = new MockedPluginService({} as any);
     const mockListPlugins = jest.fn().mockReturnValue(["github"]);

package/tests/processors/ToolResponseCache.test.ts

@@ -371,7 +371,7 @@ describe("ToolResponseCache", () => {
       const result = await cache.queryToolResponse("missing_id", ".test");
       expect(result).toContain("Error: No tool response found");
       expect(result).toContain("missing_id");
-      expect(result).toContain("Available IDs:");
+      expect(result).toContain("Available toolCallIds:");
     });
 
     it("should handle invalid JQ queries with error message", async () => {
@@ -698,7 +698,7 @@ describe("ToolResponseCache", () => {
       const result = await cache.tailToolResponse("missing_id");
       expect(result).toContain("Error: No tool response found");
       expect(result).toContain("missing_id");
-      expect(result).toContain("Available IDs:");
+      expect(result).toContain("Available toolCallIds:");
     });
 
     it("should handle lines option of 0", async () => {

package/tests/test.spec.ts

@@ -1,18 +1,4 @@
 // Global mocks that need to be hoisted before any imports
-jest.mock("tree-sitter", () => {
-  return jest.fn().mockImplementation(() => ({
-    setLanguage: jest.fn(),
-    parse: jest.fn(() => ({ rootNode: { toString: () => "mock tree" } })),
-  }));
-});
-jest.mock("tree-sitter-typescript", () => ({ typescript: jest.fn() }));
-jest.mock("tree-sitter-javascript", () => ({ javascript: jest.fn() }));
-jest.mock("../src/plugins/tree-sitter/parser", () => ({
-  LanguageAgnosticParser: jest.fn(),
-}));
-jest.mock("../src/plugins/tree-sitter/editor", () => ({
-  TreeEditor: jest.fn(),
-}));
 jest.mock("../src/services/S3", () => ({
   S3Service: jest.fn().mockImplementation(() => ({
     uploadFile: jest.fn(),

package/tests/unit/modules/moduleLoading.test.ts

@@ -132,7 +132,7 @@ describe("ModulesService.loadModulesFromConfig", () => {
   });
 
   it("should load plugins from a module", async () => {
-    const mockPlugin = {
+    const mockPluginInstance = {
       meta: { key: "test-plugin", name: "Test Plugin" },
       isEnabled: () => true,
       enable: () => {},
@@ -141,8 +141,10 @@ describe("ModulesService.loadModulesFromConfig", () => {
       callMany: () => Promise.resolve(""),
       embed: () => Promise.resolve([]),
     };
+    // ModulePlugin expects a constructor (class), not an instance
+    const MockPluginClass = jest.fn().mockImplementation(() => mockPluginInstance);
     const mockModule = makeModule({
-      plugins: [{ name: "test-plugin", plugin: mockPlugin as any }],
+      plugins: [{ name: "test-plugin", plugin: MockPluginClass as any }],
     });
 
     const service = new ModulesService();
@@ -153,13 +155,14 @@ describe("ModulesService.loadModulesFromConfig", () => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
         for (const plugin of mockModule.plugins) {
-          resolvedCtx.Plugins.registerPlugin(plugin.name, plugin.plugin);
+          const instance = new (plugin.plugin as any)(resolvedCtx);
+          resolvedCtx.Plugins.registerPlugin(plugin.name, instance);
         }
       });
 
     await service.loadModulesFromConfig(context);
 
-    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith("test-plugin", mockPlugin);
+    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith("test-plugin", mockPluginInstance);
     spy.mockRestore();
   });
 

package/tests/unit/plugins/pluginLoading.test.ts

@@ -11,6 +11,7 @@ function makeContext(): PluginContext {
       emit: jest.fn(),
       emitBlocking: jest.fn(),
       emitNonBlocking: jest.fn(),
+      log: jest.fn(),
     } as any,
   } as PluginContext;
 }
@@ -110,8 +111,8 @@ describe("PluginService.loadPluginsFromConfig", () => {
   });
 
   it("should log a warning and not crash when a plugin fails to load", async () => {
-    const service = new PluginService(makeContext());
-    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const context = makeContext();
+    const service = new PluginService(context);
 
     service.loadPlugin = jest.fn().mockRejectedValue(new Error("Module not found"));
 
@@ -122,12 +123,11 @@ describe("PluginService.loadPluginsFromConfig", () => {
     } as unknown as Config;
 
     await expect(service.loadPluginsFromConfig(config)).resolves.toBeUndefined();
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(context.Events.log).toHaveBeenCalledWith(
+      "PluginService",
       expect.stringContaining("broken"),
-      expect.any(String)
+      "warn"
     );
-
-    warnSpy.mockRestore();
   });
 
   it("should load each plugin with the correct spec string", async () => {