coaiajs 0.1.0

package/dist/src/langfuse/datasets.js

@@ -0,0 +1,140 @@
+// coaiajs/src/langfuse/datasets.ts — Dataset operations
+// Port of cofuse.py dataset functions
+import { getClient } from './client.js';
+export async function listDatasets() {
+    const client = getClient();
+    const result = await client.request('GET', '/api/public/v2/datasets');
+    return JSON.stringify(result, null, 2);
+}
+export async function getDataset(name) {
+    const client = getClient();
+    const result = await client.request('GET', `/api/public/v2/datasets/${encodeURIComponent(name)}`);
+    return JSON.stringify(result, null, 2);
+}
+export async function createDataset(params) {
+    const client = getClient();
+    const data = { name: params.name };
+    if (params.description)
+        data.description = params.description;
+    if (params.metadata) {
+        data.metadata = typeof params.metadata === 'string'
+            ? safeParseJSON(params.metadata)
+            : params.metadata;
+    }
+    const result = await client.request('POST', '/api/public/v2/datasets', data);
+    return JSON.stringify(result, null, 2);
+}
+export async function listDatasetItems(name) {
+    const client = getClient();
+    const allItems = [];
+    let page = 1;
+    while (true) {
+        const data = await client.request('GET', `/api/public/dataset-items?name=${encodeURIComponent(name)}&page=${page}`);
+        const items = data.data;
+        if (!items || !Array.isArray(items) || items.length === 0)
+            break;
+        allItems.push(...items);
+        const meta = data.meta;
+        if (!meta || (meta.page ?? page) >= (meta.totalPages ?? 1))
+            break;
+        page++;
+    }
+    return JSON.stringify(allItems, null, 2);
+}
+export async function createDatasetItem(params) {
+    const client = getClient();
+    const data = {
+        datasetName: params.datasetName,
+        input: params.input,
+    };
+    if (params.expectedOutput !== undefined)
+        data.expectedOutput = params.expectedOutput;
+    if (params.metadata)
+        data.metadata = params.metadata;
+    if (params.sourceTraceId)
+        data.sourceTraceId = params.sourceTraceId;
+    if (params.sourceObservationId)
+        data.sourceObservationId = params.sourceObservationId;
+    const result = await client.request('POST', '/api/public/dataset-items', data);
+    return JSON.stringify(result, null, 2);
+}
+// ─── Formatters ─────────────────────────────────────────────────────
+export function formatDatasetsTable(json) {
+    try {
+        const raw = typeof json === 'string' ? JSON.parse(json) : json;
+        const datasets = Array.isArray(raw)
+            ? raw
+            : raw.data ?? [];
+        if (!datasets.length)
+            return 'No datasets found.';
+        const headers = ['Name', 'Description', 'Items', 'Created'];
+        const rows = datasets.map((d) => [
+            trunc(String(d.name ?? 'N/A'), 25),
+            trunc(String(d.description ?? 'N/A'), 30),
+            String(d.items?.toString() ?? 'N/A'),
+            String(d.createdAt ?? 'N/A').slice(0, 10),
+        ]);
+        return formatTable(headers, rows) + `\nTotal datasets: ${datasets.length}`;
+    }
+    catch (e) {
+        return `Error formatting datasets: ${e}`;
+    }
+}
+export function formatDatasetForFinetuning(items, format, systemInstruction) {
+    try {
+        const parsed = (typeof items === 'string' ? JSON.parse(items) : items);
+        const sysInstr = systemInstruction ?? 'You are a helpful assistant.';
+        const lines = [];
+        for (const item of parsed) {
+            const input = item.input;
+            const output = item.expectedOutput;
+            if (!input || !output)
+                continue;
+            if (format === 'openai') {
+                lines.push(JSON.stringify({
+                    messages: [
+                        { role: 'system', content: sysInstr },
+                        { role: 'user', content: input },
+                        { role: 'assistant', content: output },
+                    ],
+                }));
+            }
+            else {
+                lines.push(JSON.stringify({
+                    systemInstruction: {
+                        role: 'system',
+                        parts: [{ text: sysInstr }],
+                    },
+                    contents: [
+                        { role: 'user', parts: [{ text: input }] },
+                        { role: 'model', parts: [{ text: output }] },
+                    ],
+                }));
+            }
+        }
+        return lines.join('\n');
+    }
+    catch (e) {
+        return `Error formatting for fine-tuning: ${e}`;
+    }
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function trunc(s, len) {
+    return s.length > len ? s.slice(0, len - 3) + '...' : s;
+}
+function safeParseJSON(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return { note: s };
+    }
+}
+function formatTable(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)));
+    const sep = '+' + widths.map((w) => '-'.repeat(w + 2)).join('+') + '+';
+    const hdr = '| ' + headers.map((h, i) => h.padEnd(widths[i])).join(' | ') + ' |';
+    const body = rows.map((r) => '| ' + r.map((c, i) => (c ?? '').padEnd(widths[i])).join(' | ') + ' |');
+    return [sep, hdr, sep, ...body, sep].join('\n');
+}
+//# sourceMappingURL=datasets.js.map

package/dist/src/langfuse/index.d.ts

@@ -0,0 +1,13 @@
+export { LangfuseClient, LangfuseApiError, getClient, resetClient, nowISO } from './client.js';
+export type { IngestionEvent, LangfuseClientConfig } from './client.js';
+export { addTrace, patchTraceOutput, listTraces, getTrace, formatTracesTable, formatTraceTree } from './traces.js';
+export type { TraceFilters } from './traces.js';
+export { addObservation, getObservation, formatObservationDisplay } from './observations.js';
+export { listPrompts, getPrompt, createPrompt, formatPromptsTable, formatPromptDisplay } from './prompts.js';
+export { listDatasets, getDataset, createDataset, listDatasetItems, createDatasetItem, formatDatasetsTable, formatDatasetForFinetuning, } from './datasets.js';
+export { createScore, applyScoreToTrace, createScoreForTarget, listScores, listScoreConfigs, getScoreConfig, createScoreConfig, exportScoreConfigs, importScoreConfigs, applyScoreConfig, getBuiltInPresets, installPreset, formatScoresTable, formatScoreConfigsTable, } from './scores.js';
+export type { ScoreFilters } from './scores.js';
+export { listComments, getComment, createComment } from './comments.js';
+export type { CommentFilters } from './comments.js';
+export { uploadAndAttachMedia, getMedia, detectContentType, formatMediaDisplay, } from './media.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/langfuse/index.js

@@ -0,0 +1,10 @@
+// coaiajs/src/langfuse/index.ts — Barrel export
+export { LangfuseClient, LangfuseApiError, getClient, resetClient, nowISO } from './client.js';
+export { addTrace, patchTraceOutput, listTraces, getTrace, formatTracesTable, formatTraceTree } from './traces.js';
+export { addObservation, getObservation, formatObservationDisplay } from './observations.js';
+export { listPrompts, getPrompt, createPrompt, formatPromptsTable, formatPromptDisplay } from './prompts.js';
+export { listDatasets, getDataset, createDataset, listDatasetItems, createDatasetItem, formatDatasetsTable, formatDatasetForFinetuning, } from './datasets.js';
+export { createScore, applyScoreToTrace, createScoreForTarget, listScores, listScoreConfigs, getScoreConfig, createScoreConfig, exportScoreConfigs, importScoreConfigs, applyScoreConfig, getBuiltInPresets, installPreset, formatScoresTable, formatScoreConfigsTable, } from './scores.js';
+export { listComments, getComment, createComment } from './comments.js';
+export { uploadAndAttachMedia, getMedia, detectContentType, formatMediaDisplay, } from './media.js';
+//# sourceMappingURL=index.js.map

package/dist/src/langfuse/media.d.ts

@@ -0,0 +1,11 @@
+export declare function uploadAndAttachMedia(params: {
+    filePath: string;
+    traceId: string;
+    field?: string;
+    observationId?: string;
+    contentType?: string;
+}): Promise<string>;
+export declare function getMedia(mediaId: string): Promise<string>;
+export declare function detectContentType(filePath: string): string;
+export declare function formatMediaDisplay(json: unknown): string;
+//# sourceMappingURL=media.d.ts.map

package/dist/src/langfuse/media.js

@@ -0,0 +1,167 @@
+// coaiajs/src/langfuse/media.ts — Media upload operations
+// Port of cofuse.py media functions
+import { readFileSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { getClient } from './client.js';
+const SUPPORTED_CONTENT_TYPES = new Set([
+    'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+    'image/tiff', 'image/bmp', 'image/avif',
+    'audio/mpeg', 'audio/mp4', 'audio/wav', 'audio/ogg', 'audio/webm', 'audio/flac',
+    'video/mp4', 'video/webm', 'video/ogg', 'video/quicktime',
+    'application/pdf',
+    'text/plain', 'text/html', 'text/css', 'text/csv',
+    'application/json', 'application/xml',
+]);
+const EXTENSION_MAP = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+    '.tiff': 'image/tiff', '.tif': 'image/tiff', '.bmp': 'image/bmp',
+    '.avif': 'image/avif',
+    '.mp3': 'audio/mpeg', '.m4a': 'audio/mp4', '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg', '.flac': 'audio/flac', '.weba': 'audio/webm',
+    '.mp4': 'video/mp4', '.webm': 'video/webm', '.ogv': 'video/ogg',
+    '.mov': 'video/quicktime',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain', '.html': 'text/html', '.htm': 'text/html',
+    '.css': 'text/css', '.csv': 'text/csv',
+    '.json': 'application/json', '.xml': 'application/xml',
+};
+const TRUSTED_DOMAINS = [
+    'amazonaws.com',
+    's3.amazonaws.com',
+    'storage.googleapis.com',
+    'blob.core.windows.net',
+    'r2.cloudflarestorage.com',
+];
+export async function uploadAndAttachMedia(params) {
+    const { filePath, traceId, observationId } = params;
+    const field = params.field ?? 'input';
+    // Detect content type
+    const contentType = params.contentType ?? detectContentType(filePath);
+    if (!SUPPORTED_CONTENT_TYPES.has(contentType)) {
+        return JSON.stringify({ error: `Unsupported content type: ${contentType}` });
+    }
+    // Calculate file info
+    const stat = statSync(filePath);
+    const fileData = readFileSync(filePath);
+    const sha256 = createHash('sha256').update(fileData).digest('base64');
+    const client = getClient();
+    // Step 1: Get presigned upload URL
+    const uploadReqData = {
+        traceId,
+        contentType,
+        contentLength: stat.size,
+        sha256Hash: sha256,
+        field,
+    };
+    if (observationId)
+        uploadReqData.observationId = observationId;
+    const uploadInfo = await client.request('POST', '/api/public/media', uploadReqData);
+    const uploadUrl = uploadInfo.uploadUrl;
+    const mediaId = uploadInfo.mediaId;
+    if (!uploadUrl || !mediaId) {
+        return JSON.stringify({ error: 'Failed to get upload URL', detail: uploadInfo });
+    }
+    // Step 2: Validate upload URL domain
+    const url = new URL(uploadUrl);
+    if (!isTrustedDomain(url.hostname)) {
+        return JSON.stringify({
+            error: `Security: Upload URL domain '${url.hostname}' is not trusted`,
+        });
+    }
+    // Step 3: Upload to presigned URL
+    const startTime = Date.now();
+    const uploadResponse = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': contentType,
+            'x-amz-checksum-sha256': sha256,
+        },
+        body: fileData,
+    });
+    const uploadTimeMs = Date.now() - startTime;
+    // Step 4: Patch status
+    await client.request('PATCH', `/api/public/media/${mediaId}`, {
+        uploadHttpStatus: uploadResponse.status,
+        uploadTimeMs,
+        uploadedAt: new Date().toISOString(),
+    });
+    if (!uploadResponse.ok) {
+        return JSON.stringify({
+            error: `Upload failed: ${uploadResponse.status}`,
+            mediaId,
+        });
+    }
+    // Build media token
+    const token = `@@@langfuseMedia:type=${contentType}|id=${mediaId}|source=file@@@`;
+    return JSON.stringify({
+        success: true,
+        mediaId,
+        fileName: basename(filePath),
+        contentType,
+        contentLength: stat.size,
+        traceId,
+        field,
+        observationId: observationId ?? null,
+        uploadTimeMs,
+        mediaToken: token,
+    }, null, 2);
+}
+export async function getMedia(mediaId) {
+    const client = getClient();
+    const result = await client.request('GET', `/api/public/media/${mediaId}`);
+    return JSON.stringify(result, null, 2);
+}
+export function detectContentType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return EXTENSION_MAP[ext] ?? 'application/octet-stream';
+}
+export function formatMediaDisplay(json) {
+    try {
+        const media = (typeof json === 'string' ? JSON.parse(json) : json);
+        if ('error' in media)
+            return `Error: ${media.error}`;
+        const contentType = String(media.contentType ?? 'unknown');
+        let glyph = '📎';
+        if (contentType.startsWith('image/'))
+            glyph = '🖼️';
+        else if (contentType.startsWith('video/'))
+            glyph = '🎥';
+        else if (contentType.startsWith('audio/'))
+            glyph = '🎵';
+        else if (contentType === 'application/pdf')
+            glyph = '📄';
+        const lines = [];
+        lines.push(`${glyph} Media: ${media.fileName ?? 'Unnamed'}`);
+        lines.push(`├── 🆔 ID: ${media.id ?? media.mediaId ?? 'N/A'}`);
+        lines.push(`├── 📝 Content Type: ${contentType}`);
+        lines.push(`├── 📏 Size: ${media.contentLength ?? 0} bytes`);
+        lines.push(`├── 🔗 Trace ID: ${media.traceId ?? 'N/A'}`);
+        if (media.observationId)
+            lines.push(`├── 👁️ Observation ID: ${media.observationId}`);
+        if (media.field)
+            lines.push(`├── 🏷️ Field: ${media.field}`);
+        if (media.uploadedAt)
+            lines.push(`├── ⏰ Uploaded: ${String(media.uploadedAt).slice(0, 19)}`);
+        // Fix last line to └──
+        if (lines.length > 1) {
+            const last = lines[lines.length - 1];
+            lines[lines.length - 1] = last.replace('├── ', '└── ');
+        }
+        return lines.join('\n');
+    }
+    catch (e) {
+        return `Error formatting media: ${e}`;
+    }
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function isTrustedDomain(hostname) {
+    const lower = hostname.toLowerCase();
+    for (const domain of TRUSTED_DOMAINS) {
+        if (lower === domain || lower.endsWith(`.${domain}`))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=media.js.map

package/dist/src/langfuse/observations.d.ts

@@ -0,0 +1,18 @@
+export declare function addObservation(params: {
+    observationId?: string;
+    traceId: string;
+    type?: string;
+    name: string;
+    parentId?: string;
+    inputData?: unknown;
+    outputData?: unknown;
+    metadata?: unknown;
+    startTime?: string;
+    endTime?: string;
+    level?: string;
+    model?: string;
+    usage?: unknown;
+}): Promise<string>;
+export declare function getObservation(observationId: string): Promise<string>;
+export declare function formatObservationDisplay(json: unknown): string;
+//# sourceMappingURL=observations.d.ts.map

package/dist/src/langfuse/observations.js

@@ -0,0 +1,113 @@
+// coaiajs/src/langfuse/observations.ts — Observation operations
+// Port of cofuse.py observation functions
+import { v4 as uuidv4 } from 'uuid';
+import { getClient, nowISO } from './client.js';
+export async function addObservation(params) {
+    const client = getClient();
+    const now = nowISO();
+    const obsId = params.observationId ?? uuidv4();
+    const body = {
+        id: obsId,
+        traceId: params.traceId,
+        type: params.type ?? 'EVENT',
+        startTime: params.startTime ?? now,
+        level: params.level ?? 'DEFAULT',
+    };
+    if (params.name)
+        body.name = params.name;
+    if (params.inputData)
+        body.input = params.inputData;
+    if (params.outputData)
+        body.output = params.outputData;
+    if (params.metadata)
+        body.metadata = params.metadata;
+    if (params.parentId)
+        body.parentObservationId = params.parentId;
+    if (params.endTime)
+        body.endTime = params.endTime;
+    if (params.model)
+        body.model = params.model;
+    if (params.usage)
+        body.usage = params.usage;
+    const event = {
+        id: `${obsId}-event`,
+        timestamp: now,
+        type: 'observation-create',
+        body,
+    };
+    await client.ingest([event]);
+    return JSON.stringify({
+        success: true,
+        observationId: obsId,
+        traceId: params.traceId,
+        name: params.name,
+        type: params.type ?? 'EVENT',
+    }, null, 2);
+}
+export async function getObservation(observationId) {
+    const client = getClient();
+    const result = await client.request('GET', `/api/public/observations/${observationId}`);
+    return JSON.stringify(result, null, 2);
+}
+// ─── Formatters ─────────────────────────────────────────────────────
+const TYPE_GLYPHS = {
+    SPAN: '🔗',
+    GENERATION: '🤖',
+    EVENT: '⚡',
+    DEFAULT: '📦',
+};
+export function formatObservationDisplay(json) {
+    try {
+        const obs = (typeof json === 'string' ? JSON.parse(json) : json);
+        if ('error' in obs)
+            return `Error: ${obs.error}`;
+        const obsType = String(obs.type ?? 'UNKNOWN').toUpperCase();
+        const glyph = TYPE_GLYPHS[obsType] ?? TYPE_GLYPHS.DEFAULT;
+        const lines = [];
+        lines.push(`${glyph} Observation: ${obs.name ?? 'Unnamed'}`);
+        lines.push(`├── 🆔 ID: ${obs.id ?? 'N/A'}`);
+        lines.push(`├── 📋 Type: ${obsType}`);
+        lines.push(`├── 🔗 Trace: ${obs.traceId ?? 'N/A'}`);
+        lines.push(`├── ⏰ Start: ${String(obs.startTime ?? 'N/A').slice(0, 19)}`);
+        if (obs.endTime)
+            lines.push(`├── ⏰ End: ${String(obs.endTime).slice(0, 19)}`);
+        if (obs.level && obs.level !== 'DEFAULT')
+            lines.push(`├── 📊 Level: ${obs.level}`);
+        if (obs.model)
+            lines.push(`├── 🤖 Model: ${obs.model}`);
+        if (obs.parentObservationId) {
+            lines.push(`├── 👆 Parent: ${obs.parentObservationId}`);
+        }
+        if (obs.input) {
+            const txt = String(obs.input).replace(/\n/g, ' ');
+            lines.push(`├── 📥 Input: ${txt.length > 100 ? txt.slice(0, 100) + '...' : txt}`);
+        }
+        if (obs.output) {
+            const txt = String(obs.output).replace(/\n/g, ' ');
+            lines.push(`├── 📤 Output: ${txt.length > 100 ? txt.slice(0, 100) + '...' : txt}`);
+        }
+        const metadata = obs.metadata;
+        if (metadata && typeof metadata === 'object' && Object.keys(metadata).length) {
+            lines.push(`└── 📋 Metadata:`);
+            const entries = Object.entries(metadata);
+            entries.forEach(([k, v], i) => {
+                const pre = i === entries.length - 1 ? '└── ' : '├── ';
+                lines.push(`    ${pre}${k}: ${JSON.stringify(v)}`);
+            });
+        }
+        else {
+            // Fix last ├── to └──
+            if (lines.length > 0) {
+                const last = lines[lines.length - 1];
+                if (last.startsWith('├── ')) {
+                    lines[lines.length - 1] = last.replace('├── ', '└── ');
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    catch (e) {
+        return `Error formatting observation: ${e}`;
+    }
+}
+//# sourceMappingURL=observations.js.map

package/dist/src/langfuse/prompts.d.ts

@@ -0,0 +1,14 @@
+export declare function listPrompts(): Promise<string>;
+export declare function getPrompt(name: string, label?: string): Promise<string>;
+export declare function createPrompt(params: {
+    name: string;
+    content: string | unknown[];
+    commitMessage?: string;
+    labels?: string[];
+    tags?: string[];
+    promptType?: 'text' | 'chat';
+    config?: Record<string, unknown>;
+}): Promise<string>;
+export declare function formatPromptsTable(json: unknown): string;
+export declare function formatPromptDisplay(json: unknown): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/src/langfuse/prompts.js

@@ -0,0 +1,127 @@
+// coaiajs/src/langfuse/prompts.ts — Prompt operations
+// Port of cofuse.py prompt functions
+import { getClient } from './client.js';
+export async function listPrompts() {
+    const client = getClient();
+    const allPrompts = [];
+    let page = 1;
+    while (true) {
+        const data = await client.request('GET', `/api/public/v2/prompts?page=${page}`);
+        const prompts = data.data;
+        if (!prompts || !Array.isArray(prompts) || prompts.length === 0)
+            break;
+        allPrompts.push(...prompts);
+        const meta = data.meta;
+        if (meta?.totalPages && (meta.page ?? page) >= meta.totalPages)
+            break;
+        if (!data.hasNextPage && !meta?.totalPages)
+            break;
+        page++;
+    }
+    return JSON.stringify(allPrompts, null, 2);
+}
+export async function getPrompt(name, label) {
+    const client = getClient();
+    const params = label ? `?label=${encodeURIComponent(label)}` : '';
+    const result = await client.request('GET', `/api/public/v2/prompts/${encodeURIComponent(name)}${params}`);
+    return JSON.stringify(result, null, 2);
+}
+export async function createPrompt(params) {
+    const client = getClient();
+    const data = {
+        type: params.promptType ?? 'text',
+        name: params.name,
+        prompt: params.content,
+    };
+    if (params.commitMessage)
+        data.commitMessage = params.commitMessage;
+    if (params.labels)
+        data.labels = params.labels;
+    if (params.tags)
+        data.tags = params.tags;
+    if (params.config)
+        data.config = params.config;
+    const result = await client.request('POST', '/api/public/v2/prompts', data);
+    return JSON.stringify(result, null, 2);
+}
+// ─── Formatters ─────────────────────────────────────────────────────
+export function formatPromptsTable(json) {
+    try {
+        const raw = typeof json === 'string' ? JSON.parse(json) : json;
+        const prompts = Array.isArray(raw)
+            ? raw
+            : raw.data ?? [];
+        if (!prompts.length)
+            return 'No prompts found.';
+        const headers = ['Name', 'Version', 'Created', 'Tags/Labels'];
+        const rows = prompts.map((p) => [
+            trunc(String(p.name ?? 'N/A'), 30),
+            String(p.version ?? 'N/A'),
+            String(p.createdAt ?? 'N/A').slice(0, 10),
+            (p.labels ?? []).join(', ') || 'None',
+        ]);
+        return formatTable(headers, rows) + `\nTotal prompts: ${prompts.length}`;
+    }
+    catch (e) {
+        return `Error formatting prompts: ${e}`;
+    }
+}
+export function formatPromptDisplay(json) {
+    try {
+        const prompt = (typeof json === 'string' ? JSON.parse(json) : json);
+        if ('error' in prompt)
+            return `Error: ${prompt.error}`;
+        const name = String(prompt.name ?? 'Unnamed');
+        const version = String(prompt.version ?? 'N/A');
+        const type = String(prompt.type ?? 'text');
+        const isActive = Boolean(prompt.isActive);
+        const created = String(prompt.createdAt ?? 'N/A').slice(0, 19);
+        const updated = String(prompt.updatedAt ?? 'N/A').slice(0, 19);
+        const labels = prompt.labels ?? [];
+        const tags = prompt.tags ?? [];
+        const commitMsg = String(prompt.commitMessage ?? '');
+        const config = prompt.config;
+        const content = String(prompt.prompt ?? '');
+        const header = `🎯 PROMPT: ${name}${version !== 'N/A' ? ` (v${version})` : ''}`;
+        const sep = '='.repeat(header.length);
+        const lines = [sep, header, sep, ''];
+        lines.push('📋 METADATA:');
+        lines.push(`   Type: ${type}`);
+        lines.push(`   Active: ${isActive ? '✅ Yes' : '❌ No'}`);
+        lines.push(`   Created: ${created}`);
+        lines.push(`   Updated: ${updated}`);
+        lines.push(`   Labels: ${labels.length ? labels.join(', ') : 'None'}`);
+        if (tags.length)
+            lines.push(`   Tags: ${tags.join(', ')}`);
+        if (commitMsg)
+            lines.push(`   Commit: ${commitMsg}`);
+        lines.push('');
+        if (config && Object.keys(config).length) {
+            lines.push('⚙️ CONFIGURATION:');
+            for (const [k, v] of Object.entries(config)) {
+                lines.push(`   ${k}: ${v}`);
+            }
+            lines.push('');
+        }
+        lines.push('📝 PROMPT CONTENT:');
+        lines.push('-'.repeat(50));
+        lines.push(content || '(No content)');
+        lines.push('-'.repeat(50));
+        return lines.join('\n');
+    }
+    catch (e) {
+        return `Error formatting prompt: ${e}`;
+    }
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function trunc(s, len) {
+    return s.length > len ? s.slice(0, len - 3) + '...' : s;
+}
+function formatTable(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)));
+    const sep = '+' + widths.map((w) => '-'.repeat(w + 2)).join('+') + '+';
+    const hdr = '| ' + headers.map((h, i) => h.padEnd(widths[i])).join(' | ') + ' |';
+    const body = rows.map((r) => '| ' + r.map((c, i) => (c ?? '').padEnd(widths[i])).join(' | ') + ' |');
+    return [sep, hdr, sep, ...body, sep].join('\n');
+}
+//# sourceMappingURL=prompts.js.map

package/dist/src/langfuse/scores.d.ts

@@ -0,0 +1,54 @@
+import type { ScoreConfig } from '../types.js';
+export interface ScoreFilters {
+    userId?: string;
+    name?: string;
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    configId?: string;
+    page?: number;
+}
+export declare function createScore(params: {
+    id?: string;
+    name?: string;
+    value: number;
+    traceId?: string;
+    observationId?: string;
+    configId?: string;
+    comment?: string;
+}): Promise<string>;
+export declare function applyScoreToTrace(traceId: string, scoreId: string, value: number): Promise<string>;
+export declare function createScoreForTarget(params: {
+    targetType: 'trace' | 'session';
+    targetId: string;
+    scoreId?: string;
+    value: number;
+    scoreName?: string;
+    observationId?: string;
+    configId?: string;
+    comment?: string;
+}): Promise<string>;
+export declare function listScores(filters: ScoreFilters): Promise<string>;
+export declare function listScoreConfigs(): Promise<string>;
+export declare function getScoreConfig(configId: string): Promise<string>;
+export declare function createScoreConfig(params: {
+    name: string;
+    dataType: 'NUMERIC' | 'CATEGORICAL' | 'BOOLEAN';
+    description?: string;
+    categories?: Array<{
+        label: string;
+        value: number;
+    }>;
+    minValue?: number;
+    maxValue?: number;
+}): Promise<string>;
+export declare function exportScoreConfigs(outputFile: string): Promise<string>;
+export declare function importScoreConfigs(importFile: string, options?: {
+    allowDuplicates?: boolean;
+    selectedConfigs?: string[];
+}): Promise<string>;
+export declare function applyScoreConfig(configNameOrId: string, targetType: string, targetId: string, value: number, observationId?: string, comment?: string): Promise<string>;
+export declare function getBuiltInPresets(): ScoreConfig[];
+export declare function installPreset(name: string, checkDuplicates?: boolean): Promise<string>;
+export declare function formatScoresTable(json: unknown): string;
+export declare function formatScoreConfigsTable(json: unknown): string;
+//# sourceMappingURL=scores.d.ts.map