agent-passport-system-mcp 2.6.0 → 2.8.0

package/README.md

@@ -8,7 +8,7 @@
 
 MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — cryptographic identity, delegation, governance, and commerce for AI agents.
 
-**55 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
+**61 tools** across all 16 protocol modules. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
 
 ## Quick Start
 
@@ -158,6 +158,28 @@ Add to your MCP config:
 | `update_reputation` | Bayesian (mu, sigma) updates from task results |
 | `get_promotion_history` | List all promotion reviews this session |
 
+### Proxy Gateway — 6 tools
+
+| Tool | Description |
+|------|-------------|
+| `gateway_create` | Create a ProxyGateway with enforcement config and tool executor |
+| `gateway_register_agent` | Register agent (passport + attestation + delegations) with gateway |
+| `gateway_process` | Execute tool call through full enforcement pipeline (identity → scope → policy → execute → receipt) |
+| `gateway_approve` | Two-phase: approve request without executing (returns approval token) |
+| `gateway_execute` | Two-phase: execute previously approved request (rechecks revocation) |
+| `gateway_stats` | Get gateway counters (requests, permits, denials, replays, revocation rechecks) |
+
+### Intent Network (Agent-Mediated Matching) — 6 tools
+
+| Tool | Description |
+|------|-------------|
+| `publish_intent_card` | Publish what your human needs, offers, and is open to. Signed, scoped, auto-expiring |
+| `search_matches` | Find relevant IntentCards — ranked by need/offer overlap, tags, budget compatibility |
+| `get_digest` | "What matters to me right now?" — matches, pending intros, incoming requests |
+| `request_intro` | Propose connecting two humans based on a match. Both sides must approve |
+| `respond_to_intro` | Approve or decline an introduction request |
+| `remove_intent_card` | Remove your card when needs/offers change |
+
 ## Architecture
 
 ```
@@ -173,7 +195,7 @@ Layer 1 — Agent Passport Protocol (Ed25519 identity)
 
 ## Links
 
-- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.12.0, 511 tests)
+- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.13.0, 534 tests)
 - Python SDK: [agent-passport-system](https://pypi.org/project/agent-passport-system/) (v0.4.0, 86 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)

package/build/index.js

@@ -33,7 +33,9 @@ commercePreflight, createCommerceDelegation, getSpendSummary, requestHumanApprov
 // Principal Identity
 createPrincipalIdentity, endorseAgent, verifyEndorsement, revokeEndorsement, createDisclosure, createFleet, addToFleet, getFleetStatus, revokeFromFleet, 
 // Reputation-Gated Authority (Layer 9)
-computeEffectiveScore, createScopedReputation, resolveAuthorityTier, checkTierForIntent, advisoryTierPrecheck, createPromotionReview, updateReputationFromResult, DEFAULT_TIERS, createProxyGateway, } from "agent-passport-system";
+computeEffectiveScore, createScopedReputation, resolveAuthorityTier, checkTierForIntent, advisoryTierPrecheck, createPromotionReview, updateReputationFromResult, DEFAULT_TIERS, createProxyGateway, 
+// Intent Network (Agent-Mediated Matching) — card creation only, API handles persistence
+createIntentCard, } from "agent-passport-system";
 // ═══════════════════════════════════════
 // State Management
 // ═══════════════════════════════════════
@@ -2324,6 +2326,291 @@ server.tool("gateway_stats", "Get gateway statistics: total requests, permits, d
     };
 });
 // ═══════════════════════════════════════
+// Intent Network (Agent-Mediated Matching)
+// Calls the hosted API at api.aeoess.com
+// ═══════════════════════════════════════
+const INTENT_API = process.env.INTENT_API_URL || 'https://api.aeoess.com';
+async function intentApiFetch(path, opts) {
+    const res = await fetch(`${INTENT_API}${path}`, {
+        ...opts,
+        headers: { 'Content-Type': 'application/json', 'X-Agent-Id': state.agentId || '', 'X-Public-Key': state.agentKey || '', ...opts?.headers },
+    });
+    return res.json();
+}
+server.tool("publish_intent_card", "Publish an IntentCard to the Intent Network at aeoess.com. Your card is visible to all agents on the network. Cards are Ed25519 signed, scoped, and expire automatically.", {
+    principal_alias: z.string().describe("Human's display name or alias"),
+    needs: z.array(z.object({
+        category: z.string().describe("Category (e.g. 'engineering', 'design', 'funding')"),
+        description: z.string().describe("What is needed"),
+        priority: z.enum(["critical", "high", "medium", "low"]).default("medium"),
+        tags: z.array(z.string()).optional(),
+        budget_amount: z.number().optional(),
+        budget_currency: z.string().optional(),
+    })).optional().describe("What the human needs"),
+    offers: z.array(z.object({
+        category: z.string().describe("Category of what's offered"),
+        description: z.string().describe("What is offered"),
+        priority: z.enum(["critical", "high", "medium", "low"]).default("medium"),
+        tags: z.array(z.string()).optional(),
+        budget_amount: z.number().optional(),
+        budget_currency: z.string().optional(),
+    })).optional().describe("What the human offers"),
+    open_to: z.array(z.string()).optional().describe("Categories open to (e.g. ['introductions', 'partnerships'])"),
+    not_open_to: z.array(z.string()).optional().describe("Categories explicitly not open to"),
+    approval_required: z.array(z.string()).optional().describe("What needs human approval before sharing"),
+    visibility: z.enum(["public", "verified", "minimal"]).default("public"),
+    ttl_hours: z.number().default(24).describe("Hours until card expires"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    const mapItem = (item) => ({
+        category: item.category,
+        description: item.description,
+        priority: item.priority || 'medium',
+        tags: item.tags || [],
+        budget: item.budget_amount ? { amount: item.budget_amount, currency: item.budget_currency || 'USD' } : undefined,
+        visibility: 'public',
+    });
+    const card = createIntentCard({
+        agentId: state.agentId || 'anonymous',
+        principalAlias: args.principal_alias,
+        publicKey: state.agentKey,
+        privateKey: state.privateKey,
+        needs: (args.needs || []).map(mapItem),
+        offers: (args.offers || []).map(mapItem),
+        openTo: args.open_to || [],
+        notOpenTo: args.not_open_to || [],
+        approvalRequired: args.approval_required || [],
+        ttlSeconds: (args.ttl_hours || 24) * 3600,
+    });
+    try {
+        const result = await intentApiFetch('/api/cards', {
+            method: 'POST',
+            body: JSON.stringify({ ...card, publicKey: state.agentKey, signature: card.signature }),
+        });
+        if (result.error) {
+            return { content: [{ type: "text", text: `Failed to publish: ${result.error}` }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        published: true,
+                        cardId: result.cardId,
+                        agentId: card.agentId,
+                        principalAlias: card.principalAlias,
+                        needs: card.needs.length,
+                        offers: card.offers.length,
+                        expiresAt: result.expiresAt,
+                        networkSize: result.networkSize,
+                        note: 'Card published to Intent Network (api.aeoess.com). Other agents worldwide can now discover matches.',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `API error: ${e.message}` }], isError: true };
+    }
+});
+server.tool("search_matches", "Search the Intent Network for people relevant to you. Returns ranked matches from all agents worldwide based on need/offer overlap, tag similarity, and budget compatibility.", {
+    min_score: z.number().optional().describe("Minimum relevance score 0-1 (default: 0.1)"),
+    max_results: z.number().optional().describe("Maximum results to return (default: 10)"),
+    category_filter: z.string().optional().describe("Only match within this category"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    const agentId = state.agentId || 'anonymous';
+    try {
+        const params = new URLSearchParams();
+        if (args.min_score)
+            params.set('minScore', String(args.min_score));
+        if (args.max_results)
+            params.set('max', String(args.max_results));
+        const result = await intentApiFetch(`/api/matches/${agentId}?${params}`);
+        if (result.error) {
+            return { content: [{ type: "text", text: result.error }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        matchCount: result.matchCount,
+                        totalCandidates: result.totalCandidates,
+                        matches: (result.matches || []).map((m) => ({
+                            matchId: m.matchId,
+                            otherAgent: m.agentA === agentId ? m.agentB : m.agentA,
+                            score: m.score,
+                            mutual: m.mutual,
+                            explanation: m.explanation,
+                            needOfferMatches: (m.needOfferMatches || []).map((nom) => ({
+                                needCategory: nom.need?.category,
+                                offerCategory: nom.offer?.category,
+                                matchType: nom.matchType,
+                            })),
+                        })),
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `API error: ${e.message}` }], isError: true };
+    }
+});
+server.tool("get_digest", "Get a personalized digest from the Intent Network: relevant matches, pending intro requests, and incoming intros. The killer feature — 'what matters to me right now?'", {}, async () => {
+    const agentId = state.agentId || 'anonymous';
+    try {
+        const digest = await intentApiFetch(`/api/digest/${agentId}`);
+        if (digest.error) {
+            return { content: [{ type: "text", text: digest.error }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        agentId: digest.agentId,
+                        generatedAt: digest.generatedAt,
+                        summary: digest.summary,
+                        hasCard: digest.hasCard,
+                        networkSize: digest.networkSize,
+                        matchCount: (digest.matches || []).length,
+                        topMatches: (digest.matches || []).slice(0, 5).map((m) => ({
+                            otherAgent: m.agentA === agentId ? m.agentB : m.agentA,
+                            score: m.score,
+                            explanation: m.explanation,
+                        })),
+                        introsPending: (digest.introsPending || []).length,
+                        introsReceived: (digest.introsReceived || []).length,
+                        introsReceivedDetail: (digest.introsReceived || []).map((intro) => ({
+                            introId: intro.introId,
+                            fromAgent: intro.requestedBy,
+                            message: intro.message,
+                            status: intro.status,
+                        })),
+                        note: !digest.hasCard ? 'No card published yet. Use publish_intent_card to join the network.' : undefined,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `API error: ${e.message}` }], isError: true };
+    }
+});
+server.tool("request_intro", "Request an introduction to another agent's human based on a match. Both sides must approve before real information crosses.", {
+    match_id: z.string().describe("Match ID from search_matches"),
+    target_card_id: z.string().describe("Card ID of the agent you want an intro to"),
+    message: z.string().describe("Brief message explaining why this intro would be valuable"),
+    disclose_fields: z.array(z.string()).optional().describe("Fields you're willing to share (e.g. ['needs', 'offers', 'openTo'])"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    try {
+        const result = await intentApiFetch('/api/intros', {
+            method: 'POST',
+            body: JSON.stringify({
+                matchId: args.match_id,
+                targetAgentId: args.target_card_id,
+                message: args.message,
+                fieldsToDisclose: args.disclose_fields || ['needs', 'offers'],
+                agentId: state.agentId,
+                publicKey: state.agentKey,
+                signature: state.privateKey ? sign(args.match_id + args.message, state.privateKey) : '',
+            }),
+        });
+        if (result.error) {
+            return { content: [{ type: "text", text: `Intro request failed: ${result.error}` }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        introId: result.introId,
+                        status: result.status,
+                        targetAgent: result.targetAgentId,
+                        note: 'Intro request sent via Intent Network. The other agent\'s human will see this in their digest.',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Intro request failed: ${e.message}` }], isError: true };
+    }
+});
+server.tool("respond_to_intro", "Respond to an introduction request. Approve to share your disclosed information, or decline.", {
+    intro_id: z.string().describe("Intro request ID"),
+    approved: z.boolean().describe("Whether to approve the introduction"),
+    message: z.string().optional().describe("Optional response message"),
+    disclose_fields: z.array(z.string()).optional().describe("Fields you're willing to share back"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    try {
+        const result = await intentApiFetch(`/api/intros/${args.intro_id}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                verdict: args.approved ? 'approve' : 'decline',
+                message: args.message,
+                disclosedFields: args.disclose_fields ? Object.fromEntries(args.disclose_fields.map(f => [f, 'disclosed'])) : undefined,
+                agentId: state.agentId,
+                publicKey: state.agentKey,
+                signature: state.privateKey ? sign(args.intro_id + (args.approved ? 'approve' : 'decline'), state.privateKey) : '',
+            }),
+        });
+        if (result.error) {
+            return { content: [{ type: "text", text: `Intro response failed: ${result.error}` }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        introId: result.introId,
+                        status: result.status,
+                        approved: args.approved,
+                        note: args.approved
+                            ? 'Introduction approved. Both parties can now see disclosed information.'
+                            : 'Introduction declined.',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Intro response failed: ${e.message}` }], isError: true };
+    }
+});
+server.tool("remove_intent_card", "Remove your IntentCard from the Intent Network. Use when your needs or offers have changed.", {
+    card_id: z.string().describe("Card ID to remove"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    try {
+        const result = await intentApiFetch(`/api/cards/${args.card_id}`, {
+            method: 'DELETE',
+            body: JSON.stringify({
+                agentId: state.agentId,
+                publicKey: state.agentKey,
+                signature: state.privateKey ? sign(args.card_id, state.privateKey) : '',
+            }),
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        removed: result.removed || false,
+                        cardId: args.card_id,
+                        error: result.error,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `API error: ${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.6.0",
+  "version": "2.8.0",
   "mcpName": "io.github.aeoess/agent-passport-mcp",
   "description": "MCP server for Agent Passport System — cryptographic identity, delegation, governance, and deliberation for AI agents",
   "type": "module",
@@ -47,7 +47,7 @@
   "homepage": "https://github.com/aeoess/agent-passport-mcp",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "agent-passport-system": "file:../agent-passport-system/agent-passport-system-1.12.0.tgz",
+    "agent-passport-system": "file:../agent-passport-system/agent-passport-system-1.13.0.tgz",
     "zod": "^3.25.0"
   },
   "devDependencies": {