@useparallel/agent-identification 0.0.0-stage → 0.9.0

package/dist/types/browser/track-script.d.ts

@@ -0,0 +1,8 @@
+import { track } from "./track.js";
+declare global {
+    interface Window {
+        AgentIdentificationTracker: {
+            track: typeof track;
+        };
+    }
+}

package/dist/types/browser/track.d.ts

@@ -0,0 +1,39 @@
+export interface TrackerOptions {
+    siteId: string;
+    apiUrl: string;
+    /** Where the tab's session is kept: sessionStorage (the default) or memory only. */
+    storage?: "session" | "memory";
+    /** Your route pattern for this page, such as /tickets/:id, for parts masking can't catch. */
+    route?: string;
+    /**
+     * Records a page view whenever the path changes without a reload, through the History API or
+     * the back and forward buttons. Defaults to true; turn it off if you call pageView() yourself.
+     */
+    navigation?: boolean;
+    /**
+     * Reports whether this browser is automated (navigator.webdriver) or headless, once per
+     * session, as heuristic evidence that never labels a visitor an AI agent. Defaults to true.
+     */
+    automationSignals?: boolean;
+    /**
+     * 0.9.0: a binding context your server signed with createBindingContext() for this visitor's
+     * own session. Actions your server reports with the same sessionBinding then join this visit.
+     */
+    bindingContext?: string;
+    onError?: (error: Error) => void;
+}
+export interface Tracker {
+    /** Resolves once this page load's page view is confirmed, and rejects if it couldn't be. */
+    readonly ready: Promise<void>;
+    /** Records a page view, for apps that change pages without the History API. */
+    pageView(options?: {
+        route?: string;
+    }): Promise<void>;
+    /** Stops recording. It never ends the session or removes anything already recorded. */
+    destroy(): void;
+}
+/**
+ * Records this page's views and automation signals for one site, without drawing anything.
+ * Calling it again for the same site returns the same tracker.
+ */
+export declare function track(options: TrackerOptions): Tracker;

package/dist/types/protocol.d.ts

@@ -0,0 +1,189 @@
+/** Shared wire protocol. Classifications are always self-reported. */
+export declare const VERSION = "0.9.0";
+export declare const CHOICES: readonly ["ai_assistant", "person", "prefer_not_to_say"];
+export type Choice = (typeof CHOICES)[number];
+export type Mode = "optional" | "required";
+export interface SessionStatus {
+    sessionId: string;
+    siteId: string;
+    origin: string;
+    expiresAt: string;
+    choice: Choice | null;
+    receipt: string | null;
+    eventId: string | null;
+    evidence: "self_reported";
+}
+export interface CreatedSession extends SessionStatus {
+    sessionToken: string;
+}
+export interface RecordedDeclaration extends SessionStatus {
+    choice: Choice;
+    receipt: string;
+    eventId: string;
+}
+export interface ApiError {
+    error: string;
+}
+export declare function isChoice(value: unknown): value is Choice;
+export declare const EVENT_TYPES: readonly ["declaration", "page_view", "action", "signature", "signal"];
+export type EventType = (typeof EVENT_TYPES)[number];
+/** A browser report can come from any client that copies the public site ID. */
+export type EventSource = "browser" | "server";
+/**
+ * Who vouches for an event: the visitor, the page's script, the host's own server, the
+ * collector's own check of a Web Bot Auth signature, or the host's CDN.
+ */
+export type Evidence = "self_reported" | "browser_reported" | "host_reported" | "signature_verified" | "signature_claimed" | "cdn_reported";
+export declare const OUTCOMES: readonly ["attempted", "rejected", "confirmed"];
+/** `confirmed` means the host's application says the action succeeded. */
+export type Outcome = (typeof OUTCOMES)[number];
+/** What an agent says about itself. Every field is self-reported, and null means unknown. */
+export interface AgentClaim {
+    name: string | null;
+    provider: string | null;
+    purpose: string | null;
+}
+interface EventBase {
+    /** Chosen by the reporter, so a retry with the same ID is recorded once. */
+    id: string;
+    siteId: string;
+    /** The collector session, when the reporter knows it. */
+    sessionId: string | null;
+    /** The page's origin for browser events; null for server events. */
+    origin: string | null;
+    source: EventSource;
+    evidence: Evidence;
+    /** When the reporter says it happened. */
+    occurredAt: string;
+    /** When the collector received it. */
+    receivedAt: string;
+    /**
+     * The host's opaque reference to the account used, set only by the host's server. It says
+     * which account acted, never who delegated an agent to act.
+     */
+    accountRef: string | null;
+    /**
+     * Since 0.7.0, true on a server report that joined its session through a link: the page that
+     * received the server's response claimed it. The report itself carried no session.
+     */
+    linked?: true;
+}
+export interface DeclarationEvent extends EventBase {
+    type: "declaration";
+    source: "browser";
+    evidence: "self_reported";
+    choice: Choice;
+    agent: AgentClaim;
+}
+export interface PageViewEvent extends EventBase {
+    type: "page_view";
+    source: "browser";
+    evidence: "browser_reported";
+    /** Always passed through `routePath`. */
+    path: string;
+    /** The host's own route pattern, such as /tickets/:id, when it supplies one. */
+    route: string | null;
+}
+export interface ActionEvent extends EventBase {
+    type: "action";
+    source: "server";
+    evidence: "host_reported";
+    /** Named by the host, such as ticket.update. */
+    action: string;
+    resourceRef: string | null;
+    outcome: Outcome;
+}
+/** Why a Web Bot Auth signature was or wasn't verified. */
+export declare const SIGNATURE_RESULTS: readonly ["verified", "unknown_signer", "bad_signature", "expired", "replayed", "wrong_authority", "malformed", "key_unavailable"];
+export type SignatureResult = (typeof SIGNATURE_RESULTS)[number];
+/**
+ * A request that named a Web Bot Auth signer. `signature_verified` means the collector checked
+ * the signature against an allowlisted signer's published key; `signature_claimed` means it
+ * couldn't, and `result` says why; `cdn_reported` means the host passed on its CDN's verdict.
+ * A signature identifies the operator only, never the person or account it acts for.
+ */
+export interface SignatureEvent extends EventBase {
+    type: "signature";
+    source: "server";
+    evidence: "signature_verified" | "signature_claimed" | "cdn_reported";
+    /** The allowlisted signer's name, such as ChatGPT agent, when known. */
+    signer: string | null;
+    /** The key directory the request named in Signature-Agent. */
+    signatureAgent: string | null;
+    result: SignatureResult;
+    /** The CDN that vouched for a cdn_reported event. */
+    verifier: string | null;
+    /** The signed request's path, masked like a page view's. */
+    path: string | null;
+}
+/**
+ * Heuristic automation signals. Each is evidence, never identity: an automated browser isn't
+ * necessarily an AI agent, and a user agent that names one is only a claim anyone can make.
+ */
+export declare const SIGNALS: readonly ["webdriver", "headless_browser", "agent_user_agent", "http_client", "synthetic_input"];
+export type Signal = (typeof SIGNALS)[number];
+/** The signals a page can observe itself. */
+export declare const BROWSER_SIGNALS: readonly Signal[];
+/**
+ * Whether a request that named an agent came from the addresses that agent's operator publishes:
+ * "operator" when it did, "elsewhere" when it didn't, which means the name was likely forged.
+ */
+export declare const ADDRESS_CHECKS: readonly ["operator", "elsewhere"];
+export type AddressCheck = (typeof ADDRESS_CHECKS)[number];
+export declare function isAddressCheck(value: unknown): value is AddressCheck;
+export interface SignalEvent extends EventBase {
+    type: "signal";
+    evidence: "browser_reported" | "host_reported";
+    signal: Signal;
+    /** What triggered it, such as the user agent's ChatGPT-User token. */
+    detail: string | null;
+    /** 0.9.0: for a server's report, the masked path of the page requested. Null from a page. */
+    path: string | null;
+    /**
+     * For a server-reported agent user agent sent with the visitor's address, whether that address
+     * is on the agent's operator's published list. Null when it wasn't checked.
+     */
+    address: AddressCheck | null;
+}
+export type ActivityEvent = DeclarationEvent | PageViewEvent | ActionEvent | SignatureEvent | SignalEvent;
+export declare const MAX_PATH = 512;
+/**
+ * A page path safe to collect: the query and fragment are dropped, and segments that look
+ * like IDs become `:id`. Masking only catches what looks like an ID, so hosts with other
+ * personal segments should supply their own route pattern.
+ */
+export declare function routePath(path: string): string;
+export declare function isRoutePattern(value: unknown): value is string;
+/** Account and resource references are opaque IDs, never names or email addresses. */
+export declare function isReference(value: unknown): value is string;
+export declare function isActionName(value: unknown): value is string;
+export declare function isSignatureResult(value: unknown): value is SignatureResult;
+export declare function isSignal(value: unknown): value is Signal;
+/**
+ * User agent tokens that AI agents and AI crawlers publish for themselves. Matching one means the
+ * request claims to be that agent, which anyone can do, so it's a signal, never verification.
+ */
+export declare const AGENT_USER_AGENT_TOKENS: readonly ["Claude-Agent", "ChatGPT-User", "OAI-SearchBot", "GPTBot", "Claude-User", "Claude-SearchBot", "ClaudeBot", "Perplexity-User", "PerplexityBot", "MistralAI-User", "DuckAssistBot"];
+/**
+ * Coding agents that fetch pages from the developer's own machine, named by a product token in
+ * their user agent. Claude Code sends "Claude-User (claude-code/2.1.317; …)" from wherever it
+ * runs, so it's named on its own rather than checked against Anthropic's server addresses.
+ */
+export declare const CODING_AGENT_PRODUCTS: readonly [RegExp, string][];
+/** The signals a user agent string carries on its own. */
+export declare function userAgentSignals(userAgent: string): {
+    signal: Signal;
+    detail: string;
+}[];
+export declare function isOutcome(value: unknown): value is Outcome;
+/** Reads an agent's self-description. Missing or empty fields are unknown; null means invalid. */
+export declare function agentClaim(value: unknown): AgentClaim | null;
+/**
+ * Since 0.7.0, a server can link a report to the page it served: it puts a random link in the
+ * response's Server-Timing header under this name, and sends the same link with the report.
+ * Only the browser that received the page can read it, so its page script can claim the report.
+ */
+export declare const LINK_TIMING = "agent-id";
+/** 128 random bits, base64url without padding. */
+export declare function isLink(value: unknown): value is string;
+export {};

package/dist/types/react/index.d.ts

@@ -0,0 +1,7 @@
+import { type WidgetOptions } from "../browser/index.js";
+export interface AgentIdentificationProps extends Omit<WidgetOptions, "container"> {
+    className?: string;
+    id?: string;
+}
+/** Optional React integration; all network and DOM work happens after mount. */
+export declare function AgentIdentification({ className, id, onRecorded, onError, ...options }: AgentIdentificationProps): import("react").JSX.Element;

package/dist/types/server/activity.d.ts

@@ -0,0 +1,40 @@
+import { type Outcome } from "../protocol.js";
+export interface ActionReportOptions {
+    apiUrl: string;
+    siteId: string;
+    /** The site's server secret. Never use it in browser code. */
+    secret: string;
+    /** Called when a report fails. Defaults to a console warning without any secret. */
+    onError?: (error: Error) => void;
+    fetch?: typeof globalThis.fetch;
+}
+export interface ReportedAction {
+    /** Your name for it, lowercase, such as ticket.update. */
+    action: string;
+    /** attempted, rejected, or confirmed once your application says it succeeded. */
+    outcome: Outcome;
+    /** Your opaque ID for what it acted on, never a name or email address. */
+    resourceRef?: string;
+    /** Your opaque ID for the account used. It never says who delegated an agent. */
+    accountRef?: string;
+    /** Your server's own session binding, the one you put in binding contexts. */
+    sessionBinding?: string;
+    /** Reuse the same ID to retry; a new one is chosen when missing. */
+    id?: string;
+    occurredAt?: Date;
+}
+export type ActionReport = {
+    status: "recorded";
+    id: string;
+    sessionId: string | null;
+    duplicate: boolean;
+} | {
+    status: "failed";
+    id: string;
+    error: Error;
+};
+/**
+ * Reports what your server did, so it joins the session's activity. It retries with the same
+ * ID, never throws, and only says recorded when the collector confirms it.
+ */
+export declare function reportAction(input: ReportedAction, options: ActionReportOptions): Promise<ActionReport>;

package/dist/types/server/index.d.ts

@@ -0,0 +1,16 @@
+export { createBindingContext, verifyDeclaration } from "./tokens.js";
+export type { BindingOptions, DeclarationClaims } from "./tokens.js";
+export { verifyDeclarationOnline } from "./online.js";
+export type { OnlineVerificationOptions } from "./online.js";
+export { reportAction } from "./activity.js";
+export type { ActionReport, ActionReportOptions, ReportedAction } from "./activity.js";
+export { reportSignedRequest } from "./web-bot-auth.js";
+export { reportRequestSignals } from "./signals.js";
+export { reportLink, serverTiming } from "./links.js";
+export { agentIdentification, DEFAULT_COLLECTOR } from "./setup.js";
+export type { AgentIdentification, AgentIdentificationOptions, RequestReportOptions, } from "./setup.js";
+export type { SignalReport, SignalReportOptions } from "./signals.js";
+export type { ReportableRequest, SignatureReport, SignatureReportOptions } from "./web-bot-auth.js";
+export { routePath, userAgentSignals, isLink, AGENT_USER_AGENT_TOKENS, LINK_TIMING, } from "../protocol.js";
+export type { ActionEvent, ActivityEvent, AgentClaim, DeclarationEvent, EventSource, EventType, Evidence, Outcome, PageViewEvent, Signal, SignalEvent, SignatureEvent, SignatureResult, } from "../protocol.js";
+export type { AddressCheck } from "../protocol.js";

package/dist/types/server/links.d.ts

@@ -0,0 +1,12 @@
+import { type ReportableRequest } from "./web-bot-auth.js";
+/**
+ * A new link for a request that reportSignedRequest or reportRequestSignals will report: one that
+ * is signed or names an AI agent in its user agent, for a page rather than an asset. Pass it to
+ * both, and put it in the response with serverTiming(), so the page script in the browser that
+ * gets the page can join those reports to its visit. Null for every other request.
+ */
+export declare function reportLink(request: ReportableRequest, options?: {
+    url?: string;
+}): string | null;
+/** The Server-Timing header value that carries a link to the page script. */
+export declare function serverTiming(link: string): string;

package/dist/types/server/online.d.ts

@@ -0,0 +1,13 @@
+import { type BindingOptions, type DeclarationClaims } from "./tokens.js";
+export interface OnlineVerificationOptions extends Omit<BindingOptions, "expiresInSeconds"> {
+    apiUrl: string;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Verify the signature, actual host-session binding, and current collector state.
+ * Call from your server immediately before the protected action, after checking
+ * the user's ordinary permissions. Any error must deny/defer that action.
+ */
+export declare function verifyDeclarationOnline(receipt: string, options: OnlineVerificationOptions): Promise<DeclarationClaims & {
+    bindingHash: string;
+}>;

package/dist/types/server/setup.d.ts

@@ -0,0 +1,60 @@
+import { type ActionReport, type ReportedAction } from "./activity.js";
+import { type ReportableRequest } from "./web-bot-auth.js";
+/** The hosted collector, used unless you pass apiUrl or set AGENT_ID_API_URL. */
+export declare const DEFAULT_COLLECTOR = "https://parallel-agent-identification.vercel.app";
+export interface AgentIdentificationOptions {
+    /** Your public site ID. Defaults to the AGENT_ID_SITE_ID environment variable. */
+    siteId?: string;
+    /** Your server secret. Defaults to AGENT_ID_SITE_SECRET. Never put it in browser code. */
+    secret?: string;
+    /** The collector. Defaults to AGENT_ID_API_URL, then the hosted collector. */
+    apiUrl?: string;
+    /** Called when a report fails. Defaults to a console warning without any secret. */
+    onError?: (error: Error) => void;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RequestReportOptions {
+    /** The URL the visitor asked for, if your framework rewrites the request's own. */
+    url?: string;
+    /**
+     * The visitor's IP address as your platform gives it, never from a header visitors can set.
+     * It's sent only with a request that names an agent, to check it against the agent's
+     * operator's published addresses, and the collector keeps only the result.
+     */
+    clientIp?: string | null;
+    /** Your server's own session binding, as in the page script's binding context. */
+    sessionBinding?: string;
+    /** Keeps the reports running after the response, such as Next.js's event.waitUntil. */
+    waitUntil?: (work: Promise<unknown>) => void;
+}
+export interface AgentIdentification {
+    /**
+     * Reports one request: a signed agent's signature, and an agent or automation its user agent
+     * names. Ordinary requests and assets are skipped without a network call. Returns the
+     * Server-Timing value to add to this page's response, or null, so the page script can join the
+     * reports to its visit. It never throws and never waits for the collector.
+     */
+    report(request: ReportableRequest, options?: RequestReportOptions): string | null;
+    /** Express or Connect middleware that reports every request. */
+    express(): (request: ReportableRequest & {
+        ip?: string;
+    }, response: {
+        append(name: string, value: string): unknown;
+    }, next: () => void) => void;
+    /**
+     * For a Next.js proxy: reports the request and adds the link to your response. On Vercel it
+     * passes the visitor's address from x-real-ip, which Vercel sets; elsewhere pass clientIp.
+     */
+    next<T extends {
+        headers: Headers;
+    }>(request: Request, event: {
+        waitUntil(work: Promise<unknown>): void;
+    }, response: T, options?: Pick<RequestReportOptions, "clientIp" | "sessionBinding">): T;
+    /** Reports an action your server handled, such as an order placed. Never throws. */
+    action(input: ReportedAction): Promise<ActionReport>;
+}
+/**
+ * Sets up agent identification in one call, from AGENT_ID_SITE_ID and AGENT_ID_SITE_SECRET unless
+ * you pass them. Use .express() as middleware, or .next() in a Next.js proxy.
+ */
+export declare function agentIdentification(options?: AgentIdentificationOptions): AgentIdentification;

package/dist/types/server/signals.d.ts

@@ -0,0 +1,50 @@
+import { type AddressCheck, type Signal } from "../protocol.js";
+import { type ReportableRequest } from "./web-bot-auth.js";
+export interface SignalReportOptions {
+    apiUrl: string;
+    siteId: string;
+    /** The site's server secret. Never use it in browser code. */
+    secret: string;
+    /** Your server's own session binding, the one you put in binding contexts. */
+    sessionBinding?: string;
+    /** From reportLink(), so the page script can join these signals to its visit. */
+    link?: string | null;
+    /**
+     * The visitor's IP address, as your platform gives it to you: on Vercel the x-real-ip header,
+     * in Express req.ip, in Node.js req.socket.remoteAddress. Never use a header a visitor can set
+     * themselves. It's sent only when the user agent names an agent whose operator publishes its
+     * addresses, so the collector can check the claim. The collector keeps the result, not the
+     * address.
+     */
+    clientIp?: string | null;
+    /**
+     * The URL the visitor asked for, when your framework changes the request's own (Next.js uses
+     * localhost). Its masked path goes with the report, so you can see which pages agents fetched.
+     */
+    url?: string;
+    /** Called when a report fails. Defaults to a console warning without any secret. */
+    onError?: (error: Error) => void;
+    fetch?: typeof globalThis.fetch;
+}
+export type SignalReport = {
+    status: "skipped";
+} | {
+    status: "recorded";
+    signals: {
+        signal: Signal;
+        detail: string | null;
+        /** Whether the request came from the agent's operator's published addresses, if checked. */
+        address: AddressCheck | null;
+    }[];
+} | {
+    status: "failed";
+    error: Error;
+};
+/**
+ * Reports what a request's user agent says about automation: a token an AI agent publishes for
+ * itself, such as ChatGPT-User, or a headless browser. Anyone can send those, so they're
+ * signals. With clientIp, the collector also checks a named agent against the addresses its
+ * operator publishes, which a forged user agent can't pass. Requests with neither, and asset
+ * requests, are skipped without a network call. It retries with the same IDs and never throws.
+ */
+export declare function reportRequestSignals(request: ReportableRequest, options: SignalReportOptions): Promise<SignalReport>;

package/dist/types/server/tokens.d.ts

@@ -0,0 +1,59 @@
+import { type Choice } from "../protocol.js";
+export interface SiteConfig {
+    id: string;
+    origins: string[];
+    secret: string;
+}
+export interface BindingOptions {
+    siteId: string;
+    origin: string;
+    secret: string;
+    /** An opaque value derived by your server from its current authenticated session. */
+    sessionBinding: string;
+    now?: Date;
+    expiresInSeconds?: number;
+}
+interface CommonClaims {
+    v: 1;
+    siteId: string;
+    origin: string;
+    iat: number;
+    exp: number;
+}
+export interface ContextClaims extends CommonClaims {
+    purpose: "binding_context";
+    bindingHash: string;
+}
+export interface DeclarationClaims extends CommonClaims {
+    purpose: "declaration";
+    sessionId: string;
+    eventId: string;
+    choice: Choice;
+    bindingHash: string | null;
+    evidence: "self_reported";
+}
+export declare function isUuid(value: unknown): value is string;
+export declare function isSiteId(value: unknown): value is string;
+export declare function isAllowedOrigin(value: unknown): value is string;
+export declare function validateSite(site: SiteConfig): void;
+export declare function hashToken(token: string): string;
+export declare function hashBinding(siteId: string, binding: string): string;
+export declare function secretEquals(actual: string, expected: string): boolean;
+/** Mint on your server only, using its current session rather than browser input. */
+export declare function createBindingContext(options: BindingOptions): string;
+export declare function verifyBindingContext(token: string, expected: {
+    siteId: string;
+    origin: string;
+    secret: string;
+    now?: Date;
+}): ContextClaims;
+export declare function mintDeclaration(claims: Omit<DeclarationClaims, "v" | "purpose" | "evidence">, secret: string): string;
+/**
+ * Verify a bound receipt against your server's actual current session.
+ * A valid declaration is self-reported and does not establish authorization.
+ * Receipts remain valid until expiry; use online status for immediate revocation.
+ */
+export declare function verifyDeclaration(receipt: string, expected: Omit<BindingOptions, "expiresInSeconds">): DeclarationClaims & {
+    bindingHash: string;
+};
+export {};

package/dist/types/server/web-bot-auth.d.ts

@@ -0,0 +1,50 @@
+import type { SignatureEvent } from "../protocol.js";
+/** A request as a server framework sees it: a Fetch Request, or Node's IncomingMessage. */
+export type ReportableRequest = Request | {
+    method?: string;
+    url?: string;
+    originalUrl?: string;
+    protocol?: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+export interface SignatureReportOptions {
+    apiUrl: string;
+    siteId: string;
+    /** The site's server secret. Never use it in browser code. */
+    secret: string;
+    /** The collector session, when your server knows it. */
+    sessionId?: string;
+    /** Your opaque ID for the account used, never a name or email address. */
+    accountRef?: string;
+    /** The URL the visitor requested, when a proxy rewrote the request's own. */
+    url?: string;
+    /** From reportLink(), so the page script can join this report to its visit. */
+    link?: string | null;
+    /**
+     * Also report scripts, styles, images and other assets. Off by default, so one page load
+     * counts as one signed request.
+     */
+    includeAssets?: boolean;
+    /** Called when a report fails. Defaults to a console warning without any secret. */
+    onError?: (error: Error) => void;
+    fetch?: typeof globalThis.fetch;
+}
+export type SignatureReport = {
+    status: "skipped";
+} | {
+    status: "recorded";
+    event: SignatureEvent;
+} | {
+    status: "failed";
+    error: Error;
+};
+/** Scripts, styles, images and the like, so one page load counts once. */
+export declare function isAssetRequest(url: string, headers: Record<string, string>): boolean;
+export declare function headerMap(request: ReportableRequest): Record<string, string>;
+export declare function requestUrl(request: ReportableRequest, headers: Record<string, string>): string;
+/**
+ * Reports a request that carries a Web Bot Auth signature so the collector can check it.
+ * A request without one is skipped without a network call. It never throws, so run it without
+ * awaiting, or in waitUntil, and the visitor's response never waits for it.
+ */
+export declare function reportSignedRequest(request: ReportableRequest, options: SignatureReportOptions): Promise<SignatureReport>;

package/package.json

@@ -1,6 +1,97 @@
 {
   "name": "@useparallel/agent-identification",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.0",
+  "description": "See which AI agents use your website: report agents from your server, record visits with a page script that draws nothing, and verify signed agents and operators' published addresses.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "ai-agents",
+    "agent-identification",
+    "web-bot-auth",
+    "bot-detection",
+    "analytics",
+    "http-message-signatures"
+  ],
+  "homepage": "https://parallel-agent-dashboard.vercel.app/docs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Parallel-AI-Research/agent-identification.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/browser/index.js",
+  "types": "./dist/types/browser/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/browser/index.d.ts",
+      "import": "./dist/browser/index.js"
+    },
+    "./react": {
+      "types": "./dist/types/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    },
+    "./server": {
+      "types": "./dist/types/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./styles.css": "./dist/agent-id.css",
+    "./script": "./dist/agent-id.js",
+    "./track-script": "./dist/agent-id-track.js",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "react": ">=18 <20"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings=0",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "test": "node --import tsx --test tests/*.test.ts tests/*.test.mjs",
+    "test:e2e": "playwright test",
+    "smoke:hosted": "node scripts/smoke-hosted.mjs",
+    "test:package": "node scripts/test-package.mjs",
+    "check": "npm run build && npm run typecheck && npm run lint && npm run format:check && npm test && npm run test:package",
+    "dev:collector": "node --import tsx scripts/dev-server.ts",
+    "site:create": "node scripts/site-config.mjs",
+    "sites:import": "node --import tsx scripts/import-sites.ts",
+    "events": "node scripts/events.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "0.5.10",
+    "@electric-sql/pglite-socket": "0.2.13",
+    "@eslint/js": "10.0.1",
+    "@playwright/test": "1.64.1",
+    "@types/jsdom": "30.0.0",
+    "@types/node": "26.6.5",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "esbuild": "0.28.2",
+    "eslint": "10.13.0",
+    "globals": "17.13.0",
+    "jose": "6.2.14",
+    "jsdom": "30.1.3",
+    "postgres": "3.4.9",
+    "prettier": "3.9.10",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "tsx": "4.23.15",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.0"
+  }
+}