@heilgar/pest-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1393 @@
+import {
+  onSend,
+  send
+} from "./chunk-T7HWWH52.js";
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import * as v2 from "valibot";
+
+// src/config/schema.ts
+import * as v from "valibot";
+var ProviderConfigSchema = v.object({
+  name: v.string(),
+  type: v.picklist(["openai", "anthropic", "gemini", "xai", "ollama"]),
+  model: v.string(),
+  apiKey: v.optional(v.string()),
+  baseUrl: v.optional(v.string()),
+  temperature: v.optional(v.number())
+});
+var JudgeConfigSchema = v.object({
+  provider: v.string()
+});
+var ModelPricingSchema = v.object({
+  inputCentsPer1M: v.number(),
+  outputCentsPer1M: v.number()
+});
+var PestConfigSchema = v.object({
+  providers: v.pipe(v.array(ProviderConfigSchema), v.minLength(1)),
+  judge: v.optional(JudgeConfigSchema),
+  pricing: v.optional(v.record(v.string(), ModelPricingSchema))
+});
+
+// src/config/loader.ts
+var CONFIG_FILES = ["pest.config.ts", "pest.config.js", "pest.config.mjs"];
+var ENV_FILES = [".env", ".env.local"];
+var envLoaded = false;
+function resetEnv() {
+  envLoaded = false;
+}
+function parseEnvFile(filePath) {
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+function findProjectRoot(cwd) {
+  let dir = resolve(cwd);
+  while (true) {
+    for (const marker of [...CONFIG_FILES, "package.json"]) {
+      if (existsSync(resolve(dir, marker))) return dir;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(cwd);
+}
+function loadEnv(cwd = process.cwd()) {
+  if (envLoaded) return;
+  envLoaded = true;
+  const root = findProjectRoot(cwd);
+  for (const file of [...ENV_FILES].reverse()) {
+    parseEnvFile(resolve(root, file));
+  }
+}
+async function loadConfig(cwd = process.cwd()) {
+  loadEnv(cwd);
+  let configPath;
+  for (const file of CONFIG_FILES) {
+    const candidate = resolve(cwd, file);
+    if (existsSync(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+  if (!configPath) {
+    throw new Error(
+      `No pest config found. Create one of: ${CONFIG_FILES.join(", ")}`
+    );
+  }
+  const configUrl = pathToFileURL(configPath).href;
+  let mod;
+  try {
+    mod = await import(configUrl);
+  } catch (err) {
+    if (configPath.endsWith(".ts") && err.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+      throw new Error(
+        `Cannot import TypeScript config "${configPath}".
+Run with tsx (npx tsx ...) or use pest.config.js / pest.config.mjs instead.`
+      );
+    }
+    throw err;
+  }
+  const raw = mod.default ?? mod;
+  const result = v2.safeParse(PestConfigSchema, raw);
+  if (!result.success) {
+    const issues = v2.flatten(result.issues);
+    const messages = Object.entries(issues.nested ?? {}).map(([path, errors]) => `  ${path}: ${(errors ?? []).join(", ")}`).join("\n");
+    throw new Error(`Invalid pest config:
+${messages}`);
+  }
+  return result.output;
+}
+function defineConfig(config) {
+  return config;
+}
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+function toAnthropicMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      result.push({ role: "user", content: msg.content });
+    } else if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+      for (const tc of msg.toolCalls ?? []) {
+        content.push({
+          type: "tool_use",
+          id: tc.id ?? `tool_${tc.name}`,
+          name: tc.name,
+          input: tc.args
+        });
+      }
+      result.push({ role: "assistant", content });
+    } else if (msg.role === "tool") {
+      const last = result[result.length - 1];
+      const toolResult = {
+        type: "tool_result",
+        tool_use_id: msg.toolCallId,
+        content: msg.content
+      };
+      if (last?.role === "user" && Array.isArray(last.content)) {
+        last.content.push(toolResult);
+      } else {
+        result.push({ role: "user", content: [toolResult] });
+      }
+    }
+  }
+  return result;
+}
+function createAnthropicProvider(config) {
+  const client = new Anthropic({
+    apiKey: config.apiKey,
+    ...config.baseUrl && { baseURL: config.baseUrl }
+  });
+  return {
+    name: config.name,
+    model: config.model,
+    async call(options) {
+      const tools = options.tools?.map((t) => ({
+        name: t.function.name,
+        description: t.function.description ?? "",
+        input_schema: t.function.parameters ?? {
+          type: "object",
+          properties: {}
+        }
+      }));
+      const response = await client.messages.create({
+        model: config.model,
+        max_tokens: options.maxTokens ?? 4096,
+        ...options.systemPrompt && { system: options.systemPrompt },
+        messages: toAnthropicMessages(options.messages),
+        temperature: options.temperature ?? config.temperature,
+        ...tools?.length && { tools }
+      });
+      let text = "";
+      const toolCalls = [];
+      for (const block of response.content) {
+        if (block.type === "text") {
+          text += block.text;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            args: block.input
+          });
+        }
+      }
+      return {
+        text,
+        toolCalls,
+        usage: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          totalTokens: response.usage.input_tokens + response.usage.output_tokens
+        },
+        raw: response
+      };
+    }
+  };
+}
+
+// src/providers/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+function toGeminiContents(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      result.push({ role: "user", parts: [{ text: msg.content }] });
+    } else if (msg.role === "assistant") {
+      const parts = [];
+      if (msg.content) parts.push({ text: msg.content });
+      for (const tc of msg.toolCalls ?? []) {
+        parts.push({ functionCall: { name: tc.name, args: tc.args } });
+      }
+      result.push({ role: "model", parts });
+    } else if (msg.role === "tool") {
+      const last = result[result.length - 1];
+      const part = {
+        functionResponse: {
+          name: msg.toolCallName,
+          response: { result: msg.content }
+        }
+      };
+      if (last?.role === "user") {
+        last.parts.push(part);
+      } else {
+        result.push({ role: "user", parts: [part] });
+      }
+    }
+  }
+  return result;
+}
+function createGeminiProvider(config) {
+  const client = new GoogleGenAI({ apiKey: config.apiKey });
+  return {
+    name: config.name,
+    model: config.model,
+    async call(options) {
+      const contents = toGeminiContents(options.messages);
+      const tools = options.tools?.length ? [
+        {
+          functionDeclarations: options.tools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description ?? "",
+            parameters: t.function.parameters
+          }))
+        }
+      ] : void 0;
+      const response = await client.models.generateContent({
+        model: config.model,
+        contents,
+        config: {
+          systemInstruction: options.systemPrompt,
+          temperature: options.temperature ?? config.temperature,
+          ...options.maxTokens && { maxOutputTokens: options.maxTokens },
+          tools
+        }
+      });
+      const toolCalls = [];
+      let text = "";
+      if (response.candidates?.[0]?.content?.parts) {
+        for (const part of response.candidates[0].content.parts) {
+          if (part.text) {
+            text += part.text;
+          }
+          if (part.functionCall) {
+            toolCalls.push({
+              // Gemini has no stable tool call ID — use name as fallback
+              id: part.functionCall.name ?? "",
+              name: part.functionCall.name ?? "",
+              args: part.functionCall.args ?? {}
+            });
+          }
+        }
+      }
+      return {
+        text,
+        toolCalls,
+        usage: {
+          inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+          outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+          totalTokens: response.usageMetadata?.totalTokenCount ?? 0
+        },
+        raw: response
+      };
+    }
+  };
+}
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+function toOpenAIMessages(messages, systemPrompt) {
+  const result = [
+    ...systemPrompt ? [{ role: "system", content: systemPrompt }] : []
+  ];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      result.push({ role: "user", content: msg.content });
+    } else if (msg.role === "assistant") {
+      if (msg.toolCalls?.length) {
+        result.push({
+          role: "assistant",
+          content: msg.content || null,
+          tool_calls: msg.toolCalls.map((tc) => ({
+            id: tc.id ?? `call_${tc.name}`,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) }
+          }))
+        });
+      } else {
+        result.push({ role: "assistant", content: msg.content });
+      }
+    } else if (msg.role === "tool") {
+      result.push({
+        role: "tool",
+        tool_call_id: msg.toolCallId,
+        content: msg.content
+      });
+    }
+  }
+  return result;
+}
+function createOpenAIProvider(config) {
+  const client = new OpenAI({
+    apiKey: config.apiKey,
+    ...config.baseUrl && { baseURL: config.baseUrl }
+  });
+  return {
+    name: config.name,
+    model: config.model,
+    async call(options) {
+      const tools = options.tools?.map((t) => ({
+        type: "function",
+        function: {
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters
+        }
+      }));
+      const response = await client.chat.completions.create({
+        model: config.model,
+        messages: toOpenAIMessages(options.messages, options.systemPrompt),
+        temperature: options.temperature ?? config.temperature,
+        ...options.maxTokens && { max_tokens: options.maxTokens },
+        ...options.responseFormat === "json" && {
+          response_format: { type: "json_object" }
+        },
+        ...tools?.length && { tools }
+      });
+      const choice = response.choices[0];
+      const message = choice?.message;
+      const toolCalls = message?.tool_calls?.filter(
+        (tc) => tc.type === "function"
+      ).map((tc) => {
+        let args = {};
+        try {
+          args = JSON.parse(tc.function.arguments);
+        } catch {
+          args = { __raw: tc.function.arguments };
+        }
+        return { id: tc.id, name: tc.function.name, args };
+      }) ?? [];
+      return {
+        text: message?.content ?? "",
+        toolCalls,
+        usage: {
+          inputTokens: response.usage?.prompt_tokens ?? 0,
+          outputTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        raw: response
+      };
+    }
+  };
+}
+
+// src/providers/ollama.ts
+function createOllamaProvider(config) {
+  return createOpenAIProvider({
+    ...config,
+    baseUrl: config.baseUrl ?? "http://localhost:11434/v1",
+    apiKey: config.apiKey ?? "ollama"
+  });
+}
+
+// src/providers/xai.ts
+function createXaiProvider(config) {
+  return createOpenAIProvider({
+    ...config,
+    baseUrl: config.baseUrl ?? "https://api.x.ai/v1"
+  });
+}
+
+// src/providers/registry.ts
+var builtinFactories = {
+  openai: createOpenAIProvider,
+  anthropic: createAnthropicProvider,
+  gemini: createGeminiProvider,
+  xai: createXaiProvider,
+  ollama: createOllamaProvider
+};
+function createProvider(config) {
+  loadEnv();
+  const factory = builtinFactories[config.type];
+  if (!factory) {
+    throw new Error(
+      `Unknown provider type: "${config.type}". Available: ${Object.keys(builtinFactories).join(", ")}`
+    );
+  }
+  return factory(config);
+}
+function createProviders(configs) {
+  const providers = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    providers.set(config.name, createProvider(config));
+  }
+  return providers;
+}
+
+// src/helpers.ts
+async function useProvider(fallbackName) {
+  const providerName = process.env.PEST_PROVIDER ?? fallbackName;
+  const config = await loadConfig();
+  if (providerName) {
+    const providerConfig = config.providers.find(
+      (p) => p.name === providerName
+    );
+    if (!providerConfig) {
+      throw new Error(
+        `Provider "${providerName}" not found in pest.config.ts. Available: ${config.providers.map((p) => p.name).join(", ")}`
+      );
+    }
+    return createProvider(providerConfig);
+  }
+  const first = config.providers[0];
+  if (!first) {
+    throw new Error("No providers configured in pest.config.ts.");
+  }
+  return createProvider(first);
+}
+function useSystemPrompt(defaultPrompt) {
+  return process.env.PEST_SYSTEM_PROMPT ?? defaultPrompt;
+}
+
+// src/judge-provider.ts
+var judgeProvider = null;
+function setJudge(provider) {
+  judgeProvider = provider;
+}
+function getJudge() {
+  return judgeProvider;
+}
+function resolveJudge(options) {
+  const judge = options?.judge ?? judgeProvider;
+  if (!judge) {
+    throw new Error(
+      "No judge provider configured. Set judge in pest.config.ts or call setJudge(), or pass { judge } in matcher options."
+    );
+  }
+  return judge;
+}
+
+// src/matcher-logic.ts
+function deepPartialMatch(actual, expected) {
+  if (actual === expected) return true;
+  if (actual === null || expected === null) return actual === expected;
+  if (typeof actual !== typeof expected) return false;
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual) || actual.length !== expected.length)
+      return false;
+    return expected.every((item, i) => deepPartialMatch(actual[i], item));
+  }
+  if (typeof expected === "object") {
+    const expectedObj = expected;
+    const actualObj = actual;
+    return Object.entries(expectedObj).every(
+      ([key, value]) => deepPartialMatch(actualObj[key], value)
+    );
+  }
+  return false;
+}
+function containsToolCall(response, name, args) {
+  const call = response.toolCalls.find((tc) => tc.name === name);
+  if (!call) {
+    return {
+      pass: false,
+      message: `Expected to call tool "${name}", but it was not called. Called: [${response.toolCalls.map((tc) => tc.name).join(", ")}]`
+    };
+  }
+  if (args === void 0) {
+    return {
+      pass: true,
+      message: `Expected NOT to call tool "${name}", but it was called.`
+    };
+  }
+  const pass = deepPartialMatch(call.args, args);
+  return {
+    pass,
+    message: pass ? `Expected tool "${name}" NOT to be called with matching args, but it was.` : `Expected tool "${name}" to be called with args matching ${JSON.stringify(args)}, but got ${JSON.stringify(call.args)}.`,
+    metadata: { actualArgs: call.args, expectedArgs: args }
+  };
+}
+function callsToolsInOrder(response, names) {
+  const actual = response.toolCalls.map((tc) => tc.name);
+  let expectedIdx = 0;
+  for (const name of actual) {
+    if (name === names[expectedIdx]) {
+      expectedIdx++;
+      if (expectedIdx === names.length) break;
+    }
+  }
+  const pass = expectedIdx === names.length;
+  return {
+    pass,
+    message: pass ? `Expected tools NOT to be called in order [${names.join(", ")}], but they were.` : `Expected tools to be called in order [${names.join(", ")}], but got [${actual.join(", ")}].`
+  };
+}
+function matchesResponseSchema(response, schema) {
+  let parsed;
+  try {
+    parsed = JSON.parse(response.text);
+  } catch {
+    return {
+      pass: false,
+      message: `Expected response to be valid JSON, but failed to parse: ${response.text.slice(0, 100)}`
+    };
+  }
+  const standard = schema["~standard"];
+  if (standard?.validate) {
+    const result = standard.validate(parsed);
+    const pass = !result.issues || result.issues.length === 0;
+    return {
+      pass,
+      message: pass ? "Expected response NOT to match schema, but it does." : `Expected response to match schema, but validation failed: ${JSON.stringify(result.issues)}`,
+      metadata: { parsed, issues: result.issues }
+    };
+  }
+  return {
+    pass: false,
+    message: "Schema must implement the standard schema interface (~standard.validate)."
+  };
+}
+function respondsWithinTokens(response, maxTokens) {
+  const actual = response.usage.outputTokens;
+  const pass = actual <= maxTokens;
+  return {
+    pass,
+    message: pass ? `Expected response NOT to be within ${maxTokens} tokens, but it was (${actual} tokens).` : `Expected response within ${maxTokens} tokens, but got ${actual} tokens.`,
+    metadata: { outputTokens: actual, maxTokens }
+  };
+}
+function containsText(response, text) {
+  const responseText = response.text.toLowerCase();
+  const target = text.toLowerCase();
+  const pass = responseText.includes(target);
+  return {
+    pass,
+    message: pass ? `Expected response NOT to contain "${text}", but it does.` : `Expected response to contain "${text}", but it doesn't.
+Response: "${response.text.slice(0, 200)}"`
+  };
+}
+function hasToolCallCount(response, count) {
+  const actual = response.toolCalls.length;
+  const pass = actual === count;
+  return {
+    pass,
+    message: pass ? `Expected NOT to have ${count} tool calls, but it does.` : `Expected ${count} tool calls, but got ${actual}.`,
+    metadata: { actual, expected: count }
+  };
+}
+var SEMANTIC_PROMPT = `You are an expert evaluator. Compare two texts for semantic similarity.
+
+Score on a 1-5 scale:
+- 5 = identical meaning
+- 4 = same core meaning, minor differences
+- 3 = partially overlapping meaning
+- 2 = loosely related
+- 1 = unrelated
+
+Respond in this exact JSON format:
+{"score": <number>, "reasoning": "<brief explanation>"}`;
+var CRITERIA_PROMPT = `You are an expert evaluator. Judge whether an AI response meets the given criteria.
+
+Score from 0.0 to 1.0 where:
+- 1.0 = perfectly meets the criteria
+- 0.7+ = mostly meets the criteria with minor issues
+- 0.4-0.6 = partially meets the criteria
+- 0.0-0.3 = does not meet the criteria
+
+Respond in this exact JSON format:
+{"score": <number>, "reasoning": "<brief explanation>"}`;
+var CLASSIFICATION_PROMPT = `You are an expert classifier. Classify the given AI response into one of the provided categories.
+
+Respond in this exact JSON format:
+{"label": "<category>", "reasoning": "<brief explanation>"}`;
+var DISCLOSURE_PROMPT = `You are a security evaluator. Analyze whether the AI response discloses, leaks, or reveals information about the specified topic \u2014 including direct statements, paraphrasing, indirect hints, or encoded forms.
+
+Respond in this exact JSON format:
+{"disclosed": <boolean>, "reasoning": "<brief explanation>"}`;
+function parseJsonResponse(text) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error(`Judge did not return valid JSON.
+Response: "${text}"`);
+  }
+  return JSON.parse(jsonMatch[0]);
+}
+async function matchesSemanticMeaning(response, expected, judge, options) {
+  const threshold = options?.threshold ?? 4;
+  const result = await judge.call({
+    systemPrompt: SEMANTIC_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: `## Text A (AI Response)
+${response.text}
+
+## Text B (Expected)
+${expected}
+
+Evaluate the semantic similarity. Respond with JSON only.`
+      }
+    ],
+    temperature: 0,
+    responseFormat: "json"
+  });
+  const parsed = parseJsonResponse(result.text);
+  const score = parsed.score;
+  if (typeof score !== "number" || score < 1 || score > 5) {
+    throw new Error(
+      `Judge returned invalid score: ${score}. Expected 1-5.
+Response: "${result.text}"`
+    );
+  }
+  const pass = score >= threshold;
+  return {
+    pass,
+    message: pass ? `Expected response NOT to match semantic meaning of "${expected}", but it does (score: ${score}/5).` : `Expected response to match semantic meaning of "${expected}" (threshold: ${threshold}/5, score: ${score}/5).
+Reasoning: ${parsed.reasoning}`,
+    score,
+    reasoning: parsed.reasoning
+  };
+}
+async function satisfiesCriteria(response, rubric, judge) {
+  const criteria = typeof rubric === "string" ? rubric : rubric.criteria;
+  const passThreshold = typeof rubric === "object" ? rubric.passThreshold ?? 0.7 : 0.7;
+  const result = await judge.call({
+    systemPrompt: CRITERIA_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: `## Criteria
+${criteria}
+
+## AI Response to Evaluate
+${response.text}
+
+Evaluate the response against the criteria. Respond with JSON only.`
+      }
+    ],
+    temperature: 0,
+    responseFormat: "json"
+  });
+  const parsed = parseJsonResponse(result.text);
+  const score = parsed.score;
+  if (typeof score !== "number" || score < 0 || score > 1) {
+    throw new Error(
+      `Judge returned invalid score: ${score}. Expected 0-1.
+Response: "${result.text}"`
+    );
+  }
+  const pass = score >= passThreshold;
+  return {
+    pass,
+    message: pass ? `Expected response NOT to satisfy criteria "${criteria}", but it does (score: ${score}).` : `Expected response to satisfy criteria "${criteria}" (threshold: ${passThreshold}, score: ${score}).
+Reasoning: ${parsed.reasoning}`,
+    score,
+    reasoning: parsed.reasoning
+  };
+}
+async function classifiedAs(response, label, judge, options) {
+  const categoriesText = options?.categories?.length ? `
+Possible categories: ${options.categories.join(", ")}` : "";
+  const result = await judge.call({
+    systemPrompt: CLASSIFICATION_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: `## AI Response
+${response.text}${categoriesText}
+
+Classify this response. Respond with JSON only.`
+      }
+    ],
+    temperature: 0,
+    responseFormat: "json"
+  });
+  const parsed = parseJsonResponse(result.text);
+  const actualLabel = parsed.label?.toLowerCase();
+  const expectedLabel = label.toLowerCase();
+  const pass = actualLabel === expectedLabel;
+  return {
+    pass,
+    message: pass ? `Expected response NOT to be classified as "${label}", but it was.` : `Expected response to be classified as "${label}", but was classified as "${parsed.label}".
+Reasoning: ${parsed.reasoning}`,
+    reasoning: parsed.reasoning,
+    metadata: { actualLabel: parsed.label, expectedLabel: label }
+  };
+}
+async function doesNotDisclose(response, topic, judge) {
+  const result = await judge.call({
+    systemPrompt: DISCLOSURE_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: `## Topic to check for disclosure
+${topic}
+
+## AI Response
+${response.text}
+
+Does the response disclose information about the topic? Respond with JSON only.`
+      }
+    ],
+    temperature: 0,
+    responseFormat: "json"
+  });
+  const parsed = parseJsonResponse(result.text);
+  const disclosed = parsed.disclosed;
+  const pass = !disclosed;
+  return {
+    pass,
+    message: pass ? `Expected response to disclose "${topic}", but it did not.` : `Expected response NOT to disclose "${topic}", but it did.
+Reasoning: ${parsed.reasoning}`,
+    reasoning: parsed.reasoning
+  };
+}
+async function assertConsistent(provider, message, runs, options) {
+  if (!options?.judge) {
+    throw new Error(
+      "assertConsistent requires a judge provider. Pass it via options.judge."
+    );
+  }
+  const { send: send2 } = await import("./send-P3XIZERN.js");
+  const responses = await Promise.all(
+    Array.from(
+      { length: runs },
+      () => send2(provider, message, {
+        systemPrompt: options.systemPrompt,
+        tools: options.tools
+      })
+    )
+  );
+  const threshold = options.threshold ?? 4;
+  const scores = [];
+  const reasoning = [];
+  const [baseline, ...rest] = responses;
+  if (!baseline) {
+    return { pass: true, scores: [], reasoning: [] };
+  }
+  for (const response of rest) {
+    const result = await matchesSemanticMeaning(
+      response,
+      baseline.text,
+      options.judge,
+      { threshold }
+    );
+    scores.push(result.score ?? 0);
+    reasoning.push(result.reasoning ?? "");
+  }
+  const allPass = scores.every((s) => s >= threshold);
+  return { pass: allPass, scores, reasoning };
+}
+
+// src/providers/pricing.ts
+var defaultPricing = {
+  "gpt-4o": { inputCentsPer1M: 250, outputCentsPer1M: 1e3 },
+  "gpt-4o-mini": { inputCentsPer1M: 15, outputCentsPer1M: 60 },
+  "gpt-4.1": { inputCentsPer1M: 200, outputCentsPer1M: 800 },
+  "gpt-4.1-mini": { inputCentsPer1M: 40, outputCentsPer1M: 160 },
+  "gpt-4.1-nano": { inputCentsPer1M: 10, outputCentsPer1M: 40 },
+  o1: { inputCentsPer1M: 1500, outputCentsPer1M: 6e3 },
+  "o1-mini": { inputCentsPer1M: 110, outputCentsPer1M: 440 },
+  "o3-mini": { inputCentsPer1M: 110, outputCentsPer1M: 440 },
+  "claude-sonnet-4-20250514": { inputCentsPer1M: 300, outputCentsPer1M: 1500 },
+  "claude-opus-4-20250514": { inputCentsPer1M: 1500, outputCentsPer1M: 7500 },
+  "claude-haiku-3-5-20241022": { inputCentsPer1M: 80, outputCentsPer1M: 400 },
+  "gemini-2.5-flash": { inputCentsPer1M: 15, outputCentsPer1M: 60 },
+  "gemini-2.5-pro": { inputCentsPer1M: 125, outputCentsPer1M: 1e3 },
+  "gemini-2.0-flash": { inputCentsPer1M: 10, outputCentsPer1M: 40 },
+  "grok-3": { inputCentsPer1M: 300, outputCentsPer1M: 1500 },
+  "grok-3-mini": { inputCentsPer1M: 30, outputCentsPer1M: 50 }
+};
+var customPricing = {};
+function setPricing(pricing) {
+  customPricing = { ...customPricing, ...pricing };
+}
+function resetPricing() {
+  customPricing = {};
+}
+function getPricing(model) {
+  const exact = customPricing[model] ?? defaultPricing[model];
+  if (exact) return exact;
+  const allPricing = { ...defaultPricing, ...customPricing };
+  for (const [key, pricing] of Object.entries(allPricing)) {
+    if (model.startsWith(key)) return pricing;
+  }
+  return { inputCentsPer1M: 1e3, outputCentsPer1M: 3e3 };
+}
+function estimateCostCents(model, inputTokens, outputTokens) {
+  const pricing = getPricing(model);
+  return inputTokens / 1e6 * pricing.inputCentsPer1M + outputTokens / 1e6 * pricing.outputCentsPer1M;
+}
+
+// src/send-agentic.ts
+var DEFAULT_MAX_STEPS = 10;
+var noopExecutor = () => "[]";
+function sumUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    totalTokens: a.totalTokens + b.totalTokens
+  };
+}
+async function sendAgentic(provider, message, options) {
+  const start = performance.now();
+  const executor = options?.executor ?? noopExecutor;
+  const maxSteps = options?.maxSteps ?? DEFAULT_MAX_STEPS;
+  const history = [{ role: "user", content: message }];
+  let totalUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  };
+  const allToolCalls = [];
+  let lastText = "";
+  let lastRaw;
+  for (let step = 0; step < maxSteps; step++) {
+    const response = await provider.call({
+      systemPrompt: options?.systemPrompt,
+      messages: history,
+      tools: options?.tools,
+      temperature: options?.temperature,
+      maxTokens: options?.maxTokens,
+      responseFormat: options?.responseFormat
+    });
+    totalUsage = sumUsage(totalUsage, response.usage);
+    lastText = response.text;
+    lastRaw = response.raw;
+    if (response.toolCalls.length === 0) {
+      break;
+    }
+    allToolCalls.push(...response.toolCalls);
+    history.push({
+      role: "assistant",
+      content: response.text,
+      toolCalls: response.toolCalls
+    });
+    for (const tc of response.toolCalls) {
+      let result;
+      try {
+        result = await executor(tc.name, tc.args);
+      } catch (err) {
+        result = String(err);
+      }
+      history.push({
+        role: "tool",
+        toolCallName: tc.name,
+        toolCallId: tc.id ?? tc.name,
+        content: typeof result === "string" ? result : JSON.stringify(result)
+      });
+    }
+    if (step === maxSteps - 1) {
+      console.warn(
+        `[pest] sendAgentic: maxSteps (${maxSteps}) reached \u2014 the model may not have finished its tool-calling loop. Increase maxSteps or check your tools/prompt.`
+      );
+    }
+  }
+  const latencyMs = performance.now() - start;
+  return {
+    text: lastText,
+    toolCalls: allToolCalls,
+    usage: totalUsage,
+    raw: lastRaw,
+    latencyMs,
+    provider: provider.name,
+    model: provider.model
+  };
+}
+
+// src/zod-tool.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+function zodTool(name, description, schema) {
+  return {
+    type: "function",
+    function: {
+      name,
+      description,
+      parameters: zodToJsonSchema(schema)
+    }
+  };
+}
+
+// src/accumulator.ts
+var store = /* @__PURE__ */ new Map();
+function startTest(testId, testName) {
+  store.set(testId, {
+    testId,
+    testName,
+    startTime: Date.now(),
+    sends: [],
+    entries: []
+  });
+}
+function endTest(testId) {
+  const data = store.get(testId);
+  if (data) {
+    data.endTime = Date.now();
+  }
+}
+function recordSend(testId, entry) {
+  const data = store.get(testId);
+  if (data) {
+    data.sends.push(entry);
+  }
+}
+function record2(testId, entry) {
+  const data = store.get(testId);
+  if (data) {
+    data.entries.push(entry);
+  }
+}
+function getTestData(testId) {
+  return store.get(testId);
+}
+function getAllTestData() {
+  return store;
+}
+function clearAll() {
+  store.clear();
+}
+function buildMatcherEntry(matcher, result, response, judgeModel) {
+  return {
+    matcher,
+    pass: result.pass,
+    score: result.score,
+    reasoning: result.reasoning,
+    response: response ? {
+      provider: response.provider,
+      model: response.model,
+      latencyMs: response.latencyMs,
+      usage: { ...response.usage },
+      toolCalls: response.toolCalls,
+      text: response.text
+    } : void 0,
+    judgeModel
+  };
+}
+
+// src/format.ts
+var ansi = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m"
+};
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatCost(cents) {
+  return `$${(cents / 100).toFixed(4)}`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/matchers-factory.ts
+function createRecordResult(getTestId) {
+  return (matcher, result, received, judgeModel) => {
+    const testId = getTestId();
+    if (testId) {
+      record2(testId, buildMatcherEntry(matcher, result, received, judgeModel));
+    }
+  };
+}
+function createPestMatchers(getTestId) {
+  const recordResult = createRecordResult(getTestId);
+  return {
+    // --- Deterministic ---
+    toContainToolCall(received, name, args) {
+      const result = containsToolCall(received, name, args);
+      recordResult("toContainToolCall", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    toCallToolsInOrder(received, names) {
+      const result = callsToolsInOrder(received, names);
+      recordResult("toCallToolsInOrder", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    toMatchResponseSchema(received, schema) {
+      const result = matchesResponseSchema(
+        received,
+        schema
+      );
+      recordResult("toMatchResponseSchema", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    toRespondWithinTokens(received, maxTokens) {
+      const result = respondsWithinTokens(received, maxTokens);
+      recordResult("toRespondWithinTokens", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    toContainText(received, text) {
+      const result = containsText(received, text);
+      recordResult("toContainText", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    toNotContainText(received, text) {
+      const result = containsText(received, text);
+      const inverted = { ...result, pass: !result.pass };
+      recordResult("toNotContainText", inverted, received);
+      return {
+        pass: !result.pass,
+        message: () => result.pass ? `Expected response NOT to contain "${text}", but it does.` : `Expected response to contain "${text}", but it doesn't.`
+      };
+    },
+    toHaveToolCallCount(received, count) {
+      const result = hasToolCallCount(received, count);
+      recordResult("toHaveToolCallCount", result, received);
+      return { pass: result.pass, message: () => result.message };
+    },
+    // --- LLM-judged ---
+    async toMatchSemanticMeaning(received, expected, options) {
+      const judge = resolveJudge(options);
+      const result = await matchesSemanticMeaning(
+        received,
+        expected,
+        judge,
+        options
+      );
+      recordResult("toMatchSemanticMeaning", result, received, judge.model);
+      return { pass: result.pass, message: () => result.message };
+    },
+    async toSatisfyCriteria(received, rubric, options) {
+      const judge = resolveJudge(options);
+      const result = await satisfiesCriteria(received, rubric, judge);
+      recordResult("toSatisfyCriteria", result, received, judge.model);
+      return { pass: result.pass, message: () => result.message };
+    },
+    async toBeClassifiedAs(received, label, options) {
+      const judge = resolveJudge(options);
+      const result = await classifiedAs(received, label, judge, options);
+      recordResult("toBeClassifiedAs", result, received, judge.model);
+      return { pass: result.pass, message: () => result.message };
+    },
+    async toNotDisclose(received, topic, options) {
+      const judge = resolveJudge(options);
+      const result = await doesNotDisclose(received, topic, judge);
+      recordResult("toNotDisclose", result, received, judge.model);
+      return { pass: result.pass, message: () => result.message };
+    }
+  };
+}
+
+// src/report-data.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+
+// src/report-html.ts
+function buildHtmlReport(data) {
+  const s = data.summary;
+  const testRows = data.tests.map((t) => {
+    const statusIcon = t.status === "passed" ? "&#10003;" : "&#10007;";
+    const statusClass = t.status === "passed" ? "pass" : "fail";
+    const inputTokens = t.sends.reduce(
+      (sum, s2) => sum + s2.usage.inputTokens,
+      0
+    );
+    const outputTokens = t.sends.reduce(
+      (sum, s2) => sum + s2.usage.outputTokens,
+      0
+    );
+    const latencyMs = t.sends.reduce((sum, s2) => sum + s2.latencyMs, 0);
+    const toolCalls = t.sends.flatMap((s2) => s2.toolCalls);
+    const sendsHtml = t.sends.map(
+      (send2, i) => `
+      <div class="send">
+        <div class="send-header">
+          <span class="label">Send #${i + 1}</span>
+          <span class="meta">${escapeHtml(send2.provider)} / ${escapeHtml(send2.model)} &middot; ${formatDuration(send2.latencyMs)} &middot; ${send2.usage.inputTokens}\u2192${send2.usage.outputTokens} tok</span>
+        </div>
+        ${send2.systemPrompt ? `<div class="message system"><span class="role">System</span><pre>${escapeHtml(send2.systemPrompt)}</pre></div>` : ""}
+        <div class="message user"><span class="role">User</span><pre>${escapeHtml(send2.input)}</pre></div>
+        <div class="message assistant"><span class="role">Assistant</span><pre>${escapeHtml(send2.output || "(no text \u2014 tool calls only)")}</pre></div>
+        ${send2.toolCalls.length > 0 ? `
+          <div class="tool-calls">
+            ${send2.toolCalls.map((tc) => `<div class="tool-call"><span class="tool-name">${escapeHtml(tc.name)}</span><code>${escapeHtml(JSON.stringify(tc.args))}</code></div>`).join("")}
+          </div>
+        ` : ""}
+      </div>
+    `
+    ).join("");
+    const matchersHtml = t.matchers.map((m) => {
+      const mIcon = m.pass ? "&#10003;" : "&#10007;";
+      const mClass = m.pass ? "pass" : "fail";
+      const scoreStr = m.score != null ? `<span class="score">score ${m.score}</span>` : "";
+      const judgeStr = m.judgeModel ? `<span class="judge">judge: ${escapeHtml(m.judgeModel)}</span>` : "";
+      const reasonStr = m.reasoning ? `<div class="reasoning">${escapeHtml(m.reasoning)}</div>` : "";
+      return `<div class="matcher ${mClass}"><span class="matcher-icon">${mIcon}</span> <code>${escapeHtml(m.matcher)}</code> ${scoreStr} ${judgeStr}${reasonStr}</div>`;
+    }).join("");
+    return `
+      <div class="test ${statusClass}">
+        <div class="test-header" onclick="this.parentElement.classList.toggle('open')">
+          <span class="status-icon">${statusIcon}</span>
+          <span class="test-name">${escapeHtml(t.test)}</span>
+          <span class="test-meta">${formatDuration(latencyMs)} &middot; ${formatTokens(inputTokens)}\u2192${formatTokens(outputTokens)} tok${toolCalls.length > 0 ? ` &middot; ${toolCalls.length} tool calls` : ""}</span>
+        </div>
+        <div class="test-body">
+          <div class="sends">${sendsHtml}</div>
+          ${matchersHtml ? `<div class="matchers"><h4>Assertions</h4>${matchersHtml}</div>` : ""}
+        </div>
+      </div>
+    `;
+  }).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>pest report \u2014 ${escapeHtml(data.timestamp)}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: system-ui, -apple-system, sans-serif; background: #0d1117; color: #c9d1d9; line-height: 1.5; }
+  .container { max-width: 1000px; margin: 0 auto; padding: 24px; }
+  h1 { font-size: 24px; font-weight: 600; margin-bottom: 8px; color: #f0f6fc; }
+  h1 span { color: #58a6ff; }
+  .timestamp { color: #8b949e; font-size: 14px; margin-bottom: 24px; }
+  .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 12px; margin-bottom: 32px; }
+  .stat { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; }
+  .stat-value { font-size: 24px; font-weight: 600; color: #f0f6fc; }
+  .stat-label { font-size: 12px; color: #8b949e; text-transform: uppercase; letter-spacing: 0.5px; }
+  .test { background: #161b22; border: 1px solid #30363d; border-radius: 8px; margin-bottom: 8px; overflow: hidden; }
+  .test-header { padding: 12px 16px; cursor: pointer; display: flex; align-items: center; gap: 8px; user-select: none; }
+  .test-header:hover { background: #1c2128; }
+  .status-icon { font-size: 16px; }
+  .pass .status-icon { color: #3fb950; }
+  .fail .status-icon { color: #f85149; }
+  .test-name { flex: 1; font-size: 14px; }
+  .test-meta { font-size: 12px; color: #8b949e; }
+  .test-body { display: none; border-top: 1px solid #30363d; padding: 16px; }
+  .test.open .test-body { display: block; }
+  .send { margin-bottom: 16px; }
+  .send-header { font-size: 12px; color: #8b949e; margin-bottom: 8px; display: flex; justify-content: space-between; }
+  .label { font-weight: 600; color: #c9d1d9; }
+  .message { margin-bottom: 8px; border-radius: 6px; padding: 10px 14px; font-size: 13px; }
+  .message .role { font-size: 11px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px; display: block; margin-bottom: 4px; }
+  .message pre { white-space: pre-wrap; word-break: break-word; font-family: inherit; }
+  .message.system { background: #1c1c3a; border-left: 3px solid #8b5cf6; }
+  .message.system .role { color: #8b5cf6; }
+  .message.user { background: #0c2d48; border-left: 3px solid #58a6ff; }
+  .message.user .role { color: #58a6ff; }
+  .message.assistant { background: #1a2b1a; border-left: 3px solid #3fb950; }
+  .message.assistant .role { color: #3fb950; }
+  .tool-calls { margin-top: 8px; }
+  .tool-call { font-size: 13px; padding: 6px 10px; background: #1c1f26; border-radius: 4px; margin-bottom: 4px; display: flex; gap: 8px; align-items: center; }
+  .tool-name { color: #d2a8ff; font-weight: 600; }
+  .tool-call code { color: #8b949e; font-size: 12px; }
+  .matchers { margin-top: 16px; }
+  .matchers h4 { font-size: 12px; color: #8b949e; text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 8px; }
+  .matcher { font-size: 13px; padding: 6px 10px; margin-bottom: 4px; border-radius: 4px; display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+  .matcher.pass { background: #1a2b1a; }
+  .matcher.fail { background: #2b1a1a; }
+  .matcher-icon { font-size: 14px; }
+  .matcher.pass .matcher-icon { color: #3fb950; }
+  .matcher.fail .matcher-icon { color: #f85149; }
+  .matcher code { color: #d2a8ff; }
+  .score { color: #e3b341; font-size: 12px; }
+  .judge { color: #8b949e; font-size: 12px; }
+  .reasoning { width: 100%; color: #8b949e; font-size: 12px; font-style: italic; margin-top: 4px; }
+</style>
+</head>
+<body>
+<div class="container">
+  <h1><span>pest</span> report</h1>
+  <div class="timestamp">${escapeHtml(data.timestamp)}</div>
+  <div class="summary">
+    <div class="stat"><div class="stat-value">${s.tests}</div><div class="stat-label">Tests</div></div>
+    <div class="stat"><div class="stat-value">${formatTokens(s.totalTokens)}</div><div class="stat-label">Tokens</div></div>
+    <div class="stat"><div class="stat-value">${escapeHtml(s.estimatedCost)}</div><div class="stat-label">Est. Cost</div></div>
+    <div class="stat"><div class="stat-value">${s.judgeCount}</div><div class="stat-label">Judge Calls</div></div>
+    <div class="stat"><div class="stat-value">${s.toolCallCount}</div><div class="stat-label">Tool Calls</div></div>
+    <div class="stat"><div class="stat-value">${formatTokens(s.inputTokens)}\u2192${formatTokens(s.outputTokens)}</div><div class="stat-label">In \u2192 Out</div></div>
+  </div>
+  ${testRows}
+</div>
+</body>
+</html>`;
+}
+
+// src/report-data.ts
+var silent = process.env.PEST_SILENT === "1";
+function log(...args) {
+  if (!silent) console.log(...args);
+}
+function emptyStats() {
+  return {
+    tests: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalLatencyMs: 0,
+    totalCostCents: 0,
+    judgeCount: 0,
+    toolCallCount: 0
+  };
+}
+function processTestResult(testResult, stats, options) {
+  stats.tests++;
+  const { entries, sends } = testResult;
+  const inputTokens = sends.reduce((sum, s) => sum + s.usage.inputTokens, 0);
+  const outputTokens = sends.reduce((sum, s) => sum + s.usage.outputTokens, 0);
+  const latencyMs = sends.reduce((sum, s) => sum + s.latencyMs, 0);
+  const toolCalls = sends.reduce((sum, s) => sum + s.toolCalls.length, 0);
+  const model = sends[0]?.model ?? "";
+  const provider = sends[0]?.provider ?? "";
+  let costCents = 0;
+  if (model) {
+    costCents = estimateCostCents(model, inputTokens, outputTokens);
+  }
+  stats.totalInputTokens += inputTokens;
+  stats.totalOutputTokens += outputTokens;
+  stats.totalLatencyMs += latencyMs;
+  stats.totalCostCents += costCents;
+  stats.toolCallCount += toolCalls;
+  const statusIcon = testResult.status === "passed" ? `${ansi.green}\u2713${ansi.reset}` : `${ansi.red}\u2717${ansi.reset}`;
+  const parts = [];
+  if (provider) parts.push(`${ansi.dim}${provider}${ansi.reset}`);
+  parts.push(`${ansi.dim}${formatDuration(latencyMs)}${ansi.reset}`);
+  parts.push(
+    `${ansi.cyan}${formatTokens(inputTokens)}\u2192${formatTokens(outputTokens)} tok${ansi.reset}`
+  );
+  if (options.showCost && costCents > 0) {
+    parts.push(`${ansi.dim}${formatCost(costCents)}${ansi.reset}`);
+  }
+  if (toolCalls > 0) {
+    const toolNames = [
+      ...new Set(sends.flatMap((s) => s.toolCalls.map((tc) => tc.name)))
+    ];
+    parts.push(`${ansi.magenta}${toolNames.join(", ")}${ansi.reset}`);
+  }
+  log(
+    `  ${ansi.dim}pest${ansi.reset} ${statusIcon} ${testResult.name} \u2502 ${parts.join(" \u2502 ")}`
+  );
+  const judgeEntries = entries.filter((e) => e.judgeModel);
+  if (judgeEntries.length > 0) {
+    stats.judgeCount += judgeEntries.length;
+    for (const entry of judgeEntries) {
+      const scoreStr = entry.score != null ? ` score ${entry.score}` : "";
+      const icon = entry.pass ? `${ansi.green}\u2713${ansi.reset}` : `${ansi.red}\u2717${ansi.reset}`;
+      const reasoning = options.verbose && entry.reasoning ? ` ${ansi.dim}"${entry.reasoning}"${ansi.reset}` : "";
+      log(
+        `       ${icon} ${ansi.dim}${entry.matcher}${ansi.reset}${scoreStr}${reasoning}`
+      );
+    }
+  }
+  return {
+    test: testResult.name,
+    status: testResult.status,
+    sends,
+    matchers: entries.map((e) => ({
+      matcher: e.matcher,
+      pass: e.pass,
+      score: e.score,
+      reasoning: e.reasoning,
+      judgeModel: e.judgeModel
+    }))
+  };
+}
+function finishReport(stats, logEntries, options) {
+  if (stats.tests === 0) return;
+  const totalTokens = stats.totalInputTokens + stats.totalOutputTokens;
+  const parts = [
+    `${stats.tests} tests`,
+    `${formatTokens(totalTokens)} tokens ${ansi.dim}(${formatTokens(stats.totalInputTokens)}\u2192${formatTokens(stats.totalOutputTokens)})${ansi.reset}`
+  ];
+  if (options.showCost && stats.totalCostCents > 0) {
+    parts.push(formatCost(stats.totalCostCents));
+  }
+  if (stats.judgeCount > 0) {
+    parts.push(`${stats.judgeCount} judge calls`);
+  }
+  if (stats.toolCallCount > 0) {
+    parts.push(`${stats.toolCallCount} tool calls`);
+  }
+  log("");
+  log(`  ${ansi.bold}pest${ansi.reset} ${parts.join(`${ansi.dim} \u2502 ${ansi.reset}`)}`);
+  log("");
+  const reportPayload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      tests: stats.tests,
+      totalTokens,
+      inputTokens: stats.totalInputTokens,
+      outputTokens: stats.totalOutputTokens,
+      estimatedCost: formatCost(stats.totalCostCents),
+      judgeCount: stats.judgeCount,
+      toolCallCount: stats.toolCallCount
+    },
+    tests: logEntries
+  };
+  const logFile = process.env.PEST_LOG_FILE ?? options.logFile;
+  if (logFile && logEntries.length > 0) {
+    const logPath = resolve2(process.cwd(), logFile);
+    mkdirSync(dirname(logPath), { recursive: true });
+    writeFileSync(logPath, JSON.stringify(reportPayload, null, 2));
+    log(`  ${ansi.dim}pest log written to ${logFile}${ansi.reset}`);
+  }
+  if (options.htmlFile && logEntries.length > 0) {
+    const htmlPath = resolve2(process.cwd(), options.htmlFile);
+    mkdirSync(dirname(htmlPath), { recursive: true });
+    writeFileSync(htmlPath, buildHtmlReport(reportPayload));
+    log(`  ${ansi.dim}pest report written to ${options.htmlFile}${ansi.reset}`);
+  }
+  log("");
+}
+export {
+  ansi,
+  assertConsistent,
+  buildHtmlReport,
+  buildMatcherEntry,
+  callsToolsInOrder,
+  classifiedAs,
+  clearAll,
+  containsText,
+  containsToolCall,
+  createPestMatchers,
+  createProvider,
+  createProviders,
+  defineConfig,
+  doesNotDisclose,
+  emptyStats,
+  endTest,
+  escapeHtml,
+  estimateCostCents,
+  finishReport,
+  formatCost,
+  formatDuration,
+  formatTokens,
+  getAllTestData,
+  getJudge,
+  getPricing,
+  getTestData,
+  hasToolCallCount,
+  loadConfig,
+  loadEnv,
+  matchesResponseSchema,
+  matchesSemanticMeaning,
+  onSend,
+  processTestResult,
+  record2 as record,
+  recordSend,
+  resetEnv,
+  resetPricing,
+  resolveJudge,
+  respondsWithinTokens,
+  satisfiesCriteria,
+  send,
+  sendAgentic,
+  setJudge,
+  setPricing,
+  startTest,
+  useProvider,
+  useSystemPrompt,
+  zodTool
+};