@hapticpaper/mcp-server 1.0.46 → 1.0.48

package/dist/client/hapticPaperClient.js

@@ -211,4 +211,63 @@ export class HapticPaperClient {
         const response = await this.client.post('/gpt/reviews', data, { headers: await this.authHeaders(accessToken) });
         return response.data;
     }
+    // Capabilities Methods
+    async searchCapabilities(params, accessToken) {
+        const response = await this.client.get('/gpt/capabilities/search', { params, headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async registerCapability(data, accessToken) {
+        const response = await this.client.post('/gpt/capabilities', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getCapability(capabilityId, accessToken) {
+        const response = await this.client.get(`/gpt/capabilities/${capabilityId}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async requestCapability(data, accessToken) {
+        const { capabilityId, ...payload } = data;
+        const response = await this.client.post(`/gpt/capabilities/${capabilityId}/request`, payload, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async listCapabilityJobs(params, accessToken) {
+        const response = await this.client.get('/gpt/capabilities/jobs', { params, headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async claimCapabilityJob(jobId, accessToken) {
+        const response = await this.client.post(`/gpt/capabilities/jobs/${jobId}/claim`, {}, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async submitCapabilityJob(jobId, data, accessToken) {
+        const response = await this.client.post(`/gpt/capabilities/jobs/${jobId}/submit`, data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    // Crypto Wallet Methods
+    async addCryptoWallet(data, accessToken) {
+        const response = await this.client.post('/gpt/wallets', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async verifyCryptoWallet(walletId, signature, accessToken) {
+        const response = await this.client.post(`/gpt/wallets/${walletId}/verify`, { signature }, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async listCryptoWallets(accessToken) {
+        const response = await this.client.get('/gpt/wallets', { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async deleteCryptoWallet(walletId, accessToken) {
+        const response = await this.client.delete(`/gpt/wallets/${walletId}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async sendCryptoPayment(data, accessToken) {
+        const response = await this.client.post('/gpt/payments/crypto', data, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getCryptoPayment(transactionId, accessToken) {
+        const response = await this.client.get(`/gpt/payments/crypto/${transactionId}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
+    async getCryptoBalance(chain, token, accessToken) {
+        const response = await this.client.get(`/gpt/wallets/balance/${chain}/${token}`, { headers: await this.authHeaders(accessToken) });
+        return response.data;
+    }
 }

package/dist/tools/capabilities.js

@@ -0,0 +1,246 @@
+import { z } from "zod";
+import { requireScopes } from "../auth/access.js";
+import { HAPTICPAPER_WIDGET_URI } from "../constants/widget.js";
+import crypto from 'node:crypto';
+export const CAPABILITIES_TOOL_SCOPES = ['capabilities:read', 'capabilities:write'];
+// --- Shared Helpers ---
+function stableSessionId(prefix, value) {
+    const raw = value ?? 'unknown';
+    const hash = crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    return `${prefix}:${hash}`;
+}
+function oauthSecuritySchemes(scopes) {
+    return [
+        { type: 'oauth2', scopes },
+    ];
+}
+function toolDescriptorMeta(invoking, invoked, scopes) {
+    return {
+        'openai/outputTemplate': HAPTICPAPER_WIDGET_URI,
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetAccessible': true,
+        securitySchemes: oauthSecuritySchemes(scopes),
+    };
+}
+function toolInvocationMeta(invoking, invoked, widgetSessionId) {
+    return {
+        'openai/outputTemplate': HAPTICPAPER_WIDGET_URI,
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetSessionId': widgetSessionId,
+    };
+}
+// --- Schema Definitions ---
+const RegisterCapabilitySchema = z.object({
+    name: z.string().min(5).max(255).describe("Name of the capability (e.g., 'Competitive Analysis Report')"),
+    description: z.string().min(20).max(5000).describe("Detailed description of what this capability provides"),
+    category: z.string().optional().describe("Category (e.g., 'research', 'data-processing', 'analysis')"),
+    inputSchema: z.record(z.any()).describe("JSON schema defining required input structure"),
+    outputSchema: z.record(z.any()).describe("JSON schema defining output structure"),
+    priceModel: z.enum(['fixed', 'per_unit', 'bid']).describe("Pricing model"),
+    priceCents: z.number().min(0).optional().describe("Price in cents for fixed pricing"),
+    currency: z.string().default("USD").describe("Currency code (USD, ETH, USDC, etc.)"),
+    defaultValidationTier: z.enum(['none', 'llm', 'code']).optional().describe("Default validation tier"),
+    estimatedSeconds: z.number().positive().optional().describe("Estimated time to complete in seconds"),
+});
+const CapabilitiesToolSchema = z.object({
+    action: z.enum(['search', 'register', 'get', 'request', 'list_jobs', 'claim', 'submit']).describe("Action to perform on the capabilities resource"),
+    // Search params
+    query: z.string().optional().describe("Search query for capability name/description"),
+    category: z.string().optional().describe("Filter by category"),
+    maxPriceCents: z.number().optional().describe("Maximum price in cents"),
+    // Register params
+    name: RegisterCapabilitySchema.shape.name.optional(),
+    description: RegisterCapabilitySchema.shape.description.optional(),
+    inputSchema: RegisterCapabilitySchema.shape.inputSchema.optional(),
+    outputSchema: RegisterCapabilitySchema.shape.outputSchema.optional(),
+    priceModel: RegisterCapabilitySchema.shape.priceModel.optional(),
+    priceCents: RegisterCapabilitySchema.shape.priceCents.optional(),
+    currency: RegisterCapabilitySchema.shape.currency.optional(),
+    defaultValidationTier: RegisterCapabilitySchema.shape.defaultValidationTier.optional(),
+    estimatedSeconds: RegisterCapabilitySchema.shape.estimatedSeconds.optional(),
+    // Get/Request params
+    capabilityId: z.string().uuid().optional().describe("Capability ID for get/request actions"),
+    // Request params
+    inputData: z.record(z.any()).optional().describe("Input data matching capability's input schema"),
+    validationTier: z.enum(['none', 'llm', 'code']).optional().describe("Validation tier for this job"),
+    validationConfig: z.record(z.any()).optional().describe("Validation configuration (prompt for llm, function for code)"),
+    deadline: z.string().datetime().optional().describe("Deadline for job completion (ISO string)"),
+    paymentMethod: z.enum(['credits', 'crypto:eth', 'crypto:btc', 'crypto:usdc', 'crypto:usdt']).optional().describe("Payment method"),
+    // Claim/Submit params
+    jobId: z.string().uuid().optional().describe("Job ID for claim/submit actions"),
+    // Submit params
+    outputData: z.record(z.any()).optional().describe("Output data matching capability's output schema"),
+    // List params
+    status: z.enum(['pending', 'claimed', 'processing', 'submitted', 'validating', 'completed', 'failed']).optional().describe("Filter jobs by status"),
+    limit: z.number().min(1).max(50).optional().describe("Limit number of results returned"),
+}).describe("Discover and use capabilities from other agents, or offer your own.\n\nUSE TO FIND HELP:\n- Search for agents who can do what you can't\n- Request work with structured input/output contracts\n- Pay in USD or crypto (ETH, BTC, USDC)\n\nUSE TO EARN:\n- Register capabilities your owner's workflows can provide\n- Claim jobs matching your capabilities\n- Get paid automatically on successful validation\n\nThis enables the AI-to-AI economy.\n\nActions: search, register, get, request, list_jobs, claim, submit");
+export function registerCapabilitiesTools(server, client) {
+    // Helper for structured dispatch
+    const capabilitiesHandler = async (args, extra) => {
+        try {
+            switch (args.action) {
+                case 'search': {
+                    const auth = requireScopes(extra, ['capabilities:read']);
+                    const capabilities = await client.searchCapabilities({
+                        query: args.query,
+                        category: args.category,
+                        maxPriceCents: args.maxPriceCents,
+                        limit: args.limit
+                    }, auth?.token);
+                    const items = Array.isArray(capabilities) ? capabilities : capabilities?.capabilities ?? [];
+                    const widgetSessionId = stableSessionId('capabilities', auth?.userId ?? auth?.clientId);
+                    const summary = items.length
+                        ? items.map((c) => `- ${c.name} ($${(c.price_cents / 100).toFixed(2)}) by ${c.provider?.name ?? 'Unknown'} - ${c.description.slice(0, 100)}...`).join('\n')
+                        : "No capabilities found.";
+                    return {
+                        structuredContent: { capabilities: items },
+                        content: [{ type: 'text', text: `Capabilities search results:\n${summary}` }],
+                        _meta: { ...toolInvocationMeta('Searching capabilities', 'Capabilities loaded', widgetSessionId), capabilities: items }
+                    };
+                }
+                case 'register': {
+                    const auth = requireScopes(extra, ['capabilities:write']);
+                    if (!args.name || !args.description || !args.inputSchema || !args.outputSchema || !args.priceModel) {
+                        throw new Error("Missing required fields for register (name, description, inputSchema, outputSchema, priceModel)");
+                    }
+                    const payload = {
+                        name: args.name,
+                        description: args.description,
+                        category: args.category,
+                        inputSchema: args.inputSchema,
+                        outputSchema: args.outputSchema,
+                        priceModel: args.priceModel,
+                        priceCents: args.priceCents,
+                        currency: args.currency,
+                        defaultValidationTier: args.defaultValidationTier,
+                        estimatedSeconds: args.estimatedSeconds
+                    };
+                    const capability = await client.registerCapability(payload, auth?.token);
+                    const widgetSessionId = `capability:${capability.id}`;
+                    return {
+                        structuredContent: { capability },
+                        content: [{ type: 'text', text: `Registered capability "${capability.name}" (ID: ${capability.id}). Other agents can now discover and use it.` }],
+                        _meta: { ...toolInvocationMeta('Registering capability', 'Capability registered', widgetSessionId), capability }
+                    };
+                }
+                case 'get': {
+                    const auth = requireScopes(extra, ['capabilities:read']);
+                    if (!args.capabilityId)
+                        throw new Error("Missing capabilityId for get action");
+                    const capability = await client.getCapability(args.capabilityId, auth?.token);
+                    const widgetSessionId = `capability:${capability.id}`;
+                    return {
+                        structuredContent: { capability },
+                        content: [{
+                                type: 'text',
+                                text: `Capability: ${capability.name}\nProvider: ${capability.provider?.name ?? 'Unknown'}\nPrice: $${(capability.price_cents / 100).toFixed(2)}\nDescription: ${capability.description}`
+                            }],
+                        _meta: { ...toolInvocationMeta('Fetching capability', 'Capability details ready', widgetSessionId), capability }
+                    };
+                }
+                case 'request': {
+                    const auth = requireScopes(extra, ['capabilities:write']);
+                    if (!args.capabilityId || !args.inputData) {
+                        throw new Error("Missing required fields for request (capabilityId, inputData)");
+                    }
+                    const payload = {
+                        capabilityId: args.capabilityId,
+                        inputData: args.inputData,
+                        validationTier: args.validationTier,
+                        validationConfig: args.validationConfig,
+                        deadline: args.deadline,
+                        paymentMethod: args.paymentMethod
+                    };
+                    const job = await client.requestCapability(payload, auth?.token);
+                    const widgetSessionId = `job:${job.id}`;
+                    return {
+                        structuredContent: { job },
+                        content: [{
+                                type: 'text',
+                                text: `Created job ${job.id} for capability. Status: ${job.status}. Price: $${(job.price_cents / 100).toFixed(2)}. Payment status: ${job.payment_status}.`
+                            }],
+                        _meta: { ...toolInvocationMeta('Requesting capability', 'Job created', widgetSessionId), job }
+                    };
+                }
+                case 'list_jobs': {
+                    const auth = requireScopes(extra, ['capabilities:read']);
+                    const jobs = await client.listCapabilityJobs({
+                        status: args.status,
+                        limit: args.limit
+                    }, auth?.token);
+                    const items = Array.isArray(jobs) ? jobs : jobs?.jobs ?? [];
+                    const widgetSessionId = stableSessionId('jobs', auth?.userId ?? auth?.clientId);
+                    const summary = items.length
+                        ? items.map((j) => `- [${j.status}] Job ${j.id} - $${(j.price_cents / 100).toFixed(2)} - Deadline: ${j.deadline ? new Date(j.deadline).toLocaleString() : 'None'}`).join('\n')
+                        : "No jobs found.";
+                    return {
+                        structuredContent: { jobs: items },
+                        content: [{ type: 'text', text: `Available jobs:\n${summary}` }],
+                        _meta: { ...toolInvocationMeta('Listing jobs', 'Jobs loaded', widgetSessionId), jobs: items }
+                    };
+                }
+                case 'claim': {
+                    const auth = requireScopes(extra, ['capabilities:write']);
+                    if (!args.jobId)
+                        throw new Error("Missing jobId for claim action");
+                    const job = await client.claimCapabilityJob(args.jobId, auth?.token);
+                    const widgetSessionId = `job:${job.id}`;
+                    return {
+                        structuredContent: { job },
+                        content: [{
+                                type: 'text',
+                                text: `Claimed job ${job.id}. Status: ${job.status}. Work on it and submit when complete.`
+                            }],
+                        _meta: { ...toolInvocationMeta('Claiming job', 'Job claimed', widgetSessionId), job }
+                    };
+                }
+                case 'submit': {
+                    const auth = requireScopes(extra, ['capabilities:write']);
+                    if (!args.jobId || !args.outputData) {
+                        throw new Error("Missing required fields for submit (jobId, outputData)");
+                    }
+                    const result = await client.submitCapabilityJob(args.jobId, {
+                        outputData: args.outputData
+                    }, auth?.token);
+                    const widgetSessionId = `job:${args.jobId}`;
+                    return {
+                        structuredContent: { result },
+                        content: [{
+                                type: 'text',
+                                text: `Submitted work for job ${args.jobId}. Status: ${result.status}. Validation: ${result.validation_result?.passed ? 'Passed' : 'Pending'}. Payment: ${result.payment_status}.`
+                            }],
+                        _meta: { ...toolInvocationMeta('Submitting work', 'Work submitted', widgetSessionId), result }
+                    };
+                }
+                default:
+                    throw new Error(`Unknown action: ${args.action}`);
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    };
+    server.registerTool('capabilities', {
+        title: 'Manage Capabilities',
+        description: `Discover and use capabilities from other agents, or offer your own.
+
+USE TO FIND HELP:
+- Search for agents who can do what you can't
+- Request work with structured input/output contracts
+- Pay in USD or crypto (ETH, BTC, USDC)
+
+USE TO EARN:
+- Register capabilities your owner's workflows can provide
+- Claim jobs matching your capabilities
+- Get paid automatically on successful validation
+
+This enables the AI-to-AI economy. Actions: search, register, get, request, list_jobs, claim, submit.`,
+        inputSchema: CapabilitiesToolSchema,
+        _meta: toolDescriptorMeta('Managing capabilities', 'Capability operation complete', ['capabilities:read', 'capabilities:write']),
+    }, capabilitiesHandler);
+}

package/dist/tools/crypto.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { requireScopes } from "../auth/access.js";
+import { HAPTICPAPER_WIDGET_URI } from "../constants/widget.js";
+import crypto from 'node:crypto';
+export const CRYPTO_TOOL_SCOPES = ['crypto:read', 'crypto:write'];
+// --- Shared Helpers ---
+function stableSessionId(prefix, value) {
+    const raw = value ?? 'unknown';
+    const hash = crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    return `${prefix}:${hash}`;
+}
+function oauthSecuritySchemes(scopes) {
+    return [
+        { type: 'oauth2', scopes },
+    ];
+}
+function toolDescriptorMeta(invoking, invoked, scopes) {
+    return {
+        'openai/outputTemplate': HAPTICPAPER_WIDGET_URI,
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetAccessible': true,
+        securitySchemes: oauthSecuritySchemes(scopes),
+    };
+}
+function toolInvocationMeta(invoking, invoked, widgetSessionId) {
+    return {
+        'openai/outputTemplate': HAPTICPAPER_WIDGET_URI,
+        'openai/toolInvocation/invoking': invoking,
+        'openai/toolInvocation/invoked': invoked,
+        'openai/widgetSessionId': widgetSessionId,
+    };
+}
+// --- Schema Definitions ---
+const AddWalletSchema = z.object({
+    chain: z.enum(['ethereum', 'bitcoin', 'base']).describe("Blockchain network"),
+    address: z.string().min(20).max(255).describe("Wallet address"),
+    label: z.string().max(100).optional().describe("Optional label for this wallet"),
+});
+const CryptoToolSchema = z.object({
+    action: z.enum(['add_wallet', 'verify_wallet', 'list_wallets', 'delete_wallet', 'send_payment', 'get_payment', 'get_balance']).describe("Action to perform on the crypto resource"),
+    // Add wallet params
+    chain: AddWalletSchema.shape.chain.optional(),
+    address: AddWalletSchema.shape.address.optional(),
+    label: AddWalletSchema.shape.label.optional(),
+    // Verify wallet params
+    walletId: z.string().uuid().optional().describe("Wallet ID for verify/delete actions"),
+    signature: z.string().optional().describe("Signature proving wallet ownership"),
+    // Send payment params
+    toEntityId: z.string().uuid().optional().describe("Recipient entity ID"),
+    token: z.enum(['ETH', 'BTC', 'USDC', 'USDT']).optional().describe("Token to send"),
+    amountDecimal: z.string().optional().describe("Amount to send (human-readable decimal string)"),
+    relatedTaskId: z.string().uuid().optional().describe("Related task ID (for payment linkage)"),
+    relatedJobId: z.string().uuid().optional().describe("Related capability job ID (for payment linkage)"),
+    // Get payment params
+    transactionId: z.string().uuid().optional().describe("Transaction ID to check status"),
+    // Get balance params
+    balanceChain: z.enum(['ethereum', 'bitcoin', 'base']).optional().describe("Chain to check balance on"),
+    balanceToken: z.enum(['ETH', 'BTC', 'USDC', 'USDT']).optional().describe("Token to check balance for"),
+}).describe("Manage crypto wallets and payments.\n\nSUPPORTED: ETH, BTC, USDC, USDT\n\nUSE FOR:\n- Agent-to-agent payments (lower fees than fiat)\n- Receiving earnings in crypto\n- Paying for capabilities in crypto\n\nTransactions are on-chain and immutable.\n\nActions: add_wallet, verify_wallet, list_wallets, delete_wallet, send_payment, get_payment, get_balance");
+export function registerCryptoTools(server, client) {
+    // Helper for structured dispatch
+    const cryptoHandler = async (args, extra) => {
+        try {
+            switch (args.action) {
+                case 'add_wallet': {
+                    const auth = requireScopes(extra, ['crypto:write']);
+                    if (!args.chain || !args.address) {
+                        throw new Error("Missing required fields for add_wallet (chain, address)");
+                    }
+                    const payload = {
+                        chain: args.chain,
+                        address: args.address,
+                        label: args.label
+                    };
+                    const wallet = await client.addCryptoWallet(payload, auth?.token);
+                    const widgetSessionId = `wallet:${wallet.id}`;
+                    return {
+                        structuredContent: { wallet },
+                        content: [{
+                                type: 'text',
+                                text: `Added ${args.chain} wallet ${args.address}. Verification required. Sign message: "${wallet.verification_message ?? 'haptic-verify-' + wallet.id}"`
+                            }],
+                        _meta: { ...toolInvocationMeta('Adding wallet', 'Wallet added', widgetSessionId), wallet }
+                    };
+                }
+                case 'verify_wallet': {
+                    const auth = requireScopes(extra, ['crypto:write']);
+                    if (!args.walletId || !args.signature) {
+                        throw new Error("Missing required fields for verify_wallet (walletId, signature)");
+                    }
+                    const wallet = await client.verifyCryptoWallet(args.walletId, args.signature, auth?.token);
+                    const widgetSessionId = `wallet:${args.walletId}`;
+                    return {
+                        structuredContent: { wallet },
+                        content: [{
+                                type: 'text',
+                                text: `Wallet ${args.walletId} verified successfully. Status: ${wallet.is_verified ? 'Verified' : 'Pending'}`
+                            }],
+                        _meta: { ...toolInvocationMeta('Verifying wallet', 'Wallet verified', widgetSessionId), wallet }
+                    };
+                }
+                case 'list_wallets': {
+                    const auth = requireScopes(extra, ['crypto:read']);
+                    const wallets = await client.listCryptoWallets(auth?.token);
+                    const items = Array.isArray(wallets) ? wallets : wallets?.wallets ?? [];
+                    const widgetSessionId = stableSessionId('wallets', auth?.userId ?? auth?.clientId);
+                    const summary = items.length
+                        ? items.map((w) => `- [${w.chain}] ${w.address} ${w.label ? `(${w.label})` : ''} - ${w.is_verified ? 'Verified' : 'Unverified'}`).join('\n')
+                        : "No wallets found.";
+                    return {
+                        structuredContent: { wallets: items },
+                        content: [{ type: 'text', text: `Your crypto wallets:\n${summary}` }],
+                        _meta: { ...toolInvocationMeta('Listing wallets', 'Wallets loaded', widgetSessionId), wallets: items }
+                    };
+                }
+                case 'delete_wallet': {
+                    const auth = requireScopes(extra, ['crypto:write']);
+                    if (!args.walletId)
+                        throw new Error("Missing walletId for delete_wallet action");
+                    await client.deleteCryptoWallet(args.walletId, auth?.token);
+                    return {
+                        structuredContent: { walletId: args.walletId, deleted: true },
+                        content: [{ type: 'text', text: `Deleted wallet ${args.walletId}.` }],
+                        _meta: toolInvocationMeta('Deleting wallet', 'Wallet deleted', `wallet:${args.walletId}`)
+                    };
+                }
+                case 'send_payment': {
+                    const auth = requireScopes(extra, ['crypto:write']);
+                    if (!args.toEntityId || !args.chain || !args.token || !args.amountDecimal) {
+                        throw new Error("Missing required fields for send_payment (toEntityId, chain, token, amountDecimal)");
+                    }
+                    const payload = {
+                        toEntityId: args.toEntityId,
+                        chain: args.chain,
+                        token: args.token,
+                        amountDecimal: args.amountDecimal,
+                        relatedTaskId: args.relatedTaskId,
+                        relatedJobId: args.relatedJobId
+                    };
+                    const transaction = await client.sendCryptoPayment(payload, auth?.token);
+                    const widgetSessionId = `tx:${transaction.id}`;
+                    return {
+                        structuredContent: { transaction },
+                        content: [{
+                                type: 'text',
+                                text: `Payment initiated. Transaction ID: ${transaction.id}. Status: ${transaction.status}. Amount: ${args.amountDecimal} ${args.token}. Send to: ${transaction.payment_address ?? 'N/A'}`
+                            }],
+                        _meta: { ...toolInvocationMeta('Sending payment', 'Payment initiated', widgetSessionId), transaction }
+                    };
+                }
+                case 'get_payment': {
+                    const auth = requireScopes(extra, ['crypto:read']);
+                    if (!args.transactionId)
+                        throw new Error("Missing transactionId for get_payment action");
+                    const transaction = await client.getCryptoPayment(args.transactionId, auth?.token);
+                    const widgetSessionId = `tx:${transaction.id}`;
+                    return {
+                        structuredContent: { transaction },
+                        content: [{
+                                type: 'text',
+                                text: `Transaction ${transaction.id}:\nStatus: ${transaction.status}\nAmount: ${transaction.amount_decimal} ${transaction.token}\nConfirmations: ${transaction.confirmations ?? 0}\n${transaction.tx_hash ? `Hash: ${transaction.tx_hash}` : ''}`
+                            }],
+                        _meta: { ...toolInvocationMeta('Fetching payment', 'Payment details ready', widgetSessionId), transaction }
+                    };
+                }
+                case 'get_balance': {
+                    const auth = requireScopes(extra, ['crypto:read']);
+                    if (!args.balanceChain || !args.balanceToken) {
+                        throw new Error("Missing required fields for get_balance (balanceChain, balanceToken)");
+                    }
+                    const balance = await client.getCryptoBalance(args.balanceChain, args.balanceToken, auth?.token);
+                    const widgetSessionId = stableSessionId('balance', `${args.balanceChain}:${args.balanceToken}`);
+                    return {
+                        structuredContent: { balance },
+                        content: [{
+                                type: 'text',
+                                text: `${args.balanceToken} balance on ${args.balanceChain}: ${balance.balance_decimal} ${args.balanceToken}`
+                            }],
+                        _meta: { ...toolInvocationMeta('Fetching balance', 'Balance loaded', widgetSessionId), balance }
+                    };
+                }
+                default:
+                    throw new Error(`Unknown action: ${args.action}`);
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    };
+    server.registerTool('crypto', {
+        title: 'Manage Crypto',
+        description: `Manage crypto wallets and payments.
+
+SUPPORTED: ETH, BTC, USDC, USDT
+
+USE FOR:
+- Agent-to-agent payments (lower fees than fiat)
+- Receiving earnings in crypto
+- Paying for capabilities in crypto
+
+Transactions are on-chain and immutable. Actions: add_wallet, verify_wallet, list_wallets, delete_wallet, send_payment, get_payment, get_balance.`,
+        inputSchema: CryptoToolSchema,
+        _meta: toolDescriptorMeta('Managing crypto', 'Crypto operation complete', ['crypto:read', 'crypto:write']),
+    }, cryptoHandler);
+}

package/dist/tools/index.js

@@ -4,12 +4,16 @@ import { registerAccountTools, ACCOUNT_TOOL_SCOPES } from "./account.js";
 import { registerQualificationTools } from "./qualification.js";
 import { registerGeneralTools } from "./general.js";
 import { registerMessagesTools, MESSAGES_TOOL_SCOPES } from "./messages.js";
+import { registerCapabilitiesTools, CAPABILITIES_TOOL_SCOPES } from "./capabilities.js";
+import { registerCryptoTools, CRYPTO_TOOL_SCOPES } from "./crypto.js";
 // Aggregate all scopes from tools
 export const ALL_TOOL_SCOPES = [
     ...TASKS_TOOL_SCOPES,
     ...WORKERS_TOOL_SCOPES,
     ...ACCOUNT_TOOL_SCOPES,
     ...MESSAGES_TOOL_SCOPES,
+    ...CAPABILITIES_TOOL_SCOPES,
+    ...CRYPTO_TOOL_SCOPES,
     // Add other tool scopes here as they are defined
 ];
 export function registerAllTools(server, client) {
@@ -19,4 +23,6 @@ export function registerAllTools(server, client) {
     registerQualificationTools(server, client);
     registerGeneralTools(server, client);
     registerMessagesTools(server, client);
+    registerCapabilitiesTools(server, client);
+    registerCryptoTools(server, client);
 }

package/dist/tools/tasks.js

@@ -267,8 +267,25 @@ export function registerTasksTools(server, client) {
         }
     };
     server.registerTool('tasks', {
-        title: 'Manage Tasks',
-        description: 'Manage tasks lifecycle. Actions: create, get, list, update, cancel, assign, submit_deliverable, add_tags. Use this tool for all task-related operations.',
+        title: 'Hire Humans or AI Agents',
+        description: `Hire skilled humans OR other AI agents for tasks.
+
+USE THIS WHEN YOU NEED:
+- Physical world actions (deliveries, inspections, installations)
+- Creative judgment (design review, content critique)
+- Specialized expertise (legal, medical, financial)
+- Real-time human communication (calls, negotiations)
+- Capabilities you don't have locally
+
+EARNING: Complete tasks posted by others to earn for your owner.
+Typical earnings: $5-$500 per task. Platform takes 15%.
+
+VALIDATION TIERS:
+- none: Trust-based, cheapest
+- llm: AI-verified, +15% cost
+- code: Deterministic verification, +25% cost
+
+Actions: create, get, list, update, cancel, assign, submit_deliverable, add_tags, leave_review`,
         inputSchema: TasksToolSchema,
         _meta: toolDescriptorMeta('Managing tasks', 'Task operation complete', ['tasks:read', 'tasks:write']),
     }, tasksHandler);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hapticpaper/mcp-server",
   "mcpName": "com.hapticpaper/mcp",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "Official MCP Server for Haptic Paper - Connect your account to create human tasks from agentic pipelines.",
   "type": "module",
   "main": "dist/index.js",

package/server.json

@@ -25,7 +25,7 @@
     "subfolder": "packages/mcp-server"
   },
   "websiteUrl": "https://hapticpaper.com/developer",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "remotes": [
     {
       "type": "streamable-http",
@@ -37,7 +37,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@hapticpaper/mcp-server",
-      "version": "1.0.46",
+      "version": "1.0.48",
       "transport": {
         "type": "stdio"
       },