@hourslabs/domovoi 0.1.0

package/dist/testing/index.js

@@ -0,0 +1,34 @@
+// src/testing/index.ts
+var DEFAULT_CAPABILITIES = {
+  distributionSource: "logprobs",
+  coverageMeasurement: "exact",
+  // Higher than OpenAI's 20 so users don't trip the chain-min cap unexpectedly
+  // in tests of large decision spaces.
+  maxTopLogprobs: 100
+};
+function mockProvider(options) {
+  const id = options.id ?? "mock/test";
+  const modelId = options.modelId ?? "test";
+  const tokenizerId = options.tokenizerId ?? "mock";
+  const capabilities = options.capabilities ?? DEFAULT_CAPABILITIES;
+  const erased = options.behavior;
+  return {
+    id,
+    modelId,
+    tokenizerId,
+    capabilities,
+    async sample(input, space, opts) {
+      if (opts.signal?.aborted) {
+        const reason = opts.signal.reason;
+        if (reason instanceof Error) throw reason;
+        throw new Error(typeof reason === "string" ? reason : "aborted");
+      }
+      const result = await erased(input, space, opts);
+      return result;
+    }
+  };
+}
+
+export { mockProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/index.ts"],"names":[],"mappings":";AAWA,IAAM,oBAAA,GAA6C;AAAA,EACjD,kBAAA,EAAoB,UAAA;AAAA,EACpB,mBAAA,EAAqB,OAAA;AAAA;AAAA;AAAA,EAGrB,cAAA,EAAgB;AAClB,CAAA;AAoCO,SAAS,aAAwC,OAAA,EAA2C;AACjG,EAAA,MAAM,EAAA,GAAK,QAAQ,EAAA,IAAM,WAAA;AACzB,EAAA,MAAM,OAAA,GAAU,QAAQ,OAAA,IAAW,MAAA;AACnC,EAAA,MAAM,WAAA,GAAc,QAAQ,WAAA,IAAe,MAAA;AAC3C,EAAA,MAAM,YAAA,GAAe,QAAQ,YAAA,IAAgB,oBAAA;AAU7C,EAAA,MAAM,SAAS,OAAA,CAAQ,QAAA;AAEvB,EAAA,OAAO;AAAA,IACL,EAAA;AAAA,IACA,OAAA;AAAA,IACA,WAAA;AAAA,IACA,YAAA;AAAA,IACA,MAAM,MAAA,CACJ,KAAA,EACA,KAAA,EACA,IAAA,EAC0B;AAE1B,MAAA,IAAI,IAAA,CAAK,QAAQ,OAAA,EAAS;AACxB,QAAA,MAAM,MAAA,GAAS,KAAK,MAAA,CAAO,MAAA;AAC3B,QAAA,IAAI,MAAA,YAAkB,OAAO,MAAM,MAAA;AACnC,QAAA,MAAM,IAAI,KAAA,CAAM,OAAO,MAAA,KAAW,QAAA,GAAW,SAAS,SAAS,CAAA;AAAA,MACjE;AACA,MAAA,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,KAAA,EAAO,OAA4B,IAAI,CAAA;AACnE,MAAA,OAAO,MAAA;AAAA,IACT;AAAA,GACF;AACF","file":"index.js","sourcesContent":["/**\n * Public test helpers exposed via `@hourslabs/domovoi/testing` subpath.\n *\n * `mockProvider({ behavior, capabilities?, id? })` builds a Provider for\n * tests without hitting a real LLM. Defaults work out-of-the-box for unit\n * tests of engine logic, threshold semantics, and fallback chains.\n */\n\nimport type { Provider, SampleOptions } from \"../providers/provider.js\";\nimport type { Distribution, ProviderCapabilities } from \"../types.js\";\n\nconst DEFAULT_CAPABILITIES: ProviderCapabilities = {\n  distributionSource: \"logprobs\",\n  coverageMeasurement: \"exact\",\n  // Higher than OpenAI's 20 so users don't trip the chain-min cap unexpectedly\n  // in tests of large decision spaces.\n  maxTopLogprobs: 100,\n};\n\nexport type MockProviderOptions<T extends string = string> = {\n  /**\n   * Function that produces the Distribution for a given input + space + opts.\n   * May be sync or async; engine awaits the result.\n   */\n  readonly behavior: (\n    input: string,\n    space: readonly T[],\n    opts: SampleOptions,\n  ) => Distribution<T> | Promise<Distribution<T>>;\n  /** Override default capabilities (for testing capability-mismatch logic). */\n  readonly capabilities?: ProviderCapabilities;\n  /** Override the provider id; defaults to \"mock/test\". */\n  readonly id?: string;\n  /** Override the model id; defaults to \"test\". */\n  readonly modelId?: string;\n  /** Override the tokenizer id; defaults to \"mock\". */\n  readonly tokenizerId?: string;\n};\n\n/**\n * Construct a mock Provider for testing.\n *\n * @example\n *   const c = domovoi.classifier({\n *     space: [\"a\",\"b\",\"c\"] as const,\n *     thresholds: { high: 0.7, coverageMin: 0.5 },\n *     providers: [\n *       mockProvider({\n *         behavior: () => ({ probs: { a: 0.8, b: 0.1, c: 0.1 }, coverage: 0.95 }),\n *       }),\n *     ],\n *   });\n */\nexport function mockProvider<T extends string = string>(options: MockProviderOptions<T>): Provider {\n  const id = options.id ?? \"mock/test\";\n  const modelId = options.modelId ?? \"test\";\n  const tokenizerId = options.tokenizerId ?? \"mock\";\n  const capabilities = options.capabilities ?? DEFAULT_CAPABILITIES;\n\n  // Cast the behavior to the generic Provider.sample shape. Tests typically\n  // pin `T` via the classifier they pass the mock to, so the type erasure here\n  // is safe in practice.\n  type AnyBehavior = (\n    i: string,\n    s: readonly string[],\n    o: SampleOptions,\n  ) => Distribution<string> | Promise<Distribution<string>>;\n  const erased = options.behavior as unknown as AnyBehavior;\n\n  return {\n    id,\n    modelId,\n    tokenizerId,\n    capabilities,\n    async sample<U extends string>(\n      input: string,\n      space: readonly U[],\n      opts: SampleOptions,\n    ): Promise<Distribution<U>> {\n      // Pre-aborted check: producers should respect cancellation.\n      if (opts.signal?.aborted) {\n        const reason = opts.signal.reason;\n        if (reason instanceof Error) throw reason;\n        throw new Error(typeof reason === \"string\" ? reason : \"aborted\");\n      }\n      const result = await erased(input, space as readonly string[], opts);\n      return result as Distribution<U>;\n    },\n  };\n}\n"]}

package/dist/tokenizer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Tokenizer abstraction (internal — not exported from the public surface).
+ *
+ * Supports first-token-id resolution for decision-space collision detection
+ * and logit_bias construction. Backed by tiktoken (`cl100k_base` for OpenAI
+ * models). Adapters that need different tokenizers can build their own
+ * implementation of the same internal interface.
+ *
+ * Contract:
+ *   - `encode(label)` returns the token ids for the leading whitespace + label
+ *     (matches OpenAI's tokenization of an emitted output token).
+ *   - `firstTokenId(label)` returns the first token id of the encoded label.
+ *
+ * Note: OpenAI's tokenizer often prepends a leading space to emitted tokens
+ * (`" yes"` vs `"yes"`). We detect first-token id with the leading-space
+ * variant since that's what the model emits at the first content position.
+ */
+type TokenizerId = "openai/cl100k_base";
+export interface Tokenizer {
+    readonly id: TokenizerId;
+    /** Token ids for `label` as it would appear at a generation boundary. */
+    encode(label: string): number[];
+    /** First token id of `label` at a generation boundary. */
+    firstTokenId(label: string): number;
+}
+/**
+ * cl100k_base tokenizer, used by GPT-4o family + most OpenAI Chat models.
+ * Lazy-initialized; the underlying tiktoken native module is heavy.
+ */
+export declare function cl100kTokenizer(): Tokenizer;
+/**
+ * Detect first-token-id collisions across a decision space. Returns the
+ * conflicting label pair if any two labels resolve to the same first token,
+ * or `undefined` if the space is collision-free.
+ *
+ * Used by the OpenAI adapter (and other tokenizer-aware adapters) at
+ * construction time to throw `ConfigError({ code: "decision_space_collision" })`
+ * before any network I/O.
+ *
+ * Imperative form (rather than `reduce`) chosen for readability: the early
+ * return on first collision short-circuits naturally without the bookkeeping
+ * that a `reduce` accumulator would require.
+ */
+export declare function findFirstTokenCollision(tokenizer: Tokenizer, space: readonly string[]): {
+    a: string;
+    b: string;
+    tokenId: number;
+} | undefined;
+/**
+ * Build a logit_bias map for OpenAI Chat Completions: positive bias on each
+ * in-space first-token id. Negative biases are deliberately avoided so the
+ * coverage signal stays honest — positive bias nudges, doesn't force.
+ */
+export declare function buildLogitBias(tokenizer: Tokenizer, space: readonly string[], bias?: number): Record<string, number>;
+export {};
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../src/tokenizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAExC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,yEAAyE;IACzE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAChC,0DAA0D;IAC1D,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACrC;AAID;;;GAGG;AACH,wBAAgB,eAAe,IAAI,SAAS,CAuB3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAWvD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,SAAM,GACT,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIxB"}

package/dist/types.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Core types for domovoi: typed-uncertainty classification.
+ */
+/**
+ * Capabilities a Provider declares about its sampling behavior. The engine
+ * uses these to decide how to interpret the returned `Distribution` and
+ * which providers in a chain produce comparable Verdict metadata.
+ */
+export type ProviderCapabilities = {
+    readonly distributionSource: "logprobs" | "multi_sample";
+    readonly coverageMeasurement: "exact" | "approximate" | "none";
+    /** Max top-K logprobs returned by the provider; 0 for `multi_sample`. */
+    readonly maxTopLogprobs: number;
+};
+/**
+ * The label-type domain a Verdict can range over: string for multi-class
+ * spaces, boolean for the binary `domovoi.boolean()` verb.
+ */
+export type Label = string | boolean;
+/**
+ * Probability distribution over the labels of a decision space, plus a
+ * coverage signal that measures how much probability mass the model put
+ * on labels outside the space.
+ */
+export type Distribution<T extends Label> = {
+    /**
+     * Probability per label, renormalized to sum to 1 over the space. Labels
+     * the model didn't express any opinion on are present with value 0.
+     */
+    readonly probs: [T] extends [string] ? {
+        readonly [K in T]: number;
+    } : {
+        readonly [K in `${T & boolean}`]: number;
+    };
+    /**
+     * Pre-renormalization mass on in-space labels, ∈ [0, 1]. Low coverage
+     * means the model wanted to answer with something outside the space.
+     */
+    readonly coverage: number;
+};
+/**
+ * Plain-object error shape. `Verdict.meta.providerErrors[i].error` carries
+ * this so `JSON.stringify(verdict)` round-trips cleanly. Live `Error`
+ * instances are still passed to the `onProviderError` hook for callers
+ * that need `instanceof` semantics.
+ */
+export type SerializableError = {
+    readonly name: string;
+    readonly message: string;
+    readonly code?: string;
+    readonly cause?: SerializableError;
+    readonly stack?: string;
+};
+/**
+ * Per-Verdict metadata recorded by the engine. Present on every variant —
+ * gives observability into which provider answered, how long it took, and
+ * what failed along the way without separate instrumentation.
+ */
+export type VerdictMeta = {
+    /** Provider that produced this Verdict, in `factory/model` form. */
+    readonly providerUsed: string;
+    /** Every provider attempted, in chain order. */
+    readonly providersAttempted: readonly string[];
+    /** Errors swallowed during fallback. Empty when no errors occurred. */
+    readonly providerErrors: ReadonlyArray<{
+        readonly providerId: string;
+        readonly error: SerializableError;
+    }>;
+    /** Wall-clock latency from engine entry to this Verdict. */
+    readonly latencyMs: number;
+    /** True when this Verdict was served from cache. */
+    readonly cacheHit: boolean;
+    /** OOD-signal quality from the answering provider. */
+    readonly coverageQuality: "exact" | "approximate" | "none";
+    /** How the answering provider constructed its Distribution. */
+    readonly distributionSource: "logprobs" | "multi_sample";
+};
+/**
+ * Why a Verdict came back as `Unknown`. Each variant carries the data
+ * relevant to its mode — surface it for routing, alerting, or retry logic.
+ */
+export type UnknownVerdictCause<T extends Label> = {
+    readonly type: "out_of_distribution";
+    readonly coverage: number;
+    readonly topIfRenormalized: T;
+    readonly probabilityIfRenormalized: number;
+} | {
+    readonly type: "chain_exhausted";
+    readonly lastDistribution: Distribution<T>;
+    readonly providersAttempted: number;
+} | {
+    readonly type: "predicate_rejected";
+    readonly previousKind: "classified" | "uncertain";
+} | {
+    readonly type: "provider_failure";
+    readonly errors: readonly SerializableError[];
+} | {
+    readonly type: "budget_exhausted";
+    readonly scope: "per_call_timeout" | "chain_timeout" | "max_calls";
+} | {
+    readonly type: "cancelled";
+    readonly reason?: string;
+};
+/**
+ * Confident result. `value` cleared the `high` threshold (and the margin
+ * requirement, if any) over the decision space.
+ */
+export type Classified<T extends Label> = {
+    readonly kind: "classified";
+    readonly value: T;
+    /** Calibrated probability of `value`, ∈ [0, 1]. */
+    readonly probability: number;
+    readonly meta: VerdictMeta;
+};
+/**
+ * Top candidate found, but below the `high` threshold (or the margin
+ * requirement was not met). Carries `runnerUp` so callers can fall back,
+ * confirm with the user, or escalate to a stronger model with both
+ * candidates in scope.
+ */
+export type Uncertain<T extends Label> = {
+    readonly kind: "uncertain";
+    readonly top: T;
+    /** Calibrated probability of `top`, ∈ [0, 1]. */
+    readonly probability: number;
+    readonly runnerUp: T;
+    readonly distribution: Distribution<T>;
+    readonly meta: VerdictMeta;
+};
+/** No usable classification. `reason.type` discriminates the cause. */
+export type Unknown<T extends Label> = {
+    readonly kind: "unknown";
+    readonly reason: UnknownVerdictCause<T>;
+    readonly meta: VerdictMeta;
+};
+/**
+ * The discriminated union returned by every classifier call. Narrow with
+ * `kind`, the type guards (`isClassified` / `isUncertain` / `isUnknown`),
+ * or `match` for exhaustive handling.
+ */
+export type Verdict<T extends Label> = Classified<T> | Uncertain<T> | Unknown<T>;
+/** Verdict variants that carry a top-class candidate. */
+export type Filterable<T extends Label> = Classified<T> | Uncertain<T>;
+/**
+ * Threshold rules, discriminated by space length. Binary spaces use a
+ * deadband (`high` / `low`); multi-class spaces use a top-confidence rule
+ * with optional margin. Values must lie in `[0, 1]` and binary `high` must
+ * exceed `low` strictly.
+ */
+export type Thresholds<Space extends readonly string[]> = Space["length"] extends 2 ? {
+    readonly high: number;
+    readonly low: number;
+    readonly coverageMin?: number;
+} : {
+    readonly high: number;
+    readonly margin?: number;
+    readonly coverageMin?: number;
+};
+/** Caps on time and provider calls. Defaults applied if a field is omitted. */
+export type Budget = {
+    /** Per-provider-call wall-clock timeout. Default 10_000ms. */
+    readonly perCallTimeoutMs?: number;
+    /** Across-the-chain wall-clock budget. Default 30_000ms. */
+    readonly chainTimeoutMs?: number;
+    /** Hard cap on provider calls per classification. Default = chain length. */
+    readonly maxCalls?: number;
+};
+/**
+ * Prompt template applied to every classification call. Override only when
+ * the default doesn't fit; supply your own `templateHash` so cache keys
+ * stay correct.
+ */
+export type PromptTemplate = {
+    readonly systemPrompt?: string;
+    /** Renders the user message. `{labels_csv}` is filled in user-given order. */
+    readonly userTemplate: (input: string, space: readonly string[], question?: string) => string;
+    /** Stable hash for cache-key composition. */
+    readonly templateHash: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/validate.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Construction-time validators throw `ConfigError`; the runtime
+ * `validateDistribution` (called by the engine after `Provider.sample` returns)
+ * throws `ProviderError`.
+ */
+import type { Distribution, ProviderCapabilities, Thresholds } from "./types.js";
+/**
+ * Throws if the decision space contains: empty labels (post-NFC + trim),
+ * duplicates (post-NFC), whitespace-padded labels, or fewer than 2 entries.
+ *
+ * The empty-array case is also rejected at the type level via the
+ * `readonly [T, ...T[]]` shape on classifier configs.
+ */
+export declare function validateSpace(space: readonly string[]): void;
+/**
+ * Validate threshold values at construction. Inclusive [0, 1] range; binary
+ * requires `high > low` strict; `margin >= 0` if present.
+ */
+export declare function validateThresholds<S extends readonly string[]>(thresholds: Thresholds<S>, spaceLength: number): void;
+export declare function validateClassifierName(name: string): void;
+/**
+ * Validates the provider chain. Throws if the array is empty, or if the
+ * decision space exceeds the smallest `maxTopLogprobs` across all
+ * `distributionSource: "logprobs"` providers in the chain (multi-sample
+ * providers have no top-K constraint and are exempt).
+ */
+export declare function validateProviderChain(providers: ReadonlyArray<{
+    readonly id: string;
+    readonly capabilities: ProviderCapabilities;
+}>, spaceLength: number): void;
+/**
+ * Validate calibrator vs provider chain capabilities at construction.
+ * Multi-sample providers reject non-identity calibrators.
+ */
+export declare function validateCalibratorCompatibility(calibratorIsIdentity: boolean, providers: ReadonlyArray<{
+    readonly id: string;
+    readonly capabilities: ProviderCapabilities;
+}>): void;
+/**
+ * Engine-side check on every Distribution returned by `Provider.sample`,
+ * before calibration. Verifies coverage and per-prob range, fills missing
+ * in-space labels with `0` (mutates `probs`), and asserts sum-to-one within
+ * a fixed tolerance. Throws `ProviderError` on violation — surfaces buggy
+ * custom Provider implementations.
+ */
+export declare function validateDistribution<T extends string>(d: Distribution<T>, space: readonly T[]): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CA4B5D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EAC5D,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,WAAW,EAAE,MAAM,GAClB,IAAI,CAiCN;AAYD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAOzD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAA;CAAE,CAAC,EAC9F,WAAW,EAAE,MAAM,GAClB,IAAI,CAwBN;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,oBAAoB,EAAE,OAAO,EAC7B,SAAS,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAA;CAAE,CAAC,GAC7F,IAAI,CASN;AAID;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACnD,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAClB,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,IAAI,CAmCN"}

package/dist/verbs/boolean.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Binary one-shot classifier — returns `Verdict<boolean>`.
+ *
+ * The engine internally classifies over the string space `["yes", "no"]` to
+ * match LLM first-token tokenization cleanly; a small transform at the verb
+ * boundary maps the result to `boolean` so the public surface is idiomatic.
+ *
+ * Default deadband `{ high: 0.7, low: 0.3, coverageMin: 0.3 }` is
+ * illustrative — tune for your workload.
+ */
+import { type Cache } from "../cache.js";
+import { type Calibrator } from "../calibration/index.js";
+import type { Provider } from "../providers/provider.js";
+import type { Budget, Thresholds, Verdict } from "../types.js";
+declare const YES_NO_SPACE: readonly ["yes", "no"];
+export type BooleanOptions = {
+    readonly providers?: readonly Provider[];
+    readonly calibrator?: Calibrator;
+    readonly cache?: Cache;
+    readonly budget?: Budget;
+    readonly thresholds?: Thresholds<typeof YES_NO_SPACE>;
+    readonly signal?: AbortSignal;
+};
+export declare function boolean(input: string, question: string, opts?: BooleanOptions): Promise<Verdict<boolean>>;
+export {};
+//# sourceMappingURL=boolean.d.ts.map

package/dist/verbs/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/verbs/boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,yBAAyB,CAAC;AAIpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAgB,UAAU,EAAuB,OAAO,EAAE,MAAM,aAAa,CAAC;AAMlG,QAAA,MAAM,YAAY,wBAA2D,CAAC;AAE9E,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,wBAAsB,OAAO,CAC3B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CA+B3B"}

package/dist/verbs/classifier.d.ts

@@ -0,0 +1,63 @@
+/**
+ * domovoi.classifier({...}) — reusable configured classifier factory.
+ *
+ * Returns a `Classifier<T, I>`: a callable that takes an input, returns
+ * `Promise<Verdict<T>>`. Also exposes `.batch(items, opts?)` and `.classify`
+ * alias for discoverability.
+ *
+ * Validates configuration at construction time (validate.ts) and resolves
+ * env-driven providers if `providers` is omitted (env.ts).
+ *
+ * Note: full callable+method shape requires assigning methods to a function
+ * object. We use `Object.assign` to achieve this with type safety.
+ */
+import { type Cache } from "../cache.js";
+import { type Calibrator } from "../calibration/index.js";
+import type { Provider } from "../providers/provider.js";
+import type { Budget, PromptTemplate, Thresholds, Verdict } from "../types.js";
+/**
+ * Configuration accepted by `domovoi.classifier({...})`.
+ *
+ * `format` is required when `I` is not assignable to `string`. When `I = string`
+ * (default), `format` is optional and defaults to identity.
+ */
+export type ClassifierConfig<T extends string, I> = {
+    /** /^[a-z][a-z0-9_]*$/; uppercased for env-binding lookup. */
+    readonly name?: string;
+    readonly space: readonly [T, ...T[]];
+    readonly question?: string;
+    readonly format?: (x: I) => string;
+    readonly thresholds: Thresholds<readonly [T, ...T[]]>;
+    readonly providers?: readonly Provider[];
+    readonly calibrator?: Calibrator;
+    readonly cache?: Cache;
+    readonly budget?: Budget;
+    readonly template?: PromptTemplate;
+    readonly hooks?: {
+        onCall?: (...args: unknown[]) => void | Promise<void>;
+        onResult?: (...args: unknown[]) => void | Promise<void>;
+    };
+    readonly onProviderError?: (err: Error, ctx: {
+        providerId: string;
+        attempt: number;
+    }) => void | Promise<void>;
+    readonly onErrorPolicy?: "fallback" | "throw";
+};
+/**
+ * The configured runtime instance. Callable with an input; returns
+ * `Promise<Verdict<T>>`.
+ *
+ * Methods:
+ *   - `.batch(items, opts?)`: per-item Verdicts in input order.
+ */
+export interface Classifier<T extends string, I> {
+    (input: I, opts?: {
+        signal?: AbortSignal;
+    }): Promise<Verdict<T>>;
+    batch(items: readonly I[], opts?: {
+        concurrency?: number;
+        signal?: AbortSignal;
+    }): Promise<Verdict<T>[]>;
+}
+export declare function classifier<const T extends string, I = string>(config: ClassifierConfig<T, I>): Classifier<T, I>;
+//# sourceMappingURL=classifier.d.ts.map

package/dist/verbs/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../src/verbs/classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,yBAAyB,CAAC;AAIpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI;IAClD,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACtD,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACzD,CAAC;IACF,QAAQ,CAAC,eAAe,CAAC,EAAE,CACzB,GAAG,EAAE,KAAK,EACV,GAAG,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KACzC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;CAC/C,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC;IAC7C,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,KAAK,CACH,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACpD,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;CAC1B;AAID,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,GAAG,MAAM,EAC3D,MAAM,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7B,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CA8ElB"}

package/dist/verbs/classify.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Multi-class one-shot classifier — returns `Verdict<T>` where `T` is the
+ * literal union of labels in `space`.
+ *
+ * Reads providers from `DOMOVOI_PROVIDERS` env unless the caller supplies
+ * `{ providers }`. Default thresholds `{ high: 0.5, coverageMin: 0.3 }` are
+ * illustrative — production code should construct `classifier({ ... })`
+ * with thresholds tuned to the workload.
+ */
+import { type Cache } from "../cache.js";
+import { type Calibrator } from "../calibration/index.js";
+import type { Provider } from "../providers/provider.js";
+import type { Budget, Thresholds, Verdict } from "../types.js";
+export type ClassifyOptions<T extends string> = {
+    readonly question?: string;
+    readonly providers?: readonly Provider[];
+    readonly calibrator?: Calibrator;
+    readonly cache?: Cache;
+    readonly budget?: Budget;
+    readonly thresholds?: Thresholds<readonly [T, ...T[]]>;
+    readonly signal?: AbortSignal;
+};
+export declare function classify<const T extends string>(input: string, space: readonly [T, ...T[]], opts?: ClassifyOptions<T>): Promise<Verdict<T>>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/verbs/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/verbs/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,yBAAyB,CAAC;AAIpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI/D,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,IAAI;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,wBAAsB,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EACnD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,EAC3B,IAAI,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAgCrB"}

package/dist/verdict.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Verdict combinators and type guards. The library ships only `match`,
+ * `filter`, and the three type guards; richer combinators (tap, getOrElse,
+ * etc.) compose cleanly in userspace.
+ */
+import type { Classified, Filterable, Label, Uncertain, Unknown, Verdict } from "./types.js";
+export declare function isClassified<T extends Label>(v: Verdict<T>): v is Classified<T>;
+export declare function isUncertain<T extends Label>(v: Verdict<T>): v is Uncertain<T>;
+export declare function isUnknown<T extends Label>(v: Verdict<T>): v is Unknown<T>;
+/**
+ * Pattern-match against a Verdict. All three branches are required;
+ * omitting one is a compile-time error.
+ *
+ * @example
+ * const result = match(verdict, {
+ *   classified: ({ value }) => save(value),
+ *   uncertain:  ({ top, runnerUp }) => queue.review(top, runnerUp),
+ *   unknown:    ({ reason }) => routeUnknown(reason),
+ * });
+ */
+export declare function match<T extends Label, R>(v: Verdict<T>, handlers: {
+    classified: (v: Classified<T>) => R;
+    uncertain: (v: Uncertain<T>) => R;
+    unknown: (v: Unknown<T>) => R;
+}): R;
+/**
+ * Domain-validity filter. The predicate sees `Filterable<T>` — Classified or
+ * Uncertain only. When it returns `false`, the Verdict becomes
+ * `Unknown { predicate_rejected }`. Unknown inputs pass through unchanged.
+ *
+ * @example
+ * const safe = filter<MyLabels>((v) => {
+ *   const pick = v.kind === "classified" ? v.value : v.top;
+ *   return !DEPRECATED.has(pick);
+ * })(verdict);
+ */
+export declare function filter<T extends Label>(pred: (v: Filterable<T>) => boolean): (v: Verdict<T>) => Verdict<T>;
+//# sourceMappingURL=verdict.d.ts.map

package/dist/verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../src/verdict.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE7F,wBAAgB,YAAY,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAE/E;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAE7E;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAEzE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,EACtC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,QAAQ,EAAE;IACR,UAAU,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACpC,SAAS,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAC/B,GACA,CAAC,CASH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO,IACjE,GAAG,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,CASnC"}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@hourslabs/domovoi",
+  "version": "0.1.0",
+  "description": "Typed-uncertainty classification for TypeScript. Bind a domovoi to your code; receive Verdicts with calibrated probability and structured failure modes.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./providers": {
+      "types": "./dist/providers/index.d.ts",
+      "import": "./dist/providers/index.js"
+    },
+    "./calibration": {
+      "types": "./dist/calibration/index.d.ts",
+      "import": "./dist/calibration/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly --declaration --declarationMap",
+    "check": "biome check .",
+    "check:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "typecheck:examples": "tsc --noEmit -p tsconfig.examples.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:types": "vitest run --typecheck",
+    "test:coverage": "vitest run --coverage",
+    "knip": "knip",
+    "publint": "publint",
+    "attw": "attw --pack --profile esm-only",
+    "validate:pack": "npm run build && npm run publint && npm run attw",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "npm run validate:pack && changeset publish",
+    "prepublishOnly": "npm run check && npm run typecheck && npm test && npm run validate:pack"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "classification",
+    "classifier",
+    "llm",
+    "typed",
+    "uncertainty",
+    "calibrated",
+    "openai",
+    "ollama",
+    "anthropic",
+    "vllm",
+    "embeddings",
+    "logprobs",
+    "discriminated-union"
+  ],
+  "author": "Alex Roh",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexbroh/domovoi.git"
+  },
+  "homepage": "https://github.com/alexbroh/domovoi#readme",
+  "bugs": {
+    "url": "https://github.com/alexbroh/domovoi/issues"
+  },
+  "dependencies": {
+    "openai": "^6.35.0",
+    "tiktoken": "^1.0.22"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@biomejs/biome": "^2.4.13",
+    "@changesets/cli": "^2.31.0",
+    "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^4.1.5",
+    "knip": "^6.9.0",
+    "publint": "^0.3.18",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}