@drip-sdk/node 1.1.0 → 1.1.2

package/README.md

@@ -1,332 +1,284 @@
-# @drip-sdk/node
+# Drip SDK (Node.js)
 
-The official Node.js SDK for **Drip** - Usage tracking and cost attribution for metered infrastructure.
+Drip is a lightweight SDK for **usage tracking and execution logging** in systems where cost is tied to computation — AI agents, APIs, background jobs, and infra workloads.
 
-Drip is the system of record for usage. We capture high-frequency metering for RPC providers, API companies, and AI agents - with cost attribution, execution traces, and real-time analytics.
+This **Core SDK** is designed for pilots: it records *what ran* and *how much it used*, without handling billing or balances.
 
-[![npm version](https://badge.fury.io/js/@drip-sdk/node.svg)](https://www.npmjs.com/package/@drip-sdk/node)
+**One line to start tracking:** `await drip.trackUsage({ customerId, meter, quantity })`
+
+[![npm version](https://img.shields.io/npm/v/%40drip-sdk%2Fnode.svg)](https://www.npmjs.com/package/@drip-sdk/node)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Installation
+---
+
+## 60-Second Quickstart (Core SDK)
+
+### 1. Install
 
 ```bash
 npm install @drip-sdk/node
 ```
 
-## Core SDK (Recommended for Pilots)
+### 2. Set your API key
 
-For most use cases, import the **Core SDK** - a simplified API focused on two concepts:
+```bash
+# Secret key — full API access (server-side only, never expose publicly)
+export DRIP_API_KEY=sk_test_...
 
-1. **Usage Tracking** - Record metered usage events
-2. **Execution Logging** - Log agent runs with detailed event traces
+# Or public key — read/write access for usage, customers, billing (safe for client-side)
+export DRIP_API_KEY=pk_test_...
+```
+
+### 3. Create a customer and track usage
 
 ```typescript
-import { Drip } from '@drip-sdk/node/core';
+import { drip } from '@drip-sdk/node';
 
-const drip = new Drip({ apiKey: process.env.DRIP_API_KEY! });
+// Create a customer first
+const customer = await drip.createCustomer({ externalCustomerId: 'user_123' });
 
-// Verify connection
-await drip.ping();
+// Track usage — that's it
+await drip.trackUsage({ customerId: customer.id, meter: 'api_calls', quantity: 1 });
 ```
 
-### Track Usage
+The `drip` singleton reads `DRIP_API_KEY` from your environment automatically.
+
+### Alternative: Explicit Configuration
 
 ```typescript
-// Track any metered usage (no billing - just recording)
-await drip.trackUsage({
-  customerId: 'cus_123',
-  meter: 'api_calls',
-  quantity: 1,
-  metadata: { endpoint: '/v1/generate', method: 'POST' },
-});
+import { Drip } from '@drip-sdk/node';
+
+// Auto-reads DRIP_API_KEY from environment
+const drip = new Drip();
+
+// Or pass config explicitly with a secret key (full access)
+const drip = new Drip({ apiKey: 'sk_test_...' });
+
+// Or with a public key (safe for client-side, limited scope)
+const drip = new Drip({ apiKey: 'pk_test_...' });
 ```
 
-### Record Agent Runs
+### Full Example
 
 ```typescript
-// Record a complete agent execution with one call
-const result = await drip.recordRun({
-  customerId: 'cus_123',
-  workflow: 'research-agent',
-  events: [
-    { eventType: 'llm.call', model: 'gpt-4', inputTokens: 500, outputTokens: 1200 },
-    { eventType: 'tool.call', name: 'web-search', duration: 1500 },
-    { eventType: 'llm.call', model: 'gpt-4', inputTokens: 200, outputTokens: 800 },
-  ],
-  status: 'COMPLETED',
-});
+import { drip } from '@drip-sdk/node';
+
+async function main() {
+  // Verify connectivity
+  await drip.ping();
+
+  // Create a customer (at least one of externalCustomerId or onchainAddress required)
+  const customer = await drip.createCustomer({ externalCustomerId: 'user_123' });
+
+  // Record usage
+  await drip.trackUsage({
+    customerId: customer.id,
+    meter: 'llm_tokens',
+    quantity: 842,
+    metadata: { model: 'gpt-4o-mini' },
+  });
+
+  // Record an execution lifecycle
+  await drip.recordRun({
+    customerId: customer.id,
+    workflow: 'research-agent',
+    events: [
+      { eventType: 'llm.call', quantity: 1700, units: 'tokens' },
+      { eventType: 'tool.call', quantity: 1 },
+    ],
+    status: 'COMPLETED',
+  });
+
+  console.log(`Customer ${customer.id}: usage + run recorded`);
+}
 
-console.log(result.summary);
-// Output: "Research Agent: 3 events recorded (2.5s)"
+main();
 ```
 
-### Core SDK Methods
-
-| Method | Description |
-|--------|-------------|
-| `ping()` | Verify API connection |
-| `createCustomer(params)` | Create a customer |
-| `getCustomer(customerId)` | Get customer details |
-| `listCustomers(options)` | List all customers |
-| `trackUsage(params)` | Record metered usage |
-| `recordRun(params)` | Log complete agent run (simplified) |
-| `startRun(params)` | Start execution trace |
-| `emitEvent(params)` | Log event within run |
-| `emitEventsBatch(params)` | Batch log events |
-| `endRun(runId, params)` | Complete execution trace |
-| `getRunTimeline(runId)` | Get execution timeline |
+**Expected result:**
+- No errors
+- Events appear in your Drip dashboard within seconds
 
 ---
 
-## Full SDK
+## Core Concepts (2-minute mental model)
 
-For billing, webhooks, and advanced features, use the full SDK:
+| Concept | Description |
+|---------|-------------|
+| `customerId` | The end user, API key, or account you're attributing usage to |
+| `meter` | What you're measuring (tokens, requests, seconds, rows, etc.) |
+| `quantity` | Numeric usage for that meter |
+| `run` | A single execution or request lifecycle (success / failure / duration) |
+| `correlationId` | Optional. Your trace/request ID for linking Drip data with your APM (OpenTelemetry, Datadog, etc.) |
 
-```typescript
-import { Drip } from '@drip-sdk/node';
+**Status values:** `PENDING` | `RUNNING` | `COMPLETED` | `FAILED`
 
-const drip = new Drip({ apiKey: process.env.DRIP_API_KEY! });
+**Event schema:** Payloads are schema-flexible. Drip stores events as structured JSON and does not enforce a fixed event taxonomy.
 
-// All Core SDK methods plus:
-// - charge(), getBalance(), getCharge(), listCharges()
-// - createWebhook(), listWebhooks(), deleteWebhook()
-// - estimateFromUsage(), estimateFromHypothetical()
-// - checkout(), and more
-```
+Drip is append-only and idempotent-friendly. You can safely retry events.
 
-## Quick Start (Full SDK)
+> **Distributed tracing:** Pass `correlationId` to `startRun()`, `recordRun()`, or `emitEvent()` to cross-reference Drip billing with your observability stack. See [FULL_SDK.md](./FULL_SDK.md#distributed-tracing-correlationid) for details.
 
-### Track Usage
+---
 
-```typescript
-import { Drip } from '@drip-sdk/node';
+## Idempotency Keys
 
-const drip = new Drip({ apiKey: process.env.DRIP_API_KEY! });
+Every mutating SDK method (`charge`, `trackUsage`, `emitEvent`) accepts an optional `idempotencyKey` parameter. The server uses this key to deduplicate requests — if two requests share the same key, only the first is processed.
 
-// Track any metered usage
-await drip.trackUsage({
-  customerId: 'cus_123',
-  meter: 'api_calls',
-  quantity: 1,
-  metadata: { endpoint: '/v1/generate', method: 'POST' },
-});
+`recordRun` generates idempotency keys internally for its batch events (using `externalRunId` when provided, otherwise deterministic keys).
 
-// Check accumulated usage
-const balance = await drip.getBalance('cus_123');
-console.log(`Total usage: $${balance.totalUsageUsd}`);
-```
+### Auto-generated keys (default)
 
-### Log Agent Runs (AI/Agent API)
+When you omit `idempotencyKey`, the SDK generates one automatically. The auto key is:
 
-```typescript
-// Record a complete agent execution with one call
-const result = await drip.recordRun({
-  customerId: 'cus_123',
-  workflow: 'research-agent',
-  events: [
-    { eventType: 'llm.call', model: 'gpt-4', inputTokens: 500, outputTokens: 1200 },
-    { eventType: 'tool.call', name: 'web-search', duration: 1500 },
-    { eventType: 'llm.call', model: 'gpt-4', inputTokens: 200, outputTokens: 800 },
-  ],
-  status: 'COMPLETED',
-});
+- **Unique per call** — two separate calls with identical parameters produce different keys (a monotonic counter ensures this).
+- **Stable across retries** — the key is generated once and reused for all retry attempts of that call, so network retries are safely deduplicated.
+- **Deterministic** — no randomness; keys are reproducible for debugging.
 
-console.log(result.summary);
-// Output: "Research Agent: 3 events recorded (2.5s)"
-```
-
-### View Execution Traces
-
-```typescript
-// Get detailed timeline of an agent run
-const timeline = await drip.getRunTimeline(runId);
+This means you get **free retry safety** with zero configuration.
 
-for (const event of timeline.events) {
-  console.log(`${event.eventType}: ${event.duration}ms`);
-}
-```
+> **Note:** `wrapApiCall` generates a time-based key when no explicit `idempotencyKey` is provided. Pass your own key if you need deterministic deduplication with `wrapApiCall`.
 
-## Use Cases
+### When to pass explicit keys
 
-### RPC Providers
+Pass your own `idempotencyKey` when you need **application-level deduplication** — e.g., to guarantee that a specific business operation is billed exactly once, even across process restarts:
 
 ```typescript
-// Track per-method usage with chain and latency
-await drip.trackUsage({
-  customerId: apiKeyOwner,
-  meter: 'rpc_calls',
-  quantity: 1,
-  metadata: {
-    method: 'eth_call',
-    chain: 'ethereum',
-    latencyMs: 45,
-    cacheHit: false,
-  },
-});
-```
-
-### API Companies
+const customer = await drip.createCustomer({ externalCustomerId: 'user_123' });
 
-```typescript
-// Track API usage with endpoint attribution
-await drip.trackUsage({
-  customerId: 'cus_123',
+await drip.charge({
+  customerId: customer.id,
   meter: 'api_calls',
   quantity: 1,
-  metadata: {
-    endpoint: '/v1/embeddings',
-    tokens: 1500,
-    model: 'text-embedding-3-small',
-  },
+  idempotencyKey: `order_${orderId}_charge`, // your business-level key
 });
 ```
 
-### AI Agents
+Common patterns:
+- `order_${orderId}` — one charge per order
+- `run_${runId}_step_${stepIndex}` — one charge per pipeline step
+- `invoice_${invoiceId}` — one charge per invoice
 
-```typescript
-// Track agent execution with detailed events
-const run = await drip.startRun({
-  customerId: 'cus_123',
-  workflowSlug: 'document-processor',
-});
+### StreamMeter
 
-await drip.emitEvent({
-  runId: run.id,
-  eventType: 'ocr.process',
-  quantity: 5,
-  units: 'pages',
-});
+`StreamMeter` also auto-generates idempotency keys per flush. If you provide an `idempotencyKey` in the options, each flush appends a counter (`_flush_0`, `_flush_1`, etc.) to keep multi-flush scenarios safe.
 
-await drip.emitEvent({
-  runId: run.id,
-  eventType: 'llm.summarize',
-  model: 'gpt-4',
-  inputTokens: 10000,
-  outputTokens: 500,
-});
+---
 
-await drip.endRun(run.id, { status: 'COMPLETED' });
-```
+## API Key Types
 
-## Full SDK API Reference
+Drip issues two key types per API key pair. Each has different access scopes:
 
-### Usage & Billing
+| Key Type | Prefix | Access | Use In |
+|----------|--------|--------|--------|
+| **Secret Key** | `sk_live_` / `sk_test_` | Full API access (all endpoints) | Server-side only |
+| **Public Key** | `pk_live_` / `pk_test_` | Usage tracking, customers, billing, analytics, sessions | Client-side safe |
 
-| Method | Description |
-|--------|-------------|
-| `trackUsage(params)` | Record metered usage (no billing) |
-| `charge(params)` | Create a billable charge |
-| `getBalance(customerId)` | Get balance and usage summary |
-| `getCharge(chargeId)` | Get charge details |
-| `listCharges(options)` | List all charges |
-| `getChargeStatus(chargeId)` | Get charge status |
+### What public keys **can** access
+- Usage tracking (`trackUsage`, `recordRun`, `startRun`, `emitEvent`, etc.)
+- Customer management (`createCustomer`, `getCustomer`, `listCustomers`)
+- Billing & charges (`charge`, `getBalance`, `listCharges`, etc.)
+- Pricing plans, sessions, analytics, usage caps, refunds
 
-### Execution Logging
+### What public keys **cannot** access (secret key required)
+- Webhook management (`createWebhook`, `listWebhooks`, `deleteWebhook`, etc.)
+- API key management (create, rotate, revoke keys)
+- Feature flag management
 
-| Method | Description |
-|--------|-------------|
-| `recordRun(params)` | Log complete agent run (simplified) |
-| `startRun(params)` | Start execution trace |
-| `emitEvent(params)` | Log event within run |
-| `emitEventsBatch(params)` | Batch log events |
-| `endRun(runId, params)` | Complete execution trace |
-| `getRunTimeline(runId)` | Get execution timeline |
-| `createWorkflow(params)` | Create a workflow |
-| `listWorkflows()` | List all workflows |
+The SDK detects your key type automatically and will throw a `DripError` with code `PUBLIC_KEY_NOT_ALLOWED` (HTTP 403) if you attempt a secret-key-only operation with a public key.
 
-### Customer Management
+```typescript
+const drip = new Drip({ apiKey: 'pk_test_...' });
+console.log(drip.keyType); // 'public'
 
-| Method | Description |
-|--------|-------------|
-| `createCustomer(params)` | Create a customer |
-| `getCustomer(customerId)` | Get customer details |
-| `listCustomers(options)` | List all customers |
+// Create a customer first, then track usage
+const customer = await drip.createCustomer({ externalCustomerId: 'user_123' });
+await drip.trackUsage({ customerId: customer.id, meter: 'api_calls', quantity: 1 });
 
-### Webhooks
+// This throws DripError(403, 'PUBLIC_KEY_NOT_ALLOWED')
+await drip.createWebhook({ url: '...', events: ['charge.succeeded'] });
+```
 
-| Method | Description |
-|--------|-------------|
-| `createWebhook(params)` | Create webhook endpoint |
-| `listWebhooks()` | List all webhooks |
-| `getWebhook(webhookId)` | Get webhook details |
-| `deleteWebhook(webhookId)` | Delete a webhook |
-| `testWebhook(webhookId)` | Test a webhook |
-| `rotateWebhookSecret(webhookId)` | Rotate webhook secret |
-| `Drip.verifyWebhookSignature()` | Verify webhook signature |
+---
 
-### Cost Estimation
+## SDK Variants
 
-| Method | Description |
-|--------|-------------|
-| `estimateFromUsage(params)` | Estimate cost from usage data |
-| `estimateFromHypothetical(params)` | Estimate from hypothetical usage |
+| Variant | Description |
+|---------|-------------|
+| **Core SDK** (recommended for pilots) | Usage tracking + execution logging only |
+| **Full SDK** | Includes billing, balances, and workflows (for later stages) |
+
+---
 
-### Other
+## Core SDK Methods
 
 | Method | Description |
 |--------|-------------|
-| `checkout(params)` | Create checkout session (fiat on-ramp) |
-| `listMeters()` | List available meters |
 | `ping()` | Verify API connection |
+| `createCustomer(params)` | Create a customer |
+| `getCustomer(customerId)` | Get customer details |
+| `listCustomers(options)` | List all customers |
+| `trackUsage(params)` | Record metered usage |
+| `recordRun(params)` | Log complete agent run (simplified) |
+| `startRun(params)` | Start execution trace |
+| `emitEvent(params)` | Log event within run |
+| `emitEventsBatch(params)` | Batch log events |
+| `endRun(runId, params)` | Complete execution trace |
+| `getRun(runId)` | Get run details and summary |
+| `getRunTimeline(runId)` | Get execution timeline |
 
-## Streaming Meter (LLM Token Streaming)
+### Creating Customers
 
-For LLM token streaming, accumulate usage locally and charge once:
+All parameters are optional, but at least one of `externalCustomerId` or `onchainAddress` must be provided:
 
 ```typescript
-const meter = drip.createStreamMeter({
-  customerId: 'cus_123',
-  meter: 'tokens',
-});
+// Simplest — just your internal user ID
+const customer = await drip.createCustomer({ externalCustomerId: 'user_123' });
 
-for await (const chunk of llmStream) {
-  meter.add(chunk.tokens);
-  yield chunk;
-}
+// With an on-chain address (for on-chain billing)
+const customer = await drip.createCustomer({
+  onchainAddress: '0x1234...',
+  externalCustomerId: 'user_123',
+});
 
-// Single API call at end
-await meter.flush();
+// Internal/non-billing customer (for tracking only)
+const customer = await drip.createCustomer({
+  externalCustomerId: 'internal-team',
+  isInternal: true,
+});
 ```
 
-## Framework Middleware
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `externalCustomerId` | `string` | No* | Your internal user/account ID |
+| `onchainAddress` | `string` | No* | Customer's Ethereum address |
+| `isInternal` | `boolean` | No | Mark as internal (non-billing). Default: `false` |
+| `metadata` | `object` | No | Arbitrary key-value metadata |
 
-### Next.js
+\*At least one of `externalCustomerId` or `onchainAddress` is required.
 
-```typescript
-import { withDrip } from '@drip-sdk/node/next';
+---
 
-export const POST = withDrip({
-  meter: 'api_calls',
-  quantity: 1,
-}, async (req, { customerId }) => {
-  return Response.json({ result: 'success' });
-});
-```
+## Who This Is For
 
-### Express
+- AI agents (token metering, tool calls, execution traces)
+- API companies (per-request billing, endpoint attribution)
+- RPC providers (multi-chain call tracking)
+- Cloud/infra (compute seconds, storage, bandwidth)
 
-```typescript
-import { dripMiddleware } from '@drip-sdk/node/express';
+---
 
-app.use('/api', dripMiddleware({
-  meter: 'api_calls',
-  quantity: 1,
-}));
-```
+## Full SDK (Billing, Webhooks, Integrations)
 
-## LangChain Integration
+For billing, webhooks, middleware, and advanced features:
 
 ```typescript
-import { DripCallbackHandler } from '@drip-sdk/node/langchain';
+import { Drip } from '@drip-sdk/node';
+```
 
-const handler = new DripCallbackHandler({
-  drip,
-  customerId: 'cus_123',
-});
+See **[FULL_SDK.md](./FULL_SDK.md)** for complete documentation.
 
-// Automatically tracks all LLM calls and tool usage
-await agent.invoke({ input: '...' }, { callbacks: [handler] });
-```
+---
 
 ## Error Handling
 
@@ -342,50 +294,7 @@ try {
 }
 ```
 
-## Billing (Full SDK Only)
-
-```typescript
-import { Drip } from '@drip-sdk/node';
-
-const drip = new Drip({ apiKey: process.env.DRIP_API_KEY! });
-
-// Create a billable charge
-const result = await drip.charge({
-  customerId: 'cus_123',
-  meter: 'api_calls',
-  quantity: 1,
-});
-
-// Get customer balance
-const balance = await drip.getBalance('cus_123');
-console.log(`Balance: $${balance.balanceUsdc}`);
-
-// Query charges
-const charge = await drip.getCharge(chargeId);
-const charges = await drip.listCharges({ customerId: 'cus_123' });
-
-// Cost estimation
-await drip.estimateFromUsage({ customerId, startDate, endDate });
-await drip.estimateFromHypothetical({ items: [...] });
-
-// Checkout (fiat on-ramp)
-await drip.checkout({ customerId: 'cus_123', amountUsd: 5000 });
-```
-
-## TypeScript Support
-
-Full TypeScript support with exported types:
-
-```typescript
-import type {
-  Customer,
-  Charge,
-  ChargeResult,
-  TrackUsageParams,
-  RunResult,
-  Webhook,
-} from '@drip-sdk/node';
-```
+---
 
 ## Requirements
 
@@ -393,6 +302,6 @@ import type {
 
 ## Links
 
-- [Documentation](https://docs.drippay.dev)
-- [GitHub](https://github.com/MichaelLevin5908/drip)
+- [Full SDK Documentation](./FULL_SDK.md)
+- [API Documentation](https://drippay.dev/api-reference)
 - [npm](https://www.npmjs.com/package/@drip-sdk/node)

package/dist/core.cjs

@@ -1,3 +1,3 @@
-'use strict';Object.defineProperty(exports,'__esModule',{value:true});var u=class w extends Error{constructor(n,r,i){super(n);this.statusCode=r;this.code=i;this.name="DripError",Object.setPrototypeOf(this,w.prototype);}},g=class{apiKey;baseUrl;timeout;constructor(t){if(!t.apiKey)throw new Error("Drip API key is required");this.apiKey=t.apiKey,this.baseUrl=t.baseUrl||"https://api.drip.dev/v1",this.timeout=t.timeout||3e4;}async request(t,n={}){let r=new AbortController,i=setTimeout(()=>r.abort(),this.timeout);try{let e=await fetch(`${this.baseUrl}${t}`,{...n,signal:r.signal,headers:{"Content-Type":"application/json",Authorization:`Bearer ${this.apiKey}`,...n.headers}});if(e.status===204)return {success:!0};let o=await e.json();if(!e.ok)throw new u(o.message||o.error||"Request failed",e.status,o.code);return o}catch(e){throw e instanceof u?e:e instanceof Error&&e.name==="AbortError"?new u("Request timed out",408,"TIMEOUT"):new u(e instanceof Error?e.message:"Unknown error",0,"UNKNOWN")}finally{clearTimeout(i);}}async ping(){let t=new AbortController,n=setTimeout(()=>t.abort(),this.timeout),r=this.baseUrl;r.endsWith("/v1/")?r=r.slice(0,-4):r.endsWith("/v1")&&(r=r.slice(0,-3)),r=r.replace(/\/+$/,"");let i=Date.now();try{let e=await fetch(`${r}/health`,{signal:t.signal,headers:{Authorization:`Bearer ${this.apiKey}`}}),o=Date.now()-i,a="unknown",l=Date.now();try{let c=await e.json();typeof c.status=="string"&&(a=c.status),typeof c.timestamp=="number"&&(l=c.timestamp);}catch{a=e.ok?"healthy":`error:${e.status}`;}return !e.ok&&a==="unknown"&&(a=`error:${e.status}`),{ok:e.ok&&a==="healthy",status:a,latencyMs:o,timestamp:l}}catch(e){throw e instanceof Error&&e.name==="AbortError"?new u("Request timed out",408,"TIMEOUT"):new u(e instanceof Error?e.message:"Unknown error",0,"UNKNOWN")}finally{clearTimeout(n);}}async createCustomer(t){return this.request("/customers",{method:"POST",body:JSON.stringify(t)})}async getCustomer(t){return this.request(`/customers/${t}`)}async listCustomers(t){let n=new URLSearchParams;t?.limit&&n.set("limit",t.limit.toString()),t?.status&&n.set("status",t.status);let r=n.toString(),i=r?`/customers?${r}`:"/customers";return this.request(i)}async trackUsage(t){return this.request("/usage/internal",{method:"POST",body:JSON.stringify({customerId:t.customerId,usageType:t.meter,quantity:t.quantity,idempotencyKey:t.idempotencyKey,units:t.units,description:t.description,metadata:t.metadata})})}async createWorkflow(t){return this.request("/workflows",{method:"POST",body:JSON.stringify(t)})}async listWorkflows(){return this.request("/workflows")}async startRun(t){return this.request("/runs",{method:"POST",body:JSON.stringify(t)})}async endRun(t,n){return this.request(`/runs/${t}`,{method:"PATCH",body:JSON.stringify(n)})}async getRunTimeline(t){return this.request(`/runs/${t}`)}async emitEvent(t){return this.request("/events",{method:"POST",body:JSON.stringify(t)})}async emitEventsBatch(t){return this.request("/run-events/batch",{method:"POST",body:JSON.stringify({events:t})})}async recordRun(t){let n=Date.now(),r=t.workflow,i=t.workflow;if(!t.workflow.startsWith("wf_"))try{let d=(await this.listWorkflows()).data.find(s=>s.slug===t.workflow||s.id===t.workflow);if(d)r=d.id,i=d.name;else {let s=await this.createWorkflow({name:t.workflow.replace(/[_-]/g," ").replace(/\b\w/g,m=>m.toUpperCase()),slug:t.workflow,productSurface:"CUSTOM"});r=s.id,i=s.name;}}catch{r=t.workflow;}let e=await this.startRun({customerId:t.customerId,workflowId:r,externalRunId:t.externalRunId,correlationId:t.correlationId,metadata:t.metadata}),o=0,a=0;if(t.events.length>0){let y=t.events.map((s,m)=>({runId:e.id,eventType:s.eventType,quantity:s.quantity,units:s.units,description:s.description,costUnits:s.costUnits,metadata:s.metadata,idempotencyKey:t.externalRunId?`${t.externalRunId}:${s.eventType}:${m}`:void 0})),d=await this.emitEventsBatch(y);o=d.created,a=d.duplicates;}let l=await this.endRun(e.id,{status:t.status,errorMessage:t.errorMessage,errorCode:t.errorCode}),c=Date.now()-n,f=t.events.length>0?`${o} events recorded`:"no events",p=`${t.status==="COMPLETED"?"\u2713":t.status==="FAILED"?"\u2717":"\u25CB"} ${i}: ${f} (${l.durationMs??c}ms)`;return {run:{id:e.id,workflowId:r,workflowName:i,status:t.status,durationMs:l.durationMs},events:{created:o,duplicates:a},totalCostUnits:l.totalCostUnits,summary:p}}},b=g;
-exports.Drip=g;exports.DripError=u;exports.default=b;//# sourceMappingURL=core.cjs.map
+'use strict';Object.defineProperty(exports,'__esModule',{value:true});var crypto=require('crypto');var k=0;function p(m,...t){let e=++k,n=t.filter(r=>r!==void 0).map(String);n.push(String(e));let s=crypto.createHash("sha256").update(n.join("|")).digest("hex").slice(0,24);return `${m}_${s}`}var a=class m extends Error{constructor(e,n,s){super(e);this.statusCode=n;this.code=s;this.name="DripError",Object.setPrototypeOf(this,m.prototype);}},f=class{apiKey;baseUrl;timeout;keyType;constructor(t={}){let e=t.apiKey??(typeof process<"u"?process.env.DRIP_API_KEY:void 0),n=t.baseUrl??(typeof process<"u"?process.env.DRIP_BASE_URL:void 0);if(!e)throw new Error("Drip API key is required. Either pass { apiKey } to constructor or set DRIP_API_KEY environment variable.");this.apiKey=e,this.baseUrl=n||"https://drip-app-hlunj.ondigitalocean.app/v1",this.timeout=t.timeout||3e4,e.startsWith("sk_")?this.keyType="secret":e.startsWith("pk_")?this.keyType="public":this.keyType="unknown";}async request(t,e={}){let n=new AbortController,s=setTimeout(()=>n.abort(),this.timeout);try{let r=await fetch(`${this.baseUrl}${t}`,{...e,signal:n.signal,headers:{"Content-Type":"application/json",Authorization:`Bearer ${this.apiKey}`,...e.headers}});if(r.status===204)return {success:!0};let i=await r.json();if(!r.ok)throw new a(i.message||i.error||"Request failed",r.status,i.code);return i}catch(r){throw r instanceof a?r:r instanceof Error&&r.name==="AbortError"?new a("Request timed out",408,"TIMEOUT"):new a(r instanceof Error?r.message:"Unknown error",0,"UNKNOWN")}finally{clearTimeout(s);}}async ping(){let t=new AbortController,e=setTimeout(()=>t.abort(),this.timeout),n=this.baseUrl;n.endsWith("/v1/")?n=n.slice(0,-4):n.endsWith("/v1")&&(n=n.slice(0,-3)),n=n.replace(/\/+$/,"");let s=Date.now();try{let r=await fetch(`${n}/health`,{signal:t.signal,headers:{Authorization:`Bearer ${this.apiKey}`}}),i=Date.now()-s,o="unknown",d=Date.now();try{let u=await r.json();typeof u.status=="string"&&(o=u.status),typeof u.timestamp=="number"&&(d=u.timestamp);}catch{o=r.ok?"healthy":`error:${r.status}`;}return !r.ok&&o==="unknown"&&(o=`error:${r.status}`),{ok:r.ok&&o==="healthy",status:o,latencyMs:i,timestamp:d}}catch(r){throw r instanceof Error&&r.name==="AbortError"?new a("Request timed out",408,"TIMEOUT"):new a(r instanceof Error?r.message:"Unknown error",0,"UNKNOWN")}finally{clearTimeout(e);}}async createCustomer(t){return this.request("/customers",{method:"POST",body:JSON.stringify(t)})}async getCustomer(t){return this.request(`/customers/${t}`)}async listCustomers(t){let e=new URLSearchParams;t?.limit&&e.set("limit",t.limit.toString()),t?.status&&e.set("status",t.status);let n=e.toString(),s=n?`/customers?${n}`:"/customers";return this.request(s)}async trackUsage(t){let e=t.idempotencyKey??p("track",t.customerId,t.meter,t.quantity);return this.request("/usage/internal",{method:"POST",body:JSON.stringify({customerId:t.customerId,usageType:t.meter,quantity:t.quantity,idempotencyKey:e,units:t.units,description:t.description,metadata:t.metadata})})}async createWorkflow(t){return this.request("/workflows",{method:"POST",body:JSON.stringify(t)})}async listWorkflows(){return this.request("/workflows")}async startRun(t){return this.request("/runs",{method:"POST",body:JSON.stringify(t)})}async endRun(t,e){return this.request(`/runs/${t}`,{method:"PATCH",body:JSON.stringify(e)})}async getRun(t){return this.request(`/runs/${t}`)}async getRunTimeline(t,e){let n=new URLSearchParams;e?.limit&&n.set("limit",e.limit.toString()),e?.cursor&&n.set("cursor",e.cursor),e?.includeAnomalies!==void 0&&n.set("includeAnomalies",String(e.includeAnomalies)),e?.collapseRetries!==void 0&&n.set("collapseRetries",String(e.collapseRetries));let s=n.toString(),r=s?`/runs/${t}/timeline?${s}`:`/runs/${t}/timeline`;return this.request(r)}async emitEvent(t){let e=t.idempotencyKey??p("evt",t.runId,t.eventType,t.quantity);return this.request("/run-events",{method:"POST",body:JSON.stringify({...t,idempotencyKey:e})})}async emitEventsBatch(t){return this.request("/run-events/batch",{method:"POST",body:JSON.stringify({events:t})})}async recordRun(t){try{return await this.request("/runs/record",{method:"POST",body:JSON.stringify({customerId:t.customerId,workflow:t.workflow,events:t.events,status:t.status,errorMessage:t.errorMessage,errorCode:t.errorCode,externalRunId:t.externalRunId,correlationId:t.correlationId,metadata:t.metadata})})}catch(e){if(e instanceof a&&e.statusCode===404)return this._recordRunFallback(t);throw e}}async _recordRunFallback(t){let e=Date.now(),n=t.workflow,s=t.workflow,{data:r}=await this.listWorkflows(),i=r.find(l=>l.slug===t.workflow||l.id===t.workflow);if(i)n=i.id,s=i.name;else {let l=await this.request("/workflows",{method:"POST",body:JSON.stringify({name:t.workflow.replace(/[_-]/g," ").replace(/\b\w/g,y=>y.toUpperCase()),slug:t.workflow,productSurface:"CUSTOM"})});n=l.id,s=l.name;}let o=await this.startRun({customerId:t.customerId,workflowId:n,correlationId:t.correlationId,externalRunId:t.externalRunId,metadata:t.metadata}),d=0,u=0;if(t.events.length>0){let l=t.events.map((c,I)=>({runId:o.id,eventType:c.eventType,quantity:c.quantity??1,units:c.units,description:c.description,costUnits:c.costUnits,metadata:c.metadata,idempotencyKey:t.externalRunId?`${t.externalRunId}:${c.eventType}:${I}`:void 0})),y=await this.emitEventsBatch(l);d=y.created,u=y.duplicates;}let g=await this.endRun(o.id,{status:t.status,errorMessage:t.errorMessage,errorCode:t.errorCode}),w=Date.now()-e,h=t.status==="COMPLETED"?"\u2713":t.status==="FAILED"?"\u2717":"\u25CB";return {run:{id:o.id,workflowId:n,workflowName:s,status:g.status,durationMs:g.durationMs??w},events:{created:d,duplicates:u},totalCostUnits:g.totalCostUnits??null,summary:`${h} ${s}: ${d} events recorded (${g.durationMs??w}ms)`}}},S=f,R=null;function C(){return R||(R=new f),R}var O=new Proxy({},{get(m,t){let e=C(),n=e[t];return typeof n=="function"?n.bind(e):n}});
+exports.Drip=f;exports.DripError=a;exports.default=S;exports.drip=O;//# sourceMappingURL=core.cjs.map
 //# sourceMappingURL=core.cjs.map