llm-mock-server 1.0.1 → 1.0.3

package/test/formats/parse-helpers.test.ts

@@ -0,0 +1,315 @@
+import { describe, expect, it } from "vitest";
+import {
+  splitText,
+  genId,
+  toolId,
+  shouldEmitText,
+  finishReason,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../../src/formats/serialize-helpers.js";
+import {
+  isStreaming,
+  buildMockRequest,
+} from "../../src/formats/request-helpers.js";
+import type { ReplyObject } from "../../src/types.js";
+
+describe("parse-helpers", () => {
+  describe("constants", () => {
+    it("MS_PER_SECOND is 1000", () => {
+      expect(MS_PER_SECOND).toBe(1000);
+    });
+
+    it("DEFAULT_USAGE has expected shape", () => {
+      expect(DEFAULT_USAGE).toEqual({ input: 10, output: 5 });
+    });
+  });
+
+  describe("splitText", () => {
+    it("returns the full string when chunkSize is 0", () => {
+      expect(splitText("hello", 0)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when chunkSize is negative", () => {
+      expect(splitText("hello", -1)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when text fits in one chunk", () => {
+      expect(splitText("hello", 10)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when chunkSize equals text length", () => {
+      expect(splitText("hello", 5)).toEqual(["hello"]);
+    });
+
+    it("splits text into equal chunks", () => {
+      expect(splitText("abcdef", 2)).toEqual(["ab", "cd", "ef"]);
+    });
+
+    it("handles a remainder chunk", () => {
+      expect(splitText("abcde", 2)).toEqual(["ab", "cd", "e"]);
+    });
+
+    it("splits into single characters with chunkSize 1", () => {
+      expect(splitText("abc", 1)).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns single-element array for empty string", () => {
+      expect(splitText("", 5)).toEqual([""]);
+    });
+  });
+
+  describe("genId", () => {
+    it("starts with the given prefix", () => {
+      const id = genId("chatcmpl");
+      expect(id).toMatch(/^chatcmpl_/);
+    });
+
+    it("generates unique ids", () => {
+      const a = genId("msg");
+      const b = genId("msg");
+      // Could collide if Date.now() returns the same ms, but format is still valid
+      expect(a).toMatch(/^msg_[a-z0-9]+$/);
+      expect(b).toMatch(/^msg_[a-z0-9]+$/);
+    });
+  });
+
+  describe("toolId", () => {
+    it("uses the tool's own id when present", () => {
+      expect(toolId({ id: "call_abc" }, "call", 0)).toBe("call_abc");
+    });
+
+    it("generates an id when tool has no id", () => {
+      const id = toolId({}, "call", 2);
+      expect(id).toMatch(/^call_[a-z0-9]+_2$/);
+    });
+
+    it("generates an id when tool id is undefined", () => {
+      const id = toolId({ id: undefined }, "call", 0);
+      expect(id).toMatch(/^call_[a-z0-9]+_0$/);
+    });
+  });
+
+  describe("shouldEmitText", () => {
+    it("returns true when reply has text", () => {
+      expect(shouldEmitText({ text: "hello" })).toBe(true);
+    });
+
+    it("returns true when reply has no text, no tools, no reasoning", () => {
+      expect(shouldEmitText({})).toBe(true);
+    });
+
+    it("returns false when reply has only tools", () => {
+      expect(shouldEmitText({ tools: [{ name: "fn", args: {} }] })).toBe(false);
+    });
+
+    it("returns false when reply has only reasoning", () => {
+      expect(shouldEmitText({ reasoning: "thinking..." })).toBe(false);
+    });
+
+    it("returns true when reply has text and tools", () => {
+      expect(
+        shouldEmitText({ text: "hi", tools: [{ name: "fn", args: {} }] }),
+      ).toBe(true);
+    });
+
+    it("returns true for empty text with no tools or reasoning", () => {
+      expect(shouldEmitText({ text: "" })).toBe(true);
+    });
+  });
+
+  describe("finishReason", () => {
+    it("returns onTools when tools are present", () => {
+      const reply: ReplyObject = { tools: [{ name: "fn", args: {} }] };
+      expect(finishReason(reply, "tool_calls", "stop")).toBe("tool_calls");
+    });
+
+    it("returns onStop when no tools", () => {
+      expect(finishReason({ text: "hi" }, "tool_calls", "stop")).toBe("stop");
+    });
+
+    it("returns onStop when tools array is empty", () => {
+      expect(finishReason({ tools: [] }, "tool_calls", "stop")).toBe("stop");
+    });
+
+    it("returns onStop when tools is undefined", () => {
+      expect(finishReason({}, "tool_calls", "stop")).toBe("stop");
+    });
+  });
+
+  describe("isStreaming", () => {
+    it("returns true when stream is true", () => {
+      expect(isStreaming({ stream: true })).toBe(true);
+    });
+
+    it("returns false when stream is false", () => {
+      expect(isStreaming({ stream: false })).toBe(false);
+    });
+
+    it("returns true when stream is absent", () => {
+      expect(isStreaming({})).toBe(true);
+    });
+
+    it("returns true for null body", () => {
+      expect(isStreaming(null)).toBe(true);
+    });
+
+    it("returns true for non-object body", () => {
+      expect(isStreaming("not an object")).toBe(true);
+    });
+
+    it("returns true for undefined body", () => {
+      expect(isStreaming(undefined)).toBe(true);
+    });
+  });
+
+  describe("buildMockRequest", () => {
+    it("builds a minimal request with defaults", () => {
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [{ role: "user", content: "hello" }],
+        undefined,
+        "gpt-4",
+        {
+          messages: [],
+        },
+      );
+
+      expect(result.format).toBe("openai");
+      expect(result.model).toBe("gpt-4");
+      expect(result.streaming).toBe(true);
+      expect(result.lastMessage).toBe("hello");
+      expect(result.systemMessage).toBe("");
+      expect(result.tools).toBeUndefined();
+      expect(result.toolNames).toEqual([]);
+      expect(result.lastToolCallId).toBeUndefined();
+      expect(result.headers).toEqual({});
+      expect(result.path).toBe("");
+    });
+
+    it("uses model from body when provided", () => {
+      const result = buildMockRequest(
+        "anthropic",
+        { model: "claude-sonnet" },
+        [],
+        undefined,
+        "default-model",
+        {},
+      );
+      expect(result.model).toBe("claude-sonnet");
+    });
+
+    it("falls back to default model when body model is empty string", () => {
+      const result = buildMockRequest(
+        "openai",
+        { model: "" },
+        [],
+        undefined,
+        "gpt-4",
+        {},
+      );
+      expect(result.model).toBe("gpt-4");
+    });
+
+    it("extracts last user message", () => {
+      const messages = [
+        { role: "user" as const, content: "first" },
+        { role: "assistant" as const, content: "reply" },
+        { role: "user" as const, content: "second" },
+      ];
+      const result = buildMockRequest(
+        "openai",
+        {},
+        messages,
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.lastMessage).toBe("second");
+    });
+
+    it("extracts system message", () => {
+      const messages = [
+        { role: "system" as const, content: "be helpful" },
+        { role: "user" as const, content: "hi" },
+      ];
+      const result = buildMockRequest(
+        "openai",
+        {},
+        messages,
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.systemMessage).toBe("be helpful");
+    });
+
+    it("extracts tool names", () => {
+      const tools = [
+        { name: "get_weather", parameters: {} },
+        { name: "search", parameters: {} },
+      ];
+      const result = buildMockRequest("openai", {}, [], tools, "m", {});
+      expect(result.toolNames).toEqual(["get_weather", "search"]);
+    });
+
+    it("extracts last tool call id", () => {
+      const messages = [
+        { role: "tool" as const, content: "result1", toolCallId: "call_1" },
+        { role: "tool" as const, content: "result2", toolCallId: "call_2" },
+      ];
+      const result = buildMockRequest(
+        "openai",
+        {},
+        messages,
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.lastToolCallId).toBe("call_2");
+    });
+
+    it("sets streaming to false when stream is false", () => {
+      const result = buildMockRequest(
+        "openai",
+        { stream: false },
+        [],
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.streaming).toBe(false);
+    });
+
+    it("uses provided meta for headers and path", () => {
+      const meta = {
+        headers: { authorization: "Bearer sk-test" },
+        path: "/v1/chat/completions",
+      };
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [],
+        undefined,
+        "m",
+        {},
+        meta,
+      );
+      expect(result.headers).toEqual({ authorization: "Bearer sk-test" });
+      expect(result.path).toBe("/v1/chat/completions");
+    });
+
+    it("returns empty lastMessage when no user messages", () => {
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [{ role: "system" as const, content: "sys" }],
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.lastMessage).toBe("");
+    });
+  });
+});

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");
@@ -275,10 +333,10 @@ describe("Responses Format", () => {
         "codex-mini",
       ) as ResponsesComplete;
       const fnCall = result.output.find((o) => o.type === "function_call");
-      expect(fnCall).toBeDefined();
-      expect(fnCall!.name).toBe("read_file");
-      expect(fnCall!.status).toBe("completed");
-      expect(fnCall!.call_id).toBeTypeOf("string");
+      if (!fnCall) throw new Error("expected function_call output");
+      expect(fnCall.name).toBe("read_file");
+      expect(fnCall.status).toBe("completed");
+      expect(fnCall.call_id).toBeTypeOf("string");
     });
 
     it("includes usage tokens", () => {
@@ -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/helpers/make-req.ts

@@ -0,0 +1,18 @@
+import type { MockRequest } from "../../src/types.js";
+
+export function makeReq(overrides: Partial<MockRequest> = {}): MockRequest {
+  return {
+    format: "openai",
+    model: "gpt-5.4",
+    streaming: true,
+    messages: [{ role: "user", content: "hello" }],
+    lastMessage: "hello",
+    systemMessage: "",
+    toolNames: [],
+    lastToolCallId: undefined,
+    raw: {},
+    headers: {},
+    path: "/v1/chat/completions",
+    ...overrides,
+  };
+}