llm-mock-server 1.0.0 → 1.0.2

package/src/formats/{parse-helpers.ts → request-helpers.ts}

@@ -1,39 +1,10 @@
-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>;
   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 +16,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,5 +1,5 @@
 import type { MockRequest, Message, ToolDef } from "../../types.js";
-import { buildMockRequest, type RequestMeta } from "../parse-helpers.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 {

package/src/formats/responses/schema.ts

@@ -1,75 +1,6 @@
 import { z } from "zod";
 
-const InputMessageSchema = z.object({
-  type: z.literal("message").optional(),
-  role: z.enum(["user", "assistant", "system", "developer"]),
-  content: z.union([z.string(), z.array(z.record(z.string(), z.unknown()))]),
-});
-
-const FunctionCallInputSchema = z.object({
-  type: z.literal("function_call"),
-  id: z.string().optional(),
-  call_id: z.string(),
-  name: z.string(),
-  arguments: z.string(),
-});
-
-const FunctionCallOutputSchema = z.object({
-  type: z.literal("function_call_output"),
-  call_id: z.string(),
-  output: z.string(),
-});
-
-const InputItemSchema = z.union([
-  InputMessageSchema,
-  FunctionCallInputSchema,
-  FunctionCallOutputSchema,
-]);
-
-const RawToolSchema = z.record(z.string(), z.unknown());
-
-export const FunctionToolSchema = z.object({
-  type: z.literal("function"),
-  name: z.string(),
-  description: z.string().optional(),
-  parameters: z.record(z.string(), z.unknown()).optional(),
-});
-
-export type FunctionTool = z.infer<typeof FunctionToolSchema>;
-
-export const ResponsesRequestSchema = z.looseObject({
-  model: z.string().min(1).optional(),
-  input: z.union([z.string(), z.array(InputItemSchema)]).optional(),
-  instructions: z.string().optional(),
-  tools: z.array(RawToolSchema).optional(),
-  stream: z.boolean().optional(),
-  temperature: z.number().optional(),
-  previous_response_id: z.string().optional(),
-  background: z.boolean().optional(),
-  context_management: z.unknown().optional(),
-  conversation: z.unknown().optional(),
-  include: z.array(z.string()).optional(),
-  max_output_tokens: z.number().optional(),
-  max_tool_calls: z.number().optional(),
-  metadata: z.record(z.string(), z.string()).optional(),
-  parallel_tool_calls: z.boolean().optional(),
-  prompt: z.unknown().optional(),
-  prompt_cache_key: z.string().optional(),
-  prompt_cache_retention: z.string().optional(),
-  reasoning: z.unknown().optional(),
-  safety_identifier: z.string().optional(),
-  service_tier: z.string().optional(),
-  store: z.boolean().optional(),
-  stream_options: z.unknown().optional(),
-  text: z.unknown().optional(),
-  tool_choice: z.unknown().optional(),
-  top_logprobs: z.number().optional(),
-  top_p: z.number().optional(),
-  truncation: z.string().optional(),
-  user: z.string().optional(),
-});
-
-export type ResponsesRequest = z.infer<typeof ResponsesRequestSchema>;
+export { ResponsesRequestSchema, FunctionToolSchema, type ResponsesRequest } from "llm-schemas/openai/responses";
 
 const OutputContentSchema = z.object({
   type: z.string(),
@@ -89,8 +20,6 @@ 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(),

package/src/formats/responses/serialize.ts

@@ -1,6 +1,10 @@
 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";
+
+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 }
 
@@ -95,12 +99,12 @@ export function serialize(reply: ReplyObject, model: string, options: ReplyOptio
     c({
       type: "response.completed",
       response: { ...baseResponse, status: "completed", output,
-        usage: { input_tokens: usage.input, output_tokens: usage.output, total_tokens: usage.input + usage.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;
@@ -120,10 +124,10 @@ export function serializeComplete(reply: ReplyObject, model: string): unknown {
 
   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 },
+    usage: buildUsage(usage),
   };
 }
 
-export function serializeError(error: { status: number; message: string; type?: string }): unknown {
+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,30 @@
+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,5 @@
 import type { FormatName, MockRequest, ReplyObject, ReplyOptions } from "../types.js";
-import type { RequestMeta } from "./parse-helpers.js";
+import type { RequestMeta } from "./request-helpers.js";
 
 export interface SSEChunk {
   readonly event?: string | undefined;
@@ -12,6 +12,6 @@ export interface Format {
   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;
+  serializeComplete(reply: ReplyObject, model: string): Record<string, unknown>;
+  serializeError(error: { status: number; message: string; type?: string | undefined }): Record<string, unknown>;
 }

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;
 }
@@ -106,8 +106,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,13 +118,10 @@ 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> {

package/src/logger.ts

@@ -19,6 +19,15 @@ 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 +37,16 @@ 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);
-    }
-  }
-
-  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);
-    }
+  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);
   }
 
-  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);
-    }
-  }
-
-  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);
-    }
-  }
+  error(msg: string, ...args: unknown[]): void { this.log("error", msg, args); }
+  warn(msg: string, ...args: unknown[]): void { this.log("warn", msg, args); }
+  info(msg: string, ...args: unknown[]): void { this.log("info", msg, args); }
+  debug(msg: string, ...args: unknown[]): void { this.log("debug", msg, args); }
 }

package/src/mock-server.ts

@@ -3,7 +3,7 @@ import type { FastifyInstance } from "fastify";
 import type {
   Match, PendingRule, Reply, ReplyOptions, Resolver, Rule, RuleHandle, RuleSummary, SequenceEntry,
 } from "./types.js";
-import { RuleEngine } from "./rule-engine.js";
+import { RuleEngine, createSequenceResolver } from "./rule-engine.js";
 import { RequestHistory } from "./history.js";
 import { openaiFormat } from "./formats/openai/index.js";
 import { anthropicFormat } from "./formats/anthropic/index.js";
@@ -103,19 +103,15 @@ export class MockServer {
         return makeHandle(engine.add(match, response, options));
       },
       replySequence(entries: readonly SequenceEntry[]): RuleHandle {
-        if (entries.length === 0) throw new Error("replySequence requires at least one entry.");
-        let index = 0;
-        const last = entries[entries.length - 1]!;
-        const rule = engine.add(match, () => {
-          const entry = entries[index++] ?? last;
-          if (typeof entry === "string" || !("reply" in entry)) {
-            rule.options = {};
-            return entry;
-          }
-          rule.options = entry.options ?? {};
-          return entry.reply;
-        });
-        rule.remaining = entries.length;
+        const steps = entries.map((entry) =>
+          typeof entry === "string" || !("reply" in entry)
+            ? { reply: entry as Reply }
+            : { reply: entry.reply, options: entry.options },
+        );
+        const rule = engine.add(match, "");
+        const { resolver, entryCount } = createSequenceResolver(steps, rule);
+        rule.resolve = resolver;
+        rule.remaining = entryCount;
         return makeHandle(rule);
       },
     };

package/src/route-handler.ts

@@ -37,7 +37,7 @@ async function resolveReply(
   }
 }
 
-export interface RouteHandlerDeps {
+interface RouteHandlerDeps {
   engine: RuleEngine;
   history: RequestHistory;
   logger: Logger;

package/src/rule-engine.ts

@@ -1,4 +1,4 @@
-import type { Match, MatchObject, MockRequest, Resolver, ReplyOptions, Rule, RuleSummary } from "./types.js";
+import type { Match, MatchObject, MockRequest, Resolver, Reply, ReplyOptions, Rule, RuleSummary } from "./types.js";
 
 function safeRegex(re: RegExp): RegExp {
   return (re.global || re.sticky) ? new RegExp(re.source, re.flags.replace(/[gy]/g, "")) : re;
@@ -62,6 +62,28 @@ function createRule(match: Match, resolve: Resolver, options: ReplyOptions, desc
   };
 }
 
+interface SequenceStep {
+  readonly reply: Reply;
+  readonly options?: ReplyOptions | undefined;
+}
+
+export function createSequenceResolver(
+  steps: readonly SequenceStep[],
+  rule: { options: ReplyOptions },
+): { resolver: () => Reply; entryCount: number } {
+  if (steps.length === 0) throw new Error("Sequence requires at least one entry.");
+  let index = 0;
+  const last = steps[steps.length - 1]!;
+  return {
+    resolver: () => {
+      const step = steps[index++] ?? last;
+      rule.options = step.options ?? {};
+      return step.reply;
+    },
+    entryCount: steps.length,
+  };
+}
+
 export class RuleEngine {
   private readonly rules: Rule[] = [];
 

package/src/types/reply.ts

@@ -5,13 +5,11 @@ export type Reply = string | ReplyObject;
 
 /** A structured reply. Text, reasoning, tool calls, usage, and errors are all optional. */
 export interface ReplyObject {
-  /** Text content to send back. */
   readonly text?: string | undefined;
   /** Extended thinking or chain-of-thought. Works with Anthropic and Responses formats. */
   readonly reasoning?: string | undefined;
-  /** Tool calls the "model" wants to make. */
   readonly tools?: readonly ToolCall[] | undefined;
-  /** Token counts to report. Falls back to `{ input: 10, output: 5 }` if omitted. */
+  /** Falls back to `{ input: 10, output: 5 }` if omitted. */
   readonly usage?: { readonly input: number; readonly output: number } | undefined;
   /** When set, the server responds with this HTTP error instead of a normal reply. */
   readonly error?: ErrorReply | undefined;
@@ -19,16 +17,14 @@ export interface ReplyObject {
 
 /** An HTTP error response. The server returns this status code with a format-appropriate body. */
 export interface ErrorReply {
-  /** HTTP status code, like 429 or 500. */
   readonly status: number;
   readonly message: string;
-  /** Error type string in the response body. Each format has its own default if omitted. */
+  /** Each format has its own default if omitted. */
   readonly type?: string | undefined;
 }
 
-/** A tool call in the mock response. */
 export interface ToolCall {
-  /** Explicit ID for the call. Auto-generated if omitted. */
+  /** Auto-generated if omitted. */
   readonly id?: string | undefined;
   readonly name: string;
   readonly args: Readonly<Record<string, unknown>>;
@@ -37,11 +33,11 @@ export interface ToolCall {
 /** A reply value or a function that produces one. Async functions are supported. */
 export type Resolver = Reply | ((req: MockRequest) => Reply | Promise<Reply>);
 
-/** Streaming options for a rule. Merged with server-level defaults, with per-rule values winning. */
+/** Per-rule streaming options. Merged with server-level defaults, with per-rule values winning. */
 export interface ReplyOptions {
-  /** Milliseconds to wait between SSE chunks. */
+  /** Milliseconds between SSE chunks. */
   readonly latency?: number | undefined;
-  /** Split text into chunks of this many characters for more realistic streaming. */
+  /** Characters per SSE chunk for more realistic streaming. */
   readonly chunkSize?: number | undefined;
 }
 

package/src/types/request.ts

@@ -3,28 +3,24 @@ export type FormatName = "openai" | "anthropic" | "responses";
 
 /** A normalised view of an incoming request, regardless of the original wire format. */
 export interface MockRequest {
-  /** Which format route the request hit. */
   readonly format: FormatName;
   readonly model: string;
-  /** Whether the client asked for SSE streaming. */
   readonly streaming: boolean;
   /** Full conversation, normalised from whatever format came in. */
   readonly messages: readonly Message[];
   /** The last user message's text. This is what most matchers check. */
   readonly lastMessage: string;
-  /** System prompt text, or `""` if there wasn't one. */
+  /** Empty string if there wasn't one. */
   readonly systemMessage: string;
-  /** Tool definitions from the request, if any were sent. */
   readonly tools?: readonly ToolDef[] | undefined;
-  /** The names from `tools`, pulled out for quick lookups. */
+  /** Pulled out from `tools` for quick lookups. */
   readonly toolNames: readonly string[];
-  /** If the last message was a tool result, this is its `tool_call_id`. */
+  /** Set when the last message was a tool result. */
   readonly lastToolCallId: string | undefined;
-  /** The raw request body, in case you need something we don't extract. */
+  /** The raw request body, for anything we don't extract. */
   readonly raw: unknown;
-  /** HTTP headers from the incoming request. */
   readonly headers: Readonly<Record<string, string | undefined>>;
-  /** The URL path that was hit, e.g. `/v1/chat/completions`. */
+  /** e.g. `/v1/chat/completions` */
   readonly path: string;
 }
 
@@ -32,7 +28,7 @@ export interface MockRequest {
 export interface Message {
   readonly role: "system" | "user" | "assistant" | "tool";
   readonly content: string;
-  /** Only set on `"tool"` messages. Links the result back to its tool call. */
+  /** Links the result back to its tool call. Only set on `"tool"` messages. */
   readonly toolCallId?: string | undefined;
 }
 
@@ -40,6 +36,6 @@ export interface Message {
 export interface ToolDef {
   readonly name: string;
   readonly description?: string | undefined;
-  /** JSON Schema for the tool's parameters, passed through as-is. */
+  /** JSON Schema, passed through as-is. */
   readonly parameters?: unknown;
 }

package/src/types/rule.ts

@@ -17,13 +17,9 @@ export type Match =
 
 /** A structured matcher. Every field you set must match for the rule to fire. */
 export interface MatchObject {
-  /** Substring or regex against the last user message. */
   readonly message?: string | RegExp;
-  /** Substring or regex against the model name. */
   readonly model?: string | RegExp;
-  /** Substring or regex against the system prompt. */
   readonly system?: string | RegExp;
-  /** Only match requests from this API format. */
   readonly format?: FormatName;
   /** Match when the request includes a tool definition with this name. */
   readonly toolName?: string;
@@ -36,15 +32,13 @@ export interface MatchObject {
 /** Returned by `when()`. Call `.reply()` or `.replySequence()` on it to complete the rule. */
 export interface PendingRule {
   reply(response: Resolver, options?: ReplyOptions): RuleHandle;
-  /** Each match advances through the array. The last entry repeats once the sequence is exhausted. */
+  /** Each match advances through the array. The last entry repeats once exhausted. */
   replySequence(entries: readonly SequenceEntry[]): RuleHandle;
 }
 
 /** A handle to a registered rule. All methods return `this` for chaining. */
 export interface RuleHandle {
-  /** Auto-expire the rule after `n` matches. */
   times(n: number): RuleHandle;
-  /** Move this rule to the front of the list so it matches first. */
   first(): RuleHandle;
 }
 
@@ -59,16 +53,15 @@ export interface Handler {
 
 /** A summary of a registered rule, for inspection. */
 export interface RuleSummary {
-  /** Human-readable description of what the rule matches. */
   readonly description: string;
-  /** How many matches are left. `Infinity` means unlimited. */
+  /** `Infinity` means unlimited. */
   readonly remaining: number;
 }
 
 export interface Rule {
   readonly description: string;
   readonly match: (req: MockRequest) => boolean;
-  readonly resolve: Resolver;
+  resolve: Resolver;
   options: ReplyOptions;
   remaining: number;
 }

package/src/types.ts

@@ -1,5 +1,3 @@
-export type {
-  FormatName, MockRequest, Message, ToolDef,
-  Reply, ReplyObject, ErrorReply, ToolCall, Resolver, ReplyOptions, SequenceEntry,
-  Match, MatchObject, PendingRule, RuleHandle, RuleSummary, Handler, RecordedRequest, Rule,
-} from "./types/index.js";
+export type { FormatName, MockRequest, Message, ToolDef } from "./types/request.js";
+export type { Reply, ReplyObject, ErrorReply, ToolCall, Resolver, ReplyOptions, SequenceEntry } from "./types/reply.js";
+export type { Match, MatchObject, PendingRule, RuleHandle, RuleSummary, Handler, Rule } from "./types/rule.js";

package/test/formats/anthropic.test.ts

@@ -226,10 +226,10 @@ describe("Anthropic Format", () => {
         "claude-sonnet-4-6",
       ) as AnthropicComplete;
       const tool = result.content.find((c) => c.type === "tool_use");
-      expect(tool).toBeDefined();
-      expect(tool!.name).toBe("read_file");
-      expect(tool!.input).toEqual({ path: "/tmp" });
-      expect(tool!.id).toBeTypeOf("string");
+      if (!tool) throw new Error("expected tool_use content block");
+      expect(tool.name).toBe("read_file");
+      expect(tool.input).toEqual({ path: "/tmp" });
+      expect(tool.id).toBeTypeOf("string");
     });
 
     it("sets stop_reason to tool_use when tools present", () => {