@posthog/ai 4.0.0 → 4.1.0

package/lib/index.esm.js

@@ -1,9 +1,13 @@
 import OpenAIOrignal, { AzureOpenAI } from 'openai';
 import * as uuid from 'uuid';
 import { v4 } from 'uuid';
+import { Buffer } from 'buffer';
 import { experimental_wrapLanguageModel } from 'ai';
 import AnthropicOriginal from '@anthropic-ai/sdk';
 
+// limit large outputs by truncating to 200kb (approx 200k bytes)
+const MAX_OUTPUT_SIZE = 200000;
+const STRING_FORMAT = 'utf8';
 const getModelParams = params => {
   if (!params) {
     return {};
@@ -59,6 +63,33 @@ const mergeSystemPrompt = (params, provider) => {
 const withPrivacyMode = (client, privacyMode, input) => {
   return client.privacy_mode || privacyMode ? null : input;
 };
+const truncate = str => {
+  try {
+    const buffer = Buffer.from(str, STRING_FORMAT);
+    if (buffer.length <= MAX_OUTPUT_SIZE) {
+      return str;
+    }
+    const truncatedBuffer = buffer.slice(0, MAX_OUTPUT_SIZE);
+    return `${truncatedBuffer.toString(STRING_FORMAT)}... [truncated]`;
+  } catch (error) {
+    console.error('Error truncating, likely not a string');
+    return str;
+  }
+};
+function sanitizeValues(obj) {
+  if (obj === undefined || obj === null) {
+    return obj;
+  }
+  const jsonSafe = JSON.parse(JSON.stringify(obj));
+  if (typeof jsonSafe === 'string') {
+    return Buffer.from(jsonSafe, STRING_FORMAT).toString(STRING_FORMAT);
+  } else if (Array.isArray(jsonSafe)) {
+    return jsonSafe.map(sanitizeValues);
+  } else if (jsonSafe && typeof jsonSafe === 'object') {
+    return Object.fromEntries(Object.entries(jsonSafe).map(([k, v]) => [k, sanitizeValues(v)]));
+  }
+  return jsonSafe;
+}
 const sendEventToPosthog = ({
   client,
   distinctId,
@@ -77,11 +108,15 @@ const sendEventToPosthog = ({
   tools
 }) => {
   if (client.capture) {
+    // sanitize input and output for UTF-8 validity
+    const safeInput = sanitizeValues(input);
+    const safeOutput = sanitizeValues(output);
+    const safeError = sanitizeValues(error);
     let errorData = {};
     if (isError) {
       errorData = {
         $ai_is_error: true,
-        $ai_error: error
+        $ai_error: safeError
       };
     }
     let costOverrideData = {};
@@ -112,8 +147,8 @@ const sendEventToPosthog = ({
         $ai_provider: params.posthogProviderOverride ?? provider,
         $ai_model: params.posthogModelOverride ?? model,
         $ai_model_parameters: getModelParams(params),
-        $ai_input: withPrivacyMode(client, params.posthogPrivacyMode ?? false, input),
-        $ai_output_choices: withPrivacyMode(client, params.posthogPrivacyMode ?? false, output),
+        $ai_input: withPrivacyMode(client, params.posthogPrivacyMode ?? false, safeInput),
+        $ai_output_choices: withPrivacyMode(client, params.posthogPrivacyMode ?? false, safeOutput),
         $ai_http_status: httpStatus,
         $ai_input_tokens: usage.inputTokens ?? 0,
         $ai_output_tokens: usage.outputTokens ?? 0,
@@ -469,14 +504,26 @@ const mapVercelParams = params => {
   };
 };
 const mapVercelPrompt = prompt => {
-  return prompt.map(p => {
+  // 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;
+  }
+  return promptsArray.map(p => {
     let content = {};
     if (Array.isArray(p.content)) {
       content = p.content.map(c => {
         if (c.type === 'text') {
           return {
             type: 'text',
-            content: c.text
+            content: truncate(c.text)
           };
         } else if (c.type === 'image') {
           return {
@@ -522,7 +569,7 @@ const mapVercelPrompt = prompt => {
     } else {
       content = {
         type: 'text',
-        text: p.content
+        text: truncate(p.content)
       };
     }
     return {
@@ -532,46 +579,62 @@ const mapVercelPrompt = prompt => {
   });
 };
 const mapVercelOutput = result => {
+  // normalize string results to object
+  const normalizedResult = typeof result === 'string' ? {
+    text: result
+  } : result;
   const output = {
-    ...(result.text ? {
-      text: result.text
+    ...(normalizedResult.text ? {
+      text: normalizedResult.text
     } : {}),
-    ...(result.object ? {
-      object: result.object
+    ...(normalizedResult.object ? {
+      object: normalizedResult.object
     } : {}),
-    ...(result.reasoning ? {
-      reasoning: result.reasoning
+    ...(normalizedResult.reasoning ? {
+      reasoning: normalizedResult.reasoning
     } : {}),
-    ...(result.response ? {
-      response: result.response
+    ...(normalizedResult.response ? {
+      response: normalizedResult.response
     } : {}),
-    ...(result.finishReason ? {
-      finishReason: result.finishReason
+    ...(normalizedResult.finishReason ? {
+      finishReason: normalizedResult.finishReason
     } : {}),
-    ...(result.usage ? {
-      usage: result.usage
+    ...(normalizedResult.usage ? {
+      usage: normalizedResult.usage
     } : {}),
-    ...(result.warnings ? {
-      warnings: result.warnings
+    ...(normalizedResult.warnings ? {
+      warnings: normalizedResult.warnings
     } : {}),
-    ...(result.providerMetadata ? {
-      toolCalls: result.providerMetadata
+    ...(normalizedResult.providerMetadata ? {
+      toolCalls: normalizedResult.providerMetadata
+    } : {}),
+    ...(normalizedResult.files ? {
+      files: normalizedResult.files.map(file => ({
+        name: file.name,
+        size: file.size,
+        type: file.type
+      }))
     } : {})
   };
-  // if text and no object or reasoning, return text
   if (output.text && !output.object && !output.reasoning) {
     return [{
-      content: output.text,
+      content: truncate(output.text),
       role: 'assistant'
     }];
   }
-  return [{
-    content: JSON.stringify(output),
-    role: 'assistant'
-  }];
+  // otherwise stringify and truncate
+  try {
+    const jsonOutput = JSON.stringify(output);
+    return [{
+      content: truncate(jsonOutput),
+      role: 'assistant'
+    }];
+  } catch (error) {
+    console.error('Error stringifying output');
+    return [];
+  }
 };
 const extractProvider = model => {
-  // vercel provider is in the format of provider.endpoint
   const provider = model.provider.toLowerCase();
   const providerName = provider.split('.')[0];
   return providerName;
@@ -649,7 +712,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
             outputTokens: 0
           },
           isError: true,
-          error: JSON.stringify(error)
+          error: truncate(JSON.stringify(error))
         });
         throw error;
       }
@@ -741,7 +804,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
             outputTokens: 0
           },
           isError: true,
-          error: JSON.stringify(error)
+          error: truncate(JSON.stringify(error))
         });
         throw error;
       }