@langfuse/client 4.0.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,908 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatMessageType: () => ChatMessageType,
+  ChatPromptClient: () => ChatPromptClient,
+  DatasetManager: () => DatasetManager,
+  LangfuseClient: () => LangfuseClient,
+  MediaManager: () => MediaManager,
+  PromptManager: () => PromptManager,
+  ScoreManager: () => ScoreManager,
+  TextPromptClient: () => TextPromptClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/LangfuseClient.ts
+var import_core5 = require("@langfuse/core");
+
+// src/dataset/index.ts
+var DatasetManager = class {
+  constructor(params) {
+    this.apiClient = params.apiClient;
+  }
+  async get(name, options) {
+    var _a;
+    const dataset = await this.apiClient.datasets.get(name);
+    const items = [];
+    let page = 1;
+    while (true) {
+      const itemsResponse = await this.apiClient.datasetItems.list({
+        datasetName: name,
+        limit: (_a = options == null ? void 0 : options.fetchItemsPageSize) != null ? _a : 50,
+        page
+      });
+      items.push(...itemsResponse.data);
+      if (itemsResponse.meta.totalPages <= page) {
+        break;
+      }
+      page++;
+    }
+    const returnDataset = {
+      ...dataset,
+      items: items.map((item) => ({
+        ...item,
+        link: this.createDatasetItemLinkFunction(item)
+      }))
+    };
+    return returnDataset;
+  }
+  createDatasetItemLinkFunction(item) {
+    const linkFunction = async (obj, runName, runArgs) => {
+      return await this.apiClient.datasetRunItems.create({
+        runName,
+        datasetItemId: item.id,
+        traceId: obj.otelSpan.spanContext().traceId,
+        runDescription: runArgs == null ? void 0 : runArgs.description,
+        metadata: runArgs == null ? void 0 : runArgs.metadata
+      });
+    };
+    return linkFunction;
+  }
+};
+
+// src/media/index.ts
+var import_core = require("@langfuse/core");
+var MediaManager = class _MediaManager {
+  constructor(params) {
+    this.apiClient = params.apiClient;
+  }
+  /**
+   * Replaces the media reference strings in an object with base64 data URIs for the media content.
+   *
+   * This method recursively traverses an object (up to a maximum depth of 10) looking for media reference strings
+   * in the format "@@@langfuseMedia:...@@@". When found, it fetches the actual media content using the provided
+   * Langfuse client and replaces the reference string with a base64 data URI.
+   *
+   * If fetching media content fails for a reference string, a warning is logged and the reference string is left unchanged.
+   *
+   * @param params - Configuration object
+   * @param params.obj - The object to process. Can be a primitive value, array, or nested object
+   * @param params.resolveWith - The representation of the media content to replace the media reference string with. Currently only "base64DataUri" is supported.
+   * @param params.maxDepth - Optional. Default is 10. The maximum depth to traverse the object.
+   *
+   * @returns A deep copy of the input object with all media references replaced with base64 data URIs where possible
+   *
+   * @example
+   * ```typescript
+   * const obj = {
+   *   image: "@@@langfuseMedia:type=image/jpeg|id=123|source=bytes@@@",
+   *   nested: {
+   *     pdf: "@@@langfuseMedia:type=application/pdf|id=456|source=bytes@@@"
+   *   }
+   * };
+   *
+   * const result = await LangfuseMedia.resolveMediaReferences({
+   *   obj,
+   *   langfuseClient
+   * });
+   *
+   * // Result:
+   * // {
+   * //   image: "data:image/jpeg;base64,/9j/4AAQSkZJRg...",
+   * //   nested: {
+   * //     pdf: "data:application/pdf;base64,JVBERi0xLjcK..."
+   * //   }
+   * // }
+   * ```
+   */
+  async resolveReferences(params) {
+    const { obj, maxDepth = 10 } = params;
+    const traverse = async (obj2, depth) => {
+      if (depth > maxDepth) {
+        return obj2;
+      }
+      if (typeof obj2 === "string") {
+        const regex = /@@@langfuseMedia:.+?@@@/g;
+        const referenceStringMatches = obj2.match(regex);
+        if (!referenceStringMatches) {
+          return obj2;
+        }
+        let result = obj2;
+        const referenceStringToMediaContentMap = /* @__PURE__ */ new Map();
+        await Promise.all(
+          referenceStringMatches.map(async (referenceString) => {
+            try {
+              const parsedMediaReference = _MediaManager.parseReferenceString(referenceString);
+              const mediaData = await this.apiClient.media.get(
+                parsedMediaReference.mediaId
+              );
+              const mediaContent = await fetch(mediaData.url, {
+                method: "GET",
+                headers: {}
+              });
+              if (mediaContent.status !== 200) {
+                throw new Error("Failed to fetch media content");
+              }
+              const uint8Content = new Uint8Array(
+                await mediaContent.arrayBuffer()
+              );
+              const base64MediaContent = (0, import_core.uint8ArrayToBase64)(uint8Content);
+              const base64DataUri = `data:${mediaData.contentType};base64,${base64MediaContent}`;
+              referenceStringToMediaContentMap.set(
+                referenceString,
+                base64DataUri
+              );
+            } catch (error) {
+              (0, import_core.getGlobalLogger)().warn(
+                "Error fetching media content for reference string",
+                referenceString,
+                error
+              );
+            }
+          })
+        );
+        for (const [
+          referenceString,
+          base64MediaContent
+        ] of referenceStringToMediaContentMap.entries()) {
+          result = result.replaceAll(referenceString, base64MediaContent);
+        }
+        return result;
+      }
+      if (Array.isArray(obj2)) {
+        return Promise.all(
+          obj2.map(async (item) => await traverse(item, depth + 1))
+        );
+      }
+      if (typeof obj2 === "object" && obj2 !== null) {
+        return Object.fromEntries(
+          await Promise.all(
+            Object.entries(obj2).map(async ([key, value]) => [
+              key,
+              await traverse(value, depth + 1)
+            ])
+          )
+        );
+      }
+      return obj2;
+    };
+    return traverse(obj, 0);
+  }
+  /**
+   * Parses a media reference string into a ParsedMediaReference.
+   *
+   * Example reference string:
+   *     "@@@langfuseMedia:type=image/jpeg|id=some-uuid|source=base64DataUri@@@"
+   *
+   * @param referenceString - The reference string to parse.
+   * @returns An object with the mediaId, source, and contentType.
+   *
+   * @throws Error if the reference string is invalid or missing required fields.
+   */
+  static parseReferenceString(referenceString) {
+    const prefix = "@@@langfuseMedia:";
+    const suffix = "@@@";
+    if (!referenceString.startsWith(prefix)) {
+      throw new Error(
+        "Reference string does not start with '@@@langfuseMedia:type='"
+      );
+    }
+    if (!referenceString.endsWith(suffix)) {
+      throw new Error("Reference string does not end with '@@@'");
+    }
+    const content = referenceString.slice(prefix.length, -suffix.length);
+    const pairs = content.split("|");
+    const parsedData = {};
+    for (const pair of pairs) {
+      const [key, value] = pair.split("=", 2);
+      parsedData[key] = value;
+    }
+    if (!("type" in parsedData && "id" in parsedData && "source" in parsedData)) {
+      throw new Error("Missing required fields in reference string");
+    }
+    return {
+      mediaId: parsedData["id"],
+      source: parsedData["source"],
+      contentType: parsedData["type"]
+    };
+  }
+};
+
+// src/prompt/promptManager.ts
+var import_core3 = require("@langfuse/core");
+
+// src/prompt/promptCache.ts
+var import_core2 = require("@langfuse/core");
+var DEFAULT_PROMPT_CACHE_TTL_SECONDS = 60;
+var LangfusePromptCacheItem = class {
+  constructor(value, ttlSeconds) {
+    this.value = value;
+    this._expiry = Date.now() + ttlSeconds * 1e3;
+  }
+  get isExpired() {
+    return Date.now() > this._expiry;
+  }
+};
+var LangfusePromptCache = class {
+  constructor() {
+    this._cache = /* @__PURE__ */ new Map();
+    this._defaultTtlSeconds = DEFAULT_PROMPT_CACHE_TTL_SECONDS;
+    this._refreshingKeys = /* @__PURE__ */ new Map();
+  }
+  getIncludingExpired(key) {
+    var _a;
+    return (_a = this._cache.get(key)) != null ? _a : null;
+  }
+  createKey(params) {
+    const { name, version, label } = params;
+    const parts = [name];
+    if (version !== void 0) {
+      parts.push("version:" + version.toString());
+    } else if (label !== void 0) {
+      parts.push("label:" + label);
+    } else {
+      parts.push("label:production");
+    }
+    return parts.join("-");
+  }
+  set(key, value, ttlSeconds) {
+    const effectiveTtlSeconds = ttlSeconds != null ? ttlSeconds : this._defaultTtlSeconds;
+    this._cache.set(
+      key,
+      new LangfusePromptCacheItem(value, effectiveTtlSeconds)
+    );
+  }
+  addRefreshingPromise(key, promise) {
+    this._refreshingKeys.set(key, promise);
+    promise.then(() => {
+      this._refreshingKeys.delete(key);
+    }).catch(() => {
+      this._refreshingKeys.delete(key);
+    });
+  }
+  isRefreshing(key) {
+    return this._refreshingKeys.has(key);
+  }
+  invalidate(promptName) {
+    (0, import_core2.getGlobalLogger)().debug(
+      "Invalidating cache keys for",
+      promptName,
+      this._cache.keys()
+    );
+    for (const key of this._cache.keys()) {
+      if (key.startsWith(promptName)) {
+        this._cache.delete(key);
+      }
+    }
+  }
+};
+
+// src/prompt/promptClients.ts
+var import_mustache = __toESM(require("mustache"), 1);
+
+// src/prompt/types.ts
+var ChatMessageType = /* @__PURE__ */ ((ChatMessageType2) => {
+  ChatMessageType2["ChatMessage"] = "chatmessage";
+  ChatMessageType2["Placeholder"] = "placeholder";
+  return ChatMessageType2;
+})(ChatMessageType || {});
+
+// src/prompt/promptClients.ts
+import_mustache.default.escape = function(text) {
+  return text;
+};
+var BasePromptClient = class {
+  constructor(prompt, isFallback = false, type) {
+    this.name = prompt.name;
+    this.version = prompt.version;
+    this.config = prompt.config;
+    this.labels = prompt.labels;
+    this.tags = prompt.tags;
+    this.isFallback = isFallback;
+    this.type = type;
+    this.commitMessage = prompt.commitMessage;
+  }
+  _transformToLangchainVariables(content) {
+    const jsonEscapedContent = this.escapeJsonForLangchain(content);
+    return jsonEscapedContent.replace(/\{\{(\w+)\}\}/g, "{$1}");
+  }
+  /**
+   * Escapes every curly brace that is part of a JSON object by doubling it.
+   *
+   * A curly brace is considered “JSON-related” when, after skipping any immediate
+   * whitespace, the next non-whitespace character is a single (') or double (") quote.
+   *
+   * Braces that are already doubled (e.g. `{{variable}}` placeholders) are left untouched.
+   *
+   * @param text - Input string that may contain JSON snippets.
+   * @returns The string with JSON-related braces doubled.
+   */
+  escapeJsonForLangchain(text) {
+    var _a;
+    const out = [];
+    const stack = [];
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+      const ch = text[i];
+      if (ch === "{") {
+        if (i + 1 < n && text[i + 1] === "{") {
+          out.push("{{");
+          i += 2;
+          continue;
+        }
+        let j = i + 1;
+        while (j < n && /\s/.test(text[j])) {
+          j++;
+        }
+        const isJson = j < n && (text[j] === "'" || text[j] === '"');
+        out.push(isJson ? "{{" : "{");
+        stack.push(isJson);
+        i += 1;
+        continue;
+      }
+      if (ch === "}") {
+        if (i + 1 < n && text[i + 1] === "}") {
+          out.push("}}");
+          i += 2;
+          continue;
+        }
+        const isJson = (_a = stack.pop()) != null ? _a : false;
+        out.push(isJson ? "}}" : "}");
+        i += 1;
+        continue;
+      }
+      out.push(ch);
+      i += 1;
+    }
+    return out.join("");
+  }
+};
+var TextPromptClient = class extends BasePromptClient {
+  constructor(prompt, isFallback = false) {
+    super(prompt, isFallback, "text");
+    this.promptResponse = prompt;
+    this.prompt = prompt.prompt;
+  }
+  compile(variables, _placeholders) {
+    return import_mustache.default.render(this.promptResponse.prompt, variables != null ? variables : {});
+  }
+  getLangchainPrompt(_options) {
+    return this._transformToLangchainVariables(this.prompt);
+  }
+  toJSON() {
+    return JSON.stringify({
+      name: this.name,
+      prompt: this.prompt,
+      version: this.version,
+      isFallback: this.isFallback,
+      tags: this.tags,
+      labels: this.labels,
+      type: this.type,
+      config: this.config
+    });
+  }
+};
+var ChatPromptClient = class _ChatPromptClient extends BasePromptClient {
+  constructor(prompt, isFallback = false) {
+    const normalizedPrompt = _ChatPromptClient.normalizePrompt(prompt.prompt);
+    const typedPrompt = {
+      ...prompt,
+      prompt: normalizedPrompt
+    };
+    super(typedPrompt, isFallback, "chat");
+    this.promptResponse = typedPrompt;
+    this.prompt = normalizedPrompt;
+  }
+  static normalizePrompt(prompt) {
+    return prompt.map((item) => {
+      if ("type" in item) {
+        return item;
+      } else {
+        return {
+          type: "chatmessage" /* ChatMessage */,
+          ...item
+        };
+      }
+    });
+  }
+  compile(variables, placeholders) {
+    const messagesWithPlaceholdersReplaced = [];
+    const placeholderValues = placeholders != null ? placeholders : {};
+    for (const item of this.prompt) {
+      if ("type" in item && item.type === "placeholder" /* Placeholder */) {
+        const placeholderValue = placeholderValues[item.name];
+        if (Array.isArray(placeholderValue) && placeholderValue.length > 0 && placeholderValue.every(
+          (msg) => typeof msg === "object" && "role" in msg && "content" in msg
+        )) {
+          messagesWithPlaceholdersReplaced.push(
+            ...placeholderValue
+          );
+        } else if (Array.isArray(placeholderValue) && placeholderValue.length === 0) {
+        } else if (placeholderValue !== void 0) {
+          messagesWithPlaceholdersReplaced.push(
+            JSON.stringify(placeholderValue)
+          );
+        } else {
+          messagesWithPlaceholdersReplaced.push(
+            item
+          );
+        }
+      } else if ("role" in item && "content" in item && item.type === "chatmessage" /* ChatMessage */) {
+        messagesWithPlaceholdersReplaced.push({
+          role: item.role,
+          content: item.content
+        });
+      }
+    }
+    return messagesWithPlaceholdersReplaced.map((item) => {
+      if (typeof item === "object" && item !== null && "role" in item && "content" in item) {
+        return {
+          ...item,
+          content: import_mustache.default.render(item.content, variables != null ? variables : {})
+        };
+      } else {
+        return item;
+      }
+    });
+  }
+  getLangchainPrompt(options) {
+    var _a;
+    const messagesWithPlaceholdersReplaced = [];
+    const placeholderValues = (_a = options == null ? void 0 : options.placeholders) != null ? _a : {};
+    for (const item of this.prompt) {
+      if ("type" in item && item.type === "placeholder" /* Placeholder */) {
+        const placeholderValue = placeholderValues[item.name];
+        if (Array.isArray(placeholderValue) && placeholderValue.length > 0 && placeholderValue.every(
+          (msg) => typeof msg === "object" && "role" in msg && "content" in msg
+        )) {
+          messagesWithPlaceholdersReplaced.push(
+            ...placeholderValue.map((msg) => {
+              return {
+                role: msg.role,
+                content: this._transformToLangchainVariables(msg.content)
+              };
+            })
+          );
+        } else if (Array.isArray(placeholderValue) && placeholderValue.length === 0) {
+        } else if (placeholderValue !== void 0) {
+          messagesWithPlaceholdersReplaced.push(
+            JSON.stringify(placeholderValue)
+          );
+        } else {
+          messagesWithPlaceholdersReplaced.push({
+            variableName: item.name,
+            optional: false
+          });
+        }
+      } else if ("role" in item && "content" in item && item.type === "chatmessage" /* ChatMessage */) {
+        messagesWithPlaceholdersReplaced.push({
+          role: item.role,
+          content: this._transformToLangchainVariables(item.content)
+        });
+      }
+    }
+    return messagesWithPlaceholdersReplaced;
+  }
+  toJSON() {
+    return JSON.stringify({
+      name: this.name,
+      prompt: this.promptResponse.prompt.map((item) => {
+        if ("type" in item && item.type === "chatmessage" /* ChatMessage */) {
+          const { type: _, ...messageWithoutType } = item;
+          return messageWithoutType;
+        }
+        return item;
+      }),
+      version: this.version,
+      isFallback: this.isFallback,
+      tags: this.tags,
+      labels: this.labels,
+      type: this.type,
+      config: this.config
+    });
+  }
+};
+
+// src/prompt/promptManager.ts
+var PromptManager = class {
+  constructor(params) {
+    const { apiClient } = params;
+    this.apiClient = apiClient;
+    this.cache = new LangfusePromptCache();
+  }
+  get logger() {
+    return (0, import_core3.getGlobalLogger)();
+  }
+  async create(body) {
+    var _a;
+    const requestBody = body.type === "chat" ? {
+      ...body,
+      prompt: body.prompt.map((item) => {
+        if ("type" in item && item.type === "placeholder" /* Placeholder */) {
+          return {
+            type: "placeholder" /* Placeholder */,
+            name: item.name
+          };
+        } else {
+          return { type: "chatmessage" /* ChatMessage */, ...item };
+        }
+      })
+    } : {
+      ...body,
+      type: (_a = body.type) != null ? _a : "text"
+    };
+    const promptResponse = await this.apiClient.prompts.create(requestBody);
+    if (promptResponse.type === "chat") {
+      return new ChatPromptClient(promptResponse);
+    }
+    return new TextPromptClient(promptResponse);
+  }
+  async update(params) {
+    const { name, version, newLabels } = params;
+    const newPrompt = await this.apiClient.promptVersion.update(name, version, {
+      newLabels
+    });
+    this.cache.invalidate(name);
+    return newPrompt;
+  }
+  async get(name, options) {
+    var _a;
+    const cacheKey = this.cache.createKey({
+      name,
+      label: options == null ? void 0 : options.label
+    });
+    const cachedPrompt = this.cache.getIncludingExpired(cacheKey);
+    if (!cachedPrompt || (options == null ? void 0 : options.cacheTtlSeconds) === 0) {
+      try {
+        return await this.fetchPromptAndUpdateCache({
+          name,
+          version: options == null ? void 0 : options.version,
+          label: options == null ? void 0 : options.label,
+          cacheTtlSeconds: options == null ? void 0 : options.cacheTtlSeconds,
+          maxRetries: options == null ? void 0 : options.maxRetries,
+          fetchTimeoutMs: options == null ? void 0 : options.fetchTimeoutMs
+        });
+      } catch (err) {
+        if (options == null ? void 0 : options.fallback) {
+          const sharedFallbackParams = {
+            name,
+            version: (_a = options == null ? void 0 : options.version) != null ? _a : 0,
+            labels: options.label ? [options.label] : [],
+            cacheTtlSeconds: options == null ? void 0 : options.cacheTtlSeconds,
+            config: {},
+            tags: []
+          };
+          if (options.type === "chat") {
+            return new ChatPromptClient(
+              {
+                ...sharedFallbackParams,
+                type: "chat",
+                prompt: options.fallback.map((msg) => ({
+                  type: "chatmessage" /* ChatMessage */,
+                  ...msg
+                }))
+              },
+              true
+            );
+          } else {
+            return new TextPromptClient(
+              {
+                ...sharedFallbackParams,
+                type: "text",
+                prompt: options.fallback
+              },
+              true
+            );
+          }
+        }
+        throw err;
+      }
+    }
+    if (cachedPrompt.isExpired) {
+      if (!this.cache.isRefreshing(cacheKey)) {
+        const refreshPromptPromise = this.fetchPromptAndUpdateCache({
+          name,
+          version: options == null ? void 0 : options.version,
+          label: options == null ? void 0 : options.label,
+          cacheTtlSeconds: options == null ? void 0 : options.cacheTtlSeconds,
+          maxRetries: options == null ? void 0 : options.maxRetries,
+          fetchTimeoutMs: options == null ? void 0 : options.fetchTimeoutMs
+        }).catch(() => {
+          this.logger.warn(
+            `Failed to refresh prompt cache '${cacheKey}', stale cache will be used until next refresh succeeds.`
+          );
+        });
+        this.cache.addRefreshingPromise(cacheKey, refreshPromptPromise);
+      }
+      return cachedPrompt.value;
+    }
+    return cachedPrompt.value;
+  }
+  async fetchPromptAndUpdateCache(params) {
+    const cacheKey = this.cache.createKey(params);
+    try {
+      const {
+        name,
+        version,
+        cacheTtlSeconds,
+        label,
+        maxRetries,
+        fetchTimeoutMs
+      } = params;
+      const data = await this.apiClient.prompts.get(
+        name,
+        {
+          version,
+          label
+        },
+        {
+          maxRetries,
+          timeoutInSeconds: fetchTimeoutMs ? fetchTimeoutMs / 1e3 : void 0
+        }
+      );
+      let prompt;
+      if (data.type === "chat") {
+        prompt = new ChatPromptClient(data);
+      } else {
+        prompt = new TextPromptClient(data);
+      }
+      this.cache.set(cacheKey, prompt, cacheTtlSeconds);
+      return prompt;
+    } catch (error) {
+      this.logger.error(`Error fetching prompt '${cacheKey}':`, error);
+      throw error;
+    }
+  }
+};
+
+// src/score/index.ts
+var import_core4 = require("@langfuse/core");
+var import_api = require("@opentelemetry/api");
+var MAX_QUEUE_SIZE = 1e5;
+var MAX_BATCH_SIZE = 100;
+var ScoreManager = class {
+  constructor(params) {
+    this.eventQueue = [];
+    this.flushPromise = null;
+    this.flushTimer = null;
+    this.apiClient = params.apiClient;
+    const envFlushAtCount = (0, import_core4.getEnv)("LANGFUSE_FLUSH_AT");
+    const envFlushIntervalSeconds = (0, import_core4.getEnv)("LANGFUSE_FLUSH_INTERVAL");
+    this.flushAtCount = envFlushAtCount ? Number(envFlushAtCount) : 10;
+    this.flushIntervalSeconds = envFlushIntervalSeconds ? Number(envFlushIntervalSeconds) : 1;
+  }
+  get logger() {
+    return (0, import_core4.getGlobalLogger)();
+  }
+  create(data) {
+    var _a, _b;
+    const scoreData = {
+      ...data,
+      id: (_a = data.id) != null ? _a : (0, import_core4.generateUUID)(),
+      environment: (_b = data.environment) != null ? _b : (0, import_core4.getEnv)("LANGFUSE_TRACING_ENVIRONMENT")
+    };
+    const scoreIngestionEvent = {
+      id: (0, import_core4.generateUUID)(),
+      type: "score-create",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      body: scoreData
+    };
+    if (this.eventQueue.length >= MAX_QUEUE_SIZE) {
+      this.logger.error(
+        `Score queue is at max size ${MAX_QUEUE_SIZE}. Dropping score.`
+      );
+      return;
+    }
+    this.eventQueue.push(scoreIngestionEvent);
+    if (this.eventQueue.length >= this.flushAtCount) {
+      this.flushPromise = this.flush();
+    } else if (!this.flushTimer) {
+      this.flushTimer = (0, import_core4.safeSetTimeout)(() => {
+        this.flushPromise = this.flush();
+      }, this.flushIntervalSeconds * 1e3);
+    }
+  }
+  observation(observation, data) {
+    const { spanId, traceId } = observation.otelSpan.spanContext();
+    this.create({
+      ...data,
+      traceId,
+      observationId: spanId
+    });
+  }
+  trace(observation, data) {
+    const { traceId } = observation.otelSpan.spanContext();
+    this.create({
+      ...data,
+      traceId
+    });
+  }
+  activeObservation(data) {
+    const currentOtelSpan = import_api.trace.getActiveSpan();
+    if (!currentOtelSpan) {
+      this.logger.warn("No active span in context to score.");
+      return;
+    }
+    const { spanId, traceId } = currentOtelSpan.spanContext();
+    this.create({
+      ...data,
+      traceId,
+      observationId: spanId
+    });
+  }
+  activeTrace(data) {
+    const currentOtelSpan = import_api.trace.getActiveSpan();
+    if (!currentOtelSpan) {
+      this.logger.warn("No active span in context to score trace.");
+      return;
+    }
+    const { traceId } = currentOtelSpan.spanContext();
+    this.create({
+      ...data,
+      traceId
+    });
+  }
+  async handleFlush() {
+    try {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      const promises = [];
+      while (this.eventQueue.length > 0) {
+        const batch = this.eventQueue.splice(0, MAX_BATCH_SIZE);
+        promises.push(
+          this.apiClient.ingestion.batch({ batch }).then((res) => {
+            var _a;
+            if (((_a = res.errors) == null ? void 0 : _a.length) > 0) {
+              this.logger.error("Error ingesting scores:", res.errors);
+            }
+          }).catch((err) => {
+            this.logger.error("Failed to export score batch:", err);
+          })
+        );
+      }
+      await Promise.all(promises);
+    } catch (err) {
+      this.logger.error("Error flushing Score Manager: ", err);
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  async flush() {
+    var _a;
+    return (_a = this.flushPromise) != null ? _a : this.handleFlush();
+  }
+  async shutdown() {
+    await this.flush();
+  }
+};
+
+// src/LangfuseClient.ts
+var LangfuseClient = class {
+  constructor(params) {
+    this.projectId = null;
+    var _a, _b, _c, _d, _e, _f, _g;
+    const logger = (0, import_core5.getGlobalLogger)();
+    const publicKey = (_a = params == null ? void 0 : params.publicKey) != null ? _a : (0, import_core5.getEnv)("LANGFUSE_PUBLIC_KEY");
+    const secretKey = (_b = params == null ? void 0 : params.secretKey) != null ? _b : (0, import_core5.getEnv)("LANGFUSE_SECRET_KEY");
+    this.baseUrl = (_e = (_d = (_c = params == null ? void 0 : params.baseUrl) != null ? _c : (0, import_core5.getEnv)("LANGFUSE_BASE_URL")) != null ? _d : (0, import_core5.getEnv)("LANGFUSE_BASEURL")) != null ? _e : (
+      // legacy v2
+      "https://cloud.langfuse.com"
+    );
+    if (!publicKey) {
+      logger.warn(
+        "No public key provided in constructor or as LANGFUSE_PUBLIC_KEY env var. Client operations will fail."
+      );
+    }
+    if (!secretKey) {
+      logger.warn(
+        "No secret key provided in constructor or as LANGFUSE_SECRET_KEY env var. Client operations will fail."
+      );
+    }
+    const timeoutSeconds = (_g = params == null ? void 0 : params.timeout) != null ? _g : Number((_f = (0, import_core5.getEnv)("LANGFUSE_TIMEOUT")) != null ? _f : 5);
+    this.api = new import_core5.LangfuseAPIClient({
+      baseUrl: this.baseUrl,
+      username: publicKey,
+      password: secretKey,
+      xLangfusePublicKey: publicKey,
+      xLangfuseSdkVersion: import_core5.LANGFUSE_SDK_VERSION,
+      xLangfuseSdkName: "javascript",
+      environment: "",
+      // noop as baseUrl is set
+      headers: params == null ? void 0 : params.additionalHeaders
+    });
+    logger.debug("Initialized LangfuseClient with params:", {
+      publicKey,
+      baseUrl: this.baseUrl,
+      timeoutSeconds
+    });
+    this.prompt = new PromptManager({ apiClient: this.api });
+    this.dataset = new DatasetManager({ apiClient: this.api });
+    this.score = new ScoreManager({ apiClient: this.api });
+    this.media = new MediaManager({ apiClient: this.api });
+    this.getPrompt = this.prompt.get.bind(this.prompt);
+    this.createPrompt = this.prompt.create.bind(this.prompt);
+    this.updatePrompt = this.prompt.update.bind(this.prompt);
+    this.getDataset = this.dataset.get;
+    this.fetchTrace = this.api.trace.get;
+    this.fetchTraces = this.api.trace.list;
+    this.fetchObservation = this.api.observations.get;
+    this.fetchObservations = this.api.observations.getMany;
+    this.fetchSessions = this.api.sessions.get;
+    this.getDatasetRun = this.api.datasets.getRun;
+    this.getDatasetRuns = this.api.datasets.getRuns;
+    this.createDataset = this.api.datasets.create;
+    this.getDatasetItem = this.api.datasetItems.get;
+    this.createDatasetItem = this.api.datasetItems.create;
+    this.fetchMedia = this.api.media.get;
+    this.resolveMediaReferences = this.media.resolveReferences;
+  }
+  async flush() {
+    return this.score.flush();
+  }
+  async shutdown() {
+    return this.score.shutdown();
+  }
+  async getTraceUrl(traceId) {
+    let projectId = this.projectId;
+    if (!projectId) {
+      projectId = (await this.api.projects.get()).data[0].id;
+      this.projectId = projectId;
+    }
+    const traceUrl = `${this.baseUrl}/project/${projectId}/traces/${traceId}`;
+    return traceUrl;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatMessageType,
+  ChatPromptClient,
+  DatasetManager,
+  LangfuseClient,
+  MediaManager,
+  PromptManager,
+  ScoreManager,
+  TextPromptClient
+});
+//# sourceMappingURL=index.cjs.map