open-classify 0.2.0 → 0.5.0

package/dist/src/classifiers.js

@@ -1,11 +1,13 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { buildStockClassifierPrompt } from "./stock-prompt.js";
+import { buildClassifierPrompt } from "./stock-prompt.js";
 import { validateJsonClassifierManifest, validateOutputForManifest, } from "./stock-validation.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLASSIFIERS_DIR = join(__dirname, "classifiers");
-const KIND_DIRS = ["stock", "custom"];
+// Directories whose names start with "_" are reserved for shared assets
+// (e.g. `_prompts/`) and are not loaded as classifiers.
+const SHARED_DIRECTORY_PREFIX = "_";
 export class ClassifierManifestError extends Error {
     constructor(message) {
         super(message);
@@ -17,62 +19,59 @@ export function loadClassifierRegistry(classifiersDir = CLASSIFIERS_DIR) {
         throw new ClassifierManifestError(`classifier directory not found: ${classifiersDir}`);
     }
     const manifests = [];
-    for (const kind of KIND_DIRS) {
-        const kindDir = join(classifiersDir, kind);
-        if (!existsSync(kindDir))
+    for (const entry of readdirSync(classifiersDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
             continue;
-        for (const entry of readdirSync(kindDir, { withFileTypes: true })) {
-            if (!entry.isDirectory())
-                continue;
-            if (kind === "stock" && entry.name === "prompts")
-                continue;
-            manifests.push(loadClassifierManifest(join(kindDir, entry.name), kind));
-        }
+        if (entry.name.startsWith(SHARED_DIRECTORY_PREFIX))
+            continue;
+        manifests.push(loadClassifierManifest(join(classifiersDir, entry.name)));
     }
-    manifests.sort((a, b) => a.order - b.order);
+    // Lower dispatch_order runs first. Classifiers without dispatch_order sort
+    // last (treated as +Infinity) — useful for "run me whenever there's a slot".
+    manifests.sort((a, b) => (a.dispatch_order ?? Infinity) - (b.dispatch_order ?? Infinity));
     validateRegistry(manifests);
     return manifests;
 }
-function loadClassifierManifest(classifierDir, expectedKind) {
+function loadClassifierManifest(classifierDir) {
     const manifestPath = join(classifierDir, "manifest.json");
     const promptPath = join(classifierDir, "prompt.md");
     if (!existsSync(manifestPath)) {
         throw new ClassifierManifestError(`missing manifest.json in ${classifierDir}`);
     }
-    if (expectedKind === "custom" && !existsSync(promptPath)) {
+    if (!existsSync(promptPath)) {
         throw new ClassifierManifestError(`missing prompt.md in ${classifierDir}`);
     }
     const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    const manifest = validateJsonClassifierManifest(parsed, manifestPath);
-    if (manifest.kind !== expectedKind) {
-        throw new ClassifierManifestError(`${manifestPath}: manifest kind "${manifest.kind}" does not match parent directory "${expectedKind}"`);
-    }
+    const { manifest, reservedFields, composedOutputSchema, appliesTo } = validateJsonClassifierManifest(parsed, manifestPath);
     const directoryName = basename(classifierDir);
     if (manifest.name !== directoryName) {
         throw new ClassifierManifestError(`${manifestPath}: manifest name "${manifest.name}" does not match directory "${directoryName}"`);
     }
-    let systemPrompt = buildStockClassifierPrompt(manifest);
-    if (manifest.kind === "custom") {
-        const classifierPrompt = readFileSync(promptPath, "utf8").trim();
-        if (classifierPrompt.length === 0) {
-            throw new ClassifierManifestError(`prompt.md must not be empty: ${promptPath}`);
-        }
-        systemPrompt = `${systemPrompt}\n\nClassifier guidance:\n${classifierPrompt}`;
+    const classifierPromptText = readFileSync(promptPath, "utf8");
+    if (classifierPromptText.trim().length === 0) {
+        throw new ClassifierManifestError(`prompt.md must not be empty: ${promptPath}`);
     }
-    return { ...manifest, systemPrompt };
+    const systemPrompt = buildClassifierPrompt({
+        manifest,
+        reservedFields,
+        appliesTo,
+        classifierPromptText,
+    });
+    return {
+        ...manifest,
+        systemPrompt,
+        composedOutputSchema,
+        reservedFields,
+        appliesTo,
+    };
 }
 function validateRegistry(manifests) {
     const names = new Set();
-    const orders = new Set();
     for (const manifest of manifests) {
         if (names.has(manifest.name)) {
             throw new ClassifierManifestError(`duplicate classifier name: ${manifest.name}`);
         }
         names.add(manifest.name);
-        if (orders.has(manifest.order)) {
-            throw new ClassifierManifestError(`duplicate classifier order: ${manifest.order}`);
-        }
-        orders.add(manifest.order);
     }
 }
 export const REGISTRY = loadClassifierRegistry();

package/dist/src/classify.d.ts

@@ -1,10 +1,17 @@
 import { type RunClassifier } from "./classifiers.js";
 import { type OpenClassifyConfig } from "./config.js";
-import type { AggregatorConfig, Catalog, PipelineResult } from "./manifest.js";
+import type { AggregatorConfig, Catalog, InspectResult, PipelineResult } from "./manifest.js";
 import type { OpenClassifyInput } from "./types.js";
 export type Classifier = (input: OpenClassifyInput, options?: {
     signal?: AbortSignal;
 }) => Promise<PipelineResult>;
+export type Inspector = (input: OpenClassifyInput, options?: {
+    signal?: AbortSignal;
+}) => Promise<InspectResult>;
+export interface OpenClassify {
+    readonly classify: Classifier;
+    readonly inspect: Inspector;
+}
 export interface CreateClassifierOptions {
     runClassifier?: RunClassifier;
     catalog?: Catalog;
@@ -17,6 +24,7 @@ export interface CreateClassifierOptions {
     fetch?: typeof fetch;
     classifierTimeoutMs?: number;
     classifierRetryCount?: number;
+    maxConcurrency?: number;
     aggregator?: AggregatorConfig;
 }
-export declare function createClassifier(options?: CreateClassifierOptions): Classifier;
+export declare function createClassifier(options?: CreateClassifierOptions): OpenClassify;

package/dist/src/classify.js

@@ -1,11 +1,11 @@
 // High-level facade for the pipeline. Builds the runner and catalog once,
-// then returns a closure callers can invoke many times without re-loading
-// config or the catalog from disk. Backend-agnostic: pass a custom
-// `runClassifier` to bypass the bundled Ollama runner entirely.
+// 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 { assertOllamaResources, createOllamaClassifierRunner, OLLAMA_DEFAULT_CATALOG_PATH, } from "./ollama.js";
-import { classifyOpenClassifyInput } from "./pipeline.js";
+import { classifyOpenClassifyInput, inspectOpenClassifyInput, } from "./pipeline.js";
 export function createClassifier(options = {}) {
     const fileConfig = options.config ??
         loadOpenClassifyConfig(options.configPath, {
@@ -30,21 +30,36 @@ export function createClassifier(options = {}) {
         loadCatalog(options.catalogPath ?? fileConfig?.catalog ?? OLLAMA_DEFAULT_CATALOG_PATH);
     const aggregator = options.aggregator ?? fileConfig?.aggregator;
     let resourceCheck;
-    return async (input, callOptions) => {
-        if (needsResourceCheck) {
-            resourceCheck ??= assertOllamaResources({
-                minTotalMemoryBytes: options.minTotalMemoryBytes,
-                minAvailableMemoryBytes: options.minAvailableMemoryBytes,
-            });
-            await resourceCheck;
-        }
+    const ensureResources = async () => {
+        if (!needsResourceCheck)
+            return;
+        resourceCheck ??= assertOllamaResources({
+            minTotalMemoryBytes: options.minTotalMemoryBytes,
+            minAvailableMemoryBytes: options.minAvailableMemoryBytes,
+        });
+        await resourceCheck;
+    };
+    const classify = async (input, callOptions) => {
+        await ensureResources();
         return classifyOpenClassifyInput(input, {
             runClassifier,
             catalog,
             classifierTimeoutMs: options.classifierTimeoutMs,
             classifierRetryCount: options.classifierRetryCount,
+            maxConcurrency: options.maxConcurrency,
             aggregator,
             signal: callOptions?.signal,
         });
     };
+    const inspect = async (input, callOptions) => {
+        await ensureResources();
+        return inspectOpenClassifyInput(input, {
+            runClassifier,
+            classifierTimeoutMs: options.classifierTimeoutMs,
+            classifierRetryCount: options.classifierRetryCount,
+            maxConcurrency: options.maxConcurrency,
+            signal: callOptions?.signal,
+        });
+    };
+    return { classify, inspect };
 }

package/dist/src/config.d.ts

@@ -16,10 +16,7 @@ export interface OllamaRunnerConfig {
         readonly seed?: number;
         readonly num_ctx?: number;
     };
-    readonly models?: {
-        readonly stock?: Readonly<Record<string, string>>;
-        readonly custom?: Readonly<Record<string, string>>;
-    };
+    readonly models?: Readonly<Record<string, string>>;
 }
 export declare class OpenClassifyConfigError extends Error {
     constructor(message: string);

package/dist/src/config.js

@@ -1,7 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { REGISTRY } from "./classifiers.js";
-import { CERTAINTY_GATE_MODES, } from "./manifest.js";
-import { STOCK_CLASSIFIER_NAMES } from "./stock.js";
+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 {
@@ -26,13 +24,7 @@ export function loadOpenClassifyConfig(path = process.env.OPEN_CLASSIFY_CONFIG ?
     return validateOpenClassifyConfig(parsed, path);
 }
 export function classifierModelsFromConfig(config) {
-    const models = config?.runner?.models;
-    if (!models)
-        return {};
-    return {
-        ...models.stock,
-        ...models.custom,
-    };
+    return { ...config?.runner?.models };
 }
 export function validateOpenClassifyConfig(value, path = "open-classify config") {
     if (!isRecord(value)) {
@@ -49,7 +41,7 @@ function validateAggregator(value, path) {
     if (!isRecord(value)) {
         throwConfig(path, "aggregator must be an object");
     }
-    ensureAllowedKeys(value, ["certaintyThreshold", "confidenceThreshold", "certaintyGate"], path, "aggregator");
+    ensureAllowedKeys(value, ["certaintyThreshold", "confidenceThreshold"], path, "aggregator");
     return {
         ...(value.certaintyThreshold === undefined
             ? {}
@@ -57,9 +49,6 @@ function validateAggregator(value, path) {
         ...(value.confidenceThreshold === undefined
             ? {}
             : { confidenceThreshold: requireUnitFloat(value.confidenceThreshold, path, "aggregator.confidenceThreshold") }),
-        ...(value.certaintyGate === undefined
-            ? {}
-            : { certaintyGate: requireCertaintyGateMode(value.certaintyGate, path, "aggregator.certaintyGate") }),
     };
 }
 function validateRunner(value, path) {
@@ -107,37 +96,16 @@ function validateModels(value, path) {
     if (!isRecord(value)) {
         throwConfig(path, "runner.models must be an object");
     }
-    ensureAllowedKeys(value, ["stock", "custom"], path, "runner.models");
-    return {
-        ...(value.stock === undefined
-            ? {}
-            : { stock: validateModelMap(value.stock, path, "runner.models.stock", stockClassifierNames()) }),
-        ...(value.custom === undefined
-            ? {}
-            : { custom: validateModelMap(value.custom, path, "runner.models.custom", customClassifierNames()) }),
-    };
-}
-function validateModelMap(value, path, field, allowedNames) {
-    if (!isRecord(value)) {
-        throwConfig(path, `${field} must be an object`);
-    }
+    const allowed = new Set(CLASSIFIER_NAMES);
     const out = {};
     for (const [name, model] of Object.entries(value)) {
-        if (!allowedNames.has(name)) {
-            throwConfig(path, `${field}.${name} is not a known classifier`);
+        if (!allowed.has(name)) {
+            throwConfig(path, `runner.models.${name} is not a known classifier`);
         }
-        out[name] = requireString(model, path, `${field}.${name}`);
+        out[name] = requireString(model, path, `runner.models.${name}`);
     }
     return out;
 }
-function stockClassifierNames() {
-    return new Set(STOCK_CLASSIFIER_NAMES);
-}
-function customClassifierNames() {
-    return new Set(REGISTRY
-        .filter((classifier) => classifier.kind === "custom")
-        .map((classifier) => classifier.name));
-}
 function requireString(value, path, field) {
     if (typeof value !== "string" || value.trim().length === 0) {
         throwConfig(path, `${field} must be a non-empty string`);
@@ -157,12 +125,6 @@ function requireUnitFloat(value, path, field) {
     }
     return number;
 }
-function requireCertaintyGateMode(value, path, field) {
-    if (typeof value !== "string" || !CERTAINTY_GATE_MODES.includes(value)) {
-        throwConfig(path, `${field} must be one of ${CERTAINTY_GATE_MODES.join(", ")}`);
-    }
-    return value;
-}
 function ensureAllowedKeys(value, allowedKeys, path, field) {
     const allowed = new Set(allowedKeys);
     for (const key of Object.keys(value)) {

package/dist/src/index.d.ts

@@ -8,6 +8,7 @@ export * from "./input.js";
 export * from "./manifest.js";
 export * from "./ollama.js";
 export * from "./pipeline.js";
+export * from "./reserved-fields.js";
 export * from "./stock.js";
 export * from "./stock-prompt.js";
 export * from "./stock-validation.js";

package/dist/src/index.js

@@ -13,6 +13,7 @@ export * from "./input.js";
 export * from "./manifest.js";
 export * from "./ollama.js";
 export * from "./pipeline.js";
+export * from "./reserved-fields.js";
 export * from "./stock.js";
 export * from "./stock-prompt.js";
 export * from "./stock-validation.js";

package/dist/src/input.d.ts

@@ -1,4 +1,7 @@
 import type { ClassifierInput, NormalizedOpenClassifyInput, OpenClassifyInput } from "./types.js";
 export declare function sanitizeText(raw: string): string;
-export declare function normalizeOpenClassifyInput(input: OpenClassifyInput): NormalizedOpenClassifyInput;
+export interface NormalizeOptions {
+    readonly expectedRole?: "user" | "assistant";
+}
+export declare function normalizeOpenClassifyInput(input: OpenClassifyInput, options?: NormalizeOptions): NormalizedOpenClassifyInput;
 export declare function toClassifierInput(normalized: NormalizedOpenClassifyInput): ClassifierInput;

package/dist/src/input.js

@@ -51,10 +51,11 @@ export function sanitizeText(raw) {
 function hashCanonicalValue(value) {
     return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 8);
 }
-export function normalizeOpenClassifyInput(input) {
+export function normalizeOpenClassifyInput(input, options = {}) {
     assertPlainObject(input, "input");
     rejectUnknownFields(input, INPUT_FIELDS, "input");
-    const messages = normalizeMessages(input.messages);
+    const expectedRole = options.expectedRole ?? "user";
+    const messages = normalizeMessages(input.messages, expectedRole);
     const target = messages[messages.length - 1];
     const text = target.text;
     const normalized = {
@@ -63,7 +64,7 @@ export function normalizeOpenClassifyInput(input) {
         target_message_hash: "",
     };
     normalized.target_message_hash = hashCanonicalValue({
-        role: target.role ?? "user",
+        role: target.role ?? expectedRole,
         text,
     });
     return normalized;
@@ -75,14 +76,14 @@ export function toClassifierInput(normalized) {
         target_message_hash: normalized.target_message_hash,
     };
 }
-function normalizeMessages(messages) {
+function normalizeMessages(messages, expectedRole) {
     if (!Array.isArray(messages)) {
         throw new TypeError("input.messages must be an array");
     }
     if (messages.length === 0) {
         throw new Error("input.messages must contain at least one message");
     }
-    return takeNewestWholeMessagesThatFit(messages);
+    return takeNewestWholeMessagesThatFit(messages, expectedRole);
 }
 function normalizeConversationMessage(message, path) {
     assertPlainObject(message, path);
@@ -104,12 +105,13 @@ function normalizeConversationMessage(message, path) {
 // Walk the message history newest → oldest, keeping whole messages while
 // we're under both the count cap and the character budget. The final
 // message is non-negotiable (it's what we're classifying) — we validate it
-// stricter, force role=user, and never drop it on length grounds.
+// stricter, force role to the expected one, and never drop it on length
+// grounds.
 //
 // We never slice text inside a message: classifiers depend on the full
 // final message, and slicing earlier ones at arbitrary boundaries tends to
 // confuse models more than it helps.
-function takeNewestWholeMessagesThatFit(messages) {
+function takeNewestWholeMessagesThatFit(messages, expectedRole) {
     const selected = [];
     let totalChars = 0;
     for (let index = messages.length - 1; index >= 0; index -= 1) {
@@ -119,10 +121,10 @@ function takeNewestWholeMessagesThatFit(messages) {
             if (normalized.text.length === 0) {
                 throw new Error("final message is empty after sanitization");
             }
-            if (normalized.role !== undefined && normalized.role !== "user") {
-                throw new Error("final message must have role user");
+            if (normalized.role !== undefined && normalized.role !== expectedRole) {
+                throw new Error(`final message must have role ${expectedRole}`);
             }
-            normalized.role = "user";
+            normalized.role = expectedRole;
             if (normalized.text.length > CONVERSATION_TEXT_MAX_CHARS) {
                 throw new RangeError(`final message must be ${CONVERSATION_TEXT_MAX_CHARS} characters or fewer`);
             }

package/dist/src/manifest.d.ts

@@ -1,10 +1,8 @@
-import type { AckReplySignal, ClassifierOutput, CustomClassifierOutput, FinalReplySignal, PromptInjectionSignal, RoutingSignal, RuntimeClassifierManifest, ToolsSignal } from "./stock.js";
+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";
 export type ClassifierName = string;
 export type ClassifierResults = Record<ClassifierName, ClassifierOutput>;
-export declare const CERTAINTY_GATE_MODES: readonly ["min_score", "avg_score", "off"];
-export type CertaintyGateMode = (typeof CERTAINTY_GATE_MODES)[number];
 export type RunClassifier = (name: ClassifierName, input: ClassifierInput, signal: AbortSignal) => Promise<ClassifierOutput>;
 export interface CatalogEntry {
     readonly id: string;
@@ -22,11 +20,11 @@ export interface Catalog {
 }
 export interface ModelRecommendationResolution {
     readonly constraints_used: Partial<{
-        specialization: ModelSpecialization;
-        tier: DownstreamModelTier;
+        model_specialization: ModelSpecialization;
+        model_tier: DownstreamModelTier;
     }>;
     readonly constraints_dropped: ReadonlyArray<{
-        readonly axis: "specialization" | "tier";
+        readonly axis: "model_specialization" | "model_tier";
         readonly reason: "low_confidence" | "no_match_relaxed" | "default_fallback";
     }>;
     readonly confidences: Partial<{
@@ -49,10 +47,10 @@ export interface Envelope {
     readonly routing?: RoutingSignal;
     readonly tools?: ToolsSignal;
     readonly prompt_injection?: PromptInjectionSignal;
-    readonly custom_outputs: ReadonlyArray<CustomClassifierOutput>;
+    readonly classifier_outputs: ReadonlyArray<ClassifierAuditOutput>;
     readonly model_recommendation: ModelRecommendation;
 }
-export type ClassifierCustomOutputs = Record<string, unknown>;
+export type ClassifierPublicOutputs = Record<string, Record<string, unknown>>;
 export interface DownstreamTargetMessage {
     readonly role: "user";
     readonly text: string;
@@ -67,57 +65,31 @@ 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;
-    readonly fired_by?: string;
-    readonly certainty_gate?: LowCertaintyBlockReason;
-}
-export type BlockReason = PromptInjectionBlockReason | LowCertaintyBlockReason;
-export interface PromptInjectionBlockReason {
-    readonly kind: "prompt_injection";
-    readonly risk_level: PromptInjectionSignal["risk_level"];
 }
-export interface LowCertaintyBlockReason {
-    readonly kind: "low_certainty";
-    readonly mode: Exclude<CertaintyGateMode, "off">;
-    readonly threshold: number;
-    readonly score: number;
-    readonly classifier_scores: Readonly<Record<string, number>>;
-    readonly low_classifiers: ReadonlyArray<string>;
+export interface InspectResult {
+    readonly target_message_hash: string;
+    readonly classifier_outputs: ClassifierPublicOutputs;
 }
-export type ReplyPipelineResult = {
-    readonly action: "reply";
-    readonly message_id: string;
-    readonly reply: {
-        readonly text: string;
-    };
-    readonly reason: "preflight_reply";
-    readonly classifier_outputs: ClassifierCustomOutputs;
-    readonly audit: Pick<PipelineAudit, "final_reply" | "meta" | "fired_by">;
-};
-export type BlockPipelineResult = {
-    readonly action: "block";
-    readonly message_id: string;
-    readonly fired_by?: string;
-    readonly reason: BlockReason;
-    readonly classifier_outputs: ClassifierCustomOutputs;
-    readonly audit: Pick<PipelineAudit, "prompt_injection" | "meta" | "fired_by" | "certainty_gate">;
-};
-export type RoutePipelineResult = {
+export interface PipelineResult {
     readonly action: "route";
-    readonly message_id: string;
+    readonly target_message_hash: string;
     readonly downstream: DownstreamPayload;
-    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly classifier_outputs: ClassifierPublicOutputs;
     readonly audit: PipelineAudit;
-};
-export type PipelineResult = ReplyPipelineResult | BlockPipelineResult | RoutePipelineResult;
+}
 export interface AggregatorConfig {
     readonly certaintyThreshold?: number;
     /** @deprecated Use certaintyThreshold. */
     readonly confidenceThreshold?: number;
-    readonly certaintyGate?: CertaintyGateMode;
 }
 export type ClassifierRegistry = ReadonlyArray<RuntimeClassifierManifest>;

package/dist/src/manifest.js

@@ -1,5 +1 @@
-export const CERTAINTY_GATE_MODES = [
-    "min_score",
-    "avg_score",
-    "off",
-];
+export {};

package/dist/src/pipeline.d.ts

@@ -1,9 +1,9 @@
 import { type RunClassifier } from "./classifiers.js";
-import type { AggregatorConfig, Catalog, PipelineResult } from "./manifest.js";
+import type { AggregatorConfig, Catalog, 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;
-export declare const DEFAULT_CERTAINTY_GATE = "min_score";
+export declare const DEFAULT_MAX_CONCURRENCY = 7;
 export declare class OpenClassifyNormalizationError extends Error {
     constructor(cause: unknown);
 }
@@ -12,7 +12,16 @@ export interface ClassifyOptions {
     catalog: Catalog;
     classifierTimeoutMs?: number;
     classifierRetryCount?: number;
+    maxConcurrency?: number;
     aggregator?: AggregatorConfig;
     signal?: AbortSignal;
 }
+export interface InspectOptions {
+    runClassifier: RunClassifier;
+    classifierTimeoutMs?: number;
+    classifierRetryCount?: number;
+    maxConcurrency?: number;
+    signal?: AbortSignal;
+}
 export declare function classifyOpenClassifyInput(input: OpenClassifyInput, options: ClassifyOptions): Promise<PipelineResult>;
+export declare function inspectOpenClassifyInput(input: OpenClassifyInput, options: InspectOptions): Promise<InspectResult>;