llm-mock-server 1.0.6 → 1.0.8

package/test/formats/openai.test.ts

@@ -1,316 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { chatCompletionsFormat } from "../../src/formats/openai/chat-completions/index.js";
-import type {
-  OpenAIChunk,
-  OpenAIComplete,
-  OpenAIError,
-} from "../../src/formats/openai/chat-completions/schema.js";
-
-function parse<T>(chunk: { data: string }): T {
-  return JSON.parse(chunk.data) as T;
-}
-
-describe("OpenAI Format", () => {
-  describe("parseRequest", () => {
-    it("parses a basic chat completion request", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [
-          { role: "system", content: "You are helpful" },
-          { role: "user", content: "Hello" },
-        ],
-        stream: true,
-      });
-      expect(req.format).toBe("openai");
-      expect(req.model).toBe("gpt-5.4");
-      expect(req.streaming).toBe(true);
-      expect(req.lastMessage).toBe("Hello");
-      expect(req.systemMessage).toBe("You are helpful");
-      expect(req.messages).toHaveLength(2);
-    });
-
-    it("defaults stream to true", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [{ role: "user", content: "hi" }],
-      });
-      expect(req.streaming).toBe(true);
-    });
-
-    it("detects stream: false", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [{ role: "user", content: "hi" }],
-        stream: false,
-      });
-      expect(req.streaming).toBe(false);
-    });
-
-    it("parses tools with function wrapper", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [{ role: "user", content: "read file" }],
-        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");
-    });
-
-    it("extracts toolNames from tools array", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [{ role: "user", content: "hi" }],
-        tools: [
-          { type: "function", function: { name: "get_weather" } },
-          { type: "function", function: { name: "search" } },
-        ],
-      });
-      expect(req.toolNames).toEqual(["get_weather", "search"]);
-    });
-
-    it("extracts lastToolCallId from tool messages", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [
-          { role: "user", content: "hi" },
-          { role: "tool", tool_call_id: "call_123", content: "result" },
-        ],
-      });
-      expect(req.lastToolCallId).toBe("call_123");
-    });
-
-    it("handles non-string content (array of content parts)", () => {
-      const req = chatCompletionsFormat.parseRequest({
-        model: "gpt-5.4",
-        messages: [
-          { role: "user", content: [{ type: "text", text: "Hello" }] },
-        ],
-      });
-      expect(req.lastMessage).toContain("Hello");
-    });
-
-    it("rejects requests with invalid role values", () => {
-      expect(() =>
-        chatCompletionsFormat.parseRequest({
-          model: "gpt-5.4",
-          messages: [{ role: "banana", content: "hi" }],
-        }),
-      ).toThrow();
-    });
-
-    it("rejects requests missing model", () => {
-      expect(() =>
-        chatCompletionsFormat.parseRequest({
-          messages: [{ role: "user", content: "hi" }],
-        }),
-      ).toThrow();
-    });
-  });
-
-  describe("serialize (streaming)", () => {
-    it("starts with role delta and ends with [DONE]", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { text: "Hello world" },
-        "gpt-5.4",
-      );
-      const first = parse<OpenAIChunk>(chunks[0]!);
-      expect(first.choices[0]!.delta).toEqual({ role: "assistant" });
-      expect(chunks.at(-1)!.data).toBe("[DONE]");
-    });
-
-    it("content delta has correct structure", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { text: "Hello world" },
-        "gpt-5.4",
-      );
-      const content = parse<OpenAIChunk>(chunks[1]!);
-      expect(content.object).toBe("chat.completion.chunk");
-      expect(content.model).toBe("gpt-5.4");
-      expect(content.choices[0]!.delta).toEqual({ content: "Hello world" });
-      expect(content.choices[0]!.finish_reason).toBeNull();
-    });
-
-    it("finish chunk has finish_reason: stop for text", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { text: "Hello" },
-        "gpt-5.4",
-      );
-      const finish = parse<OpenAIChunk>(chunks.at(-3)!);
-      expect(finish.choices[0]!.finish_reason).toBe("stop");
-    });
-
-    it("finish chunk has finish_reason: tool_calls for tools", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
-        "gpt-5.4",
-      );
-      const finish = parse<OpenAIChunk>(chunks.at(-3)!);
-      expect(finish.choices[0]!.finish_reason).toBe("tool_calls");
-    });
-
-    it("includes usage chunk before [DONE]", () => {
-      const chunks = chatCompletionsFormat.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?.prompt_tokens_details?.cached_tokens).toBe(0);
-    });
-
-    it("tool call delta has correct structure", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
-        "gpt-5.4",
-      );
-      const toolChunk = chunks.find((c) => {
-        if (c.data === "[DONE]") return false;
-        return parse<OpenAIChunk>(c).choices[0]?.delta.tool_calls !== undefined;
-      });
-      expect(toolChunk).toBeDefined();
-      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");
-    });
-
-    it("no named events (openai uses data-only SSE)", () => {
-      const chunks = chatCompletionsFormat.serialize({ text: "hi" }, "gpt-5.4");
-      for (const chunk of chunks) {
-        expect(chunk.event).toBeUndefined();
-      }
-    });
-
-    it("splits text into multiple delta chunks with chunkSize", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { text: "Hello, world!" },
-        "gpt-5.4",
-        { chunkSize: 5 },
-      );
-      const contentDeltas = chunks
-        .filter((c) => c.data !== "[DONE]")
-        .map((c) => parse<OpenAIChunk>(c))
-        .filter((d) => d.choices[0]?.delta.content !== undefined)
-        .map((d) => d.choices[0]!.delta.content);
-      expect(contentDeltas).toEqual(["Hello", ", wor", "ld!"]);
-    });
-
-    it("all chunks share same id and created timestamp", () => {
-      const chunks = chatCompletionsFormat.serialize(
-        { text: "Hello" },
-        "gpt-5.4",
-      );
-      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);
-      expect(new Set(created).size).toBe(1);
-    });
-  });
-
-  describe("serializeComplete (non-streaming)", () => {
-    it("produces correct top-level structure", () => {
-      const result = chatCompletionsFormat.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");
-      expect(result.created).toBeTypeOf("number");
-    });
-
-    it("message has correct content and finish_reason", () => {
-      const result = chatCompletionsFormat.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");
-    });
-
-    it("includes tool_calls with correct structure", () => {
-      const result = chatCompletionsFormat.serializeComplete(
-        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
-        "gpt-5.4",
-      ) as OpenAIComplete;
-      expect(result.choices[0]!.finish_reason).toBe("tool_calls");
-      const tc = result.choices[0]!.message.tool_calls![0]!;
-      expect(tc.type).toBe("function");
-      expect(tc.id).toBeTypeOf("string");
-      expect(tc.function.name).toBe("read_file");
-    });
-
-    it("includes usage tokens with details", () => {
-      const result = chatCompletionsFormat.serializeComplete(
-        { 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?.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 = chatCompletionsFormat.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 = chatCompletionsFormat.serializeComplete(
-        { text: "hi" },
-        "gpt-5.4",
-      ) as OpenAIComplete;
-      expect(result.choices[0]!.logprobs).toBeNull();
-    });
-  });
-
-  describe("serializeError", () => {
-    it("produces OpenAI error format", () => {
-      const result = chatCompletionsFormat.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 = chatCompletionsFormat.serializeError({
-        status: 500,
-        message: "Internal",
-      }) as OpenAIError;
-      expect(result.error.type).toBe("server_error");
-    });
-  });
-});

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

@@ -1,315 +0,0 @@
-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("");
-    });
-  });
-});