@posthog/ai 5.2.3 → 6.0.1

package/dist/vercel/index.mjs

@@ -1,4 +1,4 @@
-import { experimental_wrapLanguageModel } from 'ai';
+import { wrapLanguageModel } from 'ai';
 import { v4 } from 'uuid';
 import { Buffer } from 'buffer';
 
@@ -34,6 +34,20 @@ const truncate = str => {
     return str;
   }
 };
+
+/**
+ * Extract available tool calls from the request parameters.
+ * These are the tools provided to the LLM, not the tool calls in the response.
+ */
+const extractAvailableToolCalls = (provider, params) => {
+  {
+    // Vercel AI SDK stores tools in params.mode.tools when mode type is 'regular'
+    if (params.mode?.type === 'regular' && params.mode.tools) {
+      return params.mode.tools;
+    }
+    return null;
+  }
+};
 function sanitizeValues(obj) {
   if (obj === undefined || obj === null) {
     return obj;
@@ -141,7 +155,7 @@ const sendEventToPosthog = async ({
 const mapVercelParams = params => {
   return {
     temperature: params.temperature,
-    max_tokens: params.maxTokens,
+    max_output_tokens: params.maxOutputTokens,
     top_p: params.topP,
     frequency_penalty: params.frequencyPenalty,
     presence_penalty: params.presencePenalty,
@@ -149,79 +163,68 @@ const mapVercelParams = params => {
     stream: params.stream
   };
 };
-const mapVercelPrompt = prompt => {
-  // normalize single inputs into an array of messages
-  let promptsArray;
-  if (typeof prompt === 'string') {
-    promptsArray = [{
-      role: 'user',
-      content: prompt
-    }];
-  } else if (!Array.isArray(prompt)) {
-    promptsArray = [prompt];
-  } else {
-    promptsArray = prompt;
-  }
-
+const mapVercelPrompt = messages => {
   // Map and truncate individual content
-  const inputs = promptsArray.map(p => {
-    let content = {};
-    if (Array.isArray(p.content)) {
-      content = p.content.map(c => {
-        if (c.type === 'text') {
-          return {
-            type: 'text',
-            content: truncate(c.text)
-          };
-        } else if (c.type === 'image') {
-          return {
-            type: 'image',
-            content: {
-              // if image is a url use it, or use "none supported"
-              image: c.image instanceof URL ? c.image.toString() : 'raw images not supported',
-              mimeType: c.mimeType
-            }
-          };
-        } else if (c.type === 'file') {
-          return {
-            type: 'file',
-            content: {
+  const inputs = messages.map(message => {
+    let content;
+
+    // Handle system role which has string content
+    if (message.role === 'system') {
+      content = [{
+        type: 'text',
+        text: truncate(String(message.content))
+      }];
+    } else {
+      // Handle other roles which have array content
+      if (Array.isArray(message.content)) {
+        content = message.content.map(c => {
+          if (c.type === 'text') {
+            return {
+              type: 'text',
+              text: truncate(c.text)
+            };
+          } else if (c.type === 'file') {
+            return {
+              type: 'file',
               file: c.data instanceof URL ? c.data.toString() : 'raw files not supported',
-              mimeType: c.mimeType
-            }
-          };
-        } else if (c.type === 'tool-call') {
-          return {
-            type: 'tool-call',
-            content: {
+              mediaType: c.mediaType
+            };
+          } else if (c.type === 'reasoning') {
+            return {
+              type: 'reasoning',
+              text: truncate(c.reasoning)
+            };
+          } else if (c.type === 'tool-call') {
+            return {
+              type: 'tool-call',
               toolCallId: c.toolCallId,
               toolName: c.toolName,
-              args: c.args
-            }
-          };
-        } else if (c.type === 'tool-result') {
-          return {
-            type: 'tool-result',
-            content: {
+              input: c.input
+            };
+          } else if (c.type === 'tool-result') {
+            return {
+              type: 'tool-result',
               toolCallId: c.toolCallId,
               toolName: c.toolName,
-              result: c.result,
+              output: c.output,
               isError: c.isError
-            }
+            };
+          }
+          return {
+            type: 'text',
+            text: ''
           };
-        }
-        return {
-          content: ''
-        };
-      });
-    } else {
-      content = {
-        type: 'text',
-        text: truncate(p.content)
-      };
+        });
+      } else {
+        // Fallback for non-array content
+        content = [{
+          type: 'text',
+          text: truncate(String(message.content))
+        }];
+      }
     }
     return {
-      role: p.role,
+      role: message.role,
       content
     };
   });
@@ -253,52 +256,75 @@ const mapVercelPrompt = prompt => {
   return inputs;
 };
 const mapVercelOutput = result => {
-  // normalize string results to object
-  const normalizedResult = typeof result === 'string' ? {
-    text: result
-  } : result;
-  const output = {
-    ...(normalizedResult.text ? {
-      text: normalizedResult.text
-    } : {}),
-    ...(normalizedResult.object ? {
-      object: normalizedResult.object
-    } : {}),
-    ...(normalizedResult.reasoning ? {
-      reasoning: normalizedResult.reasoning
-    } : {}),
-    ...(normalizedResult.response ? {
-      response: normalizedResult.response
-    } : {}),
-    ...(normalizedResult.finishReason ? {
-      finishReason: normalizedResult.finishReason
-    } : {}),
-    ...(normalizedResult.usage ? {
-      usage: normalizedResult.usage
-    } : {}),
-    ...(normalizedResult.warnings ? {
-      warnings: normalizedResult.warnings
-    } : {}),
-    ...(normalizedResult.providerMetadata ? {
-      toolCalls: normalizedResult.providerMetadata
-    } : {}),
-    ...(normalizedResult.files ? {
-      files: normalizedResult.files.map(file => ({
-        name: file.name,
-        size: file.size,
-        type: file.type
-      }))
-    } : {})
-  };
-  if (output.text && !output.object && !output.reasoning) {
+  const content = result.map(item => {
+    if (item.type === 'text') {
+      return {
+        type: 'text',
+        text: truncate(item.text)
+      };
+    }
+    if (item.type === 'tool-call') {
+      return {
+        type: 'tool-call',
+        id: item.toolCallId,
+        function: {
+          name: item.toolName,
+          arguments: item.args || JSON.stringify(item.arguments || {})
+        }
+      };
+    }
+    if (item.type === 'reasoning') {
+      return {
+        type: 'reasoning',
+        text: truncate(item.text)
+      };
+    }
+    if (item.type === 'file') {
+      // Handle files similar to input mapping - avoid large base64 data
+      let fileData;
+      if (item.data instanceof URL) {
+        fileData = item.data.toString();
+      } else if (typeof item.data === 'string') {
+        // Check if it's base64 data and potentially large
+        if (item.data.startsWith('data:') || item.data.length > 1000) {
+          fileData = `[${item.mediaType} file - ${item.data.length} bytes]`;
+        } else {
+          fileData = item.data;
+        }
+      } else {
+        fileData = `[binary ${item.mediaType} file]`;
+      }
+      return {
+        type: 'file',
+        name: 'generated_file',
+        mediaType: item.mediaType,
+        data: fileData
+      };
+    }
+    if (item.type === 'source') {
+      return {
+        type: 'source',
+        sourceType: item.sourceType,
+        id: item.id,
+        url: item.url || '',
+        title: item.title || ''
+      };
+    }
+    // Fallback for unknown types - try to extract text if possible
+    return {
+      type: 'text',
+      text: truncate(JSON.stringify(item))
+    };
+  });
+  if (content.length > 0) {
     return [{
-      content: truncate(output.text),
-      role: 'assistant'
+      role: 'assistant',
+      content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
     }];
   }
   // otherwise stringify and truncate
   try {
-    const jsonOutput = JSON.stringify(output);
+    const jsonOutput = JSON.stringify(result);
     return [{
       content: truncate(jsonOutput),
       role: 'assistant'
@@ -324,14 +350,14 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         ...options,
         ...mapVercelParams(params)
       };
+      const availableTools = extractAvailableToolCalls('vercel', params);
       try {
         const result = await doGenerate();
-        const latency = (Date.now() - startTime) / 1000;
         const modelId = options.posthogModelOverride ?? (result.response?.modelId ? result.response.modelId : model.modelId);
         const provider = options.posthogProviderOverride ?? extractProvider(model);
         const baseURL = ''; // cannot currently get baseURL from vercel
-        const content = mapVercelOutput(result);
-        // let tools = result.toolCalls
+        const content = mapVercelOutput(result.content);
+        const latency = (Date.now() - startTime) / 1000;
         const providerMetadata = result.providerMetadata;
         const additionalTokenValues = {
           ...(providerMetadata?.openai?.reasoningTokens ? {
@@ -352,19 +378,17 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           model: modelId,
           provider: provider,
           input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-          output: [{
-            content,
-            role: 'assistant'
-          }],
+          output: content,
           latency,
           baseURL,
           params: mergedParams,
           httpStatus: 200,
           usage: {
-            inputTokens: result.usage.promptTokens,
-            outputTokens: result.usage.completionTokens,
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
             ...additionalTokenValues
           },
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         return result;
@@ -388,6 +412,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           isError: true,
           error: truncate(JSON.stringify(error)),
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         throw error;
@@ -399,6 +424,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
     }) => {
       const startTime = Date.now();
       let generatedText = '';
+      let reasoningText = '';
       let usage = {};
       const mergedParams = {
         ...options,
@@ -406,7 +432,9 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
       };
       const modelId = options.posthogModelOverride ?? model.modelId;
       const provider = options.posthogProviderOverride ?? extractProvider(model);
+      const availableTools = extractAvailableToolCalls('vercel', params);
       const baseURL = ''; // cannot currently get baseURL from vercel
+
       try {
         const {
           stream,
@@ -414,13 +442,17 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         } = await doStream();
         const transformStream = new TransformStream({
           transform(chunk, controller) {
+            // Handle new v5 streaming patterns
             if (chunk.type === 'text-delta') {
-              generatedText += chunk.textDelta;
+              generatedText += chunk.delta;
+            }
+            if (chunk.type === 'reasoning-delta') {
+              reasoningText += chunk.delta; // New in v5
             }
             if (chunk.type === 'finish') {
               usage = {
-                inputTokens: chunk.usage?.promptTokens,
-                outputTokens: chunk.usage?.completionTokens
+                inputTokens: chunk.usage?.inputTokens,
+                outputTokens: chunk.usage?.outputTokens
               };
               if (chunk.providerMetadata?.openai?.reasoningTokens) {
                 usage.reasoningTokens = chunk.providerMetadata.openai.reasoningTokens;
@@ -439,6 +471,26 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           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)
+              });
+            }
+
+            // Structure output like mapVercelOutput does
+            const output = content.length > 0 ? [{
+              role: 'assistant',
+              content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+            }] : [];
             await sendEventToPosthog({
               client: phClient,
               distinctId: options.posthogDistinctId,
@@ -446,15 +498,13 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               model: modelId,
               provider: provider,
               input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-              output: [{
-                content: generatedText,
-                role: 'assistant'
-              }],
+              output: output,
               latency,
               baseURL,
               params: mergedParams,
               httpStatus: 200,
               usage,
+              tools: availableTools,
               captureImmediate: options.posthogCaptureImmediate
             });
           }
@@ -482,6 +532,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           isError: true,
           error: truncate(JSON.stringify(error)),
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         throw error;
@@ -497,7 +548,7 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
     posthogTraceId: traceId,
     posthogDistinctId: options.posthogDistinctId
   });
-  const wrappedModel = experimental_wrapLanguageModel({
+  const wrappedModel = wrapLanguageModel({
     model,
     middleware
   });