llm-mock-server 1.0.2 → 1.0.3

package/test/formats/anthropic.test.ts

@@ -1,8 +1,11 @@
 import { describe, it, expect } from "vitest";
 import { anthropicFormat } from "../../src/formats/anthropic/index.js";
 import type {
-  AnthropicMessageStart, AnthropicBlockEvent, AnthropicDelta,
-  AnthropicComplete, AnthropicError,
+  AnthropicMessageStart,
+  AnthropicBlockEvent,
+  AnthropicDelta,
+  AnthropicComplete,
+  AnthropicError,
 } from "../../src/formats/anthropic/schema.js";
 
 function parse<T>(chunk: { data: string }): T {
@@ -40,7 +43,9 @@ describe("Anthropic Format", () => {
       const req = anthropicFormat.parseRequest({
         model: "claude-sonnet-4-6",
         max_tokens: 1024,
-        messages: [{ role: "user", content: [{ type: "text", text: "Hello there" }] }],
+        messages: [
+          { role: "user", content: [{ type: "text", text: "Hello there" }] },
+        ],
       });
       expect(req.lastMessage).toBe("Hello there");
     });
@@ -50,7 +55,13 @@ describe("Anthropic Format", () => {
         model: "claude-sonnet-4-6",
         max_tokens: 1024,
         messages: [{ role: "user", content: "read file" }],
-        tools: [{ name: "read_file", description: "Read", input_schema: { type: "object" } }],
+        tools: [
+          {
+            name: "read_file",
+            description: "Read",
+            input_schema: { type: "object" },
+          },
+        ],
       });
       expect(req.tools).toHaveLength(1);
       expect(req.tools![0]!.name).toBe("read_file");
@@ -75,7 +86,16 @@ describe("Anthropic Format", () => {
         max_tokens: 1024,
         messages: [
           { role: "user", content: "hi" },
-          { role: "user", content: [{ type: "tool_result", tool_use_id: "toolu_123", content: "result" }] },
+          {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: "toolu_123",
+                content: "result",
+              },
+            ],
+          },
         ],
       });
       expect(req.lastToolCallId).toBe("toolu_123");
@@ -84,7 +104,10 @@ describe("Anthropic Format", () => {
 
   describe("serialize (streaming)", () => {
     it("produces correct event sequence for text", () => {
-      const chunks = anthropicFormat.serialize({ text: "Hello" }, "claude-sonnet-4-6");
+      const chunks = anthropicFormat.serialize(
+        { text: "Hello" },
+        "claude-sonnet-4-6",
+      );
       const events = chunks.map((c) => c.event);
       expect(events).toEqual([
         "message_start",
@@ -97,7 +120,10 @@ describe("Anthropic Format", () => {
     });
 
     it("message_start contains correct structure", () => {
-      const chunks = anthropicFormat.serialize({ text: "Hello" }, "claude-sonnet-4-6");
+      const chunks = anthropicFormat.serialize(
+        { text: "Hello" },
+        "claude-sonnet-4-6",
+      );
       const msg = parse<AnthropicMessageStart>(chunks[0]!);
       expect(msg.message).toMatchObject({
         type: "message",
@@ -111,7 +137,10 @@ describe("Anthropic Format", () => {
     });
 
     it("text block uses index 0 when no reasoning", () => {
-      const chunks = anthropicFormat.serialize({ text: "Hello" }, "claude-sonnet-4-6");
+      const chunks = anthropicFormat.serialize(
+        { text: "Hello" },
+        "claude-sonnet-4-6",
+      );
       const blockStart = chunks.find((c) => c.event === "content_block_start");
       const data = parse<AnthropicBlockEvent>(blockStart!);
       expect(data.index).toBe(0);
@@ -143,7 +172,9 @@ describe("Anthropic Format", () => {
         return parse<AnthropicBlockEvent>(c).delta?.type === "thinking_delta";
       });
       expect(thinkingDelta).toBeDefined();
-      expect(parse<AnthropicBlockEvent>(thinkingDelta!).delta?.thinking).toBe("Let me think");
+      expect(parse<AnthropicBlockEvent>(thinkingDelta!).delta?.thinking).toBe(
+        "Let me think",
+      );
     });
 
     it("closes thinking block before text block starts", () => {
@@ -151,9 +182,18 @@ describe("Anthropic Format", () => {
         { text: "answer", reasoning: "think" },
         "claude-sonnet-4-6",
       );
-      const events = chunks.map((c) => ({ event: c.event, data: parse<AnthropicBlockEvent>(c) }));
-      const thinkingStop = events.findIndex((e) => e.event === "content_block_stop" && e.data.index === 0);
-      const textStart = events.findIndex((e) => e.event === "content_block_start" && e.data.content_block?.type === "text");
+      const events = chunks.map((c) => ({
+        event: c.event,
+        data: parse<AnthropicBlockEvent>(c),
+      }));
+      const thinkingStop = events.findIndex(
+        (e) => e.event === "content_block_stop" && e.data.index === 0,
+      );
+      const textStart = events.findIndex(
+        (e) =>
+          e.event === "content_block_start" &&
+          e.data.content_block?.type === "text",
+      );
       expect(thinkingStop).toBeLessThan(textStart);
     });
 
@@ -179,17 +219,25 @@ describe("Anthropic Format", () => {
         "claude-sonnet-4-6",
       );
       const delta = chunks.find((c) => c.event === "message_delta");
-      expect(parse<AnthropicDelta>(delta!).delta).toMatchObject({ stop_reason: "tool_use" });
+      expect(parse<AnthropicDelta>(delta!).delta).toMatchObject({
+        stop_reason: "tool_use",
+      });
     });
 
     it("includes stop_sequence: null in message_delta", () => {
-      const chunks = anthropicFormat.serialize({ text: "Hello" }, "claude-sonnet-4-6");
+      const chunks = anthropicFormat.serialize(
+        { text: "Hello" },
+        "claude-sonnet-4-6",
+      );
       const delta = chunks.find((c) => c.event === "message_delta");
       expect(parse<AnthropicDelta>(delta!).delta.stop_sequence).toBeNull();
     });
 
     it("message_delta includes output_tokens in usage", () => {
-      const chunks = anthropicFormat.serialize({ text: "Hello", usage: { input: 20, output: 15 } }, "claude-sonnet-4-6");
+      const chunks = anthropicFormat.serialize(
+        { text: "Hello", usage: { input: 20, output: 15 } },
+        "claude-sonnet-4-6",
+      );
       const delta = chunks.find((c) => c.event === "message_delta");
       expect(parse<AnthropicDelta>(delta!).usage.output_tokens).toBe(15);
     });
@@ -197,7 +245,10 @@ describe("Anthropic Format", () => {
 
   describe("serializeComplete (non-streaming)", () => {
     it("produces correct top-level structure", () => {
-      const result = anthropicFormat.serializeComplete({ text: "Hello" }, "claude-sonnet-4-6") as AnthropicComplete;
+      const result = anthropicFormat.serializeComplete(
+        { text: "Hello" },
+        "claude-sonnet-4-6",
+      ) as AnthropicComplete;
       expect(result.type).toBe("message");
       expect(result.role).toBe("assistant");
       expect(result.model).toBe("claude-sonnet-4-6");
@@ -206,8 +257,14 @@ describe("Anthropic Format", () => {
     });
 
     it("includes text content block", () => {
-      const result = anthropicFormat.serializeComplete({ text: "Hello, world!" }, "claude-sonnet-4-6") as AnthropicComplete;
-      expect(result.content[0]).toMatchObject({ type: "text", text: "Hello, world!" });
+      const result = anthropicFormat.serializeComplete(
+        { text: "Hello, world!" },
+        "claude-sonnet-4-6",
+      ) as AnthropicComplete;
+      expect(result.content[0]).toMatchObject({
+        type: "text",
+        text: "Hello, world!",
+      });
     });
 
     it("includes thinking before text when reasoning provided", () => {
@@ -251,7 +308,11 @@ describe("Anthropic Format", () => {
 
   describe("serializeError", () => {
     it("produces Anthropic error format", () => {
-      const result = anthropicFormat.serializeError({ status: 400, message: "Bad request", type: "invalid_request_error" }) as AnthropicError;
+      const result = anthropicFormat.serializeError({
+        status: 400,
+        message: "Bad request",
+        type: "invalid_request_error",
+      }) as AnthropicError;
       expect(result.type).toBe("error");
       expect(result.error.type).toBe("invalid_request_error");
       expect(result.error.message).toBe("Bad request");

package/test/formats/openai.test.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect } from "vitest";
 import { openaiFormat } from "../../src/formats/openai/index.js";
-import type { OpenAIChunk, OpenAIComplete, OpenAIError } from "../../src/formats/openai/schema.js";
+import type {
+  OpenAIChunk,
+  OpenAIComplete,
+  OpenAIError,
+} from "../../src/formats/openai/schema.js";
 
 function parse<T>(chunk: { data: string }): T {
   return JSON.parse(chunk.data) as T;
@@ -26,12 +30,19 @@ describe("OpenAI Format", () => {
     });
 
     it("defaults stream to true", () => {
-      const req = openaiFormat.parseRequest({ model: "gpt-5.4", messages: [{ role: "user", content: "hi" }] });
+      const req = openaiFormat.parseRequest({
+        model: "gpt-5.4",
+        messages: [{ role: "user", content: "hi" }],
+      });
       expect(req.streaming).toBe(true);
     });
 
     it("detects stream: false", () => {
-      const req = openaiFormat.parseRequest({ model: "gpt-5.4", messages: [{ role: "user", content: "hi" }], stream: false });
+      const req = openaiFormat.parseRequest({
+        model: "gpt-5.4",
+        messages: [{ role: "user", content: "hi" }],
+        stream: false,
+      });
       expect(req.streaming).toBe(false);
     });
 
@@ -39,7 +50,16 @@ describe("OpenAI Format", () => {
       const req = openaiFormat.parseRequest({
         model: "gpt-5.4",
         messages: [{ role: "user", content: "read file" }],
-        tools: [{ type: "function", function: { name: "read_file", description: "Read a file", parameters: {} } }],
+        tools: [
+          {
+            type: "function",
+            function: {
+              name: "read_file",
+              description: "Read a file",
+              parameters: {},
+            },
+          },
+        ],
       });
       expect(req.tools).toHaveLength(1);
       expect(req.tools![0]!.name).toBe("read_file");
@@ -71,22 +91,28 @@ describe("OpenAI Format", () => {
     it("handles non-string content (array of content parts)", () => {
       const req = openaiFormat.parseRequest({
         model: "gpt-5.4",
-        messages: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+        messages: [
+          { role: "user", content: [{ type: "text", text: "Hello" }] },
+        ],
       });
       expect(req.lastMessage).toContain("Hello");
     });
 
     it("rejects requests with invalid role values", () => {
-      expect(() => openaiFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [{ role: "banana", content: "hi" }],
-      })).toThrow();
+      expect(() =>
+        openaiFormat.parseRequest({
+          model: "gpt-5.4",
+          messages: [{ role: "banana", content: "hi" }],
+        }),
+      ).toThrow();
     });
 
     it("rejects requests missing model", () => {
-      expect(() => openaiFormat.parseRequest({
-        messages: [{ role: "user", content: "hi" }],
-      })).toThrow();
+      expect(() =>
+        openaiFormat.parseRequest({
+          messages: [{ role: "user", content: "hi" }],
+        }),
+      ).toThrow();
     });
   });
 
@@ -123,14 +149,19 @@ describe("OpenAI Format", () => {
     });
 
     it("includes usage chunk before [DONE]", () => {
-      const chunks = openaiFormat.serialize({ text: "Hello", usage: { input: 10, output: 5 } }, "gpt-5.4");
+      const chunks = openaiFormat.serialize(
+        { text: "Hello", usage: { input: 10, output: 5 } },
+        "gpt-5.4",
+      );
       const usageChunk = parse<OpenAIChunk>(chunks.at(-2)!);
       expect(usageChunk.usage).toMatchObject({
         prompt_tokens: 10,
         completion_tokens: 5,
         total_tokens: 15,
       });
-      expect(usageChunk.usage?.completion_tokens_details?.reasoning_tokens).toBe(0);
+      expect(
+        usageChunk.usage?.completion_tokens_details?.reasoning_tokens,
+      ).toBe(0);
       expect(usageChunk.usage?.prompt_tokens_details?.cached_tokens).toBe(0);
     });
 
@@ -144,7 +175,8 @@ describe("OpenAI Format", () => {
         return parse<OpenAIChunk>(c).choices[0]?.delta.tool_calls !== undefined;
       });
       expect(toolChunk).toBeDefined();
-      const tc = parse<OpenAIChunk>(toolChunk!).choices[0]!.delta.tool_calls![0]!;
+      const tc = parse<OpenAIChunk>(toolChunk!).choices[0]!.delta
+        .tool_calls![0]!;
       expect(tc.type).toBe("function");
       expect(tc.id).toBeTypeOf("string");
       expect(tc.function.name).toBe("read_file");
@@ -158,7 +190,11 @@ describe("OpenAI Format", () => {
     });
 
     it("splits text into multiple delta chunks with chunkSize", () => {
-      const chunks = openaiFormat.serialize({ text: "Hello, world!" }, "gpt-5.4", { chunkSize: 5 });
+      const chunks = openaiFormat.serialize(
+        { text: "Hello, world!" },
+        "gpt-5.4",
+        { chunkSize: 5 },
+      );
       const contentDeltas = chunks
         .filter((c) => c.data !== "[DONE]")
         .map((c) => parse<OpenAIChunk>(c))
@@ -169,7 +205,9 @@ describe("OpenAI Format", () => {
 
     it("all chunks share same id and created timestamp", () => {
       const chunks = openaiFormat.serialize({ text: "Hello" }, "gpt-5.4");
-      const dataChunks = chunks.filter((c) => c.data !== "[DONE]").map((c) => parse<OpenAIChunk>(c));
+      const dataChunks = chunks
+        .filter((c) => c.data !== "[DONE]")
+        .map((c) => parse<OpenAIChunk>(c));
       const ids = dataChunks.map((c) => c.id);
       const created = dataChunks.map((c) => c.created);
       expect(new Set(ids).size).toBe(1);
@@ -179,7 +217,10 @@ describe("OpenAI Format", () => {
 
   describe("serializeComplete (non-streaming)", () => {
     it("produces correct top-level structure", () => {
-      const result = openaiFormat.serializeComplete({ text: "Hello, world!" }, "gpt-5.4") as OpenAIComplete;
+      const result = openaiFormat.serializeComplete(
+        { text: "Hello, world!" },
+        "gpt-5.4",
+      ) as OpenAIComplete;
       expect(result.object).toBe("chat.completion");
       expect(result.model).toBe("gpt-5.4");
       expect(result.id).toBeTypeOf("string");
@@ -187,7 +228,10 @@ describe("OpenAI Format", () => {
     });
 
     it("message has correct content and finish_reason", () => {
-      const result = openaiFormat.serializeComplete({ text: "Hello, world!" }, "gpt-5.4") as OpenAIComplete;
+      const result = openaiFormat.serializeComplete(
+        { text: "Hello, world!" },
+        "gpt-5.4",
+      ) as OpenAIComplete;
       expect(result.choices[0]!.message.role).toBe("assistant");
       expect(result.choices[0]!.message.content).toBe("Hello, world!");
       expect(result.choices[0]!.finish_reason).toBe("stop");
@@ -210,33 +254,50 @@ describe("OpenAI Format", () => {
         { text: "hi", usage: { input: 20, output: 15 } },
         "gpt-5.4",
       ) as OpenAIComplete;
-      expect(result.usage).toMatchObject({ prompt_tokens: 20, completion_tokens: 15, total_tokens: 35 });
+      expect(result.usage).toMatchObject({
+        prompt_tokens: 20,
+        completion_tokens: 15,
+        total_tokens: 35,
+      });
       expect(result.usage?.completion_tokens_details?.reasoning_tokens).toBe(0);
       expect(result.usage?.prompt_tokens_details?.cached_tokens).toBe(0);
     });
 
     it("includes service_tier and system_fingerprint", () => {
-      const result = openaiFormat.serializeComplete({ text: "hi" }, "gpt-5.4") as OpenAIComplete;
+      const result = openaiFormat.serializeComplete(
+        { text: "hi" },
+        "gpt-5.4",
+      ) as OpenAIComplete;
       expect(result.service_tier).toBe("default");
       expect(result.system_fingerprint).toBeNull();
     });
 
     it("includes logprobs: null on choices", () => {
-      const result = openaiFormat.serializeComplete({ text: "hi" }, "gpt-5.4") as OpenAIComplete;
+      const result = openaiFormat.serializeComplete(
+        { text: "hi" },
+        "gpt-5.4",
+      ) as OpenAIComplete;
       expect(result.choices[0]!.logprobs).toBeNull();
     });
   });
 
   describe("serializeError", () => {
     it("produces OpenAI error format", () => {
-      const result = openaiFormat.serializeError({ status: 429, message: "Rate limited", type: "rate_limit_error" }) as OpenAIError;
+      const result = openaiFormat.serializeError({
+        status: 429,
+        message: "Rate limited",
+        type: "rate_limit_error",
+      }) as OpenAIError;
       expect(result.error.message).toBe("Rate limited");
       expect(result.error.type).toBe("rate_limit_error");
       expect(result.error.code).toBeNull();
     });
 
     it("defaults type to server_error", () => {
-      const result = openaiFormat.serializeError({ status: 500, message: "Internal" }) as OpenAIError;
+      const result = openaiFormat.serializeError({
+        status: 500,
+        message: "Internal",
+      }) as OpenAIError;
       expect(result.error.type).toBe("server_error");
     });
   });

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

@@ -108,7 +108,9 @@ describe("parse-helpers", () => {
     });
 
     it("returns true when reply has text and tools", () => {
-      expect(shouldEmitText({ text: "hi", tools: [{ name: "fn", args: {} }] })).toBe(true);
+      expect(
+        shouldEmitText({ text: "hi", tools: [{ name: "fn", args: {} }] }),
+      ).toBe(true);
     });
 
     it("returns true for empty text with no tools or reasoning", () => {
@@ -169,7 +171,9 @@ describe("parse-helpers", () => {
         [{ role: "user", content: "hello" }],
         undefined,
         "gpt-4",
-        { messages: [] },
+        {
+          messages: [],
+        },
       );
 
       expect(result.format).toBe("openai");
@@ -214,7 +218,14 @@ describe("parse-helpers", () => {
         { role: "assistant" as const, content: "reply" },
         { role: "user" as const, content: "second" },
       ];
-      const result = buildMockRequest("openai", {}, messages, undefined, "m", {});
+      const result = buildMockRequest(
+        "openai",
+        {},
+        messages,
+        undefined,
+        "m",
+        {},
+      );
       expect(result.lastMessage).toBe("second");
     });
 
@@ -223,7 +234,14 @@ describe("parse-helpers", () => {
         { role: "system" as const, content: "be helpful" },
         { role: "user" as const, content: "hi" },
       ];
-      const result = buildMockRequest("openai", {}, messages, undefined, "m", {});
+      const result = buildMockRequest(
+        "openai",
+        {},
+        messages,
+        undefined,
+        "m",
+        {},
+      );
       expect(result.systemMessage).toBe("be helpful");
     });
 
@@ -241,12 +259,26 @@ describe("parse-helpers", () => {
         { 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", {});
+      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", {});
+      const result = buildMockRequest(
+        "openai",
+        { stream: false },
+        [],
+        undefined,
+        "m",
+        {},
+      );
       expect(result.streaming).toBe(false);
     });
 
@@ -255,7 +287,15 @@ describe("parse-helpers", () => {
         headers: { authorization: "Bearer sk-test" },
         path: "/v1/chat/completions",
       };
-      const result = buildMockRequest("openai", {}, [], undefined, "m", {}, meta);
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [],
+        undefined,
+        "m",
+        {},
+        meta,
+      );
       expect(result.headers).toEqual({ authorization: "Bearer sk-test" });
       expect(result.path).toBe("/v1/chat/completions");
     });