@langfuse/client 4.0.0-alpha.0

package/dist/prompt/promptClients.js

@@ -0,0 +1,279 @@
+import mustache from "mustache";
+import { ChatMessageType, } from "./types.js";
+mustache.escape = function (text) {
+    return text;
+};
+class BasePromptClient {
+    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 = []; // collected characters
+        const stack = []; // true = “this { belongs to JSON”, false = normal “{”
+        let i = 0;
+        const n = text.length;
+        while (i < n) {
+            const ch = text[i];
+            // ---------- opening brace ----------
+            if (ch === "{") {
+                // leave existing “{{ …” untouched
+                if (i + 1 < n && text[i + 1] === "{") {
+                    out.push("{{");
+                    i += 2;
+                    continue;
+                }
+                // look ahead to find the next non-space character
+                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); // remember how this “{” was treated
+                i += 1;
+                continue;
+            }
+            // ---------- closing brace ----------
+            if (ch === "}") {
+                // leave existing “… }}” untouched
+                if (i + 1 < n && text[i + 1] === "}") {
+                    out.push("}}");
+                    i += 2;
+                    continue;
+                }
+                const isJson = (_a = stack.pop()) !== null && _a !== void 0 ? _a : false;
+                out.push(isJson ? "}}" : "}");
+                i += 1;
+                continue;
+            }
+            // ---------- any other character ----------
+            out.push(ch);
+            i += 1;
+        }
+        return out.join("");
+    }
+}
+export class TextPromptClient extends BasePromptClient {
+    constructor(prompt, isFallback = false) {
+        super(prompt, isFallback, "text");
+        this.promptResponse = prompt;
+        this.prompt = prompt.prompt;
+    }
+    compile(variables, _placeholders) {
+        return mustache.render(this.promptResponse.prompt, variables !== null && variables !== void 0 ? variables : {});
+    }
+    getLangchainPrompt(_options) {
+        /**
+         * Converts Langfuse prompt into string compatible with Langchain PromptTemplate.
+         *
+         * It specifically adapts the mustache-style double curly braces {{variable}} used in Langfuse
+         * to the single curly brace {variable} format expected by Langchain.
+         *
+         * @returns {string} The string that can be plugged into Langchain's PromptTemplate.
+         */
+        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,
+        });
+    }
+}
+export 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) {
+        // Convert ChatMessages to ChatMessageWithPlaceholders for backward compatibility
+        return prompt.map((item) => {
+            if ("type" in item) {
+                // Already has type field (new format)
+                return item;
+            }
+            else {
+                // Plain ChatMessage (legacy format) - add type field
+                return {
+                    type: ChatMessageType.ChatMessage,
+                    ...item,
+                };
+            }
+        });
+    }
+    compile(variables, placeholders) {
+        /**
+         * Compiles the chat prompt by replacing placeholders and variables with provided values.
+         *
+         * First fills-in placeholders by from the provided placeholder parameter.
+         * Then compiles variables into the message content.
+         * Unresolved placeholders are included in the output as placeholder objects.
+         * If you only want to fill-in placeholders, pass an empty object for variables.
+         *
+         * @param variables - Key-value pairs for Mustache variable substitution in message content
+         * @param placeholders - Key-value pairs where keys are placeholder names and values can be ChatMessage arrays
+         * @returns Array of ChatMessage objects and placeholder objects with placeholders replaced and variables rendered
+         */
+        const messagesWithPlaceholdersReplaced = [];
+        const placeholderValues = placeholders !== null && placeholders !== void 0 ? placeholders : {};
+        for (const item of this.prompt) {
+            if ("type" in item && item.type === ChatMessageType.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) {
+                    // Empty array provided - skip placeholder (don't include it)
+                }
+                else if (placeholderValue !== undefined) {
+                    // Non-standard placeholder value format, just stringfiy
+                    messagesWithPlaceholdersReplaced.push(JSON.stringify(placeholderValue));
+                }
+                else {
+                    // Keep unresolved placeholder in the output
+                    messagesWithPlaceholdersReplaced.push(item);
+                }
+            }
+            else if ("role" in item &&
+                "content" in item &&
+                item.type === ChatMessageType.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: mustache.render(item.content, variables !== null && variables !== void 0 ? variables : {}),
+                };
+            }
+            else {
+                // Return placeholder or stringified value as-is
+                return item;
+            }
+        });
+    }
+    getLangchainPrompt(options) {
+        var _a;
+        /*
+         * Converts Langfuse prompt into format compatible with Langchain PromptTemplate.
+         *
+         * Fills-in placeholders from provided values and converts unresolved ones to Langchain MessagesPlaceholder objects.
+         * Transforms variables from {{var}} to {var} format for Langchain without rendering them.
+         *
+         * @param options - Configuration object
+         * @param options.placeholders - Key-value pairs where keys are placeholder names and values can be ChatMessage arrays
+         * @returns Array of ChatMessage objects and Langchain MessagesPlaceholder objects with variables transformed for Langchain compatibility.
+         *
+         * @example
+         * ```typescript
+         * const client = new ChatPromptClient(prompt);
+         * client.getLangchainPrompt({ placeholders: { examples: [{ role: "user", content: "Hello" }] } });
+         * ```
+         */
+        const messagesWithPlaceholdersReplaced = [];
+        const placeholderValues = (_a = options === null || options === void 0 ? void 0 : options.placeholders) !== null && _a !== void 0 ? _a : {};
+        for (const item of this.prompt) {
+            if ("type" in item && item.type === ChatMessageType.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)) {
+                    // Complete placeholder fill-in, replace with it
+                    messagesWithPlaceholdersReplaced.push(...placeholderValue.map((msg) => {
+                        return {
+                            role: msg.role,
+                            content: this._transformToLangchainVariables(msg.content),
+                        };
+                    }));
+                }
+                else if (Array.isArray(placeholderValue) &&
+                    placeholderValue.length === 0) {
+                    // Skip empty array placeholder
+                }
+                else if (placeholderValue !== undefined) {
+                    // Non-standard placeholder value, just stringify and add directly
+                    messagesWithPlaceholdersReplaced.push(JSON.stringify(placeholderValue));
+                }
+                else {
+                    // Convert unresolved placeholder to Langchain MessagesPlaceholder
+                    messagesWithPlaceholdersReplaced.push({
+                        variableName: item.name,
+                        optional: false,
+                    });
+                }
+            }
+            else if ("role" in item &&
+                "content" in item &&
+                item.type === ChatMessageType.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 === ChatMessageType.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,
+        });
+    }
+}

package/dist/prompt/promptManager.d.ts

@@ -0,0 +1,41 @@
+import { CreatePromptRequest, LangfuseAPIClient, Prompt, ChatMessage } from "@langfuse/core";
+import { ChatPromptClient, TextPromptClient } from "./promptClients.js";
+import { CreateChatPromptBodyWithPlaceholders } from "./types.js";
+export declare class PromptManager {
+    private cache;
+    private apiClient;
+    constructor(params: {
+        apiClient: LangfuseAPIClient;
+    });
+    get logger(): import("@langfuse/core").Logger;
+    create(body: CreateChatPromptBodyWithPlaceholders): Promise<ChatPromptClient>;
+    create(body: Omit<CreatePromptRequest.Text, "type"> & {
+        type?: "text";
+    }): Promise<TextPromptClient>;
+    create(body: CreatePromptRequest.Chat): Promise<ChatPromptClient>;
+    update(params: {
+        name: string;
+        version: number;
+        newLabels: string[];
+    }): Promise<Prompt>;
+    get(name: string, options?: {
+        version?: number;
+        label?: string;
+        cacheTtlSeconds?: number;
+        fallback?: string;
+        maxRetries?: number;
+        type?: "text";
+        fetchTimeoutMs?: number;
+    }): Promise<TextPromptClient>;
+    get(name: string, options?: {
+        version?: number;
+        label?: string;
+        cacheTtlSeconds?: number;
+        fallback?: ChatMessage[];
+        maxRetries?: number;
+        type: "chat";
+        fetchTimeoutMs?: number;
+    }): Promise<ChatPromptClient>;
+    private fetchPromptAndUpdateCache;
+}
+//# sourceMappingURL=promptManager.d.ts.map

package/dist/prompt/promptManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptManager.d.ts","sourceRoot":"","sources":["../../src/prompt/promptManager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAEnB,iBAAiB,EAEjB,MAAM,EACN,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAEL,oCAAoC,EACrC,MAAM,YAAY,CAAC;AAEpB,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAoB;gBAEzB,MAAM,EAAE;QAAE,SAAS,EAAE,iBAAiB,CAAA;KAAE;IAOpD,IAAI,MAAM,oCAET;IAEK,MAAM,CACV,IAAI,EAAE,oCAAoC,GACzC,OAAO,CAAC,gBAAgB,CAAC;IACtB,MAAM,CACV,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAC/D,OAAO,CAAC,gBAAgB,CAAC;IACtB,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqCjE,MAAM,CAAC,MAAM,EAAE;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,GAAG,OAAO,CAAC,MAAM,CAAC;IAYb,GAAG,CACP,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,gBAAgB,CAAC;IACtB,GAAG,CACP,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,gBAAgB,CAAC;YA2Fd,yBAAyB;CAgDxC"}

package/dist/prompt/promptManager.js

@@ -0,0 +1,144 @@
+import { getGlobalLogger, } from "@langfuse/core";
+import { LangfusePromptCache } from "./promptCache.js";
+import { ChatPromptClient, TextPromptClient, } from "./promptClients.js";
+import { ChatMessageType, } from "./types.js";
+export class PromptManager {
+    constructor(params) {
+        const { apiClient } = params;
+        this.apiClient = apiClient;
+        this.cache = new LangfusePromptCache();
+    }
+    get logger() {
+        return getGlobalLogger();
+    }
+    async create(body) {
+        var _a;
+        const requestBody = body.type === "chat"
+            ? {
+                ...body,
+                prompt: body.prompt.map((item) => {
+                    if ("type" in item && item.type === ChatMessageType.Placeholder) {
+                        return {
+                            type: ChatMessageType.Placeholder,
+                            name: item.name,
+                        };
+                    }
+                    else {
+                        // Handle regular ChatMessage (without type field) from API
+                        return { type: ChatMessageType.ChatMessage, ...item };
+                    }
+                }),
+            }
+            : {
+                ...body,
+                type: (_a = body.type) !== null && _a !== void 0 ? _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 || options === void 0 ? void 0 : options.label,
+        });
+        const cachedPrompt = this.cache.getIncludingExpired(cacheKey);
+        if (!cachedPrompt || (options === null || options === void 0 ? void 0 : options.cacheTtlSeconds) === 0) {
+            try {
+                return await this.fetchPromptAndUpdateCache({
+                    name,
+                    version: options === null || options === void 0 ? void 0 : options.version,
+                    label: options === null || options === void 0 ? void 0 : options.label,
+                    cacheTtlSeconds: options === null || options === void 0 ? void 0 : options.cacheTtlSeconds,
+                    maxRetries: options === null || options === void 0 ? void 0 : options.maxRetries,
+                    fetchTimeoutMs: options === null || options === void 0 ? void 0 : options.fetchTimeoutMs,
+                });
+            }
+            catch (err) {
+                if (options === null || options === void 0 ? void 0 : options.fallback) {
+                    const sharedFallbackParams = {
+                        name,
+                        version: (_a = options === null || options === void 0 ? void 0 : options.version) !== null && _a !== void 0 ? _a : 0,
+                        labels: options.label ? [options.label] : [],
+                        cacheTtlSeconds: options === null || options === void 0 ? void 0 : options.cacheTtlSeconds,
+                        config: {},
+                        tags: [],
+                    };
+                    if (options.type === "chat") {
+                        return new ChatPromptClient({
+                            ...sharedFallbackParams,
+                            type: "chat",
+                            prompt: options.fallback.map((msg) => ({
+                                type: ChatMessageType.ChatMessage,
+                                ...msg,
+                            })),
+                        }, true);
+                    }
+                    else {
+                        return new TextPromptClient({
+                            ...sharedFallbackParams,
+                            type: "text",
+                            prompt: options.fallback,
+                        }, true);
+                    }
+                }
+                throw err;
+            }
+        }
+        if (cachedPrompt.isExpired) {
+            // If the cache is not currently being refreshed, start refreshing it and register the promise in the cache
+            if (!this.cache.isRefreshing(cacheKey)) {
+                const refreshPromptPromise = this.fetchPromptAndUpdateCache({
+                    name,
+                    version: options === null || options === void 0 ? void 0 : options.version,
+                    label: options === null || options === void 0 ? void 0 : options.label,
+                    cacheTtlSeconds: options === null || options === void 0 ? void 0 : options.cacheTtlSeconds,
+                    maxRetries: options === null || options === void 0 ? void 0 : options.maxRetries,
+                    fetchTimeoutMs: options === null || options === void 0 ? 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 / 1000 : undefined,
+            });
+            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;
+        }
+    }
+}

package/dist/prompt/types.d.ts

@@ -0,0 +1,18 @@
+import { ChatMessage, PlaceholderMessage, ChatMessageWithPlaceholders, CreatePromptRequest } from "@langfuse/core";
+export declare enum ChatMessageType {
+    ChatMessage = "chatmessage",
+    Placeholder = "placeholder"
+}
+export type ChatMessageOrPlaceholder = ChatMessage | ({
+    type: ChatMessageType.Placeholder;
+} & PlaceholderMessage);
+export type LangchainMessagesPlaceholder = {
+    variableName: string;
+    optional?: boolean;
+};
+export type CreateChatPromptBodyWithPlaceholders = {
+    type: "chat";
+} & Omit<CreatePromptRequest.Chat, "type" | "prompt"> & {
+    prompt: (ChatMessage | ChatMessageWithPlaceholders)[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/prompt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/prompt/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,oBAAY,eAAe;IACzB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,wBAAwB,GAChC,WAAW,GACX,CAAC;IAAE,IAAI,EAAE,eAAe,CAAC,WAAW,CAAA;CAAE,GAAG,kBAAkB,CAAC,CAAC;AAEjE,MAAM,MAAM,4BAA4B,GAAG;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG;IACpD,MAAM,EAAE,CAAC,WAAW,GAAG,2BAA2B,CAAC,EAAE,CAAC;CACvD,CAAC"}

package/dist/prompt/types.js

@@ -0,0 +1,5 @@
+export var ChatMessageType;
+(function (ChatMessageType) {
+    ChatMessageType["ChatMessage"] = "chatmessage";
+    ChatMessageType["Placeholder"] = "placeholder";
+})(ChatMessageType || (ChatMessageType = {}));

package/dist/score/index.d.ts

@@ -0,0 +1,27 @@
+import { LangfuseAPIClient, ScoreBody } from "@langfuse/core";
+import { Span } from "@opentelemetry/api";
+export declare class ScoreManager {
+    private apiClient;
+    private eventQueue;
+    private flushPromise;
+    private flushTimer;
+    private flushAtCount;
+    private flushIntervalSeconds;
+    constructor(params: {
+        apiClient: LangfuseAPIClient;
+    });
+    get logger(): import("@langfuse/core").Logger;
+    create(data: ScoreBody): void;
+    observation(observation: {
+        otelSpan: Span;
+    }, data: Omit<ScoreBody, "traceId" | "sessionId" | "observationId" | "datasetRunId">): void;
+    trace(observation: {
+        otelSpan: Span;
+    }, data: Omit<ScoreBody, "traceId" | "sessionId" | "observationId" | "datasetRunId">): void;
+    activeObservation(data: Omit<ScoreBody, "traceId" | "sessionId" | "observationId" | "datasetRunId">): void;
+    activeTrace(data: Omit<ScoreBody, "traceId" | "sessionId" | "observationId" | "datasetRunId">): void;
+    private handleFlush;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/score/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/score/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EAIjB,SAAS,EAIV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,IAAI,EAAS,MAAM,oBAAoB,CAAC;AAKjD,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,oBAAoB,CAAS;gBAEzB,MAAM,EAAE;QAAE,SAAS,EAAE,iBAAiB,CAAA;KAAE;IAYpD,IAAI,MAAM,oCAET;IAEM,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAgC7B,WAAW,CAChB,WAAW,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,EAC/B,IAAI,EAAE,IAAI,CACR,SAAS,EACT,SAAS,GAAG,WAAW,GAAG,eAAe,GAAG,cAAc,CAC3D;IAWI,KAAK,CACV,WAAW,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,EAC/B,IAAI,EAAE,IAAI,CACR,SAAS,EACT,SAAS,GAAG,WAAW,GAAG,eAAe,GAAG,cAAc,CAC3D;IAUI,iBAAiB,CACtB,IAAI,EAAE,IAAI,CACR,SAAS,EACT,SAAS,GAAG,WAAW,GAAG,eAAe,GAAG,cAAc,CAC3D;IAkBI,WAAW,CAChB,IAAI,EAAE,IAAI,CACR,SAAS,EACT,SAAS,GAAG,WAAW,GAAG,eAAe,GAAG,cAAc,CAC3D;YAiBW,WAAW;IAkCZ,KAAK;IAIL,QAAQ;CAGtB"}

package/dist/score/index.js

@@ -0,0 +1,125 @@
+import { getEnv, generateUUID, getGlobalLogger, safeSetTimeout, } from "@langfuse/core";
+import { trace } from "@opentelemetry/api";
+const MAX_QUEUE_SIZE = 100000; // prevent memory leaks
+const MAX_BATCH_SIZE = 100;
+export class ScoreManager {
+    constructor(params) {
+        this.eventQueue = [];
+        this.flushPromise = null;
+        this.flushTimer = null;
+        this.apiClient = params.apiClient;
+        const envFlushAtCount = getEnv("LANGFUSE_FLUSH_AT");
+        const envFlushIntervalSeconds = getEnv("LANGFUSE_FLUSH_INTERVAL");
+        this.flushAtCount = envFlushAtCount ? Number(envFlushAtCount) : 10;
+        this.flushIntervalSeconds = envFlushIntervalSeconds
+            ? Number(envFlushIntervalSeconds)
+            : 1;
+    }
+    get logger() {
+        return getGlobalLogger();
+    }
+    create(data) {
+        var _a, _b;
+        const scoreData = {
+            ...data,
+            id: (_a = data.id) !== null && _a !== void 0 ? _a : generateUUID(),
+            environment: (_b = data.environment) !== null && _b !== void 0 ? _b : getEnv("LANGFUSE_TRACING_ENVIRONMENT"),
+        };
+        const scoreIngestionEvent = {
+            id: generateUUID(),
+            type: "score-create",
+            timestamp: 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 = safeSetTimeout(() => {
+                this.flushPromise = this.flush();
+            }, this.flushIntervalSeconds * 1000);
+        }
+    }
+    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 = 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 = 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 || _a === void 0 ? 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 !== void 0 ? _a : this.handleFlush();
+    }
+    async shutdown() {
+        await this.flush();
+    }
+}