@elasticdash/langchain 0.0.1 → 0.0.2

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+This repository is licensed under the MIT License. Portions of this codebase are derived from posthog/posthog-js-lite by PostHog, which is also licensed under the MIT License.
+
+Copyright (c) 2023-2026 Langfuse GmbH
+Copyright (c) 2022 PostHog (part of Hiberly Inc)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,8 +6,8 @@ This is the Langchain integration package of the Langfuse JS SDK containing the
 
 ## Packages
 
-| Package                                     | NPM                                                                                                               | Description                                               | Environments |
-| ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- | ------------ |
+| Package                                        | NPM                                                                                                                     | Description                                               | Environments |
+| ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- | ------------ |
 | [@elasticdash/client](./packages/client)       | [![NPM](https://img.shields.io/npm/v/@elasticdash/client.svg)](https://www.npmjs.com/package/@elasticdash/client)       | Langfuse API client for universal JavaScript environments | Universal JS |
 | [@elasticdash/tracing](./packages/tracing)     | [![NPM](https://img.shields.io/npm/v/@elasticdash/tracing.svg)](https://www.npmjs.com/package/@elasticdash/tracing)     | Langfuse instrumentation methods based on OpenTelemetry   | Node.js 20+  |
 | [@elasticdash/otel](./packages/otel)           | [![NPM](https://img.shields.io/npm/v/@elasticdash/otel.svg)](https://www.npmjs.com/package/@elasticdash/otel)           | Langfuse OpenTelemetry export helpers                     | Node.js 20+  |

package/dist/index.cjs

@@ -0,0 +1,559 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CallbackHandler: () => CallbackHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/CallbackHandler.ts
+var import_core = require("@elasticdash/core");
+var import_tracing = require("@elasticdash/tracing");
+var import_base = require("@langchain/core/callbacks/base");
+var import_messages = require("@langchain/core/messages");
+var LANGSMITH_HIDDEN_TAG = "langsmith:hidden";
+var CallbackHandler = class extends import_base.BaseCallbackHandler {
+  constructor(params) {
+    var _a;
+    super();
+    this.name = "LangfuseCallbackHandler";
+    this.completionStartTimes = {};
+    this.runMap = /* @__PURE__ */ new Map();
+    this.last_trace_id = null;
+    this.sessionId = params == null ? void 0 : params.sessionId;
+    this.userId = params == null ? void 0 : params.userId;
+    this.tags = (_a = params == null ? void 0 : params.tags) != null ? _a : [];
+    this.traceMetadata = params == null ? void 0 : params.traceMetadata;
+    this.version = params == null ? void 0 : params.version;
+    this.promptToParentRunMap = /* @__PURE__ */ new Map();
+  }
+  get logger() {
+    return (0, import_core.getGlobalLogger)();
+  }
+  async handleLLMNewToken(token, _idx, runId, _parentRunId, _tags, _fields) {
+    if (runId && !(runId in this.completionStartTimes)) {
+      this.logger.debug(`LLM first streaming token: ${runId}`);
+      this.completionStartTimes[runId] = /* @__PURE__ */ new Date();
+    }
+  }
+  async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+    var _a, _b;
+    try {
+      this.logger.debug(`Chain start with Id: ${runId}`);
+      const runName = (_b = name != null ? name : (_a = chain.id.at(-1)) == null ? void 0 : _a.toString()) != null ? _b : "Langchain Run";
+      this.registerLangfusePrompt(parentRunId, metadata);
+      let finalInput = inputs;
+      if (typeof inputs === "object" && "input" in inputs && Array.isArray(inputs["input"]) && inputs["input"].every((m) => m instanceof import_messages.BaseMessage)) {
+        finalInput = inputs["input"].map(
+          (m) => this.extractChatMessageContent(m)
+        );
+      } else if (typeof inputs === "object" && "messages" in inputs && Array.isArray(inputs["messages"]) && inputs["messages"].every((m) => m instanceof import_messages.BaseMessage)) {
+        finalInput = inputs["messages"].map(
+          (m) => this.extractChatMessageContent(m)
+        );
+      } else if (typeof inputs === "object" && "content" in inputs && typeof inputs["content"] === "string") {
+        finalInput = inputs["content"];
+      }
+      const span = this.startAndRegisterOtelSpan({
+        runName,
+        parentRunId,
+        runId,
+        tags,
+        metadata,
+        attributes: {
+          input: finalInput
+        }
+      });
+      const traceTags = [.../* @__PURE__ */ new Set([...tags != null ? tags : [], ...this.tags])];
+      if (!parentRunId) {
+        span.updateTrace({
+          tags: traceTags,
+          userId: metadata && "langfuseUserId" in metadata && typeof metadata["langfuseUserId"] === "string" ? metadata["langfuseUserId"] : this.userId,
+          sessionId: metadata && "langfuseSessionId" in metadata && typeof metadata["langfuseSessionId"] === "string" ? metadata["langfuseSessionId"] : this.sessionId,
+          metadata: this.traceMetadata,
+          version: this.version
+        });
+      }
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleAgentAction(action, runId, parentRunId) {
+    try {
+      this.logger.debug(`Agent action ${action.tool} with ID: ${runId}`);
+      this.startAndRegisterOtelSpan({
+        runId,
+        parentRunId,
+        runName: action.tool,
+        attributes: {
+          input: action
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleAgentEnd(action, runId, parentRunId) {
+    try {
+      this.logger.debug(`Agent finish with ID: ${runId}`);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: { output: action }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleChainError(err, runId, parentRunId) {
+    try {
+      this.logger.debug(`Chain error: ${err} with ID: ${runId}`);
+      const azureRefusalError = this.parseAzureRefusalError(err);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          level: "ERROR",
+          statusMessage: err.toString() + azureRefusalError
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleGenerationStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    var _a, _b;
+    this.logger.debug(
+      `Generation start with ID: ${runId} and parentRunId ${parentRunId}`
+    );
+    const runName = (_b = name != null ? name : (_a = llm.id.at(-1)) == null ? void 0 : _a.toString()) != null ? _b : "Langchain Generation";
+    const modelParameters = {};
+    const invocationParams = extraParams == null ? void 0 : extraParams["invocation_params"];
+    for (const [key, value] of Object.entries({
+      temperature: invocationParams == null ? void 0 : invocationParams.temperature,
+      max_tokens: invocationParams == null ? void 0 : invocationParams.max_tokens,
+      top_p: invocationParams == null ? void 0 : invocationParams.top_p,
+      frequency_penalty: invocationParams == null ? void 0 : invocationParams.frequency_penalty,
+      presence_penalty: invocationParams == null ? void 0 : invocationParams.presence_penalty,
+      request_timeout: invocationParams == null ? void 0 : invocationParams.request_timeout
+    })) {
+      if (value !== void 0 && value !== null) {
+        modelParameters[key] = value;
+      }
+    }
+    let extractedModelName;
+    if (extraParams) {
+      const invocationParamsModelName = extraParams.invocation_params.model;
+      const metadataModelName = metadata && "ls_model_name" in metadata ? metadata["ls_model_name"] : void 0;
+      extractedModelName = invocationParamsModelName != null ? invocationParamsModelName : metadataModelName;
+    }
+    const registeredPrompt = this.promptToParentRunMap.get(
+      parentRunId != null ? parentRunId : "root"
+    );
+    if (registeredPrompt && parentRunId) {
+      this.deregisterLangfusePrompt(parentRunId);
+    }
+    this.startAndRegisterOtelSpan({
+      type: "generation",
+      runId,
+      parentRunId,
+      metadata,
+      tags,
+      runName,
+      attributes: {
+        input: messages,
+        model: extractedModelName,
+        modelParameters,
+        prompt: registeredPrompt
+      }
+    });
+  }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    try {
+      this.logger.debug(`Chat model start with ID: ${runId}`);
+      const prompts = messages.flatMap(
+        (message) => message.map((m) => this.extractChatMessageContent(m))
+      );
+      this.handleGenerationStart(
+        llm,
+        prompts,
+        runId,
+        parentRunId,
+        extraParams,
+        tags,
+        metadata,
+        name
+      );
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleChainEnd(outputs, runId, parentRunId) {
+    try {
+      this.logger.debug(`Chain end with ID: ${runId}`);
+      let finalOutput = outputs;
+      if (typeof outputs === "object" && "output" in outputs && typeof outputs["output"] === "string") {
+        finalOutput = outputs["output"];
+      } else if (typeof outputs === "object" && "messages" in outputs && Array.isArray(outputs["messages"]) && outputs["messages"].every((m) => m instanceof import_messages.BaseMessage)) {
+        finalOutput = {
+          messages: outputs.messages.map(
+            (message) => this.extractChatMessageContent(message)
+          )
+        };
+      }
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          output: finalOutput
+        }
+      });
+      this.deregisterLangfusePrompt(runId);
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+    try {
+      this.logger.debug(`LLM start with ID: ${runId}`);
+      this.handleGenerationStart(
+        llm,
+        prompts,
+        runId,
+        parentRunId,
+        extraParams,
+        tags,
+        metadata,
+        name
+      );
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+    var _a, _b;
+    try {
+      this.logger.debug(`Tool start with ID: ${runId}`);
+      this.startAndRegisterOtelSpan({
+        runId,
+        parentRunId,
+        runName: (_b = name != null ? name : (_a = tool.id.at(-1)) == null ? void 0 : _a.toString()) != null ? _b : "Tool execution",
+        attributes: {
+          input
+        },
+        metadata,
+        tags
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    var _a, _b;
+    try {
+      this.logger.debug(`Retriever start with ID: ${runId}`);
+      this.startAndRegisterOtelSpan({
+        runId,
+        parentRunId,
+        runName: (_b = name != null ? name : (_a = retriever.id.at(-1)) == null ? void 0 : _a.toString()) != null ? _b : "Retriever",
+        attributes: {
+          input: query
+        },
+        tags,
+        metadata
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleRetrieverEnd(documents, runId, parentRunId) {
+    try {
+      this.logger.debug(`Retriever end with ID: ${runId}`);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          output: documents
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleRetrieverError(err, runId, parentRunId) {
+    try {
+      this.logger.debug(`Retriever error: ${err} with ID: ${runId}`);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          level: "ERROR",
+          statusMessage: err.toString()
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleToolEnd(output, runId, parentRunId) {
+    try {
+      this.logger.debug(`Tool end with ID: ${runId}`);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: { output }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleToolError(err, runId, parentRunId) {
+    try {
+      this.logger.debug(`Tool error ${err} with ID: ${runId}`);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          level: "ERROR",
+          statusMessage: err.toString()
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleLLMEnd(output, runId, parentRunId) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    try {
+      this.logger.debug(`LLM end with ID: ${runId}`);
+      const lastResponse = output.generations[output.generations.length - 1][output.generations[output.generations.length - 1].length - 1];
+      const llmUsage = (_b = this.extractUsageMetadata(lastResponse)) != null ? _b : (_a = output.llmOutput) == null ? void 0 : _a["tokenUsage"];
+      const modelName = this.extractModelNameFromMetadata(lastResponse);
+      const usageDetails = {
+        input: (_c = llmUsage == null ? void 0 : llmUsage.input_tokens) != null ? _c : "promptTokens" in llmUsage ? llmUsage == null ? void 0 : llmUsage.promptTokens : void 0,
+        output: (_d = llmUsage == null ? void 0 : llmUsage.output_tokens) != null ? _d : "completionTokens" in llmUsage ? llmUsage == null ? void 0 : llmUsage.completionTokens : void 0,
+        total: (_e = llmUsage == null ? void 0 : llmUsage.total_tokens) != null ? _e : "totalTokens" in llmUsage ? llmUsage == null ? void 0 : llmUsage.totalTokens : void 0
+      };
+      if (llmUsage && "input_token_details" in llmUsage) {
+        for (const [key, val] of Object.entries(
+          (_f = llmUsage["input_token_details"]) != null ? _f : {}
+        )) {
+          usageDetails[`input_${key}`] = val;
+          if ("input" in usageDetails && typeof val === "number") {
+            usageDetails["input"] = Math.max(0, usageDetails["input"] - val);
+          }
+        }
+      }
+      if (llmUsage && "output_token_details" in llmUsage) {
+        for (const [key, val] of Object.entries(
+          (_g = llmUsage["output_token_details"]) != null ? _g : {}
+        )) {
+          usageDetails[`output_${key}`] = val;
+          if ("output" in usageDetails && typeof val === "number") {
+            usageDetails["output"] = Math.max(0, usageDetails["output"] - val);
+          }
+        }
+      }
+      const extractedOutput = "message" in lastResponse ? this.extractChatMessageContent(
+        lastResponse["message"]
+      ) : lastResponse.text;
+      this.handleOtelSpanEnd({
+        runId,
+        type: "generation",
+        attributes: {
+          model: modelName,
+          output: extractedOutput,
+          completionStartTime: runId in this.completionStartTimes ? this.completionStartTimes[runId] : void 0,
+          usageDetails
+        }
+      });
+      if (runId in this.completionStartTimes) {
+        delete this.completionStartTimes[runId];
+      }
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  async handleLLMError(err, runId, parentRunId) {
+    try {
+      this.logger.debug(`LLM error ${err} with ID: ${runId}`);
+      const azureRefusalError = this.parseAzureRefusalError(err);
+      this.handleOtelSpanEnd({
+        runId,
+        attributes: {
+          level: "ERROR",
+          statusMessage: err.toString() + azureRefusalError
+        }
+      });
+    } catch (e) {
+      this.logger.debug(e instanceof Error ? e.message : String(e));
+    }
+  }
+  registerLangfusePrompt(parentRunId, metadata) {
+    if (metadata && "langfusePrompt" in metadata && parentRunId) {
+      this.promptToParentRunMap.set(
+        parentRunId,
+        metadata.langfusePrompt
+      );
+    }
+  }
+  deregisterLangfusePrompt(runId) {
+    this.promptToParentRunMap.delete(runId);
+  }
+  startAndRegisterOtelSpan(params) {
+    var _a, _b;
+    const { type, runName, runId, parentRunId, attributes, metadata, tags } = params;
+    const observation = type === "generation" ? (0, import_tracing.startObservation)(
+      runName,
+      {
+        version: this.version,
+        metadata: this.joinTagsAndMetaData(tags, metadata),
+        level: tags && tags.includes(LANGSMITH_HIDDEN_TAG) ? "DEBUG" : void 0,
+        ...attributes
+      },
+      {
+        asType: "generation",
+        parentSpanContext: parentRunId ? (_a = this.runMap.get(parentRunId)) == null ? void 0 : _a.otelSpan.spanContext() : void 0
+      }
+    ) : (0, import_tracing.startObservation)(
+      runName,
+      {
+        version: this.version,
+        metadata: this.joinTagsAndMetaData(tags, metadata),
+        level: tags && tags.includes(LANGSMITH_HIDDEN_TAG) ? "DEBUG" : void 0,
+        ...attributes
+      },
+      {
+        parentSpanContext: parentRunId ? (_b = this.runMap.get(parentRunId)) == null ? void 0 : _b.otelSpan.spanContext() : void 0
+      }
+    );
+    this.runMap.set(runId, observation);
+    return observation;
+  }
+  handleOtelSpanEnd(params) {
+    const { runId, attributes = {} } = params;
+    const span = this.runMap.get(runId);
+    if (!span) {
+      this.logger.warn("Span not found in runMap. Skipping operation");
+      return;
+    }
+    span.update(attributes).end();
+    this.last_trace_id = span.traceId;
+    this.runMap.delete(runId);
+  }
+  parseAzureRefusalError(err) {
+    let azureRefusalError = "";
+    if (typeof err == "object" && "error" in err) {
+      try {
+        azureRefusalError = "\n\nError details:\n" + JSON.stringify(err["error"], null, 2);
+      } catch {
+      }
+    }
+    return azureRefusalError;
+  }
+  joinTagsAndMetaData(tags, metadata1, metadata2) {
+    const finalDict = {};
+    if (tags && tags.length > 0) {
+      finalDict.tags = tags;
+    }
+    if (metadata1) {
+      Object.assign(finalDict, metadata1);
+    }
+    if (metadata2) {
+      Object.assign(finalDict, metadata2);
+    }
+    return this.stripLangfuseKeysFromMetadata(finalDict);
+  }
+  stripLangfuseKeysFromMetadata(metadata) {
+    if (!metadata) {
+      return;
+    }
+    const langfuseKeys = [
+      "langfusePrompt",
+      "langfuseUserId",
+      "langfuseSessionId"
+    ];
+    return Object.fromEntries(
+      Object.entries(metadata).filter(
+        ([key, _]) => !langfuseKeys.includes(key)
+      )
+    );
+  }
+  /** Not all models supports tokenUsage in llmOutput, can use AIMessage.usage_metadata instead */
+  extractUsageMetadata(generation) {
+    try {
+      const usageMetadata = "message" in generation && (generation["message"] instanceof import_messages.AIMessage || generation["message"] instanceof import_messages.AIMessageChunk) ? generation["message"].usage_metadata : void 0;
+      return usageMetadata;
+    } catch (err) {
+      this.logger.debug(`Error extracting usage metadata: ${err}`);
+      return;
+    }
+  }
+  extractModelNameFromMetadata(generation) {
+    try {
+      return "message" in generation && (generation["message"] instanceof import_messages.AIMessage || generation["message"] instanceof import_messages.AIMessageChunk) ? generation["message"].response_metadata.model_name : void 0;
+    } catch {
+    }
+  }
+  extractChatMessageContent(message) {
+    var _a, _b;
+    let response = void 0;
+    if (message.getType() === "human") {
+      response = { content: message.content, role: "user" };
+    } else if (message.getType() === "generic") {
+      response = {
+        content: message.content,
+        role: "human"
+      };
+    } else if (message.getType() === "ai") {
+      response = { content: message.content, role: "assistant" };
+      if ("tool_calls" in message && Array.isArray(message.tool_calls) && ((_b = (_a = message.tool_calls) == null ? void 0 : _a.length) != null ? _b : 0) > 0) {
+        response["tool_calls"] = message["tool_calls"];
+      }
+      if ("additional_kwargs" in message && "tool_calls" in message["additional_kwargs"]) {
+        response["tool_calls"] = message["additional_kwargs"]["tool_calls"];
+      }
+    } else if (message.getType() === "system") {
+      response = { content: message.content, role: "system" };
+    } else if (message.getType() === "function") {
+      response = {
+        content: message.content,
+        additional_kwargs: message.additional_kwargs,
+        role: message.name
+      };
+    } else if (message.getType() === "tool") {
+      response = {
+        content: message.content,
+        additional_kwargs: message.additional_kwargs,
+        role: message.name
+      };
+    } else if (!message.name) {
+      response = { content: message.content };
+    } else {
+      response = {
+        role: message.name,
+        content: message.content
+      };
+    }
+    if ((message.additional_kwargs.function_call || message.additional_kwargs.tool_calls) && response["tool_calls"] === void 0) {
+      return { ...response, additional_kwargs: message.additional_kwargs };
+    }
+    return response;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallbackHandler
+});
+//# sourceMappingURL=index.cjs.map