llm-mock-server 1.0.1 → 1.0.3

package/src/formats/openai/serialize.ts

@@ -1,15 +1,43 @@
 import type { ReplyObject, ReplyOptions } from "../../types.js";
 import type { SSEChunk } from "../types.js";
-import { splitText, genId, toolId, finishReason, MS_PER_SECOND, DEFAULT_USAGE } from "../parse-helpers.js";
+import {
+  splitText,
+  genId,
+  toolId,
+  finishReason,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../serialize-helpers.js";
+
+function buildUsage(usage: { input: number; output: number }) {
+  return {
+    prompt_tokens: usage.input,
+    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,
+    },
+  };
+}
 
 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 }],
@@ -18,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;
@@ -31,32 +63,39 @@ 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) },
+        },
+      ],
     }),
   );
 
-  const usageChunk = {
-    prompt_tokens: usage.input,
-    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 },
-  };
+  const usageChunk = buildUsage(usage);
 
   return [
     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): 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;
@@ -66,27 +105,42 @@ export function serializeComplete(reply: ReplyObject, model: string): unknown {
     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") }],
-    usage: {
-      prompt_tokens: usage.input,
-      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 },
-    },
+    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 }): 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/{parse-helpers.ts → request-helpers.ts}

@@ -1,39 +1,11 @@
-import type { FormatName, Message, MockRequest, ReplyObject, ToolDef } from "../types.js";
-
-export const MS_PER_SECOND = 1000;
-const BASE_36 = 36;
-export const DEFAULT_USAGE = { input: 10, output: 5 } as const;
+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 {};
 }
 
-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;
-}
-
 export function isStreaming(body: unknown): boolean {
   return asRecord(body)["stream"] !== false;
 }
@@ -45,7 +17,7 @@ export interface RequestMeta {
 
 const EMPTY_META: RequestMeta = { headers: {}, path: "" };
 
-export interface ParsedBody {
+interface ParsedBody {
   readonly model?: string | undefined;
   readonly stream?: boolean | undefined;
 }

package/src/formats/responses/index.ts

@@ -1,5 +1,5 @@
 import type { Format } from "../types.js";
-import { isStreaming } from "../parse-helpers.js";
+import { isStreaming } from "../request-helpers.js";
 import { parseRequest } from "./parse.js";
 import { serialize, serializeComplete, serializeError } from "./serialize.js";
 

package/src/formats/responses/parse.ts

@@ -1,8 +1,14 @@
 import type { MockRequest, Message, ToolDef } from "../../types.js";
-import { buildMockRequest, type RequestMeta } from "../parse-helpers.js";
-import { ResponsesRequestSchema, FunctionToolSchema, type ResponsesRequest } from "./schema.js";
+import { buildMockRequest, type RequestMeta } from "../request-helpers.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 FunctionTool, type ResponsesRequest } from "llm-schemas/openai/responses";
+export {
+  ResponsesRequestSchema,
+  FunctionToolSchema,
+  type ResponsesRequest,
+} from "llm-schemas/openai/responses";
 
 const OutputContentSchema = z.object({
   type: z.string(),
@@ -20,30 +24,34 @@ const OutputItemSchema = z.object({
   summary: z.array(z.object({ type: z.string(), text: z.string() })).optional(),
 });
 
-export type ResponsesOutputItem = z.infer<typeof OutputItemSchema>;
-
 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(),
 });
@@ -68,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>;