llm-mock-server 1.0.6 → 1.0.8

package/src/cli/cli.ts

@@ -1,141 +0,0 @@
-#!/usr/bin/env node
-
-import { watch } from "node:fs";
-import { createRequire } from "node:module";
-import { Command } from "commander";
-import pc from "picocolors";
-import { MockServer } from "#/mock-server.js";
-import { Logger } from "#/logger.js";
-import {
-  parsePort,
-  parseHost,
-  parseLogLevel,
-  parseChunkSize,
-  parseLatency,
-} from "./validators.js";
-
-const require = createRequire(import.meta.url);
-const { version } = require("../../package.json") as { version: string };
-
-const WATCH_DEBOUNCE_MS = 100;
-
-interface StartOptions {
-  port: string;
-  host: string;
-  rules?: string;
-  latency: string;
-  chunkSize: string;
-  fallback?: string;
-  logLevel: string;
-  watch?: boolean;
-}
-
-async function start(options: StartOptions): Promise<void> {
-  const logLevel = parseLogLevel(options.logLevel);
-  const logger = new Logger(logLevel);
-  const port = parsePort(options.port);
-  const host = await parseHost(options.host);
-  const latency = parseLatency(options.latency);
-  const chunkSize = parseChunkSize(options.chunkSize);
-
-  const server = new MockServer({
-    port,
-    host,
-    logLevel,
-    ...(latency > 0 && { defaultLatency: latency }),
-    ...(chunkSize > 0 && { defaultChunkSize: chunkSize }),
-  });
-
-  if (options.fallback) {
-    server.fallback(options.fallback);
-  }
-
-  if (options.rules) {
-    await server.load(options.rules);
-  }
-
-  const quiet = logLevel === "none";
-
-  await server.start(port);
-
-  if (!quiet) {
-    console.log();
-    console.log(
-      `  ${pc.bold(pc.cyan("llm-mock-server"))} ${pc.dim(`v${version}`)}`,
-    );
-    console.log();
-    console.log(`  ${pc.dim("Port")}       ${pc.bold(String(port))}`);
-    console.log(
-      `  ${pc.dim("Rules")}      ${pc.bold(String(server.ruleCount))} loaded`,
-    );
-    if (latency > 0) {
-      console.log(
-        `  ${pc.dim("Latency")}    ${pc.bold(`${String(latency)}ms`)} per chunk`,
-      );
-    }
-    console.log(
-      `  ${pc.dim("Endpoints")}  ${server.routes.map((r) => pc.green(r)).join(", ")}`,
-    );
-    console.log();
-  }
-
-  if (options.watch && options.rules) {
-    const rulesPath = options.rules;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    watch(rulesPath, { recursive: true }, () => {
-      clearTimeout(timer);
-      timer = setTimeout(async () => {
-        try {
-          server.reset();
-          await server.load(rulesPath);
-          if (options.fallback) server.fallback(options.fallback);
-          logger.info(`Reloaded rules from ${rulesPath}`);
-        } catch (err) {
-          logger.error("Failed to reload rules", err);
-        }
-      }, WATCH_DEBOUNCE_MS);
-    });
-    logger.info(`Watching ${rulesPath} for changes`);
-  }
-
-  let shuttingDown = false;
-  const shutdown = async (signal: string) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-
-    logger.info(`Got ${signal}, shutting down...`);
-    await server.stop();
-    logger.info("Clean shutdown complete");
-    process.exit(0);
-  };
-
-  process.on("SIGINT", () => {
-    shutdown("SIGINT").catch(() => process.exit(1));
-  });
-  process.on("SIGTERM", () => {
-    shutdown("SIGTERM").catch(() => process.exit(1));
-  });
-}
-
-const program = new Command()
-  .name("llm-mock-server")
-  .description("Mock LLM server for deterministic testing")
-  .version(version);
-
-program
-  .command("start", { isDefault: true })
-  .description("Start the mock server")
-  .option("-p, --port <number>", "port to listen on", "5555")
-  .option("-H, --host <address>", "host to bind to", "127.0.0.1")
-  .option("-r, --rules <path>", "path to rules file or directory")
-  .option("-l, --latency <ms>", "latency between SSE chunks (ms)", "0")
-  .option("-c, --chunk-size <chars>", "characters per SSE chunk", "0")
-  .option("-f, --fallback <text>", "fallback reply text")
-  .option("-w, --watch", "watch rules path and reload on changes")
-  .option("--log-level <level>", "log verbosity", "info")
-  .action((options: StartOptions) => start(options));
-
-program.parseAsync().catch((err: unknown) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});

package/src/cli/validators.ts

@@ -1,68 +0,0 @@
-import { isIP } from "node:net";
-import { lookup } from "node:dns/promises";
-import { LEVEL_PRIORITY, type LogLevel } from "#/logger.js";
-
-const VALID_LOG_LEVELS: string[] = Object.keys(LEVEL_PRIORITY);
-
-function parseStrictInt(value: string): number {
-  if (!/^\d+$/.test(value)) return NaN;
-  return Number(value);
-}
-
-const MAX_PORT = 65535;
-
-export function parsePort(value: string): number {
-  const port = parseStrictInt(value);
-  if (isNaN(port) || port < 1 || port > MAX_PORT) {
-    throw new Error(`Invalid port "${value}". Must be 1-${String(MAX_PORT)}.`);
-  }
-  return port;
-}
-
-export function parseLogLevel(value: string): LogLevel {
-  if (!VALID_LOG_LEVELS.includes(value)) {
-    throw new Error(
-      `Invalid log level "${value}". Valid: ${VALID_LOG_LEVELS.join(", ")}`,
-    );
-  }
-  return value as LogLevel;
-}
-
-export async function parseHost(value: string): Promise<string> {
-  if (!value) {
-    throw new Error(
-      `Invalid host "${value}". Must be a resolvable hostname or IP address.`,
-    );
-  }
-  if (value === "localhost" || isIP(value) !== 0) {
-    return value;
-  }
-  try {
-    await lookup(value);
-    return value;
-  } catch {
-    throw new Error(
-      `Invalid host "${value}". Must be a resolvable hostname or IP address.`,
-    );
-  }
-}
-
-export function parseChunkSize(value: string): number {
-  const size = parseStrictInt(value);
-  if (isNaN(size) || size < 0) {
-    throw new Error(
-      `Invalid chunk size "${value}". Must be a non-negative integer.`,
-    );
-  }
-  return size;
-}
-
-export function parseLatency(value: string): number {
-  const ms = parseStrictInt(value);
-  if (isNaN(ms) || ms < 0) {
-    throw new Error(
-      `Invalid latency "${value}". Must be a non-negative integer (ms).`,
-    );
-  }
-  return ms;
-}

package/src/formats/anthropic/index.ts

@@ -1,14 +0,0 @@
-import type { Format } from "#/formats/types.js";
-import { isStreaming } from "#/formats/request-helpers.js";
-import { parseRequest } from "./parse.js";
-import { serialize, serializeComplete, serializeError } from "./serialize.js";
-
-export const anthropicFormat: Format = {
-  name: "anthropic",
-  route: "/v1/messages",
-  parseRequest,
-  isStreaming,
-  serialize,
-  serializeComplete,
-  serializeError,
-};

package/src/formats/anthropic/parse.ts

@@ -1,70 +0,0 @@
-import type { MockRequest, Message, ToolDef } from "#/types/request.js";
-import {
-  buildMockRequest,
-  type RequestMeta,
-} from "#/formats/request-helpers.js";
-import { AnthropicRequestSchema, type AnthropicRequest } from "./schema.js";
-
-function extractSystem(system: AnthropicRequest["system"]): Message[] {
-  if (system == null) return [];
-  if (typeof system === "string")
-    return system ? [{ role: "system", content: system }] : [];
-  const text = system.map((b) => b.text).join("\n");
-  return text ? [{ role: "system", content: text }] : [];
-}
-
-function extractContent(
-  content: AnthropicRequest["messages"][number]["content"],
-): {
-  content: string;
-  toolCallId?: string | undefined;
-} {
-  if (typeof content === "string") return { content };
-  const text = content
-    .filter((b): b is { type: "text"; text: string } => b.type === "text")
-    .map((b) => b.text)
-    .join("\n");
-  const toolResult = content.find(
-    (b): b is { type: "tool_result"; tool_use_id: string } =>
-      b.type === "tool_result",
-  );
-  const toolCallId = toolResult?.tool_use_id;
-  return { content: text, toolCallId };
-}
-
-function parseMessages(req: AnthropicRequest): readonly Message[] {
-  const system = extractSystem(req.system);
-  const conversation = req.messages.map((m) => {
-    const extracted = extractContent(m.content);
-    return {
-      role: m.role,
-      content: extracted.content,
-      ...(extracted.toolCallId !== undefined && {
-        toolCallId: extracted.toolCallId,
-      }),
-    };
-  });
-  return [...system, ...conversation];
-}
-
-function parseTools(req: AnthropicRequest): readonly ToolDef[] | undefined {
-  if (!req.tools) return undefined;
-  return req.tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: t.input_schema,
-  }));
-}
-
-export function parseRequest(body: unknown, meta?: RequestMeta): MockRequest {
-  const req = AnthropicRequestSchema.parse(body);
-  return buildMockRequest(
-    "anthropic",
-    req,
-    parseMessages(req),
-    parseTools(req),
-    "claude-sonnet-4-6",
-    body,
-    meta,
-  );
-}

package/src/formats/anthropic/schema.ts

@@ -1,74 +0,0 @@
-import { z } from "zod";
-
-export {
-  AnthropicRequestSchema,
-  type AnthropicRequest,
-} from "llm-schemas/anthropic";
-
-const ResponseContentBlockSchema = z.object({
-  type: z.string(),
-  text: z.string().optional(),
-  thinking: z.string().optional(),
-  id: z.string().optional(),
-  name: z.string().optional(),
-  input: z.unknown().optional(),
-});
-
-export const AnthropicMessageStartSchema = z.object({
-  message: z.object({
-    id: z.string(),
-    type: z.literal("message"),
-    role: z.literal("assistant"),
-    content: z.array(z.unknown()),
-    model: z.string(),
-    stop_reason: z.string().nullable(),
-    usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }),
-  }),
-});
-
-export type AnthropicMessageStart = z.infer<typeof AnthropicMessageStartSchema>;
-
-export const AnthropicBlockEventSchema = z.object({
-  index: z.number(),
-  content_block: ResponseContentBlockSchema.optional(),
-  delta: z
-    .object({
-      type: z.string(),
-      text: z.string().optional(),
-      thinking: z.string().optional(),
-      partial_json: z.string().optional(),
-    })
-    .optional(),
-});
-
-export type AnthropicBlockEvent = z.infer<typeof AnthropicBlockEventSchema>;
-
-export const AnthropicDeltaSchema = z.object({
-  delta: z.object({
-    stop_reason: z.string(),
-    stop_sequence: z.string().nullable(),
-  }),
-  usage: z.object({ output_tokens: z.number() }),
-});
-
-export type AnthropicDelta = z.infer<typeof AnthropicDeltaSchema>;
-
-export const AnthropicCompleteSchema = z.object({
-  id: z.string(),
-  type: z.literal("message"),
-  role: z.literal("assistant"),
-  model: z.string(),
-  content: z.array(ResponseContentBlockSchema),
-  stop_reason: z.string(),
-  stop_sequence: z.string().nullable(),
-  usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }),
-});
-
-export type AnthropicComplete = z.infer<typeof AnthropicCompleteSchema>;
-
-export const AnthropicErrorSchema = z.object({
-  type: z.literal("error"),
-  error: z.object({ type: z.string(), message: z.string() }),
-});
-
-export type AnthropicError = z.infer<typeof AnthropicErrorSchema>;

package/src/formats/anthropic/serialize.ts

@@ -1,179 +0,0 @@
-import type { ReplyObject, ReplyOptions } from "#/types/reply.js";
-import type { SSEChunk } from "#/formats/types.js";
-import {
-  splitText,
-  genId,
-  toolId,
-  shouldEmitText,
-  finishReason,
-  DEFAULT_USAGE,
-} from "#/formats/serialize-helpers.js";
-
-function buildUsage(usage: { input: number; output: number }) {
-  return { input_tokens: usage.input, output_tokens: usage.output };
-}
-
-function contentBlock(
-  index: number,
-  startBlock: unknown,
-  deltas: SSEChunk[],
-): SSEChunk[] {
-  return [
-    {
-      event: "content_block_start",
-      data: JSON.stringify({
-        type: "content_block_start",
-        index,
-        content_block: startBlock,
-      }),
-    },
-    ...deltas,
-    {
-      event: "content_block_stop",
-      data: JSON.stringify({ type: "content_block_stop", index }),
-    },
-  ];
-}
-
-function delta(index: number, payload: Record<string, unknown>): SSEChunk {
-  return {
-    event: "content_block_delta",
-    data: JSON.stringify({
-      type: "content_block_delta",
-      index,
-      delta: payload,
-    }),
-  };
-}
-
-function reasoningBlock(i: number, reasoning: string): SSEChunk[] {
-  return contentBlock(i, { type: "thinking", thinking: "" }, [
-    delta(i, { type: "thinking_delta", thinking: reasoning }),
-  ]);
-}
-
-function textBlock(i: number, text: string, chunkSize: number): SSEChunk[] {
-  return contentBlock(
-    i,
-    { type: "text", text: "" },
-    splitText(text, chunkSize).map((piece) =>
-      delta(i, { type: "text_delta", text: piece }),
-    ),
-  );
-}
-
-function toolBlocks(
-  startIndex: number,
-  tools: ReplyObject["tools"],
-): SSEChunk[] {
-  return (tools ?? []).flatMap((tool, i) => {
-    const idx = startIndex + i;
-    const id = toolId(tool, "toolu", idx);
-    return contentBlock(
-      idx,
-      { type: "tool_use", id, name: tool.name, input: {} },
-      [
-        delta(idx, {
-          type: "input_json_delta",
-          partial_json: JSON.stringify(tool.args),
-        }),
-      ],
-    );
-  });
-}
-
-export function serialize(
-  reply: ReplyObject,
-  model: string,
-  options: ReplyOptions = {},
-): readonly SSEChunk[] {
-  const id = genId("msg");
-  const usage = reply.usage ?? DEFAULT_USAGE;
-  let idx = 0;
-
-  const reasoningChunks = reply.reasoning
-    ? reasoningBlock(idx++, reply.reasoning)
-    : [];
-  const textChunks = shouldEmitText(reply)
-    ? textBlock(idx++, reply.text ?? "", options.chunkSize ?? 0)
-    : [];
-  const toolChunks = toolBlocks(idx, reply.tools);
-
-  return [
-    {
-      event: "message_start",
-      data: JSON.stringify({
-        type: "message_start",
-        message: {
-          id,
-          type: "message",
-          role: "assistant",
-          model,
-          content: [],
-          stop_reason: null,
-          usage: { ...buildUsage(usage), output_tokens: 0 },
-        },
-      }),
-    },
-    ...reasoningChunks,
-    ...textChunks,
-    ...toolChunks,
-    {
-      event: "message_delta",
-      data: JSON.stringify({
-        type: "message_delta",
-        delta: {
-          stop_reason: finishReason(reply, "tool_use", "end_turn"),
-          stop_sequence: null,
-        },
-        usage: { output_tokens: usage.output },
-      }),
-    },
-    { event: "message_stop", data: JSON.stringify({ type: "message_stop" }) },
-  ];
-}
-
-export function serializeComplete(
-  reply: ReplyObject,
-  model: string,
-): Record<string, unknown> {
-  const id = genId("msg");
-  const usage = reply.usage ?? DEFAULT_USAGE;
-
-  const content: unknown[] = [
-    ...(reply.reasoning
-      ? [{ type: "thinking", thinking: reply.reasoning }]
-      : []),
-    ...(shouldEmitText(reply)
-      ? [{ type: "text", text: reply.text ?? "" }]
-      : []),
-    ...(reply.tools ?? []).map((tool, i) => ({
-      type: "tool_use",
-      id: toolId(tool, "toolu", i),
-      name: tool.name,
-      input: tool.args,
-    })),
-  ];
-
-  return {
-    id,
-    type: "message",
-    role: "assistant",
-    model,
-    content,
-    stop_reason: finishReason(reply, "tool_use", "end_turn"),
-    stop_sequence: null,
-    usage: buildUsage(usage),
-  };
-}
-
-export function serializeError(error: {
-  status: number;
-  message: string;
-  type?: string;
-}): Record<string, unknown> {
-  return {
-    type: "error",
-    error: { type: error.type ?? "api_error", message: error.message },
-  };
-}

package/src/formats/openai/chat-completions/index.ts

@@ -1,14 +0,0 @@
-import type { Format } from "#/formats/types.js";
-import { isStreaming } from "#/formats/request-helpers.js";
-import { parseRequest } from "./parse.js";
-import { serialize, serializeComplete, serializeError } from "./serialize.js";
-
-export const chatCompletionsFormat: Format = {
-  name: "openai",
-  route: "/v1/chat/completions",
-  parseRequest,
-  isStreaming,
-  serialize,
-  serializeComplete,
-  serializeError,
-};

package/src/formats/openai/chat-completions/parse.ts

@@ -1,47 +0,0 @@
-import type { MockRequest, Message, ToolDef } from "#/types/request.js";
-import {
-  buildMockRequest,
-  type RequestMeta,
-} from "#/formats/request-helpers.js";
-import { OpenAIRequestSchema, type OpenAIRequest } from "./schema.js";
-
-function extractContent(
-  content: OpenAIRequest["messages"][number]["content"],
-): string {
-  if (content == null) return "";
-  if (typeof content === "string") return content;
-  return content
-    .filter((p) => p.type === "text" && p.text !== undefined)
-    .map((p) => p.text!)
-    .join("\n");
-}
-
-function parseMessages(req: OpenAIRequest): readonly Message[] {
-  return req.messages.map((m) => ({
-    role: m.role === "developer" ? "system" : (m.role ?? "user"),
-    content: extractContent(m.content),
-    ...(m.tool_call_id !== undefined && { toolCallId: m.tool_call_id }),
-  }));
-}
-
-function parseTools(req: OpenAIRequest): readonly ToolDef[] | undefined {
-  if (!req.tools) return undefined;
-  return req.tools.map((t) => ({
-    name: t.function.name,
-    description: t.function.description,
-    parameters: t.function.parameters,
-  }));
-}
-
-export function parseRequest(body: unknown, meta?: RequestMeta): MockRequest {
-  const req = OpenAIRequestSchema.parse(body);
-  return buildMockRequest(
-    "openai",
-    req,
-    parseMessages(req),
-    parseTools(req),
-    "gpt-5.4",
-    body,
-    meta,
-  );
-}

package/src/formats/openai/chat-completions/schema.ts

@@ -1,92 +0,0 @@
-import { z } from "zod";
-
-export {
-  OpenAIRequestSchema,
-  type OpenAIRequest,
-} from "llm-schemas/openai/chat-completions";
-
-const ToolCallResponseSchema = z.object({
-  id: z.string(),
-  type: z.string(),
-  function: z.object({ name: z.string(), arguments: z.string() }),
-});
-
-const UsageSchema = z.object({
-  prompt_tokens: z.number(),
-  completion_tokens: z.number(),
-  total_tokens: z.number(),
-  prompt_tokens_details: z
-    .object({
-      cached_tokens: z.number().optional(),
-      audio_tokens: z.number().optional(),
-    })
-    .optional(),
-  completion_tokens_details: z
-    .object({
-      reasoning_tokens: z.number().optional(),
-      audio_tokens: z.number().optional(),
-      accepted_prediction_tokens: z.number().optional(),
-      rejected_prediction_tokens: z.number().optional(),
-    })
-    .optional(),
-});
-
-export const OpenAIChunkSchema = z.object({
-  id: z.string(),
-  object: z.literal("chat.completion.chunk"),
-  created: z.number(),
-  model: z.string(),
-  system_fingerprint: z.string().nullable().optional(),
-  service_tier: z.string().optional(),
-  choices: z.array(
-    z.object({
-      index: z.number(),
-      delta: z
-        .object({
-          role: z.string(),
-          content: z.string(),
-          tool_calls: z.array(ToolCallResponseSchema),
-        })
-        .partial(),
-      logprobs: z.unknown().nullable().optional(),
-      finish_reason: z.string().nullable(),
-    }),
-  ),
-  usage: UsageSchema.nullable().optional(),
-});
-
-export type OpenAIChunk = z.infer<typeof OpenAIChunkSchema>;
-
-export const OpenAICompleteSchema = z.object({
-  id: z.string(),
-  object: z.literal("chat.completion"),
-  created: z.number(),
-  model: z.string(),
-  system_fingerprint: z.string().nullable().optional(),
-  service_tier: z.string().optional(),
-  choices: z.array(
-    z.object({
-      index: z.number(),
-      message: z.object({
-        role: z.string(),
-        content: z.string().nullable(),
-        tool_calls: z.array(ToolCallResponseSchema).optional(),
-      }),
-      logprobs: z.unknown().nullable().optional(),
-      finish_reason: z.string(),
-    }),
-  ),
-  usage: UsageSchema.optional(),
-});
-
-export type OpenAIComplete = z.infer<typeof OpenAICompleteSchema>;
-
-export const OpenAIErrorSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string(),
-    code: z.string().nullable(),
-  }),
-});
-
-export type OpenAIError = z.infer<typeof OpenAIErrorSchema>;