@quidli/connect-mcp 0.6.0 → 0.6.3

package/README.md

@@ -34,23 +34,23 @@ See [Choose how to connect](#choose-how-to-connect) below for API keys, x402 wal
 
 Then ask your agent:
 
-> Resolve the Farcaster handle `ahn.eth` to a wallet.
+> Resolve the GitHub handle `justinquidli` to a wallet.
 
 ```json
 {
   "status": "completed",
   "results": [
     {
-      "type": "farcaster",
-      "value": "ahn.eth",
-      "ethWalletAddress": "0x07De92Ce6474D718c80e696516bf0bE53290fF5E",
+      "type": "github",
+      "value": "justinquidli",
+      "ethWalletAddress": "0x6a48ADE3bE3F9f0b8B4c9af61Bb654A219311699",
       "solWalletAddress": "9DD2CqPKZJoo7ZRgCXxJNMjhzfgVihSKtkZpn8qnEWK9"
     }
   ]
 }
 ```
 
-Resolves across Telegram, Discord, Farcaster, X, GitHub, LinkedIn, email and phone — and generates a wallet for people who have never used Quidli.
+Resolves across GitHub, X, Telegram, Discord, LinkedIn, Farcaster, email and phone — and generates a wallet for people who have never used Quidli.
 
 Lookup, scores, and price run without a key under a shared anonymous quota. Add a [Connect API key](https://connect.quid.li) for higher limits, your own profile (`connect_me`), and Smart Send.
 
@@ -375,4 +375,10 @@ mistake.
 | `connect_drop_balance`       | Smart Send wallet balances on a chain — **API key only**  |
 
 
-Ask your client to use these tools when you need Connect data or actions.
+Ask your client to use these tools when you need Connect data or actions.
+
+## Contributing
+
+This repository is a read-only mirror, regenerated on every release — changes
+committed here are overwritten. Please open an issue rather than a pull request.
+See [CONTRIBUTING.md](CONTRIBUTING.md).

package/dist/mount.d.ts

@@ -1,4 +1,4 @@
-import type { IRouter } from 'express';
+import type { IRouter, Request } from 'express';
 import { AnonymousToolQuota } from './anonymous-quota.js';
 export { resolveRequestHost } from './request-host.js';
 export interface ConnectMcpMountOptions {
@@ -8,4 +8,5 @@ export interface ConnectMcpMountOptions {
 }
 export declare function resolveEmbeddedApiBaseUrl(port: number, env?: NodeJS.ProcessEnv): string;
 export declare function isConnectMcpHost(hostname: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function normalizeAcceptHeader(req: Pick<Request, 'headers'>): void;
 export declare function mountConnectMcpHttp(router: IRouter, options: ConnectMcpMountOptions): void;

package/dist/mount.js

@@ -39,6 +39,35 @@ export function isConnectMcpHost(hostname, env = process.env) {
         normalized === 'mcp.staging.connect.quid.li' ||
         normalized.endsWith('.mcp.connect.quid.li'));
 }
+// The MCP SDK's StreamableHTTPServerTransport requires the Accept header to
+// name BOTH application/json and text/event-stream literally, and rejects
+// anything else with 406. That is stricter than HTTP content negotiation: a
+// wildcard Accept (the default for curl, fetch and most HTTP libraries, and
+// for clients that omit the header entirely) does accept both, but is still
+// refused. Directory health checkers and plain HTTP integrators hit this.
+//
+// So rewrite the header to the canonical form whenever the client's own Accept
+// already permits both types (absent, wildcard, or the relevant type
+// wildcards). A client that genuinely accepts neither is left alone and still
+// gets its 406.
+const CANONICAL_ACCEPT = 'application/json, text/event-stream';
+export function normalizeAcceptHeader(req) {
+    const raw = req.headers.accept;
+    const value = Array.isArray(raw) ? raw.join(',') : (raw ?? '');
+    // No Accept header means "anything" per RFC 9110.
+    if (!value.trim()) {
+        req.headers.accept = CANONICAL_ACCEPT;
+        return;
+    }
+    const types = value
+        .split(',')
+        .map((part) => part.split(';')[0].trim().toLowerCase())
+        .filter(Boolean);
+    const permits = (type) => types.includes(type) || types.includes('*/*') || types.includes(`${type.split('/')[0]}/*`);
+    if (permits('application/json') && permits('text/event-stream')) {
+        req.headers.accept = CANONICAL_ACCEPT;
+    }
+}
 export function mountConnectMcpHttp(router, options) {
     const { baseUrl } = options;
     const env = options.env ?? process.env;
@@ -50,6 +79,7 @@ export function mountConnectMcpHttp(router, options) {
     // No in-memory session map, so Cloud Run restarts / multiple instances
     // never cause "Missing or invalid MCP session" errors.
     router.all('/', async (req, res) => {
+        normalizeAcceptHeader(req);
         const gate = gateHostedMcpRequest(req, { env, anonymousQuota });
         if (!gate.ok) {
             sendJsonRpcError(res, gate.status, gate.message, {

package/dist/schemas.d.ts

@@ -83,6 +83,93 @@ export declare const dropInputSchema: {
     chainId: z.ZodNumber;
     tokenContract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     recipients: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "wallet"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "wallet"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "wallet"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    amountInWeiPerRecipient: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    ignoreFailedRecipients: z.ZodOptional<z.ZodBoolean>;
+    trustFilter: z.ZodOptional<z.ZodObject<{
+        context: z.ZodOptional<z.ZodString>;
+        mode: z.ZodEnum<["require", "skip"]>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "require" | "skip";
+        context?: string | undefined;
+    }, {
+        mode: "require" | "skip";
+        context?: string | undefined;
+    }>>;
+};
+export declare const trustIdentitySchema: z.ZodObject<{
+    type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+    id: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+    id: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+    id: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const trustCreateInputSchema: {
+    to: z.ZodObject<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    level: z.ZodNumber;
+    context: z.ZodOptional<z.ZodString>;
+    expiresIn: z.ZodOptional<z.ZodNumber>;
+};
+export declare const trustRevokeInputSchema: {
+    to: z.ZodObject<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    context: z.ZodOptional<z.ZodString>;
+};
+export declare const trustCheckInputSchema: {
+    from: z.ZodObject<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
+        id: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    targets: z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<["email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "wallet", "username"]>;
         id: z.ZodOptional<z.ZodString>;
         username: z.ZodOptional<z.ZodString>;
@@ -95,6 +182,11 @@ export declare const dropInputSchema: {
         id: z.ZodOptional<z.ZodString>;
         username: z.ZodOptional<z.ZodString>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
-    amountInWeiPerRecipient: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    ignoreFailedRecipients: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodString>;
+};
+export declare const trustGraphInputSchema: {
+    platform: z.ZodEnum<["wallet", "email", "phone", "telegram", "discord", "farcaster", "twitter", "github", "linkedin", "slack", "username"]>;
+    identifier: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<["out", "in"]>>;
 };

package/dist/schemas.js

@@ -16,6 +16,23 @@ const recipientTypeSchema = z.enum([
     'username',
 ]);
 const exposureRecipientTypeSchema = recipientTypeSchema;
+const dropSocialTypeSchema = z.enum([
+    'email',
+    'phone',
+    'telegram',
+    'discord',
+    'farcaster',
+    'twitter',
+    'github',
+]);
+const dropRecipientTypeSchema = z.enum([...dropSocialTypeSchema.options, 'wallet']);
+const dropRecipientSchema = z
+    .object({
+    type: dropRecipientTypeSchema,
+    id: z.string().optional(),
+    username: z.string().optional(),
+})
+    .passthrough();
 /** Unified recipient — API validates fully; MCP forwards JSON. */
 export const linkedAccountSchema = z
     .object({
@@ -94,9 +111,9 @@ export const dropInputSchema = {
         .optional()
         .describe('EVM ERC-20 contract or Solana SPL mint. Omit or null for the native token (ETH/POL/AVAX, or SOL on 1399811149). Do not use the zero address.'),
     recipients: z
-        .array(linkedAccountSchema)
+        .array(dropRecipientSchema)
         .min(1)
-        .describe('Wallet or social recipients (all wallet or all social, no mix). Optional amountInWei per recipient uses the same smallest-unit rules as amountInWeiPerRecipient. On Solana, wallet ids are base58 pubkeys; social lookup pays solWalletAddress.'),
+        .describe('Wallet or social recipients (all wallet or all social, no mix). Social types: email, phone, telegram, discord, farcaster, twitter, github (numeric id or username). linkedin and slack are not supported — use connect_lookup first, then type wallet. Optional amountInWei per recipient uses the same smallest-unit rules as amountInWeiPerRecipient. On EVM, wallet ids are 0x addresses; on Solana, base58 pubkeys. Social lookup payouts use ethWalletAddress on EVM and solWalletAddress on Solana.'),
     amountInWeiPerRecipient: z
         .string()
         .optional()
@@ -106,4 +123,47 @@ export const dropInputSchema = {
         .boolean()
         .optional()
         .describe('When true, send to recipients that resolved successfully and skip failed lookups.'),
+    trustFilter: z
+        .object({
+        context: z.string().optional().describe('Restrict to this trust context. Omit to match any.'),
+        mode: z.enum(['require', 'skip']).describe('require = fail if anyone is outside the graph; skip = drop them'),
+    })
+        .optional()
+        .describe('Keep only recipients in the sender EAS trust graph.'),
+};
+export const trustIdentitySchema = linkedAccountSchema;
+export const trustCreateInputSchema = {
+    to: trustIdentitySchema.describe('Identity to trust (wallet, social, or Connect username)'),
+    level: z.number().int().min(1).max(100).describe('Trust level 1–100'),
+    context: z.string().max(64).optional().describe('Optional context such as team:quidli'),
+    expiresIn: z.number().int().positive().optional().describe('Optional lifetime in seconds'),
+};
+export const trustRevokeInputSchema = {
+    to: trustIdentitySchema.describe('Identity to untrust'),
+    context: z.string().max(64).optional().describe('Revoke only this context. Omit to revoke all contexts for the pair.'),
+};
+export const trustCheckInputSchema = {
+    from: trustIdentitySchema.describe('Graph owner'),
+    targets: z.array(trustIdentitySchema).min(1).describe('Identities to test'),
+    context: z.string().max(64).optional().describe('If set, only this context matches'),
+};
+export const trustGraphInputSchema = {
+    platform: z
+        .enum([
+        'wallet',
+        'email',
+        'phone',
+        'telegram',
+        'discord',
+        'farcaster',
+        'twitter',
+        'github',
+        'linkedin',
+        'slack',
+        'username',
+    ])
+        .describe('Identity platform, or username for a Connect username'),
+    identifier: z.string().min(1),
+    context: z.string().max(64).optional(),
+    direction: z.enum(['out', 'in']).optional().describe('out = who they trust (default); in = who trusts them'),
 };

package/dist/tools/register.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ConnectClient } from '../client.js';
-export declare const CONNECT_MCP_TOOL_NAMES: readonly ["connect_get_price", "connect_get_chains", "connect_lookup", "connect_lookup_exposed", "connect_scores_batch", "connect_scores_by_account", "connect_scores_by_username", "connect_me", "connect_drop", "connect_drop_balance"];
+export declare const CONNECT_MCP_TOOL_NAMES: readonly ["connect_get_price", "connect_get_chains", "connect_lookup", "connect_lookup_exposed", "connect_scores_batch", "connect_scores_by_account", "connect_scores_by_username", "connect_me", "connect_drop", "connect_drop_balance", "connect_trust_create", "connect_trust_revoke", "connect_trust_check", "connect_trust_graph"];
 export declare function registerTools(server: McpServer, client: ConnectClient): void;

package/dist/tools/register.js

@@ -1,4 +1,4 @@
-import { dropBalanceInputSchema, dropInputSchema, lookupExposedInputSchema, lookupInputSchema, scoresBatchInputSchema, scoresByAccountInputSchema, scoresByUsernameInputSchema, } from '../schemas.js';
+import { dropBalanceInputSchema, dropInputSchema, lookupExposedInputSchema, lookupInputSchema, scoresBatchInputSchema, scoresByAccountInputSchema, scoresByUsernameInputSchema, trustCheckInputSchema, trustCreateInputSchema, trustGraphInputSchema, trustRevokeInputSchema, } from '../schemas.js';
 export const CONNECT_MCP_TOOL_NAMES = [
     'connect_get_price',
     'connect_get_chains',
@@ -10,6 +10,10 @@ export const CONNECT_MCP_TOOL_NAMES = [
     'connect_me',
     'connect_drop',
     'connect_drop_balance',
+    'connect_trust_create',
+    'connect_trust_revoke',
+    'connect_trust_check',
+    'connect_trust_graph',
 ];
 /**
  * Tool annotations. `readOnlyHint` is load-bearing, not decorative: clients
@@ -42,7 +46,7 @@ export function registerTools(server, client) {
         path: '/lookup/exposed',
         body: { recipient },
     }));
-    server.tool('connect_scores_batch', 'Batch scores for linked accounts or Connect usernames. Optional filter excludes users below minScore (quidli 0–100, neynar/lens 0–1, ethos 0–2800).', scoresBatchInputSchema, READ_ONLY, async ({ users, filter }) => client.request({
+    server.tool('connect_scores_batch', 'Batch scores for linked accounts or Connect usernames. One result per request user. Optional filter sets passedFilter (quidli 0–100, neynar/lens 0–1, ethos 0–2800).', scoresBatchInputSchema, READ_ONLY, async ({ users, filter }) => client.request({
         method: 'POST',
         path: '/scores',
         body: { users, ...(filter ? { filter } : {}) },
@@ -59,8 +63,8 @@ export function registerTools(server, client) {
         method: 'GET',
         path: '/account/me',
     }));
-    server.tool('connect_drop', 'Execute a Smart Send from the API key owner Connect embedded wallet. EVM: batch native or ERC-20 (need native gas plus the token). Solana (chainId 1399811149): SOL or SPL from the Solana embedded wallet. Lookup social recipients and pay solWalletAddress, never ethWalletAddress. Omit tokenContract or set it to null for the native token; pass an ERC-20 contract or SPL mint otherwise — do not use the zero address. Amounts are smallest-unit integer strings (ETH 18 decimals, SOL 9, USDC usually 6). Packs up to 20 SOL or 10 SPL recipients per transaction. ' +
-        'Solana native (tokenContract null): no ATA. Sending to a new or empty wallet requires amount ≥ 890880 lamports (rent-exempt minimum for a system account); that SOL stays with the recipient. Below that the tx fails. Sender also pays a ~5000-lamport fee. ' +
+    server.tool('connect_drop', 'Execute a Smart Send from the API key owner Connect embedded wallet. EVM: batch native or ERC-20 (need native gas plus the token). Solana (chainId 1399811149): SOL or SPL from the Solana embedded wallet; packs up to 20 native or 10 SPL recipients per transaction. Social recipient types: email, phone, telegram, discord, farcaster, twitter, github (id or username). linkedin and slack are not on /drop — use connect_lookup first, then type wallet. After connect_lookup, EVM payouts use ethWalletAddress (never solWalletAddress); Solana payouts use solWalletAddress (never ethWalletAddress). Social types on /drop resolve server-side; for type wallet, pass the resolved payout address for the target chain. Omit tokenContract or set it to null for the native token; pass an ERC-20 contract or SPL mint otherwise — do not use the zero address. Amounts are smallest-unit integer strings (ETH 18 decimals, SOL 9, USDC usually 6). ' +
+        'Solana native (tokenContract null): no ATA. Sending to a recipient without an existing funded account requires amount ≥ 890880 lamports (rent-exempt minimum for a system account); that SOL stays with the recipient. Below that the tx fails. Sender also pays a ~5000-lamport fee. ' +
         'Solana SPL: tokens sit in Associated Token Accounts (ATA), not on the wallet pubkey. Recipients need not already hold the token — the API prepends CreateIdempotent. The sender (not the recipient) pays ~2039280 lamports (~0.002039 SOL) rent per newly created dest ATA, plus tx fees, on top of the token amount (which can be as small as 1 unit). A 400 "Insufficient funds" on SPL is often missing SOL for ATA rent, not missing USDC. Token-2022 is not supported; USDC mint is EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v. ' +
         'Always call connect_drop_balance first. Returns 201 when submitted or 202 when recipients still processing — retry with the same idempotencyKey.', dropInputSchema, SPENDS_FUNDS, async ({ ignoreFailedRecipients, ...body }) => client.request({
         method: 'POST',
@@ -73,10 +77,35 @@ export function registerTools(server, client) {
     }));
     server.tool('connect_drop_balance', 'Get native and token balances for the API key owner Smart Send embedded wallet on a chain. Always call before connect_drop. Zero balances are omitted, so a missing token means balance 0. ' +
         'EVM: confirm native gas plus the ERC-20 being sent. ' +
-        'Solana (chainId 1399811149): SOL in this response is spendable lamports on the wallet pubkey (rent locked in existing token accounts is not included). Native SOL drop to a new/empty recipient: amount itself must be ≥ 890880 lamports and sender SOL must cover amount + ~5000 lamports fee. SPL drop: token balance ≥ total amount, and SOL ≥ tx fee + ~2039280 lamports (~0.002039 SOL) per recipient that may need a new Associated Token Account — even when sending USDC. Insufficient SOL for ATA rent fails before the token transfer.', dropBalanceInputSchema, READ_ONLY, async ({ chainId }) => client.request({
+        'Solana (chainId 1399811149): SOL in this response is spendable lamports on the wallet pubkey (rent locked in existing token accounts is not included). Native SOL drop to a recipient without an existing funded account: amount itself must be ≥ 890880 lamports and sender SOL must cover amount + ~5000 lamports fee. SPL drop: token balance ≥ total amount, and SOL ≥ tx fee + ~2039280 lamports (~0.002039 SOL) per recipient that may need a new Associated Token Account — even when sending USDC. Insufficient SOL for ATA rent fails before the token transfer.', dropBalanceInputSchema, READ_ONLY, async ({ chainId }) => client.request({
         method: 'GET',
         path: '/drop/balance',
         requireApiKey: true,
         query: { chainId: String(chainId) },
     }));
+    server.tool('connect_trust_create', 'Create a unidirectional trust attestation on Base (EAS) from the API key owner embedded wallet to a wallet or social identity. Identical active attestations are returned without a new transaction. Requires CONNECT_API_KEY, Smart Send attestation signer enrolled, and ETH on Base for gas.', trustCreateInputSchema, SPENDS_FUNDS, async (body) => client.request({
+        method: 'POST',
+        path: '/trust',
+        body,
+        requireApiKey: true,
+    }));
+    server.tool('connect_trust_revoke', 'Revoke active trust attestations from the API key owner to a target. Optional context limits which attestations are revoked. Requires CONNECT_API_KEY and ETH on Base.', trustRevokeInputSchema, SPENDS_FUNDS, async (body) => client.request({
+        method: 'POST',
+        path: '/trust/revoke',
+        body,
+        requireApiKey: true,
+    }));
+    server.tool('connect_trust_check', 'Check whether identities sit in a trust graph at depth 1. Omit context to match any context.', trustCheckInputSchema, READ_ONLY, async (body) => client.request({
+        method: 'POST',
+        path: '/trust/check',
+        body,
+    }));
+    server.tool('connect_trust_graph', 'List outgoing or incoming trust edges for an identity at depth 1.', trustGraphInputSchema, READ_ONLY, async ({ platform, identifier, context, direction }) => client.request({
+        method: 'GET',
+        path: `/trust/graph/${encodeURIComponent(platform)}/${encodeURIComponent(identifier)}`,
+        query: {
+            context,
+            direction,
+        },
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quidli/connect-mcp",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "description": "MCP server for agent identity and reputation: resolve social handles to wallet addresses, score onchain reputation, and send USDC from any MCP client.",
   "keywords": [
     "mcp",
@@ -55,7 +55,7 @@
     "./http": "./dist/http.js"
   },
   "scripts": {
-    "build": "tsc && chmod +x dist/index.js dist/index-http.js",
+    "build": "tsc && node --input-type=commonjs -e \"const fs=require('fs'); for (const f of ['dist/index.js','dist/index-http.js']) fs.chmodSync(f, 0o755)\"",
     "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
     "start:http": "node dist/index-http.js",