open-classify 0.1.0

package/dist/src/ollama.js

@@ -0,0 +1,293 @@
+// Reference `RunClassifier` implementation backed by a local Ollama server.
+// Three responsibilities live here:
+//   1. Resource sanity check — refuse to run on undersized hardware.
+//   2. Prompt packing — render the system+user prompts and drop older context
+//      messages until the rendered prompt fits the configured num_ctx budget.
+//   3. Backend wiring — call Ollama, parse JSON, and delegate validation to
+//      each classifier module's `validate` function.
+//
+// Custom backend? Implement `RunClassifier` directly and pass it to
+// `classifyOpenClassifyInput` — you don't have to use this module at all.
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { loadCatalog } from "./catalog.js";
+import { CLASSIFIER_NAMES, MODULES_BY_NAME, validateClassifierOutput, } from "./classifiers.js";
+import { classifierModelsFromConfig, loadOpenClassifyConfig, } from "./config.js";
+import { classifyOpenClassifyInput } from "./pipeline.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
+ * runtime is deliberately much smaller because Open Classify sends multiple
+ * classifiers in parallel on one workstation-class Ollama server. This is the
+ * configured classifier runtime context, not the model's architectural maximum.
+ */
+export const OLLAMA_CONTEXT_LENGTH = 4096;
+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;
+    constructor(classifier, model, message, cause) {
+        super(message, { cause });
+        this.name = "OllamaClassifierError";
+        this.classifier = classifier;
+        this.model = model;
+    }
+}
+export class OllamaResourceError extends Error {
+    totalMemoryBytes;
+    availableMemoryBytes;
+    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`);
+        this.name = "OllamaResourceError";
+        this.totalMemoryBytes = totalMemoryBytes;
+        this.availableMemoryBytes = availableMemoryBytes;
+        this.minTotalMemoryBytes = minTotalMemoryBytes;
+        this.minAvailableMemoryBytes = minAvailableMemoryBytes;
+    }
+}
+// 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 = {}) {
+    const host = trimTrailingSlash(config.host ?? OLLAMA_DEFAULT_HOST);
+    const fetchImpl = config.fetch ?? fetch;
+    const models = config.models ?? {};
+    const defaultModel = config.defaultModel ?? OLLAMA_BASE_MODEL;
+    const hasDefaultModelOverride = config.defaultModel !== undefined;
+    const options = {
+        temperature: 0,
+        num_ctx: OLLAMA_CONTEXT_LENGTH,
+        ...config.options,
+    };
+    let resourceCheck;
+    return async (name, input, signal) => {
+        if (!config.skipResourceCheck) {
+            resourceCheck ??= assertOllamaResources({
+                minTotalMemoryBytes: config.minTotalMemoryBytes ?? OLLAMA_MIN_TOTAL_MEMORY_BYTES,
+                minAvailableMemoryBytes: config.minAvailableMemoryBytes ?? OLLAMA_MIN_AVAILABLE_MEMORY_BYTES,
+            });
+            await resourceCheck;
+        }
+        const configuredModel = models[name];
+        const model = configuredModel ?? defaultModel;
+        return runOllamaClassifier(name, input, signal, fetchImpl, host, model, options, configuredModel === undefined && !hasDefaultModelOverride);
+    };
+}
+export async function assertOllamaResources(options = {}) {
+    const minTotalMemoryBytes = options.minTotalMemoryBytes ?? OLLAMA_MIN_TOTAL_MEMORY_BYTES;
+    const minAvailableMemoryBytes = options.minAvailableMemoryBytes ?? OLLAMA_MIN_AVAILABLE_MEMORY_BYTES;
+    const { totalMemoryBytes, availableMemoryBytes } = await getSystemMemoryBytes();
+    if (totalMemoryBytes < minTotalMemoryBytes ||
+        availableMemoryBytes < minAvailableMemoryBytes) {
+        throw new OllamaResourceError(totalMemoryBytes, availableMemoryBytes, minTotalMemoryBytes, minAvailableMemoryBytes);
+    }
+}
+export async function classifyWithOllama(input, config = {}) {
+    const fileConfig = config.openClassifyConfig ?? loadOpenClassifyConfig(config.configPath, {
+        optional: config.configPath === undefined && process.env.OPEN_CLASSIFY_CONFIG === undefined,
+    });
+    const runnerFileConfig = fileConfig?.runner;
+    const runnerConfig = {
+        ...config,
+        host: config.host ?? runnerFileConfig?.host,
+        defaultModel: config.defaultModel ?? runnerFileConfig?.defaultModel,
+        models: {
+            ...classifierModelsFromConfig(fileConfig),
+            ...config.models,
+        },
+        options: {
+            ...runnerFileConfig?.options,
+            ...config.options,
+        },
+    };
+    if (!runnerConfig.skipResourceCheck) {
+        await assertOllamaResources({
+            minTotalMemoryBytes: runnerConfig.minTotalMemoryBytes,
+            minAvailableMemoryBytes: runnerConfig.minAvailableMemoryBytes,
+        });
+        Object.assign(runnerConfig, {
+            skipResourceCheck: true,
+        });
+    }
+    const catalog = config.catalog ?? loadCatalog(config.catalogPath ?? fileConfig?.catalog ?? OLLAMA_DEFAULT_CATALOG_PATH);
+    return classifyOpenClassifyInput(input, {
+        runClassifier: createOllamaClassifierRunner(runnerConfig),
+        catalog,
+    });
+}
+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;
+    if (allowManifestModel && configuredBaseModel) {
+        model = configuredBaseModel;
+    }
+    const userPrompt = buildPackedClassifierPrompt(name, input, systemPrompt, model, options);
+    const body = {
+        model,
+        stream: false,
+        format: "json",
+        think: false,
+        options,
+        messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userPrompt },
+        ],
+    };
+    let response;
+    try {
+        response = await fetchImpl(`${host}/api/chat`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    catch (error) {
+        throw new OllamaClassifierError(name, model, `${name} classifier request failed`, error);
+    }
+    let payload;
+    try {
+        payload = ((await response.json()) ?? {});
+    }
+    catch (error) {
+        throw new OllamaClassifierError(name, model, `${name} classifier returned invalid Ollama JSON`, error);
+    }
+    if (!response.ok || payload.error !== undefined) {
+        throw new OllamaClassifierError(name, model, `${name} classifier Ollama request failed: ${payload.error ?? response.statusText}`);
+    }
+    const content = payload.message?.content ?? payload.response;
+    if (typeof content !== "string") {
+        throw new OllamaClassifierError(name, model, `${name} classifier response did not include message content`);
+    }
+    const parsed = parseJsonObject(content, name, model);
+    try {
+        return validateClassifierOutput(name, parsed, model);
+    }
+    catch (error) {
+        if (error instanceof ClassifierValidationError) {
+            throw new OllamaClassifierError(name, model, error.message, error);
+        }
+        throw error;
+    }
+}
+async function getSystemMemoryBytes() {
+    const os = await import("node:os");
+    const totalMemoryBytes = os.totalmem();
+    if (process.platform === "darwin") {
+        const [{ stdout: pageSizeOutput }, { stdout: vmStatOutput }] = await Promise.all([
+            execFileAsync("pagesize"),
+            execFileAsync("vm_stat"),
+        ]);
+        const pageSize = Number(pageSizeOutput.trim());
+        const freePages = readVmStatPages(vmStatOutput, "Pages free");
+        const speculativePages = readVmStatPages(vmStatOutput, "Pages speculative");
+        const purgeablePages = readVmStatPages(vmStatOutput, "Pages purgeable");
+        return {
+            totalMemoryBytes,
+            availableMemoryBytes: (freePages + speculativePages + purgeablePages) * pageSize,
+        };
+    }
+    return {
+        totalMemoryBytes,
+        availableMemoryBytes: os.freemem(),
+    };
+}
+function readVmStatPages(output, label) {
+    const line = output
+        .split("\n")
+        .find((candidate) => candidate.trim().startsWith(`${label}:`));
+    if (line === undefined) {
+        return 0;
+    }
+    const match = line.match(/:\s+([0-9]+)\./);
+    return match === null ? 0 : Number(match[1]);
+}
+function buildPackedClassifierPrompt(name, input, systemPrompt, model, options) {
+    let messages = input.messages;
+    let prompt = buildClassifierPrompt({
+        ...input,
+        messages,
+    });
+    while (!fitsEstimatedContext(systemPrompt, prompt, options) &&
+        messages.length > 1) {
+        messages = messages.slice(1);
+        prompt = buildClassifierPrompt({
+            ...input,
+            messages,
+        });
+    }
+    if (!fitsEstimatedContext(systemPrompt, prompt, options)) {
+        throw new OllamaClassifierError(name, model, `${name} classifier prompt exceeds estimated ${contextLength(options)} token context length with only the target message`);
+    }
+    return prompt;
+}
+function fitsEstimatedContext(systemPrompt, userPrompt, options) {
+    return estimateTokens(`${systemPrompt}\n\n${userPrompt}`) <= contextLength(options);
+}
+function contextLength(options) {
+    return Number.isFinite(options.num_ctx)
+        ? Math.floor(options.num_ctx)
+        : OLLAMA_CONTEXT_LENGTH;
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / ESTIMATED_CHARS_PER_TOKEN);
+}
+function buildClassifierPrompt(input) {
+    const lines = [
+        "Classify the final message in the normalized conversation window below.",
+        "Earlier messages are context only; do not classify them as new requests.",
+        "The target user message is the final message in the window.",
+        "Return JSON only.",
+        "",
+        "Conversation window:",
+    ];
+    for (const [index, message] of input.messages.entries()) {
+        const label = index === input.messages.length - 1
+            ? `Message ${index + 1} (target)`
+            : `Message ${index + 1} (context)`;
+        lines.push(`${label}:`);
+        if (message.role !== undefined) {
+            lines.push(`role: ${message.role}`);
+        }
+        lines.push("text:");
+        lines.push(message.text);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function parseJsonObject(content, classifier, model) {
+    const json = unwrapJsonFence(content);
+    try {
+        const parsed = JSON.parse(json);
+        if (isRecord(parsed)) {
+            return parsed;
+        }
+    }
+    catch (error) {
+        throw new OllamaClassifierError(classifier, model, `${classifier} classifier returned invalid JSON`, error);
+    }
+    throw new OllamaClassifierError(classifier, model, `${classifier} classifier returned JSON that is not an object`);
+}
+function unwrapJsonFence(content) {
+    const trimmed = content.trim();
+    const match = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed);
+    return match?.[1]?.trim() ?? trimmed;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function formatBytes(value) {
+    return `${(value / (1024 * 1024 * 1024)).toFixed(1)} GiB`;
+}

package/dist/src/pipeline.d.ts

@@ -0,0 +1,17 @@
+import { type RunClassifier } from "./classifiers.js";
+import type { AggregatorConfig, Catalog, 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 class OpenClassifyNormalizationError extends Error {
+    constructor(cause: unknown);
+}
+export interface ClassifyOptions {
+    runClassifier: RunClassifier;
+    catalog: Catalog;
+    classifierTimeoutMs?: number;
+    classifierRetryCount?: number;
+    aggregator?: AggregatorConfig;
+    signal?: AbortSignal;
+}
+export declare function classifyOpenClassifyInput(input: OpenClassifyInput, options: ClassifyOptions): Promise<PipelineResult>;

package/dist/src/pipeline.js

@@ -0,0 +1,274 @@
+import { composeEnvelope } from "./aggregator.js";
+import { CLASSIFIER_NAMES, MODULES_BY_NAME, REGISTRY, } from "./classifiers.js";
+import { normalizeOpenClassifyInput, toClassifierInput } from "./input.js";
+import { isCustomManifest } from "./stock.js";
+export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15_000;
+export const DEFAULT_CLASSIFIER_RETRY_COUNT = 1;
+export class OpenClassifyNormalizationError extends Error {
+    constructor(cause) {
+        super(errorMessage(cause), { cause });
+        this.name = "OpenClassifyNormalizationError";
+    }
+}
+// Short-circuit gates are intrinsic to specific stock signals — not configured
+// per-manifest. preflight.final_reply ⇒ answer; security.decision in
+// {block, needs_review} ⇒ block / needs_review. Order matters: preflight is
+// cheaper to evaluate, so we check it first.
+const SHORT_CIRCUIT_GATES = ["preflight", "security"];
+export async function classifyOpenClassifyInput(input, options) {
+    let request;
+    try {
+        request = normalizeOpenClassifyInput(input);
+    }
+    catch (error) {
+        throw new OpenClassifyNormalizationError(error);
+    }
+    const controller = new AbortController();
+    const abortFromOptions = () => {
+        controller.abort(options.signal?.reason ?? new Error("classification aborted"));
+    };
+    if (options.signal?.aborted) {
+        abortFromOptions();
+    }
+    else {
+        options.signal?.addEventListener("abort", abortFromOptions, { once: true });
+    }
+    const classifierInput = toClassifierInput(request);
+    const classifierTimeoutMs = options.classifierTimeoutMs ?? DEFAULT_CLASSIFIER_TIMEOUT_MS;
+    const classifierRetryCount = options.classifierRetryCount ?? DEFAULT_CLASSIFIER_RETRY_COUNT;
+    const threshold = options.aggregator?.confidenceThreshold ?? 0.6;
+    const runs = new Map(CLASSIFIER_NAMES.map((name) => [
+        name,
+        runClassifierWithRetry(name, classifierInput, options.runClassifier, controller.signal, classifierTimeoutMs, classifierRetryCount),
+    ]));
+    try {
+        for (const gate of SHORT_CIRCUIT_GATES) {
+            const gateRun = runs.get(gate);
+            if (gateRun === undefined)
+                continue;
+            const settled = await gateRun;
+            if (!settled.ok)
+                continue;
+            const verdict = shortCircuitVerdict(gate, settled.value, threshold);
+            if (!verdict)
+                continue;
+            controller.abort();
+            await settleClassifierRunsExcept(runs, [gate]);
+            return buildShortCircuitResult(gate, verdict, settled, request.target_message_hash);
+        }
+        const settled = await Promise.all([...runs.values()]);
+        const { results, meta } = collectFullEntries(settled);
+        const envelope = composeEnvelope({
+            registry: REGISTRY,
+            results,
+            catalog: options.catalog,
+            input: classifierInput,
+            config: options.aggregator,
+        });
+        return buildRouteResult(request, envelope, results, meta);
+    }
+    finally {
+        options.signal?.removeEventListener("abort", abortFromOptions);
+    }
+}
+function shortCircuitVerdict(gate, result, threshold) {
+    const confidence = result.confidence ?? 0;
+    if (confidence < threshold)
+        return null;
+    if (gate === "preflight") {
+        const preflight = result;
+        if (preflight.final_reply !== undefined) {
+            return { kind: "answer", final_reply: preflight.final_reply };
+        }
+        return null;
+    }
+    if (gate === "security") {
+        const security = result;
+        if (security.decision === "block") {
+            return {
+                kind: "block",
+                safety: extractSafety(security),
+            };
+        }
+        if (security.decision === "needs_review") {
+            return {
+                kind: "needs_review",
+                safety: extractSafety(security),
+            };
+        }
+    }
+    return null;
+}
+function extractSafety(value) {
+    return {
+        ...(value.decision === undefined ? {} : { decision: value.decision }),
+        risk_level: value.risk_level,
+        signals: value.signals,
+    };
+}
+function buildShortCircuitResult(name, verdict, settled, target_message_hash) {
+    const manifest = MODULES_BY_NAME[name];
+    const value = settled.ok ? settled.value : manifest.fallback;
+    const entry = {
+        ...value,
+        status: classifierRunStatus(settled),
+        version: manifest.version,
+    };
+    const meta = { classifiers: { [name]: entry } };
+    const classifier_outputs = classifierCustomOutputs({ [name]: value });
+    if (verdict.kind === "answer") {
+        const preflight = value;
+        return {
+            action: "answer",
+            message_id: target_message_hash,
+            final_reply: verdict.final_reply,
+            reason: "already_answered",
+            classifier_outputs,
+            audit: {
+                fired_by: name,
+                ...(preflight.final_reply === undefined ? {} : { final_reply: preflight.final_reply }),
+                meta,
+            },
+        };
+    }
+    if (verdict.kind === "needs_review") {
+        return {
+            action: "needs_review",
+            message_id: target_message_hash,
+            fired_by: name,
+            reason: {
+                risk_level: verdict.safety.risk_level,
+                signals: verdict.safety.signals,
+            },
+            classifier_outputs,
+            audit: {
+                fired_by: name,
+                safety: verdict.safety,
+                meta,
+            },
+        };
+    }
+    return {
+        action: "block",
+        message_id: target_message_hash,
+        reason: {
+            risk_level: verdict.safety.risk_level,
+            signals: verdict.safety.signals,
+        },
+        classifier_outputs,
+        audit: {
+            fired_by: name,
+            safety: verdict.safety,
+            meta,
+        },
+    };
+}
+function collectFullEntries(settled) {
+    const results = {};
+    const classifiers = {};
+    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 } };
+}
+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",
+        message_id: request.target_message_hash,
+        downstream,
+        classifier_outputs: classifierCustomOutputs(results),
+        audit: {
+            ...envelope,
+            meta,
+        },
+    };
+}
+function classifierCustomOutputs(results) {
+    const out = {};
+    for (const manifest of REGISTRY) {
+        if (!isCustomManifest(manifest))
+            continue;
+        const result = results[manifest.name];
+        if (result === undefined)
+            continue;
+        out[manifest.name] = result.output;
+    }
+    return out;
+}
+async function runClassifierWithRetry(name, input, runClassifier, rootSignal, timeoutMs, retryCount) {
+    let lastError = new Error(`${name} classifier did not run`);
+    let lastReason = "error";
+    for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+        if (rootSignal.aborted)
+            break;
+        const result = await runClassifierAttempt(name, input, runClassifier, rootSignal, timeoutMs);
+        if (result.ok)
+            return { ok: true, name, value: result.value };
+        lastError = result.error;
+        lastReason = result.reason;
+    }
+    return { ok: false, name, error: lastError, reason: lastReason };
+}
+async function runClassifierAttempt(name, input, runClassifier, rootSignal, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutError = new Error(`${name} classifier timed out after ${timeoutMs}ms`);
+    let timeout;
+    let abortAttempt;
+    try {
+        const run = runClassifier(name, input, controller.signal).then((value) => ({ ok: true, value }), (error) => ({ ok: false, error, reason: "error" }));
+        const timedOut = new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                controller.abort(timeoutError);
+                resolve({ ok: false, error: timeoutError, reason: "timeout" });
+            }, timeoutMs);
+        });
+        const aborted = new Promise((resolve) => {
+            abortAttempt = () => {
+                const error = rootSignal.reason ?? new Error(`${name} classifier aborted`);
+                controller.abort(error);
+                resolve({ ok: false, error, reason: "error" });
+            };
+            rootSignal.addEventListener("abort", abortAttempt, { once: true });
+        });
+        return await Promise.race([run, timedOut, aborted]);
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (abortAttempt !== undefined)
+            rootSignal.removeEventListener("abort", abortAttempt);
+    }
+}
+async function settleClassifierRunsExcept(runs, keep) {
+    const keepSet = new Set(keep);
+    await Promise.all([...runs].filter(([name]) => !keepSet.has(name)).map(([, run]) => run.catch(() => undefined)));
+}
+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-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { JsonClassifierManifest } from "./stock.js";
+export declare function buildStockClassifierPrompt(manifest: JsonClassifierManifest): string;

package/dist/src/stock-prompt.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const STOCK_PROMPTS_DIR = join(__dirname, "classifiers", "stock", "prompts");
+export function buildStockClassifierPrompt(manifest) {
+    const sections = [
+        promptMarkdown("base.md"),
+        promptMarkdown("reason.md"),
+        promptMarkdown("confidence.md"),
+        renderTemplate(promptMarkdown("classifier-header.md"), {
+            classifier_name: manifest.name,
+            classifier_purpose: manifest.purpose,
+        }),
+    ];
+    if (manifest.kind === "stock") {
+        sections.push(stockSection(manifest));
+    }
+    else {
+        sections.push(promptMarkdown("custom-output.md"));
+    }
+    return sections.join("\n\n");
+}
+function stockSection(manifest) {
+    return renderTemplate(promptMarkdown(`${manifest.name}.md`), {
+        allowed_tools: renderAllowedTools(manifest.tools),
+        preflight_output: promptMarkdown("preflight-output.md"),
+        routing_output: promptMarkdown("routing-output.md"),
+        security_output: promptMarkdown("security-output.md"),
+        specialty: promptMarkdown("specialty.md"),
+        tier: promptMarkdown("tier.md"),
+        tools_output: promptMarkdown("tools-output.md"),
+    });
+}
+function renderAllowedTools(tools) {
+    if (!tools || tools.length === 0) {
+        return "No downstream tools are available.";
+    }
+    return [
+        "Allowed tool ids:",
+        "",
+        ...tools.map((tool) => `- ${tool.id}: ${tool.description}`),
+    ].join("\n");
+}
+function promptMarkdown(filename) {
+    return readFileSync(join(STOCK_PROMPTS_DIR, filename), "utf8").trim();
+}
+function renderTemplate(template, slots) {
+    let rendered = template;
+    for (let pass = 0; pass < 5; pass += 1) {
+        const next = rendered.replace(/\{\{([a-z_]+)\}\}/g, (match, name) => {
+            const value = slots[name];
+            if (value === undefined) {
+                throw new Error(`missing prompt slot: ${match}`);
+            }
+            return value;
+        });
+        if (next === rendered)
+            return rendered;
+        rendered = next;
+    }
+    throw new Error("prompt template slots are nested too deeply");
+}

package/dist/src/stock-validation.d.ts

@@ -0,0 +1,22 @@
+import type { JsonClassifierManifest, SafetySignal, ClassifierOutput } from "./stock.js";
+export declare const STOCK_REASON_MAX_CHARS = 120;
+export declare const STOCK_REPLY_MAX_CHARS = 200;
+export declare const STOCK_TOOL_ID_MAX_CHARS = 64;
+export declare const STOCK_TOOL_DESCRIPTION_MAX_CHARS = 240;
+export declare const STOCK_MANIFEST_NAME_MAX_CHARS = 80;
+export declare const STOCK_MANIFEST_VERSION_MAX_CHARS = 40;
+export declare const STOCK_MANIFEST_PURPOSE_MAX_CHARS = 400;
+export declare function validateJsonClassifierManifest(value: unknown, model?: string): JsonClassifierManifest;
+export interface ValidateOutputContext {
+    readonly classifier: string;
+    readonly model: string;
+}
+export declare function validateOutputForManifest(manifest: JsonClassifierManifest, value: unknown, context: ValidateOutputContext): ClassifierOutput;
+export declare function validateWithSchema(value: unknown, schema: unknown, classifier: string, model: string, path: string): void;
+export interface LegacyValidateOptions {
+    readonly classifier: string;
+    readonly model: string;
+    readonly manifest: JsonClassifierManifest;
+}
+export declare function validateClassifierOutputWithManifest(value: unknown, options: LegacyValidateOptions): ClassifierOutput;
+export type { SafetySignal };