@paygentic/wrap 0.1.0

package/dist/customer.d.ts

@@ -0,0 +1,108 @@
+import type { createApiClient } from "./api/index.js";
+import { components } from "./api/schema.js";
+type ApiClient = ReturnType<typeof createApiClient>;
+export declare function createCustomerMethods(api: ApiClient): {
+    create: (data: components["schemas"]["Customer"]) => Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    consumer?: {
+                        name: string;
+                        email: string;
+                        phone?: string;
+                        address: components["schemas"]["Address"];
+                    };
+                    consumerId?: components["schemas"]["OrganizationId"];
+                    merchantId: components["schemas"]["OrganizationId"];
+                    taxId?: string;
+                    taxRates?: components["schemas"]["TaxRates"];
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        customerId: string;
+                        validTaxAddress: components["schemas"]["ValidTaxAddress"];
+                    };
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        customerId: string;
+                        validTaxAddress: components["schemas"]["ValidTaxAddress"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    }, {
+        body: {
+            id: components["schemas"]["CustomerId"];
+            object: "customer";
+            consumerId: components["schemas"]["OrganizationId"];
+            createdAt: string;
+            merchantId: components["schemas"]["OrganizationId"];
+            organization?: {
+                id: string;
+                address?: components["schemas"]["Address"];
+                billingEmail?: string;
+                name: string;
+                phone?: string;
+            };
+            taxId?: string;
+            taxRates?: components["schemas"]["TaxRates"];
+            updatedAt: string;
+            validTaxAddress: components["schemas"]["ValidTaxAddress"];
+        };
+    }, `${string}/${string}`>>;
+    get: (id: string) => Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["schemas"]["CustomerId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Customer"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export {};
+//# sourceMappingURL=customer.d.ts.map

package/dist/customer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customer.d.ts","sourceRoot":"","sources":["../src/customer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;AAEpD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,SAAS;mBAEjC,UAAU,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC;;iBAIq/8F,CAAC;kBAA2B,CAAC;gBAAyB,CAAC;kBAA2B,CAAC;;;;;4BAA0b,CAAC;;;6BAA2e,CAAC;iCAA2U,qBAAsB;;8BAA0L,CAAC,EAAC,qBAAsB;gCAAgJ,qBAAsB;yBAA+U,CAAC;4BAAsC,CAAC,EAAC,qBAAsB;;;;;;;;;;;;yCAA+uB,qBAAsB;;;;;;;;;;;yCAAmvB,qBAAsB;;;;iBAA8F,uBAAwB;iBAAgC,uBAAwB;iBAA+B,uBAAwB;iBAA8B,uBAAwB;;;;gBAA39qE,qBAAsB;;wBAAsK,qBAAsB;;wBAA+G,qBAAsB;;;uBAAoG,CAAC,EAAC,qBAAsB;4BAAyC,CAAC;;qBAA6D,CAAC;;;uBAAuU,qBAAsB;;6BAA8G,qBAAsB;;;cAHt+7B,MAAM;;iBAGoglG,CAAC;kBAA2B,CAAC;;oBAA2H,qBAAsB;;kBAAiD,CAAC;;;;;;;;;wCAAwnC,qBAAsB;;;iBAAgE,uBAAwB;iBAA+B,uBAAwB;iBAA8B,uBAAwB;;;;;;;;;EAD1koG"}

package/dist/customer.js

@@ -0,0 +1,7 @@
+export function createCustomerMethods(api) {
+    return {
+        create: (data) => api.POST('/v0/customers', { body: data }),
+        get: (id) => api.GET('/v0/customers/{id}', { params: { path: { id } } }),
+    };
+}
+//# sourceMappingURL=customer.js.map

package/dist/customer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"customer.js","sourceRoot":"","sources":["../src/customer.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,qBAAqB,CAAC,GAAc;IAClD,OAAO;QACL,MAAM,EAAE,CAAC,IAAuC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QAC9F,GAAG,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;KACjF,CAAC;AACJ,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Error thrown when a customer has insufficient funds to process a query.
+ * Includes portal URL so customers can easily top up their balance.
+ */
+export declare class InsufficientFundsError extends Error {
+    readonly portalUrl: string;
+    readonly portalExpiresAt: string;
+    readonly subscriptionId: string;
+    constructor(message: string, portalUrl: string, portalExpiresAt: string, subscriptionId: string);
+}
+/**
+ * Checks if an error is an insufficient funds error based on the error message.
+ */
+export declare function isInsufficientFundsError(error: unknown): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,eAAe,EAAE,MAAM,CAAC;IACxC,SAAgB,cAAc,EAAE,MAAM,CAAC;gBAGrC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM;CAQzB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAOhE"}

package/dist/errors.js

@@ -0,0 +1,28 @@
+/**
+ * Error thrown when a customer has insufficient funds to process a query.
+ * Includes portal URL so customers can easily top up their balance.
+ */
+export class InsufficientFundsError extends Error {
+    portalUrl;
+    portalExpiresAt;
+    subscriptionId;
+    constructor(message, portalUrl, portalExpiresAt, subscriptionId) {
+        super(message);
+        this.name = 'InsufficientFundsError';
+        this.portalUrl = portalUrl;
+        this.portalExpiresAt = portalExpiresAt;
+        this.subscriptionId = subscriptionId;
+    }
+}
+/**
+ * Checks if an error is an insufficient funds error based on the error message.
+ */
+export function isInsufficientFundsError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = error.message.toLowerCase();
+    return message.includes('insufficient') ||
+        (message.includes('balance') && (message.includes('low') || message.includes('not enough')));
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC/B,SAAS,CAAS;IAClB,eAAe,CAAS;IACxB,cAAc,CAAS;IAEvC,YACE,OAAe,EACf,SAAiB,EACjB,eAAuB,EACvB,cAAsB;QAEtB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAc;IACrD,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;QAChC,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AACtG,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+export type { RedirectUrls, CreateSubscriptionOptions, CustomerDetails } from "./subscription.js";
+export { InsufficientFundsError } from "./errors.js";
+interface WrapClientOptions {
+    apiKey?: string;
+    env?: 'prod' | 'sandbox';
+}
+export declare function createWrapClient(options?: WrapClientOptions): {
+    subscriptions: {
+        create: (options: import("./subscription.js").CreateSubscriptionOptions) => Promise<import("./subscription.js").CreateCustomerAndSubscriptionResult>;
+        get: (customerId: string, planIdParam?: string) => Promise<{
+            id?: string;
+            object?: "subscription";
+            autoCharge: boolean;
+            createdAt?: string;
+            customerId?: string;
+            endingAt?: string;
+            estimatedTaxRate?: number;
+            taxExempt: boolean;
+            name?: string;
+            payment?: {
+                amount: string;
+                breakdown: {
+                    upfrontCharges: string;
+                    walletCharge: string;
+                };
+                checkoutUrl: string;
+                paymentSessionId: string;
+                status: "pending";
+            };
+            planId?: string;
+            prefundAmount?: string;
+            minimumAccountBalance?: string;
+            startedAt?: string;
+            status?: "pending_payment" | "active" | "terminated";
+            terminatedAt?: string;
+            terminatedBy?: string;
+            terminationReason?: string;
+            testClockId?: string;
+            updatedAt?: string;
+            walletId?: string;
+            renewalReminderEnabled?: boolean | null;
+            renewalReminderDays?: number | null;
+        } | null>;
+        findCustomer: (email: string, merchantIdParam?: string) => Promise<string | null>;
+        portal: (subscriptionId: string) => Promise<import("./subscription.js").PortalUrlResult>;
+    };
+    plans: {
+        init: (options?: import("./plan.js").InitPlanOptions) => Promise<{
+            wrap: (customerId: string) => (params: {
+                prompt: string | AsyncIterable<import("@anthropic-ai/claude-agent-sdk").SDKUserMessage>;
+                options?: import("@anthropic-ai/claude-agent-sdk").Options;
+            }) => Promise<import("@anthropic-ai/claude-agent-sdk").Query>;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,YAAY,EAAE,yBAAyB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAClG,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAErD,UAAU,iBAAiB;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/D"}

package/dist/index.js

@@ -0,0 +1,17 @@
+import { createApiClient } from "./api/index.js";
+import { createSubscriptionMethods } from "./subscription.js";
+import { createPlanMethods } from "./plan.js";
+export { InsufficientFundsError } from "./errors.js";
+export function createWrapClient(options = {}) {
+    const apiKey = options.apiKey ?? process.env.PAYGENTIC_WRAP_API_KEY;
+    const env = options.env ?? process.env.PAYGENTIC_WRAP_ENV ?? 'prod';
+    if (!apiKey) {
+        throw new Error('API key required: pass apiKey option or set PAYGENTIC_WRAP_API_KEY');
+    }
+    const api = createApiClient(apiKey, env);
+    return {
+        subscriptions: createSubscriptionMethods(api),
+        plans: createPlanMethods(api),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAOrD,MAAM,UAAU,gBAAgB,CAAC,UAA6B,EAAE;IAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;IACpE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAK,OAAO,CAAC,GAAG,CAAC,kBAAyC,IAAI,MAAM,CAAC;IAE5F,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,GAAG,GAAG,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACzC,OAAO;QACL,aAAa,EAAE,yBAAyB,CAAC,GAAG,CAAC;QAC7C,KAAK,EAAE,iBAAiB,CAAC,GAAG,CAAC;KAC9B,CAAC;AACJ,CAAC"}

package/dist/logCosts.d.ts

@@ -0,0 +1,12 @@
+import { query, Query, SDKResultMessage } from "@anthropic-ai/claude-agent-sdk";
+type QueryParams = Parameters<typeof query>[0];
+type CostLogger = (result: SDKResultMessage) => void;
+/**
+ * Wrapper around query() that captures and logs cost information from the result.
+ * Returns the full Query object with all methods (interrupt, setModel, etc.)
+ * while intercepting the result message for cost logging.
+ * Uses a Proxy to automatically forward any new Query methods.
+ */
+export declare function queryWithCostLogging(params: QueryParams, onCost?: CostLogger): Query;
+export {};
+//# sourceMappingURL=logCosts.d.ts.map

package/dist/logCosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logCosts.d.ts","sourceRoot":"","sources":["../src/logCosts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAc,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAE5F,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAErD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,KAAK,CAkCpF"}

package/dist/logCosts.js

@@ -0,0 +1,61 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * Wrapper around query() that captures and logs cost information from the result.
+ * Returns the full Query object with all methods (interrupt, setModel, etc.)
+ * while intercepting the result message for cost logging.
+ * Uses a Proxy to automatically forward any new Query methods.
+ */
+export function queryWithCostLogging(params, onCost) {
+    const agentQuery = query(params);
+    // Create a wrapped async iterator that intercepts result messages
+    async function* wrappedIterator() {
+        for await (const message of agentQuery) {
+            if (message.type === "result") {
+                const result = message;
+                if (onCost) {
+                    onCost(result);
+                }
+                else {
+                    logDetailedCost(result);
+                }
+            }
+            yield message;
+        }
+    }
+    const iterator = wrappedIterator();
+    // Use Proxy to forward all methods while overriding iterator behavior
+    return new Proxy(agentQuery, {
+        get(target, prop) {
+            // Override iterator methods to use our wrapped iterator
+            if (prop === Symbol.asyncIterator)
+                return () => iterator;
+            if (prop === "next")
+                return () => iterator.next();
+            if (prop === "return")
+                return (value) => iterator.return(value);
+            if (prop === "throw")
+                return (error) => iterator.throw(error);
+            // Forward everything else to the original query
+            const value = Reflect.get(target, prop);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
+function logDetailedCost(result) {
+    const timestamp = new Date().toISOString();
+    const cost = `$${result.total_cost_usd.toFixed(9)}`;
+    const { usage } = result;
+    console.log(`[${timestamp}] SESSION COMPLETE | ${result.session_id}`);
+    console.log(`  Cost: ${cost}`);
+    console.log(`  Turns: ${result.num_turns}`);
+    console.log(`  Tokens: ${usage.input_tokens} in / ${usage.output_tokens} out`);
+    console.log(`  Cache: ${usage.cache_read_input_tokens} read / ${usage.cache_creation_input_tokens} created`);
+    // Log per-model usage if multiple models were used
+    if (Object.keys(result.modelUsage).length > 1) {
+        console.log(`  Per-model breakdown:`);
+        for (const [model, modelUsage] of Object.entries(result.modelUsage)) {
+            console.log(`    ${model}: $${modelUsage.costUSD.toFixed(4)}`);
+        }
+    }
+}
+//# sourceMappingURL=logCosts.js.map

package/dist/logCosts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logCosts.js","sourceRoot":"","sources":["../src/logCosts.ts"],"names":[],"mappings":"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"}

package/dist/plan.d.ts

@@ -0,0 +1,27 @@
+import { query, Query } from "@anthropic-ai/claude-agent-sdk";
+import type { createApiClient } from "./api/index.js";
+type QueryParams = Parameters<typeof query>[0];
+type ApiClient = ReturnType<typeof createApiClient>;
+export interface InitPlanOptions {
+    priceId?: string;
+    planId?: string;
+}
+/**
+ * Creates plan methods for the Wrap client.
+ */
+export declare function createPlanMethods(api: ApiClient): {
+    /**
+     * Initialize a plan for wrapping agent queries with payment tracking.
+     *
+     * Validates:
+     * - Plan exists and contains the specified price
+     * - Price model is 'dynamic' or 'percentage'
+     * - For dynamic: maxPrice >= $0.20
+     * - For percentage: percentage >= 0, minCharge <= maxCharge, maxCharge >= $0.20
+     */
+    init: (options?: InitPlanOptions) => Promise<{
+        wrap: (customerId: string) => (params: QueryParams) => Promise<Query>;
+    }>;
+};
+export {};
+//# sourceMappingURL=plan.d.ts.map

package/dist/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../src/plan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAgC,MAAM,gCAAgC,CAAC;AAC5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;AAMpD,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAoGD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,SAAS;IAE5C;;;;;;;;OAQG;qBACmB,eAAe;2BAsId,MAAM,cAwBY,WAAW,KAAG,OAAO,CAAC,KAAK,CAAC;;EApBxE"}

package/dist/plan.js

@@ -0,0 +1,279 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { createSubscriptionMethods } from "./subscription.js";
+import { InsufficientFundsError, isInsufficientFundsError } from "./errors.js";
+async function getPlan(api, planId) {
+    const { data, error } = await api.GET('/v0/plans/{id}', {
+        params: { path: { id: planId } }
+    });
+    if (error) {
+        throw new Error(`Failed to get plan ${planId}: ${JSON.stringify(error)}`);
+    }
+    return data;
+}
+async function getPrice(api, priceId) {
+    const { data, error } = await api.GET('/v0/prices/{id}', {
+        params: { path: { id: priceId } }
+    });
+    if (error) {
+        throw new Error(`Failed to get price ${priceId}: ${JSON.stringify(error)}`);
+    }
+    return data;
+}
+async function createEntitlement(api, customerId, merchantId, billableMetricId, price) {
+    const { data, error } = await api.POST('/v0/entitlements', {
+        body: {
+            customerId,
+            merchantId,
+            entitlementData: [{
+                    billableMetricId,
+                    quantity: 1
+                }],
+            maxUses: 1,
+            price: price.toFixed(6)
+        }
+    });
+    if (error) {
+        throw new Error(`Failed to create entitlement: ${JSON.stringify(error)}`);
+    }
+    return data;
+}
+async function createUsageEvent(api, customerId, merchantId, billableMetricId, cost, entitlementId) {
+    const idempotencyKey = `wrap_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    const { error } = await api.POST('/v0/usage', {
+        body: {
+            customerId,
+            merchantId,
+            idempotencyKey,
+            timestamp: new Date().toISOString(),
+            properties: [{
+                    billableMetricId,
+                    price: cost.toFixed(6),
+                    quantity: 1
+                }],
+            ...(entitlementId && { entitlementId })
+        }
+    });
+    if (error) {
+        throw new Error(`Failed to create usage event: ${JSON.stringify(error)}`);
+    }
+}
+/**
+ * Creates plan methods for the Wrap client.
+ */
+export function createPlanMethods(api) {
+    return {
+        /**
+         * Initialize a plan for wrapping agent queries with payment tracking.
+         *
+         * Validates:
+         * - Plan exists and contains the specified price
+         * - Price model is 'dynamic' or 'percentage'
+         * - For dynamic: maxPrice >= $0.20
+         * - For percentage: percentage >= 0, minCharge <= maxCharge, maxCharge >= $0.20
+         */
+        init: async (options = {}) => {
+            const planId = options.planId ?? process.env.PAYGENTIC_WRAP_PLAN_ID;
+            const priceId = options.priceId ?? process.env.PAYGENTIC_WRAP_PRICE_ID;
+            if (!planId) {
+                throw new Error('Plan ID required: pass planId option or set PAYGENTIC_WRAP_PLAN_ID');
+            }
+            if (!priceId) {
+                throw new Error('Price ID required: pass priceId option or set PAYGENTIC_WRAP_PRICE_ID');
+            }
+            // Validate plan exists
+            const plan = await getPlan(api, planId);
+            if (!plan) {
+                throw new Error(`Plan not found: ${planId}`);
+            }
+            // Validate plan has merchantId
+            if (!plan.merchantId) {
+                throw new Error(`Plan ${planId} missing merchantId`);
+            }
+            const merchantId = plan.merchantId;
+            // Validate plan contains the priceId
+            const priceIds = plan.prices?.map(p => p.id) ?? [];
+            if (!priceIds.includes(priceId)) {
+                throw new Error(`Price ${priceId} not found in plan ${planId}`);
+            }
+            // Get the price details
+            const price = await getPrice(api, priceId);
+            if (!price) {
+                throw new Error(`Price not found: ${priceId}`);
+            }
+            // Validate price model is 'dynamic' or 'percentage'
+            if (price.model !== 'dynamic' && price.model !== 'percentage') {
+                throw new Error(`Price model must be 'dynamic' or 'percentage', got: ${price.model}`);
+            }
+            // Validate price has billableMetricId
+            if (!price.billableMetricId) {
+                throw new Error(`Price ${priceId} missing billableMetricId`);
+            }
+            const billableMetricId = price.billableMetricId;
+            // Determine if payment is in arrears
+            const isArrears = price.paymentTerm === 'in_arrears';
+            let context;
+            if (price.model === 'dynamic') {
+                // Get maxPrice from properties (dynamic price has minPrice/maxPrice)
+                const properties = price.properties;
+                const maxPriceStr = properties?.maxPrice;
+                if (!maxPriceStr) {
+                    throw new Error(`Dynamic price ${priceId} missing maxPrice in properties`);
+                }
+                const maxPrice = parseFloat(maxPriceStr);
+                if (maxPrice < 0.20) {
+                    throw new Error(`Price maxPrice must be >= $0.20, got: $${maxPrice}`);
+                }
+                // Calculate safe cost: 90% of maxPrice or maxPrice - $0.10, whichever is smaller
+                const safeCost = Math.min(maxPrice * 0.9, maxPrice - 0.10);
+                context = {
+                    model: 'dynamic',
+                    plan,
+                    price,
+                    maxPrice,
+                    safeCost,
+                    isArrears,
+                    merchantId,
+                    billableMetricId,
+                };
+            }
+            else {
+                // percentage model
+                const properties = price.properties;
+                const percentageStr = properties?.percentage;
+                const minChargeStr = properties?.minCharge;
+                const maxChargeStr = properties?.maxCharge;
+                if (!percentageStr) {
+                    throw new Error(`Percentage price ${priceId} missing percentage in properties`);
+                }
+                if (!minChargeStr) {
+                    throw new Error(`Percentage price ${priceId} missing minCharge in properties`);
+                }
+                if (!maxChargeStr) {
+                    throw new Error(`Percentage price ${priceId} missing maxCharge in properties`);
+                }
+                const percentage = parseFloat(percentageStr);
+                const minCharge = parseFloat(minChargeStr);
+                const maxCharge = parseFloat(maxChargeStr);
+                if (percentage < 0) {
+                    throw new Error(`Percentage must be >= 0, got: ${percentage}`);
+                }
+                if (minCharge > maxCharge) {
+                    throw new Error(`minCharge ($${minCharge}) must be <= maxCharge ($${maxCharge})`);
+                }
+                if (maxCharge < 0.20) {
+                    throw new Error(`maxCharge must be >= $0.20, got: $${maxCharge}`);
+                }
+                // Calculate maxBudgetUsd: usage_cost * (1 + percentage) <= maxCharge
+                // So: usage_cost <= maxCharge / (1 + percentage)
+                const maxBudgetUsd = maxCharge / (1 + percentage);
+                const safeCost = Math.min(maxBudgetUsd * 0.9, maxBudgetUsd - 0.10);
+                context = {
+                    model: 'percentage',
+                    plan,
+                    price,
+                    percentage,
+                    minCharge,
+                    maxCharge,
+                    maxBudgetUsd,
+                    safeCost,
+                    isArrears,
+                    merchantId,
+                    billableMetricId,
+                };
+            }
+            return {
+                wrap: (customerId) => createWrappedQuery(api, customerId, planId, context),
+            };
+        },
+    };
+}
+function calculateCharge(totalCost, context) {
+    if (context.model === 'dynamic') {
+        return totalCost;
+    }
+    const rawCharge = totalCost * (1 + context.percentage);
+    return Math.min(Math.max(rawCharge, context.minCharge), context.maxCharge);
+}
+function getMaxCharge(context) {
+    return context.model === 'dynamic' ? context.maxPrice : context.maxCharge;
+}
+function createWrappedQuery(api, customerId, planId, context) {
+    return async function wrappedQuery(params) {
+        const subscriptionMethods = createSubscriptionMethods(api);
+        // Validate customer has active subscription to this plan
+        const subscription = await subscriptionMethods.get(customerId, planId);
+        if (!subscription) {
+            throw new Error(`Customer ${customerId} does not have an active subscription to plan ${planId}`);
+        }
+        if (!subscription.id) {
+            throw new Error(`Subscription for customer ${customerId} missing id`);
+        }
+        const subscriptionId = subscription.id;
+        // For pre-paid (non-arrears), create entitlement first
+        let entitlement;
+        if (!context.isArrears) {
+            try {
+                entitlement = await createEntitlement(api, customerId, context.merchantId, context.billableMetricId, getMaxCharge(context));
+            }
+            catch (error) {
+                if (isInsufficientFundsError(error)) {
+                    const portal = await subscriptionMethods.portal(subscriptionId);
+                    throw new InsufficientFundsError('Insufficient funds to process query. Please top up your balance.', portal.url, portal.expiresAt, subscriptionId);
+                }
+                throw error;
+            }
+        }
+        // Pass safeCost in options.maxBudgetUsd
+        const wrappedParams = {
+            ...params,
+            options: {
+                ...params.options,
+                maxBudgetUsd: context.safeCost,
+            },
+        };
+        const agentQuery = query(wrappedParams);
+        // Create a wrapped async iterator that intercepts result messages for cost tracking
+        async function* wrappedIterator() {
+            for await (const message of agentQuery) {
+                if (message.type === "result") {
+                    const result = message;
+                    const totalCost = result.total_cost_usd;
+                    const charge = calculateCharge(totalCost, context);
+                    const maxCharge = getMaxCharge(context);
+                    // Handle overage: if charge > maxCharge, split into two usage events
+                    if (charge > maxCharge) {
+                        const overageAmount = charge - maxCharge;
+                        // First event: maxCharge amount
+                        await createUsageEvent(api, customerId, context.merchantId, context.billableMetricId, maxCharge, entitlement?.id);
+                        // Second event: overage amount (no entitlement)
+                        await createUsageEvent(api, customerId, context.merchantId, context.billableMetricId, overageAmount);
+                    }
+                    else {
+                        // Single usage event for the calculated charge
+                        await createUsageEvent(api, customerId, context.merchantId, context.billableMetricId, charge, entitlement?.id);
+                    }
+                }
+                yield message;
+            }
+        }
+        const iterator = wrappedIterator();
+        // Use Proxy to forward all methods while overriding iterator behavior
+        return new Proxy(agentQuery, {
+            get(target, prop) {
+                // Override iterator methods to use our wrapped iterator
+                if (prop === Symbol.asyncIterator)
+                    return () => iterator;
+                if (prop === "next")
+                    return () => iterator.next();
+                if (prop === "return")
+                    return (value) => iterator.return(value);
+                if (prop === "throw")
+                    return (error) => iterator.throw(error);
+                // Forward everything else to the original query
+                const value = Reflect.get(target, prop);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+    };
+}
+//# sourceMappingURL=plan.js.map