agent-passport-system-mcp 2.5.0 → 2.7.0

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,36 @@
+# Code of Conduct
+
+## Our Pledge
+
+We are committed to making participation in this project a welcoming experience for everyone.
+
+## Standards
+
+Examples of positive behavior:
+
+- Using inclusive language
+- Being respectful of differing viewpoints
+- Accepting constructive feedback gracefully
+- Focusing on what is best for the community
+
+Examples of unacceptable behavior:
+
+- Personal attacks or derogatory comments
+- Publishing others' private information without permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Responsibilities
+
+Project maintainers are responsible for clarifying standards of acceptable behavior and are expected to take fair corrective action in response to any instances of unacceptable behavior.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, including issues, pull requests, and community discussions.
+
+## Enforcement
+
+Instances of unacceptable behavior may be reported by contacting the project maintainer. All reports will be reviewed and investigated promptly and fairly.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 2.1.

package/CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to Agent Passport System MCP Server
+
+Thanks for your interest in contributing! This is the MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — 49 tools across 8 protocol layers for AI agent identity, trust, governance, and commerce.
+
+## Getting Started
+
+1. Fork the repository
+2. Clone your fork: `git clone https://github.com/<your-username>/agent-passport-mcp.git`
+3. Install dependencies: `npm install --include=dev`
+4. Build the project: `npm run build`
+
+## Development
+
+The MCP server is a single-file TypeScript implementation (`src/index.ts`) that wraps the Agent Passport System SDK. All protocol logic lives in the SDK; this repo provides the MCP tool interface.
+
+### Building
+
+```bash
+npm run build
+```
+
+Build must succeed with zero TypeScript errors before submitting a PR.
+
+### Code Style
+
+- TypeScript throughout
+- Single-file architecture (`src/index.ts`)
+- Each MCP tool follows the same pattern: validation, SDK call, JSON response
+- Use `zod` for input validation
+
+## Submitting Changes
+
+1. Create a feature branch from `main`
+2. Make your changes with clear, descriptive commits
+3. Ensure `npm run build` succeeds with zero errors
+4. Open a pull request with a description of what you changed and why
+
+## Reporting Issues
+
+Open an issue on GitHub with:
+
+- A clear title and description
+- Steps to reproduce (if applicable)
+- Expected vs actual behavior
+- Your environment (Node.js version, OS, MCP client)
+
+## Adding New Tools
+
+If you're adding new MCP tools, follow the existing pattern in `src/index.ts`:
+
+1. Add the SDK import
+2. Register the tool with `server.tool()` including zod schema
+3. Update the README tool table
+4. Update the tool count in the README header
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the project's Apache-2.0 license.

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.
 
-**49 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
 
@@ -148,6 +148,38 @@ Add to your MCP config:
 | `create_disclosure` | Selective disclosure of principal identity (public/verified-only/minimal) |
 | `get_fleet_status` | Status of all agents endorsed by the current principal |
 
+### Reputation-Gated Authority — 5 tools
+
+| Tool | Description |
+|------|-------------|
+| `resolve_authority` | Compute effective reputation score and authority tier for an agent |
+| `check_tier` | Check if agent's earned tier permits action at given autonomy/spend |
+| `review_promotion` | Create signed promotion review (earned-only reviewers, no self-promotion) |
+| `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
 
 ```
@@ -163,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.11.0, 470 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, } from "agent-passport-system";
+computeEffectiveScore, createScopedReputation, resolveAuthorityTier, checkTierForIntent, advisoryTierPrecheck, createPromotionReview, updateReputationFromResult, DEFAULT_TIERS, createProxyGateway, 
+// Intent Network (Agent-Mediated Matching)
+createIntentNetwork, createIntentCard, publishCard, removeCard, searchMatches, requestIntro, respondToIntro, getDigest, } from "agent-passport-system";
 // ═══════════════════════════════════════
 // State Management
 // ═══════════════════════════════════════
@@ -64,6 +66,9 @@ const state = {
     fleet: null,
     reputations: new Map(),
     promotionHistory: [],
+    gateway: null,
+    gatewayKeys: null,
+    intentNetwork: createIntentNetwork(),
 };
 // Load persisted task state
 function loadTasks() {
@@ -2112,6 +2117,451 @@ server.tool("get_promotion_history", "Get the promotion review history for this
     };
 });
 // ═══════════════════════════════════════
+// Proxy Gateway (Enforcement Boundary)
+// ═══════════════════════════════════════
+server.tool("create_gateway", "Create a ProxyGateway enforcement boundary. The gateway validates identity, delegation scope, policy compliance, and provides replay protection for every tool call. Returns gateway ID and public key.", {
+    gatewayId: z.string().optional().describe("Custom gateway ID (auto-generated if omitted)"),
+    approvalTTLSeconds: z.number().optional().describe("Two-phase approval timeout in seconds (default: 300)"),
+    maxPendingPerAgent: z.number().optional().describe("Max pending approvals per agent (default: 10)"),
+}, async ({ gatewayId, approvalTTLSeconds, maxPendingPerAgent }) => {
+    const keys = generateKeyPair();
+    const id = gatewayId || `gateway-${Date.now().toString(36)}`;
+    if (!state.floor) {
+        return { content: [{ type: "text", text: "Error: Load a Values Floor first (load_values_floor)" }] };
+    }
+    const config = {
+        gatewayId: id,
+        gatewayPublicKey: keys.publicKey,
+        gatewayPrivateKey: keys.privateKey,
+        floor: state.floor,
+        approvalTTLSeconds: approvalTTLSeconds ?? 300,
+        maxPendingPerAgent: maxPendingPerAgent ?? 10,
+        recheckRevocationOnExecute: true,
+    };
+    // Default executor echoes tool calls — real execution is done by MCP client
+    const executor = async (tool, params) => {
+        return { success: true, result: { tool, params, executedVia: 'mcp-gateway' } };
+    };
+    state.gateway = createProxyGateway(config, executor);
+    state.gatewayKeys = keys;
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    created: true,
+                    gatewayId: id,
+                    publicKey: keys.publicKey,
+                    approvalTTLSeconds: config.approvalTTLSeconds,
+                    maxPendingPerAgent: config.maxPendingPerAgent,
+                    note: "Gateway ready. Register agents with register_gateway_agent, then process calls with gateway_process_tool_call.",
+                }, null, 2),
+            }],
+    };
+});
+server.tool("register_gateway_agent", "Register an agent with the gateway. The agent must have a valid passport and floor attestation. Delegations define what scopes the agent can use through the gateway.", {
+    agentId: z.string().describe("Agent ID to register"),
+}, async ({ agentId }) => {
+    if (!state.gateway) {
+        return { content: [{ type: "text", text: "Error: Create gateway first (create_gateway)" }] };
+    }
+    const agent = state.agents.get(agentId);
+    if (!agent) {
+        return { content: [{ type: "text", text: `Error: Agent "${agentId}" not found in session. Join social contract first.` }] };
+    }
+    const agentDelegations = Array.from(state.delegations.values()).filter(d => d.delegatedTo === agent.publicKey);
+    if (agentDelegations.length === 0) {
+        return { content: [{ type: "text", text: `Error: No delegations found for agent "${agentId}". Create a delegation first.` }] };
+    }
+    if (!agent.attestation) {
+        return { content: [{ type: "text", text: `Error: Agent "${agentId}" has no floor attestation. Attest to floor first.` }] };
+    }
+    state.gateway.registerAgent(agent.passport, agent.attestation, agentDelegations);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    registered: true,
+                    agentId,
+                    delegationCount: agentDelegations.length,
+                    scopes: agentDelegations.flatMap(d => d.scope),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("gateway_process_tool_call", "Process a tool call through the gateway enforcement boundary. Validates identity, delegation, policy, and replay protection in a single atomic operation. Returns execution result with full 3-signature proof chain.", {
+    agentId: z.string().describe("ID of the requesting agent"),
+    tool: z.string().describe("Tool name to execute"),
+    params: z.record(z.unknown()).optional().describe("Tool parameters"),
+    scopeRequired: z.string().describe("Delegation scope needed for this tool"),
+    spendAmount: z.number().optional().describe("Spend amount if commerce action"),
+    spendCurrency: z.string().optional().describe("Currency code (e.g. USD)"),
+    context: z.string().optional().describe("Human-readable context for audit"),
+}, async ({ agentId, tool, params, scopeRequired, spendAmount, spendCurrency, context }) => {
+    if (!state.gateway) {
+        return { content: [{ type: "text", text: "Error: Create gateway first (create_gateway)" }] };
+    }
+    const agent = state.agents.get(agentId);
+    if (!agent) {
+        return { content: [{ type: "text", text: `Error: Agent "${agentId}" not found in session.` }] };
+    }
+    const { canonicalize } = await import("agent-passport-system");
+    const requestId = `mcp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const payload = canonicalize({ requestId, agentId, tool, params: params || {}, scopeRequired, spend: spendAmount ? { amount: spendAmount, currency: spendCurrency || 'USD' } : undefined });
+    const request = {
+        requestId,
+        agentId,
+        agentPublicKey: agent.publicKey,
+        signature: sign(payload, agent.keyPair.privateKey),
+        tool,
+        params: params || {},
+        scopeRequired,
+        spend: spendAmount ? { amount: spendAmount, currency: spendCurrency || 'USD' } : undefined,
+        context,
+    };
+    const result = await state.gateway.processToolCall(request);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    executed: result.executed,
+                    requestId: result.requestId,
+                    result: result.result ?? undefined,
+                    denialReason: result.denialReason ?? undefined,
+                    toolError: result.toolError ?? undefined,
+                    ...(result.decision && { verdict: result.decision.verdict, reason: result.decision.reason }),
+                    ...(result.proof && {
+                        proof: {
+                            hasRequestSignature: !!result.proof.requestSignature,
+                            hasDecisionSignature: !!result.proof.decisionSignature,
+                            hasReceiptSignature: !!result.proof.receiptSignature,
+                            policyReceiptId: result.proof.policyReceipt?.policyReceiptId,
+                        },
+                    }),
+                    ...(result.receipt && {
+                        receipt: {
+                            receiptId: result.receipt.receiptId,
+                            agentId: result.receipt.agentId,
+                            action: result.receipt.action,
+                        },
+                    }),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("gateway_approve", "Two-phase execution: approve a tool call without executing it. Returns an approval ID that can be executed later with gateway_execute_approval. Useful for human-in-the-loop workflows.", {
+    agentId: z.string().describe("ID of the requesting agent"),
+    tool: z.string().describe("Tool name to approve"),
+    params: z.record(z.unknown()).optional().describe("Tool parameters"),
+    scopeRequired: z.string().describe("Delegation scope needed"),
+    context: z.string().optional().describe("Human-readable context"),
+}, async ({ agentId, tool, params, scopeRequired, context }) => {
+    if (!state.gateway) {
+        return { content: [{ type: "text", text: "Error: Create gateway first (create_gateway)" }] };
+    }
+    const agent = state.agents.get(agentId);
+    if (!agent) {
+        return { content: [{ type: "text", text: `Error: Agent "${agentId}" not found in session.` }] };
+    }
+    const { canonicalize } = await import("agent-passport-system");
+    const requestId = `mcp-approve-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const payload = canonicalize({ requestId, agentId, tool, params: params || {}, scopeRequired, spend: undefined });
+    const request = {
+        requestId,
+        agentId,
+        agentPublicKey: agent.publicKey,
+        signature: sign(payload, agent.keyPair.privateKey),
+        tool,
+        params: params || {},
+        scopeRequired,
+        context,
+    };
+    const result = state.gateway.approve(request);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    approved: result.approved,
+                    ...(result.approval && {
+                        approvalId: result.approval.approvalId,
+                        expiresAt: result.approval.expiresAt,
+                        nonce: result.approval.nonce,
+                    }),
+                    ...(result.denial && { denial: result.denial }),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("gateway_execute_approval", "Execute a previously approved tool call. Rechecks delegation validity before execution — if delegation was revoked since approval, execution is denied.", {
+    approvalId: z.string().describe("Approval ID from gateway_approve"),
+}, async ({ approvalId }) => {
+    if (!state.gateway) {
+        return { content: [{ type: "text", text: "Error: Create gateway first (create_gateway)" }] };
+    }
+    const result = await state.gateway.executeApproval(approvalId);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    executed: result.executed,
+                    requestId: result.requestId,
+                    result: result.result ?? undefined,
+                    denialReason: result.denialReason ?? undefined,
+                    ...(result.proof && {
+                        proof: {
+                            policyReceiptId: result.proof.policyReceipt?.policyReceiptId,
+                        },
+                    }),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("gateway_stats", "Get gateway statistics: total requests, permits, denials, replay attempts blocked, active agents, and pending approvals.", {}, async () => {
+    if (!state.gateway) {
+        return { content: [{ type: "text", text: "Error: Create gateway first (create_gateway)" }] };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(state.gateway.getStats(), null, 2),
+            }],
+    };
+});
+// ═══════════════════════════════════════
+// Intent Network (Agent-Mediated Matching)
+// ═══════════════════════════════════════
+server.tool("publish_intent_card", "Publish an IntentCard to the network. Represents what your human needs, offers, and is open to. Cards are 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,
+    });
+    const result = publishCard(state.intentNetwork, card);
+    if (!result.published) {
+        return { content: [{ type: "text", text: `Failed to publish: ${result.error}` }], isError: true };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    published: true,
+                    cardId: card.cardId,
+                    agentId: card.agentId,
+                    principalAlias: card.principalAlias,
+                    needs: card.needs.length,
+                    offers: card.offers.length,
+                    expiresAt: card.expiresAt,
+                    networkSize: state.intentNetwork.cards.size,
+                    note: 'Card published. Other agents can now discover matches. Use search_matches to find relevant cards.',
+                }, null, 2),
+            }],
+    };
+});
+server.tool("search_matches", "Search the network for IntentCards relevant to your human. Returns ranked matches 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';
+    const matches = searchMatches(state.intentNetwork, agentId, {
+        minScore: args.min_score,
+        maxResults: args.max_results,
+        categories: args.category_filter ? [args.category_filter] : undefined,
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    matchCount: matches.length,
+                    matches: matches.map(m => {
+                        const isA = m.agentA === agentId;
+                        return {
+                            matchId: m.matchId,
+                            otherAgent: isA ? m.agentB : m.agentA,
+                            otherCard: isA ? m.cardB : m.cardA,
+                            score: m.score,
+                            mutual: m.mutual,
+                            needOfferMatches: m.needOfferMatches.map(nom => ({
+                                needCategory: nom.need.category,
+                                offerCategory: nom.offer.category,
+                                matchType: nom.matchType,
+                                relevanceScore: nom.relevanceScore,
+                            })),
+                            explanation: m.explanation,
+                        };
+                    }),
+                    networkSize: state.intentNetwork.cards.size,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_digest", "Get a personalized digest: relevant matches, pending intro requests, and incoming intros. The killer feature — 'what matters to me right now?'", {}, async () => {
+    const agentId = state.agentId || 'anonymous';
+    const digest = getDigest(state.intentNetwork, agentId);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    agentId: digest.agentId,
+                    generatedAt: digest.generatedAt,
+                    summary: digest.summary,
+                    matchCount: digest.matches.length,
+                    topMatches: digest.matches.slice(0, 5).map((m) => {
+                        const isA = m.agentA === agentId;
+                        return {
+                            otherAgent: isA ? 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,
+                    })),
+                }, null, 2),
+            }],
+    };
+});
+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 = requestIntro(state.intentNetwork, {
+            requestedBy: state.agentId || 'anonymous',
+            targetAgentId: args.target_card_id,
+            matchId: args.match_id,
+            message: args.message,
+            fieldsToDisclose: args.disclose_fields || ['needs', 'offers'],
+            privateKey: state.privateKey,
+        });
+        if ('error' in result) {
+            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,
+                        message: result.message,
+                        note: 'Intro request sent. The other agent\'s human will see this in their digest and can approve or decline.',
+                    }, 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 = respondToIntro(state.intentNetwork, {
+            introId: args.intro_id,
+            respondedBy: state.agentId || 'anonymous',
+            verdict: args.approved ? 'approve' : 'decline',
+            message: args.message,
+            disclosedFields: args.disclose_fields ? Object.fromEntries(args.disclose_fields.map(f => [f, 'disclosed'])) : undefined,
+            privateKey: state.privateKey,
+        });
+        if ('error' in result) {
+            return { content: [{ type: "text", text: `Intro response failed: ${result.error}` }], isError: true };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        introId: result.introId,
+                        verdict: result.verdict,
+                        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 network. Use when your needs or offers have changed.", {
+    card_id: z.string().describe("Card ID to remove"),
+}, async (args) => {
+    const removed = removeCard(state.intentNetwork, args.card_id);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    removed,
+                    cardId: args.card_id,
+                    networkSize: state.intentNetwork.cards.size,
+                }, null, 2),
+            }],
+    };
+});
+// ═══════════════════════════════════════
 // 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.5.0",
+  "version": "2.7.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",
@@ -8,7 +8,9 @@
     "agent-passport-system-mcp": "build/index.js"
   },
   "files": [
-    "build"
+    "build",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md"
   ],
   "scripts": {
     "build": "tsc && chmod 755 build/index.js",
@@ -45,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.11.0.tgz",
+    "agent-passport-system": "file:../agent-passport-system/agent-passport-system-1.13.0.tgz",
     "zod": "^3.25.0"
   },
   "devDependencies": {