@databuddy/sdk 2.3.1 → 2.3.21

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

@@ -1,12 +1,162 @@
 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
+ * Token usage from AI model calls
  */
-declare const wrapVercelLanguageModel: (model: LanguageModelV2, buddy: Databuddy) => LanguageModelV2;
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens?: number;
+}
+/**
+ * Cost breakdown from TokenLens
+ */
+interface TokenCost {
+    inputTokenCostUSD?: number;
+    outputTokenCostUSD?: number;
+    totalTokenCostUSD?: number;
+}
+/**
+ * Tool call information
+ */
+interface ToolCallInfo {
+    toolCallCount: number;
+    toolResultCount: number;
+    toolCallNames: string[];
+}
+/**
+ * Error information for failed AI calls
+ */
+interface AIError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Complete AI call log entry
+ */
+interface AICall {
+    timestamp: Date;
+    type: "generate" | "stream";
+    model: string;
+    provider: string;
+    finishReason?: string;
+    usage: TokenUsage;
+    cost: TokenCost;
+    tools: ToolCallInfo;
+    error?: AIError;
+    durationMs: number;
+}
+/**
+ * Transport function for sending log entries
+ */
+type Transport = (call: AICall) => Promise<void> | void;
+/**
+ * Configuration options for Databuddy LLM tracking
+ */
+interface DatabuddyLLMOptions {
+    /**
+     * API endpoint for sending logs (should include /llm path)
+     * @default process.env.DATABUDDY_API_URL or 'https://basket.databuddy.cc/llm'
+     */
+    apiUrl?: string;
+    /**
+     * API key for authentication
+     * @default process.env.DATABUDDY_API_KEY
+     */
+    apiKey?: string;
+    /**
+     * Client/Website ID for tracking
+     * @default process.env.DATABUDDY_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * Custom transport function to send log entries
+     * If provided, overrides default HTTP transport
+     */
+    transport?: Transport;
+    /**
+     * Whether to compute costs using TokenLens
+     * @default true
+     */
+    computeCosts?: boolean;
+    /**
+     * Called on successful AI calls
+     */
+    onSuccess?: (call: AICall) => void;
+    /**
+     * Called on failed AI calls
+     */
+    onError?: (call: AICall) => void;
+}
+/**
+ * Configuration options for tracking individual models
+ */
+interface TrackOptions {
+    /**
+     * Transport function to send log entries
+     * If not provided, uses the transport from DatabuddyLLM instance
+     */
+    transport?: Transport;
+    /**
+     * Whether to compute costs using TokenLens
+     * @default true
+     */
+    computeCosts?: boolean;
+    /**
+     * Called on successful AI calls
+     */
+    onSuccess?: (call: AICall) => void;
+    /**
+     * Called on failed AI calls
+     */
+    onError?: (call: AICall) => void;
+}
+
+/**
+ * Create a Databuddy LLM tracking instance
+ *
+ * @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"));
+ *
+ * // Or with custom transport
+ * const { track } = databuddyLLM({
+ *   transport: async (call) => console.log(call),
+ * });
+ * ```
+ */
+declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
+    track: (model: LanguageModelV2, trackOptions?: TrackOptions) => LanguageModelV2;
+};
+/**
+ * Create an HTTP transport that sends logs to an API endpoint
+ *
+ * @example
+ * ```ts
+ * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
+ *
+ * const { track } = databuddyLLM({
+ *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
+ * });
+ * ```
+ */
+declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
 
-export { wrapVercelLanguageModel as withBuddy };
+export { databuddyLLM, httpTransport };
+export type { AICall, AIError, DatabuddyLLMOptions, TokenCost, TokenUsage, ToolCallInfo, TrackOptions, Transport };

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

@@ -1,12 +1,162 @@
 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
+ * Token usage from AI model calls
  */
-declare const wrapVercelLanguageModel: (model: LanguageModelV2, buddy: Databuddy) => LanguageModelV2;
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens?: number;
+}
+/**
+ * Cost breakdown from TokenLens
+ */
+interface TokenCost {
+    inputTokenCostUSD?: number;
+    outputTokenCostUSD?: number;
+    totalTokenCostUSD?: number;
+}
+/**
+ * Tool call information
+ */
+interface ToolCallInfo {
+    toolCallCount: number;
+    toolResultCount: number;
+    toolCallNames: string[];
+}
+/**
+ * Error information for failed AI calls
+ */
+interface AIError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Complete AI call log entry
+ */
+interface AICall {
+    timestamp: Date;
+    type: "generate" | "stream";
+    model: string;
+    provider: string;
+    finishReason?: string;
+    usage: TokenUsage;
+    cost: TokenCost;
+    tools: ToolCallInfo;
+    error?: AIError;
+    durationMs: number;
+}
+/**
+ * Transport function for sending log entries
+ */
+type Transport = (call: AICall) => Promise<void> | void;
+/**
+ * Configuration options for Databuddy LLM tracking
+ */
+interface DatabuddyLLMOptions {
+    /**
+     * API endpoint for sending logs (should include /llm path)
+     * @default process.env.DATABUDDY_API_URL or 'https://basket.databuddy.cc/llm'
+     */
+    apiUrl?: string;
+    /**
+     * API key for authentication
+     * @default process.env.DATABUDDY_API_KEY
+     */
+    apiKey?: string;
+    /**
+     * Client/Website ID for tracking
+     * @default process.env.DATABUDDY_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * Custom transport function to send log entries
+     * If provided, overrides default HTTP transport
+     */
+    transport?: Transport;
+    /**
+     * Whether to compute costs using TokenLens
+     * @default true
+     */
+    computeCosts?: boolean;
+    /**
+     * Called on successful AI calls
+     */
+    onSuccess?: (call: AICall) => void;
+    /**
+     * Called on failed AI calls
+     */
+    onError?: (call: AICall) => void;
+}
+/**
+ * Configuration options for tracking individual models
+ */
+interface TrackOptions {
+    /**
+     * Transport function to send log entries
+     * If not provided, uses the transport from DatabuddyLLM instance
+     */
+    transport?: Transport;
+    /**
+     * Whether to compute costs using TokenLens
+     * @default true
+     */
+    computeCosts?: boolean;
+    /**
+     * Called on successful AI calls
+     */
+    onSuccess?: (call: AICall) => void;
+    /**
+     * Called on failed AI calls
+     */
+    onError?: (call: AICall) => void;
+}
+
+/**
+ * Create a Databuddy LLM tracking instance
+ *
+ * @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"));
+ *
+ * // Or with custom transport
+ * const { track } = databuddyLLM({
+ *   transport: async (call) => console.log(call),
+ * });
+ * ```
+ */
+declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
+    track: (model: LanguageModelV2, trackOptions?: TrackOptions) => LanguageModelV2;
+};
+/**
+ * Create an HTTP transport that sends logs to an API endpoint
+ *
+ * @example
+ * ```ts
+ * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
+ *
+ * const { track } = databuddyLLM({
+ *   transport: httpTransport("https://api.example.com/ai-logs", "client-id", "api-key"),
+ * });
+ * ```
+ */
+declare const httpTransport: (url: string, clientId?: string, apiKey?: string) => Transport;
 
-export { wrapVercelLanguageModel as withBuddy };
+export { databuddyLLM, httpTransport };
+export type { AICall, AIError, DatabuddyLLMOptions, TokenCost, TokenUsage, ToolCallInfo, TrackOptions, Transport };

package/dist/ai/vercel/index.mjs

@@ -1,43 +1,238 @@
 import { wrapLanguageModel } from 'ai';
-import { computeCostUSD } from 'tokenlens';
 
-const buddyWare = (buddy) => {
+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');
+    const result = await computeCostUSD({
+      modelId,
+      provider,
+      usage: {
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens
+      }
+    });
+    return {
+      inputTokenCostUSD: result.inputTokenCostUSD,
+      outputTokenCostUSD: result.outputTokenCostUSD,
+      totalTokenCostUSD: result.totalTokenCostUSD
+    };
+  } catch {
+    return {};
+  }
+};
+const createDefaultTransport = (apiUrl, clientId, apiKey) => {
+  return async (call) => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+    if (clientId) {
+      headers["databuddy-client-id"] = clientId;
+    }
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(call)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to send AI log: ${response.status} ${response.statusText}`
+      );
+    }
+  };
+};
+const createMiddleware = (transport, options = {}) => {
+  const { computeCosts: shouldComputeCosts = true } = options;
   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 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 = {
+      "Content-Type": "application/json"
+    };
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+    if (clientId) {
+      headers["databuddy-client-id"] = clientId;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(call)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to send AI log: ${response.status} ${response.statusText}`
       );
-      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) => wrapLanguageModel({
-  model,
-  middleware: buddyWare()
-});
 
-export { wrapVercelLanguageModel as withBuddy };
+export { databuddyLLM, httpTransport };