@core-ai/langfuse 0.10.0

package/README.md

@@ -0,0 +1,47 @@
+# @core-ai/langfuse
+
+[![npm](https://img.shields.io/npm/v/@core-ai/langfuse.svg)](https://www.npmjs.com/package/@core-ai/langfuse)
+
+Langfuse middleware for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/langfuse @langfuse/tracing @langfuse/otel @opentelemetry/sdk-node
+```
+
+`@langfuse/tracing` and `@langfuse/otel` are peer dependencies. `@opentelemetry/sdk-node`
+is required to register the `LangfuseSpanProcessor`.
+
+## Setup
+
+Create an instrumentation file and import it at your application's entry point:
+
+```ts
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { LangfuseSpanProcessor } from '@langfuse/otel';
+
+export const sdk = new NodeSDK({
+    spanProcessors: [new LangfuseSpanProcessor()],
+});
+
+sdk.start();
+```
+
+## Usage
+
+```ts
+import { wrapChatModel } from '@core-ai/core-ai';
+import { createOpenAI } from '@core-ai/openai';
+import { createLangfuseMiddleware } from '@core-ai/langfuse';
+
+const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const model = wrapChatModel({
+    model: openai.chatModel('gpt-5-mini'),
+    middleware: createLangfuseMiddleware({ recordContent: true }),
+});
+```
+
+`recordContent` is disabled by default. Enable it only when you want prompts and outputs
+attached to Langfuse observations.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { EmbeddingModelMiddleware, ImageModelMiddleware, ChatModelMiddleware } from '@core-ai/core-ai';
+
+type LangfuseMiddlewareOptions = {
+    recordContent?: boolean;
+};
+declare function createLangfuseMiddleware(options?: LangfuseMiddlewareOptions): ChatModelMiddleware;
+declare function createLangfuseEmbeddingMiddleware(options?: LangfuseMiddlewareOptions): EmbeddingModelMiddleware;
+declare function createLangfuseImageMiddleware(options?: LangfuseMiddlewareOptions): ImageModelMiddleware;
+
+export { type LangfuseMiddlewareOptions, createLangfuseEmbeddingMiddleware, createLangfuseImageMiddleware, createLangfuseMiddleware };

package/dist/index.js

@@ -0,0 +1,308 @@
+// src/index.ts
+import { startActiveObservation } from "@langfuse/tracing";
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function compactRecord(record) {
+  const entries = Object.entries(record).filter(
+    ([, value]) => value !== void 0 && value !== null
+  );
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(entries);
+}
+function createChatObservationName(model) {
+  return `chat ${model.modelId}`;
+}
+function createEmbeddingObservationName(model) {
+  return `embeddings ${model.modelId}`;
+}
+function createImageObservationName(model) {
+  return `image_generation ${model.modelId}`;
+}
+function createObservationAttributes(config) {
+  return {
+    model: config.modelId,
+    ...config.modelParameters ? { modelParameters: config.modelParameters } : {},
+    ...config.metadata ? { metadata: config.metadata } : {},
+    ...config.recordContent && config.input !== void 0 ? {
+      input: config.input
+    } : {}
+  };
+}
+function createModelParameters(options) {
+  return compactRecord({
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP
+  });
+}
+function createEmbeddingModelParameters(options) {
+  return compactRecord({
+    dimensions: options.dimensions
+  });
+}
+function createImageModelParameters(options) {
+  return compactRecord({
+    n: options.n,
+    size: options.size
+  });
+}
+function createChatUsageDetails(usage) {
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    totalTokens: usage.inputTokens + usage.outputTokens,
+    promptTokens: usage.inputTokens,
+    completionTokens: usage.outputTokens,
+    cacheReadInputTokens: usage.inputTokenDetails.cacheReadTokens,
+    cacheWriteInputTokens: usage.inputTokenDetails.cacheWriteTokens,
+    ...usage.outputTokenDetails.reasoningTokens !== void 0 ? {
+      reasoningOutputTokens: usage.outputTokenDetails.reasoningTokens
+    } : {}
+  };
+}
+function createEmbeddingUsageDetails(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return {
+    inputTokens: usage.inputTokens,
+    totalTokens: usage.inputTokens,
+    promptTokens: usage.inputTokens
+  };
+}
+function createChatOutput(result) {
+  return {
+    parts: result.parts,
+    toolCalls: result.toolCalls,
+    finishReason: result.finishReason,
+    ...result.content !== null ? { content: result.content } : {},
+    ...result.reasoning !== null ? { reasoning: result.reasoning } : {}
+  };
+}
+function createImageOutput(result) {
+  return result.images.map((image) => ({
+    hasBase64: image.base64 !== void 0,
+    ...image.url ? { url: image.url } : {},
+    ...image.revisedPrompt ? { revisedPrompt: image.revisedPrompt } : {}
+  }));
+}
+function createErrorAttributes(error, recordContent) {
+  const message = getErrorMessage(error);
+  return {
+    level: "ERROR",
+    statusMessage: message,
+    ...recordContent ? {
+      output: { error: message }
+    } : {}
+  };
+}
+function updateObservation(observation, attributes) {
+  if (!attributes) {
+    return;
+  }
+  observation.update(attributes);
+}
+function runGeneration(config) {
+  const { name, initialAttributes, createSuccessAttributes, recordContent, execute } = config;
+  return startActiveObservation(
+    name,
+    async (observation) => {
+      updateObservation(observation, initialAttributes);
+      try {
+        const result = await execute();
+        updateObservation(observation, createSuccessAttributes(result));
+        return result;
+      } catch (error) {
+        updateObservation(observation, createErrorAttributes(error, recordContent));
+        throw error;
+      }
+    },
+    { asType: "generation" }
+  );
+}
+function runEmbedding(config) {
+  const { name, initialAttributes, createSuccessAttributes, recordContent, execute } = config;
+  return startActiveObservation(
+    name,
+    async (observation) => {
+      updateObservation(observation, initialAttributes);
+      try {
+        const result = await execute();
+        updateObservation(observation, createSuccessAttributes(result));
+        return result;
+      } catch (error) {
+        updateObservation(observation, createErrorAttributes(error, recordContent));
+        throw error;
+      }
+    },
+    { asType: "embedding" }
+  );
+}
+function runGenerationStream(config) {
+  const {
+    name,
+    initialAttributes,
+    createSuccessAttributes,
+    recordContent,
+    execute,
+    getResult
+  } = config;
+  return startActiveObservation(
+    name,
+    async (observation) => {
+      updateObservation(observation, initialAttributes);
+      try {
+        const stream = await execute();
+        void getResult(stream).then((result) => {
+          updateObservation(observation, createSuccessAttributes(result));
+        }).catch((error) => {
+          updateObservation(observation, createErrorAttributes(error, recordContent));
+        }).finally(() => {
+          observation.end();
+        });
+        return stream;
+      } catch (error) {
+        updateObservation(observation, createErrorAttributes(error, recordContent));
+        observation.end();
+        throw error;
+      }
+    },
+    { asType: "generation", endOnExit: false }
+  );
+}
+function createLangfuseMiddleware(options = {}) {
+  const { recordContent = false } = options;
+  return {
+    generate: ({ execute, options: generateOptions, model }) => runGeneration({
+      name: createChatObservationName(model),
+      initialAttributes: createObservationAttributes({
+        modelId: model.modelId,
+        modelParameters: createModelParameters(generateOptions),
+        metadata: generateOptions.metadata,
+        input: generateOptions.messages,
+        recordContent
+      }),
+      createSuccessAttributes: (result) => ({
+        usageDetails: createChatUsageDetails(result.usage),
+        ...recordContent ? {
+          output: createChatOutput(result)
+        } : {}
+      }),
+      recordContent,
+      execute
+    }),
+    stream: ({ execute, options: generateOptions, model }) => runGenerationStream({
+      name: createChatObservationName(model),
+      initialAttributes: createObservationAttributes({
+        modelId: model.modelId,
+        modelParameters: createModelParameters(generateOptions),
+        metadata: generateOptions.metadata,
+        input: generateOptions.messages,
+        recordContent
+      }),
+      createSuccessAttributes: (result) => ({
+        usageDetails: createChatUsageDetails(result.usage),
+        ...recordContent ? {
+          output: createChatOutput(result)
+        } : {}
+      }),
+      recordContent,
+      execute,
+      getResult: (chatStream) => chatStream.result
+    }),
+    generateObject: (args) => {
+      const { execute, options: generateOptions, model } = args;
+      return runGeneration({
+        name: createChatObservationName(model),
+        initialAttributes: createObservationAttributes({
+          modelId: model.modelId,
+          modelParameters: createModelParameters(generateOptions),
+          metadata: generateOptions.metadata,
+          input: generateOptions.messages,
+          recordContent
+        }),
+        createSuccessAttributes: (result) => ({
+          usageDetails: createChatUsageDetails(result.usage),
+          ...recordContent ? {
+            output: result.object
+          } : {}
+        }),
+        recordContent,
+        execute
+      });
+    },
+    streamObject: (args) => {
+      const { execute, options: generateOptions, model } = args;
+      return runGenerationStream({
+        name: createChatObservationName(model),
+        initialAttributes: createObservationAttributes({
+          modelId: model.modelId,
+          modelParameters: createModelParameters(generateOptions),
+          metadata: generateOptions.metadata,
+          input: generateOptions.messages,
+          recordContent
+        }),
+        createSuccessAttributes: (result) => ({
+          usageDetails: createChatUsageDetails(result.usage),
+          ...recordContent ? {
+            output: result.object
+          } : {}
+        }),
+        recordContent,
+        execute,
+        getResult: (objectStream) => objectStream.result
+      });
+    }
+  };
+}
+function createLangfuseEmbeddingMiddleware(options = {}) {
+  const { recordContent = false } = options;
+  return {
+    embed: ({ execute, options: embedOptions, model }) => runEmbedding({
+      name: createEmbeddingObservationName(model),
+      initialAttributes: createObservationAttributes({
+        modelId: model.modelId,
+        modelParameters: createEmbeddingModelParameters(embedOptions),
+        metadata: embedOptions.metadata,
+        input: embedOptions.input,
+        recordContent
+      }),
+      createSuccessAttributes: (result) => compactRecord({
+        usageDetails: createEmbeddingUsageDetails(result.usage)
+      }),
+      recordContent,
+      execute
+    })
+  };
+}
+function createLangfuseImageMiddleware(options = {}) {
+  const { recordContent = false } = options;
+  return {
+    generate: ({ execute, options: imageOptions, model }) => runGeneration({
+      name: createImageObservationName(model),
+      initialAttributes: createObservationAttributes({
+        modelId: model.modelId,
+        modelParameters: createImageModelParameters(imageOptions),
+        metadata: imageOptions.metadata,
+        input: imageOptions.prompt,
+        recordContent
+      }),
+      createSuccessAttributes: (result) => recordContent ? {
+        output: createImageOutput(result)
+      } : void 0,
+      recordContent,
+      execute
+    })
+  };
+}
+export {
+  createLangfuseEmbeddingMiddleware,
+  createLangfuseImageMiddleware,
+  createLangfuseMiddleware
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@core-ai/langfuse",
+    "version": "0.10.0",
+    "description": "Langfuse middleware for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/core-ai.git",
+        "directory": "packages/langfuse"
+    },
+    "keywords": [
+        "llm",
+        "ai",
+        "langfuse",
+        "observability"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "tsup",
+        "lint": "eslint src/ --max-warnings 0",
+        "check-types": "tsc --noEmit",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@core-ai/core-ai": "^0.10.0"
+    },
+    "peerDependencies": {
+        "@langfuse/otel": "^5.1.0",
+        "@langfuse/tracing": "^5.1.0"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "*",
+        "@core-ai/typescript-config": "*",
+        "@langfuse/otel": "^5.1.0",
+        "@langfuse/tracing": "^5.1.0",
+        "@opentelemetry/sdk-node": "^0.214.0",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4",
+        "zod": "^4.3.6"
+    }
+}