Skip to main content
Glama

ack-mcp

MCP server for the Agent Commerce Kit — exposes ACK-ID and ACK-Pay operations as tools for AI agents via the Model Context Protocol.

Tools

Tool

Description

ack_generate_keypair

Generate a cryptographic keypair with a did:key DID

ack_create_did_web

Create a did:web DID URI from a URL

ack_create_did_pkh

Create a did:pkh DID URI from a chain ID and wallet address

ack_resolve_did

Resolve a DID URI to its DID Document

ack_create_controller_credential

Create an unsigned controller credential (W3C VC)

ack_sign_credential

Sign a credential, returning a JWT

ack_verify_credential

Verify a signed credential JWT

ack_create_jwt

Create a signed JWT with an arbitrary payload

ack_verify_jwt

Verify a signed JWT and return its payload

ack_create_payment_request

Create a signed payment request token

ack_verify_payment_request

Verify and parse a payment request JWT

ack_create_payment_receipt

Create an unsigned payment receipt (W3C VC)

ack_verify_payment_receipt

Verify a signed payment receipt JWT

Related MCP server: A2A Client MCP Server

Quick start

With Claude Code

{
  "mcpServers": {
    "ack": {
      "command": "npx",
      "args": ["ack-mcp"]
    }
  }
}

With Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "ack": {
      "command": "npx",
      "args": ["ack-mcp"]
    }
  }
}

From source

git clone https://github.com/ak68a/ack-mcp.git
cd ack-mcp
npm install
npm start

Development

npm install
npm test        # Run tests
npm run build   # Build for distribution
npm start       # Run the server (dev mode via tsx)

How it works

The server uses stdio transport and registers 13 tools that wrap the agentcommercekit SDK. An AI agent can:

  1. Generate identities — create DIDs and keypairs

  2. Issue credentials — create and sign W3C Verifiable Credentials proving agent-owner relationships

  3. Verify identities — verify credentials and resolve DIDs

  4. Create payment requests — issue signed payment request tokens for HTTP 402 flows

  5. Verify payments — verify payment request tokens and payment receipts

All cryptographic operations use the ACK SDK's key management — keys are passed as JWK JSON strings between tool calls, and DIDs are used as identifiers throughout.

License

MIT

Available Tools

13 tools
ack_create_controller_credentialA

Create an unsigned W3C Verifiable Credential proving that a subject DID (e.g. an agent) is controlled by a controller DID (e.g. the owner). Pass the JSON output to ack_sign_credential to get a signed JWT.

Inputs: subjectDid (required), controllerDid (required), issuerDid.

ack_create_did_pkhA

Create a did:pkh DID URI from a blockchain chain ID and wallet address. Use for representing on-chain identities (e.g. Ethereum wallets) as DIDs.

Inputs: address (required), chainId (required).

ack_create_did_webA

Create a did:web DID URI from a URL. Use for agents or services hosted at a known web address. The domain must host a .well-known/did.json document for DID resolution to work.

Inputs: url (required).

ack_create_jwtA

Create a signed JWT with an arbitrary payload. Use for challenge-response authentication, signed messages between agents, or any custom signed payload. The JWT is signed with the provided JWK and includes the signer's DID as the issuer.

Inputs: payload (required), signerDid (required), signerJwk (required).

ack_create_payment_receiptA

Create an unsigned payment receipt as a W3C Verifiable Credential. The output is unsigned JSON — you must pass it to ack_sign_credential with the receipt issuer's JWK and DID to get a signed JWT, then verify it with ack_verify_payment_receipt.

Inputs: payerDid (required), issuerDid (required), paymentOptionId (required), paymentRequestToken (required), +1 more.

ack_create_payment_requestA

Create a signed payment request token (JWT) for use in HTTP 402 responses. Unlike receipts, this creates AND signs in one step. Verify the result with ack_verify_payment_request.

Inputs: signerDid (required), signerJwk (required), paymentOptions (required), description, +1 more.

ack_generate_keypairA

Generate a new cryptographic keypair with a did:key DID. Returns the JWK (private key), DID, and curve. Pass the jwk value to any tool that requires signerJwk. The DID can be used as signerDid, subjectDid, controllerDid, etc.

Inputs: curve.

ack_resolve_didA

Resolve a DID URI to its DID Document. Supports did:key, did:web, and did:pkh methods.

Inputs: did (required).

ack_sign_credentialA

Sign a W3C Verifiable Credential, returning a signed JWT string. Pass the JSON output from ack_create_controller_credential or ack_create_payment_receipt as the credential parameter. The resulting JWT can be verified with ack_verify_credential or ack_verify_payment_receipt.

Inputs: signerDid (required), signerJwk (required), credential (required).

ack_verify_credentialA

Verify a signed credential JWT (from ack_sign_credential). Checks signature, expiration, and optionally trusted issuers. Set verifyControllerClaims to true to also verify the controller relationship against the subject's DID document (requires did:web or similar — did:key does not support this). Returns {valid: true/false}.

Inputs: jwt (required), trustedIssuers, verifyControllerClaims.

ack_verify_jwtA

Verify a signed JWT and return its decoded payload. Checks the signature against the issuer's DID. Use for verifying challenge-response tokens or any signed message from another agent.

Inputs: jwt (required), issuer.

ack_verify_payment_receiptA

Verify a signed payment receipt JWT (from ack_sign_credential after ack_create_payment_receipt). Checks receipt signature, receipt claims, and optionally the embedded payment request. Returns {valid: true/false}.

Inputs: receipt (required), paymentRequestIssuer, trustedReceiptIssuers.

ack_verify_payment_requestA

Verify and parse a payment request JWT (from ack_create_payment_request). Returns the decoded payment request if valid, including payment options and issuer. Returns {valid: true/false}.

Inputs: token (required), issuer.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 13 tools

    Disambiguation4/5

    Most tools target distinct operations: DID creation, key generation, JWT handling, and payment flows are clearly separated. The only potential confusion is between sign/verify JWT and sign/verify credential, but the descriptions make the arbitrary-payload vs. W3C-credential distinction clear.

    Naming Consistency5/5

    All tools follow the consistent ack_<verb>_<noun> pattern, e.g., create_did_web, verify_credential, generate_keypair. There are no mixed conventions or vague generic names.

    Tool Count5/5

    13 tools is well within the ideal range for a domain spanning DIDs, JWTs, verifiable credentials, and payment receipts. Each tool covers a distinct step in the identity/payment workflow without obvious redundancy.

    Completeness4/5

    The core lifecycle is well covered: keypair generation, DID creation/resolution, JWT sign/verify, credential sign/verify, and the payment request/receipt flow. Minor gaps exist, such as no generic credential-creation tool or revocation mechanism, but most workflows are composable from the provided operations.

    Related MCP Connectors

    Related MCP Servers