llm-mock-server 1.0.1 → 1.0.3

package/src/formats/responses/serialize.ts

@@ -1,8 +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 "../parse-helpers.js";
+import {
+  splitText,
+  genId,
+  toolId,
+  shouldEmitText,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../serialize-helpers.js";
 
-interface StreamBlock { chunks: SSEChunk[]; outputItem: unknown }
+function buildUsage(usage: { input: number; output: number }) {
+  return {
+    input_tokens: usage.input,
+    output_tokens: usage.output,
+    total_tokens: usage.input + usage.output,
+  };
+}
+
+interface StreamBlock {
+  chunks: SSEChunk[];
+  outputItem: unknown;
+}
 
 const NO_ANNOTATIONS: readonly unknown[] = [];
 
@@ -10,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,
+      }),
     ],
   };
 }
@@ -54,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;
@@ -76,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)),
   ];
 
@@ -94,36 +246,83 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
     ...allChunks,
     c({
       type: "response.completed",
-      response: { ...baseResponse, status: "completed", output,
-        usage: { input_tokens: usage.input, output_tokens: usage.output, total_tokens: usage.input + usage.output } },
+      response: {
+        ...baseResponse,
+        status: "completed",
+        output,
+        usage: buildUsage(usage),
+      },
     }),
   ];
 }
 
-export function serializeComplete(reply: ReplyObject, model: 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,
-    usage: { input_tokens: usage.input, output_tokens: usage.output, total_tokens: usage.input + usage.output },
+    id,
+    object: "response",
+    created_at: createdAt,
+    status: "completed",
+    model,
+    output,
+    usage: buildUsage(usage),
   };
 }
 
-export function serializeError(error: { status: number; message: string; type?: 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

@@ -0,0 +1,38 @@
+import type { ReplyObject } from "../types.js";
+
+export const MS_PER_SECOND = 1000;
+const BASE_36 = 36;
+export const DEFAULT_USAGE = { input: 10, output: 5 } as const;
+
+export function splitText(text: string, chunkSize: number): string[] {
+  if (chunkSize <= 0 || text.length <= chunkSize) return [text];
+  const chunks: string[] = [];
+  for (let i = 0; i < text.length; i += chunkSize) {
+    chunks.push(text.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+
+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 {
+  return tool.id ?? `${prefix}_${Date.now().toString(BASE_36)}_${index}`;
+}
+
+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 {
+  return reply.tools?.length ? onTools : onStop;
+}

package/src/formats/types.ts

@@ -1,5 +1,10 @@
-import type { FormatName, MockRequest, ReplyObject, ReplyOptions } from "../types.js";
-import type { RequestMeta } from "./parse-helpers.js";
+import type {
+  FormatName,
+  MockRequest,
+  ReplyObject,
+  ReplyOptions,
+} from "../types.js";
+import type { RequestMeta } from "./request-helpers.js";
 
 export interface SSEChunk {
   readonly event?: string | undefined;
@@ -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[];
-  serializeComplete(reply: ReplyObject, model: string): unknown;
-  serializeError(error: { status: number; message: string; type?: string | undefined }): unknown;
+  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>;
 }

package/src/index.ts

@@ -37,7 +37,9 @@ import type { MockServerOptions } from "./mock-server.js";
  * await server.stop();
  * ```
  */
-export async function createMock(options: MockServerOptions = {}): Promise<MockServer> {
+export async function createMock(
+  options: MockServerOptions = {},
+): Promise<MockServer> {
   const server = new MockServer(options);
   await server.start(options.port ?? 0);
   return server;

package/src/loader.ts

@@ -3,9 +3,9 @@ import { join, extname } from "node:path";
 import JSON5 from "json5";
 import { z } from "zod";
 import type { Handler, Match, MatchObject, Reply } from "./types.js";
-import type { RuleEngine } from "./rule-engine.js";
+import { type RuleEngine, createSequenceResolver } from "./rule-engine.js";
 
-export interface LoadContext {
+interface LoadContext {
   engine: RuleEngine;
   setFallback?: (reply: Reply) => void;
 }
@@ -25,7 +25,11 @@ const json5ReplySchema = z.union([
   z.object({
     text: z.string().optional(),
     reasoning: z.string().optional(),
-    tools: z.array(z.object({ name: z.string(), args: z.record(z.string(), z.unknown()) })).optional(),
+    tools: z
+      .array(
+        z.object({ name: z.string(), args: z.record(z.string(), z.unknown()) }),
+      )
+      .optional(),
   }),
 ]);
 
@@ -77,7 +81,9 @@ function compileMatch(when: z.infer<typeof json5MatchSchema>): Match {
     return parseRegexString(when);
   }
   const obj: MatchObject = {
-    ...(when.message !== undefined && { message: parseRegexString(when.message) }),
+    ...(when.message !== undefined && {
+      message: parseRegexString(when.message),
+    }),
     ...(when.model !== undefined && { model: parseRegexString(when.model) }),
     ...(when.system !== undefined && { system: parseRegexString(when.system) }),
     ...(when.format !== undefined && { format: when.format }),
@@ -106,8 +112,7 @@ function addSequenceRule(
   templates: Templates,
   filePath: string,
 ): void {
-  let index = 0;
-  const resolved = entries.map((entry) => {
+  const steps = entries.map((entry) => {
     if (typeof entry === "string" || !("reply" in entry)) {
       return { reply: resolveReplyRef(entry, templates, filePath) };
     }
@@ -119,23 +124,27 @@ function addSequenceRule(
       },
     };
   });
-  const lastStep = resolved[resolved.length - 1]!;
-  const rule = engine.add(match, () => {
-    const step = resolved[index++] ?? lastStep;
-    rule.options = step.options ?? {};
-    return step.reply;
-  });
-  rule.remaining = resolved.length;
+  const rule = engine.add(match, "");
+  const { resolver, entryCount } = createSequenceResolver(steps, rule);
+  rule.resolve = resolver;
+  rule.remaining = entryCount;
 }
 
-async function loadJson5File(filePath: string, ctx: LoadContext): Promise<void> {
+async function loadJson5File(
+  filePath: string,
+  ctx: LoadContext,
+): Promise<void> {
   const content = await readFile(filePath, "utf-8");
   const parsed = json5FileSchema.parse(JSON5.parse(content));
 
   const rules = Array.isArray(parsed) ? parsed : parsed.rules;
   const templates = Array.isArray(parsed) ? undefined : parsed.templates;
 
-  if (!Array.isArray(parsed) && parsed.fallback !== undefined && ctx.setFallback) {
+  if (
+    !Array.isArray(parsed) &&
+    parsed.fallback !== undefined &&
+    ctx.setFallback
+  ) {
     ctx.setFallback(parsed.fallback);
   }
 
@@ -156,7 +165,9 @@ async function loadJson5File(filePath: string, ctx: LoadContext): Promise<void>
 const handlerSchema = z.custom<Handler>((val): val is Handler => {
   if (typeof val !== "object" || val === null) return false;
   const obj = val as Record<string, unknown>;
-  return typeof obj["match"] === "function" && typeof obj["respond"] === "function";
+  return (
+    typeof obj["match"] === "function" && typeof obj["respond"] === "function"
+  );
 });
 
 const handlerExportSchema = z.object({
@@ -164,7 +175,10 @@ const handlerExportSchema = z.object({
   fallback: json5ReplySchema.optional(),
 });
 
-async function loadHandlerFile(filePath: string, ctx: LoadContext): Promise<void> {
+async function loadHandlerFile(
+  filePath: string,
+  ctx: LoadContext,
+): Promise<void> {
   const mod = await import(filePath);
   const parsed = handlerExportSchema.safeParse(mod);
   if (!parsed.success) {
@@ -172,14 +186,20 @@ async function loadHandlerFile(filePath: string, ctx: LoadContext): Promise<void
       `Invalid handler file ${filePath}. Expected default export with { match: Function, respond: Function }.`,
     );
   }
-  const handlers = Array.isArray(parsed.data.default) ? parsed.data.default : [parsed.data.default];
+  const handlers = Array.isArray(parsed.data.default)
+    ? parsed.data.default
+    : [parsed.data.default];
 
   if (parsed.data.fallback !== undefined && ctx.setFallback) {
     ctx.setFallback(parsed.data.fallback);
   }
 
   for (const handler of handlers) {
-    ctx.engine.addHandler(handler.match, handler.respond, `(handler: ${filePath})`);
+    ctx.engine.addHandler(
+      handler.match,
+      handler.respond,
+      `(handler: ${filePath})`,
+    );
   }
 }
 
@@ -193,7 +213,10 @@ const loaderByExtension: ReadonlyMap<string, FileLoader> = new Map([
   [".mjs", loadHandlerFile],
 ]);
 
-export async function loadRulesFromPath(pathOrDir: string, ctx: LoadContext): Promise<void> {
+export async function loadRulesFromPath(
+  pathOrDir: string,
+  ctx: LoadContext,
+): Promise<void> {
   const info = await stat(pathOrDir);
 
   if (info.isFile()) {

package/src/logger.ts

@@ -19,6 +19,18 @@ const LEVEL_STYLE = {
   debug: { label: pc.dim("DEBUG"), symbol: pc.dim("·") },
 } as const;
 
+type ConsoleMethod = "error" | "warn" | "log";
+
+const LEVEL_CONFIG: Record<
+  keyof typeof LEVEL_STYLE,
+  { priority: number; method: ConsoleMethod; dim?: boolean }
+> = {
+  error: { priority: LEVEL_PRIORITY.error, method: "error" },
+  warn: { priority: LEVEL_PRIORITY.warning, method: "warn" },
+  info: { priority: LEVEL_PRIORITY.info, method: "log" },
+  debug: { priority: LEVEL_PRIORITY.debug, method: "log", dim: true },
+};
+
 export class Logger {
   readonly level: LogLevel;
   private threshold: number;
@@ -28,31 +40,31 @@ export class Logger {
     this.threshold = LEVEL_PRIORITY[level];
   }
 
-  error(msg: string, ...args: unknown[]): void {
-    if (this.threshold >= LEVEL_PRIORITY.error) {
-      const { label, symbol } = LEVEL_STYLE.error;
-      console.error(`${pc.dim(new Date().toISOString())} ${symbol} ${label} ${msg}`, ...args);
-    }
+  private log(
+    key: keyof typeof LEVEL_STYLE,
+    msg: string,
+    args: unknown[],
+  ): void {
+    const config = LEVEL_CONFIG[key];
+    if (this.threshold < config.priority) return;
+    const { label, symbol } = LEVEL_STYLE[key];
+    const text = config.dim ? pc.dim(msg) : msg;
+    console[config.method](
+      `${pc.dim(new Date().toISOString())} ${symbol} ${label} ${text}`,
+      ...args,
+    );
   }
 
+  error(msg: string, ...args: unknown[]): void {
+    this.log("error", msg, args);
+  }
   warn(msg: string, ...args: unknown[]): void {
-    if (this.threshold >= LEVEL_PRIORITY.warning) {
-      const { label, symbol } = LEVEL_STYLE.warn;
-      console.warn(`${pc.dim(new Date().toISOString())} ${symbol} ${label} ${msg}`, ...args);
-    }
+    this.log("warn", msg, args);
   }
-
   info(msg: string, ...args: unknown[]): void {
-    if (this.threshold >= LEVEL_PRIORITY.info) {
-      const { label, symbol } = LEVEL_STYLE.info;
-      console.log(`${pc.dim(new Date().toISOString())} ${symbol} ${label} ${msg}`, ...args);
-    }
+    this.log("info", msg, args);
   }
-
   debug(msg: string, ...args: unknown[]): void {
-    if (this.threshold >= LEVEL_PRIORITY.debug) {
-      const { label, symbol } = LEVEL_STYLE.debug;
-      console.log(`${pc.dim(new Date().toISOString())} ${symbol} ${label} ${pc.dim(msg)}`, ...args);
-    }
+    this.log("debug", msg, args);
   }
 }