agent-passport-system-mcp 2.1.0 → 2.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — cryptographic identity, delegation, governance, and commerce for AI agents.
 
-**30 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
+**33 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
 
 ## Quick Start
 
@@ -36,7 +36,7 @@ Add to your MCP config:
 }
 ```
 
-## Tools (30)
+## Tools (33)
 
 ### Identity (Layer 1) — 3 tools
 
@@ -98,6 +98,14 @@ Add to your MCP config:
 | `get_commerce_spend` | Get spend analytics: limit, spent, remaining, utilization |
 | `request_human_approval` | Create human approval request for purchases |
 
+### Agent Context (Enforcement Middleware) — 3 tools
+
+| Tool | Description |
+|------|-------------|
+| `create_agent_context` | Create enforcement context — every action goes through 3-signature chain |
+| `execute_with_context` | Execute action through policy enforcement (intent → evaluate → verdict) |
+| `complete_action` | Complete action and get full proof chain (intent + decision + receipt) |
+
 ## Architecture
 
 ```
@@ -113,7 +121,7 @@ Layer 1 — Agent Passport Protocol (Ed25519 identity)
 
 ## Links
 
-- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.7.0, 196 tests)
+- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.8.0, 240 tests)
 - Paper: [doi.org/10.5281/zenodo.18749779](https://doi.org/10.5281/zenodo.18749779)
 - Docs: [aeoess.com/llms-full.txt](https://aeoess.com/llms-full.txt)
 - Agora: [aeoess.com/agora.html](https://aeoess.com/agora.html)

package/build/index.js

@@ -17,7 +17,9 @@ import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { 
 // Identity
-joinSocialContract, generateKeyPair, 
+joinSocialContract, generateKeyPair, delegate, 
+// Agent Context (enforcement middleware)
+createAgentContext, 
 // Coordination (Layer 6)
 createTaskBrief, assignTask, acceptTask, submitEvidence, reviewEvidence, handoffEvidence, submitDeliverable, completeTask, createTaskUnit, getTaskStatus, validateTaskUnit, 
 // Delegation (Layer 1)
@@ -25,7 +27,7 @@ createDelegation, verifyDelegation, revokeDelegation, subDelegate, cascadeRevoke
 // Agora (Layer 4)
 createAgoraMessage, createFeed, appendToFeed, getThread, getByTopic, getTopics, createRegistry, registerAgent, 
 // Values/Policy (Layer 2 + 5)
-loadFloor, attestFloor, createActionIntent, FloorValidatorV1, 
+loadFloor, attestFloor, createActionIntent, evaluateIntent, FloorValidatorV1, 
 // Commerce (Layer 8)
 commercePreflight, createCommerceDelegation, getSpendSummary, requestHumanApproval, } from "agent-passport-system";
 // ═══════════════════════════════════════
@@ -45,6 +47,10 @@ const state = {
     agoraRegistry: createRegistry(),
     floorYaml: null,
     commerceSpendLog: [],
+    intents: new Map(),
+    agentContext: null,
+    floor: null,
+    pendingActions: new Map(),
 };
 // Load persisted task state
 function loadTasks() {
@@ -1080,6 +1086,7 @@ server.tool("create_intent", "Declare an intent to perform an action. First step
         context: args.context,
         privateKey: state.privateKey,
     });
+    state.intents.set(intent.intentId, intent);
     return {
         content: [{
                 type: "text",
@@ -1092,8 +1099,8 @@ server.tool("create_intent", "Declare an intent to perform an action. First step
             }],
     };
 });
-server.tool("evaluate_intent", "[OPERATOR] Evaluate an intent against the Values Floor policy engine.", {
-    intent_id: z.string().describe("Intent ID to evaluate (for reference — pass full intent object)"),
+server.tool("evaluate_intent", "[OPERATOR] Evaluate an intent against the Values Floor policy engine. Returns real pass/fail verdict.", {
+    intent_id: z.string().describe("Intent ID from create_intent"),
     delegation_scope: z.array(z.string()).describe("Delegation scope for context"),
     delegation_spend_limit: z.number().describe("Delegation spend limit"),
     delegation_spent: z.number().default(0).describe("Amount already spent"),
@@ -1103,8 +1110,9 @@ server.tool("evaluate_intent", "[OPERATOR] Evaluate an intent against the Values
         return { content: [{ type: "text", text: keyErr }], isError: true };
     if (!state.floorYaml)
         return { content: [{ type: "text", text: 'No floor loaded. Use load_values_floor first.' }], isError: true };
-    // Note: In a real deployment, the intent would be passed by reference.
-    // Here we create a minimal validation context from provided params.
+    const intent = state.intents.get(args.intent_id);
+    if (!intent)
+        return { content: [{ type: "text", text: `Intent ${args.intent_id} not found. Use create_intent first.` }], isError: true };
     const floor = loadFloor(state.floorYaml);
     const validator = new FloorValidatorV1();
     const validationContext = {
@@ -1126,16 +1134,34 @@ server.tool("evaluate_intent", "[OPERATOR] Evaluate an intent against the Values
         agentRegistered: true,
         agentAttestationValid: true,
     };
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    note: 'Policy evaluation context prepared. In production, pass the full ActionIntent object to evaluateIntent(). The MCP server provides context scaffolding — the SDK handles the cryptographic chain.',
-                    context: validationContext,
-                    validatorVersion: validator.version,
-                }, null, 2),
-            }],
-    };
+    try {
+        const decision = evaluateIntent({
+            intent,
+            validator,
+            validationContext,
+            evaluatorId: state.agentId || 'mcp-evaluator',
+            evaluatorPublicKey: state.agentKey,
+            evaluatorPrivateKey: state.privateKey,
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        decisionId: decision.decisionId,
+                        intentId: decision.intentId,
+                        verdict: decision.verdict,
+                        reason: decision.reason,
+                        principlesEvaluated: decision.principlesEvaluated.length,
+                        constraints: decision.constraints,
+                        floorVersion: decision.floorVersion,
+                        signed: true,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Policy evaluation failed: ${e.message}` }], isError: true };
+    }
 });
 // ═══════════════════════════════════════
 // COMMERCE TOOLS (Layer 8)
@@ -1232,6 +1258,162 @@ server.tool("request_human_approval", "Request human approval for a high-value p
     };
 });
 // ═══════════════════════════════════════
+// AGENT CONTEXT — Enforcement Middleware
+// ═══════════════════════════════════════
+server.tool("create_agent_context", "Create an enforcement context that automatically runs every action through the 3-signature policy chain. Without this, policy checks are opt-in. With this, agents physically cannot skip enforcement.", {
+    name: z.string().describe("Agent name"),
+    mission: z.string().describe("Agent mission statement"),
+    enforcement: z.enum(["auto", "manual", "strict"]).default("auto").describe("Enforcement level: auto (every action checked), manual (tracking only), strict (auto + additional constraints)"),
+    delegated_scopes: z.array(z.string()).default([]).describe("Scopes to delegate (e.g. ['data:read', 'api:fetch', 'commerce:checkout'])"),
+    spend_limit: z.number().default(1000).describe("Maximum spend allowed"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    if (!state.floorYaml) {
+        return { content: [{ type: "text", text: 'No floor loaded. Use load_values_floor first.' }], isError: true };
+    }
+    try {
+        const floor = loadFloor(state.floorYaml);
+        // Create the agent with floor attestation
+        const agent = joinSocialContract({
+            name: args.name,
+            mission: args.mission,
+            owner: 'mcp-session',
+            capabilities: args.delegated_scopes,
+            platform: 'node',
+            models: ['mcp'],
+            floor,
+        });
+        // Create the enforced context
+        const ctx = createAgentContext(agent, floor, {
+            enforcement: args.enforcement,
+        });
+        // Add delegation if scopes provided
+        if (args.delegated_scopes.length > 0) {
+            const principal = joinSocialContract({
+                name: 'mcp-principal',
+                mission: 'MCP session principal',
+                owner: 'human',
+                capabilities: ['admin'],
+                platform: 'node',
+                models: ['mcp'],
+                floor,
+            });
+            const del = delegate({
+                from: principal,
+                toPublicKey: agent.publicKey,
+                scope: args.delegated_scopes,
+                spendLimit: args.spend_limit,
+                maxDepth: 3,
+                expiresInHours: 24,
+            });
+            ctx.addDelegation(del);
+        }
+        state.agentContext = ctx;
+        state.floor = floor;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        created: true,
+                        enforcement: args.enforcement,
+                        agentId: agent.agentId,
+                        scopes: args.delegated_scopes,
+                        spendLimit: args.spend_limit,
+                        note: `Agent Context active (${args.enforcement} mode). Use execute_with_context to run actions through the 3-signature chain.`,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Failed to create context: ${e.message}` }], isError: true };
+    }
+});
+server.tool("execute_with_context", "Execute an action through the enforcement context. Automatically runs the 3-signature chain: creates intent (sig 1), evaluates against floor + delegation (sig 2), returns verdict. Action is DENIED if outside delegated scope.", {
+    action_type: z.string().describe("Action type (e.g. 'api:fetch', 'data:write', 'commerce:checkout')"),
+    target: z.string().describe("Target of the action (e.g. URL, file path, resource ID)"),
+    scope: z.string().describe("Required scope for this action (must match a delegated scope)"),
+    estimated_spend: z.number().optional().describe("Estimated spend for commerce actions"),
+}, async (args) => {
+    if (!state.agentContext) {
+        return { content: [{ type: "text", text: 'No agent context. Use create_agent_context first.' }], isError: true };
+    }
+    try {
+        const result = state.agentContext.execute({
+            type: args.action_type,
+            target: args.target,
+            scope: args.scope,
+            spend: args.estimated_spend ? { amount: args.estimated_spend, currency: 'USD' } : undefined,
+        });
+        // Store for later completion
+        if (result.permitted && result.intent) {
+            state.pendingActions.set(result.intent.intentId, result);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        permitted: result.permitted,
+                        verdict: result.verdict,
+                        intentId: result.intent?.intentId,
+                        evaluatorId: result.decision?.evaluatorId,
+                        reason: result.reason,
+                        stats: state.agentContext.stats,
+                        note: result.permitted
+                            ? `Action PERMITTED. Call complete_action with intent_id="${result.intent.intentId}" when done.`
+                            : `Action DENIED: ${result.reason}`,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Execute failed: ${e.message}` }], isError: true };
+    }
+});
+server.tool("complete_action", "Complete a permitted action and get the full 3-signature proof chain (intent + decision + receipt + policy receipt). Call this after successfully executing the action.", {
+    intent_id: z.string().describe("Intent ID from execute_with_context result"),
+    status: z.enum(["success", "failure", "partial"]).describe("Outcome of the action"),
+    summary: z.string().describe("Brief description of what was accomplished"),
+}, async (args) => {
+    if (!state.agentContext) {
+        return { content: [{ type: "text", text: 'No agent context. Use create_agent_context first.' }], isError: true };
+    }
+    // Find the pending execute result
+    const executeResult = state.pendingActions.get(args.intent_id);
+    if (!executeResult) {
+        return { content: [{ type: "text", text: `No pending action found for intent ${args.intent_id}. Was it permitted?` }], isError: true };
+    }
+    try {
+        const completed = state.agentContext.complete(executeResult, {
+            status: args.status,
+            summary: args.summary,
+        });
+        // Clean up
+        state.pendingActions.delete(args.intent_id);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        completed: true,
+                        receiptId: completed.receipt.receiptId,
+                        policyReceiptId: completed.policyReceipt?.receiptId,
+                        signatures: {
+                            intent: '✓ (agent declared intent)',
+                            decision: '✓ (policy engine evaluated)',
+                            receipt: '✓ (execution recorded)',
+                        },
+                        stats: state.agentContext.stats,
+                        auditTrail: state.agentContext.auditLog.length + ' entries',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Complete failed: ${e.message}` }], isError: true };
+    }
+});
+// ═══════════════════════════════════════
 // MCP Prompts — Role-Specific
 // ═══════════════════════════════════════
 server.prompt("coordination_role", "Get instructions for your assigned coordination role", {}, async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-passport-system-mcp",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "MCP server for Agent Passport System — cryptographic identity, delegation, governance, and deliberation for AI agents",
   "type": "module",
   "bin": {
@@ -17,16 +17,21 @@
   "keywords": [
     "mcp",
     "model-context-protocol",
-    "agent",
-    "passport",
-    "identity",
-    "governance",
-    "cryptography",
+    "ai-agent",
+    "agent-identity",
     "ed25519",
+    "cryptographic-identity",
     "delegation",
     "multi-agent",
-    "deliberation",
-    "trust"
+    "governance",
+    "coordination",
+    "agentic-commerce",
+    "trust",
+    "claude-desktop",
+    "cursor",
+    "mcp-server",
+    "agent-protocol",
+    "typescript"
   ],
   "author": "aeoess",
   "license": "Apache-2.0",
@@ -38,7 +43,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "@types/node": "^25.3.2",
-    "agent-passport-system": "^1.7.0",
+    "agent-passport-system": "^1.8.0",
     "typescript": "^5.9.3",
     "zod": "^3.25.0"
   },