open-classify 0.4.0 → 0.6.0

package/dist/src/aggregator.js

@@ -1,245 +1,166 @@
-import { certaintyScore, isCustomManifest, isStockManifest } from "./stock.js";
-export const DEFAULT_CERTAINTY_THRESHOLD = 0.65;
-/** @deprecated Use DEFAULT_CERTAINTY_THRESHOLD. */
-export const DEFAULT_CONFIDENCE_THRESHOLD = DEFAULT_CERTAINTY_THRESHOLD;
-export function composeEnvelope(args) {
-    const { registry, results, catalog, config } = args;
-    const threshold = certaintyThreshold(config);
-    const stockByName = stockResultsByName(registry, results);
-    const preflight = stockByName.preflight;
-    const routing = stockByName.routing;
-    const modelSpec = stockByName.model_specialization;
-    const tools = stockByName.tools;
-    const promptInjection = stockByName.prompt_injection;
-    const preflightConfident = isConfident(preflight, threshold);
-    const finalReply = preflightConfident ? preflight?.final_reply : undefined;
-    const ackReply = preflightConfident ? preflight?.ack_reply : undefined;
-    const mergedRouting = mergeRouting(routing, modelSpec, threshold);
-    const lowConfidenceDrops = lowConfidenceRoutingDrops(routing, modelSpec, mergedRouting, threshold);
-    const toolsSignal = isConfident(tools, threshold) ? extractToolsSignal(tools) : undefined;
-    const promptInjectionSignal = isConfident(promptInjection, threshold)
-        ? extractPromptInjectionSignal(promptInjection)
-        : undefined;
-    const envelope = {
-        ...optional("final_reply", finalReply),
-        ...optional("ack_reply", ackReply),
-        ...optional("routing", mergedRouting),
-        ...optional("tools", toolsSignal),
-        ...optional("prompt_injection", promptInjectionSignal),
-        custom_outputs: customOutputs(registry, results),
-        model_recommendation: resolveModelFromRouting(mergedRouting, catalog, routingMaxConfidence(routing, modelSpec), lowConfidenceDrops),
-    };
-    return envelope;
-}
-export function certaintyThreshold(config) {
-    return config?.certaintyThreshold ?? config?.confidenceThreshold ?? DEFAULT_CERTAINTY_THRESHOLD;
-}
-function optional(key, value) {
-    return value === undefined ? {} : { [key]: value };
-}
-function stockResultsByName(registry, results) {
-    const map = {};
-    for (const manifest of registry) {
-        if (!isStockManifest(manifest))
-            continue;
-        const result = results[manifest.name];
-        if (result !== undefined) {
-            map[manifest.name] = result;
-        }
+import { certaintyScore } from "./stock.js";
+export function assembleResult(args) {
+    const { registry, results, failedClassifiers, catalog } = args;
+    // Pick reserved fields — highest certainty wins, no threshold gate.
+    const finalReply = pickField(registry, results, "final_reply");
+    const ackReply = pickField(registry, results, "ack_reply");
+    const modelTier = pickField(registry, results, "model_tier");
+    const modelSpec = pickField(registry, results, "model_specialization");
+    const toolsPick = pickField(registry, results, "tools");
+    const riskLevel = pickField(registry, results, "risk_level");
+    // Resolve concrete model id.
+    let model_id = null;
+    try {
+        const routing = mergeRouting(modelTier?.value, modelSpec?.value);
+        model_id = resolveModelFromRouting(routing, catalog).id;
+    }
+    catch {
+        // Catalog error — model_id stays null.
+    }
+    const tools = toolsPick?.value ?? [];
+    const reply = finalReply?.value
+        ? { text: finalReply.value.text }
+        : ackReply?.value
+            ? { text: ackReply.value.text }
+            : null;
+    const prompt_injection = riskLevel?.value !== undefined ? { risk_level: riskLevel.value } : null;
+    const { avg_certainty, min_certainty } = certaintySummary(registry, results);
+    const classifier_outputs = buildPublicOutputs(registry, results);
+    // Determine action. Priority: prompt_injection > classification_error > reply > route.
+    const isInjectionBlock = riskLevel?.value === "high_risk" || riskLevel?.value === "unknown";
+    const isClassificationError = failedClassifiers.length > 0 || reply === null || model_id === null;
+    let action;
+    let block_reason;
+    if (isInjectionBlock) {
+        action = "block";
+        block_reason = "prompt_injection";
+    }
+    else if (isClassificationError) {
+        action = "block";
+        block_reason = "classification_error";
+    }
+    else if (finalReply?.value !== undefined) {
+        action = "reply";
+    }
+    else {
+        action = "route";
     }
-    return map;
-}
-function isConfident(result, threshold) {
-    if (!result)
-        return false;
-    return scoreCertainty(result.certainty) >= threshold;
-}
-function mergeRouting(routing, modelSpec, threshold) {
-    const tier = pickConfidentAxis([
-        ["routing", routing, routing?.model_tier],
-    ], threshold);
-    const specialization = pickConfidentAxis([
-        ["model_specialization", modelSpec, modelSpec?.specialization],
-    ], threshold);
-    if (tier === undefined && specialization === undefined)
-        return undefined;
     return {
-        ...(tier === undefined ? {} : { model_tier: tier }),
-        ...(specialization === undefined ? {} : { specialization }),
+        action,
+        ...(block_reason !== undefined ? { block_reason } : {}),
+        model_id,
+        tools,
+        reply,
+        prompt_injection,
+        avg_certainty,
+        min_certainty,
+        failed_classifiers: failedClassifiers,
+        classifier_outputs,
     };
 }
-function pickConfidentAxis(candidates, threshold) {
-    let best;
-    for (const [, source, value] of candidates) {
-        if (value === undefined)
-            continue;
-        if (!isConfident(source, threshold))
-            continue;
-        const confidence = scoreCertainty(source.certainty);
-        if (best === undefined || confidence > best.confidence) {
-            best = { value, confidence };
-        }
-    }
-    return best?.value;
-}
-function routingMaxConfidence(routing, modelSpec) {
-    const values = [routing?.certainty, modelSpec?.certainty]
-        .filter((v) => v !== undefined)
-        .map(scoreCertainty);
-    if (values.length === 0)
-        return undefined;
-    return Math.max(...values);
-}
-function extractToolsSignal(result) {
-    return { tools: result.tools };
-}
-function extractPromptInjectionSignal(result) {
-    return {
-        risk_level: result.risk_level,
-    };
-}
-function customOutputs(registry, results) {
-    const out = [];
+// Build the public classifier_outputs map. Keeps reason + payload fields;
+// converts certainty label to float score.
+export function buildPublicOutputs(registry, results) {
+    const out = {};
     for (const manifest of registry) {
-        if (!isCustomManifest(manifest))
-            continue;
         const result = results[manifest.name];
         if (result === undefined)
             continue;
-        out.push({
-            classifier: manifest.name,
-            reason: result.reason,
-            certainty: result.certainty,
-            output: result.output,
-        });
+        const { certainty, ...rest } = result;
+        out[manifest.name] = {
+            ...rest,
+            certainty: scoreCertainty(certainty),
+        };
     }
     return out;
 }
-// ─── Model recommendation ───────────────────────────────────────────────────
-function lowConfidenceRoutingDrops(routing, modelSpec, merged, threshold) {
-    const dropped = [];
-    if (merged?.specialization === undefined) {
-        if (hasLowConfidenceAxis(routing, "specialization", threshold) ||
-            hasLowConfidenceAxis(modelSpec, "specialization", threshold)) {
-            dropped.push({ axis: "specialization", reason: "low_confidence" });
-        }
-    }
-    if (merged?.model_tier === undefined) {
-        if (hasLowConfidenceAxis(routing, "model_tier", threshold) ||
-            hasLowConfidenceAxis(modelSpec, "model_tier", threshold)) {
-            dropped.push({ axis: "tier", reason: "low_confidence" });
+function certaintySummary(registry, results) {
+    const scores = registry.map((m) => scoreCertainty(results[m.name]?.certainty));
+    if (scores.length === 0)
+        return { avg_certainty: 0, min_certainty: 0 };
+    const min_certainty = Math.min(...scores);
+    const avg_certainty = scores.reduce((sum, v) => sum + v, 0) / scores.length;
+    return { min_certainty, avg_certainty };
+}
+// Highest certainty wins; ties broken by registry order (already sorted by
+// dispatch_order ascending).
+function pickField(registry, results, field) {
+    let best;
+    for (const manifest of registry) {
+        if (!manifest.reservedFields.includes(field))
+            continue;
+        const output = results[manifest.name];
+        if (output === undefined)
+            continue;
+        const raw = output[field];
+        if (raw === undefined)
+            continue;
+        const score = scoreCertainty(output.certainty);
+        if (best === undefined || score > best.score) {
+            best = { value: raw, source: manifest.name, score };
         }
     }
-    return dropped;
-}
-function hasLowConfidenceAxis(result, field, threshold) {
-    if (!result)
-        return false;
-    if (result[field] === undefined)
-        return false;
-    return scoreCertainty(result.certainty) < threshold;
+    return best;
 }
 function scoreCertainty(certainty) {
     return certainty === undefined ? 0 : certaintyScore[certainty];
 }
-export function resolveModelFromRouting(routing, catalog, confidence, ignoredConstraints = []) {
+// ─── Model resolution ────────────────────────────────────────────────────────
+function mergeRouting(tier, specialization) {
+    if (tier === undefined && specialization === undefined)
+        return undefined;
+    return {
+        ...(tier === undefined ? {} : { model_tier: tier }),
+        ...(specialization === undefined ? {} : { model_specialization: specialization }),
+    };
+}
+function resolveModelFromRouting(routing, catalog) {
     const requested = {};
-    const confidences = {};
-    if (confidence !== undefined) {
-        confidences.routing = confidence;
+    if (routing?.model_specialization !== undefined) {
+        requested.model_specialization = routing.model_specialization;
+    }
+    if (routing?.model_tier !== undefined) {
+        requested.model_tier = routing.model_tier;
     }
-    if (routing?.specialization !== undefined)
-        requested.specialization = routing.specialization;
-    if (routing?.model_tier !== undefined)
-        requested.tier = routing.model_tier;
     const passes = [
-        { useSpecialization: true, useTier: true },
-        { useSpecialization: true, useTier: false },
-        { useSpecialization: false, useTier: true },
-        { useSpecialization: false, useTier: false },
+        { useSpec: true, useTier: true },
+        { useSpec: true, useTier: false },
+        { useSpec: false, useTier: true },
+        { useSpec: false, useTier: false },
     ];
     for (const pass of passes) {
-        const constraints_used = constraintsForPass(requested, pass);
-        const matching = catalog.models.filter((model) => matchesConstraints(model, constraints_used));
+        const constraints = constraintsForPass(requested, pass);
+        const matching = catalog.models.filter((m) => matchesConstraints(m, constraints));
         if (matching.length === 0)
             continue;
-        const winner = pickBestModel(matching, catalog.models);
-        return {
-            ...modelRecommendationFields(winner),
-            resolution: {
-                constraints_used,
-                constraints_dropped: [
-                    ...ignoredConstraints,
-                    ...relaxedConstraints(requested, constraints_used),
-                ],
-                confidences,
-                fell_back_to_default: false,
-            },
-        };
+        return { id: pickBestModel(matching, catalog.models).id };
     }
-    const fallback = catalog.models.find((model) => model.id === catalog.default);
+    const fallback = catalog.models.find((m) => m.id === catalog.default);
     if (!fallback) {
-        throw new Error(`catalog default "${catalog.default}" not found in models — catalog skipped validation`);
+        throw new Error(`catalog default "${catalog.default}" not found in models`);
     }
-    return {
-        ...modelRecommendationFields(fallback),
-        resolution: {
-            constraints_used: {},
-            constraints_dropped: [
-                ...ignoredConstraints,
-                ...defaultFallbackConstraints(requested),
-            ],
-            confidences,
-            fell_back_to_default: true,
-        },
-    };
-}
-// Test-friendly convenience wrapper: builds a routing signal from a typed
-// results map and resolves a model. Mirrors `composeEnvelope` for callers
-// that want just the model recommendation without the rest of the envelope.
-export function resolveModel(results, catalog, threshold) {
-    const routing = mergeRouting(results.routing, results.model_specialization, threshold);
-    return resolveModelFromRouting(routing, catalog, routingMaxConfidence(results.routing, results.model_specialization), lowConfidenceRoutingDrops(results.routing, results.model_specialization, routing, threshold));
+    return { id: fallback.id };
 }
 function constraintsForPass(requested, pass) {
     return {
-        ...(pass.useSpecialization && requested.specialization !== undefined
-            ? { specialization: requested.specialization }
+        ...(pass.useSpec && requested.model_specialization !== undefined
+            ? { model_specialization: requested.model_specialization }
+            : {}),
+        ...(pass.useTier && requested.model_tier !== undefined
+            ? { model_tier: requested.model_tier }
             : {}),
-        ...(pass.useTier && requested.tier !== undefined ? { tier: requested.tier } : {}),
     };
 }
 function matchesConstraints(model, constraints) {
-    return ((constraints.specialization === undefined ||
-        model.specializations.includes(constraints.specialization)) &&
-        (constraints.tier === undefined || model.tier === constraints.tier));
-}
-function relaxedConstraints(requested, used) {
-    const dropped = [];
-    if (requested.specialization !== undefined && used.specialization === undefined) {
-        dropped.push({ axis: "specialization", reason: "no_match_relaxed" });
-    }
-    if (requested.tier !== undefined && used.tier === undefined) {
-        dropped.push({ axis: "tier", reason: "no_match_relaxed" });
-    }
-    return dropped;
-}
-function defaultFallbackConstraints(requested) {
-    const dropped = [];
-    if (requested.specialization !== undefined) {
-        dropped.push({ axis: "specialization", reason: "default_fallback" });
-    }
-    if (requested.tier !== undefined) {
-        dropped.push({ axis: "tier", reason: "default_fallback" });
-    }
-    return dropped;
+    return ((constraints.model_specialization === undefined ||
+        model.specializations.includes(constraints.model_specialization)) &&
+        (constraints.model_tier === undefined || model.tier === constraints.model_tier));
 }
 function pickBestModel(candidates, catalogOrder) {
     let winner = candidates[0];
     for (let i = 1; i < candidates.length; i++) {
-        const candidate = candidates[i];
-        if (compareModels(candidate, winner, catalogOrder) < 0) {
-            winner = candidate;
+        if (compareModels(candidates[i], winner, catalogOrder) < 0) {
+            winner = candidates[i];
         }
     }
     return winner;
@@ -251,27 +172,15 @@ function compareModels(a, b, catalogOrder) {
     if (a.params_in_billions !== b.params_in_billions) {
         return comparableParams(b) - comparableParams(a);
     }
-    if (a.context_window !== b.context_window) {
+    if (a.context_window !== b.context_window)
         return b.context_window - a.context_window;
-    }
     return catalogOrder.indexOf(a) - catalogOrder.indexOf(b);
 }
 function priceIndex(model) {
-    if (model.input_tokens_cpm === undefined || model.output_tokens_cpm === undefined) {
+    if (model.input_tokens_cpm === undefined || model.output_tokens_cpm === undefined)
         return 0;
-    }
     return model.input_tokens_cpm + model.output_tokens_cpm;
 }
 function comparableParams(model) {
     return model.params_in_billions ?? 0;
 }
-function modelRecommendationFields(winner) {
-    return {
-        id: winner.id,
-        params_in_billions: winner.params_in_billions,
-        context_window: winner.context_window,
-        ...(winner.input_tokens_cpm === undefined ? {} : { input_tokens_cpm: winner.input_tokens_cpm }),
-        ...(winner.cached_tokens_cpm === undefined ? {} : { cached_tokens_cpm: winner.cached_tokens_cpm }),
-        ...(winner.output_tokens_cpm === undefined ? {} : { output_tokens_cpm: winner.output_tokens_cpm }),
-    };
-}

package/dist/src/classifiers/{custom/context_shift → context_shift}/manifest.json

@@ -1,19 +1,9 @@
 {
-  "kind": "custom",
   "name": "context_shift",
   "version": "1.0.0",
   "purpose": "Classify whether the latest message continues, branches from, returns to, or starts a conversation thread.",
-  "order": 80,
-  "fallback": {
-    "reason": "Classifier failed; context relationship is ambiguous.",
-    "certainty": "no_signal",
-    "output": {
-      "decision": "ambiguous"
-    }
-  },
+  "dispatch_order": 80,
   "output_schema": {
-    "type": "object",
-    "additionalProperties": false,
     "required": ["decision"],
     "properties": {
       "decision": {
@@ -27,5 +17,10 @@
         ]
       }
     }
+  },
+  "fallback": {
+    "reason": "Classifier failed; context relationship is ambiguous.",
+    "certainty": "no_signal",
+    "decision": "ambiguous"
   }
 }

package/dist/src/classifiers/{custom/context_shift → context_shift}/prompt.md

@@ -1,6 +1,6 @@
 You are the context_shift classifier for an AI assistant routing system.
 
-`output.decision` describes how the final user message relates to the visible conversation history.
+`decision` describes how the final user message relates to the visible conversation history.
 
 Use `same_active_thread` when the final message directly continues, clarifies, corrects, or asks for the next step on the active topic.
 Use `related_branch` when it starts a distinct subtask or angle that still depends on the active topic.

package/dist/src/classifiers/{custom/conversation_digest → conversation_digest}/manifest.json

@@ -1,20 +1,9 @@
 {
-  "kind": "custom",
   "name": "conversation_digest",
   "version": "1.0.0",
   "purpose": "Compress prior conversation history and the latest user message into separate summaries.",
-  "order": 70,
-  "fallback": {
-    "reason": "Classifier failed; no conversation summary generated.",
-    "certainty": "no_signal",
-    "output": {
-      "history_summary": "",
-      "latest_user_message_summary": ""
-    }
-  },
+  "dispatch_order": 70,
   "output_schema": {
-    "type": "object",
-    "additionalProperties": false,
     "required": ["history_summary", "latest_user_message_summary"],
     "properties": {
       "history_summary": {
@@ -26,5 +15,11 @@
         "maxLength": 1000
       }
     }
+  },
+  "fallback": {
+    "reason": "Classifier failed; no conversation summary generated.",
+    "certainty": "no_signal",
+    "history_summary": "",
+    "latest_user_message_summary": ""
   }
 }

package/dist/src/classifiers/{custom/conversation_digest → conversation_digest}/prompt.md

@@ -1,7 +1,7 @@
 You are the conversation_digest classifier for an AI assistant routing system.
 
-`output.history_summary` is a maximally compressed summary of every message before the final user message.
-`output.latest_user_message_summary` is a maximally compressed summary of only the final user message.
+`history_summary` is a maximally compressed summary of every message before the final user message.
+`latest_user_message_summary` is a maximally compressed summary of only the final user message.
 
 Use terse, information-dense wording. Preserve concrete goals, constraints, decisions, file paths, identifiers, and unresolved asks. Omit pleasantries and low-value filler.
 If there is no prior conversation history, return an empty string for `history_summary`.

package/dist/src/classifiers/{custom/memory_retrieval_queries → memory_retrieval_queries}/manifest.json

@@ -1,19 +1,9 @@
 {
-  "kind": "custom",
   "name": "memory_retrieval_queries",
   "version": "1.0.0",
   "purpose": "Generate retrieval queries likely to surface helpful user-specific context for the downstream model.",
-  "order": 60,
-  "fallback": {
-    "reason": "Classifier failed; no memory queries generated.",
-    "certainty": "no_signal",
-    "output": {
-      "queries": []
-    }
-  },
+  "dispatch_order": 60,
   "output_schema": {
-    "type": "object",
-    "additionalProperties": false,
     "required": ["queries"],
     "properties": {
       "queries": {
@@ -27,5 +17,10 @@
         "uniqueItems": true
       }
     }
+  },
+  "fallback": {
+    "reason": "Classifier failed; no memory queries generated.",
+    "certainty": "no_signal",
+    "queries": []
   }
 }

package/dist/src/classifiers/{custom/memory_retrieval_queries → memory_retrieval_queries}/prompt.md

@@ -1,5 +1,5 @@
 You are the memory_retrieval_queries classifier for an AI assistant routing system.
 
-`output.queries` is an array of short search strings the caller may use against its own memory store.
-Return an empty queries array when saved memories are unlikely to improve the downstream answer.
+`queries` is an array of short search strings the caller may use against its own memory store.
+Return an empty `queries` array when saved memories are unlikely to improve the downstream answer.
 Do not invent known facts about the user; only produce retrieval queries grounded in likely missing user context.

package/dist/src/classifiers/{stock/model_specialization → model_specialization}/manifest.json

@@ -1,9 +1,9 @@
 {
-  "kind": "stock",
   "name": "model_specialization",
   "version": "1.0.0",
   "purpose": "Choose the most accurate model specialty for serving the target message well.",
-  "order": 30,
+  "dispatch_order": 30,
+  "reserved_fields": ["model_specialization"],
   "fallback": {
     "reason": "Classifier failed; no specialization signal.",
     "certainty": "no_signal"

package/dist/src/classifiers/model_specialization/prompt.md

@@ -0,0 +1,5 @@
+You are the model specialization classifier for an AI assistant routing system.
+
+Pick the prompt/model specialization that best fits the target user message. Emit only `model_specialization`; do not infer tier, tools, or prompt-injection risk — other classifiers own those axes.
+
+Omit `model_specialization` when you cannot pick with reasonable certainty.

package/dist/src/classifiers/model_tier/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "model_tier",
+  "version": "1.0.0",
+  "purpose": "Recommend the downstream model tier.",
+  "dispatch_order": 20,
+  "reserved_fields": ["model_tier"],
+  "fallback": {
+    "reason": "Classifier failed; no model tier signal.",
+    "certainty": "no_signal"
+  }
+}

package/dist/src/classifiers/model_tier/prompt.md

@@ -0,0 +1,5 @@
+You are the model_tier classifier for an AI assistant routing system.
+
+Pick the coarse model tier that best fits the target user message. Emit only `model_tier`; do not infer specialization, tools, or prompt-injection risk — other classifiers own those axes.
+
+Prefer the weakest tier that should still succeed. Omit `model_tier` rather than guessing when the right tier is not clear.

package/dist/src/classifiers/preflight/manifest.json

@@ -0,0 +1,35 @@
+{
+  "name": "preflight",
+  "version": "1.1.0",
+  "purpose": "Assess whether the latest message can be answered immediately (final_reply) or should route downstream with an acknowledgement (ack_reply). Always emits exactly one.",
+  "dispatch_order": 10,
+  "reserved_fields": ["final_reply", "ack_reply"],
+  "output_schema": {
+    "examples": [
+      {
+        "reason": "Simple greeting — answerable directly.",
+        "certainty": "near_certain",
+        "final_reply": { "text": "Hi!" }
+      },
+      {
+        "reason": "Trivial arithmetic — answerable directly.",
+        "certainty": "very_strong",
+        "final_reply": { "text": "4" }
+      },
+      {
+        "reason": "Code review task requires substantive downstream work.",
+        "certainty": "very_strong",
+        "ack_reply": { "text": "On it — reviewing the code now." }
+      },
+      {
+        "reason": "Reminder request requires downstream action.",
+        "certainty": "strong",
+        "ack_reply": { "text": "Got it, I'll set that reminder for 3pm." }
+      }
+    ]
+  },
+  "fallback": {
+    "reason": "Classifier failed; no preflight signal.",
+    "certainty": "no_signal"
+  }
+}

package/dist/src/classifiers/preflight/prompt.md

@@ -0,0 +1,16 @@
+You are the preflight classifier for an AI assistant routing system.
+
+Your primary task is to assess: **can you fully answer the target message yourself**, given the conversation history? Make this judgment first — the reply text follows from it.
+
+**Step 1 — assess whether you can fully answer:**
+Ask yourself: Is the intent clear? Is the answer fully derivable from context right now, without real-time data, external tools, code execution, non-trivial generation, analysis, or judgment? Would a one-sentence reply genuinely resolve the request?
+
+If yes → emit `final_reply` with the complete answer.
+
+If no (the downstream model should handle it) → emit `ack_reply` with a brief, contextually specific acknowledgement that shows you understood the request. The ack must reflect the actual request — not a generic "On it." — so the user knows their message was understood while the model works.
+
+**Rule: always emit exactly one of `final_reply` or `ack_reply`. Never emit both. Never emit neither.**
+
+- `final_reply` is for tiny terminal answers only: greetings, thanks, spelling lookups, simple arithmetic, yes/no factual questions answerable from context. If answering requires drafting, rewriting, analysis, coding, research, planning, or any substantive generation — use `ack_reply` instead.
+- `ack_reply` text must not contain the answer. It acknowledges the request and confirms it is being worked on.
+- Do not address the user anywhere except inside `final_reply.text` or `ack_reply.text`.

package/dist/src/classifiers/prompt_injection/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "prompt_injection",
+  "version": "1.0.0",
+  "purpose": "Assess whether the target message contains prompt-injection attempts.",
+  "dispatch_order": 50,
+  "applies_to": "both",
+  "reserved_fields": ["risk_level"],
+  "output_schema": {
+    "required": ["risk_level"]
+  },
+  "fallback": {
+    "reason": "Classifier failed; prompt-injection risk could not be assessed.",
+    "certainty": "no_signal"
+  }
+}