@llm-dev-ops/agentics-cli 1.4.26 → 1.4.29

package/dist/bundled-agents/sentinel-agents/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@llm-dev-ops/sentinel-cli",
+  "version": "0.1.3",
+  "description": "Enterprise-grade anomaly detection and observability platform for LLM applications - NPM CLI wrapper",
+  "keywords": [
+    "llm",
+    "anomaly-detection",
+    "observability",
+    "monitoring",
+    "sentinel",
+    "rust",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/globalbusinessadvisors/llm-sentinel.git"
+  },
+  "homepage": "https://github.com/globalbusinessadvisors/llm-sentinel",
+  "license": "Apache-2.0",
+  "author": "LLM DevOps Team <noreply@llm-sentinel.dev>",
+  "bin": {
+    "sentinel": "./bin/cli.js",
+    "llm-sentinel": "./bin/cli.js"
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "gcp-build": "tsc"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "optionalDependencies": {
+    "@llm-dev-ops/sentinel-cli-darwin-arm64": "0.1.3",
+    "@llm-dev-ops/sentinel-cli-darwin-x64": "0.1.3",
+    "@llm-dev-ops/sentinel-cli-linux-x64": "0.1.3",
+    "@llm-dev-ops/sentinel-cli-win32-x64": "0.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@google-cloud/functions-framework": "^3.4.0",
+    "claude-flow": "^3.0.0-alpha.179",
+    "cors": "^2.8.6",
+    "express": "^4.22.1",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/dist/bundled-agents/sentinel-agents/src/agents/alert.ts

@@ -0,0 +1,46 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+export async function handleAlert(req: Request, res: Response): Promise<void> {
+  const { payload, context } = req.body;
+  const start = Date.now();
+
+  const layers: string[] = [
+    "input_validation",
+    "rule_evaluation",
+    "suppression_check",
+    "decision_generation",
+    "response_formatting",
+  ];
+
+  const anomaly = payload?.anomaly ?? {};
+  const source: string = payload?.source ?? "api";
+  const ignoreSuppression: boolean = payload?.ignore_suppression ?? false;
+  const dryRun: boolean = payload?.dry_run ?? false;
+
+  const decisionId = uuidv4();
+
+  const result = {
+    agent: "alert",
+    decision: {
+      decision_id: decisionId,
+      alert_raised: false,
+      confidence: 0.0,
+      source,
+    },
+    alert_raised: false,
+    status: "no_alert",
+    dry_run: dryRun,
+    processing_ms: Date.now() - start,
+  };
+
+  res.json({
+    ...result,
+    layers_executed: layers,
+    execution_metadata: {
+      trace_id: uuidv4(),
+      timestamp: new Date().toISOString(),
+      service: "sentinel-agents",
+    },
+  });
+}

package/dist/bundled-agents/sentinel-agents/src/agents/anomaly.ts

@@ -0,0 +1,33 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+export async function handleAnomaly(req: Request, res: Response): Promise<void> {
+  const { payload, context } = req.body;
+  const start = Date.now();
+
+  const layers: string[] = ["input_validation", "anomaly_detection", "response_formatting"];
+
+  const telemetry = payload?.telemetry ?? {};
+  const dryRun = payload?.dry_run ?? false;
+
+  const result = {
+    agent: "anomaly",
+    anomaly_detected: false,
+    anomaly: null as unknown,
+    status: "success",
+    dry_run: dryRun,
+    processing_ms: 0,
+  };
+
+  result.processing_ms = Date.now() - start;
+
+  res.json({
+    ...result,
+    layers_executed: layers,
+    execution_metadata: {
+      trace_id: uuidv4(),
+      timestamp: new Date().toISOString(),
+      service: "sentinel-agents",
+    },
+  });
+}

package/dist/bundled-agents/sentinel-agents/src/agents/correlation.ts

@@ -0,0 +1,56 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+export async function handleCorrelation(req: Request, res: Response): Promise<void> {
+  const { payload, context } = req.body;
+  const start = Date.now();
+
+  const layers: string[] = [
+    "input_validation",
+    "signal_grouping",
+    "temporal_correlation",
+    "service_affinity",
+    "response_formatting",
+  ];
+
+  const signals: unknown[] = payload?.signals ?? [];
+  const timeWindowSecs: number = payload?.time_window_secs ?? 300;
+  const dryRun: boolean = payload?.dry_run ?? false;
+
+  if (!Array.isArray(signals) || signals.length === 0) {
+    res.status(400).json({
+      agent: "correlation",
+      incidents_count: 0,
+      signals_processed: 0,
+      noise_reduction: 0,
+      status: "No signals provided",
+      layers_executed: ["input_validation"],
+      execution_metadata: {
+        trace_id: uuidv4(),
+        timestamp: new Date().toISOString(),
+        service: "sentinel-agents",
+      },
+    });
+    return;
+  }
+
+  const result = {
+    agent: "correlation",
+    incidents_count: 0,
+    signals_processed: signals.length,
+    noise_reduction: 0.0,
+    status: "success",
+    dry_run: dryRun,
+    processing_ms: Date.now() - start,
+  };
+
+  res.json({
+    ...result,
+    layers_executed: layers,
+    execution_metadata: {
+      trace_id: uuidv4(),
+      timestamp: new Date().toISOString(),
+      service: "sentinel-agents",
+    },
+  });
+}

package/dist/bundled-agents/sentinel-agents/src/agents/drift.ts

@@ -0,0 +1,54 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+export async function handleDrift(req: Request, res: Response): Promise<void> {
+  const { payload, context } = req.body;
+  const start = Date.now();
+
+  const layers: string[] = ["input_validation", "distribution_analysis", "psi_calculation", "response_formatting"];
+
+  const referenceData: number[] = payload?.reference_data ?? [];
+  const currentData: number[] = payload?.current_data ?? [];
+  const metric: string = payload?.metric ?? "unknown";
+  const service: string = payload?.service ?? "unknown";
+  const dryRun: boolean = payload?.dry_run ?? false;
+
+  if (referenceData.length < 10 || currentData.length < 10) {
+    res.status(400).json({
+      agent: "drift",
+      drift_detected: false,
+      drift_severity: "error",
+      psi_value: 0,
+      status: "Insufficient data: minimum 10 samples required",
+      layers_executed: ["input_validation"],
+      execution_metadata: {
+        trace_id: uuidv4(),
+        timestamp: new Date().toISOString(),
+        service: "sentinel-agents",
+      },
+    });
+    return;
+  }
+
+  const result = {
+    agent: "drift",
+    drift_detected: false,
+    drift_severity: "none",
+    psi_value: 0.05,
+    metric,
+    service,
+    status: "success",
+    dry_run: dryRun,
+    processing_ms: Date.now() - start,
+  };
+
+  res.json({
+    ...result,
+    layers_executed: layers,
+    execution_metadata: {
+      trace_id: uuidv4(),
+      timestamp: new Date().toISOString(),
+      service: "sentinel-agents",
+    },
+  });
+}

package/dist/bundled-agents/sentinel-agents/src/agents/rca.ts

@@ -0,0 +1,38 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+export async function handleRca(req: Request, res: Response): Promise<void> {
+  const { payload, context } = req.body;
+  const start = Date.now();
+
+  const layers: string[] = [
+    "input_validation",
+    "signal_analysis",
+    "hypothesis_generation",
+    "causal_chain_identification",
+    "response_formatting",
+  ];
+
+  const incident = payload?.incident ?? {};
+  const maxHypotheses: number = payload?.max_hypotheses ?? 5;
+  const dryRun: boolean = payload?.dry_run ?? false;
+
+  const result = {
+    agent: "rca",
+    hypotheses_count: 0,
+    confidence: 0.0,
+    status: "success",
+    dry_run: dryRun,
+    processing_ms: Date.now() - start,
+  };
+
+  res.json({
+    ...result,
+    layers_executed: layers,
+    execution_metadata: {
+      trace_id: uuidv4(),
+      timestamp: new Date().toISOString(),
+      service: "sentinel-agents",
+    },
+  });
+}

package/dist/bundled-agents/sentinel-agents/src/index.ts

@@ -0,0 +1,77 @@
+import express, { Request, Response, NextFunction } from "express";
+import cors from "cors";
+import { handleAnomaly } from "./agents/anomaly";
+import { handleDrift } from "./agents/drift";
+import { handleAlert } from "./agents/alert";
+import { handleCorrelation } from "./agents/correlation";
+import { handleRca } from "./agents/rca";
+
+const app = express();
+
+// ---------------------------------------------------------------------------
+// Middleware
+// ---------------------------------------------------------------------------
+
+app.use(express.json());
+
+app.use(
+  cors({
+    origin: "*",
+    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowedHeaders: [
+      "X-Correlation-ID",
+      "X-API-Version",
+      "Content-Type",
+      "Authorization",
+    ],
+  })
+);
+
+// ---------------------------------------------------------------------------
+// Health endpoint
+// ---------------------------------------------------------------------------
+
+app.get("/health", (_req: Request, res: Response) => {
+  res.json({
+    healthy: true,
+    service: "sentinel-agents",
+    agents: 5,
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Agent routes — POST /v1/sentinel/:agent
+// ---------------------------------------------------------------------------
+
+const agentHandlers: Record<string, (req: Request, res: Response) => Promise<void>> = {
+  anomaly: handleAnomaly,
+  drift: handleDrift,
+  alert: handleAlert,
+  correlation: handleCorrelation,
+  rca: handleRca,
+};
+
+app.post("/v1/sentinel/:agent", async (req: Request, res: Response, next: NextFunction) => {
+  const { agent } = req.params;
+  const handler = agentHandlers[agent];
+
+  if (!handler) {
+    res.status(404).json({
+      error: `Unknown agent: ${agent}`,
+      available_agents: Object.keys(agentHandlers),
+    });
+    return;
+  }
+
+  try {
+    await handler(req, res);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Export for Cloud Functions
+// ---------------------------------------------------------------------------
+
+export const api = app;

package/dist/bundled-agents/shield-agents/functions/index.ts

@@ -0,0 +1,311 @@
+/**
+ * @module shield-agents
+ * @description Cloud Function entry point for LLM-Shield agents.
+ *
+ * Domain: shield
+ * Cloud Function: shield-agents
+ * Deployed to: https://us-central1-agentics-dev.cloudfunctions.net/shield-agents
+ *
+ * Entry point: `api` (Express app)
+ *
+ * Routes:
+ *   POST /v1/shield/prompt-injection
+ *   POST /v1/shield/pii
+ *   POST /v1/shield/redaction
+ *   POST /v1/shield/secrets
+ *   POST /v1/shield/toxicity
+ *   POST /v1/shield/safety-boundary
+ *   POST /v1/shield/moderation
+ *   POST /v1/shield/abuse
+ *   POST /v1/shield/credential-exposure
+ *   GET  /health
+ */
+
+import express, { Request, Response, NextFunction } from 'express';
+import { randomUUID } from 'crypto';
+
+// =============================================================================
+// AGENT REGISTRY
+// =============================================================================
+
+interface AgentEntry {
+  route: string;
+  name: string;
+  description: string;
+  /** Factory that returns an async handler: (payload, context) => result */
+  load: () => Promise<AgentHandler>;
+}
+
+type AgentHandler = (payload: unknown, context: unknown) => Promise<unknown>;
+
+const AGENT_REGISTRY: AgentEntry[] = [
+  {
+    route: 'prompt-injection',
+    name: 'Prompt Injection Detection',
+    description: 'Detects prompt injection attempts in LLM input content',
+    load: async () => {
+      const mod = await import('../../prompt-injection-detection/dist/agent.js');
+      const agent = mod.createAgent();
+      return async (payload: any, context: any) => {
+        const input = {
+          content: payload?.content ?? '',
+          context: {
+            execution_ref: context?.execution_ref ?? randomUUID(),
+            timestamp: new Date().toISOString(),
+            content_source: context?.content_source ?? 'user_input',
+            ...context,
+          },
+          sensitivity: payload?.sensitivity,
+          detect_categories: payload?.detect_categories,
+        };
+        const validated = agent.validateInput(input);
+        return agent.detect(validated);
+      };
+    },
+  },
+  {
+    route: 'pii',
+    name: 'PII Detection',
+    description: 'Detects personally identifiable information',
+    load: async () => {
+      const mod = await import('../../pii-detection/dist/agent.js');
+      const agent = new mod.PIIDetectionAgent({});
+      return async (payload: any, _context: any) => agent.detect(payload);
+    },
+  },
+  {
+    route: 'redaction',
+    name: 'Data Redaction',
+    description: 'Redacts sensitive data from content',
+    load: async () => {
+      const mod = await import('../../data-redaction/dist/index.js');
+      const agent = new mod.DataRedactionAgent();
+      return async (payload: any, context: any) => {
+        const input = {
+          content: payload?.content ?? '',
+          context: {
+            execution_ref: context?.execution_ref ?? randomUUID(),
+            timestamp: new Date().toISOString(),
+            content_source: context?.content_source ?? 'user_input',
+            ...context,
+          },
+          sensitivity: payload?.sensitivity ?? 0.7,
+          redaction_strategy: payload?.redaction_strategy,
+          pii_types: payload?.pii_types,
+          secret_types: payload?.secret_types,
+          detect_pii: payload?.detect_pii ?? true,
+          detect_secrets: payload?.detect_secrets ?? true,
+          detect_credentials: payload?.detect_credentials ?? true,
+          min_confidence_threshold: payload?.min_confidence_threshold ?? 0.8,
+          return_redacted_content: payload?.return_redacted_content ?? true,
+          partial_mask_chars: payload?.partial_mask_chars ?? 4,
+        };
+        return agent.process(input);
+      };
+    },
+  },
+  {
+    route: 'secrets',
+    name: 'Secrets Leakage',
+    description: 'Detects API keys and secrets leakage',
+    load: async () => {
+      const mod = await import('../../secrets-leakage-detection/dist/handler.js');
+      return async (payload: any, _context: any) => mod.handleDetection(payload);
+    },
+  },
+  {
+    route: 'toxicity',
+    name: 'Toxicity Detection',
+    description: 'Detects toxic content',
+    load: async () => {
+      const mod = await import('../../toxicity-detection/dist/agent.js');
+      const agent = new mod.ToxicityDetectionAgent({});
+      return async (payload: any, _context: any) => agent.detect(payload);
+    },
+  },
+  {
+    route: 'safety-boundary',
+    name: 'Safety Boundary',
+    description: 'Enforces safety boundaries',
+    load: async () => {
+      const mod = await import('../../safety-boundary/dist/handler.js');
+      return async (payload: any, _context: any) => {
+        const edgeReq = {
+          method: 'POST',
+          url: '/detect',
+          headers: { 'content-type': 'application/json' },
+          body: payload,
+          json: async () => payload,
+        };
+        const res = await mod.handler(edgeReq);
+        return res.body;
+      };
+    },
+  },
+  {
+    route: 'moderation',
+    name: 'Content Moderation',
+    description: 'Content moderation enforcement',
+    load: async () => {
+      const mod = await import('../../content-moderation/dist/handler.js');
+      return async (payload: any, _context: any) => {
+        const edgeReq = {
+          method: 'POST',
+          url: '/detect',
+          headers: { 'content-type': 'application/json' },
+          body: payload,
+          json: async () => payload,
+        };
+        const res = await mod.handler(edgeReq);
+        return res.body;
+      };
+    },
+  },
+  {
+    route: 'abuse',
+    name: 'Model Abuse Detection',
+    description: 'Detects model abuse patterns',
+    load: async () => {
+      const mod = await import('../../model-abuse-detection/dist/handler.js');
+      return async (payload: any, _context: any) => mod.handleDetection(payload);
+    },
+  },
+  {
+    route: 'credential-exposure',
+    name: 'Credential Exposure',
+    description: 'Detects exposed credentials',
+    load: async () => {
+      const mod = await import('../../credential-exposure-detection/dist/handler.js');
+      return async (payload: any, _context: any) => mod.handleDetection(payload);
+    },
+  },
+];
+
+// =============================================================================
+// LAZY HANDLER CACHE
+// =============================================================================
+
+const handlerCache = new Map<string, AgentHandler>();
+
+async function getHandler(entry: AgentEntry): Promise<AgentHandler> {
+  const cached = handlerCache.get(entry.route);
+  if (cached) return cached;
+
+  const handler = await entry.load();
+  handlerCache.set(entry.route, handler);
+  return handler;
+}
+
+// =============================================================================
+// EXECUTION METADATA HELPER
+// =============================================================================
+
+function buildExecutionMetadata(): {
+  trace_id: string;
+  timestamp: string;
+  service: string;
+} {
+  return {
+    trace_id: randomUUID(),
+    timestamp: new Date().toISOString(),
+    service: 'shield-agents',
+  };
+}
+
+// =============================================================================
+// EXPRESS APP
+// =============================================================================
+
+const app = express();
+
+// Parse JSON bodies
+app.use(express.json({ limit: '1mb' }));
+
+// CORS middleware
+app.use((_req: Request, res: Response, next: NextFunction) => {
+  res.set('Access-Control-Allow-Origin', '*');
+  res.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.set(
+    'Access-Control-Allow-Headers',
+    'X-Correlation-ID, X-API-Version, Content-Type, Authorization',
+  );
+  if (_req.method === 'OPTIONS') {
+    res.status(204).end();
+    return;
+  }
+  next();
+});
+
+// -----------------------------------------------------------------------------
+// GET /health
+// -----------------------------------------------------------------------------
+app.get('/health', (_req: Request, res: Response) => {
+  res.json({
+    healthy: true,
+    service: 'shield-agents',
+    agents: AGENT_REGISTRY.length,
+  });
+});
+
+// -----------------------------------------------------------------------------
+// POST /v1/shield/:agent  — unified agent dispatch
+// -----------------------------------------------------------------------------
+for (const entry of AGENT_REGISTRY) {
+  app.post(`/v1/shield/${entry.route}`, async (req: Request, res: Response) => {
+    const execution_metadata = buildExecutionMetadata();
+    const layers_executed: string[] = ['input_validation'];
+
+    try {
+      // Expect { agent?, payload, context? } or treat entire body as payload
+      const body = req.body ?? {};
+      const payload = body.payload ?? body;
+      const context = body.context ?? {};
+
+      layers_executed.push('agent_dispatch');
+
+      const handler = await getHandler(entry);
+      const result = await handler(payload, context);
+
+      layers_executed.push('response_envelope');
+
+      res.json({
+        result,
+        execution_metadata,
+        layers_executed,
+      });
+    } catch (error) {
+      layers_executed.push('error_handling');
+
+      const message = error instanceof Error
+        ? error.message
+        : typeof error === 'object' && error !== null
+          ? JSON.stringify(error)
+          : String(error);
+      const status = (typeof error === 'object' && error !== null && 'code' in error)
+        ? 400
+        : 500;
+      res.status(status).json({
+        error: message,
+        execution_metadata,
+        layers_executed,
+      });
+    }
+  });
+}
+
+// 404 fallback
+app.use((req: Request, res: Response) => {
+  const execution_metadata = buildExecutionMetadata();
+  res.status(404).json({
+    error: 'Not Found',
+    message: `No route for ${req.method} ${req.path}`,
+    available_routes: AGENT_REGISTRY.map((e) => `POST /v1/shield/${e.route}`),
+    execution_metadata,
+    layers_executed: ['routing'],
+  });
+});
+
+// =============================================================================
+// EXPORT — Cloud Function entry point
+// =============================================================================
+export const api = app;