@posthog/ai 5.2.0 → 5.2.2

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import OpenAIOrignal, { APIPromise, ClientOptions as ClientOptions$1, AzureOpenAI } from 'openai';
+import OpenAIOrignal, { OpenAI, APIPromise, ClientOptions as ClientOptions$1, AzureOpenAI } from 'openai';
 import { PostHog } from 'posthog-node';
 import { Stream } from 'openai/streaming';
 import { ParsedResponse } from 'openai/resources/responses/responses';
@@ -10,10 +10,10 @@ import { GoogleGenAI } from '@google/genai';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { Serialized } from '@langchain/core/load/serializable';
 import { ChainValues } from '@langchain/core/utils/types';
-import { BaseMessage } from '@langchain/core/messages';
 import { LLMResult } from '@langchain/core/outputs';
 import { AgentAction, AgentFinish } from '@langchain/core/agents';
 import { DocumentInterface } from '@langchain/core/documents';
+import { BaseMessage } from '@langchain/core/messages';
 
 interface MonitoringParams {
     posthogDistinctId?: string;
@@ -31,43 +31,46 @@ interface CostOverride {
     outputCost: number;
 }
 
-type ChatCompletion$1 = OpenAIOrignal.ChatCompletion;
-type ChatCompletionChunk$1 = OpenAIOrignal.ChatCompletionChunk;
-type ChatCompletionCreateParamsBase$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParams;
-type ChatCompletionCreateParamsNonStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
-type ChatCompletionCreateParamsStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsStreaming;
-type ResponsesCreateParamsBase = OpenAIOrignal.Responses.ResponseCreateParams;
-type ResponsesCreateParamsNonStreaming = OpenAIOrignal.Responses.ResponseCreateParamsNonStreaming;
-type ResponsesCreateParamsStreaming = OpenAIOrignal.Responses.ResponseCreateParamsStreaming;
+declare const Chat: typeof OpenAI.Chat;
+declare const Completions: typeof OpenAI.Chat.Completions;
+declare const Responses: typeof OpenAI.Responses;
+type ChatCompletion$1 = OpenAI.ChatCompletion;
+type ChatCompletionChunk$1 = OpenAI.ChatCompletionChunk;
+type ChatCompletionCreateParamsBase$1 = OpenAI.Chat.Completions.ChatCompletionCreateParams;
+type ChatCompletionCreateParamsNonStreaming$1 = OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+type ChatCompletionCreateParamsStreaming$1 = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming;
+type ResponsesCreateParamsBase = OpenAI.Responses.ResponseCreateParams;
+type ResponsesCreateParamsNonStreaming = OpenAI.Responses.ResponseCreateParamsNonStreaming;
+type ResponsesCreateParamsStreaming = OpenAI.Responses.ResponseCreateParamsStreaming;
 interface MonitoringOpenAIConfig$1 extends ClientOptions$1 {
     apiKey: string;
     posthog: PostHog;
     baseURL?: string;
 }
 type RequestOptions$1 = Record<string, any>;
-declare class PostHogOpenAI extends OpenAIOrignal {
+declare class PostHogOpenAI extends OpenAI {
     private readonly phClient;
     chat: WrappedChat$1;
     responses: WrappedResponses;
     constructor(config: MonitoringOpenAIConfig$1);
 }
-declare class WrappedChat$1 extends OpenAIOrignal.Chat {
+declare class WrappedChat$1 extends Chat {
     constructor(parentClient: PostHogOpenAI, phClient: PostHog);
     completions: WrappedCompletions$1;
 }
-declare class WrappedCompletions$1 extends OpenAIOrignal.Chat.Completions {
+declare class WrappedCompletions$1 extends Completions {
     private readonly phClient;
-    constructor(client: OpenAIOrignal, phClient: PostHog);
+    constructor(client: OpenAI, phClient: PostHog);
     create(body: ChatCompletionCreateParamsNonStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1>;
     create(body: ChatCompletionCreateParamsStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<ChatCompletionChunk$1>>;
     create(body: ChatCompletionCreateParamsBase$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1 | Stream<ChatCompletionChunk$1>>;
 }
-declare class WrappedResponses extends OpenAIOrignal.Responses {
+declare class WrappedResponses extends Responses {
     private readonly phClient;
-    constructor(client: OpenAIOrignal, phClient: PostHog);
-    create(body: ResponsesCreateParamsNonStreaming & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response>;
-    create(body: ResponsesCreateParamsStreaming & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
-    create(body: ResponsesCreateParamsBase & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
+    constructor(client: OpenAI, phClient: PostHog);
+    create(body: ResponsesCreateParamsNonStreaming & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAI.Responses.Response>;
+    create(body: ResponsesCreateParamsStreaming & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    create(body: ResponsesCreateParamsBase & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAI.Responses.Response | Stream<OpenAI.Responses.ResponseStreamEvent>>;
     parse<Params extends ResponsesCreateParamsBase, ParsedT = any>(body: Params & MonitoringParams, options?: RequestOptions$1): APIPromise<ParsedResponse<ParsedT>>;
 }
 
@@ -229,6 +232,7 @@ declare class LangChainCallbackHandler extends BaseCallbackHandler {
     private _captureGeneration;
     private _logDebugEvent;
     private _getLangchainRunName;
+    private _convertLcToolCallsToOai;
     private _convertMessageToDict;
     private _parseUsageModel;
     private parseUsage;

package/lib/index.mjs

@@ -1,4 +1,4 @@
-import OpenAIOrignal, { AzureOpenAI } from 'openai';
+import { OpenAI, AzureOpenAI } from 'openai';
 import * as uuid from 'uuid';
 import { v4 } from 'uuid';
 import { Buffer } from 'buffer';
@@ -181,7 +181,10 @@ const sendEventToPosthog = async ({
   }
 };
 
-class PostHogOpenAI extends OpenAIOrignal {
+const Chat = OpenAI.Chat;
+const Completions = Chat.Completions;
+const Responses = OpenAI.Responses;
+class PostHogOpenAI extends OpenAI {
   constructor(config) {
     const {
       posthog,
@@ -193,13 +196,13 @@ class PostHogOpenAI extends OpenAIOrignal {
     this.responses = new WrappedResponses$1(this, this.phClient);
   }
 }
-class WrappedChat$1 extends OpenAIOrignal.Chat {
+class WrappedChat$1 extends Chat {
   constructor(parentClient, phClient) {
     super(parentClient);
     this.completions = new WrappedCompletions$1(parentClient, phClient);
   }
 }
-class WrappedCompletions$1 extends OpenAIOrignal.Chat.Completions {
+class WrappedCompletions$1 extends Completions {
   constructor(client, phClient) {
     super(client);
     this.phClient = phClient;
@@ -342,7 +345,7 @@ class WrappedCompletions$1 extends OpenAIOrignal.Chat.Completions {
     }
   }
 }
-class WrappedResponses$1 extends OpenAIOrignal.Responses {
+class WrappedResponses$1 extends Responses {
   constructor(client, phClient) {
     super(client);
     this.phClient = phClient;
@@ -2481,10 +2484,19 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     }
     return undefined;
   }
+  _convertLcToolCallsToOai(toolCalls) {
+    return toolCalls.map(toolCall => ({
+      type: 'function',
+      id: toolCall.id,
+      function: {
+        name: toolCall.name,
+        arguments: JSON.stringify(toolCall.args)
+      }
+    }));
+  }
   _convertMessageToDict(message) {
     let messageDict = {};
-    // Check the _getType() method or type property instead of instanceof
-    const messageType = message._getType?.() || message.type;
+    const messageType = message.getType();
     switch (messageType) {
       case 'human':
         messageDict = {
@@ -2497,6 +2509,9 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
           role: 'assistant',
           content: message.content
         };
+        if (message.tool_calls) {
+          messageDict.tool_calls = this._convertLcToolCallsToOai(message.tool_calls);
+        }
         break;
       case 'system':
         messageDict = {
@@ -2518,9 +2533,10 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
         break;
       default:
         messageDict = {
-          role: messageType || 'unknown',
+          role: messageType,
           content: String(message.content)
         };
+        break;
     }
     if (message.additional_kwargs) {
       messageDict = {