@hawkeyexl/inference 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 inference contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+# @hawkeyexl/inference
+
+Shared LLM inference layer for the docs-as-tests toolchain: schema-constrained completion across
+Anthropic, OpenAI-compatible, and Claude CLI providers, with result caching, cost accounting, and
+an LLM-as-judge ensemble on top.
+
+Extracted from three projects that had each grown their own copy —
+[docevals](https://github.com/hawkeyexl/docevals), [dockg](https://github.com/hawkeyexl/dockg), and
+[agentevals](https://github.com/hawkeyexl/agentevals) — so a provider fix lands once instead of
+three times.
+
+## Install
+
+```bash
+npm install @hawkeyexl/inference
+```
+
+Requires Node 24+. ESM only.
+
+## What it does
+
+Every consumer of this library wants the same narrow thing: **send a system prompt, a user prompt,
+and a JSON Schema; get back JSON that validates against that schema, or a recorded error.** No
+streaming, no multi-turn, no tool loops.
+
+Two layers, one entry point:
+
+- **Completion** — the provider contract, four providers, a content-addressed cache, a price table,
+  and a validate-and-retry wrapper. This is all dockg-style structured extraction needs.
+- **Judge** — the canonical verdict schema, an N-run ensemble, consensus math, and confidence-zone
+  routing. Built on the completion layer; ignore it if you do not need it.
+
+## Quick start
+
+### Schema-constrained completion
+
+```ts
+import { completeValidatedJSON, makeProvider } from "@hawkeyexl/inference";
+
+const provider = makeProvider({ provider: "anthropic", model: "claude-sonnet-4-5" });
+
+const run = await completeValidatedJSON<{ summary: string }>({
+  provider,
+  system: "You summarize documentation pages.",
+  user: pageBody,
+  schema: {
+    type: "object",
+    required: ["summary"],
+    properties: { summary: { type: "string" } },
+    additionalProperties: false,
+  },
+});
+
+if (run.error) console.error(run.error);
+else console.log(run.result.summary, run.usage);
+```
+
+`completeValidatedJSON` never throws on a model failure and never coerces a bad response. It
+retries once, then returns a run with `error` set and `result` absent.
+
+### LLM-as-judge
+
+```ts
+import { judge, makeProvider } from "@hawkeyexl/inference";
+
+const consensus = await judge({
+  provider: makeProvider({ provider: "claude-cli" }),
+  system: "You evaluate whether a page satisfies an assertion.",
+  user: "# Assertion\nThe page documents authentication.\n\n# Page\n...",
+  runs: 3,
+});
+
+consensus.verdict;   // "pass" | "fail"   — partial counts as fail
+consensus.zone;      // "auto-pass" | "auto-fail" | "human-review"
+consensus.agreement; // 0..1 across non-errored runs
+```
+
+Only a **unanimous, high-confidence** ensemble auto-resolves. Anything split, low-confidence, or
+containing an errored run routes to `human-review` — an errored run can never produce a silent pass.
+
+### Caching
+
+Key composition stays with you, because each consumer has a different notion of what should
+invalidate an entry (page body, prompt version, ensemble size, requested fields):
+
+```ts
+import { JsonCache, buildCacheKey, runEnsemble, sha256 } from "@hawkeyexl/inference";
+
+const cache = new JsonCache(".mytool/cache", true, "mytool");
+const cacheKey = buildCacheKey([
+  provider.provider(),
+  provider.modelName(),
+  `v${MY_PROMPT_VERSION}`,
+  `r${runs}`,
+  sha256(pageBody),         // pre-hash long parts
+]);
+
+const judgeRuns = await runEnsemble({ provider, system, user, runs, cache, cacheKey });
+```
+
+Cached runs come back flagged `cached: true`, so `costOfRuns` correctly charges nothing for a
+replay. Cache write failures warn once and continue — a read-only workspace must not abort a run
+whose inference already succeeded and was already paid for.
+
+### Cost
+
+```ts
+import { costOfRuns, pricingFor } from "@hawkeyexl/inference";
+
+const pricing = pricingFor(provider.modelName(), configOverride);
+const usd = costOfRuns(judgeRuns, pricing);
+```
+
+An unknown model returns `undefined` pricing and costs `0` — **unknown, never a guess**. A
+fabricated price is worse than an absent one when a budget gate depends on it.
+
+## Providers
+
+Constructed through `makeProvider(spec)`. The spec is a flat, library-owned shape — map your own
+config into it rather than passing your config object (see
+[ADR 01000](adrs/01000-library-owned-provider-spec.md)).
+
+| `provider` | Structured output via | Key | Reports usage |
+|---|---|---|---|
+| `anthropic` | forced tool call | `ANTHROPIC_API_KEY` | yes |
+| `openai` | strict `json_schema`, falls back to `json_object` | `OPENAI_API_KEY` | yes |
+| `claude-cli` | schema in the prompt, `--output-format json` | local `claude` auth | no |
+| `mock` | scripted responses | — | synthetic |
+
+```ts
+interface ProviderSpec {
+  provider: "anthropic" | "openai" | "claude-cli" | "mock";
+  model?: string | null;      // null/undefined -> per-provider default
+  apiKeyEnv?: string | null;  // default ANTHROPIC_API_KEY / OPENAI_API_KEY
+  baseUrl?: string;           // openai only, default https://api.openai.com/v1
+  command?: string;           // claude-cli only, default "claude"
+  timeoutMs?: number;         // claude-cli only, default 180000
+  pricing?: Pricing;          // override the built-in table
+  anthropic?: AnthropicProviderOptions;   // e.g. toolName, maxTokens
+  openai?: OpenAICompatProviderOptions;   // e.g. schemaName
+  exec?: ExecFn;              // test seam for claude-cli
+  mockResponses?: MockResponse[];
+}
+```
+
+`resolveProviderIdentity(spec)` returns `{ provider, model }` **without constructing anything** —
+cache keys and pricing need the identity, but a fully-cached run should not require an API key.
+
+Notes on the non-obvious bits:
+
+- **`openai`** targets any `/chat/completions` server (OpenAI, Azure, Ollama, Groq, Together). It
+  prefers strict `json_schema`, and `toStrictSchema` rewrites your schema into the strict subset
+  (every property in `required`, optionality as a `null` type union, unsupported keywords dropped);
+  nulls are stripped back out of the response. If the server rejects `response_format`, it
+  permanently falls back to `json_object` with the schema in the prompt. Keyless local servers are
+  allowed — only `api.openai.com` requires a key.
+- **`claude-cli`** uses your local Claude CLI auth, so no API key. The prompt goes over **stdin**,
+  never argv: user content routinely exceeds the ~32K Windows command-line limit.
+
+## Testing against this library
+
+`MockProvider` is exported for exactly this. No network required:
+
+```ts
+import { MockProvider, mockVerdict, runEnsemble } from "@hawkeyexl/inference";
+
+const provider = new MockProvider([mockVerdict("pass", 0.95)]);   // cycles when exhausted
+const runs = await runEnsemble({ provider, system, user, runs: 3 });
+provider.requests;  // every request seen, in order
+```
+
+Script an error with `{ error: "429 rate limited" }` to exercise your failure paths.
+
+## API
+
+Everything exports from the package root.
+
+**Providers** — `makeProvider`, `resolveProviderIdentity`, `DEFAULT_MODELS`,
+`DEFAULT_OPENAI_BASE_URL`, `AnthropicProvider`, `OpenAICompatProvider`, `ClaudeCliProvider`,
+`MockProvider`, `mockVerdict`, `extractJson`, `toStrictSchema`, `stripNulls`, `realExec`
+
+**Completion** — `completeValidatedJSON`, `validatorFor`
+
+**Cache** — `JsonCache`, `buildCacheKey`, `sha256`
+
+**Cost** — `pricingFor`, `costOfUsage`, `costOfRuns`, `PRICE_TABLE`
+
+**Judge** — `judge`, `runEnsemble`, `computeConsensus`, `zoneFor`, `VERDICT_SCHEMA`,
+`DEFAULT_ZONES`
+
+**Errors** — `InferenceError` (operational failures: missing key, unknown provider)
+
+Types: `InferenceProvider`, `ProviderSpec`, `ProviderName`, `CompleteJSONRequest`,
+`CompleteJSONResponse`, `InferenceRun`, `TokenUsage`, `Pricing`, `JudgeRun`, `JudgeVerdict`,
+`ConsensusResult`, `Match`, `Zone`, `ZoneThresholds`, `EnsembleOptions`, `ExecFn`, `ExecResult`,
+`ExecOptions`, `MockResponse`.
+
+## Design decisions
+
+Recorded as ADRs in [adrs/](adrs):
+
+- [01000](adrs/01000-library-owned-provider-spec.md) — a library-owned `ProviderSpec`, not consumer
+  config objects
+- [01001](adrs/01001-single-entry-point-and-canonical-verdict-schema.md) — one entry point; a
+  canonical verdict schema with a per-consumer override seam
+- [01002](adrs/01002-best-of-merge-of-three-forks.md) — which fork won for each merged file, so the
+  losing variants are not reintroduced
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,371 @@
+import { ValidateFunction } from 'ajv';
+
+/**
+ * Shared error type. Consumers catch this to distinguish an inference-layer
+ * operational failure (missing API key, unknown provider) from their own
+ * domain errors, and typically map it to their own exit code.
+ */
+declare class InferenceError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * The provider contract. A provider turns a (system, user, schema) request
+ * into schema-conforming JSON. `provider()` and `modelName()` feed cache keys
+ * and pricing lookups, so two providers/models never share a cached result.
+ *
+ * This is deliberately the narrowest useful surface: no streaming, no
+ * multi-turn, no tool loops. Everything downstream of it — judging,
+ * extraction, classification — is schema-constrained single-shot completion.
+ */
+interface CompleteJSONRequest {
+    system: string;
+    user: string;
+    /** JSON Schema the response must conform to. */
+    schema: Record<string, unknown>;
+    temperature: number;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+interface CompleteJSONResponse {
+    json: unknown;
+    /** Absent when the provider does not report usage (e.g. the Claude CLI). */
+    usage?: TokenUsage;
+}
+interface InferenceProvider {
+    /** Stable provider id — feeds cache keys. */
+    provider(): string;
+    /** Model id — feeds cache keys and pricing. */
+    modelName(): string;
+    completeJSON(req: CompleteJSONRequest): Promise<CompleteJSONResponse>;
+}
+interface ExecResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    /** Set when the process could not be spawned (e.g. binary not found). */
+    spawnError?: string;
+}
+interface ExecOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+    /** Text piped to the child's stdin (stdin is closed after writing). */
+    input?: string;
+}
+/** Injectable process-execution seam — subprocess providers take one for tests. */
+type ExecFn = (cmd: string[], opts?: ExecOptions) => Promise<ExecResult>;
+
+/**
+ * Cost tracking: token usage priced from a small static table, overridable per
+ * model by the caller. Unknown models cost 0 (unknown), never a guess — a
+ * fabricated price is worse than an absent one when a budget gate depends on it.
+ */
+
+interface Pricing {
+    inputPerMTok: number;
+    outputPerMTok: number;
+}
+/**
+ * USD per million tokens. Entries are base names; pinned variants
+ * (`claude-sonnet-4-5-20250929`) resolve by prefix.
+ */
+declare const PRICE_TABLE: Record<string, Pricing>;
+declare function pricingFor(model: string, override?: Pricing): Pricing | undefined;
+declare function costOfUsage(usage: TokenUsage | undefined, pricing: Pricing | undefined): number;
+/** Sum the cost of a set of runs. Cached runs cost nothing — they made no call. */
+declare function costOfRuns(runs: {
+    usage?: TokenUsage;
+    cached?: boolean;
+}[], pricing: Pricing | undefined): number;
+
+interface AnthropicProviderOptions {
+    /**
+     * Name of the forced tool. Purely cosmetic to the model, but a descriptive
+     * name ("record_verdict", "record_proposal") measurably steers output, so
+     * consumers may set their own.
+     */
+    toolName?: string;
+    /** Tool description shown to the model. */
+    toolDescription?: string;
+    maxTokens?: number;
+}
+declare class AnthropicProvider implements InferenceProvider {
+    private readonly model;
+    private readonly client;
+    private readonly toolName;
+    private readonly toolDescription;
+    private readonly maxTokens;
+    constructor(model: string, apiKeyEnv: string, options?: AnthropicProviderOptions);
+    provider(): string;
+    modelName(): string;
+    completeJSON(req: CompleteJSONRequest): Promise<CompleteJSONResponse>;
+}
+
+/** Extract a JSON object from content that may carry markdown fences. */
+declare function extractJson(content: string): unknown;
+/**
+ * OpenAI strict mode requires `required` to list EVERY property (optionality
+ * is expressed as a `null` type union) and rejects keywords outside its
+ * subset (minLength, uniqueItems). Transform an all-optional schema into a
+ * strict-compatible equivalent; null values are stripped from the response.
+ */
+declare function toStrictSchema(schema: Record<string, unknown>): Record<string, unknown>;
+/** Remove null-valued keys (strict-mode "omitted" marker) from a response object. */
+declare function stripNulls(value: unknown): unknown;
+interface OpenAICompatProviderOptions {
+    /** `json_schema.name` sent to the server. Cosmetic; steers some models. */
+    schemaName?: string;
+}
+declare class OpenAICompatProvider implements InferenceProvider {
+    private readonly baseUrl;
+    private readonly model;
+    private readonly apiKey;
+    private supportsJsonSchema;
+    private readonly schemaName;
+    constructor(baseUrl: string, model: string, apiKeyEnv: string, apiKey?: string | undefined, options?: OpenAICompatProviderOptions);
+    provider(): string;
+    modelName(): string;
+    private chat;
+    completeJSON(req: CompleteJSONRequest): Promise<CompleteJSONResponse>;
+    private jsonObjectFallback;
+}
+
+/**
+ * Mock provider for tests and offline development. Responds with scripted
+ * results in order, cycling when exhausted. Exported from the public API so
+ * downstream consumers can test their own pipelines without a live provider.
+ */
+
+type MockResponse = {
+    json: unknown;
+    usage?: TokenUsage;
+} | {
+    error: string;
+};
+declare class MockProvider implements InferenceProvider {
+    private readonly responses;
+    private readonly model;
+    private calls;
+    /** Every request seen, in order — assert against this in tests. */
+    readonly requests: CompleteJSONRequest[];
+    constructor(responses: MockResponse[], model?: string);
+    provider(): string;
+    modelName(): string;
+    completeJSON(req: CompleteJSONRequest): Promise<CompleteJSONResponse>;
+}
+/** Convenience: a scripted response shaped like the canonical judge verdict. */
+declare function mockVerdict(match: "pass" | "fail" | "partial", confidence: number, overrides?: Partial<{
+    claim: string;
+    observed: string;
+    reasoning: string;
+}>): {
+    json: unknown;
+};
+
+type ProviderName = "anthropic" | "openai" | "claude-cli" | "mock";
+interface ProviderSpec {
+    provider: ProviderName;
+    /** null/undefined selects the per-provider default. */
+    model?: string | null;
+    /** Env var NAME holding the API key; null/undefined selects the default. */
+    apiKeyEnv?: string | null;
+    /** openai only. */
+    baseUrl?: string;
+    /** claude-cli only: the executable to run. */
+    command?: string;
+    /** claude-cli only: subprocess timeout. */
+    timeoutMs?: number;
+    /**
+     * Pricing override for this model. Not used to construct the provider —
+     * carried here so a consumer passes one object to both `makeProvider` and
+     * `pricingFor`.
+     */
+    pricing?: Pricing;
+    /** Provider-specific tuning, ignored by the other providers. */
+    anthropic?: AnthropicProviderOptions;
+    openai?: OpenAICompatProviderOptions;
+    /** Test seam for the claude-cli provider. */
+    exec?: ExecFn;
+    /** Scripted responses for the mock provider; defaults to a single empty object. */
+    mockResponses?: MockResponse[];
+}
+declare const DEFAULT_MODELS: Record<ProviderName, string>;
+declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+/**
+ * Resolve the provider name and model WITHOUT constructing the provider —
+ * cache keys and pricing need the identity, but construction may require an
+ * API key that a fully-cached run never uses.
+ */
+declare function resolveProviderIdentity(spec: ProviderSpec): {
+    provider: string;
+    model: string;
+};
+declare function makeProvider(spec: ProviderSpec): InferenceProvider;
+
+declare class ClaudeCliProvider implements InferenceProvider {
+    private readonly model;
+    private readonly command;
+    private readonly exec;
+    private readonly timeoutMs;
+    constructor(model: string, command?: string, exec?: ExecFn, timeoutMs?: number);
+    provider(): string;
+    modelName(): string;
+    completeJSON(req: CompleteJSONRequest): Promise<CompleteJSONResponse>;
+}
+
+declare const realExec: ExecFn;
+
+/** One attempt at a schema-constrained completion. */
+interface InferenceRun<T = unknown> {
+    /** Absent when the run errored (invalid JSON after retry, API failure). */
+    result?: T;
+    error?: string;
+    provider: string;
+    model: string;
+    cached: boolean;
+    usage?: TokenUsage;
+    durationMs: number;
+}
+interface CompleteValidatedOptions {
+    provider: InferenceProvider;
+    system: string;
+    user: string;
+    schema: Record<string, unknown>;
+    temperature?: number;
+    /**
+     * Attempts before recording an error. Default 2 (one initial call plus one
+     * retry) — matches the behavior all three source projects shipped.
+     */
+    attempts?: number;
+    /**
+     * Pre-compiled validator. Compiling Ajv per call is wasteful in an ensemble
+     * loop, so `runEnsemble` compiles once and passes it down.
+     */
+    validate?: ValidateFunction;
+}
+/** Compile once per schema object identity — Ajv compilation is not cheap. */
+declare function validatorFor(schema: Record<string, unknown>): ValidateFunction;
+declare function completeValidatedJSON<T = unknown>(options: CompleteValidatedOptions): Promise<InferenceRun<T>>;
+
+declare function sha256(text: string): string;
+/**
+ * Hash an ordered list of key parts into a cache key. Long parts (page bodies,
+ * rendered traces) should be pre-hashed with `sha256` by the caller so the
+ * joined string stays small.
+ */
+declare function buildCacheKey(parts: string[]): string;
+declare class JsonCache<T> {
+    private readonly dir;
+    private readonly enabled;
+    /** Prefix for the one-time write-failure warning. */
+    private readonly label;
+    /** Cache-write failures warn once per process, not once per entry. */
+    private warned;
+    constructor(dir: string, enabled?: boolean, 
+    /** Prefix for the one-time write-failure warning. */
+    label?: string);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+}
+
+declare const VERDICT_SCHEMA: Record<string, unknown>;
+type Match = "pass" | "fail" | "partial";
+/** Confidence-zone routing for LLM-judged evals. */
+type Zone = "auto-pass" | "auto-fail" | "human-review";
+interface JudgeVerdict {
+    /** The specific assertion under evaluation. */
+    claim: string;
+    /** What the judge actually observed. */
+    observed: string;
+    match: Match;
+    /** 0.0–1.0 self-reported confidence. */
+    confidence: number;
+    reasoning: string;
+}
+/** One run within an ensemble. */
+interface JudgeRun {
+    /** Absent when the run errored (invalid JSON after retry, API failure). */
+    verdict?: JudgeVerdict;
+    error?: string;
+    provider: string;
+    model: string;
+    cached: boolean;
+    usage?: TokenUsage;
+    durationMs: number;
+}
+/** Aggregated outcome of an ensemble of judge runs for one subject. */
+interface ConsensusResult {
+    runs: JudgeRun[];
+    votes: {
+        pass: number;
+        fail: number;
+        partial: number;
+        error: number;
+    };
+    /** Majority verdict; `partial` counts as fail for the binary outcome. */
+    verdict: Match;
+    /** Fraction of non-errored runs agreeing with the majority verdict. */
+    agreement: number;
+    /** Mean confidence across non-errored runs. */
+    meanConfidence: number;
+    zone: Zone;
+}
+
+/**
+ * Ensemble consensus math. `partial` counts as fail for the binary outcome
+ * but stays visible in the vote counts. Errored runs count against consensus —
+ * they can only push a result toward human review, never toward a silent pass.
+ */
+
+declare function computeConsensus(runs: JudgeRun[]): Omit<ConsensusResult, "zone">;
+
+/**
+ * Confidence-zone routing: only unanimous, high-confidence ensembles
+ * auto-resolve; everything else goes to a human.
+ */
+
+interface ZoneThresholds {
+    autoPass: number;
+    autoFail: number;
+}
+declare const DEFAULT_ZONES: ZoneThresholds;
+declare function zoneFor(consensus: Omit<ConsensusResult, "zone">, thresholds?: ZoneThresholds): Zone;
+
+interface EnsembleOptions {
+    provider: InferenceProvider;
+    system: string;
+    user: string;
+    /** Ensemble size; default 3. */
+    runs?: number;
+    /** Default 0. Nonzero adds noise to verdicts and warns once. */
+    temperature?: number;
+    /**
+     * Verdict schema. Defaults to the canonical one; pass your own to keep
+     * domain-specific field descriptions (they measurably steer the model).
+     * Must still produce objects matching `JudgeVerdict`.
+     */
+    schema?: Record<string, unknown>;
+    /** Optional result cache. Requires `cacheKey`. */
+    cache?: JsonCache<JudgeRun[]>;
+    /** Content-addressed key; build it with `buildCacheKey`. */
+    cacheKey?: string;
+    /** Prefix for warnings, e.g. your tool's name. */
+    label?: string;
+}
+/**
+ * Run the ensemble and return every run. Cached ensembles replay identically,
+ * with each run flagged `cached: true` so cost accounting skips them.
+ */
+declare function runEnsemble(options: EnsembleOptions): Promise<JudgeRun[]>;
+/** Run the ensemble and aggregate it into a zoned consensus. */
+declare function judge(options: EnsembleOptions & {
+    zones?: ZoneThresholds;
+}): Promise<ConsensusResult>;
+/** Test seam: reset the once-per-process temperature warning. */
+declare function resetTemperatureWarning(): void;
+
+export { AnthropicProvider, type AnthropicProviderOptions, ClaudeCliProvider, type CompleteJSONRequest, type CompleteJSONResponse, type CompleteValidatedOptions, type ConsensusResult, DEFAULT_MODELS, DEFAULT_OPENAI_BASE_URL, DEFAULT_ZONES, type EnsembleOptions, type ExecFn, type ExecOptions, type ExecResult, InferenceError, type InferenceProvider, type InferenceRun, JsonCache, type JudgeRun, type JudgeVerdict, type Match, MockProvider, type MockResponse, OpenAICompatProvider, type OpenAICompatProviderOptions, PRICE_TABLE, type Pricing, type ProviderName, type ProviderSpec, type TokenUsage, VERDICT_SCHEMA, type Zone, type ZoneThresholds, buildCacheKey, completeValidatedJSON, computeConsensus, costOfRuns, costOfUsage, extractJson, judge, makeProvider, mockVerdict, pricingFor, realExec, resetTemperatureWarning, resolveProviderIdentity, runEnsemble, sha256, stripNulls, toStrictSchema, validatorFor, zoneFor };