@mate-academy/prompt-client 1.0.0

package/dist/providers/InMemory/InMemoryTracer.client.d.ts

@@ -0,0 +1,15 @@
+import { type LLMGeneration, type LLMGenerationOptions, type LLMTrace, type LLMTraceOptions, type LLMTracer } from '../../LLMTracer.typedefs';
+import { type InMemoryRecordedGeneration, type InMemoryRecordedTrace } from '../../providers/InMemory/InMemory.typedefs';
+export declare class InMemoryTracer implements LLMTracer {
+    readonly traces: InMemoryRecordedTrace[];
+    readonly generations: InMemoryRecordedGeneration[];
+    flushCallCount: number;
+    shutdownCallCount: number;
+    private nextEntityNumber;
+    createTrace(options: LLMTraceOptions): LLMTrace;
+    createGeneration(trace: LLMTrace, options: LLMGenerationOptions): LLMGeneration;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    reset(): void;
+    private takeEntityNumber;
+}

package/dist/providers/InMemory/InMemoryTracer.client.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryTracer = void 0;
+class InMemoryTracer {
+    constructor() {
+        this.traces = [];
+        this.generations = [];
+        this.flushCallCount = 0;
+        this.shutdownCallCount = 0;
+        this.nextEntityNumber = 1;
+    }
+    createTrace(options) {
+        const recordedTrace = {
+            id: `trace-${this.takeEntityNumber()}`,
+            options,
+            updates: [],
+        };
+        this.traces.push(recordedTrace);
+        return {
+            id: recordedTrace.id,
+            getTraceUrl: () => `in-memory://traces/${recordedTrace.id}`,
+            update: (updateOptions) => {
+                recordedTrace.updates.push(updateOptions);
+            },
+        };
+    }
+    createGeneration(trace, options) {
+        const recordedGeneration = {
+            id: `generation-${this.takeEntityNumber()}`,
+            traceId: trace.id,
+            options,
+            endOptions: null,
+            isEnded: false,
+        };
+        this.generations.push(recordedGeneration);
+        return {
+            id: recordedGeneration.id,
+            end: (endOptions) => {
+                recordedGeneration.endOptions = endOptions ?? null;
+                recordedGeneration.isEnded = true;
+            },
+        };
+    }
+    async flush() {
+        this.flushCallCount += 1;
+    }
+    async shutdown() {
+        this.shutdownCallCount += 1;
+    }
+    reset() {
+        this.traces.splice(0);
+        this.generations.splice(0);
+        this.flushCallCount = 0;
+        this.shutdownCallCount = 0;
+        this.nextEntityNumber = 1;
+    }
+    takeEntityNumber() {
+        const entityNumber = this.nextEntityNumber;
+        this.nextEntityNumber += 1;
+        return entityNumber;
+    }
+}
+exports.InMemoryTracer = InMemoryTracer;

package/dist/providers/Langfuse/Langfuse.factory.d.ts

@@ -0,0 +1,4 @@
+import { type PromptManagementBundle } from '../../PromptManagement.typedefs';
+import { type LangfuseProviderOptions } from '../../providers/Langfuse/Langfuse.typedefs';
+import { type PromptManagementLogger } from '../../utilities/logger';
+export declare const createLangfusePromptManagement: (options: LangfuseProviderOptions, logger: PromptManagementLogger) => PromptManagementBundle;

package/dist/providers/Langfuse/Langfuse.factory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLangfusePromptManagement = void 0;
+const langfuse_1 = require("langfuse");
+const LangfusePrompt_client_1 = require("../../providers/Langfuse/LangfusePrompt.client");
+const LangfuseTracer_client_1 = require("../../providers/Langfuse/LangfuseTracer.client");
+const createLangfusePromptManagement = (options, logger) => {
+    const client = new langfuse_1.Langfuse({
+        publicKey: options.credentials.publicKey,
+        secretKey: options.credentials.secretKey,
+        baseUrl: options.credentials.baseUrl,
+        requestTimeout: options.fetchTimeoutMs,
+        flushAt: options.flushAt,
+        flushInterval: options.flushIntervalMs,
+    });
+    return {
+        promptClient: new LangfusePrompt_client_1.LangfusePromptClient(client, options, logger),
+        tracer: new LangfuseTracer_client_1.LangfuseTracer(client, logger),
+        flush: () => client.flushAsync(),
+        shutdown: () => client.shutdownAsync(),
+    };
+};
+exports.createLangfusePromptManagement = createLangfusePromptManagement;

package/dist/providers/Langfuse/Langfuse.helpers.d.ts

@@ -0,0 +1 @@
+export declare const isLangfuseInfraError: (error: unknown) => boolean;

package/dist/providers/Langfuse/Langfuse.helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLangfuseInfraError = void 0;
+const LANGFUSE_INFRA_ERROR_NAMES = [
+    'LangfuseFetchHttpError',
+    'LangfuseFetchNetworkError',
+];
+const isLangfuseInfraError = (error) => {
+    if (typeof error !== 'object' || error === null || !('name' in error)) {
+        return false;
+    }
+    const errorName = error.name;
+    return typeof errorName === 'string'
+        && LANGFUSE_INFRA_ERROR_NAMES.includes(errorName);
+};
+exports.isLangfuseInfraError = isLangfuseInfraError;

package/dist/providers/Langfuse/Langfuse.typedefs.d.ts

@@ -0,0 +1,14 @@
+export interface LangfuseCredentials {
+    publicKey: string;
+    secretKey: string;
+    baseUrl: string;
+}
+export interface LangfuseProviderOptions {
+    credentials: LangfuseCredentials;
+    defaultPromptLabel?: string;
+    defaultCacheTtlSeconds?: number;
+    fetchTimeoutMs?: number;
+    maxRetries?: number;
+    flushAt?: number;
+    flushIntervalMs?: number;
+}

package/dist/providers/Langfuse/Langfuse.typedefs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/providers/Langfuse/LangfusePrompt.client.d.ts

@@ -0,0 +1,16 @@
+import { type Langfuse } from 'langfuse';
+import { type GetPromptOptions, type LLMPrompt, type LLMPromptClient } from '../../LLMPromptClient.typedefs';
+import { type LangfuseProviderOptions } from '../../providers/Langfuse/Langfuse.typedefs';
+import { type PromptManagementLogger } from '../../utilities/logger';
+export declare class LangfusePromptClient implements LLMPromptClient {
+    private readonly client;
+    private readonly providerOptions;
+    private readonly logger;
+    constructor(client: Langfuse, providerOptions: LangfuseProviderOptions, logger: PromptManagementLogger);
+    getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    shutdown(): Promise<void>;
+    private fetchPrompt;
+    private resolveLabelOption;
+    private ensureTextPrompt;
+    private reportPromptResolution;
+}

package/dist/providers/Langfuse/LangfusePrompt.client.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangfusePromptClient = void 0;
+const LLMPromptClient_constants_1 = require("../../LLMPromptClient.constants");
+const LLMPromptClient_errors_1 = require("../../LLMPromptClient.errors");
+const Langfuse_helpers_1 = require("../../providers/Langfuse/Langfuse.helpers");
+const LangfusePrompt_1 = require("../../providers/Langfuse/LangfusePrompt");
+const LANGFUSE_TEXT_PROMPT_TYPE = 'text';
+class LangfusePromptClient {
+    constructor(client, providerOptions, logger) {
+        this.client = client;
+        this.providerOptions = providerOptions;
+        this.logger = logger;
+    }
+    async getPrompt(name, options) {
+        const nativePrompt = await this.fetchPrompt(name, options);
+        this.ensureTextPrompt(name, nativePrompt);
+        this.reportPromptResolution(name, nativePrompt);
+        return new LangfusePrompt_1.LangfusePrompt(nativePrompt);
+    }
+    shutdown() {
+        return this.client.shutdownAsync();
+    }
+    async fetchPrompt(name, options) {
+        try {
+            const nativePrompt = await this.client.getPrompt(name, options?.version, {
+                ...this.resolveLabelOption(options),
+                cacheTtlSeconds: options?.cacheTtlSeconds
+                    ?? this.providerOptions.defaultCacheTtlSeconds
+                    ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_CACHE_TTL_SECONDS,
+                fallback: options?.fallback,
+                maxRetries: this.providerOptions.maxRetries,
+                fetchTimeoutMs: this.providerOptions.fetchTimeoutMs,
+                type: LANGFUSE_TEXT_PROMPT_TYPE,
+            });
+            return nativePrompt;
+        }
+        catch (error) {
+            if ((0, Langfuse_helpers_1.isLangfuseInfraError)(error)) {
+                this.logger.error('Failed to fetch Langfuse prompt', {
+                    error,
+                    promptName: name,
+                });
+                throw new LLMPromptClient_errors_1.LLMPromptFetchError(name, error);
+            }
+            throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name, error);
+        }
+    }
+    resolveLabelOption(options) {
+        if (options?.version !== undefined) {
+            return {};
+        }
+        return {
+            label: options?.label
+                ?? this.providerOptions.defaultPromptLabel
+                ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LABEL,
+        };
+    }
+    ensureTextPrompt(name, nativePrompt) {
+        if (nativePrompt.type !== LANGFUSE_TEXT_PROMPT_TYPE) {
+            this.logger.error('Langfuse prompt is not a text prompt', {
+                promptName: name,
+                promptType: nativePrompt.type,
+            });
+            throw new LLMPromptClient_errors_1.LLMPromptFetchError(name);
+        }
+    }
+    reportPromptResolution(name, nativePrompt) {
+        if (nativePrompt.isFallback) {
+            this.logger.warn('Langfuse prompt resolved to the provided fallback', {
+                promptName: name,
+            });
+            return;
+        }
+        this.logger.debug?.('Langfuse prompt resolved', {
+            promptName: name,
+            promptVersion: nativePrompt.version,
+        });
+    }
+}
+exports.LangfusePromptClient = LangfusePromptClient;

package/dist/providers/Langfuse/LangfusePrompt.d.ts

@@ -0,0 +1,13 @@
+import { type TextPromptClient } from 'langfuse';
+import { LLMPromptTypes, type LLMPrompt } from '../../LLMPromptClient.typedefs';
+export declare class LangfusePrompt implements LLMPrompt {
+    readonly nativePrompt: TextPromptClient;
+    readonly type = LLMPromptTypes.Text;
+    constructor(nativePrompt: TextPromptClient);
+    get name(): string;
+    get version(): number;
+    get prompt(): string;
+    get config(): unknown;
+    get isFallback(): boolean;
+    compile(variables?: Record<string, string>): string;
+}

package/dist/providers/Langfuse/LangfusePrompt.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangfusePrompt = void 0;
+const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
+class LangfusePrompt {
+    constructor(nativePrompt) {
+        this.nativePrompt = nativePrompt;
+        this.type = LLMPromptClient_typedefs_1.LLMPromptTypes.Text;
+    }
+    get name() {
+        return this.nativePrompt.name;
+    }
+    get version() {
+        return this.nativePrompt.version;
+    }
+    get prompt() {
+        return this.nativePrompt.prompt;
+    }
+    get config() {
+        return this.nativePrompt.config;
+    }
+    get isFallback() {
+        return this.nativePrompt.isFallback;
+    }
+    compile(variables) {
+        return this.nativePrompt.compile(variables);
+    }
+}
+exports.LangfusePrompt = LangfusePrompt;

package/dist/providers/Langfuse/LangfuseTracer.client.d.ts

@@ -0,0 +1,13 @@
+import { type Langfuse } from 'langfuse';
+import { type LLMGeneration, type LLMGenerationOptions, type LLMTrace, type LLMTraceOptions, type LLMTracer } from '../../LLMTracer.typedefs';
+import { type PromptManagementLogger } from '../../utilities/logger';
+export declare class LangfuseTracer implements LLMTracer {
+    private readonly client;
+    private readonly logger;
+    constructor(client: Langfuse, logger: PromptManagementLogger);
+    createTrace(options: LLMTraceOptions): LLMTrace;
+    createGeneration(trace: LLMTrace, options: LLMGenerationOptions): LLMGeneration;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private wrapError;
+}

package/dist/providers/Langfuse/LangfuseTracer.client.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangfuseTracer = void 0;
+const LLMTracer_errors_1 = require("../../LLMTracer.errors");
+const LangfusePrompt_1 = require("../../providers/Langfuse/LangfusePrompt");
+class LangfuseTracer {
+    constructor(client, logger) {
+        this.client = client;
+        this.logger = logger;
+    }
+    createTrace(options) {
+        try {
+            return this.client.trace(options);
+        }
+        catch (error) {
+            throw this.wrapError('Failed to create Langfuse trace', error, {
+                traceName: options.name,
+            });
+        }
+    }
+    createGeneration(trace, options) {
+        const { prompt, ...generationOptions } = options;
+        try {
+            return this.client.generation({
+                ...generationOptions,
+                traceId: trace.id,
+                ...(prompt instanceof LangfusePrompt_1.LangfusePrompt
+                    ? { prompt: prompt.nativePrompt }
+                    : {}),
+            });
+        }
+        catch (error) {
+            throw this.wrapError('Failed to create Langfuse generation', error, {
+                generationName: options.name,
+            });
+        }
+    }
+    flush() {
+        return this.client.flushAsync();
+    }
+    shutdown() {
+        return this.client.shutdownAsync();
+    }
+    wrapError(message, error, fields) {
+        this.logger.error(message, { error, ...fields });
+        return new LLMTracer_errors_1.LLMTracerError(message, error);
+    }
+}
+exports.LangfuseTracer = LangfuseTracer;

package/dist/utilities/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../utilities/logger';
+export * from '../utilities/template';
+export * from '../utilities/usageDetails';

package/dist/utilities/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../utilities/logger"), exports);
+__exportStar(require("../utilities/template"), exports);
+__exportStar(require("../utilities/usageDetails"), exports);

package/dist/utilities/logger/PromptManagementLogger.d.ts

@@ -0,0 +1,7 @@
+export interface PromptManagementLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    debug?(message: string, meta?: Record<string, unknown>): void;
+}
+export declare const NOOP_PROMPT_MANAGEMENT_LOGGER: PromptManagementLogger;

package/dist/utilities/logger/PromptManagementLogger.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP_PROMPT_MANAGEMENT_LOGGER = void 0;
+exports.NOOP_PROMPT_MANAGEMENT_LOGGER = {
+    info: () => undefined,
+    warn: () => undefined,
+    error: () => undefined,
+};

package/dist/utilities/logger/index.d.ts

@@ -0,0 +1 @@
+export * from '../../utilities/logger/PromptManagementLogger';

package/dist/utilities/logger/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../utilities/logger/PromptManagementLogger"), exports);

package/dist/utilities/template/compileTemplateVariables.d.ts

@@ -0,0 +1 @@
+export declare const compileTemplateVariables: (template: string, variables?: Record<string, string>) => string;

package/dist/utilities/template/compileTemplateVariables.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplateVariables = void 0;
+const compileTemplateVariables = (template, variables) => Object.entries(variables ?? {}).reduce((compiled, [variableName, variableValue]) => compiled
+    .split(`{{${variableName}}}`)
+    .join(variableValue), template);
+exports.compileTemplateVariables = compileTemplateVariables;

package/dist/utilities/template/index.d.ts

@@ -0,0 +1 @@
+export * from '../../utilities/template/compileTemplateVariables';

package/dist/utilities/template/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../utilities/template/compileTemplateVariables"), exports);

package/dist/utilities/usageDetails/index.d.ts

@@ -0,0 +1 @@
+export * from '../../utilities/usageDetails/usageDetails.helpers';

package/dist/utilities/usageDetails/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../utilities/usageDetails/usageDetails.helpers"), exports);

package/dist/utilities/usageDetails/usageDetails.helpers.d.ts

@@ -0,0 +1,17 @@
+export interface LLMUsageInput {
+    inputTextTokens?: number;
+    outputTextTokens?: number;
+    inputAudioTokens?: number;
+    outputAudioTokens?: number;
+    inputCachedTextTokens?: number;
+    inputCachedAudioTokens?: number;
+    outputReasoningTokens?: number;
+}
+export interface LLMCostInput {
+    input: number;
+    output: number;
+    total: number;
+    currency: string;
+}
+export declare const usageToUsageDetails: (usage?: LLMUsageInput) => Record<string, number> | undefined;
+export declare const costToCostDetails: (cost?: LLMCostInput) => Record<string, number> | undefined;

package/dist/utilities/usageDetails/usageDetails.helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.costToCostDetails = exports.usageToUsageDetails = void 0;
+const toPositiveDetails = (keyedAmounts) => {
+    const populated = keyedAmounts.filter(([, amount]) => amount > 0);
+    if (populated.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(populated);
+};
+const usageToUsageDetails = (usage) => {
+    if (!usage) {
+        return undefined;
+    }
+    return toPositiveDetails([
+        ['input', usage.inputTextTokens ?? 0],
+        ['input_cached', usage.inputCachedTextTokens ?? 0],
+        ['output', (usage.outputTextTokens ?? 0) + (usage.outputReasoningTokens ?? 0)],
+        ['input_audio', usage.inputAudioTokens ?? 0],
+        ['output_audio', usage.outputAudioTokens ?? 0],
+    ]);
+};
+exports.usageToUsageDetails = usageToUsageDetails;
+const costToCostDetails = (cost) => {
+    if (!cost) {
+        return undefined;
+    }
+    return toPositiveDetails([
+        ['input', cost.input],
+        ['output', cost.output],
+    ]);
+};
+exports.costToCostDetails = costToCostDetails;

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@mate-academy/prompt-client",
+  "version": "1.0.0",
+  "description": "Provider-agnostic LLM prompt management and tracing client (Langfuse, InMemory)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && tsc-alias",
+    "build:minify": "npm run build && npm run minify",
+    "minify": "find dist -type f -name \"*.js\" -exec terser {} -c -m -o {} \\;",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "type-check": "tsc --noEmit",
+    "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest src/tests/unit",
+    "test:integration": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest src/tests/integration --verbose",
+    "prepublishOnly": "npm run clean && npm run lint:fix && npm run type-check && npm run test && npm run build",
+    "postpublish": "npm run clean",
+    "clean": "rm -rf ./dist",
+    "patch": "npm version patch && npm publish",
+    "minor": "npm version minor && npm publish",
+    "major": "npm version major && npm publish",
+    "canary": "npm version prerelease --preid=canary && npm publish --tag=canary"
+  },
+  "keywords": [
+    "llm",
+    "prompt",
+    "langfuse",
+    "tracing",
+    "mate-academy"
+  ],
+  "author": "Mate academy developers",
+  "license": "MIT",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "langfuse": "^3.38.20"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.36.0",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "dotenv": "^17.2.3",
+    "eslint": "^9.36.0",
+    "eslint-plugin-no-only-tests": "^3.3.0",
+    "globals": "^16.4.0",
+    "jest": "^30.2.0",
+    "terser": "^5.44.0",
+    "ts-jest": "^29.4.5",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.44.1"
+  }
+}