added N8nLlmTracing utility

Author: Ruby Lo

docker/Dockerfile

@@ -4,7 +4,7 @@ USER root
 
 RUN mkdir -p /opt/n8n-custom-nodes && \
     cd /opt/n8n-custom-nodes && \
-    npm install n8n-nodes-langfuse-llm-dev@0.1.4 && \
+    npm install n8n-nodes-openai-langfuse@0.1.9 && \
     chown -R node:node /opt/n8n-custom-nodes
 
 ENV N8N_CUSTOM_EXTENSIONS="/opt/n8n-custom-nodes"

nodes/LmChatOpenAiLangfuse/LmChatOpenAiLangfuse.node.ts

@@ -1,6 +1,5 @@
 import { ChatOpenAI, type ClientOptions } from '@langchain/openai';
 import {
-    NodeConnectionType as NodeConnectionTypeT,
     jsonParse,
     type INodeType,
     type INodeTypeDescription,
@@ -10,6 +9,7 @@ import {
 
 import { CallbackHandler } from 'langfuse-langchain';
 import { searchModels } from './methods/loadModels';
+import { N8nLlmTracing } from './utils/N8nLlmTracing'
 
 
 export class LmChatOpenAiLangfuse implements INodeType {
@@ -46,7 +46,7 @@ export class LmChatOpenAiLangfuse implements INodeType {
         },
 
         inputs: [],
-        outputs: [NodeConnectionTypeT.AiLanguageModel],
+        outputs: ['ai_languageModel'],
         outputNames: ['Model'],
         credentials: [
             { name: 'openAiApiWithLangfuseApi', required: true },
@@ -435,7 +435,7 @@ export class LmChatOpenAiLangfuse implements INodeType {
             modelKwargs.reasoning_effort = options.reasoningEffort;
 
         const model = new ChatOpenAI({
-            callbacks: [lfHandler],
+            callbacks: [lfHandler, new N8nLlmTracing(this)],
             metadata: customMetadata,
             apiKey: credentials.apiKey as string,
             configuration: { baseURL: configuration.baseURL },

nodes/LmChatOpenAiLangfuse/utils/N8nLlmTracing.ts

@@ -0,0 +1,96 @@
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import type { Serialized } from "@langchain/core/load/serializable";
+import type { BaseMessage } from "@langchain/core/messages";
+import type { LLMResult } from "@langchain/core/outputs";
+import {
+    type ISupplyDataFunctions,
+    type IExecuteFunctions,
+    type IDataObject,
+    NodeOperationError,
+    type JsonObject,
+} from "n8n-workflow";
+import { logAiEvent } from "./helpers";
+
+type RunDetail = {
+    index: number;
+    messages: BaseMessage[] | string[] | string;
+    options: any;
+};
+
+export class N8nLlmTracing extends BaseCallbackHandler {
+    name = "N8nLlmTracing";
+    awaitHandlers = true;
+
+    connectionType = 'ai_languageModel';
+    #parentRunIndex?: number;
+    runsMap: Record<string, RunDetail> = {};
+
+    constructor(private executionFunctions: ISupplyDataFunctions | IExecuteFunctions) {
+        super();
+    }
+
+    async handleLLMStart(llm: Serialized, prompts: string[], runId: string) {
+        const sourceNodeRunIndex =
+            this.#parentRunIndex !== undefined
+                ? this.#parentRunIndex + (this.executionFunctions as any).getNextRunIndex?.()
+                : undefined;
+
+        const options = llm.type === "constructor" ? llm.kwargs : llm;
+        const { index } = (this.executionFunctions as any).addInputData(
+            this.connectionType,
+            [[{ json: { messages: prompts, options } }]],
+            sourceNodeRunIndex,
+        );
+
+        this.runsMap[runId] = {
+            index,
+            options,
+            messages: prompts,
+        };
+    }
+
+    async handleLLMEnd(output: LLMResult, runId: string) {
+        const runDetails = this.runsMap[runId] ?? { index: 0, options: {}, messages: [] };
+
+        const response = { response: { generations: output.generations } };
+
+        const sourceNodeRunIndex =
+            this.#parentRunIndex !== undefined ? this.#parentRunIndex + runDetails.index : undefined;
+
+        (this.executionFunctions as any).addOutputData(
+            this.connectionType,
+            runDetails.index,
+            [[{ json: response }]],
+            undefined,
+            sourceNodeRunIndex,
+        );
+
+        logAiEvent(this.executionFunctions, "ai-llm-generated-output", {
+            messages: runDetails.messages,
+            options: runDetails.options,
+            response,
+        });
+    }
+
+    async handleLLMError(error: IDataObject | Error, runId: string, parentRunId?: string) {
+        const runDetails = this.runsMap[runId] ?? { index: 0, options: {}, messages: [] };
+
+        (this.executionFunctions as any).addOutputData(
+            this.connectionType,
+            runDetails.index,
+            new NodeOperationError((this.executionFunctions as any).getNode(), error as JsonObject, {
+                functionality: "configuration-node",
+            }),
+        );
+
+        logAiEvent(this.executionFunctions, "ai-llm-errored", {
+            error: (error as any)?.message ?? String(error),
+            runId,
+            parentRunId,
+        });
+    }
+
+    setParentRunIndex(runIndex: number) {
+        this.#parentRunIndex = runIndex;
+    }
+}

nodes/LmChatOpenAiLangfuse/utils/N8nTool.ts

@@ -0,0 +1,13 @@
+import { DynamicStructuredTool } from "langchain/tools";
+
+export class N8nTool extends DynamicStructuredTool<any> {
+    async _call(input: string, runManager?: any): Promise<any> {
+        try {
+            const parser = this.schema as any;
+            const parsed = await parser.parseAsync(input);
+            return this.func(parsed, runManager);
+        } catch (err: any) {
+            throw new Error(`Tool input parse failed: ${err?.message ?? String(err)}`);
+        }
+    }
+}

nodes/LmChatOpenAiLangfuse/utils/helpers.ts

@@ -0,0 +1,13 @@
+import type { IDataObject, ISupplyDataFunctions, IExecuteFunctions } from "n8n-workflow";
+
+export function logAiEvent(
+    executeFunctions: ISupplyDataFunctions | IExecuteFunctions,
+    event: "ai-llm-generated-output" | "ai-llm-errored",
+    data?: IDataObject,
+) {
+    try {
+        (executeFunctions as any).logAiEvent(event, data ? JSON.stringify(data) : undefined);
+    } catch (error) {
+        (executeFunctions as any).logger?.debug?.(`Error logging AI event: ${event}`);
+    }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-openai-langfuse",
-  "version": "0.1.3",
+  "version": "0.1.9",
   "description": "n8n community node: Langfuse + OpenAI-compatible LLM provider",
   "keywords": [
     "n8n-community-node-package",
@@ -46,6 +46,7 @@
     "@langchain/core": "^0.3.72",
     "@langchain/openai": "^0.6.9",
     "langfuse-langchain": "^3.0.0",
+    "openai": "^5.19.1",
     "proxy-from-env": "^1.1.0",
     "undici": "^7.15.0"
   },