@databuddy/sdk 2.2.0 → 2.2.1

package/dist/ai/vercel/index.d.mts

@@ -0,0 +1,12 @@
+import { LanguageModelV2 } from '@ai-sdk/provider';
+import { db as Databuddy } from '../../node/index.mjs';
+
+/**
+ * Wrap a Vercel language model with Databuddy middleware
+ * @param model - The Vercel language model to wrap, if you are using the Vercel AI Gateway, please use the LanguageModelV2 type e.g. gateway('xai/grok-3') instead of the string type e.g. 'xai/grok-3'
+ * @param buddy - The Databuddy instance to use
+ * @returns The wrapped language model, can be used in e.g. generateText from the ai package
+ */
+declare const wrapVercelLanguageModel: (model: LanguageModelV2, buddy: Databuddy) => LanguageModelV2;
+
+export { wrapVercelLanguageModel as withBuddy };

package/dist/ai/vercel/index.d.ts

@@ -0,0 +1,12 @@
+import { LanguageModelV2 } from '@ai-sdk/provider';
+import { db as Databuddy } from '../../node/index.js';
+
+/**
+ * Wrap a Vercel language model with Databuddy middleware
+ * @param model - The Vercel language model to wrap, if you are using the Vercel AI Gateway, please use the LanguageModelV2 type e.g. gateway('xai/grok-3') instead of the string type e.g. 'xai/grok-3'
+ * @param buddy - The Databuddy instance to use
+ * @returns The wrapped language model, can be used in e.g. generateText from the ai package
+ */
+declare const wrapVercelLanguageModel: (model: LanguageModelV2, buddy: Databuddy) => LanguageModelV2;
+
+export { wrapVercelLanguageModel as withBuddy };

package/dist/ai/vercel/index.mjs

@@ -0,0 +1,45 @@
+import { wrapLanguageModel } from 'ai';
+import { computeCostUSD } from 'tokenlens';
+
+const buddyWare = (buddy) => {
+  return {
+    wrapGenerate: async ({ doGenerate, model }) => {
+      const result = await doGenerate();
+      const isToolCall = (part) => part.type === "tool-call";
+      const isToolResult = (part) => part.type === "tool-result";
+      const toolCalls = result.content.filter(isToolCall);
+      const toolResults = result.content.filter(isToolResult);
+      const toolCallNames = Array.from(
+        new Set(toolCalls.map((c) => c.toolName))
+      );
+      const costs = await computeCostUSD({
+        modelId: model.modelId,
+        provider: model.provider,
+        usage: result.usage
+      });
+      const payload = {
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        totalTokens: result.usage.totalTokens,
+        cachedInputTokens: result.usage.cachedInputTokens,
+        finishReason: result.finishReason,
+        toolCallCount: toolCalls.length,
+        toolResultCount: toolResults.length,
+        inputTokenCostUSD: costs.inputTokenCostUSD,
+        outputTokenCostUSD: costs.outputTokenCostUSD,
+        totalTokenCostUSD: costs.totalTokenCostUSD,
+        toolCallNames
+      };
+      console.log("payload", payload);
+      return result;
+    }
+  };
+};
+const wrapVercelLanguageModel = (model, buddy) => {
+  return wrapLanguageModel({
+    model,
+    middleware: buddyWare()
+  });
+};
+
+export { wrapVercelLanguageModel as withBuddy };

package/dist/core/index.d.mts

@@ -1,7 +1,7 @@
 import { S as StorageInterface, F as FlagsManager, a as FlagsManagerOptions, b as FlagResult, c as FlagState, d as FlagsConfig } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 export { e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
-import { D as DatabuddyConfig, a as DatabuddyTracker, T as TrackFunction, b as Databuddy$1 } from '../shared/@databuddy/sdk.C8T93n5r.mjs';
-export { B as BaseEventProperties, e as DataAttributes, d as EventName, E as EventProperties, c as EventTypeMap, P as PropertiesForEvent, S as ScreenViewFunction, f as SetGlobalPropertiesFunction } from '../shared/@databuddy/sdk.C8T93n5r.mjs';
+import { D as DatabuddyConfig, a as DatabuddyTracker, T as TrackFunction } from '../shared/@databuddy/sdk.DNing6--.mjs';
+export { B as BaseEventProperties, d as DataAttributes, c as EventName, E as EventProperties, b as EventTypeMap, P as PropertiesForEvent, S as ScreenViewFunction, e as SetGlobalPropertiesFunction } from '../shared/@databuddy/sdk.DNing6--.mjs';
 
 /**
  * Auto-detect Databuddy client ID from environment variables
@@ -84,12 +84,29 @@ declare function trackError(message: string, properties?: {
     colno?: number;
     stack?: string;
     error_type?: string;
-    [key: string]: any;
+    [key: string]: string | number | boolean | null | undefined;
 }): Promise<void>;
-
 /**
- * @deprecated Use Databuddy from `@databuddy/sdk/react` instead
+ * Get anonymous ID from multiple sources
+ * Priority: URL params > tracker instance > localStorage
+ */
+declare function getAnonymousId(urlParams?: URLSearchParams): string | null;
+/**
+ * Get session ID from multiple sources
+ * Priority: URL params > tracker instance > sessionStorage
+ */
+declare function getSessionId(urlParams?: URLSearchParams): string | null;
+/**
+ * Get tracking IDs (anonymous ID and session ID) from multiple sources
+ * Priority: URL params > tracker instance > localStorage/sessionStorage
+ */
+declare function getTrackingIds(urlParams?: URLSearchParams): {
+    anonId: string | null;
+    sessionId: string | null;
+};
+/**
+ * Get tracking IDs as URL search params string
  */
-declare const Databuddy: typeof Databuddy$1;
+declare function getTrackingParams(urlParams?: URLSearchParams): string;
 
-export { BrowserFlagStorage, CoreFlagsManager, Databuddy, DatabuddyConfig, DatabuddyTracker, FlagResult, FlagState, FlagsConfig, FlagsManager, FlagsManagerOptions, StorageInterface, TrackFunction, clear, createScript, detectClientId, flush, getTracker, isScriptInjected, isTrackerAvailable, track, trackError };
+export { BrowserFlagStorage, CoreFlagsManager, DatabuddyConfig, DatabuddyTracker, FlagResult, FlagState, FlagsConfig, FlagsManager, FlagsManagerOptions, StorageInterface, TrackFunction, clear, createScript, detectClientId, flush, getAnonymousId, getSessionId, getTracker, getTrackingIds, getTrackingParams, isScriptInjected, isTrackerAvailable, track, trackError };

package/dist/core/index.d.ts

@@ -1,7 +1,7 @@
 import { S as StorageInterface, F as FlagsManager, a as FlagsManagerOptions, b as FlagResult, c as FlagState, d as FlagsConfig } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 export { e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
-import { D as DatabuddyConfig, a as DatabuddyTracker, T as TrackFunction, b as Databuddy$1 } from '../shared/@databuddy/sdk.C8T93n5r.js';
-export { B as BaseEventProperties, e as DataAttributes, d as EventName, E as EventProperties, c as EventTypeMap, P as PropertiesForEvent, S as ScreenViewFunction, f as SetGlobalPropertiesFunction } from '../shared/@databuddy/sdk.C8T93n5r.js';
+import { D as DatabuddyConfig, a as DatabuddyTracker, T as TrackFunction } from '../shared/@databuddy/sdk.DNing6--.js';
+export { B as BaseEventProperties, d as DataAttributes, c as EventName, E as EventProperties, b as EventTypeMap, P as PropertiesForEvent, S as ScreenViewFunction, e as SetGlobalPropertiesFunction } from '../shared/@databuddy/sdk.DNing6--.js';
 
 /**
  * Auto-detect Databuddy client ID from environment variables
@@ -84,12 +84,29 @@ declare function trackError(message: string, properties?: {
     colno?: number;
     stack?: string;
     error_type?: string;
-    [key: string]: any;
+    [key: string]: string | number | boolean | null | undefined;
 }): Promise<void>;
-
 /**
- * @deprecated Use Databuddy from `@databuddy/sdk/react` instead
+ * Get anonymous ID from multiple sources
+ * Priority: URL params > tracker instance > localStorage
+ */
+declare function getAnonymousId(urlParams?: URLSearchParams): string | null;
+/**
+ * Get session ID from multiple sources
+ * Priority: URL params > tracker instance > sessionStorage
+ */
+declare function getSessionId(urlParams?: URLSearchParams): string | null;
+/**
+ * Get tracking IDs (anonymous ID and session ID) from multiple sources
+ * Priority: URL params > tracker instance > localStorage/sessionStorage
+ */
+declare function getTrackingIds(urlParams?: URLSearchParams): {
+    anonId: string | null;
+    sessionId: string | null;
+};
+/**
+ * Get tracking IDs as URL search params string
  */
-declare const Databuddy: typeof Databuddy$1;
+declare function getTrackingParams(urlParams?: URLSearchParams): string;
 
-export { BrowserFlagStorage, CoreFlagsManager, Databuddy, DatabuddyConfig, DatabuddyTracker, FlagResult, FlagState, FlagsConfig, FlagsManager, FlagsManagerOptions, StorageInterface, TrackFunction, clear, createScript, detectClientId, flush, getTracker, isScriptInjected, isTrackerAvailable, track, trackError };
+export { BrowserFlagStorage, CoreFlagsManager, DatabuddyConfig, DatabuddyTracker, FlagResult, FlagState, FlagsConfig, FlagsManager, FlagsManagerOptions, StorageInterface, TrackFunction, clear, createScript, detectClientId, flush, getAnonymousId, getSessionId, getTracker, getTrackingIds, getTrackingParams, isScriptInjected, isTrackerAvailable, track, trackError };

package/dist/core/index.mjs

@@ -1,5 +1,4 @@
-import { D as Databuddy$1 } from '../shared/@databuddy/sdk.aVQee-4k.mjs';
-export { d as detectClientId } from '../shared/@databuddy/sdk.aVQee-4k.mjs';
+export { d as detectClientId } from '../shared/@databuddy/sdk.BUsPV0LH.mjs';
 export { B as BrowserFlagStorage, C as CoreFlagsManager, c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.tFAHtL2M.mjs';
 
 function isTrackerAvailable() {
@@ -21,7 +20,8 @@ const track = async (eventName, properties) => {
   }
   try {
     await tracker(eventName, properties);
-  } catch (_error) {
+  } catch (error) {
+    console.error("Databuddy tracking error:", error);
   }
 };
 function clear() {
@@ -34,7 +34,8 @@ function clear() {
   }
   try {
     tracker();
-  } catch (_error) {
+  } catch (error) {
+    console.error("Databuddy clear error:", error);
   }
 }
 function flush() {
@@ -47,13 +48,34 @@ function flush() {
   }
   try {
     tracker();
-  } catch (_error) {
+  } catch (error) {
+    console.error("Databuddy flush error:", error);
   }
 }
 function trackError(message, properties) {
   return track("error", { message, ...properties });
 }
+function getAnonymousId(urlParams) {
+  if (typeof window === "undefined") return null;
+  return urlParams?.get("anonId") || window.databuddy?.anonymousId || localStorage.getItem("did") || null;
+}
+function getSessionId(urlParams) {
+  if (typeof window === "undefined") return null;
+  return urlParams?.get("sessionId") || window.databuddy?.sessionId || sessionStorage.getItem("did_session") || null;
+}
+function getTrackingIds(urlParams) {
+  return {
+    anonId: getAnonymousId(urlParams),
+    sessionId: getSessionId(urlParams)
+  };
+}
+function getTrackingParams(urlParams) {
+  const anonId = getAnonymousId(urlParams);
+  const sessionId = getSessionId(urlParams);
+  const params = new URLSearchParams();
+  if (anonId) params.set("anonId", anonId);
+  if (sessionId) params.set("sessionId", sessionId);
+  return params.toString();
+}
 
-const Databuddy = Databuddy$1;
-
-export { Databuddy, clear, flush, getTracker, isTrackerAvailable, track, trackError };
+export { clear, flush, getAnonymousId, getSessionId, getTracker, getTrackingIds, getTrackingParams, isTrackerAvailable, track, trackError };

package/dist/node/index.d.mts

@@ -5,57 +5,85 @@ interface Logger {
     debug(msg: string, data?: Record<string, unknown>): void;
 }
 
+/**
+ * Middleware function that can transform or filter events
+ * Return null to drop the event, or return a modified event
+ */
+type Middleware = (event: BatchEventInput) => BatchEventInput | null | Promise<BatchEventInput | null>;
 interface DatabuddyConfig {
+    /** Client ID from Databuddy dashboard */
     clientId: string;
+    /** Custom API endpoint (default: https://basket.databuddy.cc) */
     apiUrl?: string;
+    /** Enable debug logging */
     debug?: boolean;
+    /** Custom logger instance */
     logger?: Logger;
-    /**
-     * Enable automatic batching of events
-     * Default: true
-     */
+    /** Enable automatic batching (default: true) */
     enableBatching?: boolean;
-    /**
-     * Number of events to batch before auto-flushing
-     * Default: 10, Max: 100
-     */
+    /** Number of events to batch before flushing (default: 10, max: 100) */
     batchSize?: number;
-    /**
-     * Time in milliseconds before auto-flushing batched events
-     * Default: 2000ms (2 seconds)
-     */
+    /** Time in ms before auto-flushing batched events (default: 2000) */
     batchTimeout?: number;
-    /**
-     * Maximum number of events to queue before auto-flushing
-     * Default: 1000
-     */
+    /** Maximum number of events to queue (default: 1000) */
     maxQueueSize?: number;
+    /** Middleware functions to transform events */
+    middleware?: Middleware[];
+    /** Enable event deduplication based on eventId (default: true) */
+    enableDeduplication?: boolean;
+    /** Maximum deduplication cache size (default: 10000) */
+    maxDeduplicationCacheSize?: number;
 }
 interface CustomEventInput {
+    /** Event name (required) */
     name: string;
+    /** Unique event ID for deduplication */
     eventId?: string;
+    /** Anonymous user ID */
     anonymousId?: string | null;
+    /** Session ID */
     sessionId?: string | null;
+    /** Event timestamp in milliseconds */
     timestamp?: number | null;
+    /** Event properties/metadata */
     properties?: Record<string, unknown> | null;
 }
 interface EventResponse {
+    /** Whether the event was successfully sent */
     success: boolean;
+    /** Server-assigned event ID */
     eventId?: string;
+    /** Error message if failed */
     error?: string;
 }
 interface BatchEventInput {
+    /** Event type */
     type: 'custom';
+    /** Event name */
     name: string;
+    /** Unique event ID for deduplication */
     eventId?: string;
+    /** Anonymous user ID */
     anonymousId?: string | null;
+    /** Session ID */
     sessionId?: string | null;
+    /** Event timestamp in milliseconds */
     timestamp?: number | null;
+    /** Event properties/metadata */
     properties?: Record<string, unknown> | null;
 }
+/**
+ * Global properties that will be attached to all events
+ */
+interface GlobalProperties {
+    [key: string]: unknown;
+}
 interface BatchEventResponse {
+    /** Whether the batch was successfully sent */
     success: boolean;
+    /** Number of events processed */
     processed?: number;
+    /** Results for each event in the batch */
     results?: Array<{
         status: string;
         type?: string;
@@ -63,6 +91,7 @@ interface BatchEventResponse {
         message?: string;
         error?: string;
     }>;
+    /** Error message if batch failed */
     error?: string;
 }
 
@@ -75,20 +104,21 @@ declare class Databuddy {
     private batchTimeout;
     private queue;
     private flushTimer;
+    private globalProperties;
+    private middleware;
+    private enableDeduplication;
+    private deduplicationCache;
+    private maxDeduplicationCacheSize;
     constructor(config: DatabuddyConfig);
     /**
      * Track a custom event
-     * If batching is enabled, queues the event and auto-flushes when batch size is reached or timeout expires
-     * If batching is disabled, sends the event immediately
-     *
-     * @param event - Custom event data
-     * @returns Response indicating success or failure
-     *
+     * @param event - Event data to track
+     * @returns Promise with success/error response
      * @example
      * ```typescript
      * await client.track({
      *   name: 'user_signup',
-     *   properties: { plan: 'pro' }
+     *   properties: { plan: 'pro', source: 'web' }
      * });
      * ```
      */
@@ -97,26 +127,19 @@ declare class Databuddy {
     private scheduleFlush;
     /**
      * Manually flush all queued events
-     * Important for serverless/stateless environments where you need to ensure events are sent before the process exits
-     *
-     * @returns Response with batch results
-     *
+     * Useful in serverless environments to ensure events are sent before process exits
+     * @returns Promise with batch results
      * @example
      * ```typescript
-     * // In serverless function
      * await client.track({ name: 'api_call' });
-     * await client.flush(); // Ensure events are sent before function exits
+     * await client.flush(); // Ensure events are sent
      * ```
      */
     flush(): Promise<BatchEventResponse>;
     /**
-     * Send multiple custom events in a single batch request
-     * Max 100 events per batch
-     * Note: Usually you don't need to call this directly - use track() with batching enabled instead
-     *
-     * @param events - Array of custom events
-     * @returns Response with results for each event
-     *
+     * Send multiple events in a single batch request
+     * @param events - Array of events to batch (max 100)
+     * @returns Promise with batch results
      * @example
      * ```typescript
      * await client.batch([
@@ -126,7 +149,89 @@ declare class Databuddy {
      * ```
      */
     batch(events: BatchEventInput[]): Promise<BatchEventResponse>;
+    /**
+     * Set global properties attached to all events
+     * Properties are merged with existing globals; event properties override globals
+     * @param properties - Properties to merge with existing globals
+     * @example
+     * ```typescript
+     * client.setGlobalProperties({ environment: 'production', version: '1.0.0' });
+     * // All subsequent events will include these properties
+     * ```
+     */
+    setGlobalProperties(properties: GlobalProperties): void;
+    /**
+     * Get current global properties
+     * @returns Copy of current global properties
+     * @example
+     * ```typescript
+     * const globals = client.getGlobalProperties();
+     * console.log(globals); // { environment: 'production', version: '1.0.0' }
+     * ```
+     */
+    getGlobalProperties(): GlobalProperties;
+    /**
+     * Clear all global properties
+     * @example
+     * ```typescript
+     * client.clearGlobalProperties();
+     * // No more global properties will be attached to events
+     * ```
+     */
+    clearGlobalProperties(): void;
+    /**
+     * Add middleware to transform events
+     * Middleware runs before deduplication and is executed in order
+     * Return null to drop the event, or return a modified event
+     * @param middleware - Middleware function
+     * @example
+     * ```typescript
+     * client.addMiddleware((event) => {
+     *   // Add custom field
+     *   event.properties = { ...event.properties, processed: true };
+     *   return event;
+     * });
+     *
+     * // Drop events matching a condition
+     * client.addMiddleware((event) => {
+     *   if (event.name === 'unwanted_event') return null;
+     *   return event;
+     * });
+     * ```
+     */
+    addMiddleware(middleware: Middleware): void;
+    /**
+     * Remove all middleware functions
+     * @example
+     * ```typescript
+     * client.clearMiddleware();
+     * // All middleware transformations removed
+     * ```
+     */
+    clearMiddleware(): void;
+    /**
+     * Get current deduplication cache size
+     * @returns Number of event IDs in cache
+     * @example
+     * ```typescript
+     * const size = client.getDeduplicationCacheSize();
+     * console.log(`Cache size: ${size}`);
+     * ```
+     */
+    getDeduplicationCacheSize(): number;
+    /**
+     * Clear the deduplication cache
+     * Useful for testing or resetting duplicate detection
+     * @example
+     * ```typescript
+     * client.clearDeduplicationCache();
+     * // All cached event IDs cleared
+     * ```
+     */
+    clearDeduplicationCache(): void;
+    private applyMiddleware;
+    private addToDeduplicationCache;
 }
 
 export { Databuddy, Databuddy as db };
-export type { BatchEventInput, BatchEventResponse, CustomEventInput, DatabuddyConfig, EventResponse, Logger };
+export type { BatchEventInput, BatchEventResponse, CustomEventInput, DatabuddyConfig, EventResponse, GlobalProperties, Logger, Middleware };