@neuroverseos/governance 0.3.1 → 0.3.4

package/dist/chunk-VXHSMA3I.js

@@ -0,0 +1,166 @@
+import {
+  createProvider
+} from "./chunk-INWQHLPS.js";
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+
+// src/engine/intent-classifier.ts
+function buildSystemPrompt(knownIntents) {
+  let prompt = `You are an intent classifier for an AI governance system. Your job is to analyze structured content fields and produce a clean, semantic intent label.
+
+CRITICAL RULES:
+1. Distinguish WHO is performing the action. If the AI agent says "I am escalating your request", that is the AI being polite \u2014 NOT the customer demanding escalation.
+2. Focus on the CUSTOMER'S actual intent, not the AI's response language.
+3. Return a short, snake_case intent label (e.g. "shipping_inquiry", "complaint_escalation", "password_reset").
+4. Assess the actor: who initiated this action? The customer, the AI agent, or the system?
+
+You must respond with ONLY valid JSON in this exact format:
+{"intent": "<label>", "confidence": <0-1>, "actor": "<customer|ai_agent|system|unknown>", "reasoning": "<one sentence>"}`;
+  if (knownIntents && knownIntents.length > 0) {
+    prompt += `
+
+Preferred intent labels (use these when applicable, but you may create new ones if none fit):
+${knownIntents.map((i) => `- ${i}`).join("\n")}`;
+  }
+  return prompt;
+}
+function buildUserPrompt(fields) {
+  const parts = [];
+  if (fields.customer_input) {
+    parts.push(`CUSTOMER INPUT:
+${fields.customer_input}`);
+  }
+  if (fields.draft_reply) {
+    parts.push(`AI DRAFT REPLY:
+${fields.draft_reply}`);
+  }
+  if (fields.tool) {
+    parts.push(`TOOL: ${fields.tool}`);
+  }
+  if (fields.context) {
+    parts.push(`CONTEXT: ${fields.context}`);
+  }
+  if (fields.raw && parts.length === 0) {
+    parts.push(`RAW TEXT:
+${fields.raw}`);
+  }
+  return parts.join("\n\n");
+}
+async function classifyIntentWithAI(fields, options) {
+  const provider = createProvider(options.ai);
+  const systemPrompt = buildSystemPrompt(options.knownIntents);
+  const userPrompt = buildUserPrompt(fields);
+  const response = await provider.complete(systemPrompt, userPrompt);
+  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Intent classifier returned non-JSON response");
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.intent || typeof parsed.intent !== "string") {
+    throw new Error("Intent classifier returned invalid intent label");
+  }
+  return {
+    intent: parsed.intent,
+    confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+    actor: ["customer", "ai_agent", "system", "unknown"].includes(
+      parsed.actor
+    ) ? parsed.actor : "unknown",
+    reasoning: parsed.reasoning ?? ""
+  };
+}
+var OUTPUT_CONTENT_FIELDS = /* @__PURE__ */ new Set([
+  "draft_reply",
+  "content",
+  "body",
+  "message",
+  "text",
+  "reply",
+  "response",
+  "output",
+  "html",
+  "template"
+]);
+function extractContentFields(intent, args) {
+  if (!args) {
+    return { raw: intent };
+  }
+  const fields = {};
+  let hasStructuredContent = false;
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value !== "string") continue;
+    const lowerKey = key.toLowerCase();
+    if (OUTPUT_CONTENT_FIELDS.has(lowerKey)) {
+      fields.draft_reply = fields.draft_reply ? `${fields.draft_reply}
+
+${value}` : value;
+      hasStructuredContent = true;
+    }
+  }
+  if (hasStructuredContent) {
+    fields.customer_input = intent;
+  } else {
+    fields.raw = intent;
+  }
+  return fields;
+}
+
+// src/engine/ai-guard.ts
+async function evaluateGuardWithAI(event, world, options = {}) {
+  if (!options.ai) {
+    const verdict = evaluateGuard(event, world, options);
+    verdict.intent_source = "raw";
+    return verdict;
+  }
+  const fallbackOnError = options.fallbackOnError ?? true;
+  const originalIntent = event.intent;
+  const knownIntents = options.knownIntents ?? extractKnownIntents(world);
+  const contentFields = options.contentFields ?? extractContentFields(event.intent, event.args);
+  try {
+    const classification = await classifyIntentWithAI(contentFields, {
+      ai: options.ai,
+      knownIntents
+    });
+    const classifiedEvent = {
+      ...event,
+      intent: classification.intent
+    };
+    const verdict = evaluateGuard(classifiedEvent, world, options);
+    verdict.intent_source = "ai";
+    verdict.classification = classification;
+    verdict.originalIntent = originalIntent;
+    return verdict;
+  } catch (err) {
+    if (fallbackOnError) {
+      const verdict = evaluateGuard(event, world, options);
+      verdict.intent_source = "fallback";
+      verdict.originalIntent = originalIntent;
+      return verdict;
+    }
+    throw err;
+  }
+}
+function extractKnownIntents(world) {
+  const vocab = world.guards?.intent_vocabulary;
+  if (!vocab) return [];
+  return Object.keys(vocab);
+}
+
+// src/contracts/guard-contract.ts
+var GUARD_EXIT_CODES = {
+  ALLOW: 0,
+  BLOCK: 1,
+  PAUSE: 2,
+  ERROR: 3,
+  MODIFY: 4,
+  PENALIZE: 5,
+  REWARD: 6,
+  NEUTRAL: 7
+};
+
+export {
+  classifyIntentWithAI,
+  extractContentFields,
+  evaluateGuardWithAI,
+  GUARD_EXIT_CODES
+};