@posthog/ai 7.4.1 → 7.4.3

package/dist/vercel/index.mjs

@@ -2,7 +2,7 @@ import { v4 } from 'uuid';
 import { Buffer } from 'buffer';
 import { uuidv7 } from '@posthog/core';
 
-var version = "7.4.1";
+var version = "7.4.3";
 
 // Type guards for safer type checking
 
@@ -714,242 +714,252 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
     }
   };
 
-  // Create wrapped model that preserves the original type
-  const wrappedModel = {
-    ...model,
-    doGenerate: async params => {
-      const startTime = Date.now();
-      const mergedParams = {
-        ...mergedOptions,
-        ...mapVercelParams(params)
-      };
-      const availableTools = extractAvailableToolCalls('vercel', params);
-      try {
-        const result = await model.doGenerate(params);
-        const modelId = mergedOptions.posthogModelOverride ?? (result.response?.modelId ? result.response.modelId : model.modelId);
-        const provider = mergedOptions.posthogProviderOverride ?? extractProvider(model);
-        const baseURL = ''; // cannot currently get baseURL from vercel
-        const content = mapVercelOutput(result.content);
-        const latency = (Date.now() - startTime) / 1000;
-        const providerMetadata = result.providerMetadata;
-        const additionalTokenValues = extractAdditionalTokenValues(providerMetadata);
-        const webSearchCount = extractWebSearchCount(providerMetadata, result.usage);
-
-        // V2 usage has simple numbers, V3 has objects with .total - normalize both
-        const usageObj = result.usage;
-        const usage = {
-          inputTokens: extractTokenCount(result.usage.inputTokens),
-          outputTokens: extractTokenCount(result.usage.outputTokens),
-          reasoningTokens: extractReasoningTokens(usageObj),
-          cacheReadInputTokens: extractCacheReadTokens(usageObj),
-          webSearchCount,
-          ...additionalTokenValues
+  // Create wrapped model using Object.create to preserve the prototype chain
+  // This automatically inherits all properties (including getters) from the model
+  const wrappedModel = Object.create(model, {
+    doGenerate: {
+      value: async params => {
+        const startTime = Date.now();
+        const mergedParams = {
+          ...mergedOptions,
+          ...mapVercelParams(params)
         };
-        adjustAnthropicV3CacheTokens(model, provider, usage);
-        await sendEventToPosthog({
-          client: phClient,
-          distinctId: mergedOptions.posthogDistinctId,
-          traceId: mergedOptions.posthogTraceId ?? v4(),
-          model: modelId,
-          provider: provider,
-          input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-          output: content,
-          latency,
-          baseURL,
-          params: mergedParams,
-          httpStatus: 200,
-          usage,
-          tools: availableTools,
-          captureImmediate: mergedOptions.posthogCaptureImmediate
-        });
-        return result;
-      } catch (error) {
-        const modelId = model.modelId;
-        const enrichedError = await sendEventWithErrorToPosthog({
-          client: phClient,
-          distinctId: mergedOptions.posthogDistinctId,
-          traceId: mergedOptions.posthogTraceId ?? v4(),
-          model: modelId,
-          provider: model.provider,
-          input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-          output: [],
-          latency: 0,
-          baseURL: '',
-          params: mergedParams,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error: error,
-          tools: availableTools,
-          captureImmediate: mergedOptions.posthogCaptureImmediate
-        });
-        throw enrichedError;
-      }
+        const availableTools = extractAvailableToolCalls('vercel', params);
+        try {
+          const result = await model.doGenerate(params);
+          const modelId = mergedOptions.posthogModelOverride ?? (result.response?.modelId ? result.response.modelId : model.modelId);
+          const provider = mergedOptions.posthogProviderOverride ?? extractProvider(model);
+          const baseURL = ''; // cannot currently get baseURL from vercel
+          const content = mapVercelOutput(result.content);
+          const latency = (Date.now() - startTime) / 1000;
+          const providerMetadata = result.providerMetadata;
+          const additionalTokenValues = extractAdditionalTokenValues(providerMetadata);
+          const webSearchCount = extractWebSearchCount(providerMetadata, result.usage);
+
+          // V2 usage has simple numbers, V3 has objects with .total - normalize both
+          const usageObj = result.usage;
+          const usage = {
+            inputTokens: extractTokenCount(result.usage.inputTokens),
+            outputTokens: extractTokenCount(result.usage.outputTokens),
+            reasoningTokens: extractReasoningTokens(usageObj),
+            cacheReadInputTokens: extractCacheReadTokens(usageObj),
+            webSearchCount,
+            ...additionalTokenValues
+          };
+          adjustAnthropicV3CacheTokens(model, provider, usage);
+          await sendEventToPosthog({
+            client: phClient,
+            distinctId: mergedOptions.posthogDistinctId,
+            traceId: mergedOptions.posthogTraceId ?? v4(),
+            model: modelId,
+            provider: provider,
+            input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
+            output: content,
+            latency,
+            baseURL,
+            params: mergedParams,
+            httpStatus: 200,
+            usage,
+            tools: availableTools,
+            captureImmediate: mergedOptions.posthogCaptureImmediate
+          });
+          return result;
+        } catch (error) {
+          const modelId = model.modelId;
+          const enrichedError = await sendEventWithErrorToPosthog({
+            client: phClient,
+            distinctId: mergedOptions.posthogDistinctId,
+            traceId: mergedOptions.posthogTraceId ?? v4(),
+            model: modelId,
+            provider: model.provider,
+            input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
+            output: [],
+            latency: 0,
+            baseURL: '',
+            params: mergedParams,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0
+            },
+            error: error,
+            tools: availableTools,
+            captureImmediate: mergedOptions.posthogCaptureImmediate
+          });
+          throw enrichedError;
+        }
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
     },
-    doStream: async params => {
-      const startTime = Date.now();
-      let generatedText = '';
-      let reasoningText = '';
-      let usage = {};
-      let providerMetadata = undefined;
-      const mergedParams = {
-        ...mergedOptions,
-        ...mapVercelParams(params)
-      };
-      const modelId = mergedOptions.posthogModelOverride ?? model.modelId;
-      const provider = mergedOptions.posthogProviderOverride ?? extractProvider(model);
-      const availableTools = extractAvailableToolCalls('vercel', params);
-      const baseURL = ''; // cannot currently get baseURL from vercel
-
-      // Map to track in-progress tool calls
-      const toolCallsInProgress = new Map();
-      try {
-        const {
-          stream,
-          ...rest
-        } = await model.doStream(params);
-        const transformStream = new TransformStream({
-          transform(chunk, controller) {
-            // Handle streaming patterns - compatible with both V2 and V3
-            if (chunk.type === 'text-delta') {
-              generatedText += chunk.delta;
-            }
-            if (chunk.type === 'reasoning-delta') {
-              reasoningText += chunk.delta;
-            }
+    doStream: {
+      value: async params => {
+        const startTime = Date.now();
+        let generatedText = '';
+        let reasoningText = '';
+        let usage = {};
+        let providerMetadata = undefined;
+        const mergedParams = {
+          ...mergedOptions,
+          ...mapVercelParams(params)
+        };
+        const modelId = mergedOptions.posthogModelOverride ?? model.modelId;
+        const provider = mergedOptions.posthogProviderOverride ?? extractProvider(model);
+        const availableTools = extractAvailableToolCalls('vercel', params);
+        const baseURL = ''; // cannot currently get baseURL from vercel
 
-            // Handle tool call chunks
-            if (chunk.type === 'tool-input-start') {
-              // Initialize a new tool call
-              toolCallsInProgress.set(chunk.id, {
-                toolCallId: chunk.id,
-                toolName: chunk.toolName,
-                input: ''
-              });
-            }
-            if (chunk.type === 'tool-input-delta') {
-              // Accumulate tool call arguments
-              const toolCall = toolCallsInProgress.get(chunk.id);
-              if (toolCall) {
-                toolCall.input += chunk.delta;
+        // Map to track in-progress tool calls
+        const toolCallsInProgress = new Map();
+        try {
+          const {
+            stream,
+            ...rest
+          } = await model.doStream(params);
+          const transformStream = new TransformStream({
+            transform(chunk, controller) {
+              // Handle streaming patterns - compatible with both V2 and V3
+              if (chunk.type === 'text-delta') {
+                generatedText += chunk.delta;
+              }
+              if (chunk.type === 'reasoning-delta') {
+                reasoningText += chunk.delta;
               }
-            }
-            if (chunk.type === 'tool-input-end') {
-              // Tool call is complete, keep it in the map for final processing
-            }
-            if (chunk.type === 'tool-call') {
-              // Direct tool call chunk (complete tool call)
-              toolCallsInProgress.set(chunk.toolCallId, {
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-                input: chunk.input
-              });
-            }
-            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
-              };
-            }
-            controller.enqueue(chunk);
-          },
-          flush: async () => {
-            const latency = (Date.now() - startTime) / 1000;
-            // Build content array similar to mapVercelOutput structure
-            const content = [];
-            if (reasoningText) {
-              content.push({
-                type: 'reasoning',
-                text: truncate(reasoningText)
-              });
-            }
-            if (generatedText) {
-              content.push({
-                type: 'text',
-                text: truncate(generatedText)
-              });
-            }
 
-            // Add completed tool calls to content
-            for (const toolCall of toolCallsInProgress.values()) {
-              if (toolCall.toolName) {
+              // Handle tool call chunks
+              if (chunk.type === 'tool-input-start') {
+                // Initialize a new tool call
+                toolCallsInProgress.set(chunk.id, {
+                  toolCallId: chunk.id,
+                  toolName: chunk.toolName,
+                  input: ''
+                });
+              }
+              if (chunk.type === 'tool-input-delta') {
+                // Accumulate tool call arguments
+                const toolCall = toolCallsInProgress.get(chunk.id);
+                if (toolCall) {
+                  toolCall.input += chunk.delta;
+                }
+              }
+              if (chunk.type === 'tool-input-end') {
+                // Tool call is complete, keep it in the map for final processing
+              }
+              if (chunk.type === 'tool-call') {
+                // Direct tool call chunk (complete tool call)
+                toolCallsInProgress.set(chunk.toolCallId, {
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  input: chunk.input
+                });
+              }
+              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
+                };
+              }
+              controller.enqueue(chunk);
+            },
+            flush: async () => {
+              const latency = (Date.now() - startTime) / 1000;
+              // Build content array similar to mapVercelOutput structure
+              const content = [];
+              if (reasoningText) {
                 content.push({
-                  type: 'tool-call',
-                  id: toolCall.toolCallId,
-                  function: {
-                    name: toolCall.toolName,
-                    arguments: toolCall.input
-                  }
+                  type: 'reasoning',
+                  text: truncate(reasoningText)
+                });
+              }
+              if (generatedText) {
+                content.push({
+                  type: 'text',
+                  text: truncate(generatedText)
                 });
               }
-            }
 
-            // Structure output like mapVercelOutput does
-            const output = content.length > 0 ? [{
-              role: 'assistant',
-              content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
-            }] : [];
-            const webSearchCount = extractWebSearchCount(providerMetadata, usage);
-
-            // Update usage with web search count
-            const finalUsage = {
-              ...usage,
-              webSearchCount
-            };
-            adjustAnthropicV3CacheTokens(model, provider, finalUsage);
-            await sendEventToPosthog({
-              client: phClient,
-              distinctId: mergedOptions.posthogDistinctId,
-              traceId: mergedOptions.posthogTraceId ?? v4(),
-              model: modelId,
-              provider: provider,
-              input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-              output: output,
-              latency,
-              baseURL,
-              params: mergedParams,
-              httpStatus: 200,
-              usage: finalUsage,
-              tools: availableTools,
-              captureImmediate: mergedOptions.posthogCaptureImmediate
-            });
-          }
-        });
-        return {
-          stream: stream.pipeThrough(transformStream),
-          ...rest
-        };
-      } catch (error) {
-        const enrichedError = await sendEventWithErrorToPosthog({
-          client: phClient,
-          distinctId: mergedOptions.posthogDistinctId,
-          traceId: mergedOptions.posthogTraceId ?? v4(),
-          model: modelId,
-          provider: provider,
-          input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-          output: [],
-          latency: 0,
-          baseURL: '',
-          params: mergedParams,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error: error,
-          tools: availableTools,
-          captureImmediate: mergedOptions.posthogCaptureImmediate
-        });
-        throw enrichedError;
-      }
+              // Add completed tool calls to content
+              for (const toolCall of toolCallsInProgress.values()) {
+                if (toolCall.toolName) {
+                  content.push({
+                    type: 'tool-call',
+                    id: toolCall.toolCallId,
+                    function: {
+                      name: toolCall.toolName,
+                      arguments: toolCall.input
+                    }
+                  });
+                }
+              }
+
+              // Structure output like mapVercelOutput does
+              const output = content.length > 0 ? [{
+                role: 'assistant',
+                content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+              }] : [];
+              const webSearchCount = extractWebSearchCount(providerMetadata, usage);
+
+              // Update usage with web search count
+              const finalUsage = {
+                ...usage,
+                webSearchCount
+              };
+              adjustAnthropicV3CacheTokens(model, provider, finalUsage);
+              await sendEventToPosthog({
+                client: phClient,
+                distinctId: mergedOptions.posthogDistinctId,
+                traceId: mergedOptions.posthogTraceId ?? v4(),
+                model: modelId,
+                provider: provider,
+                input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
+                output: output,
+                latency,
+                baseURL,
+                params: mergedParams,
+                httpStatus: 200,
+                usage: finalUsage,
+                tools: availableTools,
+                captureImmediate: mergedOptions.posthogCaptureImmediate
+              });
+            }
+          });
+          return {
+            stream: stream.pipeThrough(transformStream),
+            ...rest
+          };
+        } catch (error) {
+          const enrichedError = await sendEventWithErrorToPosthog({
+            client: phClient,
+            distinctId: mergedOptions.posthogDistinctId,
+            traceId: mergedOptions.posthogTraceId ?? v4(),
+            model: modelId,
+            provider: provider,
+            input: mergedOptions.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
+            output: [],
+            latency: 0,
+            baseURL: '',
+            params: mergedParams,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0
+            },
+            error: error,
+            tools: availableTools,
+            captureImmediate: mergedOptions.posthogCaptureImmediate
+          });
+          throw enrichedError;
+        }
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
     }
-  };
+  });
   return wrappedModel;
 };