@intentfi/agent-sdk 0.1.0 → 0.1.1

package/dist/client.js

@@ -1,15 +1,96 @@
 const MCP_PROTOCOL_VERSION = "2025-11-25";
+const X402_VERSION = 2;
+const PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+const PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
+const PAYMENT_RESPONSE_HEADER = "PAYMENT-RESPONSE";
+const PAYMENT_IDENTIFIER_EXTENSION = "payment-identifier";
+export class DefaultX402PaymentManager {
+    policy;
+    approve;
+    schemes = new Map();
+    constructor(options = {}) {
+        this.policy = options.policy ?? {};
+        this.approve = options.approve;
+        for (const [scheme, handler] of Object.entries(options.schemes ?? {})) {
+            this.schemes.set(scheme.toLowerCase(), handler);
+        }
+    }
+    registerScheme(scheme, handler) {
+        this.schemes.set(scheme.trim().toLowerCase(), handler);
+        return this;
+    }
+    async buildPaymentPayload(args) {
+        const requirement = this.selectRequirement(args.paymentRequired);
+        const context = {
+            transport: args.transport,
+            operation: args.operation,
+            ...(args.idempotencyKey ? { idempotencyKey: args.idempotencyKey } : {}),
+            paymentRequired: args.paymentRequired,
+            requirement,
+        };
+        if (this.approve) {
+            const approved = await this.approve({ context });
+            if (!approved) {
+                throw new Error("x402 payment was not approved.");
+            }
+        }
+        const handler = this.schemes.get(requirement.scheme.trim().toLowerCase());
+        if (!handler) {
+            throw new Error(`No x402 scheme handler is registered for '${requirement.scheme}'.`);
+        }
+        const payload = await handler({ context });
+        const extensions = echoRequiredExtensions(args.paymentRequired.extensions, args.idempotencyKey);
+        return {
+            x402Version: X402_VERSION,
+            resource: args.paymentRequired.resource,
+            accepted: requirement,
+            payload,
+            ...(extensions ? { extensions } : {}),
+        };
+    }
+    async onSettlement(args) {
+        void args;
+    }
+    selectRequirement(paymentRequired) {
+        for (const requirement of paymentRequired.accepts) {
+            if (!this.passesPolicy(requirement)) {
+                continue;
+            }
+            if (!this.schemes.has(requirement.scheme.trim().toLowerCase())) {
+                continue;
+            }
+            return requirement;
+        }
+        throw new Error("No x402 payment requirement matched the configured policy or available schemes.");
+    }
+    passesPolicy(requirement) {
+        if (this.policy.allowedNetworks
+            && this.policy.allowedNetworks.length > 0
+            && !this.policy.allowedNetworks.includes(requirement.network)) {
+            return false;
+        }
+        if (this.policy.maxAmountAtomic !== undefined) {
+            const amount = parseAtomicAmount(requirement.amount);
+            if (amount > this.policy.maxAmountAtomic) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
 export class IntentFiClient {
     baseUrl;
     apiKey;
     transport;
     fetchImpl;
+    paymentManager;
     mcpSessionId;
     constructor(options = {}) {
         this.baseUrl = (options.baseUrl ?? process.env.INTENTFI_BASE_URL ?? "https://agentic.intentfi.io").replace(/\/+$/, "");
         this.apiKey = options.apiKey ?? process.env.INTENTFI_API_KEY;
         this.transport = resolveTransportMode(options.transport ?? process.env.INTENTFI_TRANSPORT);
         this.fetchImpl = options.fetchImpl ?? fetch;
+        this.paymentManager = options.paymentManager;
     }
     async requestSiweChallenge(args) {
         const response = await this.fetchJson("/agent/v1/auth/siwe/challenge", {
@@ -31,14 +112,14 @@ export class IntentFiClient {
         });
     }
     async createWorkflow(args) {
-        this.assertApiKey("createWorkflow");
+        this.assertCredential("createWorkflow", { allowX402: true });
         if (this.transport === "mcp") {
-            return await this.mcpToolCall("intentfi.create_workflow", args);
+            return await this.mcpToolCall("intentfi.create_workflow", args, { idempotencyKey: args.operationId });
         }
         return await this.createWorkflowRest(args);
     }
     async getWorkflow(args) {
-        this.assertApiKey("getWorkflow");
+        this.assertCredential("getWorkflow");
         if (this.transport === "mcp") {
             const result = await this.mcpToolCall("intentfi.get_workflow", args, { stream: (args.waitMs ?? 0) > 0 });
             const workflow = (result.workflow ??
@@ -54,9 +135,12 @@ export class IntentFiClient {
         return await this.getWorkflowRest(args);
     }
     async prepareActive(args) {
-        this.assertApiKey("prepareActive");
+        this.assertCredential("prepareActive", { allowX402: true });
         if (this.transport === "mcp") {
-            const result = await this.mcpToolCall("intentfi.prepare_active", args, { stream: (args.waitMs ?? 0) > 0 });
+            const result = await this.mcpToolCall("intentfi.prepare_active", args, {
+                stream: (args.waitMs ?? 0) > 0,
+                idempotencyKey: args.requestId,
+            });
             return {
                 result,
                 status: result.kind === "pending" ? 202 : 200,
@@ -64,8 +148,16 @@ export class IntentFiClient {
         }
         return await this.prepareActiveRest(args);
     }
+    async prepareOffchainActive(args) {
+        this.assertCredential("prepareOffchainActive");
+        if (this.transport === "mcp") {
+            const result = await this.mcpToolCall("intentfi.prepare_offchain_active", args);
+            return { result, status: 200 };
+        }
+        return await this.prepareOffchainActiveRest(args);
+    }
     async getActiveSubmissionContext(args) {
-        this.assertApiKey("getActiveSubmissionContext");
+        this.assertCredential("getActiveSubmissionContext");
         if (this.transport === "mcp") {
             return await this.mcpToolCall("intentfi.get_active_submission_context", args);
         }
@@ -73,8 +165,56 @@ export class IntentFiClient {
             headers: this.withApiKey(),
         });
     }
+    async submitOffchainActive(args) {
+        this.assertCredential("submitOffchainActive");
+        if (this.transport === "mcp") {
+            const result = await this.mcpToolCall("intentfi.submit_offchain_active", args, { stream: (args.waitMs ?? 0) > 0 });
+            const waitKind = result.wait?.kind;
+            return {
+                result,
+                status: waitKind === "timeout" ? 202 : 200,
+            };
+        }
+        return await this.submitOffchainActiveRest(args);
+    }
+    async reportOffchainResultActive(args) {
+        this.assertCredential("reportOffchainResultActive");
+        if (this.transport === "mcp") {
+            const result = await this.mcpToolCall("intentfi.report_offchain_result_active", args, { stream: (args.waitMs ?? 0) > 0 });
+            const waitKind = result.wait?.kind;
+            return {
+                result,
+                status: waitKind === "timeout" ? 202 : 200,
+            };
+        }
+        return await this.reportOffchainResultActiveRest(args);
+    }
+    async reportOffchainFailureActive(args) {
+        this.assertCredential("reportOffchainFailureActive");
+        if (this.transport === "mcp") {
+            const result = await this.mcpToolCall("intentfi.report_offchain_failure_active", args, { stream: (args.waitMs ?? 0) > 0 });
+            const waitKind = result.wait?.kind;
+            return {
+                result,
+                status: waitKind === "timeout" ? 202 : 200,
+            };
+        }
+        return await this.reportOffchainFailureActiveRest(args);
+    }
+    async cancelOffchainActive(args) {
+        this.assertCredential("cancelOffchainActive");
+        if (this.transport === "mcp") {
+            const result = await this.mcpToolCall("intentfi.cancel_offchain_active", args, { stream: (args.waitMs ?? 0) > 0 });
+            const waitKind = result.wait?.kind;
+            return {
+                result,
+                status: waitKind === "timeout" ? 202 : 200,
+            };
+        }
+        return await this.cancelOffchainActiveRest(args);
+    }
     async submitActiveTransactions(args) {
-        this.assertApiKey("submitActiveTransactions");
+        this.assertCredential("submitActiveTransactions");
         if (this.transport === "mcp") {
             const result = await this.mcpToolCall("intentfi.submit_active_transactions", args, { stream: (args.waitMs ?? 0) > 0 });
             const waitKind = result.wait?.kind;
@@ -86,7 +226,7 @@ export class IntentFiClient {
         return await this.submitActiveTransactionsRest(args);
     }
     async submitActiveSendCalls(args) {
-        this.assertApiKey("submitActiveSendCalls");
+        this.assertCredential("submitActiveSendCalls");
         if (this.transport === "mcp") {
             const result = await this.mcpToolCall("intentfi.submit_active_sendcalls", args, { stream: (args.waitMs ?? 0) > 0 });
             const waitKind = result.wait?.kind;
@@ -98,13 +238,17 @@ export class IntentFiClient {
         return await this.submitActiveSendCallsRest(args);
     }
     async createWorkflowRest(args) {
-        return await this.fetchJson("/agent/v1/workflows", {
+        const response = await this.fetchPaidEnvelope("/agent/v1/workflows", {
             method: "POST",
             headers: this.withApiKey({
                 "content-type": "application/json",
             }),
             body: JSON.stringify(args),
+        }, {
+            operation: "createWorkflow",
+            idempotencyKey: args.operationId,
         });
+        return response.data;
     }
     async getWorkflowRest(args) {
         const query = args.waitMs !== undefined ? `?waitMs=${args.waitMs}` : "";
@@ -120,7 +264,21 @@ export class IntentFiClient {
         };
     }
     async prepareActiveRest(args) {
-        const response = await this.fetchEnvelope(`/agent/v1/workflows/${args.workflowId}/prepare`, {
+        const response = await this.fetchPaidEnvelope(`/agent/v1/workflows/${args.workflowId}/prepare`, {
+            method: "POST",
+            headers: this.withApiKey({ "content-type": "application/json" }),
+            body: JSON.stringify({
+                requestId: args.requestId,
+                ...(args.waitMs !== undefined ? { waitMs: args.waitMs } : {}),
+            }),
+        }, {
+            operation: "prepareActive",
+            idempotencyKey: args.requestId,
+        });
+        return { result: response.data, status: response.status };
+    }
+    async prepareOffchainActiveRest(args) {
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${args.workflowId}/prepare-offchain`, {
             method: "POST",
             headers: this.withApiKey({ "content-type": "application/json" }),
             body: JSON.stringify({
@@ -130,19 +288,57 @@ export class IntentFiClient {
         });
         return { result: response.data, status: response.status };
     }
+    async submitOffchainActiveRest(args) {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/submit-offchain`, {
+            method: "POST",
+            headers: this.withApiKey({ "content-type": "application/json" }),
+            body: JSON.stringify(payload),
+        });
+        return { result: response.data, status: response.status };
+    }
+    async reportOffchainResultActiveRest(args) {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/report-offchain-result`, {
+            method: "POST",
+            headers: this.withApiKey({ "content-type": "application/json" }),
+            body: JSON.stringify(payload),
+        });
+        return { result: response.data, status: response.status };
+    }
+    async reportOffchainFailureActiveRest(args) {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/report-offchain-failure`, {
+            method: "POST",
+            headers: this.withApiKey({ "content-type": "application/json" }),
+            body: JSON.stringify(payload),
+        });
+        return { result: response.data, status: response.status };
+    }
+    async cancelOffchainActiveRest(args) {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/cancel-offchain`, {
+            method: "POST",
+            headers: this.withApiKey({ "content-type": "application/json" }),
+            body: JSON.stringify(payload),
+        });
+        return { result: response.data, status: response.status };
+    }
     async submitActiveTransactionsRest(args) {
-        const response = await this.fetchEnvelope(`/agent/v1/workflows/${args.workflowId}/submit-transactions`, {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/submit-transactions`, {
             method: "POST",
             headers: this.withApiKey({ "content-type": "application/json" }),
-            body: JSON.stringify(args),
+            body: JSON.stringify(payload),
         });
         return { result: response.data, status: response.status };
     }
     async submitActiveSendCallsRest(args) {
-        const response = await this.fetchEnvelope(`/agent/v1/workflows/${args.workflowId}/submit-sendcalls`, {
+        const { workflowId, ...payload } = args;
+        const response = await this.fetchEnvelope(`/agent/v1/workflows/${workflowId}/submit-sendcalls`, {
             method: "POST",
             headers: this.withApiKey({ "content-type": "application/json" }),
-            body: JSON.stringify(args),
+            body: JSON.stringify(payload),
         });
         return { result: response.data, status: response.status };
     }
@@ -185,10 +381,19 @@ export class IntentFiClient {
             throw new Error(`MCP initialized notification failed (${notification.status})`);
         }
     }
-    async mcpToolCall(name, args, options, attempt = 0) {
+    async mcpToolCall(name, args, options, attempt = 0, paymentAttempt = 0) {
         if (!this.mcpSessionId) {
             await this.mcpInitialize();
         }
+        const params = {
+            name,
+            arguments: args,
+        };
+        if (options?.paymentPayload) {
+            params._meta = {
+                "x402/payment": options.paymentPayload,
+            };
+        }
         const response = await this.fetchImpl(`${this.baseUrl}/mcp`, {
             method: "POST",
             headers: {
@@ -202,52 +407,63 @@ export class IntentFiClient {
                 jsonrpc: "2.0",
                 id: Date.now(),
                 method: "tools/call",
-                params: {
-                    name,
-                    arguments: args,
-                },
+                params,
             }),
         });
         const returnedSessionId = response.headers.get("MCP-Session-Id");
         if (returnedSessionId) {
             this.mcpSessionId = returnedSessionId;
         }
+        let body;
         const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
         if (contentType.includes("text/event-stream")) {
-            const text = await response.text();
-            const messages = text
-                .split("\n\n")
-                .map((chunk) => chunk.trim())
-                .filter((chunk) => chunk.startsWith("data:"))
-                .map((chunk) => chunk.slice(5).trim())
-                .map((chunk) => JSON.parse(chunk));
-            const final = messages.reverse().find((entry) => entry.result !== undefined || entry.error !== undefined);
+            const parsed = await parseMcpSseResponse(response);
+            const final = parsed.finalMessage;
             if (!final) {
-                throw new Error("MCP stream response did not contain a final message");
-            }
-            if (final.error) {
-                if (final.error.data?.code === "MCP_SESSION_REQUIRED" && attempt === 0) {
-                    await this.mcpInitialize();
-                    return await this.mcpToolCall(name, args, options, attempt + 1);
+                if (parsed.parseErrorCount > 0) {
+                    throw new Error(`MCP stream response did not contain a final message (failed to parse ${parsed.parseErrorCount} JSON payload(s))`);
                 }
-                throw createClientError(final.error.message ?? "MCP tool call failed", final.error.data?.code, response.status);
+                throw new Error("MCP stream response did not contain a final message");
             }
-            return final.result;
-        }
-        const text = await response.text();
-        let body;
-        try {
-            body = JSON.parse(text);
+            body = final;
         }
-        catch {
-            throw new Error(`MCP tool call failed (${response.status})`);
+        else {
+            const text = await response.text();
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`MCP tool call failed (${response.status})`);
+            }
         }
         if (body.error?.data?.code === "MCP_SESSION_REQUIRED" && attempt === 0) {
             await this.mcpInitialize();
-            return await this.mcpToolCall(name, args, options, attempt + 1);
+            return await this.mcpToolCall(name, args, options, attempt + 1, paymentAttempt);
         }
         if (!response.ok || body.error) {
-            throw createClientError(body.error?.message ?? `MCP tool call failed (${response.status})`, body.error?.data?.code, response.status);
+            throw createClientError(body.error?.message ?? `MCP tool call failed (${response.status})`, body.error?.data?.code, response.status, toErrorDetails(body.error?.data?.details));
+        }
+        await this.handleSettlement({
+            transport: "mcp",
+            operation: name,
+            result: body.result,
+        });
+        const paymentRequired = parseMcpPaymentChallenge(body.result);
+        if (paymentRequired) {
+            const challengeError = parseMcpChallengeError(body.result);
+            if (paymentAttempt > 0) {
+                throw createClientError(paymentRequired.error ?? "x402 payment challenge persisted after retry.", challengeError?.code ?? "PAYMENT_REQUIRED", challengeError?.status ?? 402, challengeError?.details);
+            }
+            const paymentPayload = await this.buildPaymentPayload({
+                transport: "mcp",
+                operation: name,
+                idempotencyKey: options?.idempotencyKey,
+                paymentRequired,
+            });
+            return await this.mcpToolCall(name, args, {
+                ...options,
+                paymentPayload,
+            }, attempt, paymentAttempt + 1);
         }
         return body.result;
     }
@@ -260,22 +476,95 @@ export class IntentFiClient {
             "x-api-key": this.apiKey,
         };
     }
-    assertApiKey(operation) {
+    assertCredential(operation, options = {}) {
+        if (this.apiKey) {
+            return;
+        }
+        if (options.allowX402 && this.paymentManager) {
+            return;
+        }
+        if (options.allowX402) {
+            throw new Error(`INTENTFI_API_KEY or paymentManager is required for ${operation}. Set apiKey in IntentFiClient options/INTENTFI_API_KEY, or provide an x402 paymentManager.`);
+        }
         if (!this.apiKey) {
             throw new Error(`INTENTFI_API_KEY is required for ${operation}. Set apiKey in IntentFiClient options or INTENTFI_API_KEY in the environment.`);
         }
     }
+    async buildPaymentPayload(args) {
+        if (!this.paymentManager) {
+            throw createClientError("x402 payment challenge received but no paymentManager is configured.", "PAYMENT_REQUIRED", 402);
+        }
+        return await this.paymentManager.buildPaymentPayload(args);
+    }
+    async handleSettlement(args) {
+        if (!this.paymentManager?.onSettlement) {
+            return;
+        }
+        const settlement = parseSettlementFromResultMeta(args.result);
+        if (!settlement) {
+            return;
+        }
+        await this.paymentManager.onSettlement({
+            transport: args.transport,
+            operation: args.operation,
+            settlement,
+        });
+    }
     async fetchJson(path, init) {
         const result = await this.fetchEnvelope(path, init);
         return result.data;
     }
+    async fetchPaidEnvelope(path, init, context) {
+        const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+        const encodedPaymentRequired = response.headers.get(PAYMENT_REQUIRED_HEADER);
+        if (response.status !== 402 || !encodedPaymentRequired) {
+            return await this.parseEnvelopeResponse(response);
+        }
+        const paymentRequired = decodePaymentRequiredHeader(encodedPaymentRequired);
+        const paymentPayload = await this.buildPaymentPayload({
+            transport: "rest",
+            operation: context.operation,
+            idempotencyKey: context.idempotencyKey,
+            paymentRequired,
+        });
+        const retryHeaders = mergeHeaders(init.headers, {
+            [PAYMENT_SIGNATURE_HEADER]: encodeBase64Json(paymentPayload),
+        });
+        const retryResponse = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: retryHeaders,
+        });
+        const retryPaymentRequired = retryResponse.headers.get(PAYMENT_REQUIRED_HEADER);
+        if (retryResponse.status === 402 && retryPaymentRequired) {
+            await this.handleSettlement({
+                transport: "rest",
+                operation: context.operation,
+                result: { _meta: decodeSettlementMetaFromHeaders(retryResponse.headers) },
+            });
+            const retryChallenge = decodePaymentRequiredHeader(retryPaymentRequired);
+            const retryError = await readEnvelopeError(retryResponse);
+            throw createClientError(retryError?.message
+                ?? retryChallenge.error
+                ?? "x402 payment challenge persisted after retry.", retryError?.code ?? "PAYMENT_REQUIRED", 402, retryError?.details);
+        }
+        const envelope = await this.parseEnvelopeResponse(retryResponse);
+        await this.handleSettlement({
+            transport: "rest",
+            operation: context.operation,
+            result: { _meta: decodeSettlementMetaFromHeaders(retryResponse.headers) },
+        });
+        return envelope;
+    }
     async fetchEnvelope(path, init) {
         const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+        return await this.parseEnvelopeResponse(response);
+    }
+    async parseEnvelopeResponse(response) {
         const body = (await response.json());
         if (!response.ok || body.ok === false) {
             const errorCode = body.ok === false ? body.error.code : "HTTP_ERROR";
             const errorMessage = body.ok === false ? body.error.message : `HTTP ${response.status}`;
-            throw createClientError(`${errorCode}: ${errorMessage}`, errorCode, response.status);
+            throw createClientError(`${errorCode}: ${errorMessage}`, errorCode, response.status, body.ok === false ? toErrorDetails(body.error.details) : undefined);
         }
         return {
             data: body.data,
@@ -284,7 +573,7 @@ export class IntentFiClient {
         };
     }
 }
-function createClientError(message, code, status) {
+function createClientError(message, code, status, details) {
     const error = new Error(message);
     if (code) {
         error.code = code;
@@ -292,8 +581,324 @@ function createClientError(message, code, status) {
     if (status !== undefined) {
         error.status = status;
     }
+    if (details) {
+        error.details = details;
+    }
     return error;
 }
+function parseMcpSseMessages(payload) {
+    const lines = payload.split(/\r?\n/);
+    let currentDataLines = [];
+    let finalMessage = null;
+    let parseErrorCount = 0;
+    const flushCurrentData = () => {
+        if (currentDataLines.length === 0) {
+            return;
+        }
+        const chunk = currentDataLines.join("\n");
+        currentDataLines = [];
+        const trimmed = chunk.trim();
+        if (!trimmed || trimmed === "[DONE]") {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.result !== undefined || parsed.error !== undefined) {
+                finalMessage = parsed;
+            }
+        }
+        catch {
+            parseErrorCount += 1;
+        }
+    };
+    for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (line.length === 0) {
+            flushCurrentData();
+            continue;
+        }
+        if (!line.startsWith("data:")) {
+            continue;
+        }
+        const value = line.slice(5);
+        currentDataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+    flushCurrentData();
+    return {
+        finalMessage,
+        parseErrorCount,
+    };
+}
+async function parseMcpSseResponse(response) {
+    if (!response.body) {
+        return parseMcpSseMessages(await response.text());
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let parseErrorCount = 0;
+    let finalMessage = null;
+    let currentDataLines = [];
+    let pendingLine = "";
+    const flushCurrentData = () => {
+        if (currentDataLines.length === 0) {
+            return;
+        }
+        const chunk = currentDataLines.join("\n");
+        currentDataLines = [];
+        const trimmed = chunk.trim();
+        if (!trimmed || trimmed === "[DONE]") {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.result !== undefined || parsed.error !== undefined) {
+                finalMessage = parsed;
+            }
+        }
+        catch {
+            parseErrorCount += 1;
+        }
+    };
+    const processLines = (text) => {
+        const lines = text.split(/\r?\n/);
+        for (const rawLine of lines) {
+            const line = rawLine.trimEnd();
+            if (line.length === 0) {
+                flushCurrentData();
+                continue;
+            }
+            if (!line.startsWith("data:")) {
+                continue;
+            }
+            const value = line.slice(5);
+            currentDataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+        }
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            pendingLine += decoder.decode(value, { stream: true });
+            const lastBreak = pendingLine.lastIndexOf("\n");
+            if (lastBreak < 0) {
+                continue;
+            }
+            const completeText = pendingLine.slice(0, lastBreak + 1);
+            pendingLine = pendingLine.slice(lastBreak + 1);
+            processLines(completeText);
+        }
+        pendingLine += decoder.decode();
+        if (pendingLine.length > 0) {
+            processLines(`${pendingLine}\n`);
+        }
+        flushCurrentData();
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return {
+        finalMessage,
+        parseErrorCount,
+    };
+}
+async function readEnvelopeError(response) {
+    try {
+        const body = (await response.json());
+        if (body.ok === false
+            && body.error
+            && typeof body.error.code === "string"
+            && typeof body.error.message === "string") {
+            const details = toErrorDetails(body.error.details);
+            return {
+                code: body.error.code,
+                message: `${body.error.code}: ${body.error.message}`,
+                ...(details ? { details } : {}),
+            };
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function parseAtomicAmount(value) {
+    try {
+        return BigInt(value);
+    }
+    catch {
+        throw new Error(`Invalid x402 amount '${value}'.`);
+    }
+}
+function echoRequiredExtensions(extensions, idempotencyKey) {
+    if (!extensions) {
+        return undefined;
+    }
+    const echoedExtensions = {
+        ...extensions,
+    };
+    if (!idempotencyKey) {
+        return echoedExtensions;
+    }
+    const paymentIdentifier = extensions[PAYMENT_IDENTIFIER_EXTENSION];
+    if (!paymentIdentifier) {
+        return echoedExtensions;
+    }
+    return {
+        ...echoedExtensions,
+        [PAYMENT_IDENTIFIER_EXTENSION]: {
+            schema: paymentIdentifier.schema,
+            info: {
+                ...paymentIdentifier.info,
+                id: idempotencyKey,
+            },
+        },
+    };
+}
+function parseMcpPaymentChallenge(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (record.isError !== true) {
+        return null;
+    }
+    const structured = record.structuredContent;
+    if (isX402PaymentRequired(structured)) {
+        return structured;
+    }
+    const content = record.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const first = content[0];
+    if (!first || typeof first !== "object" || Array.isArray(first)) {
+        return null;
+    }
+    const text = first.text;
+    if (typeof text !== "string") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return isX402PaymentRequired(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseMcpChallengeError(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const meta = value._meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return null;
+    }
+    const challengeError = meta["x402/error"];
+    if (!challengeError || typeof challengeError !== "object" || Array.isArray(challengeError)) {
+        return null;
+    }
+    const code = challengeError.code;
+    const status = challengeError.status;
+    if (typeof code !== "string" || typeof status !== "number" || !Number.isFinite(status)) {
+        return null;
+    }
+    const details = toErrorDetails(challengeError.details);
+    return {
+        code,
+        status: Math.trunc(status),
+        ...(details ? { details } : {}),
+    };
+}
+function toErrorDetails(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function parseSettlementFromResultMeta(result) {
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+        return null;
+    }
+    const meta = result._meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return null;
+    }
+    const settlement = meta["x402/payment-response"];
+    return isX402SettlementResponse(settlement) ? settlement : null;
+}
+function decodeSettlementMetaFromHeaders(headers) {
+    const encoded = headers.get(PAYMENT_RESPONSE_HEADER);
+    if (!encoded) {
+        return undefined;
+    }
+    const decoded = decodeBase64Json(encoded);
+    if (!isX402SettlementResponse(decoded)) {
+        return undefined;
+    }
+    return {
+        "x402/payment-response": decoded,
+    };
+}
+function decodePaymentRequiredHeader(header) {
+    const decoded = decodeBase64Json(header);
+    if (!isX402PaymentRequired(decoded)) {
+        throw createClientError("PAYMENT-REQUIRED header contained an invalid x402 payload.", "PAYMENT_REQUIRED", 402);
+    }
+    return decoded;
+}
+function mergeHeaders(original, extra) {
+    const headers = new Headers(original ?? {});
+    for (const [key, value] of Object.entries(extra)) {
+        headers.set(key, value);
+    }
+    return headers;
+}
+function encodeBase64Json(value) {
+    const json = JSON.stringify(value);
+    const bytes = new TextEncoder().encode(json);
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+function decodeBase64Json(encoded) {
+    const normalized = encoded.trim().replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    const text = new TextDecoder().decode(bytes);
+    return JSON.parse(text);
+}
+function isX402PaymentRequired(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    if (record.x402Version !== X402_VERSION) {
+        return false;
+    }
+    if (!record.resource || typeof record.resource !== "object" || Array.isArray(record.resource)) {
+        return false;
+    }
+    const accepts = record.accepts;
+    return Array.isArray(accepts) && accepts.length > 0;
+}
+function isX402SettlementResponse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.success === "boolean"
+        && typeof record.transaction === "string"
+        && typeof record.network === "string");
+}
 function parseRetryAfterHeader(value) {
     if (!value) {
         return undefined;