fix: bun lock

Author: izadoesdev

apps/docs/app/robots.ts

@@ -20,7 +20,6 @@ export default function robots(): MetadataRoute.Robots {
 				disallow: '/',
 			},
 		],
-		sitemap: `${SITE_URL}/sitemap.xml`,
-		host: SITE_URL,
+		sitemap: `${SITE_URL}/sitemap.xml`
 	};
 }

bun.lock

@@ -11,10 +11,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "jotai": ">=2.0.0"
-  },
-  "optionalDependencies": {
-    "pino": "^9.0.0"
+    "@ai-sdk/provider": "^2.0.0",
+    "ai": "^5.0.51",
+    "jotai": ">=2.0.0",
+    "tokenlens": "^2.0.0-alpha.3"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -50,6 +50,10 @@
     "./node": {
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.mjs"
+    },
+    "./ai/vercel": {
+      "types": "./dist/ai/vercel/index.d.ts",
+      "import": "./dist/ai/vercel/index.mjs"
     }
   },
   "files": [

packages/sdk/package.json

@@ -0,0 +1 @@
+export * from './vercel';

packages/sdk/src/ai/index.ts

@@ -0,0 +1 @@
+export { wrapVercelLanguageModel as withBuddy } from './middleware';

packages/sdk/src/ai/vercel/index.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'bun:test';
+import { generateText } from 'ai';
+import { MockLanguageModelV2 } from 'ai/test';
+import { Databuddy } from '../../node';
+import { type TrackProperties, wrapVercelLanguageModel } from './middleware';
+
+const mockModel = new MockLanguageModelV2({
+	doGenerate: async () => ({
+		finishReason: 'stop',
+		usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+		content: [{ type: 'text', text: 'Hello, world!' }],
+		warnings: [],
+	}),
+});
+
+test('wrapVercelLanguageModel', async () => {
+	const buddy = new Databuddy({});
+	const model = wrapVercelLanguageModel(mockModel, buddy);
+
+	const result = await generateText({
+		model,
+		prompt: 'Hello, how are you?',
+	});
+
+	expect(result.text).toBe('Hello, world!');
+
+	const trackEntries = buddy.records.filter((r) => r.event === 'ai.generate');
+
+	expect(trackEntries.length).toBe(1);
+	const { properties: payload } = trackEntries[0] as {
+		event: string;
+		properties: TrackProperties;
+	};
+
+	expect(payload).toEqual({
+		inputTokens: 10,
+		outputTokens: 20,
+		totalTokens: 30,
+		cachedInputTokens: undefined,
+		finishReason: 'stop',
+		toolCallCount: 0,
+		toolResultCount: 0,
+		toolCallNames: [],
+	});
+});

packages/sdk/src/ai/vercel/middleware.test.ts

@@ -0,0 +1,88 @@
+import type {
+	LanguageModelV2,
+	LanguageModelV2Middleware,
+} from '@ai-sdk/provider';
+import { wrapLanguageModel } from 'ai';
+import { computeCostUSD } from 'tokenlens';
+import type { Databuddy } from '../../node';
+
+export type TrackProperties = {
+	inputTokens?: number;
+	outputTokens?: number;
+	totalTokens?: number;
+	cachedInputTokens?: number;
+	finishReason?: string;
+	toolCallCount?: number;
+	toolResultCount?: number;
+	toolCallNames?: string[];
+	inputTokenCostUSD?: number;
+	outputTokenCostUSD?: number;
+	totalTokenCostUSD?: number;
+};
+
+const buddyWare = (buddy: Databuddy): LanguageModelV2Middleware => {
+	return {
+		wrapGenerate: async ({ doGenerate, model }) => {
+			const result = await doGenerate();
+
+			const isToolCall = (
+				part: (typeof result.content)[number]
+			): part is Extract<
+				(typeof result.content)[number],
+				{ type: 'tool-call' }
+			> => part.type === 'tool-call';
+
+			const isToolResult = (
+				part: (typeof result.content)[number]
+			): part is Extract<
+				(typeof result.content)[number],
+				{ type: 'tool-result' }
+			> => 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: TrackProperties = {
+				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,
+			};
+			buddy.track({name: 'ai.generate', properties: payload});
+
+			return result;
+		},
+	};
+};
+
+/**
+ * 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
+ */
+export const wrapVercelLanguageModel = (
+	model: LanguageModelV2,
+	buddy: Databuddy
+) => {
+	return wrapLanguageModel({
+		model,
+		middleware: buddyWare(buddy),
+	});
+};