import { TealGuard } from "tealtiger";

const guard = new TealGuard(config: TealGuardConfig);

interface TealGuardConfig {
  // Defense depth (NEW in v1.4)
  depth?: "fast" | "standard" | "deep";  // Default: "fast"

  // Enforcement mode
  mode?: "ENFORCE" | "MONITOR" | "REPORT_ONLY";  // Default: "ENFORCE"

  // Bi-directional guardrails (NEW in v1.4)
  guardrails?: {
    pre?: GuardrailConfig;
    post?: GuardrailConfig;
  };

  // Role-based policy (NEW in v1.4)
  policy?: RolePolicy;

  // Existing v1.3 options (still supported)
  pii?: boolean | PIIConfig;
  secrets?: boolean;
  injection?: boolean;
  content?: boolean | ContentConfig;
}

type Depth = "fast" | "standard" | "deep";

// Minimal latency — catches patterns only
const guard = new TealGuard({ depth: "fast" });

// Balanced — catches patterns + structural threats
const guard = new TealGuard({ depth: "standard" });

// Maximum coverage — adds ONNX classifier
const guard = new TealGuard({ depth: "deep" });

interface GuardrailConfig {
  pii?: boolean | PIIGuardrailConfig;
  secrets?: boolean;
  injection?: boolean;
  content?: boolean | ContentPolicyConfig;
  mode?: "ENFORCE" | "MONITOR" | "REPORT_ONLY";
}

interface PIIGuardrailConfig {
  categories?: ("email" | "phone" | "ssn" | "credit_card" | "passport" | "drivers_license")[];
}

interface ContentPolicyConfig {
  policy?: string;
}

const guard = new TealGuard({
  guardrails: {
    pre: { pii: true, secrets: true, injection: true }
  }
});

const guard = new TealGuard({
  guardrails: {
    post: { pii: true, secrets: true, content: true }
  }
});

const guard = new TealGuard({
  guardrails: {
    pre: {
      pii: { categories: ["ssn", "credit_card"] },
      secrets: true,
      injection: true
    },
    post: {
      pii: true,
      secrets: true,
      content: true
    }
  }
});

const guard = new TealGuard({
  guardrails: {
    pre: { pii: true, secrets: true, mode: "ENFORCE" },
    post: { pii: true, secrets: true, mode: "MONITOR" }
  }
});

async evaluate(request: GovernanceRequest): Promise<GovernanceDecision>

interface GovernanceDecision {
  // Core decision
  action: "ALLOW" | "DENY" | "SANITIZE" | "REPORT";
  riskScore: number;
  reasonCodes: string[];

  // Multi-stage fields (NEW in v1.4)
  stagesEvaluated: string[];
  stageResults: StageResult[];
  shortCircuited: boolean;
  totalLatencyMs: number;

  // Phase identifier (NEW in v1.4)
  phase: "pre" | "post";

  // Existing fields
  correlationId: string;
  timestamp: number;
  agentId?: string;
}

interface StageResult {
  stage: "stage1" | "stage2" | "stage3";
  action: "PASS" | "DENY";
  latencyMs: number;
  findings: Finding[];
}

interface Finding {
  type: string;       // "PII", "SECRET", "INJECTION", "HARMFUL_CONTENT"
  pattern?: string;   // Pattern that matched (e.g., "openai_api_key")
  category?: string;  // Finding category
  confidence: number; // 0-1
  severity: string;   // "low", "medium", "high", "critical"
}

const decision = await guard.evaluate({
  content: "My API key is sk-proj-abc123...",
  agentId: "test-agent",
  toolName: "send_email"
});

console.log(decision.action);            // "DENY"
console.log(decision.stagesEvaluated);   // ["stage1"]
console.log(decision.shortCircuited);    // true
console.log(decision.stageResults[0]);
// { stage: "stage1", action: "DENY", latencyMs: 2,
//   findings: [{ type: "SECRET", pattern: "openai_api_key", confidence: 0.99, severity: "critical" }] }

async evaluateResponse(response: GovernanceResponse): Promise<GovernanceDecision>

interface GovernanceResponse {
  content: string;
  agentId?: string;
  correlationId?: string;
  model?: string;
  provider?: string;
}

// Check a model output before returning to the caller
const postDecision = await guard.evaluateResponse({
  content: modelOutput,
  agentId: "my-agent",
  correlationId: requestCorrelationId
});

if (postDecision.action === "DENY") {
  // Response blocked — don't return to caller
  throw new Error(`Response blocked: ${postDecision.reasonCodes.join(", ")}`);
}

// Input contains an obvious secret pattern
const decision = await guard.evaluate({ content: "sk-proj-abc123xyz..." });

console.log(decision.stagesEvaluated);  // ["stage1"]  — Stages 2 and 3 skipped
console.log(decision.shortCircuited);   // true
console.log(decision.totalLatencyMs);   // 2ms — only Stage 1 latency

import { observe } from "tealtiger";
import { TealGuard } from "tealtiger";
import OpenAI from "openai";

const guard = new TealGuard({
  depth: "standard",
  guardrails: {
    pre: { pii: true, secrets: true },
    post: { pii: true, secrets: true }
  }
});

const client = observe(new OpenAI(), { guard });

// Pre-scan and post-scan happen automatically for every request
const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello" }]
});

// v1.3 style — still works, equivalent to depth: "fast", pre-only guardrails
const guard = new TealGuard({
  pii: true,
  secrets: true,
  injection: true,
  mode: "ENFORCE"
});