@mate-academy/prompt-client 1.0.0 → 2.0.0

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryPromptClient = void 0;
 const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
+const LLMPromptClient_constants_1 = require("../../LLMPromptClient.constants");
 const LLMPromptClient_errors_1 = require("../../LLMPromptClient.errors");
 const InMemory_typedefs_1 = require("../../providers/InMemory/InMemory.typedefs");
 const template_1 = require("../../utilities/template");
@@ -10,6 +11,7 @@ const FALLBACK_PROMPT_VERSION = 0;
 class InMemoryPromptClient {
     constructor(options) {
         this.prompts = new Map(Object.entries(options.prompts ?? {}));
+        this.chatPrompts = new Map(Object.entries(options.chatPrompts ?? {}));
         this.missingPromptBehavior = options.missingPromptBehavior
             ?? InMemory_typedefs_1.InMemoryMissingPromptBehaviors.Throw;
     }
@@ -26,14 +28,58 @@ class InMemoryPromptClient {
         }
         throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name);
     }
+    async getChatPrompt(name, options) {
+        const seedChatPrompt = this.chatPrompts.get(name);
+        if (seedChatPrompt) {
+            return this.buildChatPrompt(name, seedChatPrompt);
+        }
+        if (options?.fallback !== undefined) {
+            return this.buildFallbackChatPrompt(name, options.fallback);
+        }
+        if (this.missingPromptBehavior === InMemory_typedefs_1.InMemoryMissingPromptBehaviors.GenerateStub) {
+            return this.buildChatPrompt(name, {
+                messages: [{
+                        role: LLMPromptClient_typedefs_1.LLMPromptMessageRoles.System,
+                        content: `Mock prompt for ${name}`,
+                    }],
+            });
+        }
+        throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name);
+    }
+    async listPrompts(options) {
+        const matchingNames = this.collectMatchingNames(options.label);
+        const page = options.page ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LIST_PAGE;
+        const pageSize = options.pageSize ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LIST_PAGE_SIZE;
+        const startIndex = (page - 1) * pageSize;
+        return {
+            promptNames: matchingNames.slice(startIndex, startIndex + pageSize),
+            page,
+            totalPages: Math.max(1, Math.ceil(matchingNames.length / pageSize)),
+        };
+    }
+    async getPromptRecord(name, options) {
+        const seedPrompt = this.prompts.get(name);
+        if (seedPrompt && this.matchesLabel(seedPrompt.labels, options.label)) {
+            return this.buildTextPromptRecord(name, seedPrompt);
+        }
+        const seedChatPrompt = this.chatPrompts.get(name);
+        if (seedChatPrompt && this.matchesLabel(seedChatPrompt.labels, options.label)) {
+            return this.buildChatPromptRecord(name, seedChatPrompt);
+        }
+        throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name);
+    }
     shutdown() {
         return Promise.resolve();
     }
     setPrompt(name, seedPrompt) {
         this.prompts.set(name, seedPrompt);
     }
+    setChatPrompt(name, seedChatPrompt) {
+        this.chatPrompts.set(name, seedChatPrompt);
+    }
     clear() {
         this.prompts.clear();
+        this.chatPrompts.clear();
     }
     buildPrompt(name, seedPrompt) {
         return {
@@ -57,5 +103,72 @@ class InMemoryPromptClient {
             compile: (variables) => (0, template_1.compileTemplateVariables)(fallback, variables),
         };
     }
+    buildChatPrompt(name, seedChatPrompt) {
+        return {
+            name,
+            version: seedChatPrompt.version ?? DEFAULT_SEED_PROMPT_VERSION,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Chat,
+            messages: seedChatPrompt.messages,
+            config: seedChatPrompt.config ?? {},
+            isFallback: false,
+            compile: (variables) => this.compileMessages(seedChatPrompt.messages, variables),
+        };
+    }
+    buildFallbackChatPrompt(name, fallback) {
+        return {
+            name,
+            version: FALLBACK_PROMPT_VERSION,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Chat,
+            messages: fallback,
+            config: {},
+            isFallback: true,
+            compile: (variables) => this.compileMessages(fallback, variables),
+        };
+    }
+    compileMessages(messages, variables) {
+        return messages.map((message) => ({
+            role: message.role,
+            content: (0, template_1.compileTemplateVariables)(message.content, variables),
+        }));
+    }
+    collectMatchingNames(label) {
+        const matchingNames = [];
+        const seenNames = new Set();
+        const collect = (entries) => {
+            entries.forEach(([name, seedPrompt]) => {
+                if (seenNames.has(name) || !this.matchesLabel(seedPrompt.labels, label)) {
+                    return;
+                }
+                matchingNames.push(name);
+                seenNames.add(name);
+            });
+        };
+        collect([...this.prompts.entries()]);
+        collect([...this.chatPrompts.entries()]);
+        return matchingNames;
+    }
+    matchesLabel(labels, label) {
+        return (labels ?? [LLMPromptClient_constants_1.DEFAULT_PROMPT_LABEL]).includes(label);
+    }
+    buildTextPromptRecord(name, seedPrompt) {
+        return {
+            name,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Text,
+            version: seedPrompt.version ?? DEFAULT_SEED_PROMPT_VERSION,
+            labels: seedPrompt.labels ?? [LLMPromptClient_constants_1.DEFAULT_PROMPT_LABEL],
+            config: seedPrompt.config ?? {},
+            text: seedPrompt.prompt,
+        };
+    }
+    buildChatPromptRecord(name, seedChatPrompt) {
+        return {
+            name,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Chat,
+            version: seedChatPrompt.version ?? DEFAULT_SEED_PROMPT_VERSION,
+            labels: seedChatPrompt.labels ?? [LLMPromptClient_constants_1.DEFAULT_PROMPT_LABEL],
+            config: seedChatPrompt.config ?? {},
+            messages: seedChatPrompt.messages,
+        };
+    }
 }
 exports.InMemoryPromptClient = InMemoryPromptClient;

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

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

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

@@ -1 +1,8 @@
-export declare const isLangfuseInfraError: (error: unknown) => boolean;
+import { type LLMPromptMessage } from '../../LLMPromptClient.typedefs';
+export declare const isLangfusePromptNotFoundError: (error: unknown) => boolean;
+/**
+ * Narrows raw Langfuse chat prompt entries down to well-formed
+ * `LLMPromptMessage`s, dropping placeholder entries (no `role`/`content`)
+ * and any message whose role falls outside `LLMPromptMessageRoles`.
+ */
+export declare const collectPromptMessages: (entries: unknown[]) => LLMPromptMessage[];

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

@@ -1,16 +1,32 @@
 "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)) {
+exports.collectPromptMessages = exports.isLangfusePromptNotFoundError = void 0;
+const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
+const NOT_FOUND_STATUS_CODE = 404;
+const PROMPT_MESSAGE_ROLES = new Set(Object.values(LLMPromptClient_typedefs_1.LLMPromptMessageRoles));
+const isLangfusePromptNotFoundError = (error) => {
+    if (typeof error !== 'object' || error === null || !('statusCode' in error)) {
         return false;
     }
-    const errorName = error.name;
-    return typeof errorName === 'string'
-        && LANGFUSE_INFRA_ERROR_NAMES.includes(errorName);
+    const statusCode = error.statusCode;
+    return statusCode === NOT_FOUND_STATUS_CODE;
 };
-exports.isLangfuseInfraError = isLangfuseInfraError;
+exports.isLangfusePromptNotFoundError = isLangfusePromptNotFoundError;
+const isPromptMessage = (entry) => {
+    if (typeof entry !== 'object' || entry === null) {
+        return false;
+    }
+    const candidate = entry;
+    return typeof candidate.role === 'string'
+        && typeof candidate.content === 'string'
+        && PROMPT_MESSAGE_ROLES.has(candidate.role);
+};
+/**
+ * Narrows raw Langfuse chat prompt entries down to well-formed
+ * `LLMPromptMessage`s, dropping placeholder entries (no `role`/`content`)
+ * and any message whose role falls outside `LLMPromptMessageRoles`.
+ */
+const collectPromptMessages = (entries) => entries
+    .filter(isPromptMessage)
+    .map((message) => ({ role: message.role, content: message.content }));
+exports.collectPromptMessages = collectPromptMessages;

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

@@ -9,6 +9,4 @@ export interface LangfuseProviderOptions {
     defaultCacheTtlSeconds?: number;
     fetchTimeoutMs?: number;
     maxRetries?: number;
-    flushAt?: number;
-    flushIntervalMs?: number;
 }

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

@@ -1,16 +1,29 @@
-import { type Langfuse } from 'langfuse';
-import { type GetPromptOptions, type LLMPrompt, type LLMPromptClient } from '../../LLMPromptClient.typedefs';
+import { type LangfuseClient } from '@langfuse/client';
+import { type GetChatPromptOptions, type GetPromptOptions, type GetPromptRecordOptions, type LLMChatPrompt, type LLMPrompt, type LLMPromptClient, type LLMPromptCatalogPage, type LLMPromptRecord, type ListPromptsOptions } 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);
+    constructor(client: LangfuseClient, providerOptions: LangfuseProviderOptions, logger: PromptManagementLogger);
     getPrompt(name: string, options?: GetPromptOptions): Promise<LLMPrompt>;
+    getChatPrompt(name: string, options?: GetChatPromptOptions): Promise<LLMChatPrompt>;
+    listPrompts(options: ListPromptsOptions): Promise<LLMPromptCatalogPage>;
+    getPromptRecord(name: string, options: GetPromptRecordOptions): Promise<LLMPromptRecord>;
     shutdown(): Promise<void>;
-    private fetchPrompt;
-    private resolveLabelOption;
+    private fetchTextPrompt;
+    private fetchChatPrompt;
+    private resolveSelectionOptions;
+    private resolveCacheTtlSeconds;
+    private buildTextFallbackPrompt;
+    private resolveFallbackLabels;
+    private buildChatFallbackPrompt;
+    private classifyFetchError;
     private ensureTextPrompt;
+    private ensureChatPrompt;
     private reportPromptResolution;
+    private reportSkippedChatEntries;
+    private fetchRawPrompt;
+    private buildRequestOptions;
 }

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

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangfusePromptClient = void 0;
+const client_1 = require("@langfuse/client");
+const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
 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';
+const LANGFUSE_CHAT_PROMPT_TYPE = 'chat';
+const MILLISECONDS_PER_SECOND = 1000;
 class LangfusePromptClient {
     constructor(client, providerOptions, logger) {
         this.client = client;
@@ -13,42 +17,102 @@ class LangfusePromptClient {
         this.logger = logger;
     }
     async getPrompt(name, options) {
-        const nativePrompt = await this.fetchPrompt(name, options);
+        const nativePrompt = await this.fetchTextPrompt(name, options);
         this.ensureTextPrompt(name, nativePrompt);
         this.reportPromptResolution(name, nativePrompt);
         return new LangfusePrompt_1.LangfusePrompt(nativePrompt);
     }
+    async getChatPrompt(name, options) {
+        const nativePrompt = await this.fetchChatPrompt(name, options);
+        this.ensureChatPrompt(name, nativePrompt);
+        this.reportPromptResolution(name, nativePrompt);
+        this.reportSkippedChatEntries(name, nativePrompt);
+        return new LangfusePrompt_1.LangfuseChatPrompt(nativePrompt);
+    }
+    async listPrompts(options) {
+        try {
+            const promptListPage = await this.client.api.prompts.list({
+                label: options.label,
+                page: options.page ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LIST_PAGE,
+                limit: options.pageSize ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LIST_PAGE_SIZE,
+            }, this.buildRequestOptions());
+            return {
+                promptNames: promptListPage.data.map((promptSummary) => promptSummary.name),
+                page: promptListPage.meta.page,
+                totalPages: promptListPage.meta.totalPages,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to list Langfuse prompts', {
+                error,
+                label: options.label,
+            });
+            throw new LLMPromptClient_errors_1.LLMPromptListError(options.label, error);
+        }
+    }
+    async getPromptRecord(name, options) {
+        const rawPrompt = await this.fetchRawPrompt(name, options);
+        if (rawPrompt.type === LANGFUSE_CHAT_PROMPT_TYPE) {
+            return {
+                name: rawPrompt.name,
+                type: LLMPromptClient_typedefs_1.LLMPromptTypes.Chat,
+                version: rawPrompt.version,
+                labels: rawPrompt.labels,
+                config: rawPrompt.config,
+                messages: (0, Langfuse_helpers_1.collectPromptMessages)(rawPrompt.prompt),
+            };
+        }
+        return {
+            name: rawPrompt.name,
+            type: LLMPromptClient_typedefs_1.LLMPromptTypes.Text,
+            version: rawPrompt.version,
+            labels: rawPrompt.labels,
+            config: rawPrompt.config,
+            text: rawPrompt.prompt,
+        };
+    }
     shutdown() {
-        return this.client.shutdownAsync();
+        return this.client.shutdown();
     }
-    async fetchPrompt(name, options) {
+    async fetchTextPrompt(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,
+            return await this.client.prompt.get(name, {
+                ...this.resolveSelectionOptions(options),
+                cacheTtlSeconds: this.resolveCacheTtlSeconds(options),
                 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);
+            if (options?.fallback !== undefined) {
+                return this.buildTextFallbackPrompt(name, options.fallback, options);
             }
-            throw new LLMPromptClient_errors_1.LLMPromptNotFoundError(name, error);
+            throw this.classifyFetchError(name, error);
         }
     }
-    resolveLabelOption(options) {
+    async fetchChatPrompt(name, options) {
+        try {
+            return await this.client.prompt.get(name, {
+                ...this.resolveSelectionOptions(options),
+                cacheTtlSeconds: this.resolveCacheTtlSeconds(options),
+                fallback: options?.fallback,
+                maxRetries: this.providerOptions.maxRetries,
+                fetchTimeoutMs: this.providerOptions.fetchTimeoutMs,
+                type: LANGFUSE_CHAT_PROMPT_TYPE,
+            });
+        }
+        catch (error) {
+            if (options?.fallback !== undefined) {
+                return this.buildChatFallbackPrompt(name, options.fallback, options);
+            }
+            throw this.classifyFetchError(name, error);
+        }
+    }
+    resolveSelectionOptions(options) {
         if (options?.version !== undefined) {
-            return {};
+            return { version: options.version };
         }
         return {
             label: options?.label
@@ -56,6 +120,54 @@ class LangfusePromptClient {
                 ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_LABEL,
         };
     }
+    resolveCacheTtlSeconds(options) {
+        return options?.cacheTtlSeconds
+            ?? this.providerOptions.defaultCacheTtlSeconds
+            ?? LLMPromptClient_constants_1.DEFAULT_PROMPT_CACHE_TTL_SECONDS;
+    }
+    buildTextFallbackPrompt(name, fallback, options) {
+        return new client_1.TextPromptClient({
+            name,
+            version: options?.version ?? 0,
+            labels: this.resolveFallbackLabels(options),
+            tags: [],
+            config: {},
+            type: LANGFUSE_TEXT_PROMPT_TYPE,
+            prompt: fallback,
+        }, true);
+    }
+    resolveFallbackLabels(options) {
+        const selection = this.resolveSelectionOptions(options);
+        return selection.label === undefined ? [] : [selection.label];
+    }
+    buildChatFallbackPrompt(name, fallback, options) {
+        return new client_1.ChatPromptClient({
+            name,
+            version: options?.version ?? 0,
+            labels: this.resolveFallbackLabels(options),
+            tags: [],
+            config: {},
+            type: LANGFUSE_CHAT_PROMPT_TYPE,
+            prompt: fallback.map((message) => ({
+                role: message.role,
+                content: message.content,
+            })),
+        }, true);
+    }
+    classifyFetchError(name, error) {
+        if ((0, Langfuse_helpers_1.isLangfusePromptNotFoundError)(error)) {
+            this.logger.warn('Langfuse prompt not found', {
+                error,
+                promptName: name,
+            });
+            return new LLMPromptClient_errors_1.LLMPromptNotFoundError(name, error);
+        }
+        this.logger.error('Failed to fetch Langfuse prompt', {
+            error,
+            promptName: name,
+        });
+        return new LLMPromptClient_errors_1.LLMPromptFetchError(name, error);
+    }
     ensureTextPrompt(name, nativePrompt) {
         if (nativePrompt.type !== LANGFUSE_TEXT_PROMPT_TYPE) {
             this.logger.error('Langfuse prompt is not a text prompt', {
@@ -65,6 +177,15 @@ class LangfusePromptClient {
             throw new LLMPromptClient_errors_1.LLMPromptFetchError(name);
         }
     }
+    ensureChatPrompt(name, nativePrompt) {
+        if (nativePrompt.type !== LANGFUSE_CHAT_PROMPT_TYPE) {
+            this.logger.error('Langfuse prompt is not a chat 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', {
@@ -77,5 +198,35 @@ class LangfusePromptClient {
             promptVersion: nativePrompt.version,
         });
     }
+    reportSkippedChatEntries(name, nativePrompt) {
+        const skippedEntryCount = nativePrompt.prompt.length
+            - (0, Langfuse_helpers_1.collectPromptMessages)(nativePrompt.prompt).length;
+        if (skippedEntryCount > 0) {
+            this.logger.warn('Langfuse chat prompt contains unsupported entries', {
+                promptName: name,
+                skippedEntryCount,
+            });
+        }
+    }
+    async fetchRawPrompt(name, options) {
+        try {
+            return await this.client.api.prompts.get(name, { label: options.label }, this.buildRequestOptions());
+        }
+        catch (error) {
+            throw this.classifyFetchError(name, error);
+        }
+    }
+    buildRequestOptions() {
+        return {
+            ...(this.providerOptions.maxRetries !== undefined
+                ? { maxRetries: this.providerOptions.maxRetries }
+                : {}),
+            ...(this.providerOptions.fetchTimeoutMs !== undefined
+                ? {
+                    timeoutInSeconds: Math.ceil(this.providerOptions.fetchTimeoutMs / MILLISECONDS_PER_SECOND),
+                }
+                : {}),
+        };
+    }
 }
 exports.LangfusePromptClient = LangfusePromptClient;

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

@@ -1,5 +1,5 @@
-import { type TextPromptClient } from 'langfuse';
-import { LLMPromptTypes, type LLMPrompt } from '../../LLMPromptClient.typedefs';
+import { type ChatPromptClient, type TextPromptClient } from '@langfuse/client';
+import { LLMPromptTypes, type LLMChatPrompt, type LLMPrompt, type LLMPromptMessage } from '../../LLMPromptClient.typedefs';
 export declare class LangfusePrompt implements LLMPrompt {
     readonly nativePrompt: TextPromptClient;
     readonly type = LLMPromptTypes.Text;
@@ -11,3 +11,14 @@ export declare class LangfusePrompt implements LLMPrompt {
     get isFallback(): boolean;
     compile(variables?: Record<string, string>): string;
 }
+export declare class LangfuseChatPrompt implements LLMChatPrompt {
+    readonly nativePrompt: ChatPromptClient;
+    readonly type = LLMPromptTypes.Chat;
+    constructor(nativePrompt: ChatPromptClient);
+    get name(): string;
+    get version(): number;
+    get messages(): LLMPromptMessage[];
+    get config(): unknown;
+    get isFallback(): boolean;
+    compile(variables?: Record<string, string>): LLMPromptMessage[];
+}

package/dist/providers/Langfuse/LangfusePrompt.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LangfusePrompt = void 0;
+exports.LangfuseChatPrompt = exports.LangfusePrompt = void 0;
 const LLMPromptClient_typedefs_1 = require("../../LLMPromptClient.typedefs");
+const Langfuse_helpers_1 = require("../../providers/Langfuse/Langfuse.helpers");
 class LangfusePrompt {
     constructor(nativePrompt) {
         this.nativePrompt = nativePrompt;
@@ -27,3 +28,20 @@ class LangfusePrompt {
     }
 }
 exports.LangfusePrompt = LangfusePrompt;
+class LangfuseChatPrompt {
+    constructor(nativePrompt) {
+        this.nativePrompt = nativePrompt;
+        this.type = LLMPromptClient_typedefs_1.LLMPromptTypes.Chat;
+    }
+    get name() { return this.nativePrompt.name; }
+    get version() { return this.nativePrompt.version; }
+    get messages() {
+        return (0, Langfuse_helpers_1.collectPromptMessages)(this.nativePrompt.prompt);
+    }
+    get config() { return this.nativePrompt.config; }
+    get isFallback() { return this.nativePrompt.isFallback; }
+    compile(variables) {
+        return (0, Langfuse_helpers_1.collectPromptMessages)(this.nativePrompt.compile(variables));
+    }
+}
+exports.LangfuseChatPrompt = LangfuseChatPrompt;

package/dist/utilities/index.d.ts

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

package/dist/utilities/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("../utilities/logger"), exports);
 __exportStar(require("../utilities/template"), exports);
-__exportStar(require("../utilities/usageDetails"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mate-academy/prompt-client",
-  "version": "1.0.0",
-  "description": "Provider-agnostic LLM prompt management and tracing client (Langfuse, InMemory)",
+  "version": "2.0.0",
+  "description": "Provider-agnostic LLM prompt management client (Langfuse, InMemory)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -25,7 +25,6 @@
     "llm",
     "prompt",
     "langfuse",
-    "tracing",
     "mate-academy"
   ],
   "author": "Mate academy developers",
@@ -49,7 +48,7 @@
     }
   },
   "dependencies": {
-    "langfuse": "^3.38.20"
+    "@langfuse/client": "^5.4.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.36.0",

package/dist/LLMTracer.errors.d.ts

@@ -1,4 +0,0 @@
-export declare class LLMTracerError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
-}

package/dist/LLMTracer.errors.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMTracerError = void 0;
-class LLMTracerError extends Error {
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = 'LLMTracerError';
-    }
-}
-exports.LLMTracerError = LLMTracerError;