@vinaystwt/xmpp-mcp 0.1.0

package/dist/packages/contract-runtime/src/index.js

@@ -0,0 +1,364 @@
+import { Keypair } from '@stellar/stellar-sdk';
+import { Client, basicNodeSigner } from '@stellar/stellar-sdk/contract';
+import { config } from '@xmpp/config';
+import { logger } from '@xmpp/logger';
+let policyClientPromise;
+let sessionRegistryClientPromise;
+let policyClientDisabled = false;
+let sessionRegistryClientDisabled = false;
+function contractRuntimeEnabled() {
+    return process.env.VITEST !== 'true' && process.env.XMPP_DISABLE_CONTRACT_RUNTIME !== 'true';
+}
+function toNumber(value) {
+    return value == null ? 0 : Number(value);
+}
+function normalizeStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => String(entry));
+    }
+    if (value && typeof value === 'object' && Symbol.iterator in value) {
+        return [...value].map((entry) => String(entry));
+    }
+    return [];
+}
+function getAgentKeypair() {
+    if (!config.wallet.agentSecretKey) {
+        return null;
+    }
+    try {
+        return Keypair.fromSecret(config.wallet.agentSecretKey);
+    }
+    catch (error) {
+        logger.warn({ error }, '[xMPP] failed to parse agent secret key for contract runtime');
+        return null;
+    }
+}
+function getClientOptions(contractId) {
+    const keypair = getAgentKeypair();
+    if (!keypair) {
+        return null;
+    }
+    return {
+        contractId,
+        rpcUrl: config.rpcUrl,
+        networkPassphrase: config.networkPassphrase,
+        allowHttp: config.rpcUrl.startsWith('http://'),
+        publicKey: keypair.publicKey(),
+        ...basicNodeSigner(keypair, config.networkPassphrase),
+    };
+}
+async function createClient(contractId, label) {
+    const options = getClientOptions(contractId);
+    if (!options) {
+        logger.debug({ label }, '[xMPP] contract runtime disabled because no agent signer is available');
+        return null;
+    }
+    try {
+        return (await Client.from(options));
+    }
+    catch (error) {
+        logger.warn({ error, contractId, label }, '[xMPP] failed to create Soroban contract client');
+        return null;
+    }
+}
+function hasMethod(client, method, label) {
+    if (typeof client[method] === 'function') {
+        return true;
+    }
+    logger.warn({ label, method }, '[xMPP] contract method is unavailable on deployed contract');
+    return false;
+}
+async function getPolicyClient() {
+    if (!contractRuntimeEnabled() || !config.contracts.policyContractId || policyClientDisabled) {
+        return null;
+    }
+    policyClientPromise ??= createClient(config.contracts.policyContractId, 'policy');
+    const client = await policyClientPromise;
+    if (!client) {
+        policyClientDisabled = true;
+        return null;
+    }
+    if (!hasMethod(client, 'get_global_policy', 'policy') || !hasMethod(client, 'pause_flag', 'policy')) {
+        policyClientDisabled = true;
+        return null;
+    }
+    return client;
+}
+async function getSessionRegistryClient() {
+    if (!contractRuntimeEnabled() ||
+        !config.contracts.sessionRegistryContractId ||
+        sessionRegistryClientDisabled) {
+        return null;
+    }
+    sessionRegistryClientPromise ??= createClient(config.contracts.sessionRegistryContractId, 'session-registry');
+    const client = await sessionRegistryClientPromise;
+    if (!client) {
+        sessionRegistryClientDisabled = true;
+        return null;
+    }
+    if (!hasMethod(client, 'upsert_session', 'session-registry')) {
+        sessionRegistryClientDisabled = true;
+        return null;
+    }
+    return client;
+}
+function normalizeGlobalPolicy(policy) {
+    return {
+        maxSpendUsdCents: toNumber(policy.max_spend_usd_cents),
+        allowUnknownServices: policy.allow_unknown_services,
+        allowPostAutopay: policy.allow_post_autopay,
+    };
+}
+function normalizeServicePolicy(policy) {
+    if (!policy) {
+        return null;
+    }
+    return {
+        serviceId: policy.service_id,
+        enabled: policy.enabled,
+        maxSpendUsdCents: toNumber(policy.max_spend_usd_cents),
+        preferredRoute: policy.preferred_route,
+        allowSessionReuse: policy.allow_session_reuse,
+    };
+}
+function normalizeAgentPolicy(policy) {
+    if (!policy) {
+        return null;
+    }
+    return {
+        agentId: policy.agent_id,
+        enabled: policy.enabled,
+        dailyBudgetUsd: toNumber(policy.daily_budget_usd_cents) / 100,
+        allowedServices: normalizeStringList(policy.allowed_services),
+        preferredRoutes: normalizeStringList(policy.preferred_routes),
+        autopayMethods: normalizeStringList(policy.autopay_methods),
+        source: 'contract',
+    };
+}
+function normalizeTreasurySnapshot(snapshot) {
+    if (!snapshot) {
+        return null;
+    }
+    const sharedTreasuryUsd = toNumber(snapshot.shared_treasury_usd_cents) / 100;
+    const totalSpentUsd = toNumber(snapshot.total_spent_usd_cents) / 100;
+    return {
+        sharedTreasuryUsd,
+        totalSpentUsd,
+        remainingUsd: Math.max(0, sharedTreasuryUsd - totalSpentUsd),
+        paymentCount: Number(snapshot.payment_count ?? 0),
+        source: 'contract',
+    };
+}
+function normalizeAgentTreasuryState(state) {
+    if (!state) {
+        return null;
+    }
+    return {
+        agentId: state.agent_id,
+        spentUsd: toNumber(state.spent_usd_cents) / 100,
+        paymentCount: Number(state.payment_count ?? 0),
+        lastServiceId: state.last_service_id,
+        lastRoute: state.last_route,
+        source: 'contract',
+    };
+}
+function normalizeSessionRecord(record) {
+    return {
+        sessionId: String(record.session_id ?? ''),
+        serviceId: String(record.service_id ?? ''),
+        agent: String(record.agent ?? ''),
+        channelContractId: String(record.channel_contract_id ?? ''),
+        route: String(record.route ?? ''),
+        status: String(record.status ?? ''),
+        totalAmountUsdCents: toNumber(record.total_amount_usd_cents),
+        callCount: Number(record.call_count ?? 0),
+        lastReceiptId: String(record.last_receipt_id ?? ''),
+        updatedAtLedger: Number(record.updated_at_ledger ?? 0),
+    };
+}
+export async function getAgentPolicySnapshot(agentId) {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'get_agent_policy', 'policy')) {
+        return {
+            source: 'local',
+            agentPolicy: null,
+        };
+    }
+    try {
+        const tx = await client.get_agent_policy({ agent_id: agentId });
+        return {
+            source: 'contract',
+            agentPolicy: normalizeAgentPolicy(tx.result ?? null),
+        };
+    }
+    catch (error) {
+        logger.warn({ error, agentId }, '[xMPP] failed to read agent policy from contract, falling back');
+        return {
+            source: 'fallback',
+            agentPolicy: null,
+        };
+    }
+}
+export async function listAgentPolicySnapshots() {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'list_agent_policies', 'policy')) {
+        return [];
+    }
+    try {
+        const tx = await client.list_agent_policies();
+        const result = tx.result;
+        return Array.isArray(result)
+            ? result.filter((entry) => Boolean(entry)).flatMap((entry) => {
+                const normalized = normalizeAgentPolicy(entry);
+                return normalized ? [normalized] : [];
+            })
+            : [];
+    }
+    catch (error) {
+        logger.warn({ error }, '[xMPP] failed to list agent policies from contract');
+        return [];
+    }
+}
+export async function getTreasurySnapshot() {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'get_treasury_snapshot', 'policy')) {
+        return null;
+    }
+    try {
+        const tx = await client.get_treasury_snapshot();
+        return normalizeTreasurySnapshot(tx.result ?? null);
+    }
+    catch (error) {
+        logger.warn({ error }, '[xMPP] failed to read treasury snapshot from contract');
+        return null;
+    }
+}
+export async function getAgentTreasuryState(agentId) {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'get_agent_treasury_state', 'policy')) {
+        return null;
+    }
+    try {
+        const tx = await client.get_agent_treasury_state({ agent_id: agentId });
+        return normalizeAgentTreasuryState(tx.result ?? null);
+    }
+    catch (error) {
+        logger.warn({ error, agentId }, '[xMPP] failed to read agent treasury state from contract');
+        return null;
+    }
+}
+export async function listAgentTreasuryStates() {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'list_agent_treasury_states', 'policy')) {
+        return [];
+    }
+    try {
+        const tx = await client.list_agent_treasury_states();
+        const result = tx.result;
+        return Array.isArray(result)
+            ? result.flatMap((entry) => {
+                const normalized = normalizeAgentTreasuryState(entry);
+                return normalized ? [normalized] : [];
+            })
+            : [];
+    }
+    catch (error) {
+        logger.warn({ error }, '[xMPP] failed to list agent treasury states from contract');
+        return [];
+    }
+}
+export async function getPolicyRuntimeSnapshot(serviceId) {
+    const client = await getPolicyClient();
+    if (!client) {
+        return {
+            source: 'local',
+            pauseFlag: false,
+            globalPolicy: null,
+            servicePolicy: null,
+        };
+    }
+    try {
+        const globalPolicyTx = await client.get_global_policy();
+        const pauseFlagTx = await client.pause_flag();
+        const servicePolicyTx = serviceId && hasMethod(client, 'get_service_policy', 'policy')
+            ? await client.get_service_policy({ service_id: serviceId })
+            : null;
+        return {
+            source: 'contract',
+            pauseFlag: Boolean(pauseFlagTx.result),
+            globalPolicy: normalizeGlobalPolicy(globalPolicyTx.result),
+            servicePolicy: normalizeServicePolicy(servicePolicyTx?.result ?? null),
+        };
+    }
+    catch (error) {
+        logger.warn({ error, serviceId }, '[xMPP] failed to read policy from contract, falling back');
+        return {
+            source: 'fallback',
+            pauseFlag: false,
+            globalPolicy: null,
+            servicePolicy: null,
+        };
+    }
+}
+export async function recordTreasurySpend(input) {
+    const client = await getPolicyClient();
+    if (!client || !hasMethod(client, 'record_treasury_spend', 'policy')) {
+        return null;
+    }
+    try {
+        const tx = await client.record_treasury_spend({
+            agent_id: input.agentId,
+            service_id: input.serviceId,
+            route: input.route,
+            amount_usd_cents: BigInt(input.amountUsdCents),
+        });
+        const sent = await tx.signAndSend();
+        return normalizeAgentTreasuryState(sent.result);
+    }
+    catch (error) {
+        logger.warn({ error, input }, '[xMPP] failed to record treasury spend in contract');
+        return null;
+    }
+}
+export async function recordSessionRouteEvent(input) {
+    const client = await getSessionRegistryClient();
+    const keypair = getAgentKeypair();
+    if (!client || !keypair) {
+        return null;
+    }
+    try {
+        const tx = await client.upsert_session({
+            agent: keypair.publicKey(),
+            session_id: input.sessionId,
+            service_id: input.serviceId,
+            channel_contract_id: config.mpp.channelContractId ?? '',
+            route: input.route,
+            total_amount_usd_cents: BigInt(input.totalAmountUsdCents ?? 0),
+            call_count: input.callCount,
+            last_receipt_id: input.receiptId,
+            status: input.status,
+        });
+        const sent = await tx.signAndSend();
+        return normalizeSessionRecord(sent.result);
+    }
+    catch (error) {
+        logger.warn({ error, input }, '[xMPP] failed to write session route event to contract');
+        return null;
+    }
+}
+export async function listAgentSessions() {
+    const client = await getSessionRegistryClient();
+    const keypair = getAgentKeypair();
+    if (!client || !keypair || !hasMethod(client, 'list_agent_sessions', 'session-registry')) {
+        return [];
+    }
+    try {
+        const tx = await client.list_agent_sessions({ agent: keypair.publicKey() });
+        const result = tx.result;
+        return Array.isArray(result) ? result.map(normalizeSessionRecord) : [];
+    }
+    catch (error) {
+        logger.warn({ error }, '[xMPP] failed to list agent sessions from contract');
+        return [];
+    }
+}

package/dist/packages/http-interceptor/src/agents.d.ts

@@ -0,0 +1,5 @@
+import type { XmppAgentPolicySnapshot, XmppAgentProfile } from '@xmpp/types';
+export declare function listXmppAgentProfiles(): XmppAgentProfile[];
+export declare function getXmppAgentProfile(agentId?: string): XmppAgentProfile;
+export declare function applyAgentPolicy(profile: XmppAgentProfile, policy: XmppAgentPolicySnapshot | null | undefined): XmppAgentProfile;
+export declare function mergeAgentPolicies(profiles: XmppAgentProfile[], policies: XmppAgentPolicySnapshot[]): XmppAgentProfile[];

package/dist/packages/http-interceptor/src/agents.js

@@ -0,0 +1,88 @@
+import { config } from '@xmpp/config';
+const ALL_ROUTES = ['x402', 'mpp-charge', 'mpp-session-open', 'mpp-session-reuse'];
+const ROUTE_SET = new Set(ALL_ROUTES);
+function roundUsd(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function normalizeRoutes(routes) {
+    return routes.filter((route) => ROUTE_SET.has(route));
+}
+function normalizeAutopayMethods(methods) {
+    return [...new Set(methods.map((method) => method.toUpperCase()))];
+}
+function buildAgentProfiles() {
+    const researchBudget = roundUsd(config.dailyBudgetUsd * 0.3);
+    const marketBudget = roundUsd(config.dailyBudgetUsd * 0.7);
+    return [
+        {
+            agentId: 'shared-treasury',
+            displayName: 'Shared Treasury',
+            role: 'shared',
+            description: 'Default unrestricted orchestrator agent backed by the common wallet.',
+            dailyBudgetUsd: roundUsd(config.dailyBudgetUsd),
+            allowedServices: ['research-api', 'market-api', 'stream-api'],
+            preferredRoutes: ALL_ROUTES,
+            autopayMethods: ['GET', 'HEAD'],
+            enabled: true,
+            policySource: 'local',
+        },
+        {
+            agentId: 'research-agent',
+            displayName: 'Research Agent',
+            role: 'research',
+            description: 'Low-risk research worker limited to exact x402 calls on the research API.',
+            dailyBudgetUsd: researchBudget,
+            allowedServices: ['research-api'],
+            preferredRoutes: ['x402'],
+            autopayMethods: ['GET'],
+            enabled: true,
+            policySource: 'local',
+        },
+        {
+            agentId: 'market-agent',
+            displayName: 'Market Agent',
+            role: 'market',
+            description: 'Higher-ceiling market worker optimized for premium quotes and reusable session flows.',
+            dailyBudgetUsd: marketBudget,
+            allowedServices: ['market-api', 'stream-api'],
+            preferredRoutes: ['mpp-charge', 'mpp-session-open', 'mpp-session-reuse'],
+            autopayMethods: ['GET'],
+            enabled: true,
+            policySource: 'local',
+        },
+    ];
+}
+export function listXmppAgentProfiles() {
+    return buildAgentProfiles();
+}
+export function getXmppAgentProfile(agentId) {
+    const profiles = buildAgentProfiles();
+    if (!agentId) {
+        return profiles[0];
+    }
+    return profiles.find((profile) => profile.agentId === agentId) ?? profiles[0];
+}
+export function applyAgentPolicy(profile, policy) {
+    if (!policy) {
+        return {
+            ...profile,
+            enabled: profile.enabled ?? true,
+            policySource: profile.policySource ?? 'local',
+        };
+    }
+    const preferredRoutes = normalizeRoutes(policy.preferredRoutes);
+    const autopayMethods = normalizeAutopayMethods(policy.autopayMethods);
+    return {
+        ...profile,
+        dailyBudgetUsd: policy.dailyBudgetUsd > 0 ? roundUsd(policy.dailyBudgetUsd) : profile.dailyBudgetUsd,
+        allowedServices: policy.allowedServices.length > 0 ? [...policy.allowedServices] : profile.allowedServices,
+        preferredRoutes: preferredRoutes.length > 0 ? preferredRoutes : profile.preferredRoutes,
+        autopayMethods: autopayMethods.length > 0 ? autopayMethods : profile.autopayMethods,
+        enabled: policy.enabled,
+        policySource: 'merged',
+    };
+}
+export function mergeAgentPolicies(profiles, policies) {
+    const policiesByAgentId = new Map(policies.map((policy) => [policy.agentId, policy]));
+    return profiles.map((profile) => applyAgentPolicy(profile, policiesByAgentId.get(profile.agentId)));
+}

package/dist/packages/http-interceptor/src/idempotency.d.ts

@@ -0,0 +1,68 @@
+import type { XmppFetchMetadata, XmppFetchOptions } from '@xmpp/types';
+type IdempotencySnapshot = {
+    fingerprint: string;
+    storedAt: number;
+    inflight: boolean;
+    response?: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        metadata: XmppFetchMetadata;
+    };
+};
+export declare function inspectIdempotency(url: string, method: string, init?: RequestInit, options?: XmppFetchOptions): {
+    allowed: true;
+    code?: undefined;
+    reason?: undefined;
+    idempotencyKey?: undefined;
+    fingerprint?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: false;
+    code: string;
+    reason: string;
+    idempotencyKey?: undefined;
+    fingerprint?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: true;
+    idempotencyKey: string;
+    fingerprint: string;
+    code?: undefined;
+    reason?: undefined;
+    replay?: undefined;
+    response?: undefined;
+} | {
+    allowed: true;
+    idempotencyKey: string;
+    fingerprint: string;
+    replay: true;
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        metadata: XmppFetchMetadata;
+    };
+    code?: undefined;
+    reason?: undefined;
+};
+export declare function storeIdempotentResponse(idempotencyKey: string, fingerprint: string, response: Response, metadata: XmppFetchMetadata): Promise<void>;
+export declare function clearIdempotentReservation(idempotencyKey: string, fingerprint: string): void;
+export declare function buildIdempotentReplay(snapshot: IdempotencySnapshot['response']): {
+    response: Response;
+    metadata: {
+        idempotentReplay: boolean;
+        route: import("@xmpp/types").RouteKind;
+        challenge?: import("@xmpp/types").PaymentChallenge;
+        retried: boolean;
+        execution?: import("@xmpp/types").PaymentExecutionMetadata;
+        policy?: import("@xmpp/types").PolicyDecision;
+        budget?: import("@xmpp/types").XmppBudgetSnapshot;
+    };
+} | null;
+export declare function resetIdempotencyCache(): void;
+export {};

package/dist/packages/http-interceptor/src/idempotency.js

@@ -0,0 +1,149 @@
+import { createHash } from 'node:crypto';
+const IDEMPOTENCY_TTL_MS = 60 * 60 * 1000;
+const idempotencyCache = new Map();
+function normalizeBody(body) {
+    if (body == null) {
+        return '';
+    }
+    if (typeof body === 'string') {
+        return body;
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    if (body instanceof FormData) {
+        const entries = [];
+        body.forEach((value, key) => {
+            entries.push(`${key}=${typeof value === 'string' ? value : value.name}`);
+        });
+        return entries.join('&');
+    }
+    return '[stream]';
+}
+function cleanupExpired() {
+    const cutoff = Date.now() - IDEMPOTENCY_TTL_MS;
+    for (const [key, snapshot] of idempotencyCache.entries()) {
+        if (snapshot.storedAt < cutoff) {
+            idempotencyCache.delete(key);
+        }
+    }
+}
+function buildFingerprint(url, method, init) {
+    const headers = new Headers(init?.headers);
+    const headerPairs = [];
+    headers.forEach((value, key) => {
+        headerPairs.push(`${key.toLowerCase()}=${value}`);
+    });
+    headerPairs.sort();
+    return createHash('sha256')
+        .update(JSON.stringify({
+        url,
+        method: method.toUpperCase(),
+        headers: headerPairs,
+        body: normalizeBody(init?.body),
+    }))
+        .digest('hex');
+}
+function resolveIdempotencyKey(init, options) {
+    const headers = new Headers(init?.headers);
+    return (options?.idempotencyKey ??
+        headers.get('idempotency-key') ??
+        headers.get('x-idempotency-key') ??
+        undefined);
+}
+export function inspectIdempotency(url, method, init, options) {
+    cleanupExpired();
+    const upperMethod = method.toUpperCase();
+    if (upperMethod === 'GET' || upperMethod === 'HEAD') {
+        return { allowed: true };
+    }
+    const idempotencyKey = resolveIdempotencyKey(init, options);
+    if (!idempotencyKey) {
+        return {
+            allowed: false,
+            code: 'missing-key',
+            reason: 'Automatic payment for non-GET requests requires an idempotency key.',
+        };
+    }
+    const fingerprint = buildFingerprint(url, upperMethod, init);
+    const existing = idempotencyCache.get(idempotencyKey);
+    if (!existing) {
+        idempotencyCache.set(idempotencyKey, {
+            fingerprint,
+            storedAt: Date.now(),
+            inflight: true,
+        });
+        return {
+            allowed: true,
+            idempotencyKey,
+            fingerprint,
+        };
+    }
+    if (existing.fingerprint !== fingerprint) {
+        return {
+            allowed: false,
+            code: 'mismatch',
+            reason: 'This idempotency key was already used for a different request payload.',
+        };
+    }
+    if (existing.inflight || !existing.response) {
+        return {
+            allowed: false,
+            code: 'inflight',
+            reason: 'An idempotent request with this key is already in progress.',
+        };
+    }
+    return {
+        allowed: true,
+        idempotencyKey,
+        fingerprint,
+        replay: true,
+        response: existing.response,
+    };
+}
+export async function storeIdempotentResponse(idempotencyKey, fingerprint, response, metadata) {
+    const body = await response.clone().text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    idempotencyCache.set(idempotencyKey, {
+        fingerprint,
+        storedAt: Date.now(),
+        inflight: false,
+        response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            body,
+            metadata,
+        },
+    });
+}
+export function clearIdempotentReservation(idempotencyKey, fingerprint) {
+    const existing = idempotencyCache.get(idempotencyKey);
+    if (existing && existing.fingerprint === fingerprint && existing.inflight) {
+        idempotencyCache.delete(idempotencyKey);
+    }
+}
+export function buildIdempotentReplay(snapshot) {
+    if (!snapshot) {
+        return null;
+    }
+    const headers = new Headers(snapshot.headers);
+    headers.set('x-xmpp-idempotency-replay', 'true');
+    return {
+        response: new Response(snapshot.body, {
+            status: snapshot.status,
+            statusText: snapshot.statusText,
+            headers,
+        }),
+        metadata: {
+            ...snapshot.metadata,
+            idempotentReplay: true,
+        },
+    };
+}
+export function resetIdempotencyCache() {
+    idempotencyCache.clear();
+}

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

@@ -0,0 +1,10 @@
+import type { XmppAgentProfile, XmppFetchMetadata, XmppFetchOptions } from '@xmpp/types';
+import { getXmppOperatorState, listLocalSessions } from './state.js';
+import { listXmppAgentProfiles } from './agents.js';
+export declare function getXmppMetadata(resp: Response): XmppFetchMetadata | undefined;
+export { getXmppOperatorState, listLocalSessions, listXmppAgentProfiles };
+export declare function resetXmppRuntimeState(): void;
+export { resetXmppRuntimeState as resetXmppOperatorState };
+export declare function getEffectiveXmppAgentProfile(agentId?: string): Promise<XmppAgentProfile>;
+export declare function listEffectiveXmppAgentProfiles(): Promise<XmppAgentProfile[]>;
+export declare function xmppFetch(input: RequestInfo | URL, init?: RequestInit, options?: XmppFetchOptions): Promise<Response>;