open-classify 0.1.0

package/dist/src/config.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync } from "node:fs";
+import { REGISTRY } from "./classifiers.js";
+import { STOCK_CLASSIFIER_NAMES } from "./stock.js";
+import { isRecord } from "./validation.js";
+export const DEFAULT_OPEN_CLASSIFY_CONFIG_PATH = "open-classify.config.json";
+export class OpenClassifyConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OpenClassifyConfigError";
+    }
+}
+export function loadOpenClassifyConfig(path = process.env.OPEN_CLASSIFY_CONFIG ?? DEFAULT_OPEN_CLASSIFY_CONFIG_PATH, options = {}) {
+    if (!existsSync(path)) {
+        if (options.optional)
+            return undefined;
+        throw new OpenClassifyConfigError(`config file not found: ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new OpenClassifyConfigError(`${path}: invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return validateOpenClassifyConfig(parsed, path);
+}
+export function classifierModelsFromConfig(config) {
+    const models = config?.runner?.models;
+    if (!models)
+        return {};
+    return {
+        ...models.stock,
+        ...models.custom,
+    };
+}
+export function validateOpenClassifyConfig(value, path = "open-classify config") {
+    if (!isRecord(value)) {
+        throwConfig(path, "config must be a JSON object");
+    }
+    ensureAllowedKeys(value, ["runner", "catalog"], path, "<root>");
+    return {
+        ...(value.runner === undefined ? {} : { runner: validateRunner(value.runner, path) }),
+        ...(value.catalog === undefined ? {} : { catalog: requireString(value.catalog, path, "catalog") }),
+    };
+}
+function validateRunner(value, path) {
+    if (!isRecord(value)) {
+        throwConfig(path, "runner must be an object");
+    }
+    ensureAllowedKeys(value, ["provider", "host", "defaultModel", "options", "models"], path, "runner");
+    const provider = value.provider === undefined
+        ? "ollama"
+        : requireString(value.provider, path, "runner.provider");
+    if (provider !== "ollama") {
+        throwConfig(path, `runner.provider must be "ollama"`);
+    }
+    return {
+        provider: "ollama",
+        ...(value.host === undefined ? {} : { host: requireString(value.host, path, "runner.host") }),
+        ...(value.defaultModel === undefined
+            ? {}
+            : { defaultModel: requireString(value.defaultModel, path, "runner.defaultModel") }),
+        ...(value.options === undefined ? {} : { options: validateOptions(value.options, path) }),
+        ...(value.models === undefined ? {} : { models: validateModels(value.models, path) }),
+    };
+}
+function validateOptions(value, path) {
+    if (!isRecord(value)) {
+        throwConfig(path, "runner.options must be an object");
+    }
+    ensureAllowedKeys(value, ["temperature", "top_p", "seed", "num_ctx"], path, "runner.options");
+    return {
+        ...(value.temperature === undefined
+            ? {}
+            : { temperature: requireNumber(value.temperature, path, "runner.options.temperature") }),
+        ...(value.top_p === undefined
+            ? {}
+            : { top_p: requireNumber(value.top_p, path, "runner.options.top_p") }),
+        ...(value.seed === undefined
+            ? {}
+            : { seed: requireNumber(value.seed, path, "runner.options.seed") }),
+        ...(value.num_ctx === undefined
+            ? {}
+            : { num_ctx: requireNumber(value.num_ctx, path, "runner.options.num_ctx") }),
+    };
+}
+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 out = {};
+    for (const [name, model] of Object.entries(value)) {
+        if (!allowedNames.has(name)) {
+            throwConfig(path, `${field}.${name} is not a known classifier`);
+        }
+        out[name] = requireString(model, path, `${field}.${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`);
+    }
+    return value;
+}
+function requireNumber(value, path, field) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throwConfig(path, `${field} must be a finite number`);
+    }
+    return value;
+}
+function ensureAllowedKeys(value, allowedKeys, path, field) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throwConfig(path, `${field}.${key} is not a supported field`);
+        }
+    }
+}
+function throwConfig(path, message) {
+    throw new OpenClassifyConfigError(`${path}: ${message}`);
+}

package/dist/src/enums.d.ts

@@ -0,0 +1,10 @@
+export declare const DOWNSTREAM_MODEL_TIER_VALUES: readonly ["local_fast", "local_small", "local_strong", "local_coding", "frontier_fast", "frontier_strong", "frontier_coding"];
+export type DownstreamModelTier = (typeof DOWNSTREAM_MODEL_TIER_VALUES)[number];
+export declare const MODEL_SPECIALIZATION_VALUES: readonly ["agentic_coding", "agentic_workflows", "chat", "code_fixing", "code_reasoning", "code_review", "writing", "reasoning", "planning", "coding", "computer_use", "debugging", "instruction_following", "question_answering", "subagents", "summarization", "tool_assisted_coding", "vision_input"];
+export type ModelSpecialization = (typeof MODEL_SPECIALIZATION_VALUES)[number];
+export declare const SECURITY_DECISION_VALUES: readonly ["allow", "block", "needs_review"];
+export type SecurityDecision = (typeof SECURITY_DECISION_VALUES)[number];
+export declare const SECURITY_RISK_LEVEL_VALUES: readonly ["normal", "suspicious", "high_risk", "unknown"];
+export type SecurityRiskLevel = (typeof SECURITY_RISK_LEVEL_VALUES)[number];
+export declare const SECURITY_SIGNAL_VALUES: readonly ["instruction_attack", "secret_or_private_data_risk", "unsafe_tool_or_action", "untrusted_content_or_code", "injection_or_obfuscation"];
+export type SecuritySignal = (typeof SECURITY_SIGNAL_VALUES)[number];

package/dist/src/enums.js

@@ -0,0 +1,62 @@
+// Shared categorical enums used by more than one classifier or by the
+// catalog. Each enum is exported twice: once as a `*_VALUES` array (used by
+// validators and tests) and once as a string-literal union type derived from
+// the array via `(typeof X)[number]`. Keep the array and the type in sync.
+//
+// Classifier outputs omit uncertain optional fields rather than emitting an
+// escape-hatch value, so these enums list only concrete choices.
+// Coarse capability+latency tier for the downstream model. Callers map these
+// onto concrete model names via the catalog.
+export const DOWNSTREAM_MODEL_TIER_VALUES = [
+    "local_fast",
+    "local_small",
+    "local_strong",
+    "local_coding",
+    "frontier_fast",
+    "frontier_strong",
+    "frontier_coding",
+];
+// Which kind of model/prompt specialization fits the request best. Combined
+// with the tier to look up a concrete model in the catalog.
+export const MODEL_SPECIALIZATION_VALUES = [
+    "agentic_coding",
+    "agentic_workflows",
+    "chat",
+    "code_fixing",
+    "code_reasoning",
+    "code_review",
+    "writing",
+    "reasoning",
+    "planning",
+    "coding",
+    "computer_use",
+    "debugging",
+    "instruction_following",
+    "question_answering",
+    "subagents",
+    "summarization",
+    "tool_assisted_coding",
+    "vision_input",
+];
+export const SECURITY_DECISION_VALUES = [
+    "allow",
+    "block",
+    "needs_review",
+];
+// Overall safety posture on the latest user message. Security short-circuiting
+// is driven by safety.decision, not risk level alone.
+export const SECURITY_RISK_LEVEL_VALUES = [
+    "normal",
+    "suspicious",
+    "high_risk",
+    "unknown",
+];
+// Specific safety concerns the security classifier can flag. These are
+// advisory; safety.decision controls whether the pipeline blocks or needs review.
+export const SECURITY_SIGNAL_VALUES = [
+    "instruction_attack",
+    "secret_or_private_data_risk",
+    "unsafe_tool_or_action",
+    "untrusted_content_or_code",
+    "injection_or_obfuscation",
+];

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./aggregator.js";
+export * from "./catalog.js";
+export * from "./classifiers.js";
+export * from "./config.js";
+export * from "./enums.js";
+export * from "./input.js";
+export * from "./manifest.js";
+export * from "./ollama.js";
+export * from "./pipeline.js";
+export * from "./stock.js";
+export * from "./stock-prompt.js";
+export * from "./stock-validation.js";
+export * from "./types.js";

package/dist/src/index.js

@@ -0,0 +1,18 @@
+// 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 confidence threshold — 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";
+export * from "./config.js";
+export * from "./enums.js";
+export * from "./input.js";
+export * from "./manifest.js";
+export * from "./ollama.js";
+export * from "./pipeline.js";
+export * from "./stock.js";
+export * from "./stock-prompt.js";
+export * from "./stock-validation.js";
+export * from "./types.js";

package/dist/src/input.d.ts

@@ -0,0 +1,4 @@
+import type { ClassifierInput, NormalizedOpenClassifyInput, OpenClassifyInput } from "./types.js";
+export declare function sanitizeText(raw: string): string;
+export declare function normalizeOpenClassifyInput(input: OpenClassifyInput): NormalizedOpenClassifyInput;
+export declare function toClassifierInput(normalized: NormalizedOpenClassifyInput): ClassifierInput;

package/dist/src/input.js

@@ -0,0 +1,192 @@
+// Input normalization. This module enforces the Open Classify input contract
+// before anything model-shaped happens: structural shape, allowed fields,
+// sanitized text, payload budget, and a stable target-message hash. Anything
+// that throws here surfaces as `OpenClassifyNormalizationError` to callers.
+import { createHash } from "node:crypto";
+/*
+ * Message text budget:
+ *
+ * Gemma 4 E4B supports a native 131,072-token (128K) context window. Open
+ * Classify does not use that full window in the reference local runtime: it
+ * runs the classifier set in parallel with a configured 4,096-token context.
+ * The largest fixed classifier prompt is security at about 1,748 estimated
+ * tokens using the same 3 chars/token heuristic as the Ollama packer. We round
+ * that up to 2,000 fixed-prompt tokens, reserve roughly 400 tokens for output,
+ * chat-template variance, and estimation error, then spend the remainder on
+ * sanitized conversation text:
+ *
+ *   4,096 - 2,000 - 400 = 1,696 text tokens
+ *   1,696 * 3 chars/token = 5,088 chars
+ *
+ * Use a round 5,000-character API budget. The Ollama runner still validates the
+ * fully rendered prompt for the configured num_ctx and drops older whole
+ * context messages when a caller overrides num_ctx lower.
+ */
+const CONVERSATION_TEXT_MAX_CHARS = 5_000;
+const MESSAGE_HISTORY_MAX_COUNT = 20;
+const INPUT_FIELDS = new Set([
+    "messages",
+]);
+const CONVERSATION_MESSAGE_FIELDS = new Set([
+    "role",
+    "text",
+]);
+// Strip the BOM, normalize composed/decomposed Unicode (so "café" never has
+// two encodings), drop control chars except tab/newline/CR, and trim. Tabs
+// and newlines are kept because they're load-bearing in code/markdown
+// snippets that users paste in.
+export function sanitizeText(raw) {
+    let text = raw;
+    if (text.charCodeAt(0) === 0xfeff) {
+        text = text.slice(1);
+    }
+    return text
+        .normalize("NFC")
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
+        .trim();
+}
+// 8-hex-char fingerprint of the canonicalized value. Short on purpose —
+// this is for correlation/dedup, not cryptographic identity. Canonicalization
+// (sorted keys, undefined-stripped) makes the hash stable across input order.
+function hashCanonicalValue(value) {
+    return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 8);
+}
+export function normalizeOpenClassifyInput(input) {
+    assertPlainObject(input, "input");
+    rejectUnknownFields(input, INPUT_FIELDS, "input");
+    const messages = normalizeMessages(input.messages);
+    const target = messages[messages.length - 1];
+    const text = target.text;
+    const normalized = {
+        messages,
+        text,
+        target_message_hash: "",
+    };
+    normalized.target_message_hash = hashCanonicalValue({
+        role: target.role ?? "user",
+        text,
+    });
+    return normalized;
+}
+export function toClassifierInput(normalized) {
+    return {
+        text: normalized.text,
+        messages: normalized.messages,
+        target_message_hash: normalized.target_message_hash,
+    };
+}
+function normalizeMessages(messages) {
+    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);
+}
+function normalizeConversationMessage(message, path) {
+    assertPlainObject(message, path);
+    rejectUnknownFields(message, CONVERSATION_MESSAGE_FIELDS, path);
+    if (typeof message.text !== "string") {
+        throw new TypeError(`${path}.text must be a string`);
+    }
+    const normalized = {
+        text: sanitizeText(message.text),
+    };
+    if (message.role !== undefined) {
+        if (!["user", "assistant"].includes(message.role)) {
+            throw new TypeError(`${path}.role must be user or assistant`);
+        }
+        normalized.role = message.role;
+    }
+    return normalized;
+}
+// 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.
+//
+// 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) {
+    const selected = [];
+    let totalChars = 0;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const normalized = normalizeConversationMessage(messages[index], `input.messages[${index}]`);
+        const isFinalMessage = index === messages.length - 1;
+        if (isFinalMessage) {
+            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");
+            }
+            normalized.role = "user";
+            if (normalized.text.length > CONVERSATION_TEXT_MAX_CHARS) {
+                throw new RangeError(`final message must be ${CONVERSATION_TEXT_MAX_CHARS} characters or fewer`);
+            }
+        }
+        else if (normalized.text.length === 0) {
+            continue;
+        }
+        if (!isFinalMessage && selected.length >= MESSAGE_HISTORY_MAX_COUNT) {
+            break;
+        }
+        if (!isFinalMessage && totalChars + normalized.text.length > CONVERSATION_TEXT_MAX_CHARS) {
+            break;
+        }
+        selected.push(normalized);
+        totalChars += normalized.text.length;
+    }
+    return selected.reverse();
+}
+// Reject class instances and prototype-tampered objects, not just non-objects.
+// We want plain `{}` shapes here — anything carrying behavior or an exotic
+// prototype could surprise the JSON serializer or smuggle properties past
+// `rejectUnknownFields`.
+function assertPlainObject(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${path} must be a plain object`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${path} must be a plain object`);
+    }
+}
+function rejectUnknownFields(value, allowedFields, path) {
+    for (const key of Object.keys(value)) {
+        if (!allowedFields.has(key)) {
+            throw new TypeError(`${path}.${key} is not a supported field`);
+        }
+    }
+}
+function canonicalJson(value) {
+    return JSON.stringify(canonicalize(value));
+}
+// Recursive deep-sort of object keys + drop of `undefined` values. Used by
+// `hashCanonicalValue` so the hash is invariant under input key ordering —
+// `{a:1,b:2}` and `{b:2,a:1}` produce the same fingerprint.
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+        const child = value[key];
+        if (child !== undefined) {
+            result[key] = canonicalize(child);
+        }
+    }
+    return result;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/src/manifest.d.ts

@@ -0,0 +1,115 @@
+import type { AckReplySignal, ClassifierOutput, CustomClassifierOutput, FinalReplySignal, RoutingSignal, RuntimeClassifierManifest, SafetySignal, 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 type RunClassifier = (name: ClassifierName, input: ClassifierInput, signal: AbortSignal) => Promise<ClassifierOutput>;
+export interface CatalogEntry {
+    readonly id: string;
+    readonly specializations: ReadonlyArray<ModelSpecialization>;
+    readonly tier: DownstreamModelTier;
+    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;
+}
+export interface Catalog {
+    readonly models: ReadonlyArray<CatalogEntry>;
+    readonly default: string;
+}
+export interface ModelRecommendationResolution {
+    readonly constraints_used: Partial<{
+        specialization: ModelSpecialization;
+        tier: DownstreamModelTier;
+    }>;
+    readonly constraints_dropped: ReadonlyArray<{
+        readonly axis: "specialization" | "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 safety?: SafetySignal;
+    readonly custom_outputs: ReadonlyArray<CustomClassifierOutput>;
+    readonly model_recommendation: ModelRecommendation;
+}
+export type ClassifierCustomOutputs = Record<string, unknown>;
+export interface DownstreamTargetMessage {
+    readonly role: "user";
+    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 PipelineMeta {
+    readonly classifiers: Record<string, ClassifierEntry>;
+}
+export interface PipelineAudit extends Envelope {
+    readonly meta: PipelineMeta;
+    readonly fired_by?: string;
+}
+export type AnswerPipelineResult = {
+    readonly action: "answer";
+    readonly message_id: string;
+    readonly final_reply: FinalReplySignal;
+    readonly reason: "already_answered";
+    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly audit: Pick<PipelineAudit, "final_reply" | "meta" | "fired_by">;
+};
+export type BlockPipelineResult = {
+    readonly action: "block";
+    readonly message_id: string;
+    readonly reason: {
+        readonly risk_level?: SafetySignal["risk_level"];
+        readonly signals?: ReadonlyArray<string>;
+    };
+    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly audit: Pick<PipelineAudit, "safety" | "meta" | "fired_by">;
+};
+export type NeedsReviewPipelineResult = {
+    readonly action: "needs_review";
+    readonly message_id: string;
+    readonly fired_by: string;
+    readonly reason: {
+        readonly risk_level?: SafetySignal["risk_level"];
+        readonly signals?: ReadonlyArray<string>;
+    };
+    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly audit: Pick<PipelineAudit, "safety" | "meta" | "fired_by">;
+};
+export type RoutePipelineResult = {
+    readonly action: "route";
+    readonly message_id: string;
+    readonly downstream: DownstreamPayload;
+    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly audit: PipelineAudit;
+};
+export type PipelineResult = AnswerPipelineResult | BlockPipelineResult | NeedsReviewPipelineResult | RoutePipelineResult;
+export interface AggregatorConfig {
+    readonly confidenceThreshold?: number;
+}
+export type ClassifierRegistry = ReadonlyArray<RuntimeClassifierManifest>;

package/dist/src/manifest.js

@@ -0,0 +1 @@
+export {};

package/dist/src/ollama.d.ts

@@ -0,0 +1,54 @@
+import { type ClassifierName, type RunClassifier } from "./classifiers.js";
+import { type OpenClassifyConfig } from "./config.js";
+import { classifyOpenClassifyInput } from "./pipeline.js";
+import type { Catalog } from "./manifest.js";
+import type { OpenClassifyInput } from "./types.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;
+    seed?: number;
+    num_ctx?: number;
+}
+export interface OllamaClassifierRunnerConfig {
+    host?: string;
+    defaultModel?: string;
+    models?: Partial<Record<ClassifierName, string | null>>;
+    options?: OllamaOptions;
+    fetch?: typeof fetch;
+    skipResourceCheck?: boolean;
+    minAvailableMemoryBytes?: number;
+    minTotalMemoryBytes?: number;
+}
+export interface ClassifyWithOllamaConfig extends OllamaClassifierRunnerConfig {
+    catalog?: Catalog;
+    catalogPath?: string;
+    configPath?: string;
+    openClassifyConfig?: OpenClassifyConfig;
+}
+export declare class OllamaClassifierError extends Error {
+    readonly classifier: ClassifierName;
+    readonly model: string;
+    constructor(classifier: ClassifierName, model: string, message: string, cause?: unknown);
+}
+export declare class OllamaResourceError extends Error {
+    readonly totalMemoryBytes: number;
+    readonly availableMemoryBytes: number;
+    readonly minTotalMemoryBytes: number;
+    readonly minAvailableMemoryBytes: number;
+    constructor(totalMemoryBytes: number, availableMemoryBytes: number, minTotalMemoryBytes: number, minAvailableMemoryBytes: number);
+}
+export declare function createOllamaClassifierRunner(config?: OllamaClassifierRunnerConfig): RunClassifier;
+export declare function assertOllamaResources(options?: {
+    minTotalMemoryBytes?: number;
+    minAvailableMemoryBytes?: number;
+}): Promise<void>;
+export declare function classifyWithOllama(input: OpenClassifyInput, config?: ClassifyWithOllamaConfig): ReturnType<typeof classifyOpenClassifyInput>;