@vinaystwt/xmpp-http-interceptor 0.1.0

package/dist/http-interceptor/src/index.test.d.ts

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

package/dist/http-interceptor/src/index.test.js

@@ -0,0 +1,131 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as paymentAdapters from '@xmpp/payment-adapters';
+import { getXmppMetadata, resetXmppRuntimeState, xmppFetch } from './index.js';
+describe('xmppFetch', () => {
+    beforeEach(() => {
+        resetXmppRuntimeState();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        resetXmppRuntimeState();
+    });
+    it('retries after a 402 payment challenge', async () => {
+        process.env.XMPP_PAYMENT_EXECUTION_MODE = 'mock';
+        const fetchMock = vi
+            .spyOn(globalThis, 'fetch')
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+            kind: 'x402',
+            service: 'research-api',
+            amountUsd: 0.01,
+            retryHeaderName: 'x-xmpp-paid',
+            retryHeaderValue: 'ok',
+        }), {
+            status: 402,
+            headers: { 'content-type': 'application/json' },
+        }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+        const response = await xmppFetch('http://localhost:4101/research?q=stellar');
+        const metadata = getXmppMetadata(response);
+        expect(response.status).toBe(200);
+        expect(metadata?.retried).toBe(true);
+        expect(metadata?.execution?.status).toBeDefined();
+        expect(metadata?.execution?.status).not.toBe('missing-config');
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+    });
+    it('stops before retry when testnet mode is missing secrets', async () => {
+        process.env.XMPP_PAYMENT_EXECUTION_MODE = 'testnet';
+        delete process.env.XMPP_AGENT_SECRET_KEY;
+        delete process.env.MPP_SECRET_KEY;
+        const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify({
+            kind: 'mpp-charge',
+            service: 'market-api',
+            amountUsd: 0.03,
+            retryHeaderName: 'x-xmpp-paid',
+            retryHeaderValue: 'ok',
+        }), {
+            status: 402,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const response = await xmppFetch('http://localhost:4102/quote?symbol=XLM', undefined, {
+            serviceId: 'market-api',
+        });
+        const metadata = getXmppMetadata(response);
+        expect(response.status).toBe(424);
+        expect(metadata?.retried).toBe(false);
+        expect(metadata?.execution?.status).toBe('missing-config');
+        expect(metadata?.execution?.missingConfig).toContain('XMPP_AGENT_SECRET_KEY');
+        expect(metadata?.execution?.missingConfig).toContain('MPP_SECRET_KEY');
+        expect(fetchMock).toHaveBeenCalledTimes(0);
+    });
+    it('blocks unsafe routes before any network request', async () => {
+        process.env.XMPP_PAYMENT_EXECUTION_MODE = 'mock';
+        const fetchMock = vi.spyOn(globalThis, 'fetch');
+        const response = await xmppFetch('http://localhost:4102/admin/export');
+        const metadata = getXmppMetadata(response);
+        const body = await response.json();
+        expect(response.status).toBe(403);
+        expect(body.error).toContain('policy denied');
+        expect(metadata?.policy?.allowed).toBe(false);
+        expect(metadata?.policy?.code).toBe('blocked-path');
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    it('blocks an agent from spending against a disallowed service', async () => {
+        process.env.XMPP_PAYMENT_EXECUTION_MODE = 'mock';
+        const fetchMock = vi.spyOn(globalThis, 'fetch');
+        const response = await xmppFetch('http://localhost:4102/quote?symbol=XLM', undefined, {
+            agentId: 'research-agent',
+            serviceId: 'market-api',
+            projectedRequests: 1,
+        });
+        const metadata = getXmppMetadata(response);
+        const body = await response.json();
+        expect(response.status).toBe(403);
+        expect(body.error).toContain('agent policy denied');
+        expect(metadata?.policy?.code).toBe('blocked-agent');
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    it('opens then reuses a session in testnet mode and clears it on runtime reset', async () => {
+        process.env.XMPP_PAYMENT_EXECUTION_MODE = 'testnet';
+        process.env.XMPP_AGENT_SECRET_KEY =
+            'SDJ5L6UNCSFK5L2AUIIRVIE7KW4HAZ6N7P2KQ6CUPT5KUG6J6LYW7CLW';
+        process.env.MPP_SECRET_KEY =
+            'SB5Y5P5ONLTHYBUFSUWPG4KSTC35DEYKM3NOMFEML3A5FC4T5TXV6H3V';
+        process.env.MPP_CHANNEL_CONTRACT_ID =
+            'CDCMWMSCRL2HR5YZLMFKLWR5DEPTAEOOLKBXYLQ2MK4FBPUOVUP72E3A';
+        const executePaymentRoute = vi
+            .spyOn(paymentAdapters, 'executePaymentRoute')
+            .mockImplementation(async (route) => ({
+            response: new Response(JSON.stringify({ ok: true, route }), { status: 200 }),
+            metadata: {
+                mode: 'testnet',
+                status: 'settled-testnet',
+                route,
+                receiptId: `receipt-${route}`,
+            },
+        }));
+        const input = 'http://localhost:4103/stream/tick';
+        const options = {
+            agentId: 'market-agent',
+            serviceId: 'stream-api',
+            projectedRequests: 5,
+            streaming: true,
+        };
+        const first = await xmppFetch(input, { method: 'GET' }, options);
+        const firstMetadata = getXmppMetadata(first);
+        const second = await xmppFetch(input, { method: 'GET' }, options);
+        const secondMetadata = getXmppMetadata(second);
+        expect(firstMetadata?.route).toBe('mpp-session-open');
+        expect(firstMetadata?.execution?.route).toBe('mpp-session-open');
+        expect(secondMetadata?.route).toBe('mpp-session-reuse');
+        expect(secondMetadata?.execution?.route).toBe('mpp-session-reuse');
+        expect(executePaymentRoute.mock.calls.map(([route]) => route)).toEqual([
+            'mpp-session-open',
+            'mpp-session-reuse',
+        ]);
+        resetXmppRuntimeState();
+        const afterReset = await xmppFetch(input, { method: 'GET' }, options);
+        const resetMetadata = getXmppMetadata(afterReset);
+        expect(resetMetadata?.route).toBe('mpp-session-open');
+        expect(resetMetadata?.execution?.route).toBe('mpp-session-open');
+    });
+});

package/dist/http-interceptor/src/state.d.ts

@@ -0,0 +1,17 @@
+import type { XmppAgentProfile, RouteKind, XmppAgentStateSummary, XmppBudgetSnapshot, XmppOperatorState, XmppRouteEvent, XmppSessionRecord } from '@xmpp/types';
+export declare function recordXmppEvent(input: Omit<XmppRouteEvent, 'id' | 'timestamp'>): XmppRouteEvent;
+export declare function upsertLocalSession(sessionId: string, serviceId: string, callCount: number): void;
+export declare function listLocalSessions(): Pick<XmppSessionRecord, "serviceId" | "sessionId" | "callCount">[];
+export declare function buildBudgetSnapshot(input: {
+    agentId?: string;
+    agentProfile?: XmppAgentProfile;
+    url: string;
+    method: string;
+    serviceId?: string;
+    route: RouteKind;
+    projectedRequests?: number;
+    hasReusableSession?: boolean;
+}): XmppBudgetSnapshot;
+export declare function buildAgentStates(profiles?: XmppAgentProfile[]): XmppAgentStateSummary[];
+export declare function getXmppOperatorState(agentProfiles?: XmppAgentProfile[]): XmppOperatorState;
+export declare function resetXmppOperatorState(): void;

package/dist/http-interceptor/src/state.js

@@ -0,0 +1,188 @@
+import { config } from '@xmpp/config';
+import { createRouter, estimateRouteCost, resolveCatalogEntry } from '@xmpp/router';
+import { getXmppAgentProfile, listXmppAgentProfiles } from './agents.js';
+const router = createRouter();
+const recentEvents = [];
+const serviceSpendUsd = new Map();
+const serviceCallCounts = new Map();
+const agentSpendUsd = new Map();
+const agentServiceCallCounts = new Map();
+const agentRouteCounts = new Map();
+const routeCounts = {
+    x402: 0,
+    'mpp-charge': 0,
+    'mpp-session-open': 0,
+    'mpp-session-reuse': 0,
+};
+const openSessions = new Map();
+let sessionSavingsUsd = 0;
+function roundUsd(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function pushEvent(event) {
+    recentEvents.unshift(event);
+    if (recentEvents.length > 25) {
+        recentEvents.length = 25;
+    }
+}
+function emptyRouteCounts() {
+    return {
+        x402: 0,
+        'mpp-charge': 0,
+        'mpp-session-open': 0,
+        'mpp-session-reuse': 0,
+    };
+}
+function getAgentRouteCounter(agentId) {
+    const existing = agentRouteCounts.get(agentId);
+    if (existing) {
+        return existing;
+    }
+    const created = emptyRouteCounts();
+    agentRouteCounts.set(agentId, created);
+    return created;
+}
+export function recordXmppEvent(input) {
+    const event = {
+        id: `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+        timestamp: new Date().toISOString(),
+        ...input,
+        amountUsd: roundUsd(input.amountUsd),
+    };
+    pushEvent(event);
+    if (event.status === 'settled' && event.amountUsd > 0) {
+        routeCounts[event.route] += 1;
+        getAgentRouteCounter(event.agentId)[event.route] += 1;
+        serviceSpendUsd.set(event.serviceId, roundUsd((serviceSpendUsd.get(event.serviceId) ?? 0) + event.amountUsd));
+        serviceCallCounts.set(event.serviceId, (serviceCallCounts.get(event.serviceId) ?? 0) + 1);
+        agentSpendUsd.set(event.agentId, roundUsd((agentSpendUsd.get(event.agentId) ?? 0) + event.amountUsd));
+        agentServiceCallCounts.set(`${event.agentId}:${event.serviceId}`, (agentServiceCallCounts.get(`${event.agentId}:${event.serviceId}`) ?? 0) + 1);
+        const naiveCost = estimateRouteCost({
+            route: 'x402',
+            url: event.url,
+            method: event.method,
+            serviceId: event.serviceId,
+            projectedRequests: 1,
+        });
+        sessionSavingsUsd = roundUsd(sessionSavingsUsd + Math.max(0, naiveCost - event.amountUsd));
+    }
+    return event;
+}
+export function upsertLocalSession(sessionId, serviceId, callCount) {
+    openSessions.set(sessionId, {
+        sessionId,
+        serviceId,
+        callCount,
+    });
+}
+export function listLocalSessions() {
+    return [...openSessions.values()];
+}
+export function buildBudgetSnapshot(input) {
+    const agent = input.agentProfile ?? getXmppAgentProfile(input.agentId);
+    const serviceId = input.serviceId ?? resolveCatalogEntry(input).serviceId;
+    const callsThisService = agentServiceCallCounts.get(`${agent.agentId}:${serviceId}`) ?? 0;
+    const agentSpentThisSessionUsd = roundUsd(agentSpendUsd.get(agent.agentId) ?? 0);
+    const agentRemainingDailyBudgetUsd = roundUsd(Math.max(0, agent.dailyBudgetUsd - agentSpentThisSessionUsd));
+    const spentThisSessionUsd = roundUsd([...serviceSpendUsd.values()].reduce((sum, value) => sum + value, 0));
+    const remainingDailyBudgetUsd = roundUsd(Math.max(0, config.dailyBudgetUsd - spentThisSessionUsd));
+    const projectedCostIfRepeated5xUsd = roundUsd(estimateRouteCost({
+        route: input.route,
+        url: input.url,
+        method: input.method,
+        serviceId,
+        projectedRequests: 5,
+        hasReusableSession: input.hasReusableSession,
+    }));
+    const catalog = resolveCatalogEntry({
+        url: input.url,
+        method: input.method,
+        serviceId,
+        projectedRequests: input.projectedRequests,
+        streaming: false,
+    });
+    const repeatDecision = router.explain({
+        url: input.url,
+        method: input.method,
+        serviceId,
+        projectedRequests: Math.max(callsThisService + 1, catalog.routingHints.breakEvenCalls),
+        streaming: catalog.routingHints.streamingPreferred,
+        hasReusableSession: input.hasReusableSession,
+    });
+    let recommendation = `${repeatDecision.service?.displayName ?? serviceId} stays on ${repeatDecision.route} under the current usage forecast.`;
+    if (input.route === 'x402' &&
+        catalog.capabilities.mppSession &&
+        callsThisService < catalog.routingHints.breakEvenCalls) {
+        const remainingCalls = catalog.routingHints.breakEvenCalls - callsThisService;
+        recommendation = `Switch to MPP session after ${remainingCalls} more calls to amortize channel setup.`;
+    }
+    else if (input.route === 'mpp-session-open' || input.route === 'mpp-session-reuse') {
+        recommendation = 'Keep reusing the current MPP session to compress repeat spend into one channel lifecycle.';
+    }
+    else if (input.route === 'mpp-charge') {
+        recommendation = 'MPP charge remains the cleanest path for premium one-shot calls on this service.';
+    }
+    return {
+        agentId: agent.agentId,
+        agentDisplayName: agent.displayName,
+        agentSpentThisSessionUsd,
+        agentRemainingDailyBudgetUsd,
+        spentThisSessionUsd,
+        remainingDailyBudgetUsd,
+        callsThisService,
+        projectedCostIfRepeated5xUsd,
+        recommendation,
+    };
+}
+export function buildAgentStates(profiles = listXmppAgentProfiles()) {
+    return profiles.map((profile) => {
+        const spentThisSessionUsd = roundUsd(agentSpendUsd.get(profile.agentId) ?? 0);
+        return {
+            agentId: profile.agentId,
+            displayName: profile.displayName,
+            role: profile.role,
+            description: profile.description,
+            dailyBudgetUsd: profile.dailyBudgetUsd,
+            spentThisSessionUsd,
+            remainingDailyBudgetUsd: roundUsd(Math.max(0, profile.dailyBudgetUsd - spentThisSessionUsd)),
+            routeCounts: { ...getAgentRouteCounter(profile.agentId) },
+            allowedServices: [...profile.allowedServices],
+            preferredRoutes: [...profile.preferredRoutes],
+            enabled: profile.enabled ?? true,
+            policySource: profile.policySource ?? 'local',
+            autopayMethods: [...profile.autopayMethods],
+        };
+    });
+}
+export function getXmppOperatorState(agentProfiles = listXmppAgentProfiles()) {
+    const spentThisSessionUsd = roundUsd([...serviceSpendUsd.values()].reduce((sum, value) => sum + value, 0));
+    return {
+        sharedTreasuryUsd: config.dailyBudgetUsd,
+        sharedTreasuryRemainingUsd: roundUsd(Math.max(0, config.dailyBudgetUsd - spentThisSessionUsd)),
+        dailyBudgetUsd: config.dailyBudgetUsd,
+        spentThisSessionUsd,
+        remainingDailyBudgetUsd: roundUsd(Math.max(0, config.dailyBudgetUsd - spentThisSessionUsd)),
+        sessionSavingsUsd,
+        routeCounts: { ...routeCounts },
+        serviceSpendUsd: Object.fromEntries(serviceSpendUsd),
+        serviceCallCounts: Object.fromEntries(serviceCallCounts),
+        agentProfiles,
+        agentStates: buildAgentStates(agentProfiles),
+        openSessions: listLocalSessions(),
+        recentEvents: [...recentEvents],
+    };
+}
+export function resetXmppOperatorState() {
+    recentEvents.length = 0;
+    serviceSpendUsd.clear();
+    serviceCallCounts.clear();
+    agentSpendUsd.clear();
+    agentServiceCallCounts.clear();
+    agentRouteCounts.clear();
+    openSessions.clear();
+    sessionSavingsUsd = 0;
+    routeCounts.x402 = 0;
+    routeCounts['mpp-charge'] = 0;
+    routeCounts['mpp-session-open'] = 0;
+    routeCounts['mpp-session-reuse'] = 0;
+}

package/dist/logger/src/index.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;

package/dist/logger/src/index.js

@@ -0,0 +1,18 @@
+import pino from 'pino';
+export const logger = pino({
+    name: 'xmpp',
+    level: process.env.LOG_LEVEL ?? 'info',
+    redact: {
+        paths: [
+            'req.headers.authorization',
+            'req.headers.x-api-key',
+            'req.headers.cookie',
+            'req.body.headers.authorization',
+            'req.body.headers.x-api-key',
+            'req.body.options.idempotencyKey',
+            'err.config.headers.authorization',
+            'err.config.headers.x-api-key',
+        ],
+        censor: '[REDACTED]',
+    },
+});

package/dist/payment-adapters/src/index.d.ts

@@ -0,0 +1,27 @@
+import { Keypair, xdr } from '@stellar/stellar-sdk';
+import type { PaymentChallenge, PaymentExecutionMetadata, PaymentExecutionResult, RouteKind } from '@xmpp/types';
+import { XLM_SAC_TESTNET } from '@stellar/mpp';
+declare function createClassicSignatureScVal(keypair: Keypair, payload: Buffer): xdr.ScVal;
+declare function createDelegatedSignerScVal(publicKey: string): xdr.ScVal;
+declare function createDelegatedAuthPayload(publicKey: string, contextRuleIds: number[]): xdr.ScVal;
+declare function buildSmartAccountSignaturePayload(entry: xdr.SorobanAuthorizationEntry, networkPassphrase: string): Buffer<ArrayBufferLike>;
+declare function buildSmartAccountAuthDigest(signaturePayload: Buffer, contextRuleIds: number[]): Buffer<ArrayBufferLike>;
+declare function signDelegatedSmartAccountAuth(authEntries: xdr.SorobanAuthorizationEntry[], smartAccountContractId: string, delegatedSigner: Keypair, expiration: number, networkPassphrase: string, contextRuleIds?: number[]): xdr.SorobanAuthorizationEntry[];
+export declare const __smartAccountTestUtils: {
+    createClassicSignatureScVal: typeof createClassicSignatureScVal;
+    createDelegatedSignerScVal: typeof createDelegatedSignerScVal;
+    createDelegatedAuthPayload: typeof createDelegatedAuthPayload;
+    buildSmartAccountSignaturePayload: typeof buildSmartAccountSignaturePayload;
+    buildSmartAccountAuthDigest: typeof buildSmartAccountAuthDigest;
+    signDelegatedSmartAccountAuth: typeof signDelegatedSmartAccountAuth;
+};
+export declare function buildRetryHeaders(challenge: PaymentChallenge, route: RouteKind): {
+    [challenge.retryHeaderName]: string;
+    'x-xmpp-route': RouteKind;
+};
+export declare function preparePaymentExecution(challenge: PaymentChallenge, route: RouteKind): {
+    headers: Record<string, string>;
+    metadata: PaymentExecutionMetadata;
+};
+export declare function executePaymentRoute(route: RouteKind, input: RequestInfo | URL, init?: RequestInit): Promise<PaymentExecutionResult>;
+export { XLM_SAC_TESTNET };