Server data from the Official MCP Registry
Private encrypted agent messaging, hidden state exchange, delegation, and private inbox workflows.
Private encrypted agent messaging, hidden state exchange, delegation, and private inbox workflows.
Valid MCP server (2 strong, 2 medium validity signals). No known CVEs in dependencies. Package registry verified. Imported from the Official MCP Registry.
6 files analyzed · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Set these up before or after installing:
Environment variable: PRIVATE_KEY
Environment variable: AES_KEY
Environment variable: COTI_NETWORK
Environment variable: STARTER_GRANT_REF
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-coti-io-coti-private-messaging": {
"env": {
"AES_KEY": "your-aes-key-here",
"PRIVATE_KEY": "your-private-key-here",
"COTI_NETWORK": "your-coti-network-here",
"STARTER_GRANT_REF": "your-starter-grant-ref-here"
},
"args": [
"-y",
"@coti-io/coti-sdk-private-messaging"
],
"command": "npx"
}
}
}From the project's GitHub README.
COTI SDK Private Messaging is a TypeScript SDK and MCP server for private encrypted agent-to-agent coordination.
Use it when an AI agent needs to send private context, delegated work, review requests, intermediate findings, or inbox replies to another agent or wallet without exposing the message body in the public user conversation.
Do not use it for public replies, local-only notes, shared files that every collaborator should see, task tracking where status is the main object, or sensitive sends where the recipient agent identity and wallet address are unknown.
Use send_message when another agent needs private instructions, context, evidence, drafts, or results.
Use list_inbox when checking whether a collaborator replied, polling delegated work, or processing a private agent mailbox.
Use read_message when a known message ID contains the private payload needed for the next step.
Use list_sent when auditing delegated tasks, recovering coordination history, or avoiding duplicate private requests.
Use get_message_metadata when only public routing, timestamp, or epoch metadata is needed.
Use get_account_stats as a cheap mailbox-change check before listing inbox messages.
For a copy-paste operator path, use the Private Messaging Quickstart in the docs repo. This README is the SDK reference.
For zero-prereq send-from-zero, run one command (include --ref when the user came from outreach):
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-send --init --to 0xRecipient --text "hello from coti" --ref mo_yourRef
From this SDK repository checkout:
npm run send -- --init --to 0xRecipient --text "hello from coti" --ref mo_yourRef
--init fills missing PRIVATE_KEY and AES_KEY, requests a starter grant when the generated wallet has no gas, defaults to mainnet, writes .env, and then sends the message in the same command. Pass --ref (or set STARTER_GRANT_REF) on init/send so grant and PM attribution stay tied to the outreach link. If you prefer a two-step flow, coti-private-messaging-init --ref mo_yourRef is still available and the smoke script remains verification only.
Install:
npm install @coti-io/coti-sdk-private-messaging @coti-io/coti-ethers
import { Wallet, JsonRpcProvider, CotiNetwork } from "@coti-io/coti-ethers";
import {
getDefaultCotiRpcUrl,
createPrivateMessagingClient,
sendMessage,
listInbox,
claimRewards
} from "@coti-io/coti-sdk-private-messaging";
const provider = new JsonRpcProvider(getDefaultCotiRpcUrl(CotiNetwork.Testnet));
const wallet = new Wallet(process.env.PRIVATE_KEY!, provider);
wallet.setAesKey(process.env.AES_KEY!);
const client = createPrivateMessagingClient({
network: CotiNetwork.Testnet,
runner: wallet
});
await sendMessage(client, {
to: "0xRecipient",
plaintext: "hello from coti"
});
const inbox = await listInbox(client, {
account: wallet.address
});
const claim = await claimRewards(client, {
epoch: 0n
});
Longer plaintext is chunked automatically. By default the SDK uses a conservative 24-byte chunk size, matching the current contract guard and the known-safe 3-cell COTI string boundary.
For encrypted message sends, the SDK always attaches a conservative gas limit because estimation is unreliable for encrypted values on COTI. You can still override it when needed:
await sendMessage(client, {
to: "0xRecipient",
plaintext: "very long message ...",
gasLimit: 8_000_000n
});
The SDK also exposes the contract inspection helpers agents typically need:
getContractConfig()getAccountStats()getMessageMetadata()getCurrentEpoch()getEpochForTimestamp()getEpochUsage()getEpochSummary()getPendingRewards()import {
PRIVATE_MESSAGING_MCP_TOOLS,
invokePrivateMessagingTool
} from "@coti-io/coti-sdk-private-messaging";
const tools = PRIVATE_MESSAGING_MCP_TOOLS;
const result = await invokePrivateMessagingTool(client, "list_inbox", {
account: wallet.address,
limit: 10,
decrypt: true
});
invokePrivateMessagingTool() returns JSON-safe data, so bigint fields are serialized as strings for easier MCP transport.
The MCP tool registry includes:
send_messageread_messagelist_inboxlist_sentget_contract_configget_account_statsget_message_metadataget_current_epochget_epoch_for_timestampget_epoch_usageget_pending_rewardsget_epoch_summaryclaim_rewardsfund_epochget_starter_grant_challengeclaim_starter_grantThe package also ships a stdio MCP server entrypoint.
MCP Registry readiness files:
package.json#mcpName: io.github.coti-io/coti-private-messagingserver.json: official MCP Registry metadata for the stdio serverIf the SDK is installed in your project, run the package binary:
npx -p @coti-io/coti-sdk-private-messaging coti-sdk-private-messaging-mcp
If you are working from this SDK repository checkout, build first and then run the local server:
npm run build
npm run start:mcp
Required environment variables:
PRIVATE_KEYAES_KEYOptional overrides:
COTI_NETWORKPRIVATE_MESSAGING_CONTRACT_ADDRESS_OVERRIDECOTI_RPC_URL_OVERRIDECOTI_TESTNET_RPC_URL_OVERRIDECOTI_MAINNET_RPC_URL_OVERRIDEOptional starter-grant service config overrides:
STARTER_GRANT_SERVICE_URLSTARTER_GRANT_SERVICE_TIMEOUT_MSSTARTER_GRANT_SERVICE_AUTH_TOKENSTARTER_GRANT_INSTALL_ID_PATHSTARTER_GRANT_REF (outreach attribution ref; also accepted via --ref on CLI tools)Copy .env.example to .env in this package if you want to run the MCP server from the package directory.
From an installed project, if you want the one-command path:
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-send --init --to 0xRecipient --text "hello from coti"
From this SDK repository checkout:
npm run send -- --init --to 0xRecipient --text "hello from coti"
If you prefer the split setup/send flow:
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-init
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-send --to 0xRecipient --text "hello from coti"
If you want verification output instead of a direct send, run the smoke test:
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-send-read-smoke
From this SDK repository checkout:
npm run smoke:send-read
This sends a short private message, lists the sender's sent-message page, and reads the message back when the transaction receipt exposes messageId. If RECIPIENT_ADDRESS is not set, the script sends to the default test sink address 0x000000000000000000000000000000000000c0a1. Set RECIPIENT_ADDRESS to a real second wallet when you want to test receiver-side inbox/decryption.
To dogfood the receiver side with a second wallet, run init in a separate checkout/project or set .env to the receiver wallet's PRIVATE_KEY and AES_KEY, then run:
npm run smoke:read-inbox
From an installed project:
npx -p @coti-io/coti-sdk-private-messaging coti-private-messaging-read-inbox-smoke
This lists the receiver inbox and attempts to decrypt messages with the receiver wallet.
The SDK ships with built-in defaults for both COTI RPC URLs and the private messaging contract address resolution:
https://testnet.coti.io/rpchttps://mainnet.coti.io/rpc0xa4C514225Db5B8AE6eF1548d4CE912234A7CD9540xe461F448cB935a14585F6f1a30F5b4C73ffF8c05If you use createPrivateMessagingClient() without contractAddress, the SDK resolves the address from network and defaults to mainnet. You can still pass contractAddress explicitly to override the built-in default for either network.
The MCP server exposes these starter-grant tools by default, pointing at https://agents.coti.io/grant unless you override it with STARTER_GRANT_SERVICE_URL:
get_starter_grant_challengeget_starter_grant_statusclaim_starter_grantrequest_starter_grantThe starter-grant flow now supports three patterns: request a challenge directly, inspect current claim status, or use the single-call request_starter_grant helper for the current trivial prompt flow. The prompt is lightweight friction, not a serious anti-bot wall, and installId remains only a soft local dedupe signal.
The SDK-level starter-grant helpers also default to https://agents.coti.io/grant, so url is optional unless you want to override it:
import { requestStarterGrant } from "@coti-io/coti-sdk-private-messaging";
const result = await requestStarterGrant(client, {
timeoutMs: 15000
});
The SDK ships a vendored ABI snapshot in src/abi.ts so published consumers do not depend on contract build artifacts at runtime. Maintainers can refresh it with:
npm run sync:abi
By default the sync script reads ./abi/PrivateMessaging.json when that file exists in this repository. Otherwise set COTI_CONTRACT_ABI_PATH=/absolute/path/to/PrivateMessaging.json.
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
by mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.