@posthog/ai 6.0.0 → 6.1.0

package/dist/index.cjs

@@ -1235,77 +1235,75 @@ const mapVercelPrompt = messages => {
   return inputs;
 };
 const mapVercelOutput = result => {
-  const content = [];
-  if (result.text) {
-    content.push({
-      type: 'text',
-      text: truncate(result.text)
-    });
-  }
-  if (result.toolCalls && Array.isArray(result.toolCalls)) {
-    for (const toolCall of result.toolCalls) {
-      content.push({
-        type: 'function',
-        id: toolCall.toolCallId,
+  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: toolCall.toolName,
-          arguments: typeof toolCall.args === 'string' ? toolCall.args : JSON.stringify(toolCall.args)
+          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 [{
       role: 'assistant',
       content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
     }];
   }
-  // Fallback to original behavior for other result types TODO: check if we can remove this
-  const normalizedResult = typeof result === 'string' ? {
-    text: result
-  } : result;
-  const output = {
-    ...(normalizedResult.text ? {
-      text: normalizedResult.text
-    } : {}),
-    ...(normalizedResult.object ? {
-      object: normalizedResult.object
-    } : {}),
-    ...(normalizedResult.reasoningText ? {
-      reasoning: normalizedResult.reasoningText
-    } : {}),
-    ...(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) {
-    return [{
-      content: truncate(output.text),
-      role: 'assistant'
-    }];
-  }
   // otherwise stringify and truncate
   try {
-    const jsonOutput = JSON.stringify(output);
+    const jsonOutput = JSON.stringify(result);
     return [{
       content: truncate(jsonOutput),
       role: 'assistant'
@@ -1337,21 +1335,21 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         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);
+        const content = mapVercelOutput(result.content);
         const latency = (Date.now() - startTime) / 1000;
         const providerMetadata = result.providerMetadata;
         const additionalTokenValues = {
-          ...(providerMetadata?.openai?.reasoningTokens ? {
-            reasoningTokens: providerMetadata.openai.reasoningTokens
-          } : {}),
-          ...(providerMetadata?.openai?.cachedPromptTokens ? {
-            cacheReadInputTokens: providerMetadata.openai.cachedPromptTokens
-          } : {}),
           ...(providerMetadata?.anthropic ? {
-            cacheReadInputTokens: providerMetadata.anthropic.cacheReadInputTokens,
             cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
           } : {})
         };
+        const usage = {
+          inputTokens: result.usage.inputTokens,
+          outputTokens: result.usage.outputTokens,
+          reasoningTokens: result.usage.reasoningTokens,
+          cacheReadInputTokens: result.usage.cachedInputTokens,
+          ...additionalTokenValues
+        };
         await sendEventToPosthog({
           client: phClient,
           distinctId: options.posthogDistinctId,
@@ -1364,11 +1362,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           baseURL,
           params: mergedParams,
           httpStatus: 200,
-          usage: {
-            inputTokens: result.usage.inputTokens,
-            outputTokens: result.usage.outputTokens,
-            ...additionalTokenValues
-          },
+          usage,
           tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
@@ -1430,28 +1424,43 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               reasoningText += chunk.delta; // New in v5
             }
             if (chunk.type === 'finish') {
+              const providerMetadata = chunk.providerMetadata;
+              const additionalTokenValues = {
+                ...(providerMetadata?.anthropic ? {
+                  cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
+                } : {})
+              };
               usage = {
                 inputTokens: chunk.usage?.inputTokens,
-                outputTokens: chunk.usage?.outputTokens
+                outputTokens: chunk.usage?.outputTokens,
+                reasoningTokens: chunk.usage?.reasoningTokens,
+                cacheReadInputTokens: chunk.usage?.cachedInputTokens,
+                ...additionalTokenValues
               };
-              if (chunk.providerMetadata?.openai?.reasoningTokens) {
-                usage.reasoningTokens = chunk.providerMetadata.openai.reasoningTokens;
-              }
-              if (chunk.providerMetadata?.openai?.cachedPromptTokens) {
-                usage.cacheReadInputTokens = chunk.providerMetadata.openai.cachedPromptTokens;
-              }
-              if (chunk.providerMetadata?.anthropic?.cacheReadInputTokens) {
-                usage.cacheReadInputTokens = chunk.providerMetadata.anthropic.cacheReadInputTokens;
-              }
-              if (chunk.providerMetadata?.anthropic?.cacheCreationInputTokens) {
-                usage.cacheCreationInputTokens = chunk.providerMetadata.anthropic.cacheCreationInputTokens;
-              }
             }
             controller.enqueue(chunk);
           },
           flush: async () => {
             const latency = (Date.now() - startTime) / 1000;
-            const outputContent = reasoningText ? `${reasoningText}\n\n${generatedText}` : generatedText;
+            // 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,
@@ -1459,10 +1468,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               model: modelId,
               provider: provider,
               input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-              output: [{
-                content: outputContent,
-                role: 'assistant'
-              }],
+              output: output,
               latency,
               baseURL,
               params: mergedParams,
@@ -1729,7 +1735,9 @@ class WrappedModels {
         httpStatus: 200,
         usage: {
           inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
-          outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
+          outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+          reasoningTokens: response.usageMetadata?.thoughtsTokenCount ?? 0,
+          cacheReadInputTokens: response.usageMetadata?.cachedContentTokenCount ?? 0
         },
         tools: availableTools,
         captureImmediate: posthogCaptureImmediate
@@ -1785,7 +1793,9 @@ class WrappedModels {
         if (chunk.usageMetadata) {
           usage = {
             inputTokens: chunk.usageMetadata.promptTokenCount ?? 0,
-            outputTokens: chunk.usageMetadata.candidatesTokenCount ?? 0
+            outputTokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
+            reasoningTokens: chunk.usageMetadata.thoughtsTokenCount ?? 0,
+            cacheReadInputTokens: chunk.usageMetadata.cachedContentTokenCount ?? 0
           };
         }
         yield chunk;