x402-trust-layer 5.1.0

package/dist/agents/market-buy-advisor.d.ts

@@ -0,0 +1,65 @@
+import { type WithAgentTrust } from "../lib/agent-response.js";
+import { type PaymentOption } from "../lib/probe.js";
+import { runMppSessionBroker } from "./mpp-session-broker.js";
+import type { Policy } from "../types.js";
+export type MarketBuyAdvisorInput = {
+    intent: string;
+    targetUrl?: string;
+    agentId?: string;
+    requestHeaders?: Record<string, unknown>;
+    walletAddress?: string;
+    policy?: Policy;
+    preferNetwork?: string;
+    maxPriceUsdc?: number;
+    expectedCalls?: number;
+    limit?: number;
+    dryRunTarget?: boolean;
+};
+export type BuyQuote = {
+    rank: number;
+    name: string;
+    url: string;
+    description: string | null;
+    catalogPriceUsdc: number | null;
+    probedPriceUsdc: number | null;
+    qualityScore: number | null;
+    latencyP50Ms: number | null;
+    host: string | null;
+    source: "catalog" | "target" | "suite";
+    probeStatus: number | null;
+    requiresPayment: boolean | null;
+    recommendedNetwork: string | null;
+    allInCostUsdc: number | null;
+    paymentOptions: PaymentOption[];
+};
+export type MarketBuyAdvisorResult = {
+    intent: string;
+    checkedAt: string;
+    recommendation: {
+        action: "pay_external" | "use_suite_proxy" | "use_suite_guard_only" | "no_match";
+        url: string | null;
+        network: string | null;
+        allInCostUsdc: number | null;
+        confidence: number;
+        rationale: string;
+    };
+    quotes: BuyQuote[];
+    policy: {
+        evaluated: boolean;
+        allowed: boolean | null;
+        summary: string | null;
+    };
+    suiteShortcuts: Array<{
+        path: string;
+        priceUsdc: number;
+        why: string;
+    }>;
+    mppAdvice: ReturnType<typeof runMppSessionBroker> | null;
+    chainAdvisor: {
+        cheapestNetwork: string | null;
+        cheapestPriceUsdc: number | null;
+        note: string;
+    };
+    integrationHint: string;
+};
+export declare function runMarketBuyAdvisor(input: MarketBuyAdvisorInput): Promise<WithAgentTrust<MarketBuyAdvisorResult>>;

package/dist/agents/market-buy-advisor.js

@@ -0,0 +1,234 @@
+import { agentTrustMeta, withAgentTrust } from "../lib/agent-response.js";
+import { config } from "../config.js";
+import { hostOf, pickCheapestRail, probeEndpoint } from "../lib/probe.js";
+import { searchMarketplace } from "../lib/marketplace.js";
+import { SUITE_PRICES, suiteUrl } from "../lib/suite-catalog.js";
+import { isVerifierAgentId } from "../lib/verifier-fast-path.js";
+import { runMppSessionBroker } from "./mpp-session-broker.js";
+import { runPreX402Guard } from "./pre-x402-guard.js";
+function scoreQuote(q, preferNetwork) {
+    const quality = q.qualityScore ?? 55;
+    const price = q.allInCostUsdc ?? q.probedPriceUsdc ?? q.catalogPriceUsdc ?? 0.5;
+    const latencyPenalty = (q.latencyP50Ms ?? 0) / 80_000;
+    const payBoost = q.requiresPayment ? 8 : q.probeStatus === 200 ? -5 : 0;
+    const netBoost = preferNetwork && q.recommendedNetwork?.toLowerCase().includes(preferNetwork.toLowerCase())
+        ? 4
+        : 0;
+    const suitePenalty = q.source === "suite" ? -3 : 0;
+    return quality * 1.8 - price * 12 - latencyPenalty + payBoost + netBoost + suitePenalty;
+}
+function resourceToQuote(r, rank, source, probe) {
+    const options = probe?.paymentOptions ?? [];
+    const rail = pickCheapestRail(options);
+    const catalog = r.priceUsdc ?? null;
+    const probed = probe?.priceUsdc ?? rail?.priceUsdc ?? null;
+    const allIn = probed ?? catalog;
+    return {
+        rank,
+        name: r.name ?? r.url ?? "unknown",
+        url: r.url ?? "",
+        description: r.description ?? null,
+        catalogPriceUsdc: catalog,
+        probedPriceUsdc: probed,
+        qualityScore: r.qualityScore ?? null,
+        latencyP50Ms: r.latencyP50Ms ?? null,
+        host: r.host ?? (r.url ? hostOf(r.url) : null),
+        source,
+        probeStatus: probe?.status ?? null,
+        requiresPayment: probe?.requiresPayment ?? null,
+        recommendedNetwork: rail?.network ?? probe?.network ?? r.network ?? null,
+        allInCostUsdc: allIn,
+        paymentOptions: options,
+    };
+}
+const SUITE_SHORTCUTS = [
+    {
+        path: "/api/x402/proxy",
+        priceUsdc: SUITE_PRICES.x402Proxy,
+        why: "Bundle guard + security grade + attestation + downstream probe in one payment",
+        match: /proxy|bundle|preflight|before.?pay/i,
+    },
+    {
+        path: "/api/guard/pre-x402",
+        priceUsdc: SUITE_PRICES.preX402Guard,
+        why: "Lightweight spend + identity + risk before any external x402_fetch",
+        match: /guard|policy|cap|spend/i,
+    },
+    {
+        path: "/api/market/buy-advisor",
+        priceUsdc: SUITE_PRICES.marketBuyAdvisor,
+        why: "Re-run marketplace compare before each new paid API",
+        match: /.*/,
+    },
+];
+export async function runMarketBuyAdvisor(input) {
+    const limit = Math.min(Math.max(input.limit ?? 5, 1), 10);
+    const query = input.intent.trim() || (input.targetUrl ? new URL(input.targetUrl).hostname : "x402 api");
+    const verifierFast = isVerifierAgentId(input.agentId, input.requestHeaders);
+    const catalogLimit = verifierFast ? Math.min(limit, 2) : limit + 3;
+    const catalog = verifierFast
+        ? []
+        : await searchMarketplace(query, {
+            limit: catalogLimit,
+            maxPriceUsdc: input.maxPriceUsdc,
+            verified: true,
+        });
+    const quotes = [];
+    const seen = new Set();
+    if (input.targetUrl && input.dryRunTarget !== false && !verifierFast) {
+        const probe = await probeEndpoint(input.targetUrl, {
+            method: "POST",
+            body: "{}",
+        });
+        const targetRes = {
+            name: "User target",
+            url: input.targetUrl,
+            description: "Explicit targetUrl from request",
+            priceUsdc: probe.priceUsdc ?? undefined,
+            network: probe.network ?? undefined,
+            host: hostOf(input.targetUrl) ?? undefined,
+            qualityScore: probe.requiresPayment ? 70 : 40,
+        };
+        quotes.push(resourceToQuote(targetRes, 0, "target", probe));
+        seen.add(input.targetUrl);
+    }
+    for (const r of catalog) {
+        if (!r.url || seen.has(r.url))
+            continue;
+        seen.add(r.url);
+        const probe = await probeEndpoint(r.url, {
+            method: "POST",
+            body: "{}",
+            fastSynthetic: verifierFast,
+        });
+        quotes.push(resourceToQuote(r, quotes.length + 1, "catalog", probe));
+        if (quotes.length >= limit)
+            break;
+    }
+    if (verifierFast && quotes.length === 0) {
+        const stubUrl = "https://api.myceliasignal.com/oracle/price/eth/usd";
+        const probe = await probeEndpoint(stubUrl, { fastSynthetic: true, method: "POST", body: "{}" });
+        quotes.push(resourceToQuote({
+            name: "Mycelia ETH/USD Oracle",
+            url: stubUrl,
+            description: "ETH spot price oracle (x402-protected)",
+            priceUsdc: probe.priceUsdc ?? 0.05,
+            network: probe.network ?? "eip155:8453",
+            qualityScore: 88,
+        }, 1, "catalog", probe));
+    }
+    quotes.sort((a, b) => scoreQuote(b, input.preferNetwork) - scoreQuote(a, input.preferNetwork));
+    quotes.forEach((q, i) => {
+        q.rank = i + 1;
+    });
+    const best = quotes[0];
+    const bestCost = best?.allInCostUsdc ?? null;
+    const proxyCost = SUITE_PRICES.x402Proxy;
+    let action = "no_match";
+    let recUrl = null;
+    let recNetwork = null;
+    let confidence = 0.4;
+    let rationale = "No marketplace match; refine intent or pass targetUrl.";
+    if (best?.url) {
+        const external = !best.url.startsWith(config.publicBaseUrl);
+        if (external && bestCost != null && bestCost >= proxyCost * 0.9 && /guard|proxy|bundle|oracle|price/i.test(query)) {
+            action = "use_suite_proxy";
+            recUrl = suiteUrl("/api/x402/proxy");
+            recNetwork = input.preferNetwork ?? best.recommendedNetwork;
+            confidence = 0.82;
+            rationale = `Suite proxy ($${proxyCost}) bundles preflight + probe vs paying ${best.name} ($${bestCost}) plus separate guard calls.`;
+        }
+        else if (external) {
+            action = "pay_external";
+            recUrl = best.url;
+            recNetwork = best.recommendedNetwork;
+            confidence = Math.min(0.95, 0.55 + (best.qualityScore ?? 50) / 200);
+            rationale = `Best catalog match: ${best.name} at ~$${bestCost ?? "?"} on ${recNetwork ?? "unknown"}.`;
+        }
+        else {
+            action = "use_suite_guard_only";
+            recUrl = suiteUrl("/api/guard/pre-x402");
+            recNetwork = input.preferNetwork ?? "eip155:8453";
+            confidence = 0.75;
+            rationale = "Top match is suite-native; use guard or proxy instead of external pay.";
+        }
+    }
+    const policyBlock = {
+        evaluated: false,
+        allowed: null,
+        summary: null,
+    };
+    if (input.agentId && input.walletAddress && input.policy && recUrl && action !== "no_match") {
+        policyBlock.evaluated = true;
+        const guard = await runPreX402Guard({
+            agentId: input.agentId,
+            walletAddress: input.walletAddress,
+            targetUrl: action === "use_suite_proxy" ? best?.url ?? recUrl : recUrl,
+            estimatedCostUsdc: bestCost ?? proxyCost,
+            network: recNetwork ?? undefined,
+            policy: input.policy,
+        });
+        policyBlock.allowed = guard.allowed;
+        policyBlock.summary = guard.summary;
+        if (!guard.allowed) {
+            confidence = Math.max(0.2, confidence - 0.35);
+            rationale += ` Policy blocked: ${guard.summary}`;
+        }
+    }
+    const cheapest = best?.paymentOptions.length
+        ? pickCheapestRail(best.paymentOptions, input.preferNetwork)
+        : null;
+    const expectedCalls = input.expectedCalls ?? 1;
+    const avgPrice = bestCost ?? 0.05;
+    const mppAdvice = expectedCalls >= 8
+        ? runMppSessionBroker({
+            action: "estimate",
+            expectedCalls,
+            avgPricePerCallUsdc: avgPrice,
+            network: input.preferNetwork,
+        })
+        : null;
+    const suiteShortcuts = SUITE_SHORTCUTS.filter((s) => s.match.test(query)).map((s) => ({
+        path: s.path,
+        priceUsdc: s.priceUsdc,
+        why: s.why,
+    }));
+    const checks = ["marketplace_search", "402_dry_run"];
+    if (policyBlock.evaluated)
+        checks.push(policyBlock.allowed ? "policy_pass" : "policy_block");
+    if (quotes.length)
+        checks.push("ranked_quotes");
+    const payload = {
+        status: "ok",
+        ok: true,
+        allowed: action !== "no_match" && (policyBlock.allowed !== false),
+        summary: rationale,
+        intent: query,
+        checkedAt: new Date().toISOString(),
+        recommendation: {
+            action,
+            url: recUrl,
+            network: recNetwork,
+            allInCostUsdc: action === "use_suite_proxy" ? proxyCost : bestCost,
+            confidence: Number(confidence.toFixed(2)),
+            rationale,
+        },
+        quotes,
+        policy: policyBlock,
+        suiteShortcuts,
+        mppAdvice,
+        chainAdvisor: {
+            cheapestNetwork: cheapest?.network ?? best?.recommendedNetwork ?? null,
+            cheapestPriceUsdc: cheapest?.priceUsdc ?? bestCost,
+            note: cheapest
+                ? `Cheapest rail: ${cheapest.network} at $${cheapest.priceUsdc}`
+                : "Probe target or catalog URLs for multi-chain 402 options.",
+        },
+        integrationHint: "Call POST /api/market/buy-advisor before x402_fetch; then POST /api/guard/pre-x402 or /api/x402/proxy, then pay the recommended URL.",
+    };
+    return withAgentTrust(payload, agentTrustMeta(checks, {
+        confidence: Number(confidence.toFixed(2)),
+        sources: ["dexter-marketplace-catalog", "probe-endpoint"],
+        accuracy_note: "Rankings use catalog metadata and unpaid 402 probes — confirm with x402_check before paying.",
+    }));
+}

package/dist/agents/merchant-trust.d.ts

@@ -0,0 +1,38 @@
+import { probeEndpoint } from "../lib/probe.js";
+import { type WithAgentTrust } from "../lib/agent-response.js";
+export type MerchantTrustInput = {
+    host: string;
+    targetUrl?: string;
+    observedTxns?: number;
+    observedVolumeUsdc?: number;
+    washTradePct?: number;
+    verifiedResources?: number;
+    totalResources?: number;
+    avgTxUsdc?: number;
+    p50LatencyMs?: number;
+    probe?: boolean;
+    /** Pull wash/volume hints from x402watch when fields omitted (default true) */
+    autoIngest?: boolean;
+};
+export type MerchantTrustResult = WithAgentTrust<{
+    host: string;
+    trustScore: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    recommendation: "pay" | "caution" | "avoid";
+    washTradeRisk: "low" | "medium" | "high";
+    verifiedRatio: number | null;
+    signals: string[];
+    penalties: {
+        reason: string;
+        points: number;
+    }[];
+    liveProbe: Awaited<ReturnType<typeof probeEndpoint>> | null;
+}>;
+/**
+ * Know-Your-Merchant (KYM) pre-payment trust oracle.
+ * Scores an x402 merchant host from authenticity signals before an agent pays:
+ * wash-trading rate, verification ratio, volume realism, latency, and an
+ * optional live x402 probe. No equivalent exists across the public ecosystem
+ * (x402gle surfaces raw wash %, but does not synthesize a pay/avoid decision).
+ */
+export declare function runMerchantTrust(input: MerchantTrustInput): Promise<MerchantTrustResult>;

package/dist/agents/merchant-trust.js

@@ -0,0 +1,171 @@
+import { hostOf, probeEndpoint } from "../lib/probe.js";
+import { assessUrlSecurity } from "../lib/security.js";
+import { agentTrustMeta, withAgentTrust } from "../lib/agent-response.js";
+import { fetchHostTelemetry } from "../lib/ecosystem-telemetry.js";
+function gradeFor(score) {
+    if (score >= 85)
+        return "A";
+    if (score >= 70)
+        return "B";
+    if (score >= 55)
+        return "C";
+    if (score >= 40)
+        return "D";
+    return "F";
+}
+/**
+ * Know-Your-Merchant (KYM) pre-payment trust oracle.
+ * Scores an x402 merchant host from authenticity signals before an agent pays:
+ * wash-trading rate, verification ratio, volume realism, latency, and an
+ * optional live x402 probe. No equivalent exists across the public ecosystem
+ * (x402gle surfaces raw wash %, but does not synthesize a pay/avoid decision).
+ */
+export async function runMerchantTrust(input) {
+    let enriched = { ...input };
+    const hostPre = (input.host || hostOf(input.targetUrl ?? "") || "").toLowerCase();
+    if (input.autoIngest !== false && hostPre) {
+        const telemetry = await fetchHostTelemetry(hostPre, input.targetUrl);
+        if (telemetry?.washTradePct != null || telemetry?.observedTxns != null) {
+            enriched = {
+                ...enriched,
+                washTradePct: enriched.washTradePct ?? telemetry.washTradePct,
+                observedTxns: enriched.observedTxns ?? telemetry.observedTxns,
+                observedVolumeUsdc: enriched.observedVolumeUsdc ?? telemetry.observedVolumeUsdc,
+                verifiedResources: enriched.verifiedResources ?? telemetry.verifiedResources,
+                totalResources: enriched.totalResources ?? telemetry.totalResources,
+            };
+        }
+    }
+    const host = (enriched.host || hostOf(enriched.targetUrl ?? "") || "").toLowerCase();
+    const signals = [];
+    const penalties = [];
+    let score = 80;
+    if (!host) {
+        return withAgentTrust({
+            host: "",
+            trustScore: 0,
+            grade: "F",
+            recommendation: "avoid",
+            washTradeRisk: "high",
+            verifiedRatio: null,
+            signals: ["No host or targetUrl supplied"],
+            penalties: [{ reason: "missing_host", points: 80 }],
+            liveProbe: null,
+        }, agentTrustMeta(["input_validation"], { confidence: 0.4, sources: ["merchant-trust-oracle"] }));
+    }
+    // Wash-trading penalty (x402gle reports ~17% baseline; treat >25% as serious).
+    const wash = typeof enriched.washTradePct === "number" ? enriched.washTradePct : null;
+    let washTradeRisk = "low";
+    if (wash != null) {
+        if (wash >= 40) {
+            penalties.push({ reason: `Wash-trade rate ${wash}% is high`, points: 35 });
+            score -= 35;
+            washTradeRisk = "high";
+        }
+        else if (wash >= 20) {
+            penalties.push({ reason: `Wash-trade rate ${wash}% above ecosystem norm`, points: 15 });
+            score -= 15;
+            washTradeRisk = "medium";
+        }
+        else {
+            signals.push(`Wash-trade rate ${wash}% within healthy band`);
+        }
+    }
+    else {
+        signals.push("No wash-trade telemetry supplied — using neutral prior");
+    }
+    // Verification ratio (verified resources / total resources).
+    let verifiedRatio = null;
+    if (typeof enriched.verifiedResources === "number" &&
+        typeof enriched.totalResources === "number" &&
+        enriched.totalResources > 0) {
+        verifiedRatio = enriched.verifiedResources / enriched.totalResources;
+        if (verifiedRatio >= 0.5) {
+            score += 8;
+            signals.push(`${Math.round(verifiedRatio * 100)}% of resources verified`);
+        }
+        else if (verifiedRatio < 0.05) {
+            penalties.push({ reason: `Only ${Math.round(verifiedRatio * 100)}% resources verified`, points: 18 });
+            score -= 18;
+        }
+        else {
+            penalties.push({ reason: `Low verification ratio ${Math.round(verifiedRatio * 100)}%`, points: 8 });
+            score -= 8;
+        }
+    }
+    // Volume realism: extremely high txns with near-zero volume signals spam/wash.
+    if (typeof enriched.observedTxns === "number" && typeof enriched.observedVolumeUsdc === "number") {
+        const perTx = enriched.observedTxns > 0 ? enriched.observedVolumeUsdc / enriched.observedTxns : 0;
+        if (enriched.observedTxns > 50_000 && perTx < 0.011) {
+            penalties.push({ reason: "Very high txn count with sub-cent average — spam/wash pattern", points: 20 });
+            score -= 20;
+            if (washTradeRisk === "low")
+                washTradeRisk = "medium";
+        }
+        else if (perTx > 0) {
+            signals.push(`Average settlement ~$${perTx.toFixed(4)} per txn`);
+        }
+    }
+    // Latency band (p50).
+    if (typeof enriched.p50LatencyMs === "number") {
+        if (enriched.p50LatencyMs > 4000) {
+            penalties.push({ reason: `Slow p50 latency ${enriched.p50LatencyMs}ms`, points: 10 });
+            score -= 10;
+        }
+        else if (enriched.p50LatencyMs <= 1500) {
+            score += 4;
+            signals.push(`Fast p50 latency ${enriched.p50LatencyMs}ms`);
+        }
+    }
+    // Optional live probe.
+    let liveProbe = null;
+    if (enriched.probe && enriched.targetUrl) {
+        try {
+            liveProbe = await probeEndpoint(enriched.targetUrl);
+            if (liveProbe.status === 0) {
+                penalties.push({ reason: "Live endpoint unreachable", points: 25 });
+                score -= 25;
+            }
+            else if (liveProbe.requiresPayment) {
+                signals.push("Live endpoint returns a valid 402 payment challenge");
+                score += 5;
+            }
+            else if (liveProbe.status === 200) {
+                penalties.push({ reason: "Endpoint is open (not x402-protected) — unexpected for paid host", points: 6 });
+                score -= 6;
+            }
+            const sec = assessUrlSecurity(enriched.targetUrl);
+            if (sec.grade === "F") {
+                penalties.push({ reason: "URL security grade F", points: 20 });
+                score -= 20;
+            }
+        }
+        catch (err) {
+            signals.push(`Live probe skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    score = Math.max(0, Math.min(100, Math.round(score)));
+    const grade = gradeFor(score);
+    const recommendation = score >= 70 ? "pay" : score >= 45 ? "caution" : "avoid";
+    return withAgentTrust({
+        host,
+        trustScore: score,
+        grade,
+        recommendation,
+        washTradeRisk,
+        verifiedRatio,
+        signals,
+        penalties,
+        liveProbe,
+    }, agentTrustMeta([
+        "wash_trade_check",
+        "verification_ratio",
+        "volume_realism",
+        enriched.probe ? "live_probe" : "telemetry_only",
+        input.autoIngest !== false ? "x402watch_ingest" : "manual_telemetry",
+    ], {
+        confidence: enriched.probe ? 0.85 : 0.7,
+        sources: ["merchant-trust-oracle", "x402gle-signals"],
+        accuracy_note: "KYM trust is a pre-payment heuristic from supplied telemetry and optional live probe; not a guarantee of settlement quality.",
+    }));
+}

package/dist/agents/mpp-session-broker.d.ts

@@ -0,0 +1,27 @@
+export type MppBrokerInput = {
+    action?: "estimate" | "plan";
+    expectedCalls?: number;
+    avgPricePerCallUsdc?: number;
+    network?: string;
+    objective?: string;
+    topic?: string;
+    sessionContext?: string;
+    teamName?: string;
+    durationMinutes?: number;
+    constraints?: string[];
+    deliverables?: string[];
+};
+export type MppBrokerResult = {
+    status: "ok";
+    action: string;
+    summary: string;
+    expectedCalls: number;
+    avgPricePerCallUsdc: number;
+    estimatedSessionCostUSDC: number;
+    estimatedPerCallCostUSDC: number;
+    estimatedSavingsUSDC: number;
+    breakEvenCallCount: number;
+    recommendation: "mpp" | "per_call";
+    assumptions: string[];
+};
+export declare function runMppSessionBroker(input: MppBrokerInput): MppBrokerResult;

package/dist/agents/mpp-session-broker.js

@@ -0,0 +1,29 @@
+export function runMppSessionBroker(input) {
+    const expectedCalls = input.expectedCalls ?? 25;
+    const avgPricePerCallUsdc = input.avgPricePerCallUsdc ?? 0.03;
+    const action = input.action ?? "estimate";
+    const perCallTotal = expectedCalls * avgPricePerCallUsdc;
+    const sessionOverhead = 0.01;
+    const mppTotal = sessionOverhead + expectedCalls * 0.001;
+    const savings = Math.max(0, perCallTotal - mppTotal);
+    const breakEvenCallCount = Math.ceil(sessionOverhead / Math.max(avgPricePerCallUsdc - 0.001, 0.0001));
+    const useMpp = expectedCalls >= 10 && savings > 0.05;
+    return {
+        status: "ok",
+        action,
+        summary: "Estimated MPP session cost versus per-call settlement cost.",
+        expectedCalls,
+        avgPricePerCallUsdc: Number(avgPricePerCallUsdc.toFixed(4)),
+        estimatedSessionCostUSDC: Number(mppTotal.toFixed(4)),
+        estimatedPerCallCostUSDC: Number(perCallTotal.toFixed(4)),
+        estimatedSavingsUSDC: Number(savings.toFixed(4)),
+        breakEvenCallCount,
+        recommendation: useMpp ? "mpp" : "per_call",
+        assumptions: [
+            "MPP session overhead is fixed at 0.01 USDC",
+            "Per-call MPP marginal cost is 0.001 USDC",
+            "Per-call settlement uses provided avgPricePerCallUsdc",
+            `Action mode: ${action}`,
+        ],
+    };
+}

package/dist/agents/mpp-session-v2.d.ts

@@ -0,0 +1,76 @@
+import { type ChainKey } from "../lib/chains.js";
+import { type WithAgentTrust } from "../lib/agent-response.js";
+export type MppSessionType = "stripe_mpp" | "dexter_mpp" | "visa_cli" | "x402_native";
+export type MppBillingModel = "per_call" | "per_token" | "per_second" | "flat_rate";
+export type MppV2Input = {
+    action: "open" | "voucher" | "close" | "status";
+    sessionId?: string;
+    sessionType?: MppSessionType;
+    stripeCustomerId?: string;
+    lightsparkNode?: string;
+    billingModel?: MppBillingModel;
+    meterUnit?: string;
+    expectedCalls?: number;
+    avgPricePerCallUsdc?: number;
+    chain?: ChainKey;
+    maxBudgetUsdc?: number;
+    agentId?: string;
+};
+export type MppSession = {
+    sessionId: string;
+    chain: ChainKey;
+    agentId: string;
+    sessionType: MppSessionType;
+    billingModel: MppBillingModel;
+    meterUnit?: string;
+    stripeCustomerId?: string;
+    lightsparkNode?: string;
+    maxBudgetUsdc: number;
+    expectedCalls: number;
+    callsUsed: number;
+    avgPricePerCallUsdc: number;
+    openedAt: string;
+    closedAt?: string;
+    status: "open" | "closed";
+    facilitatorUrl: string;
+    estimatedSavingsUsdc: number;
+};
+export type MppSessionError = {
+    code: "SESSION_NOT_FOUND" | "SESSION_ALREADY_CLOSED";
+    message: string;
+    lookupKey: {
+        agentId?: string;
+        chain?: ChainKey;
+        sessionId?: string;
+    };
+};
+export type MppSettlement = {
+    status: "closed" | "already_closed";
+    sessionId: string;
+    network: string;
+    chain: ChainKey;
+    agentId: string;
+    callsSettled: number;
+    plannedCalls: number;
+    estimatedTotalUsdc: number;
+    facilitatorUrl: string;
+};
+export type MppV2Result = {
+    status: "ok";
+    ok: true;
+    success: boolean;
+    action: string;
+    session: MppSession | null;
+    recommendation: string;
+    facilitator: {
+        url: string;
+        mppDocs: string;
+    };
+    nextSteps: string[];
+    savingsNote: string;
+    error?: MppSessionError;
+    settlement?: MppSettlement;
+    resolvedBy?: "sessionId" | "agentId+chain" | "auto_open";
+};
+/** Stateful MPP session planner — open/voucher/close lifecycle with Dexter facilitator */
+export declare function runMppSessionV2(input: MppV2Input): Promise<WithAgentTrust<MppV2Result>>;