llm-mock-server 1.0.2 → 1.0.3

package/test/formats/responses.test.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect } from "vitest";
 import { responsesFormat } from "../../src/formats/responses/index.js";
-import type { ResponsesEvent, ResponsesComplete, ResponsesError } from "../../src/formats/responses/schema.js";
+import type {
+  ResponsesEvent,
+  ResponsesComplete,
+  ResponsesError,
+} from "../../src/formats/responses/schema.js";
 
 function parse<T>(chunk: { data: string }): T {
   return JSON.parse(chunk.data) as T;
@@ -9,7 +13,10 @@ function parse<T>(chunk: { data: string }): T {
 describe("Responses Format", () => {
   describe("parseRequest", () => {
     it("parses string input", () => {
-      const req = responsesFormat.parseRequest({ model: "codex-mini", input: "Hello world" });
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: "Hello world",
+      });
       expect(req.format).toBe("responses");
       expect(req.model).toBe("codex-mini");
       expect(req.lastMessage).toBe("Hello world");
@@ -40,7 +47,12 @@ describe("Responses Format", () => {
     it("parses content block arrays", () => {
       const req = responsesFormat.parseRequest({
         model: "codex-mini",
-        input: [{ role: "user", content: [{ type: "input_text", text: "Hello there" }] }],
+        input: [
+          {
+            role: "user",
+            content: [{ type: "input_text", text: "Hello there" }],
+          },
+        ],
       });
       expect(req.lastMessage).toBe("Hello there");
     });
@@ -49,7 +61,14 @@ describe("Responses Format", () => {
       const req = responsesFormat.parseRequest({
         model: "codex-mini",
         input: "read file",
-        tools: [{ type: "function", name: "read_file", description: "Read", parameters: {} }],
+        tools: [
+          {
+            type: "function",
+            name: "read_file",
+            description: "Read",
+            parameters: {},
+          },
+        ],
       });
       expect(req.tools).toHaveLength(1);
       expect(req.toolNames).toEqual(["read_file"]);
@@ -60,7 +79,11 @@ describe("Responses Format", () => {
         model: "codex-mini",
         input: [
           { role: "user", content: "hi" },
-          { type: "function_call_output", call_id: "call_abc", output: "result" },
+          {
+            type: "function_call_output",
+            call_id: "call_abc",
+            output: "result",
+          },
         ],
       });
       expect(req.lastToolCallId).toBe("call_abc");
@@ -69,10 +92,15 @@ describe("Responses Format", () => {
     it("handles content blocks with non-text types (image, etc.)", () => {
       const req = responsesFormat.parseRequest({
         model: "codex-mini",
-        input: [{ role: "user", content: [
-          { type: "image_url", url: "https://example.com/img.png" },
-          { type: "input_text", text: "describe this" },
-        ]}],
+        input: [
+          {
+            role: "user",
+            content: [
+              { type: "image_url", url: "https://example.com/img.png" },
+              { type: "input_text", text: "describe this" },
+            ],
+          },
+        ],
       });
       expect(req.lastMessage).toBe("describe this");
     });
@@ -100,10 +128,7 @@ describe("Responses Format", () => {
       const req = responsesFormat.parseRequest({
         model: "codex-mini",
         input: "hi",
-        tools: [
-          { type: "function", name: "run_code" },
-          { type: "web_search" },
-        ],
+        tools: [{ type: "function", name: "run_code" }, { type: "web_search" }],
       });
       expect(req.tools).toHaveLength(1);
       expect(req.tools![0]!.name).toBe("run_code");
@@ -114,17 +139,23 @@ describe("Responses Format", () => {
     it("starts with response.created and response.in_progress", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
       expect(parse<ResponsesEvent>(chunks[0]!).type).toBe("response.created");
-      expect(parse<ResponsesEvent>(chunks[1]!).type).toBe("response.in_progress");
+      expect(parse<ResponsesEvent>(chunks[1]!).type).toBe(
+        "response.in_progress",
+      );
     });
 
     it("ends with response.completed", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
-      expect(parse<ResponsesEvent>(chunks.at(-1)!).type).toBe("response.completed");
+      expect(parse<ResponsesEvent>(chunks.at(-1)!).type).toBe(
+        "response.completed",
+      );
     });
 
     it("assigns incrementing sequence_number to every event", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
-      const seqNumbers = chunks.map((c) => parse<ResponsesEvent>(c).sequence_number!);
+      const seqNumbers = chunks.map(
+        (c) => parse<ResponsesEvent>(c).sequence_number!,
+      );
       for (let i = 1; i < seqNumbers.length; i++) {
         expect(seqNumbers[i]).toBe(seqNumbers[i - 1]! + 1);
       }
@@ -135,14 +166,17 @@ describe("Responses Format", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
       const created = parse<ResponsesEvent>(chunks[0]!).response?.created_at;
       const inProgress = parse<ResponsesEvent>(chunks[1]!).response?.created_at;
-      const completed = parse<ResponsesEvent>(chunks.at(-1)!).response?.created_at;
+      const completed = parse<ResponsesEvent>(chunks.at(-1)!).response
+        ?.created_at;
       expect(created).toBe(inProgress);
       expect(created).toBe(completed);
     });
 
     it("produces text delta events with item_id", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
-      const delta = chunks.find((c) => parse<ResponsesEvent>(c).type === "response.output_text.delta");
+      const delta = chunks.find(
+        (c) => parse<ResponsesEvent>(c).type === "response.output_text.delta",
+      );
       expect(delta).toBeDefined();
       const data = parse<ResponsesEvent>(delta!);
       expect(data.delta).toBe("Hello");
@@ -153,26 +187,34 @@ describe("Responses Format", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
       const added = chunks.find((c) => {
         const d = parse<ResponsesEvent>(c);
-        return d.type === "response.output_item.added" && d.item?.type === "message";
+        return (
+          d.type === "response.output_item.added" && d.item?.type === "message"
+        );
       });
       expect(parse<ResponsesEvent>(added!).item?.status).toBe("in_progress");
 
       const done = chunks.find((c) => {
         const d = parse<ResponsesEvent>(c);
-        return d.type === "response.output_item.done" && d.item?.type === "message";
+        return (
+          d.type === "response.output_item.done" && d.item?.type === "message"
+        );
       });
       expect(parse<ResponsesEvent>(done!).item?.status).toBe("completed");
     });
 
     it("includes annotations on output_text parts", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
-      const partAdded = chunks.find((c) => parse<ResponsesEvent>(c).type === "response.content_part.added");
+      const partAdded = chunks.find(
+        (c) => parse<ResponsesEvent>(c).type === "response.content_part.added",
+      );
       expect(parse<ResponsesEvent>(partAdded!).part?.annotations).toEqual([]);
     });
 
     it("includes content_part.done event with full text", () => {
       const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
-      const partDone = chunks.find((c) => parse<ResponsesEvent>(c).type === "response.content_part.done");
+      const partDone = chunks.find(
+        (c) => parse<ResponsesEvent>(c).type === "response.content_part.done",
+      );
       expect(partDone).toBeDefined();
       expect(parse<ResponsesEvent>(partDone!).part?.text).toBe("Hello");
     });
@@ -189,7 +231,9 @@ describe("Responses Format", () => {
       expect(types).toContain("response.reasoning_summary_text.done");
       expect(types).toContain("response.reasoning_summary_part.done");
 
-      const reasoningDone = types.indexOf("response.reasoning_summary_text.done");
+      const reasoningDone = types.indexOf(
+        "response.reasoning_summary_text.done",
+      );
       const textDelta = types.indexOf("response.output_text.delta");
       expect(reasoningDone).toBeLessThan(textDelta);
     });
@@ -205,9 +249,14 @@ describe("Responses Format", () => {
     });
 
     it("accumulates text in completed output", () => {
-      const chunks = responsesFormat.serialize({ text: "hello world" }, "codex-mini");
+      const chunks = responsesFormat.serialize(
+        { text: "hello world" },
+        "codex-mini",
+      );
       const completed = parse<ResponsesEvent>(chunks.at(-1)!);
-      expect(completed.response?.output[0]!.content?.[0]?.text).toBe("hello world");
+      expect(completed.response?.output[0]!.content?.[0]?.text).toBe(
+        "hello world",
+      );
     });
 
     it("produces function_call events for tool calls", () => {
@@ -217,7 +266,10 @@ describe("Responses Format", () => {
       );
       const fnAdded = chunks.find((c) => {
         const d = parse<ResponsesEvent>(c);
-        return d.type === "response.output_item.added" && d.item?.type === "function_call";
+        return (
+          d.type === "response.output_item.added" &&
+          d.item?.type === "function_call"
+        );
       });
       expect(fnAdded).toBeDefined();
       const item = parse<ResponsesEvent>(fnAdded!).item!;
@@ -242,7 +294,10 @@ describe("Responses Format", () => {
 
   describe("serializeComplete (non-streaming)", () => {
     it("produces correct top-level structure", () => {
-      const result = responsesFormat.serializeComplete({ text: "Hello" }, "codex-mini") as ResponsesComplete;
+      const result = responsesFormat.serializeComplete(
+        { text: "Hello" },
+        "codex-mini",
+      ) as ResponsesComplete;
       expect(result.object).toBe("response");
       expect(result.status).toBe("completed");
       expect(result.model).toBe("codex-mini");
@@ -250,7 +305,10 @@ describe("Responses Format", () => {
     });
 
     it("includes message output item with status and annotations", () => {
-      const result = responsesFormat.serializeComplete({ text: "Hello, world!" }, "codex-mini") as ResponsesComplete;
+      const result = responsesFormat.serializeComplete(
+        { text: "Hello, world!" },
+        "codex-mini",
+      ) as ResponsesComplete;
       const msg = result.output[0]!;
       expect(msg.type).toBe("message");
       expect(msg.status).toBe("completed");
@@ -286,13 +344,20 @@ describe("Responses Format", () => {
         { text: "hi", usage: { input: 20, output: 15 } },
         "codex-mini",
       ) as ResponsesComplete;
-      expect(result.usage).toEqual({ input_tokens: 20, output_tokens: 15, total_tokens: 35 });
+      expect(result.usage).toEqual({
+        input_tokens: 20,
+        output_tokens: 15,
+        total_tokens: 35,
+      });
     });
   });
 
   describe("serializeError", () => {
     it("produces Responses error format", () => {
-      const result = responsesFormat.serializeError({ status: 500, message: "Internal error" }) as ResponsesError;
+      const result = responsesFormat.serializeError({
+        status: 500,
+        message: "Internal error",
+      }) as ResponsesError;
       expect(result.error.message).toBe("Internal error");
     });
   });

package/test/history.test.ts

@@ -140,9 +140,18 @@ describe("RequestHistory", () => {
 
   describe("where()", () => {
     beforeEach(() => {
-      history.record(makeReq({ lastMessage: "hello", model: "gpt-5.4" }), "rule-a");
-      history.record(makeReq({ lastMessage: "world", model: "claude-4" }), undefined);
-      history.record(makeReq({ lastMessage: "hello again", model: "gpt-5.4" }), "rule-b");
+      history.record(
+        makeReq({ lastMessage: "hello", model: "gpt-5.4" }),
+        "rule-a",
+      );
+      history.record(
+        makeReq({ lastMessage: "world", model: "claude-4" }),
+        undefined,
+      );
+      history.record(
+        makeReq({ lastMessage: "hello again", model: "gpt-5.4" }),
+        "rule-b",
+      );
     });
 
     it("filters entries by predicate", () => {
@@ -153,13 +162,17 @@ describe("RequestHistory", () => {
     });
 
     it("filters by request properties", () => {
-      const claudeRequests = history.where((e) => e.request.model === "claude-4");
+      const claudeRequests = history.where(
+        (e) => e.request.model === "claude-4",
+      );
       expect(claudeRequests).toHaveLength(1);
       expect(claudeRequests[0].request.lastMessage).toBe("world");
     });
 
     it("returns an empty array when nothing matches", () => {
-      const none = history.where((e) => e.request.lastMessage === "nonexistent");
+      const none = history.where(
+        (e) => e.request.lastMessage === "nonexistent",
+      );
       expect(none).toEqual([]);
     });
 

package/test/loader.test.ts

@@ -40,11 +40,15 @@ describe("Loader", () => {
       await loadRulesFromPath(rulesPath, { engine });
       expect(engine.ruleCount).toBe(2);
 
-      const match1 = engine.match(makeReq({ lastMessage: "Please explain recursion" }));
+      const match1 = engine.match(
+        makeReq({ lastMessage: "Please explain recursion" }),
+      );
       if (!match1) throw new Error("expected match for 'explain'");
       expect(match1.resolve).toBe("A function that calls itself.");
 
-      const match2 = engine.match(makeReq({ model: "gpt-5.4", lastMessage: "hello" }));
+      const match2 = engine.match(
+        makeReq({ model: "gpt-5.4", lastMessage: "hello" }),
+      );
       expect(match2).toBeDefined();
     });
 
@@ -61,7 +65,9 @@ describe("Loader", () => {
       );
 
       await loadRulesFromPath(rulesPath, { engine });
-      const match = engine.match(makeReq({ lastMessage: "explain polymorphism" }));
+      const match = engine.match(
+        makeReq({ lastMessage: "explain polymorphism" }),
+      );
       expect(match).toBeDefined();
     });
 
@@ -73,7 +79,9 @@ describe("Loader", () => {
       );
 
       await loadRulesFromPath(rulesPath, { engine });
-      expect(engine.match(makeReq({ lastMessage: "hello world" }))).toBeDefined();
+      expect(
+        engine.match(makeReq({ lastMessage: "hello world" })),
+      ).toBeDefined();
     });
 
     it("loads rules with times", async () => {
@@ -123,7 +131,9 @@ describe("Loader", () => {
         }`,
       );
 
-      await expect(loadRulesFromPath(rulesPath, { engine })).rejects.toThrow("Unknown template");
+      await expect(loadRulesFromPath(rulesPath, { engine })).rejects.toThrow(
+        "Unknown template",
+      );
     });
 
     it("loads a replies sequence", async () => {
@@ -161,7 +171,9 @@ describe("Loader", () => {
       let capturedFallback: unknown;
       await loadRulesFromPath(rulesPath, {
         engine,
-        setFallback: (reply) => { capturedFallback = reply; },
+        setFallback: (reply) => {
+          capturedFallback = reply;
+        },
       });
 
       expect(capturedFallback).toBe("Default reply.");
@@ -183,7 +195,9 @@ describe("Loader", () => {
       await loadRulesFromPath(handlerPath, { engine });
       expect(engine.ruleCount).toBe(1);
 
-      const match = engine.match(makeReq({ lastMessage: "summarize this article" }));
+      const match = engine.match(
+        makeReq({ lastMessage: "summarize this article" }),
+      );
       if (!match) throw new Error("expected match for 'summarize'");
       expect(match.resolve).toBeTypeOf("function");
     });
@@ -233,9 +247,14 @@ describe("Loader", () => {
 
     it("throws on invalid handler file (missing match/respond)", async () => {
       const handlerPath = join(tmpDir, "bad.ts");
-      await writeFile(handlerPath, `export default { mach: () => true, respond: () => "hi" };`);
+      await writeFile(
+        handlerPath,
+        `export default { mach: () => true, respond: () => "hi" };`,
+      );
 
-      await expect(loadRulesFromPath(handlerPath, { engine })).rejects.toThrow("Invalid handler file");
+      await expect(loadRulesFromPath(handlerPath, { engine })).rejects.toThrow(
+        "Invalid handler file",
+      );
     });
 
     it("loads fallback from handler file", async () => {
@@ -252,7 +271,9 @@ describe("Loader", () => {
       let capturedFallback: unknown;
       await loadRulesFromPath(handlerPath, {
         engine,
-        setFallback: (reply) => { capturedFallback = reply; },
+        setFallback: (reply) => {
+          capturedFallback = reply;
+        },
       });
 
       expect(capturedFallback).toBe("Default reply.");
@@ -262,14 +283,8 @@ describe("Loader", () => {
 
   describe("directory loading", () => {
     it("loads all .json5 files from a directory", async () => {
-      await writeFile(
-        join(tmpDir, "a.json5"),
-        `[{ when: "aaa", reply: "A" }]`,
-      );
-      await writeFile(
-        join(tmpDir, "b.json5"),
-        `[{ when: "bbb", reply: "B" }]`,
-      );
+      await writeFile(join(tmpDir, "a.json5"), `[{ when: "aaa", reply: "A" }]`);
+      await writeFile(join(tmpDir, "b.json5"), `[{ when: "bbb", reply: "B" }]`);
 
       await loadRulesFromPath(tmpDir, { engine });
       expect(engine.ruleCount).toBe(2);

package/test/logger.test.ts

@@ -260,18 +260,68 @@ describe("Logger", () => {
   });
 
   describe("each level as constructor argument", () => {
-    const cases: Array<{ level: LogLevel; expectError: boolean; expectWarn: boolean; expectInfo: boolean; expectDebug: boolean }> = [
-      { level: "none",    expectError: false, expectWarn: false, expectInfo: false, expectDebug: false },
-      { level: "error",   expectError: true,  expectWarn: false, expectInfo: false, expectDebug: false },
-      { level: "warning", expectError: true,  expectWarn: true,  expectInfo: false, expectDebug: false },
-      { level: "info",    expectError: true,  expectWarn: true,  expectInfo: true,  expectDebug: false },
-      { level: "debug",   expectError: true,  expectWarn: true,  expectInfo: true,  expectDebug: true  },
-      { level: "all",     expectError: true,  expectWarn: true,  expectInfo: true,  expectDebug: true  },
+    const cases: Array<{
+      level: LogLevel;
+      expectError: boolean;
+      expectWarn: boolean;
+      expectInfo: boolean;
+      expectDebug: boolean;
+    }> = [
+      {
+        level: "none",
+        expectError: false,
+        expectWarn: false,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "error",
+        expectError: true,
+        expectWarn: false,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "warning",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "info",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: false,
+      },
+      {
+        level: "debug",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: true,
+      },
+      {
+        level: "all",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: true,
+      },
     ];
 
-    for (const { level, expectError, expectWarn, expectInfo, expectDebug } of cases) {
+    for (const {
+      level,
+      expectError,
+      expectWarn,
+      expectInfo,
+      expectDebug,
+    } of cases) {
       it(`level '${level}' enables the correct methods`, () => {
-        const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+        const errorSpy = vi
+          .spyOn(console, "error")
+          .mockImplementation(() => {});
         const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
         const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});