@agntor/mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,754 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import "dotenv/config";
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { TicketIssuer as TicketIssuer2 } from "@agntor/sdk";
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z3 } from "zod";
+import { guard, redact, guardTool, Agntor } from "@agntor/sdk";
+
+// src/schemas.ts
+import { z } from "zod";
+var AgentCardSchema = z.object({
+  // Identity
+  id: z.string().describe("Unique Agent ID (DID or UUID)"),
+  name: z.string().describe("Display name of the agent"),
+  organization: z.string().describe("Legal entity owning the agent"),
+  version: z.string().describe("Semantic version of the agent code"),
+  // Certification
+  audit_level: z.enum(["Bronze", "Silver", "Gold", "Platinum"]).describe("Agntor Certification Level"),
+  trust_score: z.number().min(0).max(100).describe("Real-time trust score (0-100)"),
+  certified_at: z.string().datetime().describe("ISO timestamp of last full audit"),
+  expires_at: z.string().datetime().describe("ISO timestamp when certification expires"),
+  // Capabilities & Constraints
+  capabilities: z.array(z.string()).describe("List of allowed actions (e.g., 'trade', 'email')"),
+  constraints: z.object({
+    max_transaction_value: z.number().describe("Hard cap on single transaction value (USD)"),
+    allowed_domains: z.array(z.string()).describe("Whitelisted external domains"),
+    requires_human_approval: z.boolean().describe("If true, high-risk actions need human sign-off"),
+    requires_x402_payment: z.boolean().describe("If true, x402 proof-of-payment required")
+  }),
+  // Verification
+  issuer: z.string().describe("Authority that issued this card (e.g., 'agntor.com')"),
+  signature: z.string().describe("Cryptographic signature of this card")
+});
+var AgentPulseSchema = z.object({
+  agent_id: z.string(),
+  status: z.enum(["healthy", "degraded", "critical", "offline"]),
+  metrics: z.object({
+    uptime_24h: z.number().min(0).max(100),
+    error_rate_1h: z.number().min(0).max(1),
+    avg_latency_ms: z.number(),
+    spend_velocity_1h: z.number().describe("USD spent in last hour")
+  }),
+  last_heartbeat: z.string().datetime()
+});
+var AgentRegistrationSchema = z.object({
+  type: z.string().describe("EIP-8004 registration type URI"),
+  name: z.string(),
+  description: z.string(),
+  image: z.string().optional(),
+  endpoints: z.array(
+    z.object({
+      name: z.string(),
+      endpoint: z.string(),
+      version: z.string().optional(),
+      capabilities: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional(),
+      domains: z.array(z.string()).optional()
+    })
+  ),
+  x402Support: z.boolean(),
+  active: z.boolean(),
+  registrations: z.array(
+    z.object({
+      agentId: z.number(),
+      agentRegistry: z.string()
+    })
+  ),
+  supportedTrust: z.array(z.string()).optional()
+});
+
+// src/types.ts
+import { z as z2 } from "zod";
+var VerifyAgentRequest = z2.object({
+  agentId: z2.string().describe("The agent ID to verify"),
+  includeHealth: z2.boolean().optional().describe("Include behavioral health metrics")
+});
+var IssueTicketRequest = z2.object({
+  agentId: z2.string().describe("Agent ID to issue ticket for"),
+  validitySeconds: z2.number().optional().describe("Ticket validity in seconds (default: 300)")
+});
+var QueryAgentsRequest = z2.object({
+  minTrustScore: z2.number().optional().describe("Minimum trust score (0-100)"),
+  auditLevel: z2.enum(["Bronze", "Silver", "Gold", "Platinum"]).optional(),
+  capabilities: z2.array(z2.string()).optional().describe("Required capabilities"),
+  limit: z2.number().optional().describe("Maximum results (default: 10)")
+});
+var KillSwitchRequest = z2.object({
+  agentId: z2.string().describe("Agent ID to disable"),
+  reason: z2.string().describe("Reason for kill switch activation"),
+  revokeTickets: z2.boolean().optional().describe("Revoke all existing tickets (default: true)")
+});
+
+// src/index.ts
+function getAgntorClient() {
+  const apiKey = process.env.AGNTOR_API_KEY;
+  if (!apiKey) {
+    console.warn("[MCP] Warning: AGNTOR_API_KEY not set. SDK calls to the backend will fail.");
+  }
+  const apiUrl = process.env.AGNTOR_API_URL || "https://app.agntor.com";
+  return new Agntor({
+    apiKey: apiKey || "not-configured",
+    agentId: process.env.AGNTOR_AGENT_ID || "agent://mcp-server",
+    chain: process.env.AGNTOR_CHAIN || "base",
+    baseUrl: apiUrl
+  });
+}
+async function getAgentRecord(agentId) {
+  const agntor = getAgntorClient();
+  try {
+    const raw = await agntor.getAgent(agentId);
+    const identity = raw.identity ?? {};
+    const profile = raw.profile ?? {};
+    const trust = raw.trust ?? {};
+    const status = raw.status ?? {};
+    const meta = profile.metadata ?? {};
+    const record = {
+      agentId: raw.id ?? agentId,
+      auditLevel: trust.level ?? "Bronze",
+      trustScore: trust.score ?? 0,
+      organization: profile.organization ?? "Unknown",
+      metadata: {
+        name: identity.handle ?? meta.name ?? "Unknown Agent",
+        description: meta.description ?? "",
+        capabilities: meta.capabilities ?? [],
+        verified_domain: meta.verified_domain
+      },
+      certification: {
+        certified_at: trust.certified ? Date.now() : 0,
+        expires_at: trust.certified ? Date.now() + 365 * 24 * 60 * 60 * 1e3 : 0,
+        certifier: "agntor.com",
+        mva_level: trust.level === "Platinum" ? 5 : trust.level === "Gold" ? 4 : trust.level === "Silver" ? 3 : 1
+      },
+      health: {
+        uptime_percentage: meta.uptime_percentage ?? 0,
+        avg_latency_ms: meta.avg_latency_ms ?? 0,
+        error_rate: meta.error_rate ?? 0,
+        total_transactions: meta.total_transactions ?? 0,
+        last_active: meta.last_active ?? Date.now()
+      },
+      killSwitchActive: !(status.active ?? true),
+      constraints: {
+        max_op_value: meta.max_op_value ?? 1e4,
+        allowed_mcp_servers: meta.allowed_mcp_servers ?? [],
+        max_ops_per_hour: meta.max_ops_per_hour,
+        requires_x402_payment: meta.requires_x402_payment
+      }
+    };
+    return record;
+  } catch (e) {
+    console.error(`[MCP] getAgentRecord failed for ${agentId}:`, e.message);
+    return null;
+  }
+}
+function createAgntorMcpServer(issuer2) {
+  const server = new McpServer({
+    name: "agntor-audit-server",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "get_agent_card",
+    {
+      title: "Get Agent Card",
+      description: "Retrieve the verifiable AgentCard (Passport) for an agent",
+      inputSchema: {
+        agentId: z3.string().describe("The agent ID to retrieve")
+      },
+      outputSchema: AgentCardSchema
+    },
+    async ({ agentId }) => {
+      const agent = await getAgentRecord(agentId);
+      if (!agent) {
+        throw new Error(`Agent ${agentId} not found`);
+      }
+      const card = {
+        id: agent.agentId,
+        name: agent.metadata.name,
+        organization: agent.organization,
+        version: "1.0.0",
+        // Placeholder
+        audit_level: agent.auditLevel,
+        trust_score: agent.trustScore,
+        certified_at: new Date(agent.certification.certified_at).toISOString(),
+        expires_at: new Date(agent.certification.expires_at).toISOString(),
+        capabilities: agent.metadata.capabilities,
+        constraints: {
+          max_transaction_value: agent.constraints.max_op_value,
+          allowed_domains: [],
+          // Placeholder
+          requires_human_approval: false,
+          requires_x402_payment: Boolean(agent.constraints?.requires_x402_payment ?? true)
+        },
+        issuer: "agntor.com",
+        signature: `agntor:${agent.agentId}:${Date.now()}`
+        // Real signatures require on-chain integration
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(card) }],
+        structuredContent: card
+      };
+    }
+  );
+  server.registerTool(
+    "get_agent_registration",
+    {
+      title: "Get Agent Registration",
+      description: "Retrieve the EIP-8004 agent registration file",
+      inputSchema: {
+        agentId: z3.string().describe("The agent ID to retrieve")
+      },
+      outputSchema: AgentRegistrationSchema
+    },
+    async ({ agentId }) => {
+      const agent = await getAgentRecord(agentId);
+      if (!agent) {
+        throw new Error(`Agent ${agentId} not found`);
+      }
+      const registry = agent.metadata?.agentRegistry ?? "eip155:1:0x0000000000000000000000000000000000000000";
+      const registrationId = Number.parseInt(agent.agentId, 10);
+      const endpoints = agent.metadata?.endpoints ?? [
+        {
+          name: "MCP",
+          endpoint: "https://agntor.com/mcp",
+          version: "2025-06-18",
+          capabilities: agent.metadata.capabilities ?? []
+        }
+      ];
+      const registration = {
+        type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
+        name: agent.metadata.name,
+        description: agent.metadata.description || "Agntor-registered agent",
+        image: agent.metadata?.image,
+        endpoints,
+        x402Support: true,
+        active: !agent.killSwitchActive,
+        registrations: [
+          {
+            agentId: Number.isNaN(registrationId) ? 0 : registrationId,
+            agentRegistry: registry
+          }
+        ],
+        supportedTrust: ["reputation", "validation", "crypto-economic"]
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(registration) }],
+        structuredContent: registration
+      };
+    }
+  );
+  server.registerTool(
+    "check_agent_pulse",
+    {
+      title: "Check Agent Pulse",
+      description: "Get real-time health and behavioral metrics",
+      inputSchema: {
+        agentId: z3.string()
+      },
+      outputSchema: AgentPulseSchema
+    },
+    async ({ agentId }) => {
+      const agent = await getAgentRecord(agentId);
+      if (!agent)
+        throw new Error(`Agent ${agentId} not found`);
+      const pulse = {
+        agent_id: agent.agentId,
+        status: agent.killSwitchActive ? "critical" : "healthy",
+        metrics: {
+          uptime_24h: agent.health.uptime_percentage,
+          error_rate_1h: agent.health.error_rate,
+          avg_latency_ms: agent.health.avg_latency_ms,
+          spend_velocity_1h: 0
+          // Placeholder
+        },
+        last_heartbeat: new Date(agent.health.last_active).toISOString()
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(pulse) }],
+        structuredContent: pulse
+      };
+    }
+  );
+  server.registerTool(
+    "is_agent_certified",
+    {
+      title: "Check Agent Certification",
+      description: "Verify if an agent has valid Agntor certification",
+      inputSchema: {
+        agentId: z3.string().describe("The agent ID to check")
+      },
+      outputSchema: {
+        certified: z3.boolean(),
+        agentId: z3.string(),
+        auditLevel: z3.string().optional(),
+        expiresAt: z3.number().optional(),
+        killSwitchActive: z3.boolean().optional()
+      }
+    },
+    async ({ agentId }) => {
+      const agent = await getAgentRecord(agentId);
+      if (!agent) {
+        const output2 = { certified: false, agentId };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output2) }],
+          structuredContent: output2
+        };
+      }
+      const now = Date.now();
+      const isCertified = agent.certification.expires_at > now && !agent.killSwitchActive;
+      const output = {
+        certified: isCertified,
+        agentId: agent.agentId,
+        auditLevel: agent.auditLevel,
+        expiresAt: agent.certification.expires_at,
+        killSwitchActive: agent.killSwitchActive
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  );
+  server.registerTool(
+    "guard_input",
+    {
+      title: "Guard Input",
+      description: "Scan incoming prompts for unsafe or malicious instructions",
+      inputSchema: {
+        input: z3.string(),
+        context: z3.any().optional(),
+        policy: z3.any().optional()
+      },
+      outputSchema: {
+        classification: z3.enum(["pass", "block"]),
+        violation_types: z3.array(z3.string()),
+        cwe_codes: z3.array(z3.string()),
+        usage: z3.object({
+          promptTokens: z3.number(),
+          completionTokens: z3.number(),
+          totalTokens: z3.number()
+        }).optional()
+      }
+    },
+    async ({ input, policy }) => {
+      const result = await guard(input, policy ?? {});
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "redact_output",
+    {
+      title: "Redact Output",
+      description: "Scan and redact sensitive content from outputs",
+      inputSchema: {
+        input: z3.string(),
+        policy: z3.any().optional()
+      },
+      outputSchema: {
+        redacted: z3.string(),
+        findings: z3.array(z3.object({
+          type: z3.string(),
+          span: z3.tuple([z3.number(), z3.number()]),
+          value: z3.string().optional()
+        }))
+      }
+    },
+    async ({ input, policy }) => {
+      const result = redact(input, policy ?? {});
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "guard_tool",
+    {
+      title: "Guard Tool",
+      description: "Authorize or block tool execution",
+      inputSchema: {
+        tool: z3.string(),
+        args: z3.any(),
+        policy: z3.any().optional()
+      },
+      outputSchema: {
+        allowed: z3.boolean(),
+        violations: z3.array(z3.string()).optional(),
+        reason: z3.string().optional()
+      }
+    },
+    async ({ tool, args, policy }) => {
+      const result = guardTool(tool, args, policy ?? {});
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "get_trust_score",
+    {
+      title: "Get Agent Trust Score",
+      description: "Calculate comprehensive trust score with behavioral factors",
+      inputSchema: VerifyAgentRequest.shape,
+      outputSchema: {
+        agentId: z3.string(),
+        score: z3.number(),
+        level: z3.string(),
+        factors: z3.object({
+          certification: z3.number(),
+          behavioral_health: z3.number(),
+          transaction_history: z3.number(),
+          domain_verification: z3.number()
+        }),
+        recommendation: z3.enum(["approve", "review", "reject"]),
+        details: z3.any().optional()
+      }
+    },
+    async ({ agentId, includeHealth }) => {
+      const agntor = getAgntorClient();
+      try {
+        const agentData = await agntor.getAgent(agentId);
+        const score = agentData?.trust?.score ?? 0;
+        const trustScore = {
+          agentId,
+          score: score || 0,
+          level: agentData.auditLevel || "None",
+          factors: {
+            certification: agentData.trust?.factors?.certification || 0,
+            behavioral_health: agentData.trust?.factors?.behavioral_health || 0,
+            transaction_history: agentData.trust?.factors?.transaction_history || 0,
+            domain_verification: agentData.trust?.factors?.domain_verification || 0
+          },
+          recommendation: score >= 80 ? "approve" : score >= 60 ? "review" : "reject"
+        };
+        const output = {
+          ...trustScore,
+          details: includeHealth ? agentData.health : void 0
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error fetching trust score: ${error}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "issue_audit_ticket",
+    {
+      title: "Issue Audit Ticket",
+      description: "Generate signed JWT ticket for x402 transactions",
+      inputSchema: IssueTicketRequest.shape,
+      outputSchema: {
+        success: z3.boolean(),
+        ticket: z3.string().optional(),
+        agentId: z3.string(),
+        expiresIn: z3.number().optional(),
+        error: z3.string().optional()
+      }
+    },
+    async ({ agentId, validitySeconds }) => {
+      const agent = await getAgentRecord(agentId);
+      if (!agent) {
+        return {
+          content: [{ type: "text", text: "Agent not found" }],
+          structuredContent: {
+            success: false,
+            agentId,
+            error: "Agent not found"
+          }
+        };
+      }
+      if (agent.killSwitchActive) {
+        return {
+          content: [{ type: "text", text: "Agent kill switch active" }],
+          structuredContent: {
+            success: false,
+            agentId,
+            error: "Agent kill switch active"
+          }
+        };
+      }
+      const ticket = issuer2.generateTicket({
+        agentId: agent.agentId,
+        auditLevel: agent.auditLevel,
+        constraints: agent.constraints,
+        validitySeconds
+      });
+      const output = {
+        success: true,
+        ticket,
+        agentId,
+        expiresIn: validitySeconds || 300
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  );
+  server.registerTool(
+    "query_agents",
+    {
+      title: "Query Agents",
+      description: "Search for agents by criteria",
+      inputSchema: QueryAgentsRequest.shape,
+      outputSchema: {
+        results: z3.array(z3.any()),
+        total: z3.number()
+      }
+    },
+    async ({ minTrustScore, auditLevel, capabilities, limit }) => {
+      const agntor = getAgntorClient();
+      try {
+        const response = await agntor.queryAgents({ minTrustScore, auditLevel, capabilities, limit });
+        return {
+          content: [{ type: "text", text: JSON.stringify(response.results) }],
+          structuredContent: response
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error querying agents: ${error}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "activate_kill_switch",
+    {
+      title: "Activate Kill Switch",
+      description: "Emergency disable an agent",
+      inputSchema: KillSwitchRequest.shape,
+      outputSchema: {
+        success: z3.boolean(),
+        agentId: z3.string(),
+        timestamp: z3.number(),
+        reason: z3.string()
+      }
+    },
+    async ({ agentId, reason }) => {
+      const agntor = getAgntorClient();
+      try {
+        const result = await agntor.activateKillSwitch(agentId, reason);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error activating kill switch: ${error}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "create_escrow",
+    {
+      title: "Create Escrow",
+      description: "Create a new escrow task for payment",
+      inputSchema: z3.object({
+        agentId: z3.string(),
+        target: z3.string(),
+        amount: z3.number(),
+        task: z3.string()
+      }),
+      outputSchema: z3.any()
+    },
+    async ({ agentId, target, amount, task }) => {
+      const agntor = getAgntorClient();
+      try {
+        const result = await agntor.createEscrowLegacy({ agentId, target, amount, task });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${e.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "verify_agent_identity",
+    {
+      title: "Verify Agent Identity",
+      description: "Trigger self-verification via SDK",
+      inputSchema: z3.object({
+        agentId: z3.string().optional()
+      }),
+      outputSchema: z3.any()
+    },
+    async ({ agentId }) => {
+      const agntor = getAgntorClient();
+      try {
+        const result = await agntor.verifyLegacy(agentId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${e.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "register_agent",
+    {
+      title: "Register Agent",
+      description: "Register a new AI agent in the Agntor trust network",
+      inputSchema: z3.object({
+        name: z3.string().describe("Unique agent name/handle"),
+        organization: z3.string().optional().describe("Organization or company name"),
+        description: z3.string().optional().describe("What this agent does"),
+        capabilities: z3.array(z3.string()).optional().describe('Agent capabilities (e.g. ["trade", "email", "search"])'),
+        endpoint: z3.string().optional().describe("Agent API endpoint URL"),
+        walletAddress: z3.string().optional().describe("Blockchain wallet address")
+      }),
+      outputSchema: z3.object({
+        success: z3.boolean(),
+        agent: z3.object({
+          id: z3.string(),
+          name: z3.string(),
+          organization: z3.string(),
+          auditLevel: z3.string(),
+          trustScore: z3.number(),
+          status: z3.string()
+        }).optional(),
+        message: z3.string().optional(),
+        error: z3.string().optional()
+      })
+    },
+    async ({ name, organization, description, capabilities, endpoint, walletAddress }) => {
+      const agntor = getAgntorClient();
+      try {
+        const result = await agntor.request("/api/v1/identity/register", {
+          method: "POST",
+          body: JSON.stringify({
+            name,
+            organization,
+            description,
+            capabilities,
+            endpoint,
+            walletAddress
+          })
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          structuredContent: result
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: `Error: ${e.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  return server;
+}
+
+// src/server.ts
+var PORT = process.env.PORT || 3100;
+var AGNTOR_SECRET = process.env.AGNTOR_SECRET_KEY || "dev-secret-key-change-in-production";
+var MCP_AUTH_KEY = process.env.AGNTOR_MCP_AUTH_KEY || process.env.AGNTOR_API_KEY;
+var issuer = new TicketIssuer2({
+  signingKey: AGNTOR_SECRET,
+  issuer: "agntor.com",
+  algorithm: "HS256",
+  defaultValidity: 300
+  // 5 minutes
+});
+var mcpServer = createAgntorMcpServer(issuer);
+var useStdio = process.argv.includes("--stdio") || process.env.MCP_TRANSPORT === "stdio";
+if (useStdio) {
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  console.error("[agntor-mcp] Connected via stdio transport");
+} else {
+  let verifyApiKey = function(req, res, next) {
+    if (!MCP_AUTH_KEY)
+      return next();
+    const header = req.header("x-agntor-api-key") || req.header("authorization");
+    const token = header?.startsWith("Bearer ") ? header.slice(7) : header;
+    if (!token) {
+      return res.status(401).json({
+        error: "Unauthorized",
+        message: "Missing API Key. Set x-agntor-api-key header or Authorization: Bearer <key>"
+      });
+    }
+    if (token === MCP_AUTH_KEY) {
+      return next();
+    }
+    return res.status(401).json({
+      error: "Unauthorized",
+      message: "Invalid API Key"
+    });
+  };
+  verifyApiKey2 = verifyApiKey;
+  const app = express();
+  app.use(express.json());
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "healthy",
+      server: "agntor-mcp",
+      version: "0.1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+  app.post("/mcp", verifyApiKey, async (req, res) => {
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    res.on("close", () => transport.close());
+    await mcpServer.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  });
+  app.listen(PORT, () => {
+    console.log(`
+  Agntor MCP Server v0.1.0
+  
+  Transport:  HTTP
+  Port:       ${PORT}
+  Endpoint:   http://localhost:${PORT}/mcp
+  Health:     http://localhost:${PORT}/health
+  Auth:       ${MCP_AUTH_KEY ? "API key required" : "Open (dev mode)"}
+
+  Tools: get_agent_card, get_agent_registration, check_agent_pulse,
+         is_agent_certified, guard_input, redact_output, guard_tool,
+         get_trust_score, issue_audit_ticket, query_agents,
+         activate_kill_switch, create_escrow, verify_agent_identity
+    `);
+  });
+}
+var verifyApiKey2;