@knownagents/sdk 1.11.0 → 2.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![NPM version](https://img.shields.io/npm/v/@knownagents/sdk.svg)](https://npmjs.org/package/@knownagents/sdk)
 
-This library provides convenient access to [Known Agents](https://knownagents.com/) from server-side TypeScript or JavaScript.
+This library provides convenient access to [Known Agents](https://knownagents.com/) from server-side Node.js applications written in TypeScript or JavaScript.
 
 ## Install the Package
 
@@ -24,25 +24,35 @@ const knownAgents = new KnownAgents("YOUR_ACCESS_TOKEN")
 
 ## How To Set Up Agent & LLM Analytics ([Full Docs](https://knownagents.com/docs/analytics))
 
-Get realtime insight into the hidden ecosystem of [crawlers, scrapers, AI agents, and other bots](https://knownagents.com/agents) browsing your website. Measure human traffic coming from AI chat and search platforms like ChatGPT, Perplexity, and Gemini.
+Get realtime insight into the hidden ecosystem of [AI agents and other bots](https://knownagents.com/agents) browsing your website, REST APIs, and [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) servers. Measure human traffic coming from AI chat and search platforms like ChatGPT, Perplexity, and Gemini.
 
-To collect this data, call `trackVisit` for each incoming request in the endpoints where you serve your pages.
+### Track Pageview and REST Calls
+
+To collect pageview and REST API analytics, call `trackPageviewOrRESTCall` with the incoming Node.js request and response.
 
 ```ts
-knownAgents.trackVisit(request)
+knownAgents.trackPageviewOrRESTCall(request, response)
 ```
 
-For richer analytics, include the response and duration:
+For REST APIs that return [ACP (Agentic Commerce Protocol)](https://www.agenticcommerce.dev/) or [UCP (Universal Commerce Protocol)](https://ucp.dev/) commerce metadata, include the response body:
 
 ```ts
-knownAgents.trackVisit(request, response, responseDurationInMilliseconds)
+knownAgents.trackPageviewOrRESTCall(request, response, {
+    restACPResponseBody: acpResponseBody
+})
 ```
 
-### Use Middleware if Possible
+```ts
+knownAgents.trackPageviewOrRESTCall(request, response, {
+    restUCPResponseBody: ucpResponseBody
+})
+```
+
+The SDK waits for the response to finish, then sends status, headers, duration, and any commerce metadata. Sensitive headers are filtered automatically.
 
-If you can, add this in middleware to track incoming requests to all pages from a single place.
+#### Use Middleware if Possible
 
-Here's an example with Express, but you can apply this same technique with other frameworks:
+If your framework supports middleware, call `trackPageviewOrRESTCall` there so pageviews and REST calls are tracked from a single place. [MCP](https://modelcontextprotocol.io/) requests are skipped automatically.
 
 ```ts
 import express from "express"
@@ -51,46 +61,75 @@ import { KnownAgents } from "@knownagents/sdk"
 const app = express()
 const knownAgents = new KnownAgents("YOUR_ACCESS_TOKEN")
 
-app.use((req, res, next) => {
-    const start = Date.now()
-    res.on('finish', () => {
-        const duration = Date.now() - start
-        knownAgents.trackVisit(req, res, duration)
-    })
-    
+app.use((request, response, next) => {
+    knownAgents.trackPageviewOrRESTCall(request, response)
     next()
 })
 
-app.get("/", (req, res) => {
-    res.send("Hello, world!")
+app.get("/", (request, response) => {
+    response.send("Hello, world!")
 })
 
 app.listen(3000, () => console.log("Server running on port 3000"))
 ```
 
-### Batch Requests If Possible
+### Track MCP Calls
 
-For high-traffic websites, batch multiple visits together and send them periodically (e.g. every 30 seconds) using `trackVisits`:
+For [MCP](https://modelcontextprotocol.io/) servers that use `StreamableHTTPServerTransport`, call `trackMCPCall` after connecting the transport and before the transport handles the request.
+
+For MCP calls that return [ACP](https://www.agenticcommerce.dev/) or [UCP](https://ucp.dev/) commerce metadata, the SDK captures the relevant currency and total amount automatically.
+
+Use this order in your MCP HTTP handler:
 
 ```ts
-import { VisitRequest } from "@knownagents/sdk"
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js"
+
+const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined
+})
+
+await mcpServer.connect(transport)
+knownAgents.trackMCPCall(request, response, transport)
+await transport.handleRequest(request, response, parsedBody)
+```
+
+Use `trackVisits` instead if the same transport instance handles concurrent requests.
 
+### Batching
+
+For high-traffic websites, batch multiple visits together and send them periodically (e.g. every 30 seconds) using `trackVisits`. `trackVisits` can also batch MCP visits; if you do that, include the MCP fields in each `VisitRequest` and do not also call `trackMCPCall` for the same requests. Here's an Express example:
+
+```ts
+import express from "express"
+import { KnownAgents, type VisitRequest } from "@knownagents/sdk"
+
+const app = express()
+const knownAgents = new KnownAgents("YOUR_ACCESS_TOKEN")
 const visits: VisitRequest[] = []
 
-// Collect visits
-visits.push({
-    request_path: req.url,
-    request_method: req.method,
-    request_headers: req.headers,
-    response_status_code: res.statusCode,
-    response_duration_in_milliseconds: duration,
-    created: new Date().toISOString()
+app.use((request, response, next) => {
+    const created = new Date()
+
+    response.once("finish", () => {
+        visits.push({
+            request_path: request.url,
+            request_method: request.method,
+            request_headers: request.headers,
+            response_status_code: response.statusCode,
+            response_headers: response.getHeaders(),
+            response_duration_in_milliseconds: Date.now() - created.getTime(),
+            created: created.toISOString()
+        })
+    })
+
+    next()
 })
 
-// Send batch periodically
 setInterval(() => {
-    if (visits.length > 0) {
-        knownAgents.trackVisits(visits.splice(0))
+    const batch = visits.splice(0)
+
+    if (batch.length > 0) {
+        knownAgents.trackVisits(batch)
     }
 }, 30000)
 ```
@@ -110,21 +149,21 @@ Protect sensitive content from unwanted access and scraping. Generate a continuo
 Use the `generateRobotsTXT` function. Select which `AgentType`s you want to block, and a string specifying which URLs are disallowed (e.g. `"/"` to disallow all paths).
 
 ```ts
+import { AgentType } from "@knownagents/sdk"
+
 const robotsTxt = await knownAgents.generateRobotsTXT([
-  AgentType.AIDataScraper,
-  AgentType.Scraper,
-  AgentType.IntelligenceGatherer,
-  AgentType.SEOCrawler
-  // ...
+    AgentType.AIDataScraper,
+    AgentType.AIDataProvider,
+    AgentType.Scraper,
+    AgentType.SEOCrawler
 ], "/")
-
 ```
 
 The return value is a plain text robots.txt string. Generate a `robotsTxt` periodically (e.g. once per day), then cache and serve it from your website's `/robots.txt` endpoint.
 
 ## How To Use Agent Identification ([Full Docs](https://knownagents.com/docs/identification))
 
-Use the `identifyAgent` and `identifyAgents` functions to [identify](https://knownagents.com/agents) and verify agents from network requests using Web Bot Auth (HTTP message signatures), IP matching, or other available methods. This can be useful for implementing access policies based on verified agent identity or enriching your own datasets.
+Use the `identifyAgent` and `identifyAgents` functions to identify and verify [AI agents and bots](https://knownagents.com/agents) from network requests using Web Bot Auth (HTTP message signatures), IP matching, or other available methods. This can be useful for implementing access policies based on verified agent identity or enriching your own datasets.
 
 ### Identify a Single Request
 
@@ -134,9 +173,9 @@ Call `identifyAgent` with the incoming request.
 const identification = await knownAgents.identifyAgent(request)
 
 if (identification.result === "verified") {
-    // Agent is legitimate
+    handleVerifiedAgent(identification)
 } else if (identification.result === "verification_failed") {
-    // Agent is not legitimate
+    handleFailedVerification(identification)
 }
 ```
 
@@ -177,8 +216,8 @@ TypeScript >= 4.7 is supported.
 
 The following runtimes are supported:
 
-- Node.js 18 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
+- Node.js 18 LTS or later ([non-EOL](https://endoflife.date/nodejs))
 
 ## Support
 
-Please [open an issue](https://github.com/knownagents/node-sdk/issues) with questions, bugs, or suggestions.
+Please [open an issue](https://github.com/knownagents/node-sdk/issues) with questions, bugs, or suggestions.

package/dist/KnownAgents.d.ts

@@ -0,0 +1,74 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import type { AgentType, IdentificationRequest, IdentificationResult, TrackPageviewOrRESTCallOptions, VisitRequest } from "./types";
+/**
+ * Server-side client for Known Agents analytics, robots.txt generation, and agent identification.
+ */
+export declare class KnownAgents {
+    private readonly accessToken;
+    /**
+     * Creates a new instance of the Known Agents client.
+     *
+     * @param accessToken - Your project's access token.
+     */
+    constructor(accessToken: string);
+    /**
+     * Tracks a single non-MCP pageview or REST API call for analytics.
+     * The visit is sent after the response finishes so status, headers, and duration are included.
+     * This method is non-blocking and handles errors internally.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @param response - The outgoing Node.js HTTP response.
+     * @param options - Optional ACP or UCP response metadata for REST API calls.
+     */
+    trackPageviewOrRESTCall(request: IncomingMessage, response: ServerResponse, options?: TrackPageviewOrRESTCallOptions): void;
+    /**
+     * Tracks a single MCP call handled by `StreamableHTTPServerTransport`.
+     * Call this after connecting the transport and before the transport processes the request so request and response metadata can be captured.
+     * Do not use this with transport instances shared across concurrent requests; use `trackVisits()` instead.
+     * This method is non-blocking and handles errors internally.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @param response - The outgoing Node.js HTTP response.
+     * @param transport - The MCP streamable HTTP transport handling the request.
+     */
+    trackMCPCall(request: IncomingMessage, response: ServerResponse, transport: StreamableHTTPServerTransport): void;
+    /**
+     * Tracks multiple visits in a batch for analytics.
+     * This method is non-blocking and handles errors internally.
+     * Recommended for high-traffic websites - batch visits and send periodically (e.g. every 30 seconds).
+     *
+     * @param requests - An array of visits.
+     */
+    trackVisits(requests: VisitRequest[]): void;
+    /**
+     * Generates a robots.txt file that disallows the specified agent types.
+     * The generated file stays up-to-date with all current and future agents in the specified categories.
+     * Cache and serve the result at your website's `/robots.txt` endpoint.
+     *
+     * @param agentTypes - An array of agent types to disallow.
+     * @param disallow - The path to disallow (default: "/" for all paths).
+     * @returns A promise that resolves to the generated robots.txt content as a string.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    generateRobotsTXT(agentTypes: AgentType[], disallow?: string): Promise<string>;
+    /**
+     * Identifies and verifies a single agent from an HTTP request.
+     * Uses Web Bot Auth (HTTP message signatures), IP matching, or other available methods.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @returns A promise that resolves to the identification result.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    identifyAgent(request: IncomingMessage): Promise<IdentificationResult>;
+    /**
+     * Identifies and verifies multiple agents from HTTP requests in a batch.
+     * Uses Web Bot Auth (HTTP message signatures), IP matching, or other available methods.
+     *
+     * @param requests - An array of identification requests.
+     * @returns A promise that resolves to an array of identification results.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    identifyAgents(requests: IdentificationRequest[]): Promise<IdentificationResult[]>;
+}
+//# sourceMappingURL=KnownAgents.d.ts.map

package/dist/KnownAgents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KnownAgents.d.ts","sourceRoot":"","sources":["../src/KnownAgents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AAC3D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAA;AAavG,OAAO,KAAK,EACR,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,8BAA8B,EAC9B,YAAY,EACf,MAAM,SAAS,CAAA;AAqChB;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAEpC;;;;OAIG;gBACS,WAAW,EAAE,MAAM;IAI/B;;;;;;;;OAQG;IACH,uBAAuB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,8BAA8B,GAAG,IAAI;IAsC3H;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,6BAA6B,GAAG,IAAI;IAuEhH;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IA6B3C;;;;;;;;;OASG;IACG,iBAAiB,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE,QAAQ,GAAE,MAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBzF;;;;;;;OAOG;IACG,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAmB5E;;;;;;;OAOG;IACG,cAAc,CAAC,QAAQ,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC;CAsB3F"}

package/dist/KnownAgents.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownAgents = void 0;
+const commerce_1 = require("./commerce");
+const headers_1 = require("./headers");
+const paths_1 = require("./paths");
+/**
+ * Server-side client for Known Agents analytics, robots.txt generation, and agent identification.
+ */
+class KnownAgents {
+    /**
+     * Creates a new instance of the Known Agents client.
+     *
+     * @param accessToken - Your project's access token.
+     */
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    /**
+     * Tracks a single non-MCP pageview or REST API call for analytics.
+     * The visit is sent after the response finishes so status, headers, and duration are included.
+     * This method is non-blocking and handles errors internally.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @param response - The outgoing Node.js HTTP response.
+     * @param options - Optional ACP or UCP response metadata for REST API calls.
+     */
+    trackPageviewOrRESTCall(request, response, options) {
+        const isMCPCall = (0, headers_1.getIsMCPCall)(request.headers);
+        const path = request.url;
+        const method = request.method;
+        if (isMCPCall || !path || (0, paths_1.getIsPathExcluded)(path) || !method) {
+            return;
+        }
+        const created = new Date();
+        const sendVisit = () => {
+            const responseDurationInMilliseconds = Date.now() - created.getTime();
+            const visitRequest = {
+                request_path: path,
+                request_method: method,
+                request_headers: request.headers,
+                response_status_code: response?.statusCode,
+                response_headers: response.getHeaders(),
+                response_duration_in_milliseconds: responseDurationInMilliseconds,
+                acp_response_currency: options?.restACPResponseBody ? (0, commerce_1.getRESTACPCurrencyIfPossible)(options?.restACPResponseBody) : undefined,
+                acp_response_total_amount: options?.restACPResponseBody ? (0, commerce_1.getRESTACPTotalAmountIfPossible)(options?.restACPResponseBody) : undefined,
+                ucp_response_currency: options?.restUCPResponseBody ? (0, commerce_1.getRESTUCPCurrencyIfPossible)(options?.restUCPResponseBody) : undefined,
+                ucp_response_total_amount: options?.restUCPResponseBody ? (0, commerce_1.getRESTUCPTotalAmountIfPossible)(options?.restUCPResponseBody) : undefined,
+                created: created.toISOString()
+            };
+            this.trackVisits([visitRequest]);
+        };
+        if (response.writableEnded) {
+            sendVisit();
+        }
+        else {
+            response.once("finish", sendVisit);
+        }
+    }
+    /**
+     * Tracks a single MCP call handled by `StreamableHTTPServerTransport`.
+     * Call this after connecting the transport and before the transport processes the request so request and response metadata can be captured.
+     * Do not use this with transport instances shared across concurrent requests; use `trackVisits()` instead.
+     * This method is non-blocking and handles errors internally.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @param response - The outgoing Node.js HTTP response.
+     * @param transport - The MCP streamable HTTP transport handling the request.
+     */
+    trackMCPCall(request, response, transport) {
+        const isMCPCall = (0, headers_1.getIsMCPCall)(request.headers);
+        const path = request.url;
+        const method = request.method;
+        if (!isMCPCall || !path || (0, paths_1.getIsPathExcluded)(path) || !method) {
+            return;
+        }
+        const created = new Date();
+        let mcpRequestBody;
+        let mcpResponseBody;
+        const originalTransportOnMessage = transport.onmessage;
+        transport.onmessage = (message, extra) => {
+            mcpRequestBody = message;
+            originalTransportOnMessage?.(message, extra);
+        };
+        const originalTransportSend = transport.send;
+        transport.send = async (message, options) => {
+            mcpResponseBody = message;
+            await originalTransportSend.call(transport, message, options);
+        };
+        const restoreTransport = () => {
+            transport.onmessage = originalTransportOnMessage;
+            transport.send = originalTransportSend;
+        };
+        const sendVisit = () => {
+            restoreTransport();
+            if (!mcpRequestBody || !mcpResponseBody) {
+                return;
+            }
+            const responseDurationInMilliseconds = Date.now() - created.getTime();
+            const visitRequest = {
+                request_path: path,
+                request_method: method,
+                request_headers: request.headers,
+                response_status_code: response?.statusCode,
+                response_headers: response.getHeaders(),
+                response_duration_in_milliseconds: responseDurationInMilliseconds,
+                mcp_request_method: mcpRequestBody.method,
+                mcp_request_tool_name: mcpRequestBody.params?.name,
+                mcp_request_client_info_name: mcpRequestBody.params?.clientInfo?.name,
+                mcp_request_client_info_version: mcpRequestBody.params?.clientInfo?.version,
+                mcp_response_result_is_error: mcpResponseBody.result?.isError,
+                mcp_response_error_code: mcpResponseBody.error?.code,
+                mcp_response_error_message: mcpResponseBody.error?.message,
+                acp_response_currency: (0, commerce_1.getMCPACPCurrencyIfPossible)(request, mcpResponseBody),
+                acp_response_total_amount: (0, commerce_1.getMCPACPTotalAmountIfPossible)(request, mcpResponseBody),
+                ucp_response_currency: (0, commerce_1.getMCPUCPCurrencyIfPossible)(request, mcpResponseBody),
+                ucp_response_total_amount: (0, commerce_1.getMCPUCPTotalAmountIfPossible)(request, mcpResponseBody),
+                created: created.toISOString()
+            };
+            this.trackVisits([visitRequest]);
+        };
+        if (response.writableEnded) {
+            sendVisit();
+        }
+        else {
+            response.once("finish", sendVisit);
+        }
+    }
+    /**
+     * Tracks multiple visits in a batch for analytics.
+     * This method is non-blocking and handles errors internally.
+     * Recommended for high-traffic websites - batch visits and send periodically (e.g. every 30 seconds).
+     *
+     * @param requests - An array of visits.
+     */
+    trackVisits(requests) {
+        const filteredRequests = requests
+            .filter((request) => {
+            return !(0, paths_1.getIsPathExcluded)(request.request_path);
+        })
+            .map((request) => {
+            return {
+                ...request,
+                request_headers: (0, headers_1.getFilteredHeaders)(request.request_headers),
+                response_headers: request.response_headers ? (0, headers_1.getFilteredHeaders)(request.response_headers) : undefined,
+            };
+        });
+        if (filteredRequests.length === 0) {
+            return;
+        }
+        fetch("https://api.knownagents.com/visits", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(filteredRequests)
+        }).catch(error => {
+            console.error(`Known Agents failed to track visits: ${error.message}`);
+        });
+    }
+    /**
+     * Generates a robots.txt file that disallows the specified agent types.
+     * The generated file stays up-to-date with all current and future agents in the specified categories.
+     * Cache and serve the result at your website's `/robots.txt` endpoint.
+     *
+     * @param agentTypes - An array of agent types to disallow.
+     * @param disallow - The path to disallow (default: "/" for all paths).
+     * @returns A promise that resolves to the generated robots.txt content as a string.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    async generateRobotsTXT(agentTypes, disallow = "/") {
+        const response = await fetch("https://api.knownagents.com/robots-txts", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agent_types: agentTypes,
+                disallow: disallow
+            })
+        });
+        if (response.ok) {
+            return await response.text();
+        }
+        else {
+            throw new Error(`Known Agents failed to generate robots.txt: ${response.status} ${response.statusText}`);
+        }
+    }
+    /**
+     * Identifies and verifies a single agent from an HTTP request.
+     * Uses Web Bot Auth (HTTP message signatures), IP matching, or other available methods.
+     *
+     * @param request - The incoming Node.js HTTP request.
+     * @returns A promise that resolves to the identification result.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    async identifyAgent(request) {
+        const response = await fetch("https://api.knownagents.com/agent-identifications", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                request_headers: (0, headers_1.getFilteredHeaders)(request.headers)
+            })
+        });
+        if (response.ok) {
+            return await response.json();
+        }
+        else {
+            throw new Error(`Known Agents failed to identify agent: ${response.status} ${response.statusText}`);
+        }
+    }
+    /**
+     * Identifies and verifies multiple agents from HTTP requests in a batch.
+     * Uses Web Bot Auth (HTTP message signatures), IP matching, or other available methods.
+     *
+     * @param requests - An array of identification requests.
+     * @returns A promise that resolves to an array of identification results.
+     * @throws {Error} If the API call fails or returns a non-200 status.
+     */
+    async identifyAgents(requests) {
+        const response = await fetch("https://api.knownagents.com/agent-identifications", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(requests.map(request => {
+                return {
+                    ...request,
+                    request_headers: (0, headers_1.getFilteredHeaders)(request.request_headers),
+                };
+            }))
+        });
+        if (response.ok) {
+            return await response.json();
+        }
+        else {
+            throw new Error(`Known Agents failed to identify agents: ${response.status} ${response.statusText}`);
+        }
+    }
+}
+exports.KnownAgents = KnownAgents;

package/dist/commerce.d.ts

@@ -0,0 +1,28 @@
+import type { IncomingMessage } from "http";
+import type { RESTACPResponseBody, RESTUCPResponseBody } from "./types";
+interface MCPCommerceResponseBody {
+    result?: {
+        currency?: string;
+        totals?: {
+            type?: string;
+            amount?: number;
+        }[];
+        structuredContent?: {
+            currency?: string;
+            totals?: {
+                type?: string;
+                amount?: number;
+            }[];
+        };
+    };
+}
+export declare function getRESTACPCurrencyIfPossible(restACPResponseBody: RESTACPResponseBody): string | undefined;
+export declare function getRESTACPTotalAmountIfPossible(restACPResponseBody: RESTACPResponseBody): number | undefined;
+export declare function getMCPACPCurrencyIfPossible(request: IncomingMessage, mcpResponseBody: MCPCommerceResponseBody): string | undefined;
+export declare function getMCPACPTotalAmountIfPossible(request: IncomingMessage, mcpResponseBody: MCPCommerceResponseBody): number | undefined;
+export declare function getRESTUCPCurrencyIfPossible(restUCPResponseBody: RESTUCPResponseBody): string | undefined;
+export declare function getRESTUCPTotalAmountIfPossible(restUCPResponseBody: RESTUCPResponseBody): number | undefined;
+export declare function getMCPUCPCurrencyIfPossible(request: IncomingMessage, mcpResponseBody: MCPCommerceResponseBody): string | undefined;
+export declare function getMCPUCPTotalAmountIfPossible(request: IncomingMessage, mcpResponseBody: MCPCommerceResponseBody): number | undefined;
+export {};
+//# sourceMappingURL=commerce.d.ts.map

package/dist/commerce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commerce.d.ts","sourceRoot":"","sources":["../src/commerce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAEvE,UAAU,uBAAuB;IAC7B,MAAM,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,MAAM,CAAC,EAAE;YACL,IAAI,CAAC,EAAE,MAAM,CAAA;YACb,MAAM,CAAC,EAAE,MAAM,CAAA;SAClB,EAAE,CAAA;QACH,iBAAiB,CAAC,EAAE;YAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;YACjB,MAAM,CAAC,EAAE;gBACL,IAAI,CAAC,EAAE,MAAM,CAAA;gBACb,MAAM,CAAC,EAAE,MAAM,CAAA;aAClB,EAAE,CAAA;SACN,CAAA;KACJ,CAAA;CACJ;AAED,wBAAgB,4BAA4B,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAEzG;AAED,wBAAgB,+BAA+B,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAI5G;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAGlI;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAOrI;AAED,wBAAgB,4BAA4B,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAEzG;AAED,wBAAgB,+BAA+B,CAAC,mBAAmB,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAI5G;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAGlI;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAOrI"}

package/dist/commerce.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRESTACPCurrencyIfPossible = getRESTACPCurrencyIfPossible;
+exports.getRESTACPTotalAmountIfPossible = getRESTACPTotalAmountIfPossible;
+exports.getMCPACPCurrencyIfPossible = getMCPACPCurrencyIfPossible;
+exports.getMCPACPTotalAmountIfPossible = getMCPACPTotalAmountIfPossible;
+exports.getRESTUCPCurrencyIfPossible = getRESTUCPCurrencyIfPossible;
+exports.getRESTUCPTotalAmountIfPossible = getRESTUCPTotalAmountIfPossible;
+exports.getMCPUCPCurrencyIfPossible = getMCPUCPCurrencyIfPossible;
+exports.getMCPUCPTotalAmountIfPossible = getMCPUCPTotalAmountIfPossible;
+const headers_1 = require("./headers");
+function getRESTACPCurrencyIfPossible(restACPResponseBody) {
+    return restACPResponseBody?.currency;
+}
+function getRESTACPTotalAmountIfPossible(restACPResponseBody) {
+    return restACPResponseBody?.totals?.find((total) => {
+        return total.type == "total";
+    })?.amount;
+}
+function getMCPACPCurrencyIfPossible(request, mcpResponseBody) {
+    const isProbablyACP = !(0, headers_1.getIsUCPCall)(request.headers) && (0, headers_1.getIsProbablyACPCall)(request.headers);
+    return isProbablyACP ? mcpResponseBody.result?.currency : undefined;
+}
+function getMCPACPTotalAmountIfPossible(request, mcpResponseBody) {
+    const isProbablyACP = !(0, headers_1.getIsUCPCall)(request.headers) && (0, headers_1.getIsProbablyACPCall)(request.headers);
+    return isProbablyACP
+        ? mcpResponseBody.result?.totals?.find((total) => {
+            return total.type == "total";
+        })?.amount
+        : undefined;
+}
+function getRESTUCPCurrencyIfPossible(restUCPResponseBody) {
+    return restUCPResponseBody?.currency;
+}
+function getRESTUCPTotalAmountIfPossible(restUCPResponseBody) {
+    return restUCPResponseBody?.totals?.find((total) => {
+        return total.type == "total";
+    })?.amount;
+}
+function getMCPUCPCurrencyIfPossible(request, mcpResponseBody) {
+    const isUCP = (0, headers_1.getIsUCPCall)(request.headers);
+    return isUCP ? mcpResponseBody.result?.structuredContent?.currency : undefined;
+}
+function getMCPUCPTotalAmountIfPossible(request, mcpResponseBody) {
+    const isUCP = (0, headers_1.getIsUCPCall)(request.headers);
+    return isUCP
+        ? mcpResponseBody.result?.structuredContent?.totals?.find((total) => {
+            return total.type == "total";
+        })?.amount
+        : undefined;
+}

package/dist/headers.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from "http";
+export declare function getFilteredHeaders<Headers extends IncomingHttpHeaders | OutgoingHttpHeaders>(headers: Headers): Headers;
+export declare function getIsMCPCall(headers: IncomingHttpHeaders): boolean;
+export declare function getIsUCPCall(headers: IncomingHttpHeaders): boolean;
+export declare function getIsProbablyACPCall(headers: IncomingHttpHeaders): boolean;
+//# sourceMappingURL=headers.d.ts.map

package/dist/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../src/headers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAA;AA2BpE,wBAAgB,kBAAkB,CAAC,OAAO,SAAS,mBAAmB,GAAG,mBAAmB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAUvH;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAIlE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAIlE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAI1E"}