@vorionsys/atsf-core 0.2.3 → 0.3.0

package/dist/api/server.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2024-2026 Vorion LLC
 /**
  * API Server
  *
@@ -5,19 +7,19 @@
  *
  * @packageDocumentation
  */
-import Fastify from "fastify";
-import cors from "@fastify/cors";
-import helmet from "@fastify/helmet";
-import rateLimit from "@fastify/rate-limit";
-import { createLogger } from "../common/logger.js";
-import { getConfig } from "../common/config.js";
-import { PersistentIntentService } from "../intent/persistent-intent-service.js";
-import { createProofService } from "../proof/index.js";
-import { createTrustEngine } from "../trust-engine/index.js";
-import { createEvaluator } from "../basis/evaluator.js";
-import { createGovernanceEngine } from "../governance/index.js";
-import { GovernanceProofBridge } from "../governance/proof-bridge.js";
-const apiLogger = createLogger({ component: "api" });
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import helmet from '@fastify/helmet';
+import rateLimit from '@fastify/rate-limit';
+import { createLogger } from '../common/logger.js';
+import { getConfig } from '../common/config.js';
+import { PersistentIntentService } from '../intent/persistent-intent-service.js';
+import { createProofService } from '../proof/index.js';
+import { createTrustEngine } from '../trust-engine/index.js';
+import { createEvaluator } from '../basis/evaluator.js';
+import { createGovernanceEngine } from '../governance/index.js';
+import { GovernanceProofBridge } from '../governance/proof-bridge.js';
+const apiLogger = createLogger({ component: 'api' });
 // ============================================================
 // Health Check Implementation
 // ============================================================
@@ -43,15 +45,15 @@ function checkSystemHealth(startTime) {
     const metrics = getSystemMetrics(startTime);
     // Warning threshold: 80% memory usage
     // Error threshold: 95% memory usage
-    let status = "ok";
-    let message = "System healthy";
+    let status = 'ok';
+    let message = 'System healthy';
     if (metrics.memoryUsagePercent > 95) {
-        status = "error";
-        message = "Critical memory pressure";
+        status = 'error';
+        message = 'Critical memory pressure';
     }
     else if (metrics.memoryUsagePercent > 80) {
-        status = "degraded";
-        message = "High memory usage";
+        status = 'degraded';
+        message = 'High memory usage';
     }
     return {
         status,
@@ -71,16 +73,16 @@ async function checkService(name, checkFn) {
     try {
         await checkFn();
         return {
-            status: "ok",
+            status: 'ok',
             latencyMs: Date.now() - start,
             message: `${name} operational`,
         };
     }
     catch (error) {
         return {
-            status: "error",
+            status: 'error',
             latencyMs: Date.now() - start,
-            message: `${name} error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            message: `${name} error: ${error instanceof Error ? error.message : 'Unknown error'}`,
         };
     }
 }
@@ -101,45 +103,41 @@ export async function createServer(deps) {
             const proof = await proofService.create(req);
             return { id: proof.id };
         },
-        tenantId: "__system__",
+        tenantId: '__system__',
     });
     // Use pino logger config for Fastify 5
-    const isTest = process.env["NODE_ENV"] === "test" || process.env["VITEST"];
+    const isTest = process.env['NODE_ENV'] === 'test' || process.env['VITEST'];
     const server = Fastify({
-        logger: isTest
-            ? false
-            : {
-                level: config.env === "production" ? "info" : "debug",
-                transport: config.env !== "production"
-                    ? {
-                        target: "pino-pretty",
-                        options: { colorize: true },
-                    }
-                    : undefined,
-            },
-        requestIdHeader: "x-request-id",
-        requestIdLogLabel: "requestId",
+        logger: isTest ? false : {
+            level: config.env === 'production' ? 'info' : 'debug',
+            transport: config.env !== 'production' ? {
+                target: 'pino-pretty',
+                options: { colorize: true },
+            } : undefined,
+        },
+        requestIdHeader: 'x-request-id',
+        requestIdLogLabel: 'requestId',
     });
     // Register plugins
     await server.register(cors, {
-        origin: config.env === "production" ? false : true,
+        origin: config.env === 'production' ? false : true,
         credentials: true,
     });
     await server.register(helmet, {
-        contentSecurityPolicy: config.env === "production",
+        contentSecurityPolicy: config.env === 'production',
     });
     await server.register(rateLimit, {
         max: config.api.rateLimit,
-        timeWindow: "1 minute",
+        timeWindow: '1 minute',
     });
     // API Key authentication for protected routes
-    const API_KEY = process.env["VORION_API_KEY"] || config.api.apiKey;
+    const API_KEY = process.env['VORION_API_KEY'] || config.api.apiKey;
     const requiresAuth = (url) => {
         // Public endpoints that don't require auth
-        const publicPaths = ["/health", "/ready", "/live", "/api/v1/health"];
-        return !publicPaths.some((path) => url === path || url.startsWith(path + "?"));
+        const publicPaths = ['/health', '/ready', '/live', '/api/v1/health'];
+        return !publicPaths.some(path => url === path || url.startsWith(path + '?'));
     };
-    server.addHook("onRequest", async (request, reply) => {
+    server.addHook('onRequest', async (request, reply) => {
         // Skip auth in test mode or for public endpoints
         if (isTest || !requiresAuth(request.url)) {
             return;
@@ -148,113 +146,107 @@ export async function createServer(deps) {
         if (!API_KEY) {
             return;
         }
-        const authHeader = request.headers["authorization"];
+        const authHeader = request.headers['authorization'];
         if (!authHeader) {
             return reply.status(401).send({
-                error: {
-                    code: "UNAUTHORIZED",
-                    message: "Missing Authorization header",
-                },
+                error: { code: 'UNAUTHORIZED', message: 'Missing Authorization header' },
             });
         }
-        const [scheme, token] = authHeader.split(" ");
-        if (scheme?.toLowerCase() !== "bearer" || token !== API_KEY) {
+        const [scheme, token] = authHeader.split(' ');
+        if (scheme?.toLowerCase() !== 'bearer' || token !== API_KEY) {
             return reply.status(401).send({
-                error: { code: "UNAUTHORIZED", message: "Invalid API key" },
+                error: { code: 'UNAUTHORIZED', message: 'Invalid API key' },
             });
         }
     });
     // Health check endpoint - performs actual checks on all services
-    server.get("/health", async () => {
+    server.get('/health', async () => {
         const checks = {};
         // Check trust engine
-        checks.trustEngine = await checkService("Trust engine", async () => {
-            await trustEngine.getScore("__health_check__");
+        checks.trustEngine = await checkService('Trust engine', async () => {
+            await trustEngine.getScore('__health_check__');
         });
         // Check proof service
-        checks.proofService = await checkService("Proof service", async () => {
-            await proofService.get("__health_check_proof__");
+        checks.proofService = await checkService('Proof service', async () => {
+            await proofService.get('__health_check_proof__');
         });
         // Check intent service
-        checks.intentService = await checkService("Intent service", async () => {
-            await intentService.get("__health_check_intent__", "__system__");
+        checks.intentService = await checkService('Intent service', async () => {
+            await intentService.get('__health_check_intent__', '__system__');
         });
         // Check system health
         checks.system = checkSystemHealth(startTime);
         // Determine overall status
         const statuses = Object.values(checks).map((c) => c.status);
         let status;
-        if (statuses.every((s) => s === "ok")) {
-            status = "healthy";
+        if (statuses.every((s) => s === 'ok')) {
+            status = 'healthy';
         }
-        else if (statuses.some((s) => s === "error")) {
-            status = "unhealthy";
+        else if (statuses.some((s) => s === 'error')) {
+            status = 'unhealthy';
         }
         else {
-            status = "degraded";
+            status = 'degraded';
         }
         return {
             status,
             timestamp: new Date().toISOString(),
-            version: process.env["npm_package_version"],
+            version: process.env['npm_package_version'],
             environment: config.env,
             checks,
             metrics: getSystemMetrics(startTime),
         };
     });
     // Ready check endpoint - verifies all critical services are ready
-    server.get("/ready", async (_request, reply) => {
+    server.get('/ready', async (_request, reply) => {
         const checks = {};
         // Check trust engine (critical)
-        checks.trustEngine = await checkService("Trust engine", async () => {
-            await trustEngine.getScore("__health_check__");
+        checks.trustEngine = await checkService('Trust engine', async () => {
+            await trustEngine.getScore('__health_check__');
         });
         // Check proof service (critical)
-        checks.proofService = await checkService("Proof service", async () => {
-            await proofService.get("__health_check_proof__");
+        checks.proofService = await checkService('Proof service', async () => {
+            await proofService.get('__health_check_proof__');
         });
         // Check intent service (critical)
-        checks.intentService = await checkService("Intent service", async () => {
-            await intentService.get("__health_check_intent__", "__system__");
+        checks.intentService = await checkService('Intent service', async () => {
+            await intentService.get('__health_check_intent__', '__system__');
         });
-        const allPassed = Object.values(checks).every((c) => c.status === "ok" || c.status === "degraded");
+        const allPassed = Object.values(checks).every((c) => c.status === 'ok' || c.status === 'degraded');
         // Return 503 if not ready (for Kubernetes probes)
         if (!allPassed) {
             reply.status(503);
         }
         return {
-            status: allPassed ? "ready" : "not_ready",
+            status: allPassed ? 'ready' : 'not_ready',
             timestamp: new Date().toISOString(),
             checks,
             allPassed,
         };
     });
     // Liveness probe endpoint - simple alive check (no deep checks)
-    server.get("/live", async () => ({
-        status: "alive",
+    server.get('/live', async () => ({
+        status: 'alive',
         timestamp: new Date().toISOString(),
     }));
     // API routes
     server.register(async (api) => {
         // SDK: Health check endpoint
-        api.get("/health", async () => ({
-            status: "healthy",
-            version: process.env["npm_package_version"] ?? "0.1.0",
+        api.get('/health', async () => ({
+            status: 'healthy',
+            version: process.env['npm_package_version'] ?? '0.1.0',
         }));
         // Intent routes - unified handler for both legacy and SDK formats
-        api.post("/intents", async (request, reply) => {
+        api.post('/intents', async (request, reply) => {
             const body = request.body;
             // Detect format: SDK format has 'agentId' and 'action', legacy has 'entityId' and 'goal'
-            if ("agentId" in body && "action" in body) {
+            if ('agentId' in body && 'action' in body) {
                 // SDK format
                 const startTime = Date.now();
-                const { agentId, capabilities = [], action, } = body;
+                const { agentId, capabilities = [], action } = body;
                 if (!agentId || !action?.type || !action?.resource) {
                     return reply.status(400).send({
-                        error: {
-                            code: "INVALID_REQUEST",
-                            message: "Missing required fields: agentId, action.type, action.resource",
-                        },
+                        error: { code: 'INVALID_REQUEST', message: 'Missing required fields: agentId, action.type, action.resource' },
                     });
                 }
                 // Get or create agent trust record
@@ -264,10 +256,10 @@ export async function createServer(deps) {
                     trustRecord = await trustEngine.getScore(agentId);
                 }
                 // Check capability
-                const hasCapability = capabilities.some((cap) => cap === "*" ||
+                const hasCapability = capabilities.some(cap => cap === '*' ||
                     cap === action.type ||
                     cap === `${action.type}:*` ||
-                    cap === `${action.type}:${action.resource.split("/")[0]}`);
+                    cap === `${action.type}:${action.resource.split('/')[0]}`);
                 // Determine decision
                 const trustLevel = trustRecord?.level ?? 3;
                 const trustScore = trustRecord?.score ?? 500;
@@ -275,13 +267,13 @@ export async function createServer(deps) {
                 // Decision tier based on trust level
                 let tier;
                 if (!allowed) {
-                    tier = "RED";
+                    tier = 'RED';
                 }
                 else if (trustLevel >= 5) {
-                    tier = "GREEN";
+                    tier = 'GREEN';
                 }
                 else {
-                    tier = "YELLOW";
+                    tier = 'YELLOW';
                 }
                 // Create proof record
                 const proofId = `proof-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
@@ -289,20 +281,20 @@ export async function createServer(deps) {
                 // Determine constraints based on tier
                 const constraints = [];
                 if (trustLevel <= 1) {
-                    constraints.push("rate_limit:10/min", "audit:full", "sandbox:true");
+                    constraints.push('rate_limit:10/min', 'audit:full', 'sandbox:true');
                 }
                 else if (trustLevel <= 3) {
-                    constraints.push("rate_limit:100/min", "audit:standard");
+                    constraints.push('rate_limit:100/min', 'audit:standard');
                 }
                 else if (trustLevel <= 5) {
-                    constraints.push("rate_limit:1000/min", "audit:light");
+                    constraints.push('rate_limit:1000/min', 'audit:light');
                 }
                 const reason = allowed
-                    ? "Action permitted based on capabilities and trust level"
+                    ? 'Action permitted based on capabilities and trust level'
                     : hasCapability
                         ? `Trust score ${trustScore} below minimum threshold (200)`
-                        : `Missing capability for ${action.type}:${action.resource.split("/")[0]}`;
-                apiLogger.info({ intentId, agentId, action: action.type, allowed, tier }, "Intent processed");
+                        : `Missing capability for ${action.type}:${action.resource.split('/')[0]}`;
+                apiLogger.info({ intentId, agentId, action: action.type, allowed, tier }, 'Intent processed');
                 return {
                     intentId,
                     allowed,
@@ -318,10 +310,7 @@ export async function createServer(deps) {
                 const { entityId, goal, context, metadata } = body;
                 if (!entityId || !goal) {
                     return reply.status(400).send({
-                        error: {
-                            code: "INVALID_REQUEST",
-                            message: "Missing required fields: entityId, goal",
-                        },
+                        error: { code: 'INVALID_REQUEST', message: 'Missing required fields: entityId, goal' },
                     });
                 }
                 const intent = await intentService.submit({
@@ -329,29 +318,26 @@ export async function createServer(deps) {
                     goal,
                     context: context ?? {},
                     metadata,
-                }, { tenantId: "__system__" });
-                apiLogger.info({ intentId: intent.id, entityId }, "Intent submitted");
+                }, { tenantId: '__system__' });
+                apiLogger.info({ intentId: intent.id, entityId }, 'Intent submitted');
                 return reply.status(201).send({ intent });
             }
         });
-        api.get("/intents/:id", async (request, reply) => {
-            const intent = await intentService.get(request.params.id, "__system__");
+        api.get('/intents/:id', async (request, reply) => {
+            const intent = await intentService.get(request.params.id, '__system__');
             if (!intent) {
                 return reply.status(404).send({
-                    error: { code: "NOT_FOUND", message: "Intent not found" },
+                    error: { code: 'NOT_FOUND', message: 'Intent not found' },
                 });
             }
             return { intent };
         });
         // SDK: Check intent (pre-flight, no side effects)
-        api.post("/intents/check", async (request, reply) => {
+        api.post('/intents/check', async (request, reply) => {
             const { agentId, capabilities = [], action } = request.body;
             if (!agentId || !action?.type || !action?.resource) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required fields",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields' },
                 });
             }
             // Get agent trust record
@@ -359,49 +345,49 @@ export async function createServer(deps) {
             const trustScore = trustRecord?.score ?? 0;
             const trustLevel = trustRecord?.level ?? 0;
             // Check capability
-            const hasCapability = capabilities.some((cap) => cap === "*" ||
+            const hasCapability = capabilities.some(cap => cap === '*' ||
                 cap === action.type ||
                 cap === `${action.type}:*` ||
-                cap === `${action.type}:${action.resource.split("/")[0]}`);
+                cap === `${action.type}:${action.resource.split('/')[0]}`);
             const wouldAllow = hasCapability && trustScore >= 200;
             let tier;
             if (!wouldAllow) {
-                tier = "RED";
+                tier = 'RED';
             }
             else if (trustLevel >= 5) {
-                tier = "GREEN";
+                tier = 'GREEN';
             }
             else {
-                tier = "YELLOW";
+                tier = 'YELLOW';
             }
             const reason = wouldAllow
-                ? "Action would be permitted"
+                ? 'Action would be permitted'
                 : hasCapability
                     ? `Trust score ${trustScore} below minimum threshold`
                     : `Missing capability for ${action.type}`;
             return { wouldAllow, tier, reason };
         });
         // Proof routes
-        api.get("/proofs/:id", async (request, reply) => {
+        api.get('/proofs/:id', async (request, reply) => {
             const proof = await proofService.get(request.params.id);
             if (!proof) {
                 return reply.status(404).send({
-                    error: { code: "NOT_FOUND", message: "Proof not found" },
+                    error: { code: 'NOT_FOUND', message: 'Proof not found' },
                 });
             }
             return { proof };
         });
-        api.post("/proofs/:id/verify", async (request, reply) => {
+        api.post('/proofs/:id/verify', async (request, reply) => {
             const result = await proofService.verify(request.params.id);
             if (result.chainPosition === -1) {
                 return reply.status(404).send({
-                    error: { code: "NOT_FOUND", message: "Proof not found" },
+                    error: { code: 'NOT_FOUND', message: 'Proof not found' },
                 });
             }
             return { verification: result };
         });
         // Trust routes
-        api.get("/trust/:entityId", async (request) => {
+        api.get('/trust/:entityId', async (request) => {
             const record = await trustEngine.getScore(request.params.entityId);
             if (!record) {
                 // Return null values for non-existent agents (SDK compatible)
@@ -410,7 +396,7 @@ export async function createServer(deps) {
                     score: null,
                     tier: null,
                     tierName: null,
-                    message: "Agent not found",
+                    message: 'Agent not found',
                 };
             }
             return {
@@ -422,14 +408,11 @@ export async function createServer(deps) {
             };
         });
         // SDK: Admit agent endpoint
-        api.post("/trust/admit", async (request, reply) => {
+        api.post('/trust/admit', async (request, reply) => {
             const { agentId, name, capabilities, observationTier } = request.body;
             if (!agentId || !name) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required fields: agentId, name",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields: agentId, name' },
                 });
             }
             // Initialize agent in trust engine at T3 (Monitored)
@@ -437,35 +420,31 @@ export async function createServer(deps) {
             await trustEngine.initializeEntity(agentId, initialLevel);
             const record = await trustEngine.getScore(agentId);
             const expiresAt = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(); // 1 year
-            apiLogger.info({ agentId, name, initialLevel }, "Agent admitted");
+            apiLogger.info({ agentId, name, initialLevel }, 'Agent admitted');
             return reply.status(201).send({
                 admitted: true,
                 initialTier: record?.level ?? initialLevel,
                 initialScore: record?.score ?? 500,
-                observationCeiling: observationTier === "WHITE_BOX"
-                    ? 7
-                    : observationTier === "GRAY_BOX"
-                        ? 5
-                        : 3,
+                observationCeiling: observationTier === 'WHITE_BOX' ? 7 : observationTier === 'GRAY_BOX' ? 5 : 3,
                 capabilities: capabilities ?? [],
                 expiresAt,
             });
         });
         // SDK: Record trust signal
-        api.post("/trust/:agentId/signal", async (request, reply) => {
+        api.post('/trust/:agentId/signal', async (request, reply) => {
             const { agentId } = request.params;
             const { type, source, weight = 0.1, context } = request.body;
             const recordBefore = await trustEngine.getScore(agentId);
             if (!recordBefore) {
                 return reply.status(404).send({
-                    error: { code: "NOT_FOUND", message: "Agent not found" },
+                    error: { code: 'NOT_FOUND', message: 'Agent not found' },
                 });
             }
             const scoreBefore = recordBefore.score;
             // Map signal type to trust value
             const valueMap = {
-                success: 0.8 + weight * 0.2,
-                failure: 0.2 - weight * 0.1,
+                success: 0.8 + (weight * 0.2),
+                failure: 0.2 - (weight * 0.1),
                 violation: 0.0,
                 neutral: 0.5,
             };
@@ -487,23 +466,18 @@ export async function createServer(deps) {
                 scoreAfter,
                 change: scoreAfter - scoreBefore,
                 newTier: recordAfter?.level ?? null,
-                newTierName: recordAfter
-                    ? trustEngine.getLevelName(recordAfter.level)
-                    : null,
+                newTierName: recordAfter ? trustEngine.getLevelName(recordAfter.level) : null,
             };
         });
         // ================================================================
         // Governance routes
         // ================================================================
         // Evaluate governance request (with proof chain)
-        api.post("/governance/evaluate", async (request, reply) => {
+        api.post('/governance/evaluate', async (request, reply) => {
             const body = request.body;
             if (!body.requestId || !body.entityId || !body.action) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required fields: requestId, entityId, action",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields: requestId, entityId, action' },
                 });
             }
             const startTime = Date.now();
@@ -513,7 +487,7 @@ export async function createServer(deps) {
                 entityId: body.entityId,
                 decision: result.decision,
                 proofId,
-            }, "Governance evaluation completed");
+            }, 'Governance evaluation completed');
             return {
                 result,
                 proofId,
@@ -521,96 +495,85 @@ export async function createServer(deps) {
             };
         });
         // Query governance rules
-        api.get("/governance/rules", async (request) => {
+        api.get('/governance/rules', async (request) => {
             const rules = await governanceEngine.queryRules(request.query);
             return { rules, count: rules.length };
         });
         // Register governance rule
-        api.post("/governance/rules", async (request, reply) => {
+        api.post('/governance/rules', async (request, reply) => {
             const rule = request.body;
             if (!rule.ruleId || !rule.name || !rule.condition || !rule.effect) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required rule fields",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required rule fields' },
                 });
             }
             governanceEngine.registerRule(rule);
-            apiLogger.info({ ruleId: rule.ruleId, name: rule.name }, "Governance rule registered");
-            return reply
-                .status(201)
-                .send({ registered: true, ruleId: rule.ruleId });
+            apiLogger.info({ ruleId: rule.ruleId, name: rule.name }, 'Governance rule registered');
+            return reply.status(201).send({ registered: true, ruleId: rule.ruleId });
         });
         // ================================================================
         // Boot Camp routes
         // ================================================================
         // Run boot camp for an agent
-        api.post("/agents/:agentId/bootcamp", async (request, reply) => {
+        api.post('/agents/:agentId/bootcamp', async (request, reply) => {
             const { agentId } = request.params;
             const { tenantId } = request.body;
             if (!tenantId) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required field: tenantId",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required field: tenantId' },
                 });
             }
             // The agent must implement handleChallenge — for API usage,
             // this is a placeholder that indicates the boot camp needs
             // to be driven by the calling service with a real agent adapter.
             // For now, return the service configuration info.
-            apiLogger.info({ agentId, tenantId }, "Boot camp requested");
+            apiLogger.info({ agentId, tenantId }, 'Boot camp requested');
             return reply.status(501).send({
                 error: {
-                    code: "NOT_IMPLEMENTED",
-                    message: "Boot camp must be run programmatically via PromotionService. " +
-                        "Use the @vorionsys/atsf-core SDK to run boot camp with a BootCampAgent implementation.",
+                    code: 'NOT_IMPLEMENTED',
+                    message: 'Boot camp must be run programmatically via PromotionService. ' +
+                        'Use the @vorionsys/atsf-core SDK to run boot camp with a BootCampAgent implementation.',
                 },
                 hint: {
-                    sdk: "@vorionsys/atsf-core",
-                    import: "PromotionService",
-                    usage: "new PromotionService(trustEngine).runAndEvaluate(agent)",
+                    sdk: '@vorionsys/atsf-core',
+                    import: 'PromotionService',
+                    usage: 'new PromotionService(trustEngine).runAndEvaluate(agent)',
                 },
             });
         });
         // Constraint routes
-        api.post("/constraints/validate", async (request, reply) => {
+        api.post('/constraints/validate', async (request, reply) => {
             const { entityId, intentType, context } = request.body;
             if (!entityId || !intentType) {
                 return reply.status(400).send({
-                    error: {
-                        code: "INVALID_REQUEST",
-                        message: "Missing required fields",
-                    },
+                    error: { code: 'INVALID_REQUEST', message: 'Missing required fields' },
                 });
             }
             // Get entity trust record
             const trustRecord = await trustEngine.getScore(entityId);
             if (!trustRecord) {
                 return reply.status(404).send({
-                    error: { code: "NOT_FOUND", message: "Entity not found" },
+                    error: { code: 'NOT_FOUND', message: 'Entity not found' },
                 });
             }
             // Create evaluation context
             const evalContext = {
                 intent: {
-                    id: "validation-check",
+                    id: 'validation-check',
                     type: intentType,
-                    goal: "constraint-validation",
+                    goal: 'constraint-validation',
                     context: context ?? {},
                 },
                 entity: {
                     id: entityId,
-                    type: "agent",
+                    type: 'agent',
                     trustScore: trustRecord.score,
                     trustLevel: trustRecord.level,
                     attributes: {},
                 },
                 environment: {
                     timestamp: new Date().toISOString(),
-                    timezone: "UTC",
+                    timezone: 'UTC',
                     requestId: request.id,
                 },
                 custom: {},
@@ -636,11 +599,13 @@ export async function createServer(deps) {
             error: error.message,
             stack: error.stack,
             requestId: request.id,
-        }, "Request error");
+        }, 'Request error');
         reply.status(error.statusCode ?? 500).send({
             error: {
-                code: error.code ?? "INTERNAL_ERROR",
-                message: config.env === "production" ? "An error occurred" : error.message,
+                code: error.code ?? 'INTERNAL_ERROR',
+                message: config.env === 'production'
+                    ? 'An error occurred'
+                    : error.message,
             },
         });
     });
@@ -661,10 +626,10 @@ export async function startServer() {
             port: config.api.port,
             host: config.api.host,
             environment: config.env,
-        }, "Server started");
+        }, 'Server started');
     }
     catch (error) {
-        apiLogger.error({ error }, "Failed to start server");
+        apiLogger.error({ error }, 'Failed to start server');
         process.exit(1);
     }
 }