@databuddy/sdk 2.3.24 → 2.3.25

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

@@ -1,5 +1,58 @@
-import { LanguageModelV2 } from '@ai-sdk/provider';
+import { LanguageModelV2, LanguageModelV3 } from '@ai-sdk/provider';
 
+/**
+ * Type guards and union types for Vercel AI SDK V2/V3 support
+ *
+ * Adapted from PostHog's AI SDK implementation:
+ * https://github.com/PostHog/posthog-js/tree/main/packages/ai
+ */
+
+type LanguageModel = LanguageModelV2 | LanguageModelV3;
+
+/**
+ * Content types for input/output arrays
+ */
+type MessageContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+} | {
+    type: "tool-call";
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+} | {
+    type: "file";
+    file: string;
+    mediaType: string;
+} | {
+    type: "image";
+    image: string;
+    mediaType: string;
+} | {
+    type: "source";
+    sourceType: string;
+    id: string;
+    url: string;
+    title: string;
+};
+/**
+ * Message format for input/output
+ */
+interface AIMessage {
+    role: string;
+    content: string | MessageContent[];
+}
 /**
  * Token usage from AI model calls
  */
@@ -8,6 +61,9 @@ interface TokenUsage {
     outputTokens: number;
     totalTokens: number;
     cachedInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    reasoningTokens?: number;
+    webSearchCount?: number;
 }
 /**
  * Cost breakdown from TokenLens
@@ -24,6 +80,7 @@ interface ToolCallInfo {
     toolCallCount: number;
     toolResultCount: number;
     toolCallNames: string[];
+    availableTools?: string[];
 }
 /**
  * Error information for failed AI calls
@@ -38,15 +95,20 @@ interface AIError {
  */
 interface AICall {
     timestamp: Date;
+    traceId: string;
     type: "generate" | "stream";
     model: string;
     provider: string;
     finishReason?: string;
+    input: AIMessage[];
+    output: AIMessage[];
     usage: TokenUsage;
     cost: TokenCost;
     tools: ToolCallInfo;
     error?: AIError;
     durationMs: number;
+    httpStatus?: number;
+    params?: Record<string, unknown>;
 }
 /**
  * Transport function for sending log entries
@@ -81,6 +143,16 @@ interface DatabuddyLLMOptions {
      * @default true
      */
     computeCosts?: boolean;
+    /**
+     * Privacy mode - when true, input/output content is not captured
+     * @default false
+     */
+    privacyMode?: boolean;
+    /**
+     * Maximum size for input/output content in bytes
+     * @default 1048576 (1MB)
+     */
+    maxContentSize?: number;
     /**
      * Called on successful AI calls
      */
@@ -99,11 +171,24 @@ interface TrackOptions {
      * If not provided, uses the transport from DatabuddyLLM instance
      */
     transport?: Transport;
+    /**
+     * Trace ID to link related calls together
+     */
+    traceId?: string;
+    /**
+     * Client ID for this specific call (overrides instance-level clientId)
+     */
+    clientId?: string;
     /**
      * Whether to compute costs using TokenLens
      * @default true
      */
     computeCosts?: boolean;
+    /**
+     * Privacy mode - when true, input/output content is not captured
+     * @default false
+     */
+    privacyMode?: boolean;
     /**
      * Called on successful AI calls
      */
@@ -115,48 +200,40 @@ interface TrackOptions {
 }
 
 /**
- * Create a Databuddy LLM tracking instance
+ * Create an HTTP transport that sends logs to an API endpoint
  *
  * @example
  * ```ts
- * import { databuddyLLM } from "@databuddy/sdk/ai/vercel";
- *
- * // Use default endpoint (basket.databuddy.cc/llm)
- * const { track } = databuddyLLM({
- *   apiKey: "your-api-key",
- * });
- *
- * // Or override with custom endpoint
- * const { track } = databuddyLLM({
- *   apiUrl: "https://custom.example.com/llm",
- *   apiKey: "your-api-key",
- * });
- *
- * // Track a model
- * const model = track(openai("gpt-4"));
+ * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
  *
- * // Or with custom transport
  * const { track } = databuddyLLM({
- *   transport: async (call) => console.log(call),
+ *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
  * });
  * ```
  */
-declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
-    track: (model: LanguageModelV2, trackOptions?: TrackOptions) => LanguageModelV2;
-};
+declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
+
 /**
- * Create an HTTP transport that sends logs to an API endpoint
+ * Vercel AI SDK middleware for Databuddy
+ *
+ * Inspired by and adapted from PostHog's AI SDK implementation:
+ * https://github.com/PostHog/posthog-js/tree/main/packages/ai
+ */
+
+/**
+ * Create a Databuddy LLM tracking instance
  *
  * @example
  * ```ts
- * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
+ * import { databuddyLLM } from "@databuddy/sdk/ai/vercel";
  *
- * const { track } = databuddyLLM({
- *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
- * });
+ * const { track } = databuddyLLM({ apiKey: "your-api-key" });
+ * const model = track(openai("gpt-4"));
  * ```
  */
-declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
+declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
+    track: <T extends LanguageModel>(model: T, trackOptions?: TrackOptions) => T;
+};
 
 export { databuddyLLM, httpTransport };
 export type { AICall, AIError, DatabuddyLLMOptions, TokenCost, TokenUsage, ToolCallInfo, TrackOptions, Transport };

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

@@ -1,5 +1,58 @@
-import { LanguageModelV2 } from '@ai-sdk/provider';
+import { LanguageModelV2, LanguageModelV3 } from '@ai-sdk/provider';
 
+/**
+ * Type guards and union types for Vercel AI SDK V2/V3 support
+ *
+ * Adapted from PostHog's AI SDK implementation:
+ * https://github.com/PostHog/posthog-js/tree/main/packages/ai
+ */
+
+type LanguageModel = LanguageModelV2 | LanguageModelV3;
+
+/**
+ * Content types for input/output arrays
+ */
+type MessageContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+} | {
+    type: "tool-call";
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+} | {
+    type: "file";
+    file: string;
+    mediaType: string;
+} | {
+    type: "image";
+    image: string;
+    mediaType: string;
+} | {
+    type: "source";
+    sourceType: string;
+    id: string;
+    url: string;
+    title: string;
+};
+/**
+ * Message format for input/output
+ */
+interface AIMessage {
+    role: string;
+    content: string | MessageContent[];
+}
 /**
  * Token usage from AI model calls
  */
@@ -8,6 +61,9 @@ interface TokenUsage {
     outputTokens: number;
     totalTokens: number;
     cachedInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    reasoningTokens?: number;
+    webSearchCount?: number;
 }
 /**
  * Cost breakdown from TokenLens
@@ -24,6 +80,7 @@ interface ToolCallInfo {
     toolCallCount: number;
     toolResultCount: number;
     toolCallNames: string[];
+    availableTools?: string[];
 }
 /**
  * Error information for failed AI calls
@@ -38,15 +95,20 @@ interface AIError {
  */
 interface AICall {
     timestamp: Date;
+    traceId: string;
     type: "generate" | "stream";
     model: string;
     provider: string;
     finishReason?: string;
+    input: AIMessage[];
+    output: AIMessage[];
     usage: TokenUsage;
     cost: TokenCost;
     tools: ToolCallInfo;
     error?: AIError;
     durationMs: number;
+    httpStatus?: number;
+    params?: Record<string, unknown>;
 }
 /**
  * Transport function for sending log entries
@@ -81,6 +143,16 @@ interface DatabuddyLLMOptions {
      * @default true
      */
     computeCosts?: boolean;
+    /**
+     * Privacy mode - when true, input/output content is not captured
+     * @default false
+     */
+    privacyMode?: boolean;
+    /**
+     * Maximum size for input/output content in bytes
+     * @default 1048576 (1MB)
+     */
+    maxContentSize?: number;
     /**
      * Called on successful AI calls
      */
@@ -99,11 +171,24 @@ interface TrackOptions {
      * If not provided, uses the transport from DatabuddyLLM instance
      */
     transport?: Transport;
+    /**
+     * Trace ID to link related calls together
+     */
+    traceId?: string;
+    /**
+     * Client ID for this specific call (overrides instance-level clientId)
+     */
+    clientId?: string;
     /**
      * Whether to compute costs using TokenLens
      * @default true
      */
     computeCosts?: boolean;
+    /**
+     * Privacy mode - when true, input/output content is not captured
+     * @default false
+     */
+    privacyMode?: boolean;
     /**
      * Called on successful AI calls
      */
@@ -115,48 +200,40 @@ interface TrackOptions {
 }
 
 /**
- * Create a Databuddy LLM tracking instance
+ * Create an HTTP transport that sends logs to an API endpoint
  *
  * @example
  * ```ts
- * import { databuddyLLM } from "@databuddy/sdk/ai/vercel";
- *
- * // Use default endpoint (basket.databuddy.cc/llm)
- * const { track } = databuddyLLM({
- *   apiKey: "your-api-key",
- * });
- *
- * // Or override with custom endpoint
- * const { track } = databuddyLLM({
- *   apiUrl: "https://custom.example.com/llm",
- *   apiKey: "your-api-key",
- * });
- *
- * // Track a model
- * const model = track(openai("gpt-4"));
+ * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
  *
- * // Or with custom transport
  * const { track } = databuddyLLM({
- *   transport: async (call) => console.log(call),
+ *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
  * });
  * ```
  */
-declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
-    track: (model: LanguageModelV2, trackOptions?: TrackOptions) => LanguageModelV2;
-};
+declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
+
 /**
- * Create an HTTP transport that sends logs to an API endpoint
+ * Vercel AI SDK middleware for Databuddy
+ *
+ * Inspired by and adapted from PostHog's AI SDK implementation:
+ * https://github.com/PostHog/posthog-js/tree/main/packages/ai
+ */
+
+/**
+ * Create a Databuddy LLM tracking instance
  *
  * @example
  * ```ts
- * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
+ * import { databuddyLLM } from "@databuddy/sdk/ai/vercel";
  *
- * const { track } = databuddyLLM({
- *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
- * });
+ * const { track } = databuddyLLM({ apiKey: "your-api-key" });
+ * const model = track(openai("gpt-4"));
  * ```
  */
-declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
+declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
+    track: <T extends LanguageModel>(model: T, trackOptions?: TrackOptions) => T;
+};
 
 export { databuddyLLM, httpTransport };
 export type { AICall, AIError, DatabuddyLLMOptions, TokenCost, TokenUsage, ToolCallInfo, TrackOptions, Transport };

package/dist/ai/vercel/index.mjs

@@ -1,19 +1,3 @@
-import { wrapLanguageModel } from 'ai';
-
-const extractToolInfo = (content) => {
-  const toolCalls = content.filter((part) => part.type === "tool-call");
-  const toolResults = content.filter((part) => part.type === "tool-result");
-  const toolCallNames = [
-    ...new Set(
-      toolCalls.map((c) => c.toolName).filter((name) => Boolean(name))
-    )
-  ];
-  return {
-    toolCallCount: toolCalls.length,
-    toolResultCount: toolResults.length,
-    toolCallNames
-  };
-};
 const computeCosts = async (modelId, provider, usage) => {
   try {
     const { computeCostUSD } = await import('tokenlens');
@@ -34,6 +18,337 @@ const computeCosts = async (modelId, provider, usage) => {
     return {};
   }
 };
+
+const extractTokenCount = (value) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (value && typeof value === "object" && "total" in value && typeof value.total === "number") {
+    return value.total;
+  }
+  return void 0;
+};
+const extractReasoningTokens = (usage) => {
+  if ("reasoningTokens" in usage && typeof usage.reasoningTokens === "number") {
+    return usage.reasoningTokens;
+  }
+  if ("outputTokens" in usage && usage.outputTokens && typeof usage.outputTokens === "object" && "reasoning" in usage.outputTokens && typeof usage.outputTokens.reasoning === "number") {
+    return usage.outputTokens.reasoning;
+  }
+  return void 0;
+};
+const extractCacheReadTokens = (usage) => {
+  if ("cachedInputTokens" in usage && typeof usage.cachedInputTokens === "number") {
+    return usage.cachedInputTokens;
+  }
+  if ("inputTokens" in usage && usage.inputTokens && typeof usage.inputTokens === "object" && "cacheRead" in usage.inputTokens && typeof usage.inputTokens.cacheRead === "number") {
+    return usage.inputTokens.cacheRead;
+  }
+  return void 0;
+};
+const extractCacheCreationTokens = (providerMetadata) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "cacheCreationInputTokens" in providerMetadata.anthropic && typeof providerMetadata.anthropic.cacheCreationInputTokens === "number") {
+    return providerMetadata.anthropic.cacheCreationInputTokens;
+  }
+  return void 0;
+};
+const calculateWebSearchCount = (result) => {
+  if (!result || typeof result !== "object") {
+    return 0;
+  }
+  if (result.usage && typeof result.usage === "object" && result.usage !== null && "search_context_size" in result.usage && result.usage.search_context_size) {
+    return 1;
+  }
+  return 0;
+};
+const extractWebSearchCount = (providerMetadata, usage) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "server_tool_use" in providerMetadata.anthropic) {
+    const serverToolUse = providerMetadata.anthropic.server_tool_use;
+    if (serverToolUse && typeof serverToolUse === "object" && "web_search_requests" in serverToolUse && typeof serverToolUse.web_search_requests === "number") {
+      return serverToolUse.web_search_requests;
+    }
+  }
+  return calculateWebSearchCount({ usage});
+};
+const extractToolInfo = (content, params) => {
+  const toolCalls = content.filter((part) => part.type === "tool-call");
+  const toolResults = content.filter((part) => part.type === "tool-result");
+  const toolCallNames = [
+    ...new Set(
+      toolCalls.map((c) => c.toolName).filter((name) => Boolean(name))
+    )
+  ];
+  const availableTools = params?.tools?.map((t) => t.name) ?? [];
+  return {
+    toolCallCount: toolCalls.length,
+    toolResultCount: toolResults.length,
+    toolCallNames,
+    availableTools: availableTools.length > 0 ? availableTools : void 0
+  };
+};
+const extractAdditionalTokenValues = (providerMetadata) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "cacheCreationInputTokens" in providerMetadata.anthropic) {
+    return {
+      cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
+    };
+  }
+  return {};
+};
+const extractUsage = (usage, providerMetadata) => {
+  const usageObj = usage;
+  const inputTokens = extractTokenCount(usage.inputTokens) ?? 0;
+  const outputTokens = extractTokenCount(usage.outputTokens) ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  const cachedInputTokens = extractCacheReadTokens(usageObj);
+  const cacheCreationInputTokens = extractCacheCreationTokens(providerMetadata);
+  const reasoningTokens = extractReasoningTokens(usageObj);
+  const webSearchCount = extractWebSearchCount(providerMetadata, usage);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningTokens,
+    webSearchCount
+  };
+};
+const adjustAnthropicV3CacheTokens = (model, provider, usage) => {
+  if (model.specificationVersion === "v3" && provider.toLowerCase().includes("anthropic")) {
+    const cacheReadTokens = usage.cachedInputTokens ?? 0;
+    const cacheWriteTokens = usage.cacheCreationInputTokens ?? 0;
+    const cacheTokens = cacheReadTokens + cacheWriteTokens;
+    if (usage.inputTokens && cacheTokens > 0) {
+      usage.inputTokens = Math.max(usage.inputTokens - cacheTokens, 0);
+      usage.totalTokens = usage.inputTokens + usage.outputTokens;
+    }
+  }
+};
+
+const MAX_TEXT_LENGTH = 1e5;
+const DATA_URL_REGEX = /^data:([^;,]+)/;
+const WHITESPACE_REGEX = /\s/;
+const BASE64_REGEX = /^[A-Za-z0-9+/=]+$/;
+const truncate = (text, maxLength = MAX_TEXT_LENGTH) => {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} chars]`;
+};
+const redactBase64DataUrl = (data) => {
+  if (data.startsWith("data:")) {
+    const match = data.match(DATA_URL_REGEX);
+    const mediaType = match?.[1] ?? "unknown";
+    return `[${mediaType} data URL redacted]`;
+  }
+  if (data.length > 1e3 && !WHITESPACE_REGEX.test(data) && BASE64_REGEX.test(data)) {
+    return `[base64 data redacted - ${data.length} chars]`;
+  }
+  return data;
+};
+const toContentString = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((c) => {
+      if (typeof c === "string") {
+        return c;
+      }
+      if (c && typeof c === "object" && "text" in c) {
+        return c.text;
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+};
+const generateTraceId = () => {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+};
+
+const mapPromptToMessages = (prompt, maxSize) => {
+  const messages = prompt.map((message) => {
+    if (message.role === "system") {
+      return {
+        role: "system",
+        content: truncate(toContentString(message.content))
+      };
+    }
+    if (Array.isArray(message.content)) {
+      const content = message.content.map((c) => {
+        if (c.type === "text") {
+          return { type: "text", text: truncate(c.text) };
+        }
+        if (c.type === "file") {
+          const data = c.data;
+          const fileData = data instanceof URL ? data.toString() : typeof data === "string" ? redactBase64DataUrl(data) : "[binary file]";
+          return { type: "file", file: fileData, mediaType: c.mediaType };
+        }
+        if (c.type === "image") {
+          const data = c.image;
+          const imageData = data instanceof URL ? data.toString() : typeof data === "string" ? redactBase64DataUrl(data) : "[binary image]";
+          return {
+            type: "image",
+            image: imageData,
+            mediaType: c.mimeType ?? "image/unknown"
+          };
+        }
+        if (c.type === "tool-call") {
+          const input = c.input;
+          return {
+            type: "tool-call",
+            id: c.toolCallId,
+            function: {
+              name: c.toolName,
+              arguments: truncate(
+                typeof input === "string" ? input : JSON.stringify(input ?? {})
+              )
+            }
+          };
+        }
+        if (c.type === "tool-result") {
+          return {
+            type: "tool-result",
+            toolCallId: c.toolCallId,
+            toolName: c.toolName,
+            output: c.output,
+            isError: false
+          };
+        }
+        return { type: "text", text: "" };
+      });
+      return { role: message.role, content };
+    }
+    return {
+      role: message.role,
+      content: truncate(toContentString(message.content))
+    };
+  });
+  try {
+    let serialized = JSON.stringify(messages);
+    let removedCount = 0;
+    const initialSize = messages.length;
+    for (let i = 0; i < initialSize && Buffer.byteLength(serialized, "utf8") > maxSize; i++) {
+      messages.shift();
+      removedCount++;
+      serialized = JSON.stringify(messages);
+    }
+    if (removedCount > 0) {
+      messages.unshift({
+        role: "system",
+        content: `[${removedCount} message${removedCount === 1 ? "" : "s"} removed due to size limit]`
+      });
+    }
+  } catch (error) {
+    console.error("Error stringifying inputs", error);
+    return [
+      {
+        role: "system",
+        content: "An error occurred while processing your request. Please try again."
+      }
+    ];
+  }
+  return messages;
+};
+const mapResultToMessages = (content) => {
+  const mappedContent = content.map((item) => {
+    if (item.type === "text") {
+      return { type: "text", text: truncate(item.text ?? "") };
+    }
+    if (item.type === "reasoning") {
+      return { type: "reasoning", text: truncate(item.text ?? "") };
+    }
+    if (item.type === "tool-call") {
+      const toolItem = item;
+      const rawArgs = toolItem.args ?? toolItem.arguments ?? toolItem.input;
+      const argsValue = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs ?? {});
+      return {
+        type: "tool-call",
+        id: toolItem.toolCallId ?? "",
+        function: {
+          name: toolItem.toolName ?? "",
+          arguments: truncate(argsValue)
+        }
+      };
+    }
+    if (item.type === "file") {
+      let fileData;
+      if (item.data instanceof URL) {
+        fileData = item.data.toString();
+      } else if (typeof item.data === "string") {
+        fileData = redactBase64DataUrl(item.data);
+        if (fileData === item.data && item.data.length > 1e3) {
+          fileData = `[${item.mediaType ?? "unknown"} file - ${item.data.length} bytes]`;
+        }
+      } else {
+        fileData = "[binary file]";
+      }
+      return {
+        type: "file",
+        file: fileData,
+        mediaType: item.mediaType ?? "application/octet-stream"
+      };
+    }
+    if (item.type === "source") {
+      return {
+        type: "source",
+        sourceType: item.sourceType ?? "unknown",
+        id: item.id ?? "",
+        url: item.url ?? "",
+        title: item.title ?? ""
+      };
+    }
+    return { type: "text", text: truncate(JSON.stringify(item)) };
+  });
+  if (mappedContent.length === 0) {
+    return [];
+  }
+  return [
+    {
+      role: "assistant",
+      content: mappedContent.length === 1 && mappedContent[0].type === "text" ? mappedContent[0].text : mappedContent
+    }
+  ];
+};
+const buildStreamOutput = (generatedText, reasoningText, toolCalls, sources = []) => {
+  const outputContent = [];
+  if (reasoningText) {
+    outputContent.push({ type: "reasoning", text: truncate(reasoningText) });
+  }
+  if (generatedText) {
+    outputContent.push({ type: "text", text: truncate(generatedText) });
+  }
+  for (const toolCall of toolCalls.values()) {
+    outputContent.push({
+      type: "tool-call",
+      id: toolCall.toolCallId,
+      function: {
+        name: toolCall.toolName,
+        arguments: truncate(toolCall.input)
+      }
+    });
+  }
+  for (const source of sources) {
+    outputContent.push({
+      type: "source",
+      sourceType: source.sourceType,
+      id: source.id,
+      url: source.url,
+      title: source.title
+    });
+  }
+  if (outputContent.length === 0) {
+    return [];
+  }
+  return [
+    {
+      role: "assistant",
+      content: outputContent.length === 1 && outputContent[0].type === "text" ? outputContent[0].text : outputContent
+    }
+  ];
+};
+
 const createDefaultTransport = (apiUrl, clientId, apiKey) => {
   return async (call) => {
     const headers = {
@@ -57,160 +372,6 @@ const createDefaultTransport = (apiUrl, clientId, apiKey) => {
     }
   };
 };
-const createMiddleware = (transport, options = {}) => {
-  const { computeCosts: shouldComputeCosts = true } = options;
-  return {
-    wrapGenerate: async ({ doGenerate, model }) => {
-      const startTime = Date.now();
-      try {
-        const result = await doGenerate();
-        const durationMs = Date.now() - startTime;
-        const tools = extractToolInfo(
-          result.content
-        );
-        const inputTokens = result.usage.inputTokens ?? 0;
-        const outputTokens = result.usage.outputTokens ?? 0;
-        const totalTokens = result.usage.totalTokens ?? inputTokens + outputTokens;
-        const cachedInputTokens = result.usage.cachedInputTokens;
-        const cost = shouldComputeCosts && (inputTokens > 0 || outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
-          inputTokens,
-          outputTokens
-        }) : {};
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "generate",
-          model: model.modelId,
-          provider: model.provider,
-          finishReason: result.finishReason,
-          usage: {
-            inputTokens,
-            outputTokens,
-            totalTokens,
-            cachedInputTokens
-          },
-          cost,
-          tools,
-          durationMs
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onSuccess?.(call);
-        return result;
-      } catch (error) {
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "generate",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs,
-          error: {
-            name: error instanceof Error ? error.name : "UnknownError",
-            message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          }
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onError?.(call);
-        throw error;
-      }
-    },
-    wrapStream: async ({ doStream, model }) => {
-      const startTime = Date.now();
-      try {
-        const { stream, ...rest } = await doStream();
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "stream",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onSuccess?.(call);
-        return { stream, ...rest };
-      } catch (error) {
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "stream",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs,
-          error: {
-            name: error instanceof Error ? error.name : "UnknownError",
-            message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          }
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onError?.(call);
-        throw error;
-      }
-    }
-  };
-};
-const databuddyLLM = (options = {}) => {
-  const {
-    apiUrl,
-    apiKey,
-    clientId,
-    transport: customTransport,
-    computeCosts: defaultComputeCosts = true,
-    onSuccess: defaultOnSuccess,
-    onError: defaultOnError
-  } = options;
-  let transport;
-  if (customTransport) {
-    transport = customTransport;
-  } else {
-    const endpoint = apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm";
-    const client = clientId ?? process.env.DATABUDDY_CLIENT_ID;
-    const key = apiKey ?? process.env.DATABUDDY_API_KEY;
-    transport = createDefaultTransport(endpoint, client, key);
-  }
-  const track = (model, trackOptions = {}) => {
-    return wrapLanguageModel({
-      model,
-      middleware: createMiddleware(transport, {
-        computeCosts: trackOptions.computeCosts ?? defaultComputeCosts,
-        onSuccess: trackOptions.onSuccess ?? defaultOnSuccess,
-        onError: trackOptions.onError ?? defaultOnError,
-        transport: trackOptions.transport
-      })
-    });
-  };
-  return { track };
-};
 const httpTransport = (url, clientId, apiKey) => {
   return async (call) => {
     const headers = {
@@ -235,4 +396,328 @@ const httpTransport = (url, clientId, apiKey) => {
   };
 };
 
+const MAX_CONTENT_SIZE = 1048576;
+const extractProvider = (model) => {
+  return model.provider.toLowerCase().split(".")[0];
+};
+const createErrorCall = (traceId, type, model, provider, input, durationMs, error) => {
+  return {
+    timestamp: /* @__PURE__ */ new Date(),
+    traceId,
+    type,
+    model,
+    provider,
+    input,
+    output: [],
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    cost: {},
+    tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
+    durationMs,
+    error: {
+      name: error instanceof Error ? error.name : "UnknownError",
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    }
+  };
+};
+const sendCall = (call, transport, onSuccess, onError) => {
+  Promise.resolve(transport(call)).catch((error) => {
+    console.error("[databuddy] Failed to send AI log:", error);
+  });
+  call.error ? onError?.(call) : onSuccess?.(call);
+};
+const databuddyLLM = (options = {}) => {
+  const {
+    apiUrl,
+    apiKey,
+    clientId,
+    transport: customTransport,
+    computeCosts: defaultComputeCosts = true,
+    privacyMode: defaultPrivacyMode = false,
+    maxContentSize = MAX_CONTENT_SIZE,
+    onSuccess: defaultOnSuccess,
+    onError: defaultOnError
+  } = options;
+  const transport = customTransport ? customTransport : createDefaultTransport(
+    apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm",
+    clientId ?? process.env.DATABUDDY_CLIENT_ID,
+    apiKey ?? process.env.DATABUDDY_API_KEY
+  );
+  const track = (model, trackOptions = {}) => {
+    const getEffectiveTransport = () => {
+      if (trackOptions.transport) {
+        return trackOptions.transport;
+      }
+      if (trackOptions.clientId && trackOptions.clientId !== clientId) {
+        return createDefaultTransport(
+          apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm",
+          trackOptions.clientId,
+          apiKey ?? process.env.DATABUDDY_API_KEY
+        );
+      }
+      return transport;
+    };
+    return Object.create(model, {
+      doGenerate: {
+        value: async (params) => {
+          const startTime = Date.now();
+          const traceId = trackOptions.traceId ?? generateTraceId();
+          const effectiveTransport = getEffectiveTransport();
+          try {
+            const result = await model.doGenerate(params);
+            const durationMs = Date.now() - startTime;
+            const tools = extractToolInfo(
+              result.content,
+              params
+            );
+            const provider = extractProvider(model);
+            const usage = extractUsage(result.usage, result.providerMetadata);
+            adjustAnthropicV3CacheTokens(model, provider, usage);
+            const cost = (trackOptions.computeCosts ?? defaultComputeCosts) && (usage.inputTokens > 0 || usage.outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
+              inputTokens: usage.inputTokens,
+              outputTokens: usage.outputTokens
+            }) : {};
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const output = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapResultToMessages(
+              result.content
+            );
+            const rawFinishReason = result.finishReason;
+            let finishReason;
+            if (typeof rawFinishReason === "string") {
+              finishReason = rawFinishReason;
+            } else if (rawFinishReason && typeof rawFinishReason === "object") {
+              if ("unified" in rawFinishReason) {
+                finishReason = rawFinishReason.unified;
+              } else if ("type" in rawFinishReason) {
+                finishReason = rawFinishReason.type;
+              }
+            }
+            const call = {
+              timestamp: /* @__PURE__ */ new Date(),
+              traceId,
+              type: "generate",
+              model: result.response?.modelId ?? model.modelId,
+              provider,
+              finishReason,
+              input,
+              output,
+              usage,
+              cost,
+              tools,
+              durationMs,
+              httpStatus: 200
+            };
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            return result;
+          } catch (error) {
+            const durationMs = Date.now() - startTime;
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const call = createErrorCall(
+              traceId,
+              "generate",
+              model.modelId,
+              extractProvider(model),
+              input,
+              durationMs,
+              error
+            );
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            throw error;
+          }
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      },
+      doStream: {
+        value: async (params) => {
+          const startTime = Date.now();
+          const traceId = trackOptions.traceId ?? generateTraceId();
+          const effectiveTransport = getEffectiveTransport();
+          try {
+            const { stream, ...rest } = await model.doStream(params);
+            let generatedText = "";
+            let reasoningText = "";
+            let finishReason;
+            let providerMetadata;
+            let usage = {};
+            const toolCallsInProgress = /* @__PURE__ */ new Map();
+            const sources = [];
+            const transformStream = new TransformStream({
+              transform(chunk, controller) {
+                if (chunk.type === "text-delta") {
+                  generatedText += chunk.delta;
+                }
+                if (chunk.type === "reasoning-delta") {
+                  reasoningText += chunk.delta;
+                }
+                if (chunk.type === "tool-input-start") {
+                  toolCallsInProgress.set(chunk.id, {
+                    toolCallId: chunk.id,
+                    toolName: chunk.toolName,
+                    input: ""
+                  });
+                }
+                if (chunk.type === "tool-input-delta") {
+                  const toolCall = toolCallsInProgress.get(chunk.id);
+                  if (toolCall) {
+                    toolCall.input += chunk.delta;
+                  }
+                }
+                if (chunk.type === "tool-call") {
+                  const input = chunk.input;
+                  toolCallsInProgress.set(chunk.toolCallId, {
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    input: typeof input === "string" ? input : JSON.stringify(input ?? {})
+                  });
+                }
+                if (chunk.type === "source") {
+                  const sourceChunk = chunk;
+                  sources.push({
+                    sourceType: sourceChunk.sourceType ?? "unknown",
+                    id: sourceChunk.id ?? "",
+                    url: sourceChunk.url ?? "",
+                    title: sourceChunk.title ?? ""
+                  });
+                }
+                if (chunk.type === "finish") {
+                  providerMetadata = chunk.providerMetadata;
+                  const additionalTokenValues = extractAdditionalTokenValues(
+                    providerMetadata
+                  );
+                  const chunkUsage = chunk.usage ?? {};
+                  usage = {
+                    inputTokens: extractTokenCount(chunk.usage?.inputTokens),
+                    outputTokens: extractTokenCount(chunk.usage?.outputTokens),
+                    reasoningTokens: extractReasoningTokens(chunkUsage),
+                    cacheReadInputTokens: extractCacheReadTokens(chunkUsage),
+                    ...additionalTokenValues
+                  };
+                  const rawFinishReason = chunk.finishReason;
+                  if (typeof rawFinishReason === "string") {
+                    finishReason = rawFinishReason;
+                  } else if (rawFinishReason && typeof rawFinishReason === "object") {
+                    if ("unified" in rawFinishReason) {
+                      finishReason = rawFinishReason.unified;
+                    } else if ("type" in rawFinishReason) {
+                      finishReason = rawFinishReason.type;
+                    }
+                  }
+                }
+                controller.enqueue(chunk);
+              },
+              flush: async () => {
+                const durationMs = Date.now() - startTime;
+                const webSearchCount = extractWebSearchCount(
+                  providerMetadata,
+                  usage
+                );
+                const finalUsageObj = {
+                  ...usage,
+                  webSearchCount
+                };
+                const finalUsage = extractUsage(
+                  finalUsageObj,
+                  providerMetadata
+                );
+                const provider = extractProvider(model);
+                adjustAnthropicV3CacheTokens(model, provider, finalUsage);
+                const output = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : buildStreamOutput(
+                  generatedText,
+                  reasoningText,
+                  toolCallsInProgress,
+                  sources
+                );
+                const tools = {
+                  toolCallCount: toolCallsInProgress.size,
+                  toolResultCount: 0,
+                  toolCallNames: [
+                    ...new Set(
+                      [...toolCallsInProgress.values()].map((t) => t.toolName)
+                    )
+                  ],
+                  availableTools: params.tools?.map((t) => t.name)
+                };
+                const cost = (trackOptions.computeCosts ?? defaultComputeCosts) && (finalUsage.inputTokens > 0 || finalUsage.outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
+                  inputTokens: finalUsage.inputTokens,
+                  outputTokens: finalUsage.outputTokens
+                }) : {};
+                const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+                  params.prompt,
+                  maxContentSize
+                );
+                const call = {
+                  timestamp: /* @__PURE__ */ new Date(),
+                  traceId,
+                  type: "stream",
+                  model: model.modelId,
+                  provider,
+                  finishReason,
+                  input,
+                  output,
+                  usage: finalUsage,
+                  cost,
+                  tools,
+                  durationMs,
+                  httpStatus: 200
+                };
+                sendCall(
+                  call,
+                  effectiveTransport,
+                  trackOptions.onSuccess ?? defaultOnSuccess,
+                  trackOptions.onError ?? defaultOnError
+                );
+              }
+            });
+            return { stream: stream.pipeThrough(transformStream), ...rest };
+          } catch (error) {
+            const durationMs = Date.now() - startTime;
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const call = createErrorCall(
+              traceId,
+              "stream",
+              model.modelId,
+              extractProvider(model),
+              input,
+              durationMs,
+              error
+            );
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            throw error;
+          }
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      }
+    });
+  };
+  return { track };
+};
+
 export { databuddyLLM, httpTransport };

package/dist/core/index.mjs

@@ -1,4 +1,4 @@
-export { c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.z1buNzG1.mjs';
+export { c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.d6Qh5SSI.mjs';
 
 function detectClientId(providedClientId) {
   if (providedClientId) {

package/dist/react/index.mjs

@@ -2,7 +2,7 @@
 
 import { detectClientId } from '../core/index.mjs';
 export { clear, flush, getAnonymousId, getSessionId, getTracker, getTrackingIds, getTrackingParams, isTrackerAvailable, track, trackError } from '../core/index.mjs';
-import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.z1buNzG1.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.d6Qh5SSI.mjs';
 import React, { useRef, useMemo, useEffect, useSyncExternalStore, createContext, useContext } from 'react';
 import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.DE24-JrU.mjs';
 import { l as logger } from '../shared/@databuddy/sdk.CALvx07o.mjs';

package/dist/shared/@databuddy/{sdk.z1buNzG1.mjs → sdk.d6Qh5SSI.mjs}

@@ -1,4 +1,4 @@
-const version = "2.3.23";
+const version = "2.3.3";
 
 const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
 function isScriptInjected() {

package/dist/vue/index.mjs

@@ -1,5 +1,5 @@
 import { defineComponent, ref, onMounted, onUnmounted, watch, reactive, watchEffect, computed } from 'vue';
-import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.z1buNzG1.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.d6Qh5SSI.mjs';
 import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.DE24-JrU.mjs';
 import '../shared/@databuddy/sdk.CALvx07o.mjs';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@databuddy/sdk",
-  "version": "2.3.24",
+  "version": "2.3.25",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",
@@ -14,7 +14,7 @@
     "vscode:prepublish": "bun run build"
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^2.0.0",
+    "@ai-sdk/provider": "^3.0.2",
     "@types/node": "^20.0.0",
     "@vitejs/plugin-react": "^5.0.0",
     "ai": "^5.0.51",