@hourslabs/domovoi 0.1.0

package/dist/index.js

@@ -0,0 +1,1263 @@
+import { createHash } from 'crypto';
+import OpenAI from 'openai';
+import { get_encoding } from 'tiktoken';
+
+// src/hash.ts
+function sha256(s) {
+  return createHash("sha256").update(s).digest("hex");
+}
+function canonicalJSON(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (value === null) return null;
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => [key, canonicalize(record[key])])
+  );
+}
+function normalizeInput(input) {
+  return input.normalize("NFC").trim();
+}
+
+// src/cache.ts
+var CACHE_SCHEMA_VERSION = 1;
+function computeCacheKey(inputs) {
+  return sha256(
+    canonicalJSON({
+      cache_schema_version: CACHE_SCHEMA_VERSION,
+      provider_id: inputs.providerId,
+      model_id: inputs.modelId,
+      tokenizer_id: inputs.tokenizerId,
+      template_hash: inputs.templateHash,
+      decision_space: inputs.decisionSpace,
+      temperature: inputs.temperature,
+      provider_config_hash: inputs.providerConfigHash,
+      input_hash: sha256(normalizeInput(inputs.formattedInput))
+    })
+  );
+}
+function serializeCachedValue(d) {
+  const value = {
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    distribution: d,
+    storedAt: Date.now()
+  };
+  return JSON.stringify(value);
+}
+function deserializeCachedValue(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION) return void 0;
+    return parsed.distribution;
+  } catch {
+    return void 0;
+  }
+}
+function memoryCache(options) {
+  const maxEntries = options?.maxEntries ?? 1e4;
+  const defaultTtlMs = options?.defaultTtlMs;
+  const store = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+  function isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+  }
+  return {
+    async get(key) {
+      const entry = store.get(key);
+      if (entry === void 0) {
+        misses++;
+        return void 0;
+      }
+      if (isExpired(entry)) {
+        store.delete(key);
+        misses++;
+        return void 0;
+      }
+      store.delete(key);
+      store.set(key, entry);
+      hits++;
+      return entry.value;
+    },
+    async set(key, value, ttlMs) {
+      const ttl = ttlMs ?? defaultTtlMs;
+      const expiresAt = ttl !== void 0 ? Date.now() + ttl : void 0;
+      if (store.has(key)) store.delete(key);
+      store.set(key, { value, expiresAt });
+      while (store.size > maxEntries) {
+        const oldest = store.keys().next().value;
+        if (oldest === void 0) break;
+        store.delete(oldest);
+        evictions++;
+      }
+    },
+    async delete(key) {
+      store.delete(key);
+    },
+    stats() {
+      return {
+        size: store.size,
+        hits,
+        misses,
+        evictions
+      };
+    }
+  };
+}
+var InFlight = class {
+  map = /* @__PURE__ */ new Map();
+  async run(key, factory) {
+    const existing = this.map.get(key);
+    if (existing !== void 0) return existing;
+    const promise = factory().finally(() => {
+      this.map.delete(key);
+    });
+    this.map.set(key, promise);
+    return promise;
+  }
+  /** Drop the in-flight slot for `key`, allowing the next caller to retry. */
+  forget(key) {
+    this.map.delete(key);
+  }
+};
+
+// src/errors.ts
+var DomovoiError = class extends Error {
+  code;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "DomovoiError";
+    this.code = options?.code ?? "unspecified";
+  }
+};
+var ProviderError = class extends DomovoiError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderError";
+  }
+};
+var ConfigError = class extends DomovoiError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigError";
+  }
+};
+var BudgetExhaustedError = class extends DomovoiError {
+  attemptedProviders;
+  elapsedMs;
+  scope;
+  constructor(message, options) {
+    super(message, { code: options.scope, cause: options.cause });
+    this.name = "BudgetExhaustedError";
+    this.scope = options.scope;
+    this.attemptedProviders = options.attemptedProviders;
+    this.elapsedMs = options.elapsedMs;
+  }
+};
+function canonicalizeProviderThrow(thrown) {
+  if (thrown instanceof DomovoiError) return thrown;
+  if (thrown instanceof Error) {
+    return new ProviderError(thrown.message || "Provider call failed", {
+      code: "provider_network",
+      cause: thrown
+    });
+  }
+  return new ProviderError(String(thrown), {
+    code: "provider_network",
+    cause: thrown
+  });
+}
+function serializeError(err) {
+  if (!(err instanceof Error)) {
+    return { name: "Error", message: String(err) };
+  }
+  const code = err instanceof DomovoiError ? err.code : void 0;
+  const cause = err.cause !== void 0 ? serializeError(err.cause) : void 0;
+  return {
+    name: err.name,
+    message: err.message,
+    ...code !== void 0 ? { code } : {},
+    ...cause !== void 0 ? { cause } : {},
+    ...err.stack !== void 0 ? { stack: err.stack } : {}
+  };
+}
+
+// src/calibration/index.ts
+var identity = {
+  kind: "identity",
+  apply(d) {
+    return d;
+  }
+};
+function isIdentityCalibrator(c) {
+  return c.kind === "identity";
+}
+
+// src/prompt.ts
+var DEFAULT_TEMPLATE_HASH = "domovoi/v0-default";
+var defaultTemplate = {
+  systemPrompt: "You are a careful classifier. Output exactly one of: {labels_csv}. No other text.",
+  userTemplate: (input, _space, question) => question === void 0 ? input : `${question}
+${input}`,
+  templateHash: DEFAULT_TEMPLATE_HASH
+};
+function renderSystemPrompt(template, space) {
+  if (template.systemPrompt === void 0) return void 0;
+  return template.systemPrompt.replace("{labels_csv}", space.join(", "));
+}
+function renderUserPrompt(template, input, space, question) {
+  return template.userTemplate(input, space, question);
+}
+
+// src/validate.ts
+function validateSpace(space) {
+  if (space.length < 2) {
+    throw new ConfigError(`Decision space must have at least 2 labels; got ${space.length}.`, {
+      code: "invalid_space"
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < space.length; i++) {
+    const label = space[i];
+    if (label !== label.trim()) {
+      throw new ConfigError(
+        `Decision space label at index ${i} has leading/trailing whitespace: ${JSON.stringify(label)}.`,
+        { code: "invalid_space" }
+      );
+    }
+    const normalized = label.normalize("NFC");
+    if (!normalized) {
+      throw new ConfigError(`Decision space label at index ${i} is empty.`, {
+        code: "invalid_space"
+      });
+    }
+    if (seen.has(normalized)) {
+      throw new ConfigError(`Decision space contains duplicate label: ${JSON.stringify(label)}.`, {
+        code: "invalid_space"
+      });
+    }
+    seen.add(normalized);
+  }
+}
+function validateThresholds(thresholds, spaceLength) {
+  const t = thresholds;
+  inRange01("high", t.high);
+  if (t.coverageMin !== void 0) inRange01("coverageMin", t.coverageMin);
+  if (spaceLength === 2) {
+    if (t.low === void 0) {
+      throw new ConfigError("Binary classifier requires `thresholds.low`.", {
+        code: "invalid_thresholds"
+      });
+    }
+    inRange01("low", t.low);
+    if (!(t.high > t.low)) {
+      throw new ConfigError(
+        `Binary deadband requires high > low strict; got high=${t.high}, low=${t.low}.`,
+        { code: "invalid_thresholds" }
+      );
+    }
+  } else {
+    if (t.margin !== void 0) {
+      if (t.margin < 0 || t.margin > 1 || Number.isNaN(t.margin)) {
+        throw new ConfigError(`thresholds.margin must be in [0, 1]; got ${t.margin}.`, {
+          code: "invalid_thresholds"
+        });
+      }
+    }
+  }
+}
+function inRange01(name, value) {
+  if (Number.isNaN(value) || value < 0 || value > 1) {
+    throw new ConfigError(`thresholds.${name} must be in [0, 1] inclusive; got ${value}.`, {
+      code: "invalid_thresholds"
+    });
+  }
+}
+var CLASSIFIER_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
+function validateClassifierName(name) {
+  if (!CLASSIFIER_NAME_REGEX.test(name)) {
+    throw new ConfigError(
+      `Classifier name must match /^[a-z][a-z0-9_]*$/; got ${JSON.stringify(name)}.`,
+      { code: "invalid_classifier_name" }
+    );
+  }
+}
+function validateProviderChain(providers, spaceLength) {
+  if (providers.length === 0) {
+    throw new ConfigError("Provider chain is empty; supply at least one provider.", {
+      code: "empty_providers"
+    });
+  }
+  const logprobsCaps = providers.filter((p) => p.capabilities.distributionSource === "logprobs").map((p) => ({ id: p.id, cap: p.capabilities.maxTopLogprobs }));
+  if (logprobsCaps.length === 0) return;
+  const min = logprobsCaps.reduce(
+    (acc, p) => p.cap < acc.cap ? p : acc,
+    logprobsCaps[0]
+  );
+  if (spaceLength > min.cap) {
+    throw new ConfigError(
+      `Decision space size (${spaceLength}) exceeds provider ${min.id}'s top-K cap (${min.cap}). Reduce space size or replace the provider.`,
+      { code: "decision_space_too_large" }
+    );
+  }
+}
+function validateCalibratorCompatibility(calibratorIsIdentity, providers) {
+  if (calibratorIsIdentity) return;
+  const multiSample = providers.find((p) => p.capabilities.distributionSource === "multi_sample");
+  if (multiSample) {
+    throw new ConfigError(
+      `Provider ${multiSample.id} uses distributionSource: "multi_sample"; non-identity calibrators are not supported on multi-sample providers in v0. Use 'identity' calibrator or remove the multi-sample provider from the chain.`,
+      { code: "incompatible_calibrator" }
+    );
+  }
+}
+var SUM_TOLERANCE = 1e-3;
+function validateDistribution(d, space) {
+  if (Number.isNaN(d.coverage) || d.coverage < 0 || d.coverage > 1) {
+    throw new ProviderError(`Invalid Distribution.coverage: ${d.coverage} (must be in [0, 1]).`, {
+      code: "invalid_distribution"
+    });
+  }
+  const probs = d.probs;
+  for (const [label, prob] of Object.entries(probs)) {
+    if (prob === void 0) continue;
+    if (Number.isNaN(prob) || prob < 0 || prob > 1) {
+      throw new ProviderError(
+        `Invalid probability for label ${JSON.stringify(label)}: ${prob} (must be in [0, 1]).`,
+        { code: "invalid_distribution" }
+      );
+    }
+  }
+  for (const label of space) {
+    if (!(label in probs)) {
+      probs[label] = 0;
+    }
+  }
+  let sum = 0;
+  for (const label of space) {
+    sum += probs[label] ?? 0;
+  }
+  if (Math.abs(sum - 1) > SUM_TOLERANCE) {
+    throw new ProviderError(
+      `Distribution probs sum to ${sum.toFixed(6)}; expected 1 \xB1 ${SUM_TOLERANCE}.`,
+      { code: "invalid_distribution" }
+    );
+  }
+}
+
+// src/engine/config.ts
+var DEFAULT_PER_CALL_TIMEOUT_MS = 1e4;
+var DEFAULT_CHAIN_TIMEOUT_MS = 3e4;
+function withDefaults(input) {
+  return {
+    space: input.space,
+    thresholds: input.thresholds,
+    providers: input.providers,
+    calibrator: input.calibrator ?? identity,
+    cache: input.cache ?? memoryCache(),
+    template: input.template ?? defaultTemplate,
+    ...input.question !== void 0 ? { question: input.question } : {},
+    ...input.budget !== void 0 ? { budget: input.budget } : {},
+    onErrorPolicy: input.onErrorPolicy ?? "fallback",
+    ...input.onProviderError !== void 0 ? { onProviderError: input.onProviderError } : {},
+    ...input.hooks !== void 0 ? { hooks: input.hooks } : {},
+    providerConfigHash: input.providerConfigHash ?? "",
+    temperature: 0
+  };
+}
+function validateClassifierConfig(input) {
+  if (input.name !== void 0) validateClassifierName(input.name);
+  validateSpace(input.space);
+  validateProviderChain(input.providers, input.space.length);
+  validateThresholds(input.thresholds, input.space.length);
+  validateCalibratorCompatibility(isIdentityCalibrator(input.calibrator), input.providers);
+  for (const provider of input.providers) {
+    provider.validate?.(input.space);
+  }
+}
+
+// src/engine/meta.ts
+function makeMetaBuilder() {
+  return {
+    providersAttempted: [],
+    providerErrors: [],
+    startedAtMs: Date.now(),
+    cacheHit: false
+  };
+}
+function buildMeta(builder, provider) {
+  return {
+    providerUsed: provider.id,
+    providersAttempted: [...builder.providersAttempted],
+    providerErrors: [...builder.providerErrors],
+    latencyMs: Date.now() - builder.startedAtMs,
+    cacheHit: builder.cacheHit,
+    coverageQuality: provider.capabilities.coverageMeasurement,
+    distributionSource: provider.capabilities.distributionSource
+  };
+}
+function buildMetaForFailure(builder, fallbackProvider) {
+  const providerUsed = fallbackProvider?.id ?? builder.providersAttempted.at(-1) ?? "";
+  return {
+    providerUsed,
+    providersAttempted: [...builder.providersAttempted],
+    providerErrors: [...builder.providerErrors],
+    latencyMs: Date.now() - builder.startedAtMs,
+    cacheHit: builder.cacheHit,
+    coverageQuality: fallbackProvider?.capabilities.coverageMeasurement ?? "none",
+    distributionSource: fallbackProvider?.capabilities.distributionSource ?? "logprobs"
+  };
+}
+
+// src/engine/abort.ts
+function abortReason(signal) {
+  if (signal === void 0 || !signal.aborted) return void 0;
+  const reason = signal.reason;
+  if (typeof reason === "string") return reason;
+  if (reason instanceof Error) return reason.message;
+  if (reason !== void 0) return String(reason);
+  return "aborted";
+}
+function isTimeoutAbort(signal) {
+  const reason = signal.reason;
+  return reason instanceof Error && reason.name === "TimeoutError";
+}
+function buildCancelledVerdict(meta, reason, provider) {
+  return {
+    kind: "unknown",
+    reason: { type: "cancelled", reason },
+    meta: buildMetaForFailure(meta, provider)
+  };
+}
+function buildBudgetExhaustedVerdict(meta, scope, policy, provider) {
+  if (policy === "throw") return void 0;
+  return {
+    kind: "unknown",
+    reason: { type: "budget_exhausted", scope },
+    meta: buildMetaForFailure(meta, provider)
+  };
+}
+function deserializeForAggregate(serialized) {
+  const err = new Error(serialized.message);
+  err.name = serialized.name;
+  if (serialized.stack !== void 0) err.stack = serialized.stack;
+  if (serialized.cause !== void 0) {
+    Object.defineProperty(err, "cause", {
+      value: deserializeForAggregate(serialized.cause),
+      enumerable: false,
+      writable: true
+    });
+  }
+  return err;
+}
+
+// src/engine/distribution.ts
+var globalInFlight = new InFlight();
+function computeProviderCacheKey(provider, formattedInput, config) {
+  return computeCacheKey({
+    providerId: provider.id,
+    modelId: provider.modelId,
+    tokenizerId: provider.tokenizerId,
+    templateHash: config.template.templateHash,
+    decisionSpace: config.space,
+    temperature: config.temperature,
+    providerConfigHash: config.providerConfigHash,
+    formattedInput
+  });
+}
+function mergeSignals(userSignal, timeoutSignal) {
+  const signals = [timeoutSignal];
+  if (userSignal !== void 0) signals.push(userSignal);
+  return AbortSignal.any(signals);
+}
+async function loadDistribution(provider, formattedInput, config, meta, signal, cacheKey) {
+  const cached = await config.cache.get(cacheKey);
+  if (cached !== void 0) {
+    const parsed = deserializeCachedValue(cached);
+    if (parsed !== void 0) {
+      meta.cacheHit = true;
+      return parsed;
+    }
+  }
+  const fresh = await fetchFresh(provider, formattedInput, config, signal, cacheKey);
+  await config.cache.set(cacheKey, serializeCachedValue(fresh));
+  return fresh;
+}
+async function fetchFresh(provider, formattedInput, config, signal, cacheKey) {
+  return globalInFlight.run(
+    cacheKey,
+    () => provider.sample(formattedInput, config.space, {
+      template: config.template,
+      temperature: config.temperature,
+      timeoutMs: config.budget?.perCallTimeoutMs ?? DEFAULT_PER_CALL_TIMEOUT_MS,
+      signal
+    })
+  );
+}
+function forgetInFlight(cacheKey) {
+  globalInFlight.forget(cacheKey);
+}
+
+// src/engine/hooks.ts
+function fireAndForget(fn, ...args) {
+  if (fn === void 0) return;
+  try {
+    const result = fn(...args);
+    if (result instanceof Promise) {
+      result.catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+
+// src/engine/error-recording.ts
+function handleDistributionError(err, provider, meta, config, userSignal, timeoutSignal, index, chainStartMs, cacheKey) {
+  if (timeoutSignal.aborted && isTimeoutAbort(timeoutSignal)) {
+    const verdict = buildBudgetExhaustedVerdict(
+      meta,
+      "per_call_timeout",
+      config.onErrorPolicy,
+      provider
+    );
+    if (verdict !== void 0) return { kind: "verdict", verdict };
+    throw new BudgetExhaustedError("per_call_timeout exceeded", {
+      scope: "per_call_timeout",
+      attemptedProviders: meta.providersAttempted,
+      elapsedMs: Date.now() - chainStartMs,
+      cause: err
+    });
+  }
+  const userAbort = abortReason(userSignal);
+  if (userAbort !== void 0) {
+    const verdict = buildCancelledVerdict(meta, userAbort, provider);
+    return { kind: "verdict", verdict };
+  }
+  return recordProviderError(err, provider, meta, config, index, cacheKey);
+}
+function recordProviderError(err, provider, meta, config, index, cacheKey) {
+  const wrapped = canonicalizeProviderThrow(err);
+  if (!(wrapped instanceof ProviderError)) {
+    throw wrapped;
+  }
+  meta.providerErrors.push({ providerId: provider.id, error: serializeError(wrapped) });
+  fireAndForget(config.onProviderError, wrapped, {
+    providerId: provider.id,
+    attempt: index + 1
+  });
+  forgetInFlight(cacheKey);
+  return { kind: "continue" };
+}
+function recordValidationError(err, provider, meta, config, index, cacheKey) {
+  const wrapped = canonicalizeProviderThrow(err);
+  if (!(wrapped instanceof ProviderError)) throw wrapped;
+  meta.providerErrors.push({ providerId: provider.id, error: serializeError(wrapped) });
+  fireAndForget(config.onProviderError, wrapped, {
+    providerId: provider.id,
+    attempt: index + 1
+  });
+  forgetInFlight(cacheKey);
+  return { kind: "continue" };
+}
+
+// src/engine/finalize.ts
+function checkChainBudget(meta, chainStartMs, chainTimeoutMs, config) {
+  const elapsed = Date.now() - chainStartMs;
+  if (elapsed < chainTimeoutMs) return void 0;
+  const verdict = buildBudgetExhaustedVerdict(meta, "chain_timeout", config.onErrorPolicy);
+  if (verdict !== void 0) return verdict;
+  throw new BudgetExhaustedError("chain_timeout exceeded", {
+    scope: "chain_timeout",
+    attemptedProviders: meta.providersAttempted,
+    elapsedMs: elapsed
+  });
+}
+function makeCancelledFromMeta(meta, reason) {
+  return {
+    kind: "unknown",
+    reason: { type: "cancelled", reason },
+    meta: buildMetaForFailure(meta)
+  };
+}
+function finalizeChainExhausted(meta, lastCalibrated, attempts, config) {
+  const allErrored = lastCalibrated === void 0 && meta.providerErrors.length > 0 && meta.providerErrors.length === meta.providersAttempted.length;
+  if (allErrored) {
+    if (config.onErrorPolicy === "throw") {
+      const errors = meta.providerErrors.map((e) => deserializeForAggregate(e.error));
+      throw new AggregateError(errors, "All providers failed.");
+    }
+    const verdict2 = {
+      kind: "unknown",
+      reason: {
+        type: "provider_failure",
+        errors: meta.providerErrors.map((e) => e.error)
+      },
+      meta: buildMetaForFailure(meta)
+    };
+    fireAndForget(config.hooks?.onResult, verdict2);
+    return verdict2;
+  }
+  const verdict = {
+    kind: "unknown",
+    reason: {
+      type: "chain_exhausted",
+      lastDistribution: lastCalibrated ?? { probs: {}, coverage: 0 },
+      providersAttempted: attempts
+    },
+    meta: buildMetaForFailure(meta)
+  };
+  fireAndForget(config.hooks?.onResult, verdict);
+  return verdict;
+}
+
+// src/engine/threshold.ts
+var DEFAULT_COVERAGE_MIN = 0.5;
+function applyThresholds(d, thresholds, space) {
+  const t = thresholds;
+  const sorted = sortBySpaceProbability(d, space);
+  const top = sorted[0];
+  const second = sorted[1];
+  const coverageMin = t.coverageMin ?? DEFAULT_COVERAGE_MIN;
+  if (d.coverage < coverageMin) {
+    return {
+      kind: "out_of_distribution",
+      coverage: d.coverage,
+      topIfRenormalized: top.label,
+      probabilityIfRenormalized: top.prob
+    };
+  }
+  if (space.length === 2 && t.low !== void 0) {
+    return applyBinaryDeadband(top, second, t);
+  }
+  return applyMultiClassRule(top, second, t);
+}
+function sortBySpaceProbability(d, space) {
+  const probs = d.probs;
+  const items = space.map((label) => ({
+    label,
+    prob: probs[label]
+  }));
+  items.sort((a, b) => b.prob - a.prob);
+  return items;
+}
+function applyBinaryDeadband(top, second, t) {
+  if (top.prob >= t.high) {
+    return { kind: "classified", value: top.label, probability: top.prob };
+  }
+  if (t.low !== void 0 && top.prob <= t.low) {
+    return { kind: "classified", value: second.label, probability: second.prob };
+  }
+  return { kind: "uncertain", top: top.label, probability: top.prob, runnerUp: second.label };
+}
+function applyMultiClassRule(top, second, t) {
+  if (top.prob < t.high) {
+    return { kind: "uncertain", top: top.label, probability: top.prob, runnerUp: second.label };
+  }
+  if (t.margin !== void 0 && top.prob - second.prob < t.margin) {
+    return { kind: "uncertain", top: top.label, probability: top.prob, runnerUp: second.label };
+  }
+  return { kind: "classified", value: top.label, probability: top.prob };
+}
+
+// src/engine/decide.ts
+async function decide(formattedInput, config, signal) {
+  const meta = makeMetaBuilder();
+  const preAbort = abortReason(signal);
+  if (preAbort !== void 0) {
+    return makeCancelledFromMeta(meta, preAbort);
+  }
+  fireAndForget(config.hooks?.onCall, formattedInput, {
+    providers: config.providers.map((p) => p.id)
+  });
+  const limits = computeLimits(config);
+  const chainStartMs = Date.now();
+  let lastCalibrated;
+  let attempts = 0;
+  for (let i = 0; i < config.providers.length; i++) {
+    const provider = config.providers[i];
+    if (attempts >= limits.maxCalls) break;
+    attempts++;
+    meta.providersAttempted.push(provider.id);
+    const chainBudgetVerdict = checkChainBudget(meta, chainStartMs, limits.chainTimeoutMs, config);
+    if (chainBudgetVerdict !== void 0) {
+      fireAndForget(config.hooks?.onResult, chainBudgetVerdict);
+      return chainBudgetVerdict;
+    }
+    const midAbort = abortReason(signal);
+    if (midAbort !== void 0) {
+      const verdict = buildCancelledVerdict(meta, midAbort, provider);
+      fireAndForget(config.hooks?.onResult, verdict);
+      return verdict;
+    }
+    const isLastProvider = i === config.providers.length - 1;
+    const outcome = await attemptProvider(
+      provider,
+      formattedInput,
+      config,
+      meta,
+      signal,
+      i,
+      chainStartMs,
+      limits.perCallTimeoutMs,
+      isLastProvider
+    );
+    if (outcome.kind === "verdict") {
+      fireAndForget(config.hooks?.onResult, outcome.verdict);
+      return outcome.verdict;
+    }
+    if (outcome.kind === "lastUncertain") {
+      lastCalibrated = outcome.calibrated;
+      fireAndForget(config.hooks?.onResult, outcome.verdict);
+      return outcome.verdict;
+    }
+    if (outcome.calibrated !== void 0) lastCalibrated = outcome.calibrated;
+  }
+  return finalizeChainExhausted(meta, lastCalibrated, attempts, config);
+}
+function computeLimits(config) {
+  return {
+    perCallTimeoutMs: config.budget?.perCallTimeoutMs ?? DEFAULT_PER_CALL_TIMEOUT_MS,
+    chainTimeoutMs: config.budget?.chainTimeoutMs ?? DEFAULT_CHAIN_TIMEOUT_MS,
+    maxCalls: config.budget?.maxCalls ?? config.providers.length
+  };
+}
+async function attemptProvider(provider, formattedInput, config, meta, userSignal, index, chainStartMs, perCallTimeoutMs, isLastProvider) {
+  const cacheKey = computeProviderCacheKey(provider, formattedInput, config);
+  const timeoutSignal = AbortSignal.timeout(perCallTimeoutMs);
+  const mergedSignal = mergeSignals(userSignal, timeoutSignal);
+  let distribution;
+  try {
+    distribution = await loadDistribution(
+      provider,
+      formattedInput,
+      config,
+      meta,
+      mergedSignal,
+      cacheKey
+    );
+  } catch (err) {
+    return handleDistributionError(
+      err,
+      provider,
+      meta,
+      config,
+      userSignal,
+      timeoutSignal,
+      index,
+      chainStartMs,
+      cacheKey
+    );
+  }
+  try {
+    validateDistribution(distribution, config.space);
+  } catch (err) {
+    return recordValidationError(err, provider, meta, config, index, cacheKey);
+  }
+  const calibrated = config.calibrator.apply(distribution);
+  const result = applyThresholds(calibrated, config.thresholds, config.space);
+  if (result.kind === "classified") {
+    const verdict = {
+      kind: "classified",
+      value: result.value,
+      probability: result.probability,
+      meta: buildMeta(meta, provider)
+    };
+    return { kind: "verdict", verdict };
+  }
+  if (result.kind === "out_of_distribution") {
+    const verdict = {
+      kind: "unknown",
+      reason: {
+        type: "out_of_distribution",
+        coverage: result.coverage,
+        topIfRenormalized: result.topIfRenormalized,
+        probabilityIfRenormalized: result.probabilityIfRenormalized
+      },
+      meta: buildMeta(meta, provider)
+    };
+    return { kind: "verdict", verdict };
+  }
+  if (isLastProvider) {
+    const verdict = {
+      kind: "uncertain",
+      top: result.top,
+      probability: result.probability,
+      runnerUp: result.runnerUp,
+      distribution: calibrated,
+      meta: buildMeta(meta, provider)
+    };
+    return { kind: "lastUncertain", verdict, calibrated };
+  }
+  return { kind: "continue", calibrated };
+}
+var cl100kSingleton;
+function cl100kTokenizer() {
+  if (cl100kSingleton !== void 0) return cl100kSingleton;
+  const enc = get_encoding("cl100k_base");
+  cl100kSingleton = {
+    id: "openai/cl100k_base",
+    encode(label) {
+      const withLeadingSpace = label.startsWith(" ") ? label : ` ${label}`;
+      const ids = enc.encode(withLeadingSpace);
+      return Array.from(ids);
+    },
+    firstTokenId(label) {
+      const ids = this.encode(label);
+      const first = ids[0];
+      if (first === void 0) {
+        throw new Error(`Tokenizer produced empty encoding for label ${JSON.stringify(label)}`);
+      }
+      return first;
+    }
+  };
+  return cl100kSingleton;
+}
+function findFirstTokenCollision(tokenizer, space) {
+  const seenByTokenId = /* @__PURE__ */ new Map();
+  for (const label of space) {
+    const tokenId = tokenizer.firstTokenId(label);
+    const priorLabel = seenByTokenId.get(tokenId);
+    if (priorLabel !== void 0 && priorLabel !== label) {
+      return { a: priorLabel, b: label, tokenId };
+    }
+    seenByTokenId.set(tokenId, label);
+  }
+  return void 0;
+}
+function buildLogitBias(tokenizer, space, bias = 100) {
+  return Object.fromEntries(
+    space.map((label) => [String(tokenizer.firstTokenId(label)), bias])
+  );
+}
+
+// src/providers/openai/distribution.ts
+function buildDistributionByTokenId(space, tokenLogprobs, inSpaceIds, tokenizer) {
+  const inSpace = /* @__PURE__ */ new Map();
+  let inSpaceMass = 0;
+  for (const entry of tokenLogprobs) {
+    const ids = tokenizer.encode(entry.token);
+    const firstId = ids[0];
+    if (firstId === void 0) continue;
+    const label = inSpaceIds.get(firstId);
+    if (label === void 0) continue;
+    const prob = Math.exp(entry.logprob);
+    const previous = inSpace.get(label) ?? 0;
+    if (prob > previous) {
+      inSpace.set(label, prob);
+      inSpaceMass += prob - previous;
+    }
+  }
+  return renormalize(space, inSpace, inSpaceMass);
+}
+function buildDistributionByStringMatch(space, tokenLogprobs) {
+  const inSpace = /* @__PURE__ */ new Map();
+  let inSpaceMass = 0;
+  for (const label of space) {
+    const trimmed = label.trim();
+    let bestProb = 0;
+    for (const entry of tokenLogprobs) {
+      const tok = entry.token.trim();
+      if (tok === trimmed || tok && trimmed.startsWith(tok)) {
+        const prob = Math.exp(entry.logprob);
+        if (prob > bestProb) bestProb = prob;
+      }
+    }
+    if (bestProb > 0) {
+      inSpace.set(label, bestProb);
+      inSpaceMass += bestProb;
+    }
+  }
+  return renormalize(space, inSpace, inSpaceMass);
+}
+function renormalize(space, inSpace, inSpaceMass) {
+  const coverage = Math.min(1, inSpaceMass);
+  const probs = {};
+  for (const label of space) {
+    const raw = inSpace.get(label) ?? 0;
+    probs[label] = inSpaceMass > 0 ? raw / inSpaceMass : 0;
+  }
+  return {
+    probs,
+    coverage
+  };
+}
+
+// src/providers/openai/adapter.ts
+var LOGIT_BIAS_VALUE = 100;
+function buildAdapter(args) {
+  const collisionMemo = /* @__PURE__ */ new Set();
+  const tokenizer = args.tokenizer;
+  const eagerValidate = tokenizer === void 0 ? {} : {
+    validate: (space) => {
+      ensureNoCollisions(tokenizer, space, collisionMemo);
+    }
+  };
+  return {
+    id: args.id,
+    modelId: args.modelId,
+    tokenizerId: args.tokenizerId,
+    capabilities: args.capabilities,
+    ...eagerValidate,
+    async sample(input, space, opts) {
+      let logitBias;
+      let inSpaceFirstTokenIds;
+      if (tokenizer !== void 0) {
+        ensureNoCollisions(tokenizer, space, collisionMemo);
+        logitBias = buildLogitBias(tokenizer, space, LOGIT_BIAS_VALUE);
+        inSpaceFirstTokenIds = mapFirstTokenIds(tokenizer, space);
+      }
+      const messages = [];
+      const system = renderSystemPrompt(opts.template, space);
+      if (system !== void 0) {
+        messages.push({ role: "system", content: system });
+      }
+      messages.push({ role: "user", content: renderUserPrompt(opts.template, input, space) });
+      let response;
+      try {
+        const params = {
+          model: args.modelId,
+          messages,
+          temperature: opts.temperature,
+          logprobs: true,
+          top_logprobs: Math.min(args.capabilities.maxTopLogprobs, Math.max(space.length * 2, 5)),
+          // One label is one short word; 16 tokens is enough headroom.
+          max_completion_tokens: 16
+        };
+        if (opts.seed !== void 0) params.seed = opts.seed;
+        if (logitBias !== void 0) params.logit_bias = logitBias;
+        const requestOpts = {
+          timeout: opts.timeoutMs
+        };
+        if (opts.signal !== void 0) requestOpts.signal = opts.signal;
+        response = await args.client.chat.completions.create(params, requestOpts);
+      } catch (err) {
+        throw canonicalizeProviderThrow(err);
+      }
+      const choice = response.choices[0];
+      if (choice === void 0) {
+        throw new ProviderError("OpenAI response had no choices.", {
+          code: "provider_malformed_response"
+        });
+      }
+      const tokenLogprobs = choice.logprobs?.content?.[0]?.top_logprobs;
+      if (tokenLogprobs === void 0 || tokenLogprobs.length === 0) {
+        throw new ProviderError("OpenAI response missing first-token logprobs.", {
+          code: "provider_malformed_response"
+        });
+      }
+      return tokenizer !== void 0 && inSpaceFirstTokenIds !== void 0 ? buildDistributionByTokenId(space, tokenLogprobs, inSpaceFirstTokenIds, tokenizer) : buildDistributionByStringMatch(space, tokenLogprobs);
+    }
+  };
+}
+function ensureNoCollisions(tokenizer, space, memo) {
+  const memoKey = JSON.stringify(space);
+  if (memo.has(memoKey)) return;
+  const collision = findFirstTokenCollision(tokenizer, space);
+  if (collision !== void 0) {
+    throw new ConfigError(
+      `Decision space contains first-token collision: ${JSON.stringify(collision.a)} and ${JSON.stringify(collision.b)} both encode to token id ${collision.tokenId}. Prefix-disambiguate the labels (e.g., 'A_yes' / 'A_no') or pick alternatives.`,
+      { code: "decision_space_collision" }
+    );
+  }
+  memo.add(memoKey);
+}
+function mapFirstTokenIds(tokenizer, space) {
+  const map = /* @__PURE__ */ new Map();
+  for (const label of space) {
+    map.set(tokenizer.firstTokenId(label), label);
+  }
+  return map;
+}
+
+// src/providers/openai/factory.ts
+var LOGPROBS_CAPABILITIES = {
+  distributionSource: "logprobs",
+  coverageMeasurement: "exact",
+  // OpenAI hosted caps top_logprobs at 20; most OpenAI-compat backends match.
+  maxTopLogprobs: 20
+};
+function openai(model, opts) {
+  const client = new OpenAI({
+    apiKey: process.env.OPENAI_API_KEY,
+    baseURL: opts?.baseURL,
+    timeout: opts?.timeout
+  });
+  return buildAdapter({
+    id: `openai/${model}`,
+    modelId: model,
+    tokenizerId: "openai/cl100k_base",
+    capabilities: LOGPROBS_CAPABILITIES,
+    client,
+    tokenizer: cl100kTokenizer()
+  });
+}
+var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+var OLLAMA_DEFAULT_API_KEY = "ollama";
+function ollama(model, opts) {
+  const client = new OpenAI({
+    apiKey: OLLAMA_DEFAULT_API_KEY,
+    baseURL: OLLAMA_DEFAULT_BASE_URL,
+    timeout: opts?.timeout
+  });
+  return buildAdapter({
+    id: `ollama/${model}`,
+    modelId: model,
+    // Tokenizer id for cache-key composition; treated opaquely.
+    tokenizerId: `ollama/${model}`,
+    capabilities: LOGPROBS_CAPABILITIES,
+    client
+    // No tokenizer — string-based fallback matches Ollama's varied tokenizers.
+  });
+}
+
+// src/env.ts
+var BUILTIN_FACTORIES = {
+  openai: (model) => openai(model),
+  ollama: (model) => ollama(model)
+};
+function parseProvidersEnv(raw) {
+  if (raw === void 0) return [];
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  return trimmed.split(",").map((part) => part.trim()).filter(Boolean).map(parseProviderEntry);
+}
+function parseProviderEntry(entry) {
+  const slashIndex = entry.indexOf("/");
+  if (slashIndex < 0) {
+    throw new ConfigError(
+      `DOMOVOI_PROVIDERS: malformed entry ${JSON.stringify(entry)}; expected factory/model format.`,
+      { code: "malformed_provider_config" }
+    );
+  }
+  const factory = entry.slice(0, slashIndex).trim();
+  const model = entry.slice(slashIndex + 1).trim();
+  if (!factory || !model) {
+    throw new ConfigError(
+      `DOMOVOI_PROVIDERS: malformed entry ${JSON.stringify(entry)}; factory or model is empty.`,
+      { code: "malformed_provider_config" }
+    );
+  }
+  return { factory, model };
+}
+function resolveProvidersFromEnv(raw) {
+  const entries = parseProvidersEnv(raw);
+  if (entries.length === 0) {
+    throw new ConfigError(
+      "Cannot resolve provider chain: DOMOVOI_PROVIDERS is unset or empty. Set the env variable or pass `providers` explicitly.",
+      { code: "missing_provider_config" }
+    );
+  }
+  return entries.map((entry) => {
+    const factory = BUILTIN_FACTORIES[entry.factory];
+    if (factory === void 0) {
+      throw new ConfigError(
+        `DOMOVOI_PROVIDERS: unknown factory ${JSON.stringify(entry.factory)}. Known: ${Object.keys(BUILTIN_FACTORIES).join(", ")}. For other providers, supply { providers } explicitly in code.`,
+        { code: "unknown_provider_factory" }
+      );
+    }
+    return factory(entry.model);
+  });
+}
+function resolveDefaultProviders(name) {
+  if (name !== void 0) {
+    const namedKey = `DOMOVOI_PROVIDERS_${name.toUpperCase()}`;
+    const namedRaw = process.env[namedKey];
+    if (namedRaw?.trim()) {
+      return resolveProvidersFromEnv(namedRaw);
+    }
+  }
+  return resolveProvidersFromEnv(process.env.DOMOVOI_PROVIDERS);
+}
+
+// src/verbs/boolean.ts
+var ONE_SHOT_BINARY_THRESHOLDS = { high: 0.7, low: 0.3, coverageMin: 0.3 };
+var YES_NO_SPACE = ["yes", "no"];
+async function boolean(input, question, opts) {
+  const providers = opts?.providers !== void 0 && opts.providers.length > 0 ? opts.providers : resolveDefaultProviders();
+  const calibrator = opts?.calibrator ?? identity;
+  const cache = opts?.cache ?? memoryCache();
+  const thresholds = opts?.thresholds ?? ONE_SHOT_BINARY_THRESHOLDS;
+  validateClassifierConfig({
+    space: YES_NO_SPACE,
+    thresholds,
+    providers,
+    calibrator
+  });
+  const config = withDefaults({
+    space: YES_NO_SPACE,
+    thresholds,
+    providers,
+    calibrator,
+    cache,
+    template: defaultTemplate,
+    question,
+    ...opts?.budget !== void 0 ? { budget: opts.budget } : {}
+  });
+  const verdict = await decide(input, config, opts?.signal);
+  return toBooleanVerdict(verdict);
+}
+function toBooleanVerdict(v) {
+  switch (v.kind) {
+    case "classified":
+      return { ...v, value: v.value === "yes" };
+    case "uncertain":
+      return {
+        ...v,
+        top: v.top === "yes",
+        runnerUp: v.runnerUp === "yes",
+        distribution: rekey(v.distribution)
+      };
+    case "unknown":
+      return { ...v, reason: convertCause(v.reason) };
+  }
+}
+function convertCause(cause) {
+  switch (cause.type) {
+    case "out_of_distribution":
+      return { ...cause, topIfRenormalized: cause.topIfRenormalized === "yes" };
+    case "chain_exhausted":
+      return { ...cause, lastDistribution: rekey(cause.lastDistribution) };
+    // Remaining variants don't reference T — payload is structurally identical
+    // between UnknownVerdictCause<YesNo> and UnknownVerdictCause<boolean>.
+    case "predicate_rejected":
+    case "provider_failure":
+    case "budget_exhausted":
+    case "cancelled":
+      return cause;
+  }
+}
+function rekey(d) {
+  return {
+    probs: { true: d.probs.yes, false: d.probs.no },
+    coverage: d.coverage
+  };
+}
+
+// src/verbs/classifier.ts
+var DEFAULT_BATCH_CONCURRENCY = 5;
+function classifier(config) {
+  const providers = config.providers !== void 0 && config.providers.length > 0 ? config.providers : resolveDefaultProviders(config.name);
+  const calibrator = config.calibrator ?? identity;
+  const cache = config.cache ?? memoryCache();
+  const template = config.template ?? defaultTemplate;
+  validateClassifierConfig({
+    ...config.name !== void 0 ? { name: config.name } : {},
+    space: config.space,
+    thresholds: config.thresholds,
+    providers,
+    calibrator
+  });
+  const format = config.format ?? ((x) => x);
+  const decideConfig = withDefaults({
+    space: config.space,
+    thresholds: config.thresholds,
+    providers,
+    calibrator,
+    cache,
+    template,
+    ...config.question !== void 0 ? { question: config.question } : {},
+    ...config.budget !== void 0 ? { budget: config.budget } : {},
+    ...config.onErrorPolicy !== void 0 ? { onErrorPolicy: config.onErrorPolicy } : {},
+    ...config.onProviderError !== void 0 ? { onProviderError: config.onProviderError } : {},
+    ...config.hooks !== void 0 ? { hooks: config.hooks } : {}
+  });
+  const single = async (input, opts) => {
+    const formatted = format(input);
+    return decide(formatted, decideConfig, opts?.signal);
+  };
+  const batch = async (items, opts) => {
+    const concurrency = opts?.concurrency ?? DEFAULT_BATCH_CONCURRENCY;
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+      while (true) {
+        const idx = next++;
+        if (idx >= items.length) return;
+        const item = items[idx];
+        results[idx] = await single(
+          item,
+          opts?.signal !== void 0 ? { signal: opts.signal } : {}
+        );
+      }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+  };
+  const callable = single;
+  return Object.assign(callable, { batch });
+}
+
+// src/verbs/classify.ts
+var ONE_SHOT_DEFAULT_THRESHOLDS = { high: 0.5, coverageMin: 0.3 };
+async function classify(input, space, opts) {
+  const providers = opts?.providers !== void 0 && opts.providers.length > 0 ? opts.providers : resolveDefaultProviders();
+  const calibrator = opts?.calibrator ?? identity;
+  const cache = opts?.cache ?? memoryCache();
+  const thresholds = opts?.thresholds ?? ONE_SHOT_DEFAULT_THRESHOLDS;
+  validateClassifierConfig({
+    space,
+    thresholds,
+    providers,
+    calibrator
+  });
+  const config = withDefaults({
+    space,
+    thresholds,
+    providers,
+    calibrator,
+    cache,
+    template: defaultTemplate,
+    ...opts?.question !== void 0 ? { question: opts.question } : {},
+    ...opts?.budget !== void 0 ? { budget: opts.budget } : {}
+  });
+  return decide(input, config, opts?.signal);
+}
+
+// src/verdict.ts
+function isClassified(v) {
+  return v.kind === "classified";
+}
+function isUncertain(v) {
+  return v.kind === "uncertain";
+}
+function isUnknown(v) {
+  return v.kind === "unknown";
+}
+function match(v, handlers) {
+  switch (v.kind) {
+    case "classified":
+      return handlers.classified(v);
+    case "uncertain":
+      return handlers.uncertain(v);
+    case "unknown":
+      return handlers.unknown(v);
+  }
+}
+function filter(pred) {
+  return (v) => {
+    if (v.kind === "unknown") return v;
+    if (pred(v)) return v;
+    return {
+      kind: "unknown",
+      reason: { type: "predicate_rejected", previousKind: v.kind },
+      meta: v.meta
+    };
+  };
+}
+
+// src/index.ts
+var domovoi = {
+  classify,
+  boolean,
+  classifier,
+  memoryCache
+};
+
+export { BudgetExhaustedError, ConfigError, DomovoiError, ProviderError, domovoi, filter, isClassified, isUncertain, isUnknown, match };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map