@knownagents/sdk 1.11.0 → 2.1.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,73 +24,110 @@ 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 how [AI agents and other bots](https://knownagents.com/agents) browse your web pages, call your [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) endpoints, and purchase products through your [ACP (Agentic Commerce Protocol)](https://www.agenticcommerce.dev/) and [UCP (Universal Commerce Protocol)](https://ucp.dev/) shopping flows. Measure human traffic from AI chat and search platforms like ChatGPT, Claude, and Gemini.
 
-To collect this data, call `trackVisit` for each incoming request in the endpoints where you serve your pages.
+### Track Pageviews and REST Calls
+
+Call `trackPageviewOrRESTCall` with the incoming request and outgoing response. If you can, do this in middleware.
 
 ```ts
-knownAgents.trackVisit(request)
+knownAgents.trackPageviewOrRESTCall(request, response)
 ```
 
-For richer analytics, include the response and duration:
+MCP calls are skipped automatically by `trackPageviewOrRESTCall`. Use `trackMCPCall` to track MCP calls.
+
+High-traffic websites should not use this method. Instead, batch visits and send them periodically with `trackVisits` (see below).
+
+#### Agentic Commerce Calls
+
+For REST implementations of ACP and UCP, include the response body.
+
+```ts
+// For ACP calls ...
+
+knownAgents.trackPageviewOrRESTCall(request, response, {
+    acpResponseBody: acpResponseBody
+})
+```
 
 ```ts
-knownAgents.trackVisit(request, response, responseDurationInMilliseconds)
+// For UCP calls ...
+
+knownAgents.trackPageviewOrRESTCall(request, response, {
+    ucpResponseBody: ucpResponseBody
+})
 ```
 
-### Use Middleware if Possible
+### Track MCP Calls
 
-If you can, add this in middleware to track incoming requests to all pages from a single place.
+For MCP servers that use `StreamableHTTPServerTransport`, call `trackMCPCall` after connecting the transport and before the transport handles the request.
 
-Here's an example with Express, but you can apply this same technique with other frameworks:
+High-traffic websites, or those that use the same transport instance to handle multiple concurrent requests, should not use this method. Instead, batch visits and send them periodically with `trackVisits` (see below).
 
 ```ts
-import express from "express"
-import { KnownAgents } from "@knownagents/sdk"
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js"
 
-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)
-    })
-    
-    next()
+const mcpServer = new McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION,
 })
 
-app.get("/", (req, res) => {
-    res.send("Hello, world!")
+const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined
 })
 
-app.listen(3000, () => console.log("Server running on port 3000"))
+// ...
+
+await mcpServer.connect(transport)
+
+knownAgents.trackMCPCall(request, response, transport)
+
+await transport.handleRequest(request, response, parsedBody)
 ```
 
-### Batch Requests If Possible
+#### Agentic Commerce Calls
+
+This method will track MCP implementations of ACP and UCP automatically.
 
-For high-traffic websites, batch multiple visits together and send them periodically (e.g. every 30 seconds) using `trackVisits`:
+### Batching for High-Traffic Websites
+
+High-traffic websites should batch multiple visits together and send them periodically (e.g. every 30 seconds) using `trackVisits`. This method can track pageviews, REST, MCP, ACP, and UCP calls. Here's an example with Express middleware:
 
 ```ts
-import { VisitRequest } from "@knownagents/sdk"
+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)
 ```
@@ -101,48 +138,38 @@ setInterval(() => {
 - Click **Send a Test Visit**
 - Click **Realtime**
 
-If your website is correctly connected, you should see visits from the Known Agent in the realtime timeline within a few seconds.
+If your website is correctly connected, you should see visits from a test agent in the realtime timeline within a few seconds.
 
 ## How To Set Up Automatic Robots.txt ([Full Docs](https://knownagents.com/docs/robots-txt))
 
-Protect sensitive content from unwanted access and scraping. Generate a continuously updating robots.txt that stays up to date with [all current and future bots](https://knownagents.com/agents) in the specified categories automatically.
+Serve a robots.txt that continuously updates with rules for new [crawlers, scrapers, AI agents, and other bots](https://knownagents.com/agents) as they're discovered.
 
-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).
+Use the `generateRobotsTXT` method. 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))
+The return value is a plain text robots.txt string. Generate a `robotsTxt` periodically (e.g. once per day, using a cron job). Then, serve it from your website's `/robots.txt` endpoint.
 
-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.
+## How To Use the Agent Identification API ([Full Docs](https://knownagents.com/docs/identification))
 
-### Identify a Single Request
+Identify and verify [AI agents and other bots](https://knownagents.com/agents) in your own products, from incoming network requests. Authentication uses Web Bot Auth (HTTP message signatures), IP matching, or other available methods. This API can be useful for implementing access policies based on verified agent identity or enriching your own datasets.
 
-Call `identifyAgent` with the incoming request.
+Call `identifyAgent` to identify a single incoming request:
 
 ```ts
 const identification = await knownAgents.identifyAgent(request)
-
-if (identification.result === "verified") {
-    // Agent is legitimate
-} else if (identification.result === "verification_failed") {
-    // Agent is not legitimate
-}
 ```
 
-### Identify Multiple Requests
-
-Use `identifyAgents` to identify multiple requests at once:
+Call `identifyAgents` to identify multiple requests at once:
 
 ```ts
 const identifications = await knownAgents.identifyAgents([
@@ -157,7 +184,7 @@ const identifications = await knownAgents.identifyAgents([
 ])
 ```
 
-The functions return an object (or array of objects) with the following fields:
+These methods return an object (or array of objects) with the following fields:
 
 - `id`: The identifier from the request (if provided)
 - `result`: The identification result:
@@ -177,8 +204,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;AAGvG,OAAO,KAAK,EACR,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,8BAA8B,EAC9B,YAAY,EACf,MAAM,SAAS,CAAA;AAEhB;;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;IAoC3H;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,6BAA6B,GAAG,IAAI;IAqEhH;;;;;;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,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownAgents = void 0;
+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_body: options?.acpResponseBody,
+                ucp_response_body: options?.ucpResponseBody,
+                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 path = request.url;
+        const method = request.method;
+        if (!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 mcpResponseResult = mcpResponseBody.result?.structuredContent ?? mcpResponseBody.result;
+            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_body: (0, headers_1.getIsACPCall)(request.headers) ? mcpResponseResult : undefined,
+                ucp_response_body: (0, headers_1.getIsUCPCall)(request.headers) ? mcpResponseResult : undefined,
+                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 getIsACPCall(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,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAIlE"}