open-classify 0.5.0 → 0.7.0

package/dist/src/classify.js

@@ -1,9 +1,11 @@
-// High-level facade for the pipeline. Builds the runner and catalog once,
-// then returns two functions — classify() for the user-input/routing pass
-// and inspect() for the assistant-output lean pass. Backend-agnostic: pass a
-// custom `runClassifier` to bypass the bundled Ollama runner entirely.
+// High-level facade for the pipeline. Builds the runner, registry, and
+// catalog once, then returns two functions — classify() for the
+// user-input/routing pass and inspect() for the assistant-output lean pass.
+// Backend-agnostic: pass a custom `runClassifier` to bypass the bundled
+// Ollama runner entirely.
 import { loadCatalog } from "./catalog.js";
-import { classifierModelsFromConfig, loadOpenClassifyConfig, } from "./config.js";
+import { buildClassifierRegistry, ClassifierManifestError, } from "./classifiers.js";
+import { classifierModelsFromConfig, loadOpenClassifyConfig, OpenClassifyConfigError, } from "./config.js";
 import { assertOllamaResources, createOllamaClassifierRunner, OLLAMA_DEFAULT_CATALOG_PATH, } from "./ollama.js";
 import { classifyOpenClassifyInput, inspectOpenClassifyInput, } from "./pipeline.js";
 export function createClassifier(options = {}) {
@@ -12,6 +14,20 @@ export function createClassifier(options = {}) {
             optional: options.configPath === undefined &&
                 process.env.OPEN_CLASSIFY_CONFIG === undefined,
         });
+    const registryBundle = buildClassifierRegistry({
+        extraDirs: options.extraClassifierDirs,
+    });
+    // Cross-check `runner.models` keys against the loaded registry so a typo
+    // or stale reference fails fast at construction time instead of being
+    // silently ignored by the runner.
+    if (fileConfig?.runner?.models !== undefined) {
+        const known = new Set(registryBundle.names);
+        for (const name of Object.keys(fileConfig.runner.models)) {
+            if (!known.has(name)) {
+                throw new OpenClassifyConfigError(`runner.models.${name} is not a loaded classifier (loaded: ${registryBundle.names.join(", ")})`);
+            }
+        }
+    }
     // When we own the runner, hoist the resource check to the wrapper so a
     // failure surfaces as a top-level rejection — the per-classifier fallback
     // path would otherwise mask it as five "classifier failed" entries.
@@ -19,6 +35,7 @@ export function createClassifier(options = {}) {
     const needsResourceCheck = ownsRunner && !options.skipResourceCheck;
     const runClassifier = options.runClassifier ??
         createOllamaClassifierRunner({
+            modulesByName: registryBundle.modulesByName,
             host: fileConfig?.runner?.host,
             defaultModel: fileConfig?.runner?.defaultModel,
             models: classifierModelsFromConfig(fileConfig),
@@ -28,7 +45,6 @@ export function createClassifier(options = {}) {
         });
     const catalog = options.catalog ??
         loadCatalog(options.catalogPath ?? fileConfig?.catalog ?? OLLAMA_DEFAULT_CATALOG_PATH);
-    const aggregator = options.aggregator ?? fileConfig?.aggregator;
     let resourceCheck;
     const ensureResources = async () => {
         if (!needsResourceCheck)
@@ -44,10 +60,10 @@ export function createClassifier(options = {}) {
         return classifyOpenClassifyInput(input, {
             runClassifier,
             catalog,
+            registry: registryBundle.registry,
             classifierTimeoutMs: options.classifierTimeoutMs,
             classifierRetryCount: options.classifierRetryCount,
             maxConcurrency: options.maxConcurrency,
-            aggregator,
             signal: callOptions?.signal,
         });
     };
@@ -55,11 +71,15 @@ export function createClassifier(options = {}) {
         await ensureResources();
         return inspectOpenClassifyInput(input, {
             runClassifier,
+            registry: registryBundle.registry,
             classifierTimeoutMs: options.classifierTimeoutMs,
             classifierRetryCount: options.classifierRetryCount,
             maxConcurrency: options.maxConcurrency,
             signal: callOptions?.signal,
         });
     };
-    return { classify, inspect };
+    return { classify, inspect, registry: registryBundle };
 }
+// Re-export so callers can `import { ClassifierManifestError } from "open-classify"`
+// and catch directory/name collision errors from createClassifier().
+export { ClassifierManifestError };

package/dist/src/config.d.ts

@@ -1,10 +1,8 @@
-import { type ClassifierName } from "./classifiers.js";
-import { type AggregatorConfig } from "./manifest.js";
+import type { ClassifierName } from "./classifiers.js";
 export declare const DEFAULT_OPEN_CLASSIFY_CONFIG_PATH = "open-classify.config.json";
 export interface OpenClassifyConfig {
     readonly runner?: OllamaRunnerConfig;
     readonly catalog?: string;
-    readonly aggregator?: AggregatorConfig;
 }
 export interface OllamaRunnerConfig {
     readonly provider: "ollama";

package/dist/src/config.js

@@ -1,5 +1,4 @@
 import { existsSync, readFileSync } from "node:fs";
-import { CLASSIFIER_NAMES } from "./classifiers.js";
 import { isRecord } from "./validation.js";
 export const DEFAULT_OPEN_CLASSIFY_CONFIG_PATH = "open-classify.config.json";
 export class OpenClassifyConfigError extends Error {
@@ -30,25 +29,10 @@ export function validateOpenClassifyConfig(value, path = "open-classify config")
     if (!isRecord(value)) {
         throwConfig(path, "config must be a JSON object");
     }
-    ensureAllowedKeys(value, ["runner", "catalog", "aggregator"], path, "<root>");
+    ensureAllowedKeys(value, ["runner", "catalog"], path, "<root>");
     return {
         ...(value.runner === undefined ? {} : { runner: validateRunner(value.runner, path) }),
         ...(value.catalog === undefined ? {} : { catalog: requireString(value.catalog, path, "catalog") }),
-        ...(value.aggregator === undefined ? {} : { aggregator: validateAggregator(value.aggregator, path) }),
-    };
-}
-function validateAggregator(value, path) {
-    if (!isRecord(value)) {
-        throwConfig(path, "aggregator must be an object");
-    }
-    ensureAllowedKeys(value, ["certaintyThreshold", "confidenceThreshold"], path, "aggregator");
-    return {
-        ...(value.certaintyThreshold === undefined
-            ? {}
-            : { certaintyThreshold: requireUnitFloat(value.certaintyThreshold, path, "aggregator.certaintyThreshold") }),
-        ...(value.confidenceThreshold === undefined
-            ? {}
-            : { confidenceThreshold: requireUnitFloat(value.confidenceThreshold, path, "aggregator.confidenceThreshold") }),
     };
 }
 function validateRunner(value, path) {
@@ -96,12 +80,8 @@ function validateModels(value, path) {
     if (!isRecord(value)) {
         throwConfig(path, "runner.models must be an object");
     }
-    const allowed = new Set(CLASSIFIER_NAMES);
     const out = {};
     for (const [name, model] of Object.entries(value)) {
-        if (!allowed.has(name)) {
-            throwConfig(path, `runner.models.${name} is not a known classifier`);
-        }
         out[name] = requireString(model, path, `runner.models.${name}`);
     }
     return out;
@@ -118,13 +98,6 @@ function requireNumber(value, path, field) {
     }
     return value;
 }
-function requireUnitFloat(value, path, field) {
-    const number = requireNumber(value, path, field);
-    if (number < 0 || number > 1) {
-        throwConfig(path, `${field} must be a finite number between 0 and 1 inclusive`);
-    }
-    return number;
-}
 function ensureAllowedKeys(value, allowedKeys, path, field) {
     const allowed = new Set(allowedKeys);
     for (const key of Object.keys(value)) {

package/dist/src/index.js

@@ -1,8 +1,7 @@
 // Public barrel for the Open Classify package. Everything an external caller
 // would need — input types, enums, the registry, the pipeline, the Ollama
-// runner, the catalog loader, the aggregator's certainty threshold — is
-// re-exported here. The build emits a single `index.js` that downstream
-// consumers can import from `open-classify`.
+// runner, the catalog loader — is re-exported here. The build emits a single
+// `index.js` that downstream consumers can import from `open-classify`.
 export * from "./aggregator.js";
 export * from "./catalog.js";
 export * from "./classifiers.js";

package/dist/src/manifest.d.ts

@@ -1,9 +1,9 @@
-import type { AckReplySignal, ClassifierAuditOutput, ClassifierOutput, FinalReplySignal, PromptInjectionSignal, RoutingSignal, RuntimeClassifierManifest, ToolsSignal } from "./stock.js";
-import type { ClassifierInput, ClassifierRunStatus } from "./types.js";
-import type { DownstreamModelTier, ModelSpecialization } from "./enums.js";
+import type { RuntimeClassifierManifest } from "./stock.js";
+import type { ClassifierInput } from "./types.js";
+import type { DownstreamModelTier, ModelSpecialization, PromptInjectionRiskLevel } from "./enums.js";
 export type ClassifierName = string;
-export type ClassifierResults = Record<ClassifierName, ClassifierOutput>;
-export type RunClassifier = (name: ClassifierName, input: ClassifierInput, signal: AbortSignal) => Promise<ClassifierOutput>;
+export type ClassifierResults = Record<ClassifierName, import("./stock.js").ClassifierOutput>;
+export type RunClassifier = (name: ClassifierName, input: ClassifierInput, signal: AbortSignal) => Promise<import("./stock.js").ClassifierOutput>;
 export interface CatalogEntry {
     readonly id: string;
     readonly specializations: ReadonlyArray<ModelSpecialization>;
@@ -18,78 +18,33 @@ export interface Catalog {
     readonly models: ReadonlyArray<CatalogEntry>;
     readonly default: string;
 }
-export interface ModelRecommendationResolution {
-    readonly constraints_used: Partial<{
-        model_specialization: ModelSpecialization;
-        model_tier: DownstreamModelTier;
-    }>;
-    readonly constraints_dropped: ReadonlyArray<{
-        readonly axis: "model_specialization" | "model_tier";
-        readonly reason: "low_confidence" | "no_match_relaxed" | "default_fallback";
-    }>;
-    readonly confidences: Partial<{
-        routing: number;
-    }>;
-    readonly fell_back_to_default: boolean;
-}
-export interface ModelRecommendation {
-    readonly id: string;
-    readonly params_in_billions: number | null;
-    readonly context_window: number;
-    readonly input_tokens_cpm?: number;
-    readonly cached_tokens_cpm?: number;
-    readonly output_tokens_cpm?: number;
-    readonly resolution: ModelRecommendationResolution;
-}
-export interface Envelope {
-    readonly final_reply?: FinalReplySignal;
-    readonly ack_reply?: AckReplySignal;
-    readonly routing?: RoutingSignal;
-    readonly tools?: ToolsSignal;
-    readonly prompt_injection?: PromptInjectionSignal;
-    readonly classifier_outputs: ReadonlyArray<ClassifierAuditOutput>;
-    readonly model_recommendation: ModelRecommendation;
-}
 export type ClassifierPublicOutputs = Record<string, Record<string, unknown>>;
-export interface DownstreamTargetMessage {
-    readonly role: "user";
+export type PipelineAction = "route" | "block" | "reply";
+export type BlockReason = "prompt_injection" | "classification_error";
+export interface ReplySignal {
     readonly text: string;
-    readonly hash: string;
 }
-export interface DownstreamPayload {
-    readonly model_id: string;
-    readonly target_message: DownstreamTargetMessage;
-    readonly tools: ToolsSignal;
-}
-export type ClassifierEntry = ClassifierOutput & {
-    readonly status: ClassifierRunStatus;
-    readonly version: string;
-};
-export interface CertaintySummary {
-    readonly min: number;
-    readonly avg: number;
-}
-export interface PipelineMeta {
-    readonly classifiers: Record<string, ClassifierEntry>;
-    readonly certainty: CertaintySummary;
-}
-export interface PipelineAudit extends Envelope {
-    readonly meta: PipelineMeta;
-}
-export interface InspectResult {
+export interface PipelineResult {
+    readonly action: PipelineAction;
+    readonly block_reason?: BlockReason;
     readonly target_message_hash: string;
+    readonly model_id: string | null;
+    readonly tools: ReadonlyArray<string>;
+    readonly reply: ReplySignal | null;
+    readonly prompt_injection: {
+        readonly risk_level: PromptInjectionRiskLevel;
+    } | null;
+    readonly avg_certainty: number;
+    readonly min_certainty: number;
+    readonly failed_classifiers: ReadonlyArray<string>;
     readonly classifier_outputs: ClassifierPublicOutputs;
 }
-export interface PipelineResult {
-    readonly action: "route";
+export interface InspectResult {
     readonly target_message_hash: string;
-    readonly downstream: DownstreamPayload;
+    readonly message: {
+        readonly role: "assistant";
+        readonly text: string;
+    };
     readonly classifier_outputs: ClassifierPublicOutputs;
-    readonly audit: PipelineAudit;
-}
-export interface AggregatorConfig {
-    readonly certaintyThreshold?: number;
-    /** @deprecated Use certaintyThreshold. */
-    readonly confidenceThreshold?: number;
 }
 export type ClassifierRegistry = ReadonlyArray<RuntimeClassifierManifest>;

package/dist/src/ollama.d.ts

@@ -1,13 +1,11 @@
-import { type ClassifierName, type RunClassifier } from "./classifiers.js";
+import { type ClassifierModuleMap, type ClassifierName, type RunClassifier } from "./classifiers.js";
 export declare const OLLAMA_DEFAULT_HOST = "http://localhost:11434";
 export declare const OLLAMA_BASE_MODEL = "gemma4:e4b-it-q4_K_M";
 export declare const OLLAMA_BASE_MODEL_NATIVE_CONTEXT_LENGTH = 131072;
-export declare const OLLAMA_REQUIRED_PARALLELISM: number;
 export declare const OLLAMA_DEFAULT_CATALOG_PATH = "downstream-models.json";
 export declare const OLLAMA_CONTEXT_LENGTH = 4096;
 export declare const OLLAMA_MIN_TOTAL_MEMORY_BYTES: number;
 export declare const OLLAMA_MIN_AVAILABLE_MEMORY_BYTES: number;
-export declare const OLLAMA_CLASSIFIER_MODELS: Record<ClassifierName, string | null>;
 export interface OllamaOptions {
     temperature?: number;
     top_p?: number;
@@ -15,14 +13,15 @@ export interface OllamaOptions {
     num_ctx?: number;
 }
 export interface OllamaClassifierRunnerConfig {
+    modulesByName: ClassifierModuleMap;
+    minTotalMemoryBytes?: number;
+    minAvailableMemoryBytes?: number;
     host?: string;
     defaultModel?: string;
     models?: Partial<Record<ClassifierName, string | null>>;
     options?: OllamaOptions;
     fetch?: typeof fetch;
     skipResourceCheck?: boolean;
-    minAvailableMemoryBytes?: number;
-    minTotalMemoryBytes?: number;
 }
 export declare class OllamaClassifierError extends Error {
     readonly classifier: ClassifierName;
@@ -36,7 +35,7 @@ export declare class OllamaResourceError extends Error {
     readonly minAvailableMemoryBytes: number;
     constructor(totalMemoryBytes: number, availableMemoryBytes: number, minTotalMemoryBytes: number, minAvailableMemoryBytes: number);
 }
-export declare function createOllamaClassifierRunner(config?: OllamaClassifierRunnerConfig): RunClassifier;
+export declare function createOllamaClassifierRunner(config: OllamaClassifierRunnerConfig): RunClassifier;
 export declare function assertOllamaResources(options?: {
     minTotalMemoryBytes?: number;
     minAvailableMemoryBytes?: number;

package/dist/src/ollama.js

@@ -10,12 +10,11 @@
 // `classifyOpenClassifyInput` — you don't have to use this module at all.
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { CLASSIFIER_NAMES, MODULES_BY_NAME, validateClassifierOutput, } from "./classifiers.js";
+import { validateClassifierOutput, } from "./classifiers.js";
 import { ClassifierValidationError, isRecord, } from "./validation.js";
 export const OLLAMA_DEFAULT_HOST = "http://localhost:11434";
 export const OLLAMA_BASE_MODEL = "gemma4:e4b-it-q4_K_M";
 export const OLLAMA_BASE_MODEL_NATIVE_CONTEXT_LENGTH = 131_072;
-export const OLLAMA_REQUIRED_PARALLELISM = CLASSIFIER_NAMES.length;
 export const OLLAMA_DEFAULT_CATALOG_PATH = "downstream-models.json";
 /*
  * Gemma 4 E4B's native context is 131,072 tokens (128K). The reference local
@@ -28,7 +27,6 @@ export const OLLAMA_MIN_TOTAL_MEMORY_BYTES = 16 * 1024 * 1024 * 1024;
 export const OLLAMA_MIN_AVAILABLE_MEMORY_BYTES = 16 * 1024 * 1024 * 1024;
 const ESTIMATED_CHARS_PER_TOKEN = 3;
 const execFileAsync = promisify(execFile);
-export const OLLAMA_CLASSIFIER_MODELS = Object.fromEntries(CLASSIFIER_NAMES.map((name) => [name, null]));
 export class OllamaClassifierError extends Error {
     classifier;
     model;
@@ -45,7 +43,7 @@ export class OllamaResourceError extends Error {
     minTotalMemoryBytes;
     minAvailableMemoryBytes;
     constructor(totalMemoryBytes, availableMemoryBytes, minTotalMemoryBytes, minAvailableMemoryBytes) {
-        super(`Ollama resource check failed: ${formatBytes(totalMemoryBytes)} total and ${formatBytes(availableMemoryBytes)} available; ${formatBytes(minTotalMemoryBytes)} total and ${formatBytes(minAvailableMemoryBytes)} available required for ${OLLAMA_REQUIRED_PARALLELISM} parallel classifiers`);
+        super(`Ollama resource check failed: ${formatBytes(totalMemoryBytes)} total and ${formatBytes(availableMemoryBytes)} available; ${formatBytes(minTotalMemoryBytes)} total and ${formatBytes(minAvailableMemoryBytes)} available required to run classifiers in parallel`);
         this.name = "OllamaResourceError";
         this.totalMemoryBytes = totalMemoryBytes;
         this.availableMemoryBytes = availableMemoryBytes;
@@ -56,7 +54,11 @@ export class OllamaResourceError extends Error {
 // Build a `RunClassifier` bound to a specific Ollama host + model selection.
 // The resource check is lazy and runs once per runner — the first classifier
 // invocation pays for it; subsequent ones reuse the same promise.
-export function createOllamaClassifierRunner(config = {}) {
+export function createOllamaClassifierRunner(config) {
+    if (!config?.modulesByName) {
+        throw new Error("createOllamaClassifierRunner requires `modulesByName` from buildClassifierRegistry()");
+    }
+    const modulesByName = config.modulesByName;
     const host = trimTrailingSlash(config.host ?? OLLAMA_DEFAULT_HOST);
     const fetchImpl = config.fetch ?? fetch;
     const models = config.models ?? {};
@@ -76,9 +78,13 @@ export function createOllamaClassifierRunner(config = {}) {
             });
             await resourceCheck;
         }
+        const manifest = modulesByName[name];
+        if (manifest === undefined) {
+            throw new OllamaClassifierError(name, defaultModel, `unknown classifier "${name}" — not present in registry`);
+        }
         const configuredModel = models[name];
         const model = configuredModel ?? defaultModel;
-        return runOllamaClassifier(name, input, signal, fetchImpl, host, model, options, configuredModel === undefined && !hasDefaultModelOverride);
+        return runOllamaClassifier(manifest, input, signal, fetchImpl, host, model, options, configuredModel === undefined && !hasDefaultModelOverride);
     };
 }
 export async function assertOllamaResources(options = {}) {
@@ -90,10 +96,10 @@ export async function assertOllamaResources(options = {}) {
         throw new OllamaResourceError(totalMemoryBytes, availableMemoryBytes, minTotalMemoryBytes, minAvailableMemoryBytes);
     }
 }
-async function runOllamaClassifier(name, input, signal, fetchImpl, host, model, options, allowManifestModel) {
-    const module_ = MODULES_BY_NAME[name];
-    const systemPrompt = module_.systemPrompt;
-    const configuredBaseModel = module_.backend?.ollama?.base_model;
+async function runOllamaClassifier(manifest, input, signal, fetchImpl, host, model, options, allowManifestModel) {
+    const name = manifest.name;
+    const systemPrompt = manifest.systemPrompt;
+    const configuredBaseModel = manifest.backend?.ollama?.base_model;
     if (allowManifestModel && configuredBaseModel) {
         model = configuredBaseModel;
     }
@@ -137,7 +143,7 @@ async function runOllamaClassifier(name, input, signal, fetchImpl, host, model,
     }
     const parsed = parseJsonObject(content, name, model);
     try {
-        return validateClassifierOutput(name, parsed, model);
+        return validateClassifierOutput(manifest, parsed, model);
     }
     catch (error) {
         if (error instanceof ClassifierValidationError) {

package/dist/src/pipeline.d.ts

@@ -1,5 +1,5 @@
 import { type RunClassifier } from "./classifiers.js";
-import type { AggregatorConfig, Catalog, InspectResult, PipelineResult } from "./manifest.js";
+import type { Catalog, ClassifierRegistry, InspectResult, PipelineResult } from "./manifest.js";
 import type { OpenClassifyInput } from "./types.js";
 export declare const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15000;
 export declare const DEFAULT_CLASSIFIER_RETRY_COUNT = 1;
@@ -10,14 +10,15 @@ export declare class OpenClassifyNormalizationError extends Error {
 export interface ClassifyOptions {
     runClassifier: RunClassifier;
     catalog: Catalog;
+    registry: ClassifierRegistry;
     classifierTimeoutMs?: number;
     classifierRetryCount?: number;
     maxConcurrency?: number;
-    aggregator?: AggregatorConfig;
     signal?: AbortSignal;
 }
 export interface InspectOptions {
     runClassifier: RunClassifier;
+    registry: ClassifierRegistry;
     classifierTimeoutMs?: number;
     classifierRetryCount?: number;
     maxConcurrency?: number;

package/dist/src/pipeline.js

@@ -1,7 +1,5 @@
-import { composeEnvelope } from "./aggregator.js";
-import { MODULES_BY_NAME, REGISTRY, } from "./classifiers.js";
+import { assembleResult, buildPublicOutputs } from "./aggregator.js";
 import { normalizeOpenClassifyInput, toClassifierInput } from "./input.js";
-import { certaintyScore } from "./stock.js";
 export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15_000;
 export const DEFAULT_CLASSIFIER_RETRY_COUNT = 1;
 export const DEFAULT_MAX_CONCURRENCY = 7;
@@ -12,22 +10,27 @@ export class OpenClassifyNormalizationError extends Error {
     }
 }
 export async function classifyOpenClassifyInput(input, options) {
-    const { request, results, meta } = await runPipeline(input, "user", options);
-    const classifierInput = toClassifierInput(request);
-    const envelope = composeEnvelope({
-        registry: filteredRegistry("user"),
+    const { request, results, failedClassifiers } = await runPipeline(input, "user", options);
+    const reg = filteredRegistry(options.registry, "user");
+    const assembled = assembleResult({
+        registry: reg,
         results,
+        failedClassifiers,
         catalog: options.catalog,
-        input: classifierInput,
-        config: options.aggregator,
     });
-    return buildRouteResult(request, envelope, results, meta);
+    return {
+        ...assembled,
+        target_message_hash: request.target_message_hash,
+    };
 }
 export async function inspectOpenClassifyInput(input, options) {
     const { request, results } = await runPipeline(input, "assistant", options);
+    const reg = filteredRegistry(options.registry, "assistant");
+    const lastMsg = request.messages[request.messages.length - 1];
     return {
         target_message_hash: request.target_message_hash,
-        classifier_outputs: classifierPublicOutputs(filteredRegistry("assistant"), results),
+        message: { role: "assistant", text: lastMsg.text },
+        classifier_outputs: buildPublicOutputs(reg, results),
     };
 }
 async function runPipeline(input, role, options) {
@@ -52,22 +55,19 @@ async function runPipeline(input, role, options) {
     const classifierTimeoutMs = options.classifierTimeoutMs ?? DEFAULT_CLASSIFIER_TIMEOUT_MS;
     const classifierRetryCount = options.classifierRetryCount ?? DEFAULT_CLASSIFIER_RETRY_COUNT;
     const maxConcurrency = resolveMaxConcurrency(options.maxConcurrency);
-    // REGISTRY is already sorted by `dispatch_order` ascending. Filter by
-    // applies_to so we only dispatch classifiers relevant to this role; the
-    // worker pool then runs them in the remaining order.
-    const registry = filteredRegistry(role);
+    const registry = filteredRegistry(options.registry, role);
     const queue = registry.map((m) => m.name);
     try {
         const settled = await runWithConcurrency(queue, maxConcurrency, controller.signal, (name) => runClassifierWithRetry(name, classifierInput, options.runClassifier, controller.signal, classifierTimeoutMs, classifierRetryCount));
-        const { results, meta } = collectFullEntries(settled, registry);
-        return { request, results, meta };
+        const { results, failedClassifiers } = collectResults(registry, settled);
+        return { request, results, failedClassifiers };
     }
     finally {
         options.signal?.removeEventListener("abort", abortFromOptions);
     }
 }
-function filteredRegistry(role) {
-    return REGISTRY.filter((m) => roleAppliesTo(m.appliesTo, role));
+function filteredRegistry(registry, role) {
+    return registry.filter((m) => roleAppliesTo(m.appliesTo, role));
 }
 function roleAppliesTo(appliesTo, role) {
     return appliesTo === "both" || appliesTo === role;
@@ -91,9 +91,6 @@ async function runWithConcurrency(names, maxConcurrency, signal, start) {
                 return;
             const name = names[i];
             if (signal.aborted) {
-                // Queued classifiers that never started are reported as not-run so
-                // the audit shows their fallback in `meta.classifiers`. In-flight
-                // classifiers receive the abort signal directly and resolve normally.
                 results[i] = {
                     ok: false,
                     name,
@@ -109,71 +106,22 @@ async function runWithConcurrency(names, maxConcurrency, signal, start) {
     await Promise.all(Array.from({ length: workerCount }, () => worker()));
     return results;
 }
-function collectFullEntries(settled, registry) {
+function collectResults(registry, settled) {
+    const fallbackByName = new Map();
+    for (const m of registry)
+        fallbackByName.set(m.name, m.fallback);
     const results = {};
-    const classifiers = {};
+    const failedClassifiers = [];
     for (const s of settled) {
-        const manifest = MODULES_BY_NAME[s.name];
-        const value = s.ok ? s.value : manifest.fallback;
-        results[s.name] = value;
-        classifiers[s.name] = {
-            ...value,
-            status: classifierRunStatus(s),
-            version: manifest.version,
-        };
-    }
-    return { results, meta: { classifiers, certainty: certaintySummary(results, registry) } };
-}
-function certaintySummary(results, registry) {
-    const scores = registry.map((m) => scoreCertainty(results[m.name]?.certainty));
-    if (scores.length === 0)
-        return { min: 0, avg: 0 };
-    const min = Math.min(...scores);
-    const avg = scores.reduce((sum, v) => sum + v, 0) / scores.length;
-    return { min, avg };
-}
-function scoreCertainty(certainty) {
-    return certainty === undefined ? 0 : certaintyScore[certainty];
-}
-function buildRouteResult(request, envelope, results, meta) {
-    const downstream = {
-        model_id: envelope.model_recommendation.id,
-        target_message: {
-            role: "user",
-            text: request.text,
-            hash: request.target_message_hash,
-        },
-        tools: envelope.tools ?? { tools: [] },
-    };
-    return {
-        action: "route",
-        target_message_hash: request.target_message_hash,
-        downstream,
-        classifier_outputs: classifierPublicOutputs(filteredRegistry("user"), results),
-        audit: {
-            ...envelope,
-            meta,
-        },
-    };
-}
-// Expose each classifier's payload — every output field except `reason` and
-// `certainty`. Iterates the supplied registry so we only surface classifiers
-// that actually ran for this role.
-function classifierPublicOutputs(registry, results) {
-    const out = {};
-    for (const manifest of registry) {
-        const result = results[manifest.name];
-        if (result === undefined)
-            continue;
-        out[manifest.name] = stripMetadata(result);
+        const fallback = fallbackByName.get(s.name);
+        if (fallback === undefined) {
+            throw new Error(`pipeline: classifier "${s.name}" missing from registry`);
+        }
+        results[s.name] = s.ok ? s.value : fallback;
+        if (!s.ok)
+            failedClassifiers.push(s.name);
     }
-    return out;
-}
-function stripMetadata(output) {
-    const { reason, certainty, ...payload } = output;
-    void reason;
-    void certainty;
-    return payload;
+    return { results, failedClassifiers };
 }
 async function runClassifierWithRetry(name, input, runClassifier, rootSignal, timeoutMs, retryCount) {
     let lastError = new Error(`${name} classifier did not run`);
@@ -219,16 +167,6 @@ async function runClassifierAttempt(name, input, runClassifier, rootSignal, time
             rootSignal.removeEventListener("abort", abortAttempt);
     }
 }
-function classifierRunStatus(settled) {
-    if (settled.ok)
-        return { ok: true, source: "model" };
-    return {
-        ok: false,
-        source: "fallback",
-        reason: settled.reason,
-        error: errorMessage(settled.error),
-    };
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/src/stock-validation.js

@@ -212,10 +212,14 @@ function validateFallback(raw, composedSchema, classifier, model) {
     if (!isRecord(raw)) {
         throwInvalid(classifier, model, "fallback must be a JSON object");
     }
-    // Fallback represents the "I have no signal" state, so reserved fields are
-    // optional. The composed schema already marks them optional except for
-    // reason/certainty.
-    const validate = ajv.compile(composedSchema);
+    // Fallback is the "no signal" state: only reason and certainty are required.
+    // Strip any custom `required` entries beyond those two so that reserved fields
+    // and output_schema.required fields don't force the fallback to emit values
+    // it cannot meaningfully provide when the classifier has failed.
+    const fallbackSchema = isRecord(composedSchema)
+        ? { ...composedSchema, required: ["reason", "certainty"] }
+        : composedSchema;
+    const validate = ajv.compile(fallbackSchema);
     if (!validate(raw)) {
         const message = formatSchemaErrors(validate.errors, "fallback");
         throwInvalid(classifier, model, `fallback is invalid: ${message}`);