llm-mock-server 1.0.2 → 1.0.3

package/src/formats/openai/serialize.ts

@@ -1,6 +1,13 @@
 import type { ReplyObject, ReplyOptions } from "../../types.js";
 import type { SSEChunk } from "../types.js";
-import { splitText, genId, toolId, finishReason, MS_PER_SECOND, DEFAULT_USAGE } from "../serialize-helpers.js";
+import {
+  splitText,
+  genId,
+  toolId,
+  finishReason,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../serialize-helpers.js";
 
 function buildUsage(usage: { input: number; output: number }) {
   return {
@@ -8,18 +15,29 @@ function buildUsage(usage: { input: number; output: number }) {
     completion_tokens: usage.output,
     total_tokens: usage.input + usage.output,
     prompt_tokens_details: { cached_tokens: 0, audio_tokens: 0 },
-    completion_tokens_details: { reasoning_tokens: 0, audio_tokens: 0, accepted_prediction_tokens: 0, rejected_prediction_tokens: 0 },
+    completion_tokens_details: {
+      reasoning_tokens: 0,
+      audio_tokens: 0,
+      accepted_prediction_tokens: 0,
+      rejected_prediction_tokens: 0,
+    },
   };
 }
 
 function chunkEnvelope(
-  id: string, created: number, model: string,
-  delta: Record<string, unknown>, finish_reason: string | null = null,
+  id: string,
+  created: number,
+  model: string,
+  delta: Record<string, unknown>,
+  finish_reason: string | null = null,
   usage: Record<string, unknown> | null = null,
 ): SSEChunk {
   return {
     data: JSON.stringify({
-      id, object: "chat.completion.chunk", created, model,
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
       system_fingerprint: null,
       service_tier: "default",
       choices: [{ index: 0, delta, logprobs: null, finish_reason }],
@@ -28,7 +46,11 @@ function chunkEnvelope(
   };
 }
 
-export function serialize(reply: ReplyObject, model: string, options: ReplyOptions = {}): readonly SSEChunk[] {
+export function serialize(
+  reply: ReplyObject,
+  model: string,
+  options: ReplyOptions = {},
+): readonly SSEChunk[] {
   const id = genId("chatcmpl");
   const created = Math.floor(Date.now() / MS_PER_SECOND);
   const usage = reply.usage ?? DEFAULT_USAGE;
@@ -41,10 +63,14 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
 
   const toolChunks = (reply.tools ?? []).map((tool, i) =>
     chunkEnvelope(id, created, model, {
-      tool_calls: [{
-        index: i, id: toolId(tool, "call", i), type: "function",
-        function: { name: tool.name, arguments: JSON.stringify(tool.args) },
-      }],
+      tool_calls: [
+        {
+          index: i,
+          id: toolId(tool, "call", i),
+          type: "function",
+          function: { name: tool.name, arguments: JSON.stringify(tool.args) },
+        },
+      ],
     }),
   );
 
@@ -54,13 +80,22 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
     chunkEnvelope(id, created, model, { role: "assistant" }),
     ...textChunks,
     ...toolChunks,
-    chunkEnvelope(id, created, model, {}, finishReason(reply, "tool_calls", "stop")),
+    chunkEnvelope(
+      id,
+      created,
+      model,
+      {},
+      finishReason(reply, "tool_calls", "stop"),
+    ),
     chunkEnvelope(id, created, model, {}, null, usageChunk),
     { data: "[DONE]" },
   ];
 }
 
-export function serializeComplete(reply: ReplyObject, model: string): Record<string, unknown> {
+export function serializeComplete(
+  reply: ReplyObject,
+  model: string,
+): Record<string, unknown> {
   const id = genId("chatcmpl");
   const created = Math.floor(Date.now() / MS_PER_SECOND);
   const usage = reply.usage ?? DEFAULT_USAGE;
@@ -70,21 +105,42 @@ export function serializeComplete(reply: ReplyObject, model: string): Record<str
     content: reply.text ?? null,
     ...(reply.tools?.length && {
       tool_calls: reply.tools.map((tool, i) => ({
-        id: toolId(tool, "call", i), type: "function",
+        id: toolId(tool, "call", i),
+        type: "function",
         function: { name: tool.name, arguments: JSON.stringify(tool.args) },
       })),
     }),
   };
 
   return {
-    id, object: "chat.completion", created, model,
+    id,
+    object: "chat.completion",
+    created,
+    model,
     system_fingerprint: null,
     service_tier: "default",
-    choices: [{ index: 0, message, logprobs: null, finish_reason: finishReason(reply, "tool_calls", "stop") }],
+    choices: [
+      {
+        index: 0,
+        message,
+        logprobs: null,
+        finish_reason: finishReason(reply, "tool_calls", "stop"),
+      },
+    ],
     usage: buildUsage(usage),
   };
 }
 
-export function serializeError(error: { status: number; message: string; type?: string }): Record<string, unknown> {
-  return { error: { message: error.message, type: error.type ?? "server_error", code: null } };
+export function serializeError(error: {
+  status: number;
+  message: string;
+  type?: string;
+}): Record<string, unknown> {
+  return {
+    error: {
+      message: error.message,
+      type: error.type ?? "server_error",
+      code: null,
+    },
+  };
 }

package/src/formats/request-helpers.ts

@@ -1,7 +1,8 @@
 import type { FormatName, Message, MockRequest, ToolDef } from "../types.js";
 
 function asRecord(body: unknown): Record<string, unknown> {
-  if (typeof body === "object" && body !== null) return body as Record<string, unknown>;
+  if (typeof body === "object" && body !== null)
+    return body as Record<string, unknown>;
   return {};
 }
 

package/src/formats/responses/parse.ts

@@ -1,8 +1,14 @@
 import type { MockRequest, Message, ToolDef } from "../../types.js";
 import { buildMockRequest, type RequestMeta } from "../request-helpers.js";
-import { ResponsesRequestSchema, FunctionToolSchema, type ResponsesRequest } from "./schema.js";
+import {
+  ResponsesRequestSchema,
+  FunctionToolSchema,
+  type ResponsesRequest,
+} from "./schema.js";
 
-function extractInputContent(content: string | Record<string, unknown>[]): string {
+function extractInputContent(
+  content: string | Record<string, unknown>[],
+): string {
   if (typeof content === "string") return content;
   return content
     .filter((b) => b["type"] === "input_text" || b["type"] === "text")
@@ -52,5 +58,13 @@ function parseTools(req: ResponsesRequest): readonly ToolDef[] | undefined {
 
 export function parseRequest(body: unknown, meta?: RequestMeta): MockRequest {
   const req = ResponsesRequestSchema.parse(body);
-  return buildMockRequest("responses", req, parseInput(req), parseTools(req), "codex-mini", body, meta);
+  return buildMockRequest(
+    "responses",
+    req,
+    parseInput(req),
+    parseTools(req),
+    "codex-mini",
+    body,
+    meta,
+  );
 }

package/src/formats/responses/schema.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 
-export { ResponsesRequestSchema, FunctionToolSchema, type ResponsesRequest } from "llm-schemas/openai/responses";
+export {
+  ResponsesRequestSchema,
+  FunctionToolSchema,
+  type ResponsesRequest,
+} from "llm-schemas/openai/responses";
 
 const OutputContentSchema = z.object({
   type: z.string(),
@@ -23,25 +27,31 @@ const OutputItemSchema = z.object({
 export const ResponsesEventSchema = z.object({
   type: z.string(),
   sequence_number: z.number().optional(),
-  response: z.object({
-    id: z.string(),
-    object: z.string(),
-    created_at: z.number(),
-    model: z.string(),
-    status: z.string(),
-    output: z.array(OutputItemSchema),
-    usage: z.object({
-      input_tokens: z.number(),
-      output_tokens: z.number(),
-      total_tokens: z.number(),
-    }).optional(),
-  }).optional(),
+  response: z
+    .object({
+      id: z.string(),
+      object: z.string(),
+      created_at: z.number(),
+      model: z.string(),
+      status: z.string(),
+      output: z.array(OutputItemSchema),
+      usage: z
+        .object({
+          input_tokens: z.number(),
+          output_tokens: z.number(),
+          total_tokens: z.number(),
+        })
+        .optional(),
+    })
+    .optional(),
   item: OutputItemSchema.optional(),
-  part: z.object({
-    type: z.string(),
-    text: z.string().optional(),
-    annotations: z.array(z.unknown()).optional(),
-  }).optional(),
+  part: z
+    .object({
+      type: z.string(),
+      text: z.string().optional(),
+      annotations: z.array(z.unknown()).optional(),
+    })
+    .optional(),
   delta: z.string().optional(),
   item_id: z.string().optional(),
 });
@@ -66,7 +76,11 @@ export type ResponsesComplete = z.infer<typeof ResponsesCompleteSchema>;
 
 export const ResponsesErrorSchema = z.object({
   type: z.literal("error"),
-  error: z.object({ message: z.string(), type: z.string().optional(), code: z.string().optional() }),
+  error: z.object({
+    message: z.string(),
+    type: z.string().optional(),
+    code: z.string().optional(),
+  }),
 });
 
 export type ResponsesError = z.infer<typeof ResponsesErrorSchema>;

package/src/formats/responses/serialize.ts

@@ -1,12 +1,26 @@
 import type { ReplyObject, ReplyOptions, ToolCall } from "../../types.js";
 import type { SSEChunk } from "../types.js";
-import { splitText, genId, toolId, shouldEmitText, MS_PER_SECOND, DEFAULT_USAGE } from "../serialize-helpers.js";
+import {
+  splitText,
+  genId,
+  toolId,
+  shouldEmitText,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../serialize-helpers.js";
 
 function buildUsage(usage: { input: number; output: number }) {
-  return { input_tokens: usage.input, output_tokens: usage.output, total_tokens: usage.input + usage.output };
+  return {
+    input_tokens: usage.input,
+    output_tokens: usage.output,
+    total_tokens: usage.input + usage.output,
+  };
 }
 
-interface StreamBlock { chunks: SSEChunk[]; outputItem: unknown }
+interface StreamBlock {
+  chunks: SSEChunk[];
+  outputItem: unknown;
+}
 
 const NO_ANNOTATIONS: readonly unknown[] = [];
 
@@ -14,43 +28,140 @@ type Chunk = (payload: Record<string, unknown>) => SSEChunk;
 
 function createChunk(): Chunk {
   let seq = 0;
-  return (payload) => ({ data: JSON.stringify({ ...payload, sequence_number: seq++ }) });
+  return (payload) => ({
+    data: JSON.stringify({ ...payload, sequence_number: seq++ }),
+  });
 }
 
-function reasoningStreamBlock(c: Chunk, i: number, reasoning: string): StreamBlock {
+function reasoningStreamBlock(
+  c: Chunk,
+  i: number,
+  reasoning: string,
+): StreamBlock {
   const itemId = `rs_${genId("rs")}`;
   const summaryPart = { type: "summary_text" as const, text: reasoning };
-  const item = { type: "reasoning", id: itemId, status: "completed", summary: [summaryPart] };
+  const item = {
+    type: "reasoning",
+    id: itemId,
+    status: "completed",
+    summary: [summaryPart],
+  };
 
   return {
     outputItem: item,
     chunks: [
-      c({ type: "response.output_item.added", output_index: i, item: { type: "reasoning", id: itemId, status: "in_progress", summary: [] } }),
-      c({ type: "response.reasoning_summary_part.added", item_id: itemId, output_index: i, summary_index: 0, part: { type: "summary_text", text: "" } }),
-      c({ type: "response.reasoning_summary_text.delta", item_id: itemId, output_index: i, summary_index: 0, delta: reasoning }),
-      c({ type: "response.reasoning_summary_text.done", item_id: itemId, output_index: i, summary_index: 0, text: reasoning }),
-      c({ type: "response.reasoning_summary_part.done", item_id: itemId, output_index: i, summary_index: 0, part: summaryPart }),
+      c({
+        type: "response.output_item.added",
+        output_index: i,
+        item: {
+          type: "reasoning",
+          id: itemId,
+          status: "in_progress",
+          summary: [],
+        },
+      }),
+      c({
+        type: "response.reasoning_summary_part.added",
+        item_id: itemId,
+        output_index: i,
+        summary_index: 0,
+        part: { type: "summary_text", text: "" },
+      }),
+      c({
+        type: "response.reasoning_summary_text.delta",
+        item_id: itemId,
+        output_index: i,
+        summary_index: 0,
+        delta: reasoning,
+      }),
+      c({
+        type: "response.reasoning_summary_text.done",
+        item_id: itemId,
+        output_index: i,
+        summary_index: 0,
+        text: reasoning,
+      }),
+      c({
+        type: "response.reasoning_summary_part.done",
+        item_id: itemId,
+        output_index: i,
+        summary_index: 0,
+        part: summaryPart,
+      }),
       c({ type: "response.output_item.done", output_index: i, item }),
     ],
   };
 }
 
-function textStreamBlock(c: Chunk, i: number, text: string, chunkSize: number): StreamBlock {
+function textStreamBlock(
+  c: Chunk,
+  i: number,
+  text: string,
+  chunkSize: number,
+): StreamBlock {
   const itemId = `msg_${genId("msg")}`;
-  const outputText = { type: "output_text" as const, text, annotations: NO_ANNOTATIONS };
-  const outputItem = { type: "message", id: itemId, status: "completed", role: "assistant", content: [outputText] };
+  const outputText = {
+    type: "output_text" as const,
+    text,
+    annotations: NO_ANNOTATIONS,
+  };
+  const outputItem = {
+    type: "message",
+    id: itemId,
+    status: "completed",
+    role: "assistant",
+    content: [outputText],
+  };
 
   return {
     outputItem,
     chunks: [
-      c({ type: "response.output_item.added", output_index: i, item: { type: "message", id: itemId, status: "in_progress", role: "assistant", content: [] } }),
-      c({ type: "response.content_part.added", item_id: itemId, output_index: i, content_index: 0, part: { type: "output_text", text: "", annotations: [] } }),
+      c({
+        type: "response.output_item.added",
+        output_index: i,
+        item: {
+          type: "message",
+          id: itemId,
+          status: "in_progress",
+          role: "assistant",
+          content: [],
+        },
+      }),
+      c({
+        type: "response.content_part.added",
+        item_id: itemId,
+        output_index: i,
+        content_index: 0,
+        part: { type: "output_text", text: "", annotations: [] },
+      }),
       ...splitText(text, chunkSize).map((piece) =>
-        c({ type: "response.output_text.delta", item_id: itemId, output_index: i, content_index: 0, delta: piece }),
+        c({
+          type: "response.output_text.delta",
+          item_id: itemId,
+          output_index: i,
+          content_index: 0,
+          delta: piece,
+        }),
       ),
-      c({ type: "response.output_text.done", item_id: itemId, output_index: i, content_index: 0, text }),
-      c({ type: "response.content_part.done", item_id: itemId, output_index: i, content_index: 0, part: outputText }),
-      c({ type: "response.output_item.done", output_index: i, item: outputItem }),
+      c({
+        type: "response.output_text.done",
+        item_id: itemId,
+        output_index: i,
+        content_index: 0,
+        text,
+      }),
+      c({
+        type: "response.content_part.done",
+        item_id: itemId,
+        output_index: i,
+        content_index: 0,
+        part: outputText,
+      }),
+      c({
+        type: "response.output_item.done",
+        output_index: i,
+        item: outputItem,
+      }),
     ],
   };
 }
@@ -58,20 +169,49 @@ function textStreamBlock(c: Chunk, i: number, text: string, chunkSize: number):
 function toolStreamBlock(c: Chunk, i: number, tool: ToolCall): StreamBlock {
   const callId = toolId(tool, "call", i);
   const argsJson = JSON.stringify(tool.args);
-  const outputItem = { type: "function_call", id: callId, status: "completed", name: tool.name, call_id: callId, arguments: argsJson };
+  const outputItem = {
+    type: "function_call",
+    id: callId,
+    status: "completed",
+    name: tool.name,
+    call_id: callId,
+    arguments: argsJson,
+  };
 
   return {
     outputItem,
     chunks: [
-      c({ type: "response.output_item.added", output_index: i, item: { ...outputItem, status: "in_progress", arguments: "" } }),
-      c({ type: "response.function_call_arguments.delta", item_id: callId, output_index: i, delta: argsJson }),
-      c({ type: "response.function_call_arguments.done", item_id: callId, output_index: i, arguments: argsJson }),
-      c({ type: "response.output_item.done", output_index: i, item: outputItem }),
+      c({
+        type: "response.output_item.added",
+        output_index: i,
+        item: { ...outputItem, status: "in_progress", arguments: "" },
+      }),
+      c({
+        type: "response.function_call_arguments.delta",
+        item_id: callId,
+        output_index: i,
+        delta: argsJson,
+      }),
+      c({
+        type: "response.function_call_arguments.done",
+        item_id: callId,
+        output_index: i,
+        arguments: argsJson,
+      }),
+      c({
+        type: "response.output_item.done",
+        output_index: i,
+        item: outputItem,
+      }),
     ],
   };
 }
 
-export function serialize(reply: ReplyObject, model: string, options: ReplyOptions = {}): readonly SSEChunk[] {
+export function serialize(
+  reply: ReplyObject,
+  model: string,
+  options: ReplyOptions = {},
+): readonly SSEChunk[] {
   const id = genId("resp");
   const createdAt = Math.floor(Date.now() / MS_PER_SECOND);
   const usage = reply.usage ?? DEFAULT_USAGE;
@@ -80,13 +220,21 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
 
   const baseResponse = { id, object: "response", created_at: createdAt, model };
   const header = [
-    c({ type: "response.created", response: { ...baseResponse, status: "in_progress", output: [] } }),
-    c({ type: "response.in_progress", response: { ...baseResponse, status: "in_progress", output: [] } }),
+    c({
+      type: "response.created",
+      response: { ...baseResponse, status: "in_progress", output: [] },
+    }),
+    c({
+      type: "response.in_progress",
+      response: { ...baseResponse, status: "in_progress", output: [] },
+    }),
   ];
 
   const blocks: StreamBlock[] = [
     ...(reply.reasoning ? [reasoningStreamBlock(c, i++, reply.reasoning)] : []),
-    ...(shouldEmitText(reply) ? [textStreamBlock(c, i++, reply.text ?? "", options.chunkSize ?? 0)] : []),
+    ...(shouldEmitText(reply)
+      ? [textStreamBlock(c, i++, reply.text ?? "", options.chunkSize ?? 0)]
+      : []),
     ...(reply.tools ?? []).map((tool) => toolStreamBlock(c, i++, tool)),
   ];
 
@@ -98,36 +246,83 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
     ...allChunks,
     c({
       type: "response.completed",
-      response: { ...baseResponse, status: "completed", output,
-        usage: buildUsage(usage) },
+      response: {
+        ...baseResponse,
+        status: "completed",
+        output,
+        usage: buildUsage(usage),
+      },
     }),
   ];
 }
 
-export function serializeComplete(reply: ReplyObject, model: string): Record<string, unknown> {
+export function serializeComplete(
+  reply: ReplyObject,
+  model: string,
+): Record<string, unknown> {
   const id = genId("resp");
   const createdAt = Math.floor(Date.now() / MS_PER_SECOND);
   const usage = reply.usage ?? DEFAULT_USAGE;
 
   const output: unknown[] = [
     ...(reply.reasoning
-      ? [{ type: "reasoning", id: `rs_${genId("rs")}`, status: "completed", summary: [{ type: "summary_text", text: reply.reasoning }] }]
+      ? [
+          {
+            type: "reasoning",
+            id: `rs_${genId("rs")}`,
+            status: "completed",
+            summary: [{ type: "summary_text", text: reply.reasoning }],
+          },
+        ]
       : []),
     ...(shouldEmitText(reply)
-      ? [{ type: "message", id: `msg_${genId("msg")}`, status: "completed", role: "assistant", content: [{ type: "output_text", text: reply.text ?? "", annotations: [] }] }]
+      ? [
+          {
+            type: "message",
+            id: `msg_${genId("msg")}`,
+            status: "completed",
+            role: "assistant",
+            content: [
+              { type: "output_text", text: reply.text ?? "", annotations: [] },
+            ],
+          },
+        ]
       : []),
     ...(reply.tools ?? []).map((tool) => {
       const callId = toolId(tool, "call", 0);
-      return { type: "function_call", id: callId, status: "completed", name: tool.name, call_id: callId, arguments: JSON.stringify(tool.args) };
+      return {
+        type: "function_call",
+        id: callId,
+        status: "completed",
+        name: tool.name,
+        call_id: callId,
+        arguments: JSON.stringify(tool.args),
+      };
     }),
   ];
 
   return {
-    id, object: "response", created_at: createdAt, status: "completed", model, output,
+    id,
+    object: "response",
+    created_at: createdAt,
+    status: "completed",
+    model,
+    output,
     usage: buildUsage(usage),
   };
 }
 
-export function serializeError(error: { status: number; message: string; type?: string }): Record<string, unknown> {
-  return { type: "error", error: { message: error.message, type: error.type ?? "server_error", code: error.type ?? "server_error" } };
+export function serializeError(error: {
+  status: number;
+  message: string;
+  type?: string;
+}): Record<string, unknown> {
+  return {
+    type: "error",
+    error: {
+      message: error.message,
+      type: error.type ?? "server_error",
+      code: error.type ?? "server_error",
+    },
+  };
 }

package/src/formats/serialize-helpers.ts

@@ -17,7 +17,11 @@ export function genId(prefix: string): string {
   return `${prefix}_${Date.now().toString(BASE_36)}`;
 }
 
-export function toolId(tool: { id?: string | undefined }, prefix: string, index: number): string {
+export function toolId(
+  tool: { id?: string | undefined },
+  prefix: string,
+  index: number,
+): string {
   return tool.id ?? `${prefix}_${Date.now().toString(BASE_36)}_${index}`;
 }
 
@@ -25,6 +29,10 @@ export function shouldEmitText(reply: ReplyObject): boolean {
   return Boolean(reply.text) || (!reply.tools?.length && !reply.reasoning);
 }
 
-export function finishReason(reply: ReplyObject, onTools: string, onStop: string): string {
+export function finishReason(
+  reply: ReplyObject,
+  onTools: string,
+  onStop: string,
+): string {
   return reply.tools?.length ? onTools : onStop;
 }

package/src/formats/types.ts

@@ -1,4 +1,9 @@
-import type { FormatName, MockRequest, ReplyObject, ReplyOptions } from "../types.js";
+import type {
+  FormatName,
+  MockRequest,
+  ReplyObject,
+  ReplyOptions,
+} from "../types.js";
 import type { RequestMeta } from "./request-helpers.js";
 
 export interface SSEChunk {
@@ -11,7 +16,15 @@ export interface Format {
   readonly route: string;
   parseRequest(body: unknown, meta?: RequestMeta): MockRequest;
   isStreaming(body: unknown): boolean;
-  serialize(reply: ReplyObject, model: string, options?: ReplyOptions): readonly SSEChunk[];
+  serialize(
+    reply: ReplyObject,
+    model: string,
+    options?: ReplyOptions,
+  ): readonly SSEChunk[];
   serializeComplete(reply: ReplyObject, model: string): Record<string, unknown>;
-  serializeError(error: { status: number; message: string; type?: string | undefined }): Record<string, unknown>;
+  serializeError(error: {
+    status: number;
+    message: string;
+    type?: string | undefined;
+  }): Record<string, unknown>;
 }