@vinaystwt/xmpp-mcp 0.1.0

package/dist/packages/types/src/index.d.ts

@@ -0,0 +1,343 @@
+export type RouteKind = 'x402' | 'mpp-charge' | 'mpp-session-open' | 'mpp-session-reuse';
+export type PaymentExecutionMode = 'mock' | 'testnet';
+export type PaymentExecutionStatus = 'mock-paid' | 'ready-for-testnet' | 'settled-testnet' | 'missing-config';
+export type RouteContext = {
+    url: string;
+    method: string;
+    serviceId?: string;
+    projectedRequests?: number;
+    streaming?: boolean;
+};
+export type ServiceCatalogEntry = {
+    serviceId: string;
+    displayName: string;
+    description: string;
+    baseUrl: string;
+    source?: 'static' | 'discovered' | 'hybrid' | 'fallback';
+    capabilities: {
+        x402: boolean;
+        mppCharge: boolean;
+        mppSession: boolean;
+    };
+    pricing: {
+        x402PerCallUsd: number;
+        mppChargePerCallUsd: number;
+        mppSessionOpenUsd: number;
+        mppSessionPerCallUsd: number;
+    };
+    routingHints: {
+        breakEvenCalls: number;
+        streamingPreferred: boolean;
+        preferredSingleCall: Extract<RouteKind, 'x402' | 'mpp-charge'>;
+    };
+};
+export type RouteScoreBreakdown = {
+    route: RouteKind;
+    supported: boolean;
+    estimatedTotalUsd: number;
+    savingsVsNaiveUsd: number;
+    totalScore: number;
+    reasons: string[];
+};
+export type RouteDecision = {
+    route: RouteKind;
+    reason: string;
+    score: number;
+    projectedRequests?: number;
+    estimatedTotalUsd?: number;
+    savingsVsNaiveUsd?: number;
+    service?: ServiceCatalogEntry;
+    breakdown?: RouteScoreBreakdown[];
+};
+export type ChallengeKind = 'x402' | 'mpp-charge' | 'mpp-session';
+export type PaymentChallenge = {
+    kind: ChallengeKind;
+    service: string;
+    amountUsd: number;
+    asset: 'USDC_TESTNET';
+    retryHeaderName: string;
+    retryHeaderValue: string;
+    sessionId?: string;
+};
+export type XmppFetchOptions = Omit<RouteContext, 'url' | 'method'> & {
+    agentId?: string;
+    maxAutoPayUsd?: number;
+    idempotencyKey?: string;
+};
+export type XmppAgentProfile = {
+    agentId: string;
+    displayName: string;
+    role: 'shared' | 'research' | 'market';
+    description: string;
+    dailyBudgetUsd: number;
+    allowedServices: string[];
+    preferredRoutes: RouteKind[];
+    autopayMethods: string[];
+    enabled?: boolean;
+    policySource?: 'local' | 'contract' | 'fallback' | 'merged';
+};
+export type XmppSignedReceipt = {
+    receiptId: string;
+    issuedAt: string;
+    network: string;
+    agent: string;
+    serviceId: string;
+    url: string;
+    method: string;
+    route: RouteKind;
+    amountUsd: number;
+    txHash?: string;
+    explorerUrl?: string;
+    paymentReference?: string;
+    signature: string;
+};
+export type XmppSmartAccountExecution = {
+    configured: boolean;
+    preferred: boolean;
+    supported: boolean;
+    used: boolean;
+    contractId?: string | null;
+    fallbackReason?: string;
+};
+export type PaymentExecutionMetadata = {
+    mode: PaymentExecutionMode;
+    status: PaymentExecutionStatus;
+    route: RouteKind;
+    receiptId: string;
+    missingConfig?: string[];
+    evidenceHeaders?: Record<string, string>;
+    signedReceipt?: XmppSignedReceipt;
+    settlementStrategy?: 'keypair' | 'smart-account' | 'keypair-fallback';
+    executionNote?: string;
+    feeSponsored?: boolean;
+    feeSponsorPublicKey?: string;
+    feeBumpPublicKey?: string;
+    smartAccount?: XmppSmartAccountExecution;
+};
+export type PolicyDecision = {
+    allowed: boolean;
+    reason: string;
+    code: 'allowed' | 'blocked-domain' | 'blocked-path' | 'blocked-method' | 'blocked-service' | 'blocked-agent' | 'blocked-budget' | 'blocked-idempotency' | 'paused';
+    source?: 'local' | 'contract' | 'fallback';
+};
+export type PaymentExecutionResult = {
+    response: Response;
+    metadata: PaymentExecutionMetadata;
+};
+export type XmppFetchMetadata = {
+    route: RouteKind;
+    challenge?: PaymentChallenge;
+    retried: boolean;
+    execution?: PaymentExecutionMetadata;
+    policy?: PolicyDecision;
+    budget?: XmppBudgetSnapshot;
+    idempotentReplay?: boolean;
+};
+export type XmppSessionRecord = {
+    sessionId: string;
+    serviceId: string;
+    agent: string;
+    channelContractId: string;
+    route: string;
+    status: string;
+    totalAmountUsdCents: number;
+    callCount: number;
+    lastReceiptId: string;
+    updatedAtLedger: number;
+};
+export type WorkflowEstimateStep = {
+    url: string;
+    method?: string;
+    serviceId?: string;
+    projectedRequests: number;
+    streaming?: boolean;
+};
+export type WorkflowEstimateLineItem = {
+    serviceId: string;
+    displayName: string;
+    route: RouteKind;
+    projectedRequests: number;
+    estimatedCostUsd: number;
+    savingsVsNaiveUsd: number;
+    reason: string;
+};
+export type WorkflowEstimateResult = {
+    totalEstimatedCostUsd: number;
+    naiveX402CostUsd: number;
+    savingsVsNaiveUsd: number;
+    breakdown: WorkflowEstimateLineItem[];
+};
+export type XmppBudgetSnapshot = {
+    agentId: string;
+    agentDisplayName: string;
+    agentSpentThisSessionUsd: number;
+    agentRemainingDailyBudgetUsd: number;
+    spentThisSessionUsd: number;
+    remainingDailyBudgetUsd: number;
+    callsThisService: number;
+    projectedCostIfRepeated5xUsd: number;
+    recommendation: string;
+};
+export type XmppRouteEvent = {
+    id: string;
+    timestamp: string;
+    agentId: string;
+    url: string;
+    method: string;
+    serviceId: string;
+    route: RouteKind;
+    status: 'settled' | 'denied' | 'preview';
+    amountUsd: number;
+    projectedRequests: number;
+    policyCode?: PolicyDecision['code'];
+    receiptId?: string;
+    txHash?: string;
+    explorerUrl?: string;
+    sessionId?: string;
+    signedReceipt?: XmppSignedReceipt;
+    feeSponsored?: boolean;
+    feeSponsorPublicKey?: string;
+    settlementStrategy?: PaymentExecutionMetadata['settlementStrategy'];
+    executionNote?: string;
+};
+export type XmppAgentStateSummary = {
+    agentId: string;
+    displayName: string;
+    role: XmppAgentProfile['role'];
+    description: string;
+    dailyBudgetUsd: number;
+    spentThisSessionUsd: number;
+    remainingDailyBudgetUsd: number;
+    routeCounts: Record<RouteKind, number>;
+    allowedServices: string[];
+    preferredRoutes: RouteKind[];
+    enabled?: boolean;
+    policySource?: XmppAgentProfile['policySource'];
+    autopayMethods?: string[];
+};
+export type XmppAgentPolicySnapshot = {
+    agentId: string;
+    enabled: boolean;
+    dailyBudgetUsd: number;
+    allowedServices: string[];
+    preferredRoutes: RouteKind[];
+    autopayMethods: string[];
+    source: 'contract' | 'local' | 'fallback';
+};
+export type XmppContractTreasurySnapshot = {
+    sharedTreasuryUsd: number;
+    totalSpentUsd: number;
+    remainingUsd: number;
+    paymentCount: number;
+    source: 'contract' | 'local' | 'fallback';
+};
+export type XmppContractAgentTreasuryState = {
+    agentId: string;
+    spentUsd: number;
+    paymentCount: number;
+    lastServiceId: string;
+    lastRoute: string;
+    source: 'contract' | 'local' | 'fallback';
+};
+export type XmppOperatorState = {
+    sharedTreasuryUsd: number;
+    sharedTreasuryRemainingUsd: number;
+    dailyBudgetUsd: number;
+    spentThisSessionUsd: number;
+    remainingDailyBudgetUsd: number;
+    sessionSavingsUsd: number;
+    routeCounts: Record<RouteKind, number>;
+    serviceSpendUsd: Record<string, number>;
+    serviceCallCounts: Record<string, number>;
+    agentProfiles: XmppAgentProfile[];
+    agentStates: XmppAgentStateSummary[];
+    contractAgentPolicies?: XmppAgentPolicySnapshot[];
+    contractTreasury?: XmppContractTreasurySnapshot | null;
+    contractAgentTreasuryStates?: XmppContractAgentTreasuryState[];
+    openSessions: Array<Pick<XmppSessionRecord, 'sessionId' | 'serviceId' | 'callCount'>>;
+    recentEvents: XmppRouteEvent[];
+};
+export type XmppReceiptVerificationResult = {
+    valid: boolean;
+    agent: string;
+    receiptId: string;
+};
+export type XmppWalletInfo = {
+    connected: boolean;
+    paymentExecutionMode: PaymentExecutionMode;
+    network: string;
+    rpcUrl: string;
+    agentPublicKey: string | null;
+    settlementStrategy: 'smart-account-ready' | 'smart-account-x402-preferred' | 'smart-account-partial-fallback' | 'keypair-live';
+    smartAccount: {
+        ready: boolean;
+        mode: 'inactive' | 'x402-only' | 'full';
+        routeCoverage: 'inactive' | 'x402-only';
+        demoReady: boolean;
+        guardedFallback: boolean;
+        contractId: string | null;
+        wasmHash: string;
+        webauthnVerifierAddress: string;
+        ed25519VerifierAddress: string;
+        spendingLimitPolicyAddress: string;
+        thresholdPolicyAddress: string;
+        preferredRoutes: RouteKind[];
+        fallbackRoutes: RouteKind[];
+        supportedRoutes: RouteKind[];
+        unsupportedRoutes: RouteKind[];
+        unsupportedReason: string | null;
+        configuredMaxTransactionFeeStroops: number;
+        effectiveMaxTransactionFeeStroops: number;
+        feeFloorApplied: boolean;
+        preflightFailures: string[];
+        coverageMessage: string;
+        message: string;
+        operatorNotes: string[];
+    };
+    feeSponsorship: {
+        enabled: boolean;
+        available: boolean;
+        mppChargeEnabled: boolean;
+        mppSessionEnabled: boolean;
+        sponsorPublicKey: string | null;
+        feeBumpPublicKey: string | null;
+        message: string;
+    };
+    missingSecrets: string[];
+    message: string;
+};
+export type XmppHealthStatus = {
+    ok: boolean;
+    service: string;
+    network: string;
+    paymentExecutionMode: PaymentExecutionMode;
+    services: Record<string, string>;
+    smartAccount: {
+        configured: boolean;
+        routeCoverage: 'inactive' | 'x402-only';
+        x402Preferred: boolean;
+        mppFallback: boolean;
+        demoReady: boolean;
+        guardedFallback: boolean;
+        unsupportedRoutes: RouteKind[];
+        unsupportedReason: string | null;
+        configuredMaxTransactionFeeStroops: number;
+        effectiveMaxTransactionFeeStroops: number;
+        feeFloorApplied: boolean;
+        preflightFailures: string[];
+    };
+};
+export type XmppCatalogResponse = {
+    services: ServiceCatalogEntry[];
+};
+export type XmppPolicyPreviewResponse = {
+    policy: PolicyDecision;
+    routePreview: RouteDecision;
+};
+export type XmppGatewayFetchResponse = {
+    status: number;
+    routePreview: RouteDecision;
+    payment?: XmppFetchMetadata;
+    responseHeaders: Record<string, string>;
+    body: unknown;
+};

package/dist/packages/types/src/index.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/wallet/src/index.d.ts

@@ -0,0 +1,14 @@
+import type { PaymentExecutionMetadata, RouteKind, XmppReceiptVerificationResult, XmppSignedReceipt, XmppSmartAccountExecution, XmppWalletInfo } from '@xmpp/types';
+export declare const SMART_ACCOUNT_MIN_TRANSACTION_FEE_STROOPS = 2000000;
+export declare function signXmppReceipt(input: Omit<XmppSignedReceipt, 'signature' | 'agent' | 'issuedAt' | 'network'> & {
+    issuedAt?: string;
+    network?: string;
+}): XmppSignedReceipt | null;
+export declare function verifyXmppReceipt(receipt: XmppSignedReceipt): XmppReceiptVerificationResult;
+export declare function getEffectiveSmartAccountFeeCeiling(): number;
+export declare function getRouteExecutionPlan(route: RouteKind): {
+    settlementStrategy: PaymentExecutionMetadata['settlementStrategy'];
+    executionNote: string;
+    smartAccount: XmppSmartAccountExecution;
+};
+export declare function getWalletInfo(): Promise<XmppWalletInfo>;

package/dist/packages/wallet/src/index.js

@@ -0,0 +1,250 @@
+import { config } from '@xmpp/config';
+import { Keypair } from '@stellar/stellar-sdk';
+export const SMART_ACCOUNT_MIN_TRANSACTION_FEE_STROOPS = 2_000_000;
+function stableReceiptPayload(receipt) {
+    return JSON.stringify({
+        receiptId: receipt.receiptId,
+        issuedAt: receipt.issuedAt,
+        network: receipt.network,
+        agent: receipt.agent,
+        serviceId: receipt.serviceId,
+        url: receipt.url,
+        method: receipt.method,
+        route: receipt.route,
+        amountUsd: receipt.amountUsd,
+        txHash: receipt.txHash ?? null,
+        explorerUrl: receipt.explorerUrl ?? null,
+        paymentReference: receipt.paymentReference ?? null,
+    });
+}
+export function signXmppReceipt(input) {
+    if (!config.wallet.agentSecretKey) {
+        return null;
+    }
+    const keypair = Keypair.fromSecret(config.wallet.agentSecretKey);
+    const receipt = {
+        ...input,
+        issuedAt: input.issuedAt ?? new Date().toISOString(),
+        network: input.network ?? config.network,
+        agent: keypair.publicKey(),
+    };
+    const payload = Buffer.from(stableReceiptPayload(receipt), 'utf8');
+    const signature = keypair.sign(payload).toString('base64');
+    return {
+        ...receipt,
+        signature,
+    };
+}
+export function verifyXmppReceipt(receipt) {
+    const keypair = Keypair.fromPublicKey(receipt.agent);
+    const payload = Buffer.from(stableReceiptPayload({
+        receiptId: receipt.receiptId,
+        issuedAt: receipt.issuedAt,
+        network: receipt.network,
+        agent: receipt.agent,
+        serviceId: receipt.serviceId,
+        url: receipt.url,
+        method: receipt.method,
+        route: receipt.route,
+        amountUsd: receipt.amountUsd,
+        txHash: receipt.txHash,
+        explorerUrl: receipt.explorerUrl,
+        paymentReference: receipt.paymentReference,
+    }), 'utf8');
+    return {
+        valid: keypair.verify(payload, Buffer.from(receipt.signature, 'base64')),
+        agent: receipt.agent,
+        receiptId: receipt.receiptId,
+    };
+}
+function smartAccountConfigured() {
+    return Boolean(config.wallet.smartAccountContractId);
+}
+export function getEffectiveSmartAccountFeeCeiling() {
+    if (!smartAccountConfigured()) {
+        return config.x402.maxTransactionFeeStroops;
+    }
+    return Math.max(config.x402.maxTransactionFeeStroops, SMART_ACCOUNT_MIN_TRANSACTION_FEE_STROOPS);
+}
+function smartAccountFeeFloorApplied() {
+    return smartAccountConfigured() &&
+        config.x402.maxTransactionFeeStroops < SMART_ACCOUNT_MIN_TRANSACTION_FEE_STROOPS;
+}
+function getSmartAccountPreflightFailures() {
+    if (!smartAccountConfigured()) {
+        return ['XMPP_SMART_ACCOUNT_CONTRACT_ID'];
+    }
+    return [
+        !config.wallet.agentSecretKey ? 'XMPP_AGENT_SECRET_KEY' : null,
+        !config.x402.facilitatorPrivateKey ? 'FACILITATOR_STELLAR_PRIVATE_KEY' : null,
+    ].filter((value) => value !== null);
+}
+function smartAccountPrimaryReady() {
+    return Boolean(config.wallet.smartAccountContractId &&
+        config.wallet.agentSecretKey &&
+        config.x402.facilitatorPrivateKey);
+}
+export function getRouteExecutionPlan(route) {
+    const configured = smartAccountConfigured();
+    const liveReady = smartAccountPrimaryReady();
+    if (route === 'x402') {
+        if (liveReady) {
+            return {
+                settlementStrategy: 'smart-account',
+                executionNote: 'x402 prefers the configured smart account, with an automatic fallback to keypair settlement if delegated auth becomes unavailable.',
+                smartAccount: {
+                    configured: true,
+                    preferred: true,
+                    supported: true,
+                    used: true,
+                    contractId: config.wallet.smartAccountContractId ?? null,
+                },
+            };
+        }
+        return {
+            settlementStrategy: 'keypair',
+            executionNote: configured
+                ? 'Smart account is configured, but x402 is staying on the agent keypair until the smart-account demo preconditions are fully satisfied.'
+                : 'x402 is executing with the agent keypair.',
+            smartAccount: {
+                configured,
+                preferred: configured,
+                supported: true,
+                used: false,
+                contractId: config.wallet.smartAccountContractId ?? null,
+                fallbackReason: configured
+                    ? 'Smart-account x402 is guarded until the delegated signer, facilitator, and fee-cap preconditions are all ready.'
+                    : 'No smart account is configured.',
+            },
+        };
+    }
+    return {
+        settlementStrategy: configured ? 'keypair-fallback' : 'keypair',
+        executionNote: configured
+            ? 'MPP is using explicit keypair execution because the current MPP SDK requires Keypair signers.'
+            : 'MPP is executing with the configured keypair signer.',
+        smartAccount: {
+            configured,
+            preferred: configured,
+            supported: false,
+            used: false,
+            contractId: config.wallet.smartAccountContractId ?? null,
+            fallbackReason: configured
+                ? 'Current MPP client flows require Keypair signers.'
+                : 'No smart account is configured.',
+        },
+    };
+}
+export async function getWalletInfo() {
+    const agentKeypair = config.wallet.agentSecretKey
+        ? Keypair.fromSecret(config.wallet.agentSecretKey)
+        : null;
+    const feeSponsorSecret = config.mpp.feeSponsorSecretKey ??
+        ((config.mpp.feeSponsorship.chargeEnabled || config.mpp.feeSponsorship.sessionEnabled)
+            ? config.mpp.secretKey
+            : undefined);
+    const feeSponsorKeypair = feeSponsorSecret ? Keypair.fromSecret(feeSponsorSecret) : null;
+    const feeBumpKeypair = config.mpp.feeBumpSecretKey
+        ? Keypair.fromSecret(config.mpp.feeBumpSecretKey)
+        : null;
+    const smartAccountReady = smartAccountConfigured();
+    const smartAccountActive = smartAccountPrimaryReady();
+    const smartAccountPreflightFailures = getSmartAccountPreflightFailures();
+    const smartAccountEffectiveFeeCeiling = getEffectiveSmartAccountFeeCeiling();
+    const smartAccountFeeFloorWasApplied = smartAccountFeeFloorApplied();
+    const smartAccountMode = smartAccountActive
+        ? 'x402-only'
+        : smartAccountReady
+            ? 'x402-only'
+            : 'inactive';
+    const smartAccountRouteCoverage = smartAccountReady
+        ? 'x402-only'
+        : 'inactive';
+    const smartAccountOperatorNotes = smartAccountActive
+        ? [
+            'Smart-account execution is enabled for x402 only.',
+            'If delegated x402 settlement becomes unavailable, xMPP falls back to the stable keypair path instead of surfacing a smart-account-specific failure.',
+            'MPP charge and session flows still use keypair execution because the current MPP client requires Keypair signers.',
+            smartAccountFeeFloorWasApplied
+                ? `The facilitator is enforcing a safe x402 fee ceiling of at least ${SMART_ACCOUNT_MIN_TRANSACTION_FEE_STROOPS.toLocaleString()} stroops for smart-account execution.`
+                : `The facilitator fee ceiling is set to ${smartAccountEffectiveFeeCeiling.toLocaleString()} stroops for smart-account x402 execution.`,
+        ]
+        : smartAccountReady
+            ? [
+                'A smart-account contract id is configured, but x402 is still guarded behind the stable keypair path until all demo preconditions are satisfied.',
+                'MPP charge and session flows remain explicit keypair routes.',
+            ]
+            : ['Smart-account execution is not configured yet.'];
+    const missingSecrets = [
+        !config.wallet.agentSecretKey ? 'XMPP_AGENT_SECRET_KEY' : null,
+        !config.x402.facilitatorPrivateKey ? 'FACILITATOR_STELLAR_PRIVATE_KEY' : null,
+        !config.mpp.secretKey ? 'MPP_SECRET_KEY' : null,
+    ].filter((value) => value !== null);
+    return {
+        connected: missingSecrets.length === 0,
+        paymentExecutionMode: config.paymentExecutionMode,
+        network: config.network,
+        rpcUrl: config.rpcUrl,
+        agentPublicKey: agentKeypair?.publicKey() ?? null,
+        settlementStrategy: smartAccountActive
+            ? 'smart-account-x402-preferred'
+            : smartAccountReady
+                ? 'smart-account-partial-fallback'
+                : 'keypair-live',
+        smartAccount: {
+            ready: smartAccountReady,
+            mode: smartAccountMode,
+            routeCoverage: smartAccountRouteCoverage,
+            demoReady: smartAccountActive,
+            guardedFallback: smartAccountReady,
+            contractId: config.wallet.smartAccountContractId ?? null,
+            wasmHash: config.wallet.smartAccountWasmHash,
+            webauthnVerifierAddress: config.wallet.webauthnVerifierAddress,
+            ed25519VerifierAddress: config.wallet.ed25519VerifierAddress,
+            spendingLimitPolicyAddress: config.wallet.spendingLimitPolicyAddress,
+            thresholdPolicyAddress: config.wallet.thresholdPolicyAddress,
+            preferredRoutes: smartAccountActive ? ['x402'] : [],
+            fallbackRoutes: smartAccountReady ? ['mpp-charge', 'mpp-session-open', 'mpp-session-reuse'] : [],
+            supportedRoutes: ['x402'],
+            unsupportedRoutes: ['mpp-charge', 'mpp-session-open', 'mpp-session-reuse'],
+            unsupportedReason: smartAccountReady
+                ? 'MPP charge and MPP session routes still require explicit Keypair signers in the current client stack.'
+                : null,
+            configuredMaxTransactionFeeStroops: config.x402.maxTransactionFeeStroops,
+            effectiveMaxTransactionFeeStroops: smartAccountEffectiveFeeCeiling,
+            feeFloorApplied: smartAccountFeeFloorWasApplied,
+            preflightFailures: smartAccountPreflightFailures,
+            coverageMessage: smartAccountReady
+                ? 'Smart-account execution is intentionally limited to x402. All MPP routes remain keypair-backed.'
+                : 'Smart-account execution is not configured.',
+            message: smartAccountActive
+                ? 'Smart-account execution is enabled for x402 only, with guarded fallback to the stable keypair path if the delegated route becomes unavailable.'
+                : smartAccountReady
+                    ? 'Smart-account identifiers are configured, but x402 stays on the stable keypair path until the delegated flow is fully demo-ready.'
+                    : 'Smart account execution is not configured yet.',
+            operatorNotes: smartAccountOperatorNotes,
+        },
+        feeSponsorship: {
+            enabled: config.mpp.feeSponsorship.chargeEnabled || config.mpp.feeSponsorship.sessionEnabled,
+            available: (config.mpp.feeSponsorship.chargeEnabled || config.mpp.feeSponsorship.sessionEnabled) &&
+                Boolean(feeSponsorKeypair),
+            mppChargeEnabled: config.mpp.feeSponsorship.chargeEnabled,
+            mppSessionEnabled: config.mpp.feeSponsorship.sessionEnabled,
+            sponsorPublicKey: feeSponsorKeypair?.publicKey() ?? null,
+            feeBumpPublicKey: feeBumpKeypair?.publicKey() ?? null,
+            message: feeSponsorKeypair
+                ? config.mpp.feeSponsorship.chargeEnabled && config.mpp.feeSponsorship.sessionEnabled
+                    ? 'MPP charge and session services can sponsor gas for agent-side flows.'
+                    : config.mpp.feeSponsorship.sessionEnabled
+                        ? 'MPP session services can sponsor gas for agent-side flows; charge stays agent-funded.'
+                        : config.mpp.feeSponsorship.chargeEnabled
+                            ? 'MPP charge services can sponsor gas for agent-side flows; sessions stay agent-funded.'
+                            : 'Fee sponsorship is disabled; the agent pays its own network fees.'
+                : 'Fee sponsorship is disabled; the agent pays its own network fees.',
+        },
+        missingSecrets,
+        message: missingSecrets.length === 0
+            ? 'xMPP has the core Stellar testnet secrets required to continue live payment integration.'
+            : 'xMPP is still missing the three core Stellar testnet secrets required for live payment execution.',
+    };
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@vinaystwt/xmpp-mcp",
+  "version": "0.1.0",
+  "description": "Installable xMPP MCP server exposing paid-fetch, route explainability, receipts, and operator tools.",
+  "type": "module",
+  "license": "MIT",
+  "main": "dist/apps/mcp-server/src/server.js",
+  "types": "dist/apps/mcp-server/src/server.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://github.com/Vinaystwt/xMPP#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Vinaystwt/xMPP.git",
+    "directory": "apps/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/Vinaystwt/xMPP/issues"
+  },
+  "keywords": [
+    "xmpp",
+    "mcp",
+    "stellar",
+    "x402",
+    "mpp",
+    "agents"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/apps/mcp-server/src/server.d.ts",
+      "import": "./dist/apps/mcp-server/src/server.js",
+      "default": "./dist/apps/mcp-server/src/server.js"
+    },
+    "./cli": {
+      "types": "./dist/apps/mcp-server/src/index.d.ts",
+      "import": "./dist/apps/mcp-server/src/index.js",
+      "default": "./dist/apps/mcp-server/src/index.js"
+    }
+  },
+  "bin": {
+    "xmpp-mcp": "dist/apps/mcp-server/src/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node --import tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint src",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@vinaystwt/xmpp-config": "0.1.0",
+    "@vinaystwt/xmpp-contract-runtime": "0.1.0",
+    "@vinaystwt/xmpp-http-interceptor": "0.1.0",
+    "@vinaystwt/xmpp-router": "0.1.0",
+    "@vinaystwt/xmpp-types": "0.1.0",
+    "@vinaystwt/xmpp-wallet": "0.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "tsx": "^4.21.0"
+  }
+}