@langfuse/openai 4.0.0-alpha.0

package/dist/parseOpenAI.js

@@ -0,0 +1,217 @@
+export const parseInputArgs = (args) => {
+    let params = {};
+    params = {
+        frequency_penalty: args.frequency_penalty,
+        logit_bias: args.logit_bias,
+        logprobs: args.logprobs,
+        max_tokens: args.max_tokens,
+        n: args.n,
+        presence_penalty: args.presence_penalty,
+        seed: args.seed,
+        stop: args.stop,
+        stream: args.stream,
+        temperature: args.temperature,
+        top_p: args.top_p,
+        user: args.user,
+        response_format: args.response_format,
+        top_logprobs: args.top_logprobs,
+    };
+    let input = args.input;
+    if (args &&
+        typeof args === "object" &&
+        !Array.isArray(args) &&
+        "messages" in args) {
+        input = {};
+        input.messages = args.messages;
+        if ("function_call" in args) {
+            input.function_call = args.function_call;
+        }
+        if ("functions" in args) {
+            input.functions = args.functions;
+        }
+        if ("tools" in args) {
+            input.tools = args.tools;
+        }
+        if ("tool_choice" in args) {
+            input.tool_choice = args.tool_choice;
+        }
+    }
+    else if (!input) {
+        input = args.prompt;
+    }
+    return {
+        model: args.model,
+        input: input,
+        modelParameters: params,
+    };
+};
+export const parseCompletionOutput = (res) => {
+    var _a;
+    if (res instanceof Object &&
+        "output_text" in res &&
+        res["output_text"] !== "") {
+        return res["output_text"];
+    }
+    if (typeof res === "object" &&
+        res &&
+        "output" in res &&
+        Array.isArray(res["output"])) {
+        const output = res["output"];
+        if (output.length > 1) {
+            return output;
+        }
+        if (output.length === 1) {
+            return output[0];
+        }
+        return null;
+    }
+    if (!(res instanceof Object && "choices" in res && Array.isArray(res.choices))) {
+        return "";
+    }
+    return "message" in res.choices[0]
+        ? res.choices[0].message
+        : ((_a = res.choices[0].text) !== null && _a !== void 0 ? _a : "");
+};
+export const parseUsageDetails = (completionUsage) => {
+    if ("prompt_tokens" in completionUsage) {
+        const { prompt_tokens, completion_tokens, total_tokens, completion_tokens_details, prompt_tokens_details, } = completionUsage;
+        return {
+            input: prompt_tokens,
+            output: completion_tokens,
+            total: total_tokens,
+            ...Object.fromEntries(Object.entries(prompt_tokens_details !== null && prompt_tokens_details !== void 0 ? prompt_tokens_details : {}).map(([key, value]) => [
+                `input_${key}`,
+                value,
+            ])),
+            ...Object.fromEntries(Object.entries(completion_tokens_details !== null && completion_tokens_details !== void 0 ? completion_tokens_details : {}).map(([key, value]) => [
+                `output_${key}`,
+                value,
+            ])),
+        };
+    }
+    else if ("input_tokens" in completionUsage) {
+        const { input_tokens, output_tokens, total_tokens, input_tokens_details, output_tokens_details, } = completionUsage;
+        return {
+            input: input_tokens,
+            output: output_tokens,
+            total: total_tokens,
+            ...Object.fromEntries(Object.entries(input_tokens_details !== null && input_tokens_details !== void 0 ? input_tokens_details : {}).map(([key, value]) => [
+                `input_${key}`,
+                value,
+            ])),
+            ...Object.fromEntries(Object.entries(output_tokens_details !== null && output_tokens_details !== void 0 ? output_tokens_details : {}).map(([key, value]) => [
+                `output_${key}`,
+                value,
+            ])),
+        };
+    }
+};
+export const parseUsageDetailsFromResponse = (res) => {
+    if (hasCompletionUsage(res)) {
+        return parseUsageDetails(res.usage);
+    }
+};
+export const parseChunk = (rawChunk) => {
+    var _a, _b;
+    let isToolCall = false;
+    const _chunk = rawChunk;
+    const chunkData = (_a = _chunk === null || _chunk === void 0 ? void 0 : _chunk.choices) === null || _a === void 0 ? void 0 : _a[0];
+    try {
+        if ("delta" in chunkData &&
+            "tool_calls" in chunkData.delta &&
+            Array.isArray(chunkData.delta.tool_calls)) {
+            isToolCall = true;
+            return { isToolCall, data: chunkData.delta.tool_calls[0] };
+        }
+        if ("delta" in chunkData) {
+            return { isToolCall, data: ((_b = chunkData.delta) === null || _b === void 0 ? void 0 : _b.content) || "" };
+        }
+        if ("text" in chunkData) {
+            return { isToolCall, data: chunkData.text || "" };
+        }
+    }
+    catch { }
+    return { isToolCall: false, data: "" };
+};
+// Type guard to check if an unknown object is a UsageResponse
+function hasCompletionUsage(obj) {
+    return (obj instanceof Object &&
+        "usage" in obj &&
+        obj.usage instanceof Object &&
+        // Completion API Usage format
+        ((typeof obj.usage.prompt_tokens === "number" &&
+            typeof obj.usage.completion_tokens === "number" &&
+            typeof obj.usage.total_tokens === "number") ||
+            // Response API Usage format
+            (typeof obj.usage.input_tokens === "number" &&
+                typeof obj.usage.output_tokens === "number" &&
+                typeof obj.usage.total_tokens === "number")));
+}
+export const getToolCallOutput = (toolCallChunks) => {
+    var _a, _b;
+    let name = "";
+    let toolArguments = "";
+    for (const toolCall of toolCallChunks) {
+        name = ((_a = toolCall.function) === null || _a === void 0 ? void 0 : _a.name) || name;
+        toolArguments += ((_b = toolCall.function) === null || _b === void 0 ? void 0 : _b.arguments) || "";
+    }
+    return {
+        tool_calls: [
+            {
+                function: {
+                    name,
+                    arguments: toolArguments,
+                },
+            },
+        ],
+    };
+};
+export const parseModelDataFromResponse = (res) => {
+    if (typeof res !== "object" || res === null) {
+        return {
+            model: undefined,
+            modelParameters: undefined,
+            metadata: undefined,
+        };
+    }
+    const model = "model" in res ? res["model"] : undefined;
+    const modelParameters = {};
+    const modelParamKeys = [
+        "max_output_tokens",
+        "parallel_tool_calls",
+        "store",
+        "temperature",
+        "tool_choice",
+        "top_p",
+        "truncation",
+        "user",
+    ];
+    const metadata = {};
+    const metadataKeys = [
+        "reasoning",
+        "incomplete_details",
+        "instructions",
+        "previous_response_id",
+        "tools",
+        "metadata",
+        "status",
+        "error",
+    ];
+    for (const key of modelParamKeys) {
+        const val = key in res ? res[key] : null;
+        if (val !== null && val !== undefined) {
+            modelParameters[key] = val;
+        }
+    }
+    for (const key of metadataKeys) {
+        const val = key in res ? res[key] : null;
+        if (val) {
+            metadata[key] = val;
+        }
+    }
+    return {
+        model,
+        modelParameters: Object.keys(modelParameters).length > 0 ? modelParameters : undefined,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    };
+};

package/dist/traceMethod.d.ts

@@ -0,0 +1,7 @@
+import type { LangfuseConfig } from "./types.js";
+type GenericMethod = (...args: unknown[]) => unknown;
+export declare const withTracing: <T extends GenericMethod>(tracedMethod: T, config?: LangfuseConfig & Required<{
+    generationName: string;
+}>) => ((...args: Parameters<T>) => Promise<ReturnType<T>>);
+export {};
+//# sourceMappingURL=traceMethod.d.ts.map

package/dist/traceMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceMethod.d.ts","sourceRoot":"","sources":["../src/traceMethod.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,KAAK,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AAErD,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EACjD,cAAc,CAAC,EACf,SAAS,cAAc,GAAG,QAAQ,CAAC;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC,KAC7D,CAAC,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAErD,CAAC"}

package/dist/traceMethod.js

@@ -0,0 +1,138 @@
+import { startGeneration } from "@langfuse/tracing";
+import { getToolCallOutput, parseChunk, parseCompletionOutput, parseInputArgs, parseUsageDetails, parseModelDataFromResponse, parseUsageDetailsFromResponse, } from "./parseOpenAI.js";
+import { isAsyncIterable } from "./utils.js";
+export const withTracing = (tracedMethod, config) => {
+    return (...args) => wrapMethod(tracedMethod, config, ...args);
+};
+const wrapMethod = (tracedMethod, config, ...args) => {
+    var _a, _b;
+    const { model, input, modelParameters } = parseInputArgs((_a = args[0]) !== null && _a !== void 0 ? _a : {});
+    const finalModelParams = { ...modelParameters, response_format: null };
+    const finalMetadata = {
+        ...config === null || config === void 0 ? void 0 : config.generationMetadata,
+        response_format: "response_format" in modelParameters
+            ? modelParameters.response_format
+            : undefined,
+    };
+    const generation = startGeneration((_b = config === null || config === void 0 ? void 0 : config.generationName) !== null && _b !== void 0 ? _b : "OpenAI-completion", {
+        model,
+        input,
+        modelParameters: finalModelParams,
+        prompt: config === null || config === void 0 ? void 0 : config.langfusePrompt,
+        metadata: finalMetadata,
+    }, { parentSpanContext: config === null || config === void 0 ? void 0 : config.parentSpanContext }).updateTrace({
+        userId: config === null || config === void 0 ? void 0 : config.userId,
+        sessionId: config === null || config === void 0 ? void 0 : config.sessionId,
+        tags: config === null || config === void 0 ? void 0 : config.tags,
+        name: config === null || config === void 0 ? void 0 : config.traceName,
+    });
+    try {
+        const res = tracedMethod(...args);
+        // Handle stream responses
+        if (isAsyncIterable(res)) {
+            return wrapAsyncIterable(res, generation);
+        }
+        if (res instanceof Promise) {
+            const wrappedPromise = res
+                .then((result) => {
+                if (isAsyncIterable(result)) {
+                    return wrapAsyncIterable(result, generation);
+                }
+                const output = parseCompletionOutput(result);
+                const usageDetails = parseUsageDetailsFromResponse(result);
+                const { model: modelFromResponse, modelParameters: modelParametersFromResponse, metadata: metadataFromResponse, } = parseModelDataFromResponse(result);
+                generation
+                    .update({
+                    output,
+                    usageDetails,
+                    model: modelFromResponse,
+                    modelParameters: modelParametersFromResponse,
+                    metadata: metadataFromResponse,
+                })
+                    .end();
+                return result;
+            })
+                .catch((err) => {
+                generation
+                    .update({
+                    statusMessage: String(err),
+                    level: "ERROR",
+                    costDetails: {
+                        input: 0,
+                        output: 0,
+                        total: 0,
+                    },
+                })
+                    .end();
+                throw err;
+            });
+            return wrappedPromise;
+        }
+        return res;
+    }
+    catch (error) {
+        generation
+            .update({
+            statusMessage: String(error),
+            level: "ERROR",
+            costDetails: {
+                input: 0,
+                output: 0,
+                total: 0,
+            },
+        })
+            .end();
+        throw error;
+    }
+};
+function wrapAsyncIterable(iterable, generation) {
+    async function* tracedOutputGenerator() {
+        const response = iterable;
+        const textChunks = [];
+        const toolCallChunks = [];
+        let usage = null;
+        let completionStartTime = undefined;
+        let usageDetails = undefined;
+        let output = null;
+        for await (const rawChunk of response) {
+            completionStartTime = completionStartTime !== null && completionStartTime !== void 0 ? completionStartTime : new Date();
+            // Handle Response API chunks
+            if (typeof rawChunk === "object" && rawChunk && "response" in rawChunk) {
+                const result = rawChunk["response"];
+                output = parseCompletionOutput(result);
+                usageDetails = parseUsageDetailsFromResponse(result);
+                const { model: modelFromResponse, modelParameters: modelParametersFromResponse, metadata: metadataFromResponse, } = parseModelDataFromResponse(result);
+                generation.update({
+                    model: modelFromResponse,
+                    modelParameters: modelParametersFromResponse,
+                    metadata: metadataFromResponse,
+                });
+            }
+            if (typeof rawChunk === "object" &&
+                rawChunk != null &&
+                "usage" in rawChunk) {
+                usage = rawChunk.usage;
+            }
+            const processedChunk = parseChunk(rawChunk);
+            if (!processedChunk.isToolCall) {
+                textChunks.push(processedChunk.data);
+            }
+            else {
+                toolCallChunks.push(processedChunk.data);
+            }
+            yield rawChunk;
+        }
+        output =
+            output !== null && output !== void 0 ? output : (toolCallChunks.length > 0
+                ? getToolCallOutput(toolCallChunks)
+                : textChunks.join(""));
+        generation
+            .update({
+            output,
+            completionStartTime,
+            usageDetails: usageDetails !== null && usageDetails !== void 0 ? usageDetails : (usage ? parseUsageDetails(usage) : undefined),
+        })
+            .end();
+    }
+    return tracedOutputGenerator();
+}

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+import { SpanContext } from "@opentelemetry/api";
+export type LangfuseConfig = {
+    parentSpanContext?: SpanContext;
+    traceName?: string;
+    sessionId?: string;
+    userId?: string;
+    tags?: string[];
+    generationName?: string;
+    generationMetadata?: Record<string, unknown>;
+    langfusePrompt?: {
+        name: string;
+        version: number;
+        isFallback: boolean;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,cAAc,GAAG;IAC3B,iBAAiB,CAAC,EAAE,WAAW,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,cAAc,CAAC,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;CACH,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isAsyncIterable: (x: unknown) => x is AsyncIterable<unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,aAAa,CAAC,OAAO,CAGf,CAAC"}

package/dist/utils.js

@@ -0,0 +1,3 @@
+export const isAsyncIterable = (x) => x != null &&
+    typeof x === "object" &&
+    typeof x[Symbol.asyncIterator] === "function";

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@langfuse/openai",
+  "version": "4.0.0-alpha.0",
+  "description": "Langfuse integration for OpenAI SDK",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "author": "Langfuse",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@langfuse/core": "^4.0.0-alpha.0",
+    "@langfuse/tracing": "^4.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "openai": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "clean": "rm -rf dist"
+  }
+}