llm-mock-server 1.0.5 → 1.0.7

package/src/types.ts

@@ -1,24 +0,0 @@
-export type {
-  FormatName,
-  MockRequest,
-  Message,
-  ToolDef,
-} from "./types/request.js";
-export type {
-  Reply,
-  ReplyObject,
-  ErrorReply,
-  ToolCall,
-  Resolver,
-  ReplyOptions,
-  SequenceEntry,
-} from "./types/reply.js";
-export type {
-  Match,
-  MatchObject,
-  PendingRule,
-  RuleHandle,
-  RuleSummary,
-  Handler,
-  Rule,
-} from "./types/rule.js";

package/test/cli-validators.test.ts

@@ -1,151 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  parsePort,
-  parseHost,
-  parseChunkSize,
-  parseLogLevel,
-  parseLatency,
-} from "../src/cli/validators.js";
-
-describe("parsePort", () => {
-  it("parses a valid port", () => {
-    expect(parsePort("5555")).toBe(5555);
-  });
-
-  it("accepts port 1", () => {
-    expect(parsePort("1")).toBe(1);
-  });
-
-  it("accepts port 65535", () => {
-    expect(parsePort("65535")).toBe(65535);
-  });
-
-  it("throws on port 0", () => {
-    expect(() => parsePort("0")).toThrow('Invalid port "0"');
-  });
-
-  it("throws on port above 65535", () => {
-    expect(() => parsePort("65536")).toThrow('Invalid port "65536"');
-  });
-
-  it("throws on negative port", () => {
-    expect(() => parsePort("-1")).toThrow('Invalid port "-1"');
-  });
-
-  it("throws on non-numeric string", () => {
-    expect(() => parsePort("abc")).toThrow('Invalid port "abc"');
-  });
-
-  it("throws on empty string", () => {
-    expect(() => parsePort("")).toThrow('Invalid port ""');
-  });
-
-  it("throws on floating point", () => {
-    expect(() => parsePort("80.5")).toThrow('Invalid port "80.5"');
-  });
-
-  it("throws on numeric string with trailing chars", () => {
-    expect(() => parsePort("80abc")).toThrow('Invalid port "80abc"');
-  });
-});
-
-describe("parseLogLevel", () => {
-  it.each(["none", "error", "warning", "info", "debug", "all"] as const)(
-    "accepts %s",
-    (level) => {
-      expect(parseLogLevel(level)).toBe(level);
-    },
-  );
-
-  it("throws on invalid level", () => {
-    expect(() => parseLogLevel("verbose")).toThrow(
-      'Invalid log level "verbose"',
-    );
-  });
-
-  it("throws on empty string", () => {
-    expect(() => parseLogLevel("")).toThrow('Invalid log level ""');
-  });
-});
-
-describe("parseHost", () => {
-  it("accepts 127.0.0.1", async () => {
-    await expect(parseHost("127.0.0.1")).resolves.toBe("127.0.0.1");
-  });
-
-  it("accepts 0.0.0.0", async () => {
-    await expect(parseHost("0.0.0.0")).resolves.toBe("0.0.0.0");
-  });
-
-  it("accepts localhost", async () => {
-    await expect(parseHost("localhost")).resolves.toBe("localhost");
-  });
-
-  it("accepts an IPv6 address", async () => {
-    await expect(parseHost("::1")).resolves.toBe("::1");
-  });
-
-  it("rejects an empty string", async () => {
-    await expect(parseHost("")).rejects.toThrow('Invalid host ""');
-  });
-
-  it("rejects an unresolvable hostname", async () => {
-    await expect(parseHost("not.a.real.host.invalid")).rejects.toThrow(
-      "Invalid host",
-    );
-  });
-
-  it("rejects a string with spaces", async () => {
-    await expect(parseHost("local host")).rejects.toThrow(
-      'Invalid host "local host"',
-    );
-  });
-});
-
-describe("parseLatency", () => {
-  it("parses a valid latency", () => {
-    expect(parseLatency("100")).toBe(100);
-  });
-
-  it("accepts zero", () => {
-    expect(parseLatency("0")).toBe(0);
-  });
-
-  it("throws on negative value", () => {
-    expect(() => parseLatency("-1")).toThrow('Invalid latency "-1"');
-  });
-
-  it("throws on non-numeric value", () => {
-    expect(() => parseLatency("abc")).toThrow('Invalid latency "abc"');
-  });
-
-  it("throws on empty string", () => {
-    expect(() => parseLatency("")).toThrow('Invalid latency ""');
-  });
-
-  it("throws on floating point", () => {
-    expect(() => parseLatency("50.7")).toThrow('Invalid latency "50.7"');
-  });
-
-  it("throws on numeric string with trailing chars", () => {
-    expect(() => parseLatency("50abc")).toThrow('Invalid latency "50abc"');
-  });
-});
-
-describe("parseChunkSize", () => {
-  it("parses a valid chunk size", () => {
-    expect(parseChunkSize("20")).toBe(20);
-  });
-
-  it("accepts zero", () => {
-    expect(parseChunkSize("0")).toBe(0);
-  });
-
-  it("throws on negative value", () => {
-    expect(() => parseChunkSize("-5")).toThrow('Invalid chunk size "-5"');
-  });
-
-  it("throws on non-numeric value", () => {
-    expect(() => parseChunkSize("abc")).toThrow('Invalid chunk size "abc"');
-  });
-});

package/test/formats/anthropic.test.ts

@@ -1,336 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { anthropicFormat } from "../../src/formats/anthropic/index.js";
-import type {
-  AnthropicMessageStart,
-  AnthropicBlockEvent,
-  AnthropicDelta,
-  AnthropicComplete,
-  AnthropicError,
-} from "../../src/formats/anthropic/schema.js";
-
-function parse<T>(chunk: { data: string }): T {
-  return JSON.parse(chunk.data) as T;
-}
-
-describe("Anthropic Format", () => {
-  describe("parseRequest", () => {
-    it("parses messages with top-level system", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        system: "You are a pirate",
-        messages: [{ role: "user", content: "Hello" }],
-        max_tokens: 1024,
-        stream: true,
-      });
-      expect(req.format).toBe("anthropic");
-      expect(req.model).toBe("claude-sonnet-4-6");
-      expect(req.systemMessage).toBe("You are a pirate");
-      expect(req.lastMessage).toBe("Hello");
-      expect(req.messages).toHaveLength(2);
-    });
-
-    it("parses system as array of blocks", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        max_tokens: 1024,
-        system: [{ type: "text", text: "Be helpful" }],
-        messages: [{ role: "user", content: "hi" }],
-      });
-      expect(req.systemMessage).toBe("Be helpful");
-    });
-
-    it("parses content block arrays in messages", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        max_tokens: 1024,
-        messages: [
-          { role: "user", content: [{ type: "text", text: "Hello there" }] },
-        ],
-      });
-      expect(req.lastMessage).toBe("Hello there");
-    });
-
-    it("parses tools with input_schema", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        max_tokens: 1024,
-        messages: [{ role: "user", content: "read file" }],
-        tools: [
-          {
-            name: "read_file",
-            description: "Read",
-            input_schema: { type: "object" },
-          },
-        ],
-      });
-      expect(req.tools).toHaveLength(1);
-      expect(req.tools![0]!.name).toBe("read_file");
-    });
-
-    it("extracts toolNames from tools array", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        max_tokens: 1024,
-        messages: [{ role: "user", content: "hi" }],
-        tools: [
-          { name: "get_weather", input_schema: {} },
-          { name: "search", input_schema: {} },
-        ],
-      });
-      expect(req.toolNames).toEqual(["get_weather", "search"]);
-    });
-
-    it("extracts lastToolCallId from tool_result blocks", () => {
-      const req = anthropicFormat.parseRequest({
-        model: "claude-sonnet-4-6",
-        max_tokens: 1024,
-        messages: [
-          { role: "user", content: "hi" },
-          {
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                tool_use_id: "toolu_123",
-                content: "result",
-              },
-            ],
-          },
-        ],
-      });
-      expect(req.lastToolCallId).toBe("toolu_123");
-    });
-  });
-
-  describe("serialize (streaming)", () => {
-    it("produces correct event sequence for text", () => {
-      const chunks = anthropicFormat.serialize(
-        { text: "Hello" },
-        "claude-sonnet-4-6",
-      );
-      const events = chunks.map((c) => c.event);
-      expect(events).toEqual([
-        "message_start",
-        "content_block_start",
-        "content_block_delta",
-        "content_block_stop",
-        "message_delta",
-        "message_stop",
-      ]);
-    });
-
-    it("message_start contains correct structure", () => {
-      const chunks = anthropicFormat.serialize(
-        { text: "Hello" },
-        "claude-sonnet-4-6",
-      );
-      const msg = parse<AnthropicMessageStart>(chunks[0]!);
-      expect(msg.message).toMatchObject({
-        type: "message",
-        role: "assistant",
-        model: "claude-sonnet-4-6",
-        content: [],
-        stop_reason: null,
-      });
-      expect(msg.message.usage.input_tokens).toBeTypeOf("number");
-      expect(msg.message.usage.output_tokens).toBe(0);
-    });
-
-    it("text block uses index 0 when no reasoning", () => {
-      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);
-      expect(data.content_block?.type).toBe("text");
-    });
-
-    it("thinking block at index 0 and text block at index 1 when reasoning present", () => {
-      const chunks = anthropicFormat.serialize(
-        { text: "42", reasoning: "Let me think" },
-        "claude-sonnet-4-6",
-      );
-      const blockStarts = chunks
-        .filter((c) => c.event === "content_block_start")
-        .map((c) => parse<AnthropicBlockEvent>(c));
-
-      expect(blockStarts[0]!.index).toBe(0);
-      expect(blockStarts[0]!.content_block?.type).toBe("thinking");
-      expect(blockStarts[1]!.index).toBe(1);
-      expect(blockStarts[1]!.content_block?.type).toBe("text");
-    });
-
-    it("thinking delta has correct type and content", () => {
-      const chunks = anthropicFormat.serialize(
-        { text: "42", reasoning: "Let me think" },
-        "claude-sonnet-4-6",
-      );
-      const thinkingDelta = chunks.find((c) => {
-        if (c.event !== "content_block_delta") return false;
-        return parse<AnthropicBlockEvent>(c).delta?.type === "thinking_delta";
-      });
-      expect(thinkingDelta).toBeDefined();
-      expect(parse<AnthropicBlockEvent>(thinkingDelta!).delta?.thinking).toBe(
-        "Let me think",
-      );
-    });
-
-    it("closes thinking block before text block starts", () => {
-      const chunks = anthropicFormat.serialize(
-        { 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",
-      );
-      expect(thinkingStop).toBeLessThan(textStart);
-    });
-
-    it("includes tool_use blocks with correct structure", () => {
-      const chunks = anthropicFormat.serialize(
-        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
-        "claude-sonnet-4-6",
-      );
-      const toolStart = chunks.find((c) => {
-        if (c.event !== "content_block_start") return false;
-        return parse<AnthropicBlockEvent>(c).content_block?.type === "tool_use";
-      });
-      expect(toolStart).toBeDefined();
-      const block = parse<AnthropicBlockEvent>(toolStart!).content_block!;
-      expect(block.name).toBe("read_file");
-      expect(block.id).toBeTypeOf("string");
-      expect(block.input).toEqual({});
-    });
-
-    it("sets stop_reason to tool_use when tools present", () => {
-      const chunks = anthropicFormat.serialize(
-        { tools: [{ name: "read_file", args: {} }] },
-        "claude-sonnet-4-6",
-      );
-      const delta = chunks.find((c) => c.event === "message_delta");
-      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 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 delta = chunks.find((c) => c.event === "message_delta");
-      expect(parse<AnthropicDelta>(delta!).usage.output_tokens).toBe(15);
-    });
-  });
-
-  describe("serializeComplete (non-streaming)", () => {
-    it("produces correct top-level structure", () => {
-      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");
-      expect(result.stop_reason).toBe("end_turn");
-      expect(result.stop_sequence).toBeNull();
-    });
-
-    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!",
-      });
-    });
-
-    it("includes thinking before text when reasoning provided", () => {
-      const result = anthropicFormat.serializeComplete(
-        { text: "42", reasoning: "Thinking..." },
-        "claude-sonnet-4-6",
-      ) as AnthropicComplete;
-      expect(result.content[0]!.type).toBe("thinking");
-      expect(result.content[0]!.thinking).toBe("Thinking...");
-      expect(result.content[1]!.type).toBe("text");
-    });
-
-    it("includes tool_use with correct structure", () => {
-      const result = anthropicFormat.serializeComplete(
-        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
-        "claude-sonnet-4-6",
-      ) as AnthropicComplete;
-      const tool = result.content.find((c) => c.type === "tool_use");
-      if (!tool) throw new Error("expected tool_use content block");
-      expect(tool.name).toBe("read_file");
-      expect(tool.input).toEqual({ path: "/tmp" });
-      expect(tool.id).toBeTypeOf("string");
-    });
-
-    it("generates unique IDs for multiple tools", () => {
-      const result = anthropicFormat.serializeComplete(
-        {
-          tools: [
-            { name: "read_file", args: { path: "/a" } },
-            { name: "write_file", args: { path: "/b" } },
-          ],
-        },
-        "claude-sonnet-4-6",
-      ) as AnthropicComplete;
-      const tools = result.content.filter((c) => c.type === "tool_use");
-      if (tools.length !== 2) throw new Error("expected 2 tool_use blocks");
-      expect(tools[0].id).not.toBe(tools[1].id);
-    });
-
-    it("sets stop_reason to tool_use when tools present", () => {
-      const result = anthropicFormat.serializeComplete(
-        { tools: [{ name: "read_file", args: {} }] },
-        "claude-sonnet-4-6",
-      ) as AnthropicComplete;
-      expect(result.stop_reason).toBe("tool_use");
-    });
-
-    it("includes usage tokens", () => {
-      const result = anthropicFormat.serializeComplete(
-        { text: "hi", usage: { input: 20, output: 15 } },
-        "claude-sonnet-4-6",
-      ) as AnthropicComplete;
-      expect(result.usage).toEqual({ input_tokens: 20, output_tokens: 15 });
-    });
-  });
-
-  describe("serializeError", () => {
-    it("produces Anthropic error format", () => {
-      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");
-    });
-  });
-});