llm-mock-server 1.0.0

package/test/formats/openai.test.ts

@@ -0,0 +1,243 @@
+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";
+
+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 = openaiFormat.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 = 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 });
+      expect(req.streaming).toBe(false);
+    });
+
+    it("parses tools with function wrapper", () => {
+      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: {} } }],
+      });
+      expect(req.tools).toHaveLength(1);
+      expect(req.tools![0]!.name).toBe("read_file");
+    });
+
+    it("extracts toolNames from tools array", () => {
+      const req = openaiFormat.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 = openaiFormat.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 = openaiFormat.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(() => 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();
+    });
+  });
+
+  describe("serialize (streaming)", () => {
+    it("starts with role delta and ends with [DONE]", () => {
+      const chunks = openaiFormat.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 = openaiFormat.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 = openaiFormat.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 = openaiFormat.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 = 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?.prompt_tokens_details?.cached_tokens).toBe(0);
+    });
+
+    it("tool call delta has correct structure", () => {
+      const chunks = openaiFormat.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 = openaiFormat.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 = openaiFormat.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 = openaiFormat.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 = 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");
+      expect(result.created).toBeTypeOf("number");
+    });
+
+    it("message has correct content and finish_reason", () => {
+      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");
+    });
+
+    it("includes tool_calls with correct structure", () => {
+      const result = openaiFormat.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 = openaiFormat.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 = 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;
+      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;
+      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;
+      expect(result.error.type).toBe("server_error");
+    });
+  });
+});

package/test/formats/responses-schema.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from "vitest";
+import { ResponsesRequestSchema, FunctionToolSchema } from "../../src/formats/responses/schema.js";
+
+describe("ResponsesRequestSchema", () => {
+  const validRequest = {
+    model: "codex-mini",
+    input: "Hello",
+  };
+
+  it("accepts a valid minimal request with string input", () => {
+    expect(ResponsesRequestSchema.safeParse(validRequest).success).toBe(true);
+  });
+
+  it("accepts array input with a user message", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      model: "codex-mini",
+      input: [{ role: "user", content: "Hello" }],
+    }).success).toBe(true);
+  });
+
+  it("accepts array input with function_call and function_call_output", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      model: "codex-mini",
+      input: [
+        { type: "function_call", call_id: "call_1", name: "search", arguments: "{}" },
+        { type: "function_call_output", call_id: "call_1", output: "result" },
+      ],
+    }).success).toBe(true);
+  });
+
+  it("accepts missing model", () => {
+    expect(ResponsesRequestSchema.safeParse({ input: "Hello" }).success).toBe(true);
+  });
+
+  it("rejects empty model string", () => {
+    expect(ResponsesRequestSchema.safeParse({ model: "", input: "Hello" }).success).toBe(false);
+  });
+
+  it("accepts missing input", () => {
+    expect(ResponsesRequestSchema.safeParse({ model: "codex-mini" }).success).toBe(true);
+  });
+
+  it("accepts stream: true", () => {
+    const result = ResponsesRequestSchema.safeParse({ ...validRequest, stream: true });
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.stream).toBe(true);
+  });
+
+  it("accepts stream: false", () => {
+    const result = ResponsesRequestSchema.safeParse({ ...validRequest, stream: false });
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.stream).toBe(false);
+  });
+
+  it("accepts optional fields", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      ...validRequest,
+      instructions: "Be helpful",
+      temperature: 0.5,
+      previous_response_id: "resp_abc",
+    }).success).toBe(true);
+  });
+
+  it("accepts tools array with function tools", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      ...validRequest,
+      tools: [{
+        type: "function",
+        name: "search",
+        description: "Search the web",
+        parameters: { type: "object", properties: {} },
+      }],
+    }).success).toBe(true);
+  });
+
+  it("accepts tools array with non-function tools", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      ...validRequest,
+      tools: [{ type: "web_search" }],
+    }).success).toBe(true);
+  });
+
+  it("accepts message input with array content", () => {
+    expect(ResponsesRequestSchema.safeParse({
+      model: "codex-mini",
+      input: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+    }).success).toBe(true);
+  });
+});
+
+describe("FunctionToolSchema", () => {
+  it("accepts a valid function tool", () => {
+    const result = FunctionToolSchema.safeParse({
+      type: "function",
+      name: "search",
+      description: "Search the web",
+      parameters: { type: "object" },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts a function tool without optional fields", () => {
+    const result = FunctionToolSchema.safeParse({ type: "function", name: "run" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a non-function tool", () => {
+    expect(FunctionToolSchema.safeParse({ type: "web_search" }).success).toBe(false);
+  });
+
+  it("rejects a tool missing name", () => {
+    expect(FunctionToolSchema.safeParse({ type: "function" }).success).toBe(false);
+  });
+});

package/test/formats/responses.test.ts

@@ -0,0 +1,299 @@
+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";
+
+function parse<T>(chunk: { data: string }): T {
+  return JSON.parse(chunk.data) as T;
+}
+
+describe("Responses Format", () => {
+  describe("parseRequest", () => {
+    it("parses string input", () => {
+      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");
+    });
+
+    it("parses array input with items", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: [
+          { role: "user", content: "Hello" },
+          { role: "assistant", content: "Hi" },
+          { role: "user", content: "How are you?" },
+        ],
+      });
+      expect(req.lastMessage).toBe("How are you?");
+      expect(req.messages).toHaveLength(3);
+    });
+
+    it("parses instructions as system message", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: "Hello",
+        instructions: "You are a helpful assistant",
+      });
+      expect(req.systemMessage).toBe("You are a helpful assistant");
+    });
+
+    it("parses content block arrays", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: [{ role: "user", content: [{ type: "input_text", text: "Hello there" }] }],
+      });
+      expect(req.lastMessage).toBe("Hello there");
+    });
+
+    it("parses tools", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: "read file",
+        tools: [{ type: "function", name: "read_file", description: "Read", parameters: {} }],
+      });
+      expect(req.tools).toHaveLength(1);
+      expect(req.toolNames).toEqual(["read_file"]);
+    });
+
+    it("extracts lastToolCallId from function_call_output items", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: [
+          { role: "user", content: "hi" },
+          { type: "function_call_output", call_id: "call_abc", output: "result" },
+        ],
+      });
+      expect(req.lastToolCallId).toBe("call_abc");
+    });
+
+    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" },
+        ]}],
+      });
+      expect(req.lastMessage).toBe("describe this");
+    });
+
+    it("accepts requests with only instructions (no input)", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        instructions: "You are helpful",
+      });
+      expect(req.systemMessage).toBe("You are helpful");
+      expect(req.lastMessage).toBe("");
+    });
+
+    it("parses function tools without description", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: "hi",
+        tools: [{ type: "function", name: "run_code" }],
+      });
+      expect(req.tools![0]!.name).toBe("run_code");
+      expect(req.tools![0]!.description).toBeUndefined();
+    });
+
+    it("filters out non-function tools", () => {
+      const req = responsesFormat.parseRequest({
+        model: "codex-mini",
+        input: "hi",
+        tools: [
+          { type: "function", name: "run_code" },
+          { type: "web_search" },
+        ],
+      });
+      expect(req.tools).toHaveLength(1);
+      expect(req.tools![0]!.name).toBe("run_code");
+    });
+  });
+
+  describe("serialize (streaming)", () => {
+    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");
+    });
+
+    it("ends with response.completed", () => {
+      const chunks = responsesFormat.serialize({ text: "Hello" }, "codex-mini");
+      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!);
+      for (let i = 1; i < seqNumbers.length; i++) {
+        expect(seqNumbers[i]).toBe(seqNumbers[i - 1]! + 1);
+      }
+      expect(seqNumbers[0]).toBe(0);
+    });
+
+    it("uses same created_at across created, in_progress, and completed envelopes", () => {
+      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;
+      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");
+      expect(delta).toBeDefined();
+      const data = parse<ResponsesEvent>(delta!);
+      expect(data.delta).toBe("Hello");
+      expect(data.item_id).toBeTypeOf("string");
+    });
+
+    it("output items have status: in_progress when added, completed when done", () => {
+      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";
+      });
+      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";
+      });
+      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");
+      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");
+      expect(partDone).toBeDefined();
+      expect(parse<ResponsesEvent>(partDone!).part?.text).toBe("Hello");
+    });
+
+    it("emits reasoning events before message events", () => {
+      const chunks = responsesFormat.serialize(
+        { text: "42", reasoning: "Let me think..." },
+        "codex-mini",
+      );
+      const types = chunks.map((c) => parse<ResponsesEvent>(c).type);
+
+      expect(types).toContain("response.reasoning_summary_part.added");
+      expect(types).toContain("response.reasoning_summary_text.delta");
+      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 textDelta = types.indexOf("response.output_text.delta");
+      expect(reasoningDone).toBeLessThan(textDelta);
+    });
+
+    it("includes reasoning output item in completed response", () => {
+      const chunks = responsesFormat.serialize(
+        { text: "42", reasoning: "Let me think" },
+        "codex-mini",
+      );
+      const completed = parse<ResponsesEvent>(chunks.at(-1)!);
+      expect(completed.response?.output[0]!.type).toBe("reasoning");
+      expect(completed.response?.output[1]!.type).toBe("message");
+    });
+
+    it("accumulates text in completed output", () => {
+      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");
+    });
+
+    it("produces function_call events for tool calls", () => {
+      const chunks = responsesFormat.serialize(
+        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
+        "codex-mini",
+      );
+      const fnAdded = chunks.find((c) => {
+        const d = parse<ResponsesEvent>(c);
+        return d.type === "response.output_item.added" && d.item?.type === "function_call";
+      });
+      expect(fnAdded).toBeDefined();
+      const item = parse<ResponsesEvent>(fnAdded!).item!;
+      expect(item.name).toBe("read_file");
+      expect(item.status).toBe("in_progress");
+    });
+
+    it("no named events (responses uses data-only SSE)", () => {
+      const chunks = responsesFormat.serialize({ text: "hi" }, "codex-mini");
+      for (const chunk of chunks) {
+        expect(chunk.event).toBeUndefined();
+      }
+    });
+
+    it("works without reasoning events", () => {
+      const chunks = responsesFormat.serialize({ text: "hello" }, "codex-mini");
+      const completed = parse<ResponsesEvent>(chunks.at(-1)!);
+      expect(completed.response?.output).toHaveLength(1);
+      expect(completed.response?.output[0]!.type).toBe("message");
+    });
+  });
+
+  describe("serializeComplete (non-streaming)", () => {
+    it("produces correct top-level structure", () => {
+      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");
+      expect(result.created_at).toBeTypeOf("number");
+    });
+
+    it("includes message output item with status and annotations", () => {
+      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");
+      expect(msg.role).toBe("assistant");
+      expect(msg.content?.[0]?.type).toBe("output_text");
+      expect(msg.content?.[0]?.text).toBe("Hello, world!");
+      expect(msg.content?.[0]?.annotations).toEqual([]);
+    });
+
+    it("includes reasoning before message in output", () => {
+      const result = responsesFormat.serializeComplete(
+        { text: "42", reasoning: "Thinking..." },
+        "codex-mini",
+      ) as ResponsesComplete;
+      expect(result.output[0]!.type).toBe("reasoning");
+      expect(result.output[1]!.type).toBe("message");
+    });
+
+    it("includes function_call in output for tool calls", () => {
+      const result = responsesFormat.serializeComplete(
+        { tools: [{ name: "read_file", args: { path: "/tmp" } }] },
+        "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");
+    });
+
+    it("includes usage tokens", () => {
+      const result = responsesFormat.serializeComplete(
+        { text: "hi", usage: { input: 20, output: 15 } },
+        "codex-mini",
+      ) as ResponsesComplete;
+      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;
+      expect(result.error.message).toBe("Internal error");
+    });
+  });
+});