@anyway-sh/node-server-sdk 0.22.8

package/dist/index.js

@@ -0,0 +1,4458 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var mime = require('mime-types');
+var Papa = require('papaparse');
+var sdkNode = require('@opentelemetry/sdk-node');
+var api = require('@opentelemetry/api');
+var exporterTraceOtlpProto = require('@opentelemetry/exporter-trace-otlp-proto');
+var opentelemetryCloudTraceExporter = require('@google-cloud/opentelemetry-cloud-trace-exporter');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var aiSemanticConventions = require('@traceloop/ai-semantic-conventions');
+var instrumentationAnthropic = require('@traceloop/instrumentation-anthropic');
+var instrumentationOpenai = require('@traceloop/instrumentation-openai');
+var instrumentationLlamaindex = require('@traceloop/instrumentation-llamaindex');
+var instrumentationVertexai = require('@traceloop/instrumentation-vertexai');
+var instrumentationBedrock = require('@traceloop/instrumentation-bedrock');
+var instrumentationCohere = require('@traceloop/instrumentation-cohere');
+var instrumentationPinecone = require('@traceloop/instrumentation-pinecone');
+var instrumentationLangchain = require('@traceloop/instrumentation-langchain');
+var instrumentationChromadb = require('@traceloop/instrumentation-chromadb');
+var instrumentationQdrant = require('@traceloop/instrumentation-qdrant');
+var instrumentationTogether = require('@traceloop/instrumentation-together');
+var instrumentationMcp = require('@traceloop/instrumentation-mcp');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var incubating = require('@opentelemetry/semantic-conventions/incubating');
+var fetch$1 = require('cross-fetch');
+var fetchBuilder = require('fetch-retry');
+var core = require('@opentelemetry/core');
+var nunjucks = require('nunjucks');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var mime__namespace = /*#__PURE__*/_interopNamespaceDefault(mime);
+var Papa__namespace = /*#__PURE__*/_interopNamespaceDefault(Papa);
+
+/**
+ * The severity of an error.
+ */
+const SEVERITY = {
+    Warning: "Warning",
+    Error: "Error",
+    Critical: "Critical",
+};
+/**
+ * Base class for all Traceloop errors.
+ */
+class TraceloopError extends Error {
+    constructor(message, severity = SEVERITY.Error) {
+        super(message);
+        this.severity = severity;
+    }
+}
+class NotInitializedError extends TraceloopError {
+    constructor() {
+        super(`The Traceloop SDK must be initialized by calling the "initialize" function prior to use.`, SEVERITY.Critical);
+    }
+}
+class InitializationError extends TraceloopError {
+    constructor(message, cause) {
+        super(message !== null && message !== void 0 ? message : "Failed to initialize Traceloop SDK", SEVERITY.Critical);
+        this.underlyingCause = cause;
+    }
+}
+class ArgumentNotProvidedError extends TraceloopError {
+    constructor(argumentName) {
+        super(`The "${argumentName}" argument is required and must be a string.`);
+    }
+}
+class PromptNotFoundError extends TraceloopError {
+    constructor(key) {
+        super(`The prompt "${key}" was not found in the registry.`);
+    }
+}
+
+var version = "0.22.8";
+
+/**
+ * Base class for handling annotation operations with the Traceloop API.
+ * @internal
+ */
+class BaseAnnotation {
+    constructor(client, flow) {
+        this.client = client;
+        this.flow = flow;
+    }
+    /**
+     * Creates a new annotation.
+     *
+     * @param options - The annotation creation options
+     * @returns Promise resolving to the fetch Response
+     */
+    async create(options) {
+        return await this.client.post(`/v2/annotation-tasks/${options.annotationTask}/annotations`, {
+            entity_instance_id: options.entity.id,
+            tags: options.tags,
+            source: "sdk",
+            flow: this.flow,
+            actor: {
+                type: "service",
+                id: this.client.appName,
+            },
+        });
+    }
+}
+
+/**
+ * Handles user feedback annotations with the Traceloop API.
+ */
+class UserFeedback extends BaseAnnotation {
+    constructor(client) {
+        super(client, "user_feedback");
+    }
+    /**
+     * Creates a new annotation for a specific task and entity.
+     *
+     * @param options - The options for creating an annotation
+     * @returns Promise resolving to the fetch Response
+     *
+     * @example
+     * ```typescript
+     * await client.annotation.create({
+     *   annotationTask: 'sample-annotation-task',
+     *   entity: {
+     *     id: '123456',
+     *   },
+     *   tags: {
+     *     sentiment: 'positive',
+     *     score: 0.85,
+     *     tones: ['happy', 'surprised']
+     *   }
+     * });
+     * ```
+     */
+    async create(options) {
+        return await super.create(options);
+    }
+}
+
+/**
+ * Utility functions for transforming API responses from snake_case to camelCase
+ */
+/**
+ * Converts a snake_case string to camelCase
+ * @param str The snake_case string to convert
+ * @returns The camelCase version of the string
+ */
+function snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Recursively transforms all snake_case keys in an object to camelCase
+ * @param obj The object to transform
+ * @returns A new object with camelCase keys
+ */
+function transformResponseKeys(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(transformResponseKeys);
+    }
+    if (typeof obj === "object" && obj.constructor === Object) {
+        const transformed = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const camelKey = snakeToCamel(key);
+            transformed[camelKey] = transformResponseKeys(value);
+        }
+        return transformed;
+    }
+    return obj;
+}
+/**
+ * Transforms API response data by converting snake_case keys to camelCase
+ * This function is designed to be used in the BaseDataset.handleResponse() method
+ * to ensure consistent camelCase format throughout the SDK
+ *
+ * @param data The raw API response data
+ * @returns The transformed data with camelCase keys
+ */
+function transformApiResponse(data) {
+    return transformResponseKeys(data);
+}
+
+class BaseDatasetEntity {
+    constructor(client) {
+        this.client = client;
+    }
+    async handleResponse(response) {
+        if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                if (errorData.error) {
+                    errorMessage = errorData.error;
+                }
+            }
+            catch (_a) {
+                // Use default HTTP error message if JSON parsing fails
+            }
+            throw new Error(errorMessage);
+        }
+        const contentType = response.headers.get("content-type");
+        if (contentType && contentType.includes("application/json")) {
+            const rawData = await response.json();
+            return transformApiResponse(rawData);
+        }
+        // Handle non-JSON responses (text/csv, etc.)
+        const textContent = await response.text();
+        return {
+            contentType: contentType || "text/plain",
+            body: textContent,
+        };
+    }
+    validateDatasetId(id) {
+        if (!id || typeof id !== "string" || id.trim().length === 0) {
+            throw new Error("Dataset ID is required and must be a non-empty string");
+        }
+    }
+    validateDatasetSlug(slug) {
+        if (!slug || typeof slug !== "string" || slug.trim().length === 0) {
+            throw new Error("Dataset slug is required and must be a non-empty string");
+        }
+    }
+    validateDatasetName(name) {
+        if (!name || typeof name !== "string" || name.trim().length === 0) {
+            throw new Error("Dataset name is required and must be a non-empty string");
+        }
+    }
+}
+
+function detectFileType(contentType) {
+    if (contentType.startsWith("image/"))
+        return "image";
+    if (contentType.startsWith("video/"))
+        return "video";
+    if (contentType.startsWith("audio/"))
+        return "audio";
+    return "file";
+}
+function getMimeType(filename) {
+    return mime__namespace.lookup(filename) || "application/octet-stream";
+}
+class Attachment {
+    constructor(options) {
+        this.type = "attachment";
+        const { filePath, data, filename, contentType, fileType, metadata } = options;
+        if (!filePath && !data) {
+            throw new Error("Either filePath or data must be provided");
+        }
+        if (filePath && data) {
+            throw new Error("Cannot provide both filePath and data");
+        }
+        if (data && !filename) {
+            throw new Error("filename is required when using data");
+        }
+        this._filePath = filePath;
+        this._data = data;
+        this._filename = filename;
+        this._contentType = contentType;
+        this._fileType = fileType;
+        this._metadata = metadata;
+    }
+    async getData() {
+        if (this._data) {
+            return Buffer.isBuffer(this._data) ? this._data : Buffer.from(this._data);
+        }
+        if (this._filePath) {
+            return fs__namespace.promises.readFile(this._filePath);
+        }
+        throw new Error("No data source available");
+    }
+    getFileName() {
+        if (this._filename) {
+            return this._filename;
+        }
+        if (this._filePath) {
+            return path__namespace.basename(this._filePath);
+        }
+        throw new Error("No filename available");
+    }
+    getContentType() {
+        if (this._contentType) {
+            return this._contentType;
+        }
+        return getMimeType(this.getFileName());
+    }
+    get fileType() {
+        if (this._fileType) {
+            return this._fileType;
+        }
+        return detectFileType(this.getContentType());
+    }
+    get metadata() {
+        return this._metadata;
+    }
+}
+class ExternalAttachment {
+    constructor(options) {
+        this.type = "external";
+        const { url, filename, contentType, fileType, metadata } = options;
+        if (!url || typeof url !== "string") {
+            throw new Error("URL is required and must be a string");
+        }
+        try {
+            new URL(url);
+        }
+        catch (_a) {
+            throw new Error("Invalid URL provided");
+        }
+        this._url = url;
+        this._filename = filename;
+        this._contentType = contentType;
+        this._fileType = fileType || "file";
+        this._metadata = metadata;
+    }
+    get url() {
+        return this._url;
+    }
+    get filename() {
+        return this._filename;
+    }
+    get contentType() {
+        return this._contentType;
+    }
+    get fileType() {
+        return this._fileType;
+    }
+    get metadata() {
+        return this._metadata;
+    }
+}
+class AttachmentReference {
+    constructor(storageType, storageKey, url, fileType, metadata) {
+        this.storageType = storageType;
+        this.storageKey = storageKey;
+        this.url = url;
+        this.fileType = fileType;
+        this.metadata = metadata;
+    }
+    async download(filePath) {
+        if (!this.url) {
+            throw new Error("Cannot download attachment: no URL available");
+        }
+        const response = await fetch(this.url);
+        if (!response.ok) {
+            throw new Error(`Failed to download attachment: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        if (filePath) {
+            await fs__namespace.promises.writeFile(filePath, buffer);
+            return;
+        }
+        return buffer;
+    }
+    getUrl() {
+        return this.url;
+    }
+    toJSON() {
+        return {
+            storageType: this.storageType,
+            storageKey: this.storageKey,
+            url: this.url,
+            fileType: this.fileType,
+            metadata: this.metadata,
+        };
+    }
+}
+function isAttachment(value) {
+    return value instanceof Attachment || (value === null || value === void 0 ? void 0 : value.type) === "attachment";
+}
+function isExternalAttachment(value) {
+    return (value instanceof ExternalAttachment || (value === null || value === void 0 ? void 0 : value.type) === "external");
+}
+function isAttachmentReference(value) {
+    return (value instanceof AttachmentReference ||
+        ((value === null || value === void 0 ? void 0 : value.storageType) !== undefined &&
+            (value === null || value === void 0 ? void 0 : value.storageKey) !== undefined));
+}
+function isAnyAttachment(value) {
+    return isAttachment(value) || isExternalAttachment(value);
+}
+const attachment = {
+    file: (filePath, options) => {
+        return new Attachment(Object.assign({ filePath }, options));
+    },
+    buffer: (data, filename, options) => {
+        return new Attachment(Object.assign({ data,
+            filename }, options));
+    },
+    url: (url, options) => {
+        return new ExternalAttachment(Object.assign({ url }, options));
+    },
+};
+
+/**
+ * Handles attachment upload and registration operations
+ */
+class AttachmentUploader {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Requests a presigned upload URL from the API
+     */
+    async getUploadUrl(datasetSlug, rowId, columnSlug, fileName, contentType, fileType, metadata) {
+        const response = await this.client.post(`/v2/datasets/${datasetSlug}/rows/${rowId}/cells/${columnSlug}/upload-url`, {
+            type: fileType,
+            file_name: fileName,
+            content_type: contentType,
+            metadata: metadata,
+        });
+        if (!response.ok) {
+            let errorMessage = `Failed to get upload URL: ${response.status} ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                if (errorData.error) {
+                    errorMessage = errorData.error;
+                }
+            }
+            catch (_a) {
+                // Use default error message
+            }
+            throw new Error(errorMessage);
+        }
+        const data = await response.json();
+        return {
+            uploadUrl: data.upload_url,
+            storageKey: data.storage_key,
+            expiresAt: data.expires_at,
+            method: data.method || "PUT",
+        };
+    }
+    /**
+     * Uploads file data directly to S3 using the presigned URL
+     */
+    async uploadToS3(uploadUrl, data, contentType) {
+        const response = await fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": contentType,
+            },
+            body: new Uint8Array(data),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to upload to S3: ${response.status} ${response.statusText}`);
+        }
+    }
+    /**
+     * Confirms the upload status with the API
+     */
+    async confirmUpload(datasetSlug, rowId, columnSlug, status, metadata) {
+        const response = await this.client.put(`/v2/datasets/${datasetSlug}/rows/${rowId}/cells/${columnSlug}/upload-status`, {
+            status,
+            metadata,
+        });
+        if (!response.ok) {
+            let errorMessage = `Failed to confirm upload: ${response.status} ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                if (errorData.error) {
+                    errorMessage = errorData.error;
+                }
+            }
+            catch (_a) {
+                // Use default error message
+            }
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Registers an external URL as an attachment
+     */
+    async registerExternalUrl(datasetSlug, rowId, columnSlug, url, fileType, metadata) {
+        const response = await this.client.post(`/v2/datasets/${datasetSlug}/rows/${rowId}/cells/${columnSlug}/external-url`, {
+            type: fileType,
+            url,
+            metadata,
+        });
+        if (!response.ok) {
+            let errorMessage = `Failed to register external URL: ${response.status} ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                if (errorData.error) {
+                    errorMessage = errorData.error;
+                }
+            }
+            catch (_a) {
+                // Use default error message
+            }
+            throw new Error(errorMessage);
+        }
+        const data = await response.json();
+        return new AttachmentReference("external", data.storage_key || "", url, fileType, metadata);
+    }
+    /**
+     * Uploads an Attachment through the full flow:
+     * 1. Get presigned URL
+     * 2. Upload to S3
+     * 3. Confirm upload
+     */
+    async uploadAttachment(datasetSlug, rowId, columnSlug, attachment) {
+        const fileName = attachment.getFileName();
+        const contentType = attachment.getContentType();
+        const fileType = attachment.fileType;
+        const data = await attachment.getData();
+        // Step 1: Get presigned upload URL
+        const uploadInfo = await this.getUploadUrl(datasetSlug, rowId, columnSlug, fileName, contentType, fileType, attachment.metadata);
+        // Step 2: Upload to S3
+        try {
+            await this.uploadToS3(uploadInfo.uploadUrl, data, contentType);
+        }
+        catch (error) {
+            // Confirm failure and re-throw
+            try {
+                await this.confirmUpload(datasetSlug, rowId, columnSlug, "failed", attachment.metadata);
+            }
+            catch (_a) {
+                // Ignore confirmation errors
+            }
+            throw error;
+        }
+        // Step 3: Confirm success
+        await this.confirmUpload(datasetSlug, rowId, columnSlug, "success", attachment.metadata);
+        return new AttachmentReference("internal", uploadInfo.storageKey, undefined, fileType, attachment.metadata);
+    }
+    /**
+     * Processes an ExternalAttachment by registering the URL
+     */
+    async processExternalAttachment(datasetSlug, rowId, columnSlug, attachment) {
+        return this.registerExternalUrl(datasetSlug, rowId, columnSlug, attachment.url, attachment.fileType, attachment.metadata);
+    }
+    /**
+     * Processes any attachment type (Attachment or ExternalAttachment)
+     */
+    async processAnyAttachment(datasetSlug, rowId, columnSlug, attachmentObj) {
+        if (attachmentObj instanceof Attachment) {
+            return this.uploadAttachment(datasetSlug, rowId, columnSlug, attachmentObj);
+        }
+        else {
+            return this.processExternalAttachment(datasetSlug, rowId, columnSlug, attachmentObj);
+        }
+    }
+}
+
+class Row extends BaseDatasetEntity {
+    constructor(client, data) {
+        super(client);
+        this._deleted = false;
+        this._data = data;
+    }
+    get id() {
+        return this._data.id;
+    }
+    get datasetId() {
+        return this._data.datasetId;
+    }
+    get datasetSlug() {
+        return this._data.datasetSlug;
+    }
+    get data() {
+        return Object.assign({}, this._data.data);
+    }
+    get createdAt() {
+        return this._data.createdAt;
+    }
+    get updatedAt() {
+        return this._data.updatedAt;
+    }
+    get deleted() {
+        return this._deleted;
+    }
+    getValue(columnName) {
+        const value = this._data.data[columnName];
+        return value !== undefined ? value : null;
+    }
+    hasColumn(columnName) {
+        return columnName in this._data.data;
+    }
+    getColumns() {
+        return Object.keys(this._data.data);
+    }
+    async update(options) {
+        if (this._deleted) {
+            throw new Error("Cannot update a deleted row");
+        }
+        if (!options.data || typeof options.data !== "object") {
+            throw new Error("Update data must be a valid object");
+        }
+        const updatedData = Object.assign(Object.assign({}, this._data.data), options.data);
+        const response = await this.client.put(`/v2/datasets/${this.datasetSlug}/rows/${this.id}`, {
+            Values: updatedData,
+        });
+        const result = await this.handleResponse(response);
+        if (result && result.id) {
+            this._data = result;
+        }
+    }
+    async partialUpdate(updates) {
+        if (this._deleted) {
+            throw new Error("Cannot update a deleted row");
+        }
+        if (!updates || typeof updates !== "object") {
+            throw new Error("Updates must be a valid object");
+        }
+        const response = await this.client.put(`/v2/datasets/${this.datasetSlug}/rows/${this.id}`, {
+            Values: updates,
+        });
+        const result = await this.handleResponse(response);
+        if (result && result.id) {
+            this._data = result;
+        }
+    }
+    async delete() {
+        if (this._deleted) {
+            throw new Error("Row is already deleted");
+        }
+        const response = await this.client.delete(`/v2/datasets/${this.datasetSlug}/rows/${this.id}`);
+        await this.handleResponse(response);
+        this._deleted = true;
+    }
+    toJSON() {
+        return Object.assign({}, this._data.data);
+    }
+    toCSVRow(columns, delimiter = ",") {
+        const columnsToUse = columns || this.getColumns();
+        const values = columnsToUse.map((column) => {
+            const value = this._data.data[column];
+            if (value === null || value === undefined) {
+                return "";
+            }
+            const stringValue = String(value);
+            if (stringValue.includes(delimiter) ||
+                stringValue.includes('"') ||
+                stringValue.includes("\n")) {
+                return `"${stringValue.replace(/"/g, '""')}"`;
+            }
+            return stringValue;
+        });
+        return values.join(delimiter);
+    }
+    validate(columnValidators) {
+        const errors = [];
+        if (columnValidators) {
+            Object.keys(columnValidators).forEach((columnName) => {
+                const validator = columnValidators[columnName];
+                const value = this._data.data[columnName];
+                if (!validator(value)) {
+                    errors.push(`Invalid value for column '${columnName}': ${value}`);
+                }
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    clone() {
+        const clonedData = Object.assign(Object.assign({}, this._data), { data: Object.assign({}, this._data.data) });
+        return new Row(this.client, clonedData);
+    }
+    /**
+     * Gets an attachment reference from a column
+     * @param columnName The name of the column containing the attachment
+     * @returns AttachmentReference if the column contains an attachment, null otherwise
+     */
+    getAttachment(columnName) {
+        const value = this._data.data[columnName];
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        // Value is now guaranteed to be an object
+        const objValue = value;
+        // Check if value is already an AttachmentReference
+        if (objValue instanceof AttachmentReference) {
+            return objValue;
+        }
+        // Check if value is a serialized attachment reference
+        if (isAttachmentReference(objValue)) {
+            const ref = objValue;
+            return new AttachmentReference(ref.storageType, ref.storageKey, ref.url, ref.fileType, ref.metadata);
+        }
+        return null;
+    }
+    /**
+     * Checks if a column contains an attachment
+     * @param columnName The name of the column to check
+     */
+    hasAttachment(columnName) {
+        return this.getAttachment(columnName) !== null;
+    }
+    /**
+     * Sets/uploads an attachment to a column
+     * @param columnSlug The slug of the column to set the attachment in
+     * @param attachment The attachment to upload (Attachment or ExternalAttachment)
+     * @returns The created AttachmentReference
+     *
+     * @example
+     * // Upload from file
+     * await row.setAttachment("image", new Attachment({ filePath: "./photo.jpg" }));
+     *
+     * @example
+     * // Set external URL
+     * await row.setAttachment("document", new ExternalAttachment({ url: "https://example.com/doc.pdf" }));
+     */
+    async setAttachment(columnSlug, attachment) {
+        if (this._deleted) {
+            throw new Error("Cannot set attachment on a deleted row");
+        }
+        const uploader = new AttachmentUploader(this.client);
+        const reference = await uploader.processAnyAttachment(this.datasetSlug, this.id, columnSlug, attachment);
+        // Update internal data
+        this._data.data[columnSlug] = reference.toJSON();
+        return reference;
+    }
+    /**
+     * Downloads an attachment from a column
+     * @param columnName The name of the column containing the attachment
+     * @param outputPath Optional file path to save the downloaded file
+     * @returns Buffer if no outputPath provided, void if saved to file
+     *
+     * @example
+     * // Get as buffer
+     * const data = await row.downloadAttachment("image");
+     *
+     * @example
+     * // Save to file
+     * await row.downloadAttachment("image", "./downloaded-image.png");
+     */
+    async downloadAttachment(columnName, outputPath) {
+        if (this._deleted) {
+            throw new Error("Cannot download attachment from a deleted row");
+        }
+        const attachment = this.getAttachment(columnName);
+        if (!attachment) {
+            throw new Error(`No attachment found in column '${columnName}'`);
+        }
+        return attachment.download(outputPath);
+    }
+}
+
+class Column extends BaseDatasetEntity {
+    constructor(client, data) {
+        super(client);
+        this._deleted = false;
+        this._data = data;
+    }
+    get slug() {
+        return this._data.slug;
+    }
+    get name() {
+        return this._data.name;
+    }
+    get type() {
+        return this._data.type;
+    }
+    get required() {
+        return this._data.required || false;
+    }
+    get description() {
+        return this._data.description;
+    }
+    get datasetId() {
+        return this._data.datasetId;
+    }
+    get datasetSlug() {
+        return this._data.datasetSlug;
+    }
+    get createdAt() {
+        return this._data.createdAt;
+    }
+    get updatedAt() {
+        return this._data.updatedAt;
+    }
+    get deleted() {
+        return this._deleted;
+    }
+    async update(options) {
+        if (this._deleted) {
+            throw new Error("Cannot update a deleted column");
+        }
+        if (options.name && typeof options.name !== "string") {
+            throw new Error("Column name must be a string");
+        }
+        if (options.type &&
+            !["string", "number", "boolean", "date", "file"].includes(options.type)) {
+            throw new Error("Column type must be one of: string, number, boolean, date, file");
+        }
+        const response = await this.client.put(`/v2/datasets/${this.datasetSlug}/columns/${this.slug}`, options);
+        const data = await this.handleResponse(response);
+        // API returns dataset data, extract column info if available
+        if (data.columns && data.columns[this.slug]) {
+            const columnData = data.columns[this.slug];
+            // Update only the fields that changed, preserve datasetSlug and other metadata
+            this._data = Object.assign(Object.assign({}, this._data), { name: columnData.name || this._data.name, type: columnData.type || this._data.type, description: columnData.description || this._data.description, updatedAt: data.updatedAt || this._data.updatedAt });
+        }
+    }
+    async delete() {
+        if (this._deleted) {
+            throw new Error("Column is already deleted");
+        }
+        const response = await this.client.delete(`/v2/datasets/${this.datasetSlug}/columns/${this.slug}`);
+        await this.handleResponse(response);
+        this._deleted = true;
+    }
+    validateValue(value) {
+        if (this.required && (value === null || value === undefined)) {
+            return false;
+        }
+        if (value === null || value === undefined) {
+            return true;
+        }
+        switch (this.type) {
+            case "string":
+                return typeof value === "string";
+            case "number":
+                return typeof value === "number" && !isNaN(value) && isFinite(value);
+            case "boolean":
+                return typeof value === "boolean";
+            default:
+                return false;
+        }
+    }
+    convertValue(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        switch (this.type) {
+            case "string":
+                return String(value);
+            case "number": {
+                const numValue = Number(value);
+                return isNaN(numValue) ? null : numValue;
+            }
+            case "boolean":
+                if (typeof value === "boolean")
+                    return value;
+                if (typeof value === "string") {
+                    const lower = value.toLowerCase();
+                    if (lower === "true" || lower === "1")
+                        return true;
+                    if (lower === "false" || lower === "0")
+                        return false;
+                }
+                return Boolean(value);
+            default:
+                return value;
+        }
+    }
+}
+
+class Dataset extends BaseDatasetEntity {
+    constructor(client, data) {
+        super(client);
+        this._deleted = false;
+        this._data = data;
+        this._attachmentUploader = new AttachmentUploader(client);
+    }
+    get id() {
+        return this._data.id;
+    }
+    get slug() {
+        return this._data.slug;
+    }
+    get name() {
+        return this._data.name;
+    }
+    get description() {
+        return this._data.description;
+    }
+    get version() {
+        return this._data.version;
+    }
+    get published() {
+        return this._data.published || false;
+    }
+    get createdAt() {
+        return this._data.createdAt || "";
+    }
+    get updatedAt() {
+        return this._data.updatedAt || "";
+    }
+    get deleted() {
+        return this._deleted;
+    }
+    async update(options) {
+        if (this._deleted) {
+            throw new Error("Cannot update a deleted dataset");
+        }
+        if (options.name) {
+            this.validateDatasetName(options.name);
+        }
+        const response = await this.client.put(`/v2/datasets/${this.slug}`, options);
+        await this.handleResponse(response);
+    }
+    async delete() {
+        if (this._deleted) {
+            throw new Error("Dataset is already deleted");
+        }
+        const response = await this.client.delete(`/v2/datasets/${this.slug}`);
+        await this.handleResponse(response);
+        this._deleted = true;
+    }
+    async publish(options = {}) {
+        if (this._deleted) {
+            throw new Error("Cannot publish a deleted dataset");
+        }
+        const response = await this.client.post(`/v2/datasets/${this.slug}/publish`, options);
+        const data = await this.handleResponse(response);
+        this._data = data;
+    }
+    async addColumn(columns) {
+        if (this._deleted) {
+            throw new Error("Cannot add columns to a deleted dataset");
+        }
+        if (!Array.isArray(columns) || columns.length === 0) {
+            throw new Error("Columns must be a non-empty array");
+        }
+        const results = [];
+        for (const column of columns) {
+            if (!column.name || typeof column.name !== "string") {
+                throw new Error("Column name is required and must be a string");
+            }
+            const response = await this.client.post(`/v2/datasets/${this.slug}/columns`, column);
+            const data = await this.handleResponse(response);
+            if (!data || !data.slug) {
+                throw new Error("Failed to create column: Invalid API response");
+            }
+            const columnResponse = {
+                slug: data.slug,
+                datasetId: this._data.id,
+                datasetSlug: this.slug,
+                name: data.name,
+                type: data.type,
+                required: data.required,
+                description: data.description,
+                createdAt: data.createdAt,
+                updatedAt: data.updatedAt,
+            };
+            results.push(new Column(this.client, columnResponse));
+        }
+        return results;
+    }
+    async getColumns() {
+        if (this._deleted) {
+            throw new Error("Cannot get columns from a deleted dataset");
+        }
+        if (!this._data.columns) {
+            return [];
+        }
+        const columns = [];
+        for (const [columnSlug, columnData] of Object.entries(this._data.columns)) {
+            const col = columnData;
+            const columnResponse = {
+                slug: columnSlug,
+                datasetId: this._data.id,
+                datasetSlug: this.slug,
+                name: col.name,
+                type: col.type,
+                required: col.required === true,
+                description: col.description,
+                createdAt: this._data.createdAt || this.createdAt,
+                updatedAt: this._data.updatedAt || this.updatedAt,
+            };
+            columns.push(new Column(this.client, columnResponse));
+        }
+        return columns;
+    }
+    async addRow(rowData) {
+        if (this._deleted) {
+            throw new Error("Cannot add row to a deleted dataset");
+        }
+        if (!rowData || typeof rowData !== "object") {
+            throw new Error("Row data must be a valid object");
+        }
+        const rows = await this.addRows([rowData]);
+        if (rows.length === 0) {
+            throw new Error("Failed to add row");
+        }
+        return rows[0];
+    }
+    async addRows(rows) {
+        if (this._deleted) {
+            throw new Error("Cannot add rows to a deleted dataset");
+        }
+        if (!Array.isArray(rows)) {
+            throw new Error("Rows must be an array");
+        }
+        const columns = await this.getColumns();
+        const columnMap = new Map();
+        columns.forEach((col) => {
+            columnMap.set(col.name, col.slug);
+        });
+        // Phase 1: Extract attachments and prepare clean rows
+        const { cleanRows, attachmentMap } = this.extractAttachments(rows, columnMap);
+        // Phase 2: Create rows with regular data (attachments replaced with null)
+        const transformedRows = cleanRows.map((row) => {
+            const transformedRow = {};
+            Object.keys(row).forEach((columnName) => {
+                const columnSlug = columnMap.get(columnName);
+                if (columnSlug) {
+                    transformedRow[columnSlug] = row[columnName];
+                }
+            });
+            return transformedRow;
+        });
+        const payload = {
+            Rows: transformedRows,
+        };
+        const response = await this.client.post(`/v2/datasets/${this.slug}/rows`, payload);
+        const result = await this.handleResponse(response);
+        const createdRows = [];
+        if (result.rows) {
+            for (const row of result.rows) {
+                const rowResponse = {
+                    id: row.id,
+                    datasetId: this._data.id,
+                    datasetSlug: this.slug,
+                    data: this.transformValuesBackToNames(row.values, columnMap),
+                    createdAt: row.created_at,
+                    updatedAt: row.updated_at,
+                };
+                createdRows.push(new Row(this.client, rowResponse));
+            }
+        }
+        // Phase 3: Process attachments for created rows
+        if (attachmentMap.size > 0) {
+            await this.processAttachments(createdRows, attachmentMap, columnMap);
+        }
+        return createdRows;
+    }
+    /**
+     * Extracts attachments from rows and returns clean rows with null values
+     */
+    extractAttachments(rows, columnMap) {
+        const attachmentMap = new Map();
+        const cleanRows = [];
+        rows.forEach((row, rowIndex) => {
+            const cleanRow = {};
+            const rowAttachments = new Map();
+            Object.keys(row).forEach((columnName) => {
+                const value = row[columnName];
+                const columnSlug = columnMap.get(columnName);
+                if (isAnyAttachment(value) && columnSlug) {
+                    // Store attachment for later processing
+                    rowAttachments.set(columnSlug, value);
+                    // Replace with null in the clean row
+                    cleanRow[columnName] = null;
+                }
+                else {
+                    cleanRow[columnName] = value;
+                }
+            });
+            cleanRows.push(cleanRow);
+            if (rowAttachments.size > 0) {
+                attachmentMap.set(rowIndex, rowAttachments);
+            }
+        });
+        return { cleanRows, attachmentMap };
+    }
+    /**
+     * Processes attachments for created rows
+     */
+    async processAttachments(rows, attachmentMap, columnMap) {
+        // Create reverse map for slug to name lookup
+        const reverseColumnMap = new Map();
+        columnMap.forEach((slug, name) => {
+            reverseColumnMap.set(slug, name);
+        });
+        for (const [rowIndex, rowAttachments] of attachmentMap) {
+            const row = rows[rowIndex];
+            if (!row)
+                continue;
+            for (const [columnSlug, attachment] of rowAttachments) {
+                try {
+                    const reference = await this._attachmentUploader.processAnyAttachment(this.slug, row.id, columnSlug, attachment);
+                    // Update the row's internal data with the attachment reference
+                    const columnName = reverseColumnMap.get(columnSlug);
+                    if (columnName) {
+                        row._data.data[columnName] = reference.toJSON();
+                    }
+                }
+                catch (error) {
+                    // Log warning but don't fail the entire operation
+                    console.warn(`Failed to process attachment for row ${row.id}, column ${columnSlug}:`, error);
+                }
+            }
+        }
+    }
+    transformValuesBackToNames(values, columnMap) {
+        const result = {};
+        const reverseMap = new Map();
+        columnMap.forEach((slug, name) => {
+            reverseMap.set(slug, name);
+        });
+        Object.keys(values).forEach((columnSlug) => {
+            const columnName = reverseMap.get(columnSlug);
+            if (columnName) {
+                result[columnName] = values[columnSlug];
+            }
+        });
+        return result;
+    }
+    async getRows(limit = 100, offset = 0) {
+        if (this._deleted) {
+            throw new Error("Cannot get rows from a deleted dataset");
+        }
+        const response = await this.client.get(`/v2/datasets/${this.slug}/rows?limit=${limit}&offset=${offset}`);
+        const data = await this.handleResponse(response);
+        const rows = data.rows || [];
+        return rows.map((row) => {
+            const rowResponse = {
+                id: row.id,
+                datasetId: this._data.id,
+                datasetSlug: this.slug,
+                data: row.values || row.data || {},
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+            };
+            return new Row(this.client, rowResponse);
+        });
+    }
+    async fromCSV(csvContent, options = {}) {
+        if (this._deleted) {
+            throw new Error("Cannot import CSV to a deleted dataset");
+        }
+        const { hasHeader = true, delimiter = "," } = options;
+        if (!csvContent || typeof csvContent !== "string") {
+            throw new Error("CSV content must be a valid string");
+        }
+        const rows = this.parseCSV(csvContent, delimiter, hasHeader);
+        if (rows.length === 0) {
+            throw new Error("No data found in CSV");
+        }
+        const batchSize = 100;
+        for (let i = 0; i < rows.length; i += batchSize) {
+            const batch = rows.slice(i, i + batchSize);
+            await this.addRows(batch);
+        }
+    }
+    async getVersions() {
+        if (this._deleted) {
+            throw new Error("Cannot get versions of a deleted dataset");
+        }
+        const response = await this.client.get(`/v2/datasets/${this.slug}/versions`);
+        return await this.handleResponse(response);
+    }
+    async getVersion(version) {
+        if (this._deleted) {
+            throw new Error("Cannot get version of a deleted dataset");
+        }
+        const versionsData = await this.getVersions();
+        return versionsData.versions.find((v) => v.version === version) || null;
+    }
+    parseCSV(csvContent, delimiter, hasHeader) {
+        const parseResult = Papa__namespace.parse(csvContent, {
+            delimiter,
+            header: hasHeader,
+            skipEmptyLines: true,
+            transformHeader: (header) => header.trim(),
+            transform: (value) => this.parseValue(value.trim()),
+        });
+        if (parseResult.errors.length > 0) {
+            throw new Error(`CSV parsing failed: ${parseResult.errors[0].message}`);
+        }
+        return parseResult.data;
+    }
+    parseValue(value) {
+        if (value === "" || value.toLowerCase() === "null") {
+            return null;
+        }
+        if (value.toLowerCase() === "true") {
+            return true;
+        }
+        if (value.toLowerCase() === "false") {
+            return false;
+        }
+        const numValue = Number(value);
+        if (!isNaN(numValue) && isFinite(numValue)) {
+            return numValue;
+        }
+        return value;
+    }
+}
+
+class Datasets extends BaseDatasetEntity {
+    constructor(client) {
+        super(client);
+    }
+    async create(options) {
+        this.validateDatasetName(options.name);
+        const response = await this.client.post("/v2/datasets", options);
+        const data = await this.handleResponse(response);
+        return new Dataset(this.client, data);
+    }
+    async get(slug) {
+        this.validateDatasetSlug(slug);
+        const response = await this.client.get(`/v2/datasets/${slug}`);
+        const data = await this.handleResponse(response);
+        return new Dataset(this.client, data);
+    }
+    async list() {
+        const response = await this.client.get(`/v2/datasets`);
+        const data = await this.handleResponse(response);
+        if (!data || !data.datasets) {
+            return {
+                datasets: [],
+                total: 0,
+            };
+        }
+        const datasets = data.datasets.map((datasetData) => new Dataset(this.client, datasetData));
+        return Object.assign(Object.assign({}, data), { datasets });
+    }
+    async delete(slug) {
+        this.validateDatasetSlug(slug);
+        const response = await this.client.delete(`/v2/datasets/${slug}`);
+        await this.handleResponse(response);
+    }
+    async getVersionCSV(slug, version) {
+        this.validateDatasetSlug(slug);
+        if (!version || typeof version !== "string") {
+            throw new Error("Version must be a non-empty string");
+        }
+        const response = await this.client.get(`/v2/datasets/${slug}/versions/${version}`);
+        const csvData = await this.handleResponse(response);
+        if (typeof csvData !== "string") {
+            throw new Error("Expected CSV data as string from API");
+        }
+        return csvData;
+    }
+    async getVersionAsJsonl(slug, version) {
+        if (!version || version === "") {
+            throw new Error("Version is required");
+        }
+        const url = `/v2/datasets/${slug}/versions/${version}/jsonl`;
+        const response = await this.client.get(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch JSONL data: ${response.status} ${response.statusText}`);
+        }
+        const contentType = response.headers.get("content-type");
+        if (contentType && contentType.includes("application/json")) {
+            // If server returns JSON, handle it appropriately
+            const jsonData = await response.json();
+            if (jsonData.error) {
+                throw new Error(jsonData.error);
+            }
+            // Convert JSON response to JSONL format if needed
+            if (Array.isArray(jsonData)) {
+                return jsonData.map((item) => JSON.stringify(item)).join("\n");
+            }
+            return JSON.stringify(jsonData);
+        }
+        // Expect JSONL format (text/plain or application/jsonl)
+        return await response.text();
+    }
+}
+
+class Evaluator extends BaseDatasetEntity {
+    constructor(client) {
+        super(client);
+    }
+    /**
+     * Run evaluators on experiment task results and wait for completion
+     */
+    async runExperimentEvaluator(options) {
+        const { experimentId, experimentRunId, taskId, taskResult, evaluator, waitForResults = true, } = options;
+        this.validateEvaluatorOptions(options);
+        const triggerResponse = await this.triggerExperimentEvaluator({
+            experimentId,
+            experimentRunId,
+            taskId,
+            evaluator,
+            taskResult,
+        });
+        if (!waitForResults) {
+            return [
+                {
+                    executionId: triggerResponse.executionId,
+                    result: { status: "running", startedAt: new Date().toISOString() },
+                },
+            ];
+        }
+        return this.waitForResult(triggerResponse.executionId, triggerResponse.streamUrl);
+    }
+    /**
+     * Trigger evaluator execution without waiting for results
+     */
+    async triggerExperimentEvaluator(request) {
+        const { experimentId, experimentRunId, taskId, evaluator, taskResult } = request;
+        if (!experimentId || !taskResult) {
+            throw new Error("experimentId, evaluator, and taskResult are required");
+        }
+        // Handle string, EvaluatorWithVersion, and EvaluatorWithConfig types
+        const evaluatorName = typeof evaluator === "string" ? evaluator : evaluator.name;
+        const evaluatorVersion = typeof evaluator === "string" ? undefined : evaluator.version;
+        // Extract config if present (EvaluatorWithConfig type)
+        const evaluatorConfig = typeof evaluator === "object" && "config" in evaluator
+            ? evaluator.config
+            : undefined;
+        if (!evaluatorName) {
+            throw new Error("evaluator name is required");
+        }
+        const inputSchemaMapping = this.createInputSchemaMapping(taskResult);
+        const payload = {
+            experiment_id: experimentId,
+            experiment_run_id: experimentRunId,
+            evaluator_version: evaluatorVersion,
+            task_id: taskId,
+            input_schema_mapping: inputSchemaMapping,
+        };
+        // Add evaluator config if present
+        if (evaluatorConfig && Object.keys(evaluatorConfig).length > 0) {
+            payload.evaluator_config = evaluatorConfig;
+        }
+        const response = await this.client.post(`/v2/evaluators/slug/${evaluatorName}/execute`, payload);
+        const data = await this.handleResponse(response);
+        return {
+            executionId: data.executionId,
+            streamUrl: data.streamUrl,
+        };
+    }
+    /**
+     * Wait for execution result via stream URL (actually JSON endpoint)
+     */
+    async waitForResult(executionId, streamUrl) {
+        if (!executionId || !streamUrl) {
+            throw new Error("Execution ID and stream URL are required");
+        }
+        const fullStreamUrl = `${this.client["baseUrl"]}/v2${streamUrl}`;
+        try {
+            const response = await fetch(fullStreamUrl, {
+                headers: {
+                    Authorization: `Bearer ${this.client["apiKey"]}`,
+                    Accept: "application/json",
+                    "Cache-Control": "no-cache",
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Failed to get results: ${response.status}, body: ${errorText}`);
+            }
+            const responseText = await response.text();
+            const responseData = JSON.parse(responseText);
+            // Check execution ID match
+            if (responseData.execution_id &&
+                responseData.execution_id !== executionId) {
+                throw new Error(`Execution ID mismatch: ${responseData.execution_id} !== ${executionId}`);
+            }
+            // Convert to ExecutionResponse format
+            const executionResponse = {
+                executionId: responseData.execution_id,
+                result: responseData.result,
+            };
+            return [executionResponse];
+        }
+        catch (error) {
+            throw new Error(`Failed to wait for result: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Validate evaluator run options
+     */
+    validateEvaluatorOptions(options) {
+        const { experimentId, evaluator, taskResult } = options;
+        if (!experimentId ||
+            typeof experimentId !== "string" ||
+            experimentId.trim().length === 0) {
+            throw new Error("Experiment ID is required and must be a non-empty string");
+        }
+        if (!evaluator) {
+            throw new Error("At least one evaluator must be specified");
+        }
+        if (!taskResult) {
+            throw new Error("At least one task result must be provided");
+        }
+        // Validate evaluator based on its type
+        if (typeof evaluator === "string") {
+            if (!evaluator.trim()) {
+                throw new Error("Evaluator name cannot be empty");
+            }
+        }
+        else {
+            if (!evaluator.name ||
+                typeof evaluator.name !== "string" ||
+                !evaluator.name.trim()) {
+                throw new Error("Evaluator must have a valid name");
+            }
+        }
+        // Validate each task result
+        if (!taskResult || typeof taskResult !== "object") {
+            throw new Error(`Task result must be a valid object`);
+        }
+    }
+    /**
+     * Create InputSchemaMapping from input object
+     */
+    createInputSchemaMapping(input) {
+        const mapping = {};
+        for (const [key, value] of Object.entries(input)) {
+            mapping[key] = { source: String(value) };
+        }
+        return mapping;
+    }
+}
+
+class Experiment {
+    constructor(client) {
+        this.client = client;
+        this.evaluator = new Evaluator(client);
+        this.datasets = new Datasets(client);
+    }
+    /**
+     * Generate a unique experiment slug
+     */
+    generateExperimentSlug() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 7);
+        return `exp-${timestamp}${random}`.substring(0, 15);
+    }
+    async handleResponse(response) {
+        if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+            try {
+                const errorData = await response.json();
+                if (errorData.error) {
+                    errorMessage = errorData.error;
+                }
+            }
+            catch (_a) {
+                // Use default HTTP error message if JSON parsing fails
+            }
+            throw new Error(errorMessage);
+        }
+        const contentType = (response.headers.get("content-type") || "").toLowerCase();
+        if (contentType.includes("text/csv") ||
+            contentType.includes("application/x-ndjson")) {
+            return await response.text();
+        }
+        else {
+            const rawData = await response.json();
+            return transformApiResponse(rawData);
+        }
+    }
+    /**
+     * Run an experiment with the given task function and options
+     */
+    async run(task, options = {}) {
+        // Check if running in GitHub Actions
+        if (process.env.GITHUB_ACTIONS === "true") {
+            return await this.runInGithub(task, options);
+        }
+        return await this.runLocally(task, options);
+    }
+    /**
+     * Run an experiment locally (not in GitHub Actions)
+     */
+    async runLocally(task, options = {}) {
+        const { datasetSlug, datasetVersion, evaluators = [], waitForResults = true, } = options;
+        // When experimentSlug is not provided a random one is generated
+        let { experimentSlug } = options;
+        if (!experimentSlug) {
+            experimentSlug =
+                this.client.experimentSlug || this.generateExperimentSlug();
+        }
+        this.validateRunOptions(task, options);
+        try {
+            const evaluatorSlugs = evaluators.map((evaluator) => typeof evaluator === "string" ? evaluator : evaluator.name);
+            const experimentResponse = await this.initializeExperiment({
+                slug: experimentSlug,
+                datasetSlug,
+                datasetVersion,
+                evaluatorSlugs,
+            });
+            const rows = await this.getDatasetRows(datasetSlug, datasetVersion);
+            const taskResults = [];
+            const taskErrors = [];
+            const evaluationResults = [];
+            for (const row of rows) {
+                const taskOutput = await task(row);
+                // Create TaskResponse object
+                const taskResponse = {
+                    input: row,
+                    output: taskOutput,
+                    metadata: {
+                        rowId: row.id,
+                        timestamp: Date.now(),
+                    },
+                    timestamp: Date.now(),
+                };
+                taskResults.push(taskResponse);
+                const response = await this.createTask(experimentSlug, experimentResponse.run.id, row, taskOutput);
+                const taskId = response.id;
+                if (evaluators.length > 0) {
+                    for (const evaluator of evaluators) {
+                        const singleEvaluationResult = await this.evaluator.runExperimentEvaluator({
+                            experimentId: experimentResponse.experiment.id,
+                            experimentRunId: experimentResponse.run.id,
+                            taskId,
+                            evaluator,
+                            taskResult: taskOutput,
+                            waitForResults,
+                            timeout: 120000, // 2 minutes default
+                        });
+                        evaluationResults.push(...singleEvaluationResult);
+                    }
+                }
+            }
+            const evalResults = evaluationResults.map((evaluation) => evaluation.result);
+            // Track last experiment slug and run ID for export methods
+            this._lastExperimentSlug = experimentSlug;
+            this._lastRunId = experimentResponse.run.id;
+            return {
+                taskResults: taskResults,
+                errors: taskErrors,
+                experimentId: experimentResponse.experiment.id,
+                runId: experimentResponse.run.id,
+                evaluations: evalResults,
+            };
+        }
+        catch (error) {
+            throw new Error(`Experiment execution failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Create a task for the experiment
+     */
+    async createTask(experimentSlug, experimentRunId, taskInput, taskOutput) {
+        const body = {
+            input: taskInput,
+            output: taskOutput,
+        };
+        const response = await this.client.post(`/v2/experiments/${experimentSlug}/runs/${experimentRunId}/task`, body);
+        if (!response.ok) {
+            throw new Error(`Failed to create task for experiment '${experimentSlug}'`);
+        }
+        const data = await this.handleResponse(response);
+        return {
+            id: data.id,
+        };
+    }
+    /**
+     * Initialize a new experiment
+     */
+    async initializeExperiment(request) {
+        if (request.aux) {
+            request.experimentRunMetadata = Object.assign(Object.assign({}, request.experimentRunMetadata), { aux: request.aux });
+        }
+        if (request.relatedRef) {
+            request.experimentRunMetadata = Object.assign(Object.assign({}, request.experimentRunMetadata), { related_ref: request.relatedRef });
+        }
+        const payload = {
+            slug: request.slug,
+            dataset_slug: request.datasetSlug,
+            dataset_version: request.datasetVersion,
+            evaluator_slugs: request.evaluatorSlugs,
+            experiment_metadata: request.experimentMetadata,
+            experiment_run_metadata: request.experimentRunMetadata,
+        };
+        const response = await this.client.put("/v2/experiments/initialize", payload);
+        const data = await this.handleResponse(response);
+        return data;
+    }
+    /**
+     * Parse JSONL string into list of {col_name: col_value} dictionaries
+     * Skips the first line (columns definition)
+     */
+    parseJsonlToRows(jsonlData) {
+        const rows = [];
+        const lines = jsonlData.trim().split("\n");
+        // Skip the first line (columns definition)
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line) {
+                try {
+                    const rowData = JSON.parse(line);
+                    rows.push(rowData);
+                }
+                catch (_a) {
+                    // Skip invalid JSON lines
+                    continue;
+                }
+            }
+        }
+        return rows;
+    }
+    /**
+     * Get dataset rows for experiment execution
+     */
+    async getDatasetRows(datasetSlug, datasetVersion) {
+        if (!datasetSlug) {
+            throw new Error("Dataset slug is required for experiment execution");
+        }
+        const dataset = await this.datasets.getVersionAsJsonl(datasetSlug, datasetVersion || "");
+        const rows = this.parseJsonlToRows(dataset);
+        return rows;
+    }
+    /**
+     * Validate experiment run options
+     */
+    validateRunOptions(task, options) {
+        if (!task || typeof task !== "function") {
+            throw new Error("Task function is required and must be a function");
+        }
+        if (options.evaluators) {
+            options.evaluators.forEach((evaluator, index) => {
+                if (typeof evaluator === "string") {
+                    if (!evaluator.trim()) {
+                        throw new Error(`Evaluator at index ${index} cannot be an empty string`);
+                    }
+                }
+                else {
+                    if (!evaluator || typeof evaluator !== "object") {
+                        throw new Error(`Evaluator at index ${index} must be a string or object with name and version`);
+                    }
+                    if (!evaluator.name ||
+                        typeof evaluator.name !== "string" ||
+                        !evaluator.name.trim()) {
+                        throw new Error(`Evaluator at index ${index} must have a valid non-empty name`);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Extract GitHub Actions context from environment variables
+     */
+    getGithubContext() {
+        const repository = process.env.GITHUB_REPOSITORY;
+        const ref = process.env.GITHUB_REF;
+        const sha = process.env.GITHUB_SHA;
+        const actor = process.env.GITHUB_ACTOR;
+        if (!repository || !ref || !sha || !actor) {
+            throw new Error("Missing required GitHub environment variables: GITHUB_REPOSITORY, GITHUB_REF, GITHUB_SHA, or GITHUB_ACTOR");
+        }
+        // Extract PR number from ref (e.g., refs/pull/123/merge -> 123)
+        const prMatch = ref.match(/refs\/pull\/(\d+)\//);
+        const prNumber = prMatch ? prMatch[1] : null;
+        if (!prNumber) {
+            throw new Error(`This method can only be run on pull request events. Current ref: ${ref}`);
+        }
+        const prUrl = `https://github.com/${repository}/pull/${prNumber}`;
+        return {
+            repository,
+            prUrl,
+            commitHash: sha,
+            actor,
+        };
+    }
+    /**
+     * Execute tasks locally and capture results
+     */
+    async executeTasksLocally(task, rows) {
+        return await Promise.all(rows.map(async (row) => {
+            try {
+                const output = await task(row);
+                return {
+                    input: row,
+                    output: output,
+                    metadata: {
+                        rowId: row.id,
+                        timestamp: Date.now(),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    input: row,
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: {
+                        rowId: row.id,
+                        timestamp: Date.now(),
+                    },
+                };
+            }
+        }));
+    }
+    /**
+     * Run an experiment in GitHub Actions environment
+     * This method executes tasks locally and submits results to the backend for evaluation
+     */
+    async runInGithub(task, options) {
+        const { datasetSlug, datasetVersion, evaluators = [], experimentMetadata, experimentRunMetadata, relatedRef, aux, } = options;
+        // Generate or use provided experiment slug
+        let { experimentSlug } = options;
+        if (!experimentSlug) {
+            experimentSlug =
+                this.client.experimentSlug || this.generateExperimentSlug();
+        }
+        if (!task || typeof task !== "function") {
+            throw new Error("Task function is required and must be a function");
+        }
+        try {
+            const githubContext = this.getGithubContext();
+            const rows = await this.getDatasetRows(datasetSlug, datasetVersion);
+            const taskResults = await this.executeTasksLocally(task, rows);
+            // Prepare evaluator slugs
+            const evaluatorSlugs = evaluators.map((evaluator) => typeof evaluator === "string" ? evaluator : evaluator.name);
+            const mergedExperimentMetadata = Object.assign(Object.assign({}, (experimentMetadata || {})), { created_from: "github" });
+            const mergedExperimentRunMetadata = Object.assign(Object.assign(Object.assign({}, (experimentRunMetadata || {})), (relatedRef && { related_ref: relatedRef })), (aux && { aux: aux }));
+            // Submit to backend
+            const payload = {
+                experiment_slug: experimentSlug,
+                dataset_slug: datasetSlug,
+                dataset_version: datasetVersion,
+                evaluator_slugs: evaluatorSlugs,
+                task_results: taskResults,
+                github_context: {
+                    repository: githubContext.repository,
+                    pr_url: githubContext.prUrl,
+                    commit_hash: githubContext.commitHash,
+                    actor: githubContext.actor,
+                },
+                experiment_metadata: mergedExperimentMetadata,
+                experiment_run_metadata: mergedExperimentRunMetadata,
+            };
+            const response = await this.client.post("/v2/experiments/run-in-github", payload);
+            const data = await this.handleResponse(response);
+            // Track last experiment slug and run ID for export methods
+            this._lastExperimentSlug = data.experimentSlug;
+            this._lastRunId = data.runId;
+            return data;
+        }
+        catch (error) {
+            throw new Error(`GitHub experiment execution failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Resolve export parameters by falling back to last used values
+     */
+    resolveExportParams(experimentSlug, runId) {
+        const slug = experimentSlug || this._lastExperimentSlug;
+        const rid = runId || this._lastRunId;
+        if (!slug) {
+            throw new Error("experiment_slug is required");
+        }
+        if (!rid) {
+            throw new Error("run_id is required");
+        }
+        return { slug, runId: rid };
+    }
+    /**
+     * Export experiment results as CSV string
+     * @param experimentSlug - Optional experiment slug (uses last run if not provided)
+     * @param runId - Optional run ID (uses last run if not provided)
+     * @returns CSV string of experiment results
+     */
+    async toCsvString(experimentSlug, runId) {
+        const { slug, runId: rid } = this.resolveExportParams(experimentSlug, runId);
+        const response = await this.client.get(`/v2/experiments/${slug}/runs/${rid}/export/csv`);
+        if (!response.ok) {
+            throw new Error(`Failed to export CSV for experiment '${slug}' run '${rid}'`);
+        }
+        const result = await this.handleResponse(response);
+        if (result === null || result === undefined) {
+            throw new Error(`Failed to export CSV for experiment '${slug}' run '${rid}'`);
+        }
+        return String(result);
+    }
+    /**
+     * Export experiment results as JSON string
+     * @param experimentSlug - Optional experiment slug (uses last run if not provided)
+     * @param runId - Optional run ID (uses last run if not provided)
+     * @returns JSON string of experiment results
+     */
+    async toJsonString(experimentSlug, runId) {
+        const { slug, runId: rid } = this.resolveExportParams(experimentSlug, runId);
+        const response = await this.client.get(`/v2/experiments/${slug}/runs/${rid}/export/json`);
+        if (!response.ok) {
+            throw new Error(`Failed to export JSON for experiment '${slug}' run '${rid}'`);
+        }
+        const result = await this.handleResponse(response);
+        if (result === null || result === undefined) {
+            throw new Error(`Failed to export JSON for experiment '${slug}' run '${rid}'`);
+        }
+        // If result is already a string, return it; otherwise stringify it
+        return typeof result === "string" ? result : JSON.stringify(result);
+    }
+}
+
+/**
+ * The main client for interacting with Traceloop's API.
+ * This client can be used either directly or through the singleton pattern via configuration.
+ *
+ * @example
+ * // Direct usage
+ * const client = new TraceloopClient('your-api-key');
+ *
+ * @example
+ * // Through configuration (recommended)
+ * initialize({ apiKey: 'your-api-key', appName: 'your-app' });
+ * const client = getClient();
+ */
+class TraceloopClient {
+    /**
+     * Creates a new instance of the TraceloopClient.
+     *
+     * @param options - Configuration options for the client
+     */
+    constructor(options) {
+        this.version = version;
+        this.apiKey = options.apiKey;
+        this.appName = options.appName;
+        this.baseUrl =
+            options.baseUrl ||
+                process.env.ANYWAY_BASE_URL ||
+                "https://api.traceloop.com";
+        this.experimentSlug = options.experimentSlug;
+        this.userFeedback = new UserFeedback(this);
+        this.datasets = new Datasets(this);
+        this.experiment = new Experiment(this);
+        this.evaluator = new Evaluator(this);
+    }
+    async post(path, body) {
+        return await fetch(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+                "X-Traceloop-SDK-Version": this.version,
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    async get(path) {
+        return await fetch(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "X-Traceloop-SDK-Version": this.version,
+            },
+        });
+    }
+    async put(path, body) {
+        return await fetch(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+                "X-Traceloop-SDK-Version": this.version,
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    async delete(path) {
+        return await fetch(`${this.baseUrl}${path}`, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "X-Traceloop-SDK-Version": this.version,
+            },
+        });
+    }
+}
+
+// Auto-generated - DO NOT EDIT
+// Regenerate with: pnpm generate:evaluator-models
+const EVALUATOR_SLUGS = [
+    'agent-efficiency',
+    'agent-flow-quality',
+    'agent-goal-accuracy',
+    'agent-goal-completeness',
+    'agent-tool-error-detector',
+    'agent-tool-trajectory',
+    'answer-completeness',
+    'answer-correctness',
+    'answer-relevancy',
+    'char-count',
+    'char-count-ratio',
+    'context-relevance',
+    'conversation-quality',
+    'faithfulness',
+    'html-comparison',
+    'instruction-adherence',
+    'intent-change',
+    'json-validator',
+    'perplexity',
+    'pii-detector',
+    'placeholder-regex',
+    'profanity-detector',
+    'prompt-injection',
+    'prompt-perplexity',
+    'regex-validator',
+    'secrets-detector',
+    'semantic-similarity',
+    'sexism-detector',
+    'sql-validator',
+    'tone-detection',
+    'topic-adherence',
+    'toxicity-detector',
+    'uncertainty-detector',
+    'word-count',
+    'word-count-ratio',
+];
+const EVALUATOR_SCHEMAS = {
+    'agent-efficiency': {
+        slug: 'agent-efficiency',
+        requiredInputFields: ['trajectory_completions', 'trajectory_prompts'],
+        optionalConfigFields: [],
+        description: "Evaluate agent efficiency - detect redundant calls, unnecessary follow-ups\n\n**Request Body:**\n- `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory\n- `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory",
+    },
+    'agent-flow-quality': {
+        slug: 'agent-flow-quality',
+        requiredInputFields: ['trajectory_completions', 'trajectory_prompts'],
+        optionalConfigFields: ['conditions', 'threshold'],
+        description: "Validate agent trajectory against user-defined conditions\n\n**Request Body:**\n- `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory\n- `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory\n- `config.conditions` (array of strings, required): Array of evaluation conditions/rules to validate against\n- `config.threshold` (number, required): Score threshold for pass/fail determination (0.0-1.0)",
+    },
+    'agent-goal-accuracy': {
+        slug: 'agent-goal-accuracy',
+        requiredInputFields: ['completion', 'question', 'reference'],
+        optionalConfigFields: [],
+        description: "Evaluate agent goal accuracy\n\n**Request Body:**\n- `input.question` (string, required): The original question or goal\n- `input.completion` (string, required): The agent's completion/response\n- `input.reference` (string, required): The expected reference answer",
+    },
+    'agent-goal-completeness': {
+        slug: 'agent-goal-completeness',
+        requiredInputFields: ['trajectory_completions', 'trajectory_prompts'],
+        optionalConfigFields: ['threshold'],
+        description: "Measure if agent accomplished all user goals\n\n**Request Body:**\n- `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory\n- `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory\n- `config.threshold` (number, required): Score threshold for pass/fail determination (0.0-1.0)",
+    },
+    'agent-tool-error-detector': {
+        slug: 'agent-tool-error-detector',
+        requiredInputFields: ['tool_input', 'tool_output'],
+        optionalConfigFields: [],
+        description: "Detect errors or failures during tool execution\n\n**Request Body:**\n- `input.tool_input` (string, required): JSON string of the tool input\n- `input.tool_output` (string, required): JSON string of the tool output",
+    },
+    'agent-tool-trajectory': {
+        slug: 'agent-tool-trajectory',
+        requiredInputFields: ['executed_tool_calls', 'expected_tool_calls'],
+        optionalConfigFields: ['input_params_sensitive', 'mismatch_sensitive', 'order_sensitive', 'threshold'],
+        description: "Compare actual tool calls against expected reference tool calls\n\n**Request Body:**\n- `input.executed_tool_calls` (string, required): JSON array of actual tool calls made by the agent\n- `input.expected_tool_calls` (string, required): JSON array of expected/reference tool calls\n- `config.threshold` (float, optional): Score threshold for pass/fail determination (default: 0.5)\n- `config.mismatch_sensitive` (bool, optional): Whether tool calls must match exactly (default: false)\n- `config.order_sensitive` (bool, optional): Whether order of tool calls matters (default: false)\n- `config.input_params_sensitive` (bool, optional): Whether to compare input parameters (default: true)",
+    },
+    'answer-completeness': {
+        slug: 'answer-completeness',
+        requiredInputFields: ['completion', 'context', 'question'],
+        optionalConfigFields: [],
+        description: "Evaluate whether the answer is complete and contains all the necessary information\n\n**Request Body:**\n- `input.question` (string, required): The original question\n- `input.completion` (string, required): The completion to evaluate for completeness\n- `input.context` (string, required): The context that provides the complete information",
+    },
+    'answer-correctness': {
+        slug: 'answer-correctness',
+        requiredInputFields: ['completion', 'ground_truth', 'question'],
+        optionalConfigFields: [],
+        description: "Evaluate factual accuracy by comparing answers against ground truth\n\n**Request Body:**\n- `input.question` (string, required): The original question\n- `input.completion` (string, required): The completion to evaluate\n- `input.ground_truth` (string, required): The expected correct answer",
+    },
+    'answer-relevancy': {
+        slug: 'answer-relevancy',
+        requiredInputFields: ['answer', 'question'],
+        optionalConfigFields: [],
+        description: "Check if an answer is relevant to a question\n\n**Request Body:**\n- `input.answer` (string, required): The answer to evaluate for relevancy\n- `input.question` (string, required): The question that the answer should be relevant to",
+    },
+    'char-count': {
+        slug: 'char-count',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Count the number of characters in text\n\n**Request Body:**\n- `input.text` (string, required): The text to count characters in",
+    },
+    'char-count-ratio': {
+        slug: 'char-count-ratio',
+        requiredInputFields: ['denominator_text', 'numerator_text'],
+        optionalConfigFields: [],
+        description: "Calculate the ratio of characters between two texts\n\n**Request Body:**\n- `input.numerator_text` (string, required): The numerator text (will be divided by denominator)\n- `input.denominator_text` (string, required): The denominator text (divides the numerator)",
+    },
+    'context-relevance': {
+        slug: 'context-relevance',
+        requiredInputFields: ['context', 'query'],
+        optionalConfigFields: ['model'],
+        description: "Evaluate whether retrieved context contains sufficient information to answer the query\n\n**Request Body:**\n- `input.query` (string, required): The query/question to evaluate context relevance for\n- `input.context` (string, required): The context to evaluate for relevance to the query\n- `config.model` (string, optional): Model to use for evaluation (default: gpt-4o)",
+    },
+    'conversation-quality': {
+        slug: 'conversation-quality',
+        requiredInputFields: ['completions', 'prompts'],
+        optionalConfigFields: [],
+        description: "Evaluate conversation quality based on tone, clarity, flow, responsiveness, and transparency\n\n**Request Body:**\n- `input.prompts` (string, required): JSON array of prompts in the conversation\n- `input.completions` (string, required): JSON array of completions in the conversation",
+    },
+    'faithfulness': {
+        slug: 'faithfulness',
+        requiredInputFields: ['completion', 'context', 'question'],
+        optionalConfigFields: [],
+        description: "Check if a completion is faithful to the provided context\n\n**Request Body:**\n- `input.completion` (string, required): The LLM completion to check for faithfulness\n- `input.context` (string, required): The context that the completion should be faithful to\n- `input.question` (string, required): The original question asked",
+    },
+    'html-comparison': {
+        slug: 'html-comparison',
+        requiredInputFields: ['html1', 'html2'],
+        optionalConfigFields: [],
+        description: "Compare two HTML documents for structural and content similarity\n\n**Request Body:**\n- `input.html1` (string, required): The first HTML document to compare\n- `input.html2` (string, required): The second HTML document to compare",
+    },
+    'instruction-adherence': {
+        slug: 'instruction-adherence',
+        requiredInputFields: ['instructions', 'response'],
+        optionalConfigFields: [],
+        description: "Evaluate how well responses follow given instructions\n\n**Request Body:**\n- `input.instructions` (string, required): The instructions that should be followed\n- `input.response` (string, required): The response to evaluate for instruction adherence",
+    },
+    'intent-change': {
+        slug: 'intent-change',
+        requiredInputFields: ['completions', 'prompts'],
+        optionalConfigFields: [],
+        description: "Detect changes in user intent between prompts and completions\n\n**Request Body:**\n- `input.prompts` (string, required): JSON array of prompts in the conversation\n- `input.completions` (string, required): JSON array of completions in the conversation",
+    },
+    'json-validator': {
+        slug: 'json-validator',
+        requiredInputFields: ['text'],
+        optionalConfigFields: ['enable_schema_validation', 'schema_string'],
+        description: "Validate JSON syntax\n\n**Request Body:**\n- `input.text` (string, required): The text to validate as JSON\n- `config.enable_schema_validation` (bool, optional): Enable JSON schema validation\n- `config.schema_string` (string, optional): JSON schema to validate against",
+    },
+    'perplexity': {
+        slug: 'perplexity',
+        requiredInputFields: ['logprobs'],
+        optionalConfigFields: [],
+        description: "Measure text perplexity from logprobs\n\n**Request Body:**\n- `input.logprobs` (string, required): JSON array of log probabilities from the model",
+    },
+    'pii-detector': {
+        slug: 'pii-detector',
+        requiredInputFields: ['text'],
+        optionalConfigFields: ['probability_threshold'],
+        description: "Detect personally identifiable information in text\n\n**Request Body:**\n- `input.text` (string, required): The text to scan for personally identifiable information\n- `config.probability_threshold` (float, optional): Detection threshold (default: 0.8)",
+    },
+    'placeholder-regex': {
+        slug: 'placeholder-regex',
+        requiredInputFields: ['placeholder_value', 'text'],
+        optionalConfigFields: ['case_sensitive', 'dot_include_nl', 'multi_line', 'should_match'],
+        description: "Validate text against a placeholder regex pattern\n\n**Request Body:**\n- `input.placeholder_value` (string, required): The regex pattern to match against\n- `input.text` (string, required): The text to validate against the regex pattern\n- `config.should_match` (bool, optional): Whether the text should match the regex\n- `config.case_sensitive` (bool, optional): Case-sensitive matching\n- `config.dot_include_nl` (bool, optional): Dot matches newlines\n- `config.multi_line` (bool, optional): Multi-line mode",
+    },
+    'profanity-detector': {
+        slug: 'profanity-detector',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Detect profanity in text\n\n**Request Body:**\n- `input.text` (string, required): The text to scan for profanity",
+    },
+    'prompt-injection': {
+        slug: 'prompt-injection',
+        requiredInputFields: ['prompt'],
+        optionalConfigFields: ['threshold'],
+        description: "Detect prompt injection attempts\n\n**Request Body:**\n- `input.prompt` (string, required): The prompt to check for injection attempts\n- `config.threshold` (float, optional): Detection threshold (default: 0.5)",
+    },
+    'prompt-perplexity': {
+        slug: 'prompt-perplexity',
+        requiredInputFields: ['prompt'],
+        optionalConfigFields: [],
+        description: "Measure prompt perplexity to detect potential injection attempts\n\n**Request Body:**\n- `input.prompt` (string, required): The prompt to calculate perplexity for",
+    },
+    'regex-validator': {
+        slug: 'regex-validator',
+        requiredInputFields: ['text'],
+        optionalConfigFields: ['case_sensitive', 'dot_include_nl', 'multi_line', 'regex', 'should_match'],
+        description: "Validate text against a regex pattern\n\n**Request Body:**\n- `input.text` (string, required): The text to validate against a regex pattern\n- `config.regex` (string, optional): The regex pattern to match against\n- `config.should_match` (bool, optional): Whether the text should match the regex\n- `config.case_sensitive` (bool, optional): Case-sensitive matching\n- `config.dot_include_nl` (bool, optional): Dot matches newlines\n- `config.multi_line` (bool, optional): Multi-line mode",
+    },
+    'secrets-detector': {
+        slug: 'secrets-detector',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Detect secrets and credentials in text\n\n**Request Body:**\n- `input.text` (string, required): The text to scan for secrets (API keys, passwords, etc.)",
+    },
+    'semantic-similarity': {
+        slug: 'semantic-similarity',
+        requiredInputFields: ['completion', 'reference'],
+        optionalConfigFields: [],
+        description: "Calculate semantic similarity between completion and reference\n\n**Request Body:**\n- `input.completion` (string, required): The completion text to compare\n- `input.reference` (string, required): The reference text to compare against",
+    },
+    'sexism-detector': {
+        slug: 'sexism-detector',
+        requiredInputFields: ['text'],
+        optionalConfigFields: ['threshold'],
+        description: "Detect sexist language and bias\n\n**Request Body:**\n- `input.text` (string, required): The text to scan for sexist content\n- `config.threshold` (float, optional): Detection threshold (default: 0.5)",
+    },
+    'sql-validator': {
+        slug: 'sql-validator',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Validate SQL query syntax\n\n**Request Body:**\n- `input.text` (string, required): The text to validate as SQL",
+    },
+    'tone-detection': {
+        slug: 'tone-detection',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Detect the tone of the text\n\n**Request Body:**\n- `input.text` (string, required): The text to detect the tone of",
+    },
+    'topic-adherence': {
+        slug: 'topic-adherence',
+        requiredInputFields: ['completion', 'question', 'reference_topics'],
+        optionalConfigFields: [],
+        description: "Evaluate topic adherence\n\n**Request Body:**\n- `input.question` (string, required): The original question\n- `input.completion` (string, required): The completion to evaluate\n- `input.reference_topics` (string, required): Comma-separated list of expected topics",
+    },
+    'toxicity-detector': {
+        slug: 'toxicity-detector',
+        requiredInputFields: ['text'],
+        optionalConfigFields: ['threshold'],
+        description: "Detect toxic or harmful language\n\n**Request Body:**\n- `input.text` (string, required): The text to scan for toxic content\n- `config.threshold` (float, optional): Detection threshold (default: 0.5)",
+    },
+    'uncertainty-detector': {
+        slug: 'uncertainty-detector',
+        requiredInputFields: ['prompt'],
+        optionalConfigFields: [],
+        description: "Detect uncertainty in the text\n\n**Request Body:**\n- `input.prompt` (string, required): The text to detect uncertainty in",
+    },
+    'word-count': {
+        slug: 'word-count',
+        requiredInputFields: ['text'],
+        optionalConfigFields: [],
+        description: "Count the number of words in text\n\n**Request Body:**\n- `input.text` (string, required): The text to count words in",
+    },
+    'word-count-ratio': {
+        slug: 'word-count-ratio',
+        requiredInputFields: ['denominator_text', 'numerator_text'],
+        optionalConfigFields: [],
+        description: "Calculate the ratio of words between two texts\n\n**Request Body:**\n- `input.numerator_text` (string, required): The numerator text (will be divided by denominator)\n- `input.denominator_text` (string, required): The denominator text (divides the numerator)",
+    },
+};
+function isValidEvaluatorSlug(slug) {
+    return slug in EVALUATOR_SCHEMAS;
+}
+
+// Auto-generated - DO NOT EDIT
+// Regenerate with: pnpm generate:evaluator-models
+// ─────────────────────────────────────────────────────────────────────────────
+// Utility functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Create an evaluator configuration object.
+ */
+function createEvaluator(slug, options) {
+    return {
+        name: slug,
+        version: options === null || options === void 0 ? void 0 : options.version,
+        config: options === null || options === void 0 ? void 0 : options.config,
+    };
+}
+/**
+ * Validate that required input fields are present in task output.
+ */
+function validateEvaluatorInput(slug, taskOutput) {
+    const schema = EVALUATOR_SCHEMAS[slug];
+    if (!schema) {
+        return { valid: false, missingFields: [] };
+    }
+    const missingFields = schema.requiredInputFields.filter((field) => !(field in taskOutput) || taskOutput[field] === undefined);
+    return {
+        valid: missingFields.length === 0,
+        missingFields,
+    };
+}
+/**
+ * Get all available evaluator slugs.
+ */
+function getAvailableEvaluatorSlugs() {
+    return [...EVALUATOR_SLUGS];
+}
+/**
+ * Get schema information for an evaluator.
+ */
+function getEvaluatorSchemaInfo(slug) {
+    return EVALUATOR_SCHEMAS[slug];
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Factory class
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Factory class for creating type-safe MBT evaluator configurations.
+ *
+ * @example
+ * ```typescript
+ * import { EvaluatorMadeByTraceloop } from '@anyway-sh/node-server-sdk';
+ *
+ * const evaluators = [
+ *   EvaluatorMadeByTraceloop.piiDetector({ probability_threshold: 0.8 }),
+ *   EvaluatorMadeByTraceloop.faithfulness(),
+ * ];
+ * ```
+ */
+class EvaluatorMadeByTraceloop {
+    static create(slug, options) {
+        return createEvaluator(slug, options);
+    }
+    static getAvailableSlugs() {
+        return getAvailableEvaluatorSlugs();
+    }
+    static isValidSlug(slug) {
+        return isValidEvaluatorSlug(slug);
+    }
+    /**
+     * Evaluate agent efficiency - detect redundant calls, unnecessary follow-ups
+  
+  **Request Body:**
+  - `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory
+  - `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory
+     * Required task output fields: trajectory_completions, trajectory_prompts
+     */
+    static agentEfficiency() {
+        return createEvaluator('agent-efficiency');
+    }
+    /**
+     * Validate agent trajectory against user-defined conditions
+  
+  **Request Body:**
+  - `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory
+  - `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory
+  - `config.conditions` (array of strings, required): Array of evaluation conditions/rules to validate against
+  - `config.threshold` (number, required): Score threshold for pass/fail determination (0.0-1.0)
+     * Required task output fields: trajectory_completions, trajectory_prompts
+     */
+    static agentFlowQuality(config) {
+        return createEvaluator('agent-flow-quality', { config: config });
+    }
+    /**
+     * Evaluate agent goal accuracy
+  
+  **Request Body:**
+  - `input.question` (string, required): The original question or goal
+  - `input.completion` (string, required): The agent's completion/response
+  - `input.reference` (string, required): The expected reference answer
+     * Required task output fields: completion, question, reference
+     */
+    static agentGoalAccuracy() {
+        return createEvaluator('agent-goal-accuracy');
+    }
+    /**
+     * Measure if agent accomplished all user goals
+  
+  **Request Body:**
+  - `input.trajectory_prompts` (string, required): JSON array of prompts in the agent trajectory
+  - `input.trajectory_completions` (string, required): JSON array of completions in the agent trajectory
+  - `config.threshold` (number, required): Score threshold for pass/fail determination (0.0-1.0)
+     * Required task output fields: trajectory_completions, trajectory_prompts
+     */
+    static agentGoalCompleteness(config) {
+        return createEvaluator('agent-goal-completeness', { config: config });
+    }
+    /**
+     * Detect errors or failures during tool execution
+  
+  **Request Body:**
+  - `input.tool_input` (string, required): JSON string of the tool input
+  - `input.tool_output` (string, required): JSON string of the tool output
+     * Required task output fields: tool_input, tool_output
+     */
+    static agentToolErrorDetector() {
+        return createEvaluator('agent-tool-error-detector');
+    }
+    /**
+     * Compare actual tool calls against expected reference tool calls
+  
+  **Request Body:**
+  - `input.executed_tool_calls` (string, required): JSON array of actual tool calls made by the agent
+  - `input.expected_tool_calls` (string, required): JSON array of expected/reference tool calls
+  - `config.threshold` (float, optional): Score threshold for pass/fail determination (default: 0.5)
+  - `config.mismatch_sensitive` (bool, optional): Whether tool calls must match exactly (default: false)
+  - `config.order_sensitive` (bool, optional): Whether order of tool calls matters (default: false)
+  - `config.input_params_sensitive` (bool, optional): Whether to compare input parameters (default: true)
+     * Required task output fields: executed_tool_calls, expected_tool_calls
+     */
+    static agentToolTrajectory(config) {
+        return createEvaluator('agent-tool-trajectory', { config: config });
+    }
+    /**
+     * Evaluate whether the answer is complete and contains all the necessary information
+  
+  **Request Body:**
+  - `input.question` (string, required): The original question
+  - `input.completion` (string, required): The completion to evaluate for completeness
+  - `input.context` (string, required): The context that provides the complete information
+     * Required task output fields: completion, context, question
+     */
+    static answerCompleteness() {
+        return createEvaluator('answer-completeness');
+    }
+    /**
+     * Evaluate factual accuracy by comparing answers against ground truth
+  
+  **Request Body:**
+  - `input.question` (string, required): The original question
+  - `input.completion` (string, required): The completion to evaluate
+  - `input.ground_truth` (string, required): The expected correct answer
+     * Required task output fields: completion, ground_truth, question
+     */
+    static answerCorrectness() {
+        return createEvaluator('answer-correctness');
+    }
+    /**
+     * Check if an answer is relevant to a question
+  
+  **Request Body:**
+  - `input.answer` (string, required): The answer to evaluate for relevancy
+  - `input.question` (string, required): The question that the answer should be relevant to
+     * Required task output fields: answer, question
+     */
+    static answerRelevancy() {
+        return createEvaluator('answer-relevancy');
+    }
+    /**
+     * Count the number of characters in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to count characters in
+     * Required task output fields: text
+     */
+    static charCount() {
+        return createEvaluator('char-count');
+    }
+    /**
+     * Calculate the ratio of characters between two texts
+  
+  **Request Body:**
+  - `input.numerator_text` (string, required): The numerator text (will be divided by denominator)
+  - `input.denominator_text` (string, required): The denominator text (divides the numerator)
+     * Required task output fields: denominator_text, numerator_text
+     */
+    static charCountRatio() {
+        return createEvaluator('char-count-ratio');
+    }
+    /**
+     * Evaluate whether retrieved context contains sufficient information to answer the query
+  
+  **Request Body:**
+  - `input.query` (string, required): The query/question to evaluate context relevance for
+  - `input.context` (string, required): The context to evaluate for relevance to the query
+  - `config.model` (string, optional): Model to use for evaluation (default: gpt-4o)
+     * Required task output fields: context, query
+     */
+    static contextRelevance(config) {
+        return createEvaluator('context-relevance', { config: config });
+    }
+    /**
+     * Evaluate conversation quality based on tone, clarity, flow, responsiveness, and transparency
+  
+  **Request Body:**
+  - `input.prompts` (string, required): JSON array of prompts in the conversation
+  - `input.completions` (string, required): JSON array of completions in the conversation
+     * Required task output fields: completions, prompts
+     */
+    static conversationQuality() {
+        return createEvaluator('conversation-quality');
+    }
+    /**
+     * Check if a completion is faithful to the provided context
+  
+  **Request Body:**
+  - `input.completion` (string, required): The LLM completion to check for faithfulness
+  - `input.context` (string, required): The context that the completion should be faithful to
+  - `input.question` (string, required): The original question asked
+     * Required task output fields: completion, context, question
+     */
+    static faithfulness() {
+        return createEvaluator('faithfulness');
+    }
+    /**
+     * Compare two HTML documents for structural and content similarity
+  
+  **Request Body:**
+  - `input.html1` (string, required): The first HTML document to compare
+  - `input.html2` (string, required): The second HTML document to compare
+     * Required task output fields: html1, html2
+     */
+    static htmlComparison() {
+        return createEvaluator('html-comparison');
+    }
+    /**
+     * Evaluate how well responses follow given instructions
+  
+  **Request Body:**
+  - `input.instructions` (string, required): The instructions that should be followed
+  - `input.response` (string, required): The response to evaluate for instruction adherence
+     * Required task output fields: instructions, response
+     */
+    static instructionAdherence() {
+        return createEvaluator('instruction-adherence');
+    }
+    /**
+     * Detect changes in user intent between prompts and completions
+  
+  **Request Body:**
+  - `input.prompts` (string, required): JSON array of prompts in the conversation
+  - `input.completions` (string, required): JSON array of completions in the conversation
+     * Required task output fields: completions, prompts
+     */
+    static intentChange() {
+        return createEvaluator('intent-change');
+    }
+    /**
+     * Validate JSON syntax
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to validate as JSON
+  - `config.enable_schema_validation` (bool, optional): Enable JSON schema validation
+  - `config.schema_string` (string, optional): JSON schema to validate against
+     * Required task output fields: text
+     */
+    static jsonValidator(config) {
+        return createEvaluator('json-validator', { config: config });
+    }
+    /**
+     * Measure text perplexity from logprobs
+  
+  **Request Body:**
+  - `input.logprobs` (string, required): JSON array of log probabilities from the model
+     * Required task output fields: logprobs
+     */
+    static perplexity() {
+        return createEvaluator('perplexity');
+    }
+    /**
+     * Detect personally identifiable information in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for personally identifiable information
+  - `config.probability_threshold` (float, optional): Detection threshold (default: 0.8)
+     * Required task output fields: text
+     */
+    static piiDetector(config) {
+        return createEvaluator('pii-detector', { config: config });
+    }
+    /**
+     * Validate text against a placeholder regex pattern
+  
+  **Request Body:**
+  - `input.placeholder_value` (string, required): The regex pattern to match against
+  - `input.text` (string, required): The text to validate against the regex pattern
+  - `config.should_match` (bool, optional): Whether the text should match the regex
+  - `config.case_sensitive` (bool, optional): Case-sensitive matching
+  - `config.dot_include_nl` (bool, optional): Dot matches newlines
+  - `config.multi_line` (bool, optional): Multi-line mode
+     * Required task output fields: placeholder_value, text
+     */
+    static placeholderRegex(config) {
+        return createEvaluator('placeholder-regex', { config: config });
+    }
+    /**
+     * Detect profanity in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for profanity
+     * Required task output fields: text
+     */
+    static profanityDetector() {
+        return createEvaluator('profanity-detector');
+    }
+    /**
+     * Detect prompt injection attempts
+  
+  **Request Body:**
+  - `input.prompt` (string, required): The prompt to check for injection attempts
+  - `config.threshold` (float, optional): Detection threshold (default: 0.5)
+     * Required task output fields: prompt
+     */
+    static promptInjection(config) {
+        return createEvaluator('prompt-injection', { config: config });
+    }
+    /**
+     * Measure prompt perplexity to detect potential injection attempts
+  
+  **Request Body:**
+  - `input.prompt` (string, required): The prompt to calculate perplexity for
+     * Required task output fields: prompt
+     */
+    static promptPerplexity() {
+        return createEvaluator('prompt-perplexity');
+    }
+    /**
+     * Validate text against a regex pattern
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to validate against a regex pattern
+  - `config.regex` (string, optional): The regex pattern to match against
+  - `config.should_match` (bool, optional): Whether the text should match the regex
+  - `config.case_sensitive` (bool, optional): Case-sensitive matching
+  - `config.dot_include_nl` (bool, optional): Dot matches newlines
+  - `config.multi_line` (bool, optional): Multi-line mode
+     * Required task output fields: text
+     */
+    static regexValidator(config) {
+        return createEvaluator('regex-validator', { config: config });
+    }
+    /**
+     * Detect secrets and credentials in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for secrets (API keys, passwords, etc.)
+     * Required task output fields: text
+     */
+    static secretsDetector() {
+        return createEvaluator('secrets-detector');
+    }
+    /**
+     * Calculate semantic similarity between completion and reference
+  
+  **Request Body:**
+  - `input.completion` (string, required): The completion text to compare
+  - `input.reference` (string, required): The reference text to compare against
+     * Required task output fields: completion, reference
+     */
+    static semanticSimilarity() {
+        return createEvaluator('semantic-similarity');
+    }
+    /**
+     * Detect sexist language and bias
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for sexist content
+  - `config.threshold` (float, optional): Detection threshold (default: 0.5)
+     * Required task output fields: text
+     */
+    static sexismDetector(config) {
+        return createEvaluator('sexism-detector', { config: config });
+    }
+    /**
+     * Validate SQL query syntax
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to validate as SQL
+     * Required task output fields: text
+     */
+    static sqlValidator() {
+        return createEvaluator('sql-validator');
+    }
+    /**
+     * Detect the tone of the text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to detect the tone of
+     * Required task output fields: text
+     */
+    static toneDetection() {
+        return createEvaluator('tone-detection');
+    }
+    /**
+     * Evaluate topic adherence
+  
+  **Request Body:**
+  - `input.question` (string, required): The original question
+  - `input.completion` (string, required): The completion to evaluate
+  - `input.reference_topics` (string, required): Comma-separated list of expected topics
+     * Required task output fields: completion, question, reference_topics
+     */
+    static topicAdherence() {
+        return createEvaluator('topic-adherence');
+    }
+    /**
+     * Detect toxic or harmful language
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for toxic content
+  - `config.threshold` (float, optional): Detection threshold (default: 0.5)
+     * Required task output fields: text
+     */
+    static toxicityDetector(config) {
+        return createEvaluator('toxicity-detector', { config: config });
+    }
+    /**
+     * Detect uncertainty in the text
+  
+  **Request Body:**
+  - `input.prompt` (string, required): The text to detect uncertainty in
+     * Required task output fields: prompt
+     */
+    static uncertaintyDetector() {
+        return createEvaluator('uncertainty-detector');
+    }
+    /**
+     * Count the number of words in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to count words in
+     * Required task output fields: text
+     */
+    static wordCount() {
+        return createEvaluator('word-count');
+    }
+    /**
+     * Calculate the ratio of words between two texts
+  
+  **Request Body:**
+  - `input.numerator_text` (string, required): The numerator text (will be divided by denominator)
+  - `input.denominator_text` (string, required): The denominator text (divides the numerator)
+     * Required task output fields: denominator_text, numerator_text
+     */
+    static wordCountRatio() {
+        return createEvaluator('word-count-ratio');
+    }
+}
+
+const validateConfiguration = (options) => {
+    const { apiKey, traceloopSyncEnabled, traceloopSyncMaxRetries, traceloopSyncPollingInterval, traceloopSyncDevPollingInterval, } = options;
+    if (apiKey && typeof apiKey !== "string") {
+        throw new InitializationError('"apiKey" must be a string');
+    }
+    if (traceloopSyncEnabled) {
+        if (typeof traceloopSyncMaxRetries !== "number" ||
+            traceloopSyncMaxRetries <= 0) {
+            throw new InitializationError('"traceloopSyncMaxRetries" must be an integer greater than 0.');
+        }
+        if (typeof traceloopSyncPollingInterval !== "number" ||
+            traceloopSyncPollingInterval <= 0) {
+            throw new InitializationError('"traceloopSyncPollingInterval" must be an integer greater than 0.');
+        }
+        if (typeof traceloopSyncDevPollingInterval !== "number" ||
+            traceloopSyncDevPollingInterval <= 0) {
+            throw new InitializationError('"traceloopSyncDevPollingInterval" must be an integer greater than 0.');
+        }
+    }
+};
+
+const TRACER_NAME = "@anyway-sh/node-server-sdk";
+const TRACER_VERSION = version;
+const WORKFLOW_NAME_KEY = api.createContextKey("workflow_name");
+const ENTITY_NAME_KEY = api.createContextKey("entity_name");
+const AGENT_NAME_KEY = api.createContextKey("agent_name");
+const CONVERSATION_ID_KEY = api.createContextKey("conversation_id");
+const ASSOCATION_PROPERTIES_KEY = api.createContextKey("association_properties");
+const getTracer = () => {
+    return api.trace.getTracer(TRACER_NAME, TRACER_VERSION);
+};
+const getTraceloopTracer = getTracer;
+const getEntityPath = (entityContext) => {
+    const path = entityContext.getValue(ENTITY_NAME_KEY);
+    return path ? `${path}` : undefined;
+};
+
+const AI_GENERATE_TEXT = "ai.generateText";
+const AI_STREAM_TEXT = "ai.streamText";
+const AI_GENERATE_OBJECT = "ai.generateObject";
+const AI_STREAM_OBJECT = "ai.streamObject";
+const AI_GENERATE_TEXT_DO_GENERATE = "ai.generateText.doGenerate";
+const AI_GENERATE_OBJECT_DO_GENERATE = "ai.generateObject.doGenerate";
+const AI_STREAM_TEXT_DO_STREAM = "ai.streamText.doStream";
+const AI_STREAM_OBJECT_DO_STREAM = "ai.streamObject.doStream";
+const HANDLED_SPAN_NAMES = {
+    [AI_GENERATE_TEXT]: "run.ai",
+    [AI_STREAM_TEXT]: "stream.ai",
+    [AI_GENERATE_OBJECT]: "object.ai",
+    [AI_STREAM_OBJECT]: "stream-object.ai",
+    [AI_GENERATE_TEXT_DO_GENERATE]: "text.generate",
+    [AI_GENERATE_OBJECT_DO_GENERATE]: "object.generate",
+    [AI_STREAM_TEXT_DO_STREAM]: "text.stream",
+    [AI_STREAM_OBJECT_DO_STREAM]: "object.stream",
+};
+const TOOL_SPAN_NAME = "ai.toolCall";
+const AI_RESPONSE_TEXT = "ai.response.text";
+const AI_RESPONSE_OBJECT = "ai.response.object";
+const AI_RESPONSE_TOOL_CALLS = "ai.response.toolCalls";
+const AI_RESPONSE_PROVIDER_METADATA = "ai.response.providerMetadata";
+const AI_PROMPT_MESSAGES = "ai.prompt.messages";
+const AI_PROMPT = "ai.prompt";
+const AI_USAGE_PROMPT_TOKENS = "ai.usage.promptTokens";
+const AI_USAGE_COMPLETION_TOKENS = "ai.usage.completionTokens";
+const AI_MODEL_PROVIDER = "ai.model.provider";
+const AI_PROMPT_TOOLS = "ai.prompt.tools";
+const AI_TELEMETRY_METADATA_PREFIX = "ai.telemetry.metadata.";
+const TYPE_TEXT = "text";
+const TYPE_TOOL_CALL = "tool_call";
+const ROLE_ASSISTANT = "assistant";
+const ROLE_USER = "user";
+// Vendor mapping from AI SDK provider prefixes to standardized LLM_SYSTEM values
+// Uses prefixes to match AI SDK patterns like "openai.chat", "anthropic.messages", etc.
+const VENDOR_MAPPING = {
+    openai: "OpenAI",
+    azure: "Azure",
+    "azure-openai": "Azure",
+    anthropic: "Anthropic",
+    cohere: "Cohere",
+    mistral: "MistralAI",
+    groq: "Groq",
+    replicate: "Replicate",
+    together: "TogetherAI",
+    fireworks: "Fireworks",
+    deepseek: "DeepSeek",
+    perplexity: "Perplexity",
+    "amazon-bedrock": "AWS",
+    bedrock: "AWS",
+    google: "Google",
+    vertex: "Google",
+    ollama: "Ollama",
+    huggingface: "HuggingFace",
+    openrouter: "OpenRouter",
+};
+const getAgentNameFromAttributes = (attributes) => {
+    const agentAttr = attributes[`${AI_TELEMETRY_METADATA_PREFIX}agent`];
+    return agentAttr && typeof agentAttr === "string" ? agentAttr : null;
+};
+const transformResponseText = (attributes) => {
+    if (AI_RESPONSE_TEXT in attributes) {
+        attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.content`] =
+            attributes[AI_RESPONSE_TEXT];
+        attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.role`] = ROLE_ASSISTANT;
+        const outputMessage = {
+            role: ROLE_ASSISTANT,
+            parts: [
+                {
+                    type: TYPE_TEXT,
+                    content: attributes[AI_RESPONSE_TEXT],
+                },
+            ],
+        };
+        attributes[incubating.ATTR_GEN_AI_OUTPUT_MESSAGES] = JSON.stringify([outputMessage]);
+        delete attributes[AI_RESPONSE_TEXT];
+    }
+};
+const transformResponseObject = (attributes) => {
+    if (AI_RESPONSE_OBJECT in attributes) {
+        attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.content`] =
+            attributes[AI_RESPONSE_OBJECT];
+        attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.role`] = ROLE_ASSISTANT;
+        const outputMessage = {
+            role: ROLE_ASSISTANT,
+            parts: [
+                {
+                    type: TYPE_TEXT,
+                    content: attributes[AI_RESPONSE_OBJECT],
+                },
+            ],
+        };
+        attributes[incubating.ATTR_GEN_AI_OUTPUT_MESSAGES] = JSON.stringify([outputMessage]);
+        delete attributes[AI_RESPONSE_OBJECT];
+    }
+};
+const transformResponseToolCalls = (attributes) => {
+    if (AI_RESPONSE_TOOL_CALLS in attributes) {
+        try {
+            const toolCalls = JSON.parse(attributes[AI_RESPONSE_TOOL_CALLS]);
+            attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.role`] = ROLE_ASSISTANT;
+            const toolCallParts = [];
+            toolCalls.forEach((toolCall, index) => {
+                var _a;
+                // Support both v4 (args) and v5 (input) formats
+                // Prefer v5 (input) if present
+                const toolArgs = (_a = toolCall.input) !== null && _a !== void 0 ? _a : toolCall.args;
+                attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.tool_calls.${index}.name`] =
+                    toolCall.toolName;
+                attributes[`${incubating.ATTR_GEN_AI_COMPLETION}.0.tool_calls.${index}.arguments`] = toolArgs;
+                toolCallParts.push({
+                    type: TYPE_TOOL_CALL,
+                    tool_call: {
+                        name: toolCall.toolName,
+                        arguments: toolArgs,
+                    },
+                });
+            });
+            if (toolCallParts.length > 0) {
+                const outputMessage = {
+                    role: ROLE_ASSISTANT,
+                    parts: toolCallParts,
+                };
+                attributes[incubating.ATTR_GEN_AI_OUTPUT_MESSAGES] = JSON.stringify([
+                    outputMessage,
+                ]);
+            }
+            delete attributes[AI_RESPONSE_TOOL_CALLS];
+        }
+        catch (_a) {
+            // Ignore parsing errors
+        }
+    }
+};
+const processMessageContent = (content) => {
+    if (Array.isArray(content)) {
+        const textItems = content.filter((item) => item &&
+            typeof item === "object" &&
+            item.type === TYPE_TEXT &&
+            item.text);
+        if (textItems.length > 0) {
+            const joinedText = textItems.map((item) => item.text).join(" ");
+            return joinedText;
+        }
+        else {
+            return JSON.stringify(content);
+        }
+    }
+    if (content && typeof content === "object") {
+        if (content.type === TYPE_TEXT && content.text) {
+            return content.text;
+        }
+        return JSON.stringify(content);
+    }
+    if (typeof content === "string") {
+        try {
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                const allTextItems = parsed.every((item) => item &&
+                    typeof item === "object" &&
+                    item.type === TYPE_TEXT &&
+                    item.text);
+                if (allTextItems && parsed.length > 0) {
+                    return parsed.map((item) => item.text).join(" ");
+                }
+                else {
+                    return content;
+                }
+            }
+        }
+        catch (_a) {
+            // Ignore parsing errors
+        }
+        return content;
+    }
+    return String(content);
+};
+const transformTools = (attributes) => {
+    if (AI_PROMPT_TOOLS in attributes) {
+        try {
+            const tools = attributes[AI_PROMPT_TOOLS];
+            if (Array.isArray(tools)) {
+                tools.forEach((toolItem, index) => {
+                    var _a;
+                    let tool = toolItem;
+                    if (typeof toolItem === "string") {
+                        try {
+                            tool = JSON.parse(toolItem);
+                        }
+                        catch (_b) {
+                            return;
+                        }
+                    }
+                    if (tool && typeof tool === "object") {
+                        if (tool.name) {
+                            attributes[`${aiSemanticConventions.SpanAttributes.LLM_REQUEST_FUNCTIONS}.${index}.name`] = tool.name;
+                        }
+                        if (tool.description) {
+                            attributes[`${aiSemanticConventions.SpanAttributes.LLM_REQUEST_FUNCTIONS}.${index}.description`] = tool.description;
+                        }
+                        // Support both v4 (parameters) and v5 (inputSchema) formats
+                        // Prefer v5 (inputSchema) if present
+                        const schema = (_a = tool.inputSchema) !== null && _a !== void 0 ? _a : tool.parameters;
+                        if (schema) {
+                            attributes[`${aiSemanticConventions.SpanAttributes.LLM_REQUEST_FUNCTIONS}.${index}.parameters`] = typeof schema === "string" ? schema : JSON.stringify(schema);
+                        }
+                    }
+                });
+            }
+            delete attributes[AI_PROMPT_TOOLS];
+        }
+        catch (_a) {
+            // Ignore parsing errors
+        }
+    }
+};
+const transformPrompts = (attributes) => {
+    if (AI_PROMPT_MESSAGES in attributes) {
+        try {
+            let jsonString = attributes[AI_PROMPT_MESSAGES];
+            try {
+                JSON.parse(jsonString);
+            }
+            catch (_a) {
+                jsonString = jsonString.replace(/\\'/g, "'");
+                jsonString = jsonString.replace(/\\\\\\\\/g, "\\\\");
+            }
+            const messages = JSON.parse(jsonString);
+            const inputMessages = [];
+            messages.forEach((msg, index) => {
+                const processedContent = processMessageContent(msg.content);
+                const contentKey = `${incubating.ATTR_GEN_AI_PROMPT}.${index}.content`;
+                attributes[contentKey] = processedContent;
+                attributes[`${incubating.ATTR_GEN_AI_PROMPT}.${index}.role`] = msg.role;
+                // Add to OpenTelemetry standard gen_ai.input.messages format
+                inputMessages.push({
+                    role: msg.role,
+                    parts: [
+                        {
+                            type: TYPE_TEXT,
+                            content: processedContent,
+                        },
+                    ],
+                });
+            });
+            // Set the OpenTelemetry standard input messages attribute
+            if (inputMessages.length > 0) {
+                attributes[incubating.ATTR_GEN_AI_INPUT_MESSAGES] = JSON.stringify(inputMessages);
+            }
+            delete attributes[AI_PROMPT_MESSAGES];
+        }
+        catch (_b) {
+            // Ignore parsing errors
+        }
+    }
+    if (AI_PROMPT in attributes) {
+        try {
+            const promptData = JSON.parse(attributes[AI_PROMPT]);
+            if (promptData.messages && Array.isArray(promptData.messages)) {
+                const messages = promptData.messages;
+                const inputMessages = [];
+                messages.forEach((msg, index) => {
+                    const processedContent = processMessageContent(msg.content);
+                    const contentKey = `${incubating.ATTR_GEN_AI_PROMPT}.${index}.content`;
+                    attributes[contentKey] = processedContent;
+                    attributes[`${incubating.ATTR_GEN_AI_PROMPT}.${index}.role`] = msg.role;
+                    inputMessages.push({
+                        role: msg.role,
+                        parts: [
+                            {
+                                type: TYPE_TEXT,
+                                content: processedContent,
+                            },
+                        ],
+                    });
+                });
+                if (inputMessages.length > 0) {
+                    attributes[incubating.ATTR_GEN_AI_INPUT_MESSAGES] =
+                        JSON.stringify(inputMessages);
+                }
+                delete attributes[AI_PROMPT];
+            }
+            else if (promptData.prompt && typeof promptData.prompt === "string") {
+                attributes[`${incubating.ATTR_GEN_AI_PROMPT}.0.content`] = promptData.prompt;
+                attributes[`${incubating.ATTR_GEN_AI_PROMPT}.0.role`] = ROLE_USER;
+                const inputMessage = {
+                    role: ROLE_USER,
+                    parts: [
+                        {
+                            type: TYPE_TEXT,
+                            content: promptData.prompt,
+                        },
+                    ],
+                };
+                attributes[incubating.ATTR_GEN_AI_INPUT_MESSAGES] = JSON.stringify([inputMessage]);
+                delete attributes[AI_PROMPT];
+            }
+        }
+        catch (_c) {
+            // Ignore parsing errors
+        }
+    }
+};
+const transformPromptTokens = (attributes) => {
+    if (!(incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS in attributes) &&
+        AI_USAGE_PROMPT_TOKENS in attributes) {
+        attributes[incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS] =
+            attributes[AI_USAGE_PROMPT_TOKENS];
+    }
+    delete attributes[AI_USAGE_PROMPT_TOKENS];
+};
+const transformCompletionTokens = (attributes) => {
+    if (!(incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS in attributes) &&
+        AI_USAGE_COMPLETION_TOKENS in attributes) {
+        attributes[incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS] =
+            attributes[AI_USAGE_COMPLETION_TOKENS];
+    }
+    delete attributes[AI_USAGE_COMPLETION_TOKENS];
+};
+const transformProviderMetadata = (attributes) => {
+    if (AI_RESPONSE_PROVIDER_METADATA in attributes) {
+        try {
+            const metadataStr = attributes[AI_RESPONSE_PROVIDER_METADATA];
+            let metadata;
+            if (typeof metadataStr === "string") {
+                metadata = JSON.parse(metadataStr);
+            }
+            else if (typeof metadataStr === "object") {
+                metadata = metadataStr;
+            }
+            else {
+                return;
+            }
+            if (metadata.anthropic) {
+                const anthropicMetadata = metadata.anthropic;
+                if (anthropicMetadata.cacheCreationInputTokens !== undefined) {
+                    attributes[aiSemanticConventions.SpanAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS] =
+                        anthropicMetadata.cacheCreationInputTokens;
+                }
+                if (anthropicMetadata.cacheReadInputTokens !== undefined) {
+                    attributes[aiSemanticConventions.SpanAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] =
+                        anthropicMetadata.cacheReadInputTokens;
+                }
+            }
+            if (metadata.openai) {
+                const openaiMetadata = metadata.openai;
+                if (openaiMetadata.cachedPromptTokens !== undefined) {
+                    attributes[aiSemanticConventions.SpanAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] =
+                        openaiMetadata.cachedPromptTokens;
+                }
+                if (openaiMetadata.reasoningTokens !== undefined) {
+                    attributes[aiSemanticConventions.SpanAttributes.GEN_AI_USAGE_REASONING_TOKENS] =
+                        openaiMetadata.reasoningTokens;
+                }
+            }
+            delete attributes[AI_RESPONSE_PROVIDER_METADATA];
+        }
+        catch (_a) {
+            // Ignore JSON parsing errors
+        }
+    }
+};
+const calculateTotalTokens = (attributes) => {
+    const inputTokens = attributes[incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS];
+    const outputTokens = attributes[incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS];
+    if (inputTokens && outputTokens) {
+        attributes[`${aiSemanticConventions.SpanAttributes.LLM_USAGE_TOTAL_TOKENS}`] =
+            Number(inputTokens) + Number(outputTokens);
+    }
+};
+const transformVendor = (attributes) => {
+    if (AI_MODEL_PROVIDER in attributes) {
+        const vendor = attributes[AI_MODEL_PROVIDER];
+        // Find matching vendor prefix in mapping
+        let mappedVendor = null;
+        let providerName = vendor;
+        if (typeof vendor === "string" && vendor.length > 0) {
+            // Extract provider name (part before first dot, or entire string if no dot)
+            const dotIndex = vendor.indexOf(".");
+            providerName = dotIndex > 0 ? vendor.substring(0, dotIndex) : vendor;
+            for (const prefix of Object.keys(VENDOR_MAPPING)) {
+                if (vendor.startsWith(prefix)) {
+                    mappedVendor = VENDOR_MAPPING[prefix];
+                    break;
+                }
+            }
+            attributes[incubating.ATTR_GEN_AI_SYSTEM] = mappedVendor || vendor;
+            attributes[incubating.ATTR_GEN_AI_PROVIDER_NAME] = providerName;
+        }
+        delete attributes[AI_MODEL_PROVIDER];
+    }
+};
+const transformOperationName = (attributes, spanName) => {
+    if (!spanName)
+        return;
+    let operationName;
+    if (spanName.includes("generateText") ||
+        spanName.includes("streamText") ||
+        spanName.includes("generateObject") ||
+        spanName.includes("streamObject")) {
+        operationName = "chat";
+    }
+    else if (spanName === "ai.toolCall" || spanName.endsWith(".tool")) {
+        operationName = "execute_tool";
+    }
+    if (operationName) {
+        attributes[incubating.ATTR_GEN_AI_OPERATION_NAME] = operationName;
+    }
+};
+const transformModelId = (attributes) => {
+    const AI_MODEL_ID = "ai.model.id";
+    if (AI_MODEL_ID in attributes) {
+        attributes[incubating.ATTR_GEN_AI_REQUEST_MODEL] = attributes[AI_MODEL_ID];
+        delete attributes[AI_MODEL_ID];
+    }
+};
+const transformFinishReason = (attributes) => {
+    const AI_RESPONSE_FINISH_REASON = "ai.response.finishReason";
+    if (AI_RESPONSE_FINISH_REASON in attributes) {
+        const finishReason = attributes[AI_RESPONSE_FINISH_REASON];
+        attributes[incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS] = Array.isArray(finishReason)
+            ? finishReason
+            : [finishReason];
+        delete attributes[AI_RESPONSE_FINISH_REASON];
+    }
+};
+const transformToolCallAttributes = (attributes) => {
+    var _a, _b;
+    if ("ai.toolCall.name" in attributes) {
+        attributes[incubating.ATTR_GEN_AI_TOOL_NAME] = attributes["ai.toolCall.name"];
+        // Keep ai.toolCall.name for now, will be deleted in transformToolCalls
+    }
+    if ("ai.toolCall.id" in attributes) {
+        attributes[incubating.ATTR_GEN_AI_TOOL_CALL_ID] = attributes["ai.toolCall.id"];
+        delete attributes["ai.toolCall.id"];
+    }
+    // Support both v4 (args) and v5 (input) formats
+    // Prefer v5 (input) if present
+    const toolArgs = (_a = attributes["ai.toolCall.input"]) !== null && _a !== void 0 ? _a : attributes["ai.toolCall.args"];
+    if (toolArgs !== undefined) {
+        attributes[incubating.ATTR_GEN_AI_TOOL_CALL_ARGUMENTS] = toolArgs;
+        // Don't delete yet - transformToolCalls will handle entity input/output
+    }
+    // Support both v4 (result) and v5 (output) formats
+    // Prefer v5 (output) if present
+    const toolResult = (_b = attributes["ai.toolCall.output"]) !== null && _b !== void 0 ? _b : attributes["ai.toolCall.result"];
+    if (toolResult !== undefined) {
+        attributes[incubating.ATTR_GEN_AI_TOOL_CALL_RESULT] = toolResult;
+        // Don't delete yet - transformToolCalls will handle entity input/output
+    }
+};
+const transformConversationId = (attributes) => {
+    const conversationId = attributes["ai.telemetry.metadata.conversationId"];
+    const sessionId = attributes["ai.telemetry.metadata.sessionId"];
+    if (conversationId) {
+        attributes[incubating.ATTR_GEN_AI_CONVERSATION_ID] = conversationId;
+    }
+    else if (sessionId) {
+        attributes[incubating.ATTR_GEN_AI_CONVERSATION_ID] = sessionId;
+    }
+};
+const transformResponseMetadata = (attributes) => {
+    const AI_RESPONSE_MODEL = "ai.response.model";
+    const AI_RESPONSE_ID = "ai.response.id";
+    if (AI_RESPONSE_MODEL in attributes) {
+        attributes[incubating.ATTR_GEN_AI_RESPONSE_MODEL] = attributes[AI_RESPONSE_MODEL];
+        delete attributes[AI_RESPONSE_MODEL];
+    }
+    if (AI_RESPONSE_ID in attributes) {
+        attributes[incubating.ATTR_GEN_AI_RESPONSE_ID] = attributes[AI_RESPONSE_ID];
+        delete attributes[AI_RESPONSE_ID];
+    }
+};
+const transformTelemetryMetadata = (attributes, spanName) => {
+    const keysToDelete = [];
+    // Use the helper function to extract agent name
+    const agentName = getAgentNameFromAttributes(attributes);
+    // Find all ai.telemetry.metadata.* attributes
+    for (const [key, value] of Object.entries(attributes)) {
+        if (key.startsWith(AI_TELEMETRY_METADATA_PREFIX)) {
+            const metadataKey = key.substring(AI_TELEMETRY_METADATA_PREFIX.length);
+            // Always mark for deletion since it's a telemetry metadata attribute
+            keysToDelete.push(key);
+            if (metadataKey && value != null) {
+                // Convert value to string for association properties
+                const stringValue = typeof value === "string" ? value : String(value);
+                // Also set as traceloop association property attribute
+                attributes[`${aiSemanticConventions.SpanAttributes.TRACELOOP_ASSOCIATION_PROPERTIES}.${metadataKey}`] = stringValue;
+            }
+        }
+    }
+    if (agentName) {
+        attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = agentName;
+        const topLevelSpanNames = [
+            AI_GENERATE_TEXT,
+            AI_STREAM_TEXT,
+            AI_GENERATE_OBJECT,
+            AI_STREAM_OBJECT,
+        ];
+        if (spanName &&
+            (spanName === `${agentName}.agent` ||
+                topLevelSpanNames.includes(spanName))) {
+            attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_SPAN_KIND] =
+                aiSemanticConventions.TraceloopSpanKindValues.AGENT;
+            attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_NAME] = agentName;
+            const inputMessages = attributes[incubating.ATTR_GEN_AI_INPUT_MESSAGES];
+            const outputMessages = attributes[incubating.ATTR_GEN_AI_OUTPUT_MESSAGES];
+            const toolArgs = attributes["ai.toolCall.args"];
+            const toolResult = attributes["ai.toolCall.result"];
+            if (inputMessages || outputMessages) {
+                if (inputMessages) {
+                    attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_INPUT] = inputMessages;
+                }
+                if (outputMessages) {
+                    attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT] = outputMessages;
+                }
+            }
+            else if (toolArgs || toolResult) {
+                if (toolArgs) {
+                    attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_INPUT] = toolArgs;
+                }
+                if (toolResult) {
+                    attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT] = toolResult;
+                }
+            }
+        }
+    }
+    keysToDelete.forEach((key) => {
+        delete attributes[key];
+    });
+};
+const transformLLMSpans = (attributes, spanName) => {
+    transformOperationName(attributes, spanName);
+    transformModelId(attributes);
+    transformResponseText(attributes);
+    transformResponseObject(attributes);
+    transformResponseToolCalls(attributes);
+    transformPrompts(attributes);
+    transformTools(attributes);
+    transformPromptTokens(attributes);
+    transformCompletionTokens(attributes);
+    transformProviderMetadata(attributes);
+    transformFinishReason(attributes);
+    transformResponseMetadata(attributes);
+    calculateTotalTokens(attributes);
+    transformVendor(attributes); // Also sets GEN_AI_PROVIDER_NAME
+    transformConversationId(attributes);
+    transformToolCallAttributes(attributes);
+    transformTelemetryMetadata(attributes, spanName);
+};
+const transformToolCalls = (span) => {
+    var _a, _b;
+    // Support both v4 (args/result) and v5 (input/output) formats
+    // Prefer v5 (input/output) if present
+    const toolInput = (_a = span.attributes["ai.toolCall.input"]) !== null && _a !== void 0 ? _a : span.attributes["ai.toolCall.args"];
+    const toolOutput = (_b = span.attributes["ai.toolCall.output"]) !== null && _b !== void 0 ? _b : span.attributes["ai.toolCall.result"];
+    if (toolInput && toolOutput) {
+        span.attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_INPUT] = toolInput;
+        delete span.attributes["ai.toolCall.args"];
+        delete span.attributes["ai.toolCall.input"];
+        span.attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT] = toolOutput;
+        delete span.attributes["ai.toolCall.result"];
+        delete span.attributes["ai.toolCall.output"];
+        span.attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_SPAN_KIND] =
+            aiSemanticConventions.TraceloopSpanKindValues.TOOL;
+        // Set entity name from tool call name
+        const toolName = span.attributes["ai.toolCall.name"];
+        if (toolName) {
+            span.attributes[aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_NAME] = toolName;
+            delete span.attributes["ai.toolCall.name"];
+        }
+    }
+};
+const shouldHandleSpan = (span) => {
+    var _a;
+    return ((_a = span.instrumentationScope) === null || _a === void 0 ? void 0 : _a.name) === "ai";
+};
+const getAiSdkVersion = () => {
+    try {
+        return require("ai/package.json").version;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const TOP_LEVEL_AI_SPANS = [
+    AI_GENERATE_TEXT,
+    AI_STREAM_TEXT,
+    AI_GENERATE_OBJECT,
+    AI_STREAM_OBJECT,
+];
+const transformAiSdkSpanNames = (span) => {
+    if (span.name === TOOL_SPAN_NAME) {
+        span.updateName(`${span.attributes["ai.toolCall.name"]}.tool`);
+    }
+    if (span.name in HANDLED_SPAN_NAMES) {
+        const agentName = getAgentNameFromAttributes(span.attributes);
+        const isTopLevelSpan = TOP_LEVEL_AI_SPANS.includes(span.name);
+        if (agentName && isTopLevelSpan) {
+            span.updateName(`${agentName}.agent`);
+        }
+        else if (!isTopLevelSpan) {
+            span.updateName(HANDLED_SPAN_NAMES[span.name]);
+        }
+    }
+};
+const transformAiSdkSpanAttributes = (span) => {
+    if (!shouldHandleSpan(span)) {
+        return;
+    }
+    const aiSdkVersion = getAiSdkVersion();
+    if (aiSdkVersion) {
+        span.attributes["ai.sdk.version"] = aiSdkVersion;
+    }
+    transformLLMSpans(span.attributes, span.name);
+    transformToolCalls(span);
+};
+
+function parseKeyPairsIntoRecord(keyPairs) {
+    const result = {};
+    if (!keyPairs)
+        return result;
+    keyPairs.split(",").forEach((pair) => {
+        const [key, value] = pair.split("=");
+        if (key && value) {
+            result[key.trim()] = value.trim();
+        }
+    });
+    return result;
+}
+
+const ALL_INSTRUMENTATION_LIBRARIES = "all";
+const spanAgentNames = new Map();
+const SPAN_AGENT_NAME_TTL = 5 * 60 * 1000;
+const AI_TELEMETRY_METADATA_AGENT = "ai.telemetry.metadata.agent";
+const cleanupExpiredSpanAgentNames = () => {
+    const now = Date.now();
+    for (const [spanId, entry] of spanAgentNames.entries()) {
+        if (now - entry.timestamp > SPAN_AGENT_NAME_TTL) {
+            spanAgentNames.delete(spanId);
+        }
+    }
+};
+/**
+ * Creates a span processor with Traceloop's custom span handling logic.
+ * This can be used independently of the full SDK initialization.
+ *
+ * @param options - Configuration options for the span processor
+ * @returns A configured SpanProcessor instance
+ */
+const createSpanProcessor = (options) => {
+    var _a;
+    const url = `${options.baseUrl || process.env.ANYWAY_BASE_URL || "https://api.traceloop.com"}/v1/traces`;
+    const headers = options.headers ||
+        (process.env.ANYWAY_HEADERS
+            ? parseKeyPairsIntoRecord(process.env.ANYWAY_HEADERS)
+            : { Authorization: `Bearer ${options.apiKey}` });
+    const traceExporter = (_a = options.exporter) !== null && _a !== void 0 ? _a : new exporterTraceOtlpProto.OTLPTraceExporter({
+        url,
+        headers,
+    });
+    const spanProcessor = options.disableBatch
+        ? new sdkTraceNode.SimpleSpanProcessor(traceExporter)
+        : new sdkTraceNode.BatchSpanProcessor(traceExporter);
+    // Store the original onEnd method
+    const originalOnEnd = spanProcessor.onEnd.bind(spanProcessor);
+    spanProcessor.onStart = onSpanStart;
+    if (options.allowedInstrumentationLibraries === ALL_INSTRUMENTATION_LIBRARIES) {
+        spanProcessor.onEnd = onSpanEnd(originalOnEnd);
+    }
+    else {
+        const instrumentationLibraries = [...traceloopInstrumentationLibraries];
+        if (options.allowedInstrumentationLibraries) {
+            instrumentationLibraries.push(...options.allowedInstrumentationLibraries);
+        }
+        spanProcessor.onEnd = onSpanEnd(originalOnEnd, instrumentationLibraries);
+    }
+    return spanProcessor;
+};
+const traceloopInstrumentationLibraries = [
+    "ai",
+    "@anyway-sh/node-server-sdk",
+    "@traceloop/instrumentation-openai",
+    "@traceloop/instrumentation-langchain",
+    "@traceloop/instrumentation-chroma",
+    "@traceloop/instrumentation-anthropic",
+    "@traceloop/instrumentation-llamaindex",
+    "@traceloop/instrumentation-vertexai",
+    "@traceloop/instrumentation-bedrock",
+    "@traceloop/instrumentation-cohere",
+    "@traceloop/instrumentation-pinecone",
+    "@traceloop/instrumentation-qdrant",
+    "@traceloop/instrumentation-together",
+    "@traceloop/instrumentation-mcp",
+];
+const onSpanStart = (span) => {
+    const workflowName = api.context.active().getValue(WORKFLOW_NAME_KEY);
+    if (workflowName) {
+        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_WORKFLOW_NAME, workflowName);
+    }
+    const entityName = api.context.active().getValue(ENTITY_NAME_KEY);
+    if (entityName) {
+        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_PATH, entityName);
+    }
+    let agentName = api.context.active().getValue(AGENT_NAME_KEY);
+    if (!agentName) {
+        const aiSdkAgent = span.attributes[AI_TELEMETRY_METADATA_AGENT];
+        if (aiSdkAgent && typeof aiSdkAgent === "string") {
+            agentName = aiSdkAgent;
+        }
+    }
+    if (!agentName) {
+        const parentSpanContext = span.parentSpanContext;
+        const parentSpanId = parentSpanContext === null || parentSpanContext === void 0 ? void 0 : parentSpanContext.spanId;
+        if (parentSpanId &&
+            parentSpanId !== "0000000000000000" &&
+            spanAgentNames.has(parentSpanId)) {
+            agentName = spanAgentNames.get(parentSpanId).agentName;
+        }
+    }
+    if (agentName) {
+        span.setAttribute(incubating.ATTR_GEN_AI_AGENT_NAME, agentName);
+        const spanId = span.spanContext().spanId;
+        spanAgentNames.set(spanId, { agentName, timestamp: Date.now() });
+    }
+    // Check for conversation ID in context
+    const conversationId = api.context.active().getValue(CONVERSATION_ID_KEY);
+    if (conversationId) {
+        span.setAttribute(incubating.ATTR_GEN_AI_CONVERSATION_ID, conversationId);
+    }
+    // Check for association properties in context (set by decorators or withAssociationProperties)
+    const associationProperties = api.context
+        .active()
+        .getValue(ASSOCATION_PROPERTIES_KEY);
+    if (associationProperties && Object.keys(associationProperties).length > 0) {
+        for (const [key, value] of Object.entries(associationProperties)) {
+            span.setAttribute(`${aiSemanticConventions.SpanAttributes.TRACELOOP_ASSOCIATION_PROPERTIES}.${key}`, value);
+        }
+    }
+    transformAiSdkSpanNames(span);
+};
+/**
+ * Ensures span compatibility between OTel v1.x and v2.x for OTLP transformer
+ */
+const ensureSpanCompatibility = (span) => {
+    const spanAny = span;
+    // If the span already has instrumentationLibrary, it's compatible (OTel v2.x)
+    if (spanAny.instrumentationLibrary) {
+        return span;
+    }
+    // If it has instrumentationScope but no instrumentationLibrary (OTel v1.x),
+    // add instrumentationLibrary as an alias to prevent OTLP transformer errors
+    if (spanAny.instrumentationScope) {
+        // Create a proxy that provides both properties
+        return new Proxy(span, {
+            get(target, prop) {
+                if (prop === "instrumentationLibrary") {
+                    return target.instrumentationScope;
+                }
+                return target[prop];
+            },
+        });
+    }
+    // Fallback: add both properties with defaults
+    return new Proxy(span, {
+        get(target, prop) {
+            if (prop === "instrumentationLibrary" ||
+                prop === "instrumentationScope") {
+                return {
+                    name: "unknown",
+                    version: undefined,
+                    schemaUrl: undefined,
+                };
+            }
+            return target[prop];
+        },
+    });
+};
+const onSpanEnd = (originalOnEnd, instrumentationLibraries) => {
+    return (span) => {
+        var _a, _b, _c;
+        if (instrumentationLibraries &&
+            !instrumentationLibraries.includes(((_a = span.instrumentationScope) === null || _a === void 0 ? void 0 : _a.name) ||
+                ((_b = span.instrumentationLibrary) === null || _b === void 0 ? void 0 : _b.name))) {
+            return;
+        }
+        transformAiSdkSpanAttributes(span);
+        const spanId = span.spanContext().spanId;
+        const parentSpanId = (_c = span.parentSpanContext) === null || _c === void 0 ? void 0 : _c.spanId;
+        let agentName = span.attributes[incubating.ATTR_GEN_AI_AGENT_NAME];
+        if (agentName && typeof agentName === "string") {
+            spanAgentNames.set(spanId, {
+                agentName,
+                timestamp: Date.now(),
+            });
+        }
+        else if (parentSpanId &&
+            parentSpanId !== "0000000000000000" &&
+            spanAgentNames.has(parentSpanId)) {
+            agentName = spanAgentNames.get(parentSpanId).agentName;
+            span.attributes[incubating.ATTR_GEN_AI_AGENT_NAME] = agentName;
+            spanAgentNames.set(spanId, {
+                agentName,
+                timestamp: Date.now(),
+            });
+        }
+        if (Math.random() < 0.01) {
+            cleanupExpiredSpanAgentNames();
+        }
+        const compatibleSpan = ensureSpanCompatibility(span);
+        originalOnEnd(compatibleSpan);
+    };
+};
+
+class ImageUploader {
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async uploadBase64Image(traceId, spanId, imageName, base64ImageData) {
+        try {
+            const imageUrl = await this.getImageUrl(traceId, spanId, imageName);
+            await this.uploadImageData(imageUrl, base64ImageData);
+            return imageUrl;
+        }
+        catch (error) {
+            console.error("Failed to upload image:", error);
+            throw error;
+        }
+    }
+    async getImageUrl(traceId, spanId, imageName) {
+        const response = await fetch(`${this.baseUrl}/v2/traces/${traceId}/spans/${spanId}/images`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                image_name: imageName,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get image URL: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        return result.url;
+    }
+    async uploadImageData(url, base64ImageData) {
+        const payload = {
+            image_data: base64ImageData,
+        };
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to upload image data: ${response.status} ${response.statusText}. ${errorText}`);
+        }
+    }
+}
+
+let _sdk;
+let _spanProcessor;
+let openAIInstrumentation;
+let anthropicInstrumentation;
+let cohereInstrumentation;
+let vertexaiInstrumentation;
+let aiplatformInstrumentation;
+let bedrockInstrumentation;
+let langchainInstrumentation;
+let llamaIndexInstrumentation;
+let pineconeInstrumentation;
+let chromadbInstrumentation;
+let qdrantInstrumentation;
+let togetherInstrumentation;
+let mcpInstrumentation;
+const instrumentations = [];
+const initInstrumentations = (apiKey, baseUrl) => {
+    const exceptionLogger = (e) => {
+        console.debug("[Traceloop] Instrumentation exception:", e.message);
+    };
+    const enrichTokens = (process.env.ANYWAY_ENRICH_TOKENS || "true").toLowerCase() === "true";
+    // Create image upload callback if we have credentials
+    let uploadBase64ImageCallback;
+    if (apiKey && baseUrl) {
+        const imageUploader = new ImageUploader(baseUrl, apiKey);
+        uploadBase64ImageCallback =
+            imageUploader.uploadBase64Image.bind(imageUploader);
+    }
+    // Create or update OpenAI instrumentation
+    if (openAIInstrumentation) {
+        // Update existing instrumentation with new callback
+        openAIInstrumentation.setConfig({
+            enrichTokens,
+            exceptionLogger,
+            uploadBase64Image: uploadBase64ImageCallback,
+        });
+    }
+    else {
+        // Create new instrumentation
+        openAIInstrumentation = new instrumentationOpenai.OpenAIInstrumentation({
+            enrichTokens,
+            exceptionLogger,
+            uploadBase64Image: uploadBase64ImageCallback,
+        });
+        instrumentations.push(openAIInstrumentation);
+    }
+    if (!anthropicInstrumentation) {
+        anthropicInstrumentation = new instrumentationAnthropic.AnthropicInstrumentation({
+            exceptionLogger,
+        });
+        instrumentations.push(anthropicInstrumentation);
+    }
+    cohereInstrumentation = new instrumentationCohere.CohereInstrumentation({ exceptionLogger });
+    instrumentations.push(cohereInstrumentation);
+    vertexaiInstrumentation = new instrumentationVertexai.VertexAIInstrumentation({
+        exceptionLogger,
+    });
+    instrumentations.push(vertexaiInstrumentation);
+    aiplatformInstrumentation = new instrumentationVertexai.AIPlatformInstrumentation({
+        exceptionLogger,
+    });
+    instrumentations.push(aiplatformInstrumentation);
+    bedrockInstrumentation = new instrumentationBedrock.BedrockInstrumentation({ exceptionLogger });
+    instrumentations.push(bedrockInstrumentation);
+    pineconeInstrumentation = new instrumentationPinecone.PineconeInstrumentation({ exceptionLogger });
+    instrumentations.push(pineconeInstrumentation);
+    langchainInstrumentation = new instrumentationLangchain.LangChainInstrumentation({ exceptionLogger });
+    instrumentations.push(langchainInstrumentation);
+    llamaIndexInstrumentation = new instrumentationLlamaindex.LlamaIndexInstrumentation({
+        exceptionLogger,
+    });
+    instrumentations.push(llamaIndexInstrumentation);
+    chromadbInstrumentation = new instrumentationChromadb.ChromaDBInstrumentation({ exceptionLogger });
+    instrumentations.push(chromadbInstrumentation);
+    qdrantInstrumentation = new instrumentationQdrant.QdrantInstrumentation({ exceptionLogger });
+    instrumentations.push(qdrantInstrumentation);
+    togetherInstrumentation = new instrumentationTogether.TogetherInstrumentation({ exceptionLogger });
+    instrumentations.push(togetherInstrumentation);
+    mcpInstrumentation = new instrumentationMcp.McpInstrumentation({ exceptionLogger });
+    instrumentations.push(mcpInstrumentation);
+};
+const manuallyInitInstrumentations = (instrumentModules, apiKey, baseUrl) => {
+    const exceptionLogger = (e) => {
+        console.debug("[Traceloop] Instrumentation exception:", e.message);
+    };
+    const enrichTokens = (process.env.ANYWAY_ENRICH_TOKENS || "true").toLowerCase() === "true";
+    // Create image upload callback if we have credentials
+    let uploadBase64ImageCallback;
+    if (apiKey && baseUrl) {
+        const imageUploader = new ImageUploader(baseUrl, apiKey);
+        uploadBase64ImageCallback =
+            imageUploader.uploadBase64Image.bind(imageUploader);
+    }
+    // Clear the instrumentations array that was initialized by default
+    instrumentations.length = 0;
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.openAI) {
+        openAIInstrumentation = new instrumentationOpenai.OpenAIInstrumentation({
+            enrichTokens,
+            exceptionLogger,
+            uploadBase64Image: uploadBase64ImageCallback,
+        });
+        instrumentations.push(openAIInstrumentation);
+        openAIInstrumentation.manuallyInstrument(instrumentModules.openAI);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.anthropic) {
+        anthropicInstrumentation = new instrumentationAnthropic.AnthropicInstrumentation({
+            exceptionLogger,
+        });
+        instrumentations.push(anthropicInstrumentation);
+        anthropicInstrumentation.manuallyInstrument(instrumentModules.anthropic);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.cohere) {
+        cohereInstrumentation = new instrumentationCohere.CohereInstrumentation({ exceptionLogger });
+        instrumentations.push(cohereInstrumentation);
+        cohereInstrumentation.manuallyInstrument(instrumentModules.cohere);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.google_vertexai) {
+        vertexaiInstrumentation = new instrumentationVertexai.VertexAIInstrumentation({
+            exceptionLogger,
+        });
+        instrumentations.push(vertexaiInstrumentation);
+        vertexaiInstrumentation.manuallyInstrument(instrumentModules.google_vertexai);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.google_aiplatform) {
+        aiplatformInstrumentation = new instrumentationVertexai.AIPlatformInstrumentation({
+            exceptionLogger,
+        });
+        instrumentations.push(aiplatformInstrumentation);
+        aiplatformInstrumentation.manuallyInstrument(instrumentModules.google_aiplatform);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.bedrock) {
+        bedrockInstrumentation = new instrumentationBedrock.BedrockInstrumentation({ exceptionLogger });
+        instrumentations.push(bedrockInstrumentation);
+        bedrockInstrumentation.manuallyInstrument(instrumentModules.bedrock);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.pinecone) {
+        const instrumentation = new instrumentationPinecone.PineconeInstrumentation({ exceptionLogger });
+        instrumentations.push(instrumentation);
+        instrumentation.manuallyInstrument(instrumentModules.pinecone);
+    }
+    // Always enable LangChain instrumentation
+    langchainInstrumentation = new instrumentationLangchain.LangChainInstrumentation({
+        exceptionLogger,
+    });
+    instrumentations.push(langchainInstrumentation);
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.llamaIndex) {
+        llamaIndexInstrumentation = new instrumentationLlamaindex.LlamaIndexInstrumentation({
+            exceptionLogger,
+        });
+        instrumentations.push(llamaIndexInstrumentation);
+        llamaIndexInstrumentation.manuallyInstrument(instrumentModules.llamaIndex);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.chromadb) {
+        chromadbInstrumentation = new instrumentationChromadb.ChromaDBInstrumentation({ exceptionLogger });
+        instrumentations.push(chromadbInstrumentation);
+        chromadbInstrumentation.manuallyInstrument(instrumentModules.chromadb);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.qdrant) {
+        qdrantInstrumentation = new instrumentationQdrant.QdrantInstrumentation({ exceptionLogger });
+        instrumentations.push(qdrantInstrumentation);
+        qdrantInstrumentation.manuallyInstrument(instrumentModules.qdrant);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.together) {
+        togetherInstrumentation = new instrumentationTogether.TogetherInstrumentation({ exceptionLogger });
+        instrumentations.push(togetherInstrumentation);
+        togetherInstrumentation.manuallyInstrument(instrumentModules.together);
+    }
+    if (instrumentModules === null || instrumentModules === void 0 ? void 0 : instrumentModules.mcp) {
+        mcpInstrumentation = new instrumentationMcp.McpInstrumentation({ exceptionLogger });
+        instrumentations.push(mcpInstrumentation);
+        mcpInstrumentation.manuallyInstrument(instrumentModules.mcp);
+    }
+};
+/**
+ * Initializes the Traceloop SDK.
+ * Must be called once before any other SDK methods.
+ *
+ * @param options - The options to initialize the SDK. See the {@link InitializeOptions} for details.
+ * @throws {InitializationError} if the configuration is invalid or if failed to fetch feature data.
+ */
+const startTracing = (options) => {
+    var _a;
+    const apiKey = options.apiKey || process.env.ANYWAY_API_KEY;
+    const baseUrl = options.baseUrl ||
+        process.env.ANYWAY_BASE_URL ||
+        "https://api.traceloop.com";
+    if (Object.keys(options.instrumentModules || {}).length > 0) {
+        manuallyInitInstrumentations(options.instrumentModules, apiKey, baseUrl);
+    }
+    else {
+        // Initialize default instrumentations if no manual modules specified
+        initInstrumentations(apiKey, baseUrl);
+    }
+    if (!shouldSendTraces()) {
+        openAIInstrumentation === null || openAIInstrumentation === void 0 ? void 0 : openAIInstrumentation.setConfig({
+            traceContent: false,
+        });
+        llamaIndexInstrumentation === null || llamaIndexInstrumentation === void 0 ? void 0 : llamaIndexInstrumentation.setConfig({
+            traceContent: false,
+        });
+        vertexaiInstrumentation === null || vertexaiInstrumentation === void 0 ? void 0 : vertexaiInstrumentation.setConfig({
+            traceContent: false,
+        });
+        aiplatformInstrumentation === null || aiplatformInstrumentation === void 0 ? void 0 : aiplatformInstrumentation.setConfig({
+            traceContent: false,
+        });
+        bedrockInstrumentation === null || bedrockInstrumentation === void 0 ? void 0 : bedrockInstrumentation.setConfig({
+            traceContent: false,
+        });
+        cohereInstrumentation === null || cohereInstrumentation === void 0 ? void 0 : cohereInstrumentation.setConfig({
+            traceContent: false,
+        });
+        chromadbInstrumentation === null || chromadbInstrumentation === void 0 ? void 0 : chromadbInstrumentation.setConfig({
+            traceContent: false,
+        });
+        togetherInstrumentation === null || togetherInstrumentation === void 0 ? void 0 : togetherInstrumentation.setConfig({
+            traceContent: false,
+        });
+    }
+    const headers = options.headers ||
+        (process.env.ANYWAY_HEADERS
+            ? parseKeyPairsIntoRecord(process.env.ANYWAY_HEADERS)
+            : { Authorization: `Bearer ${options.apiKey}` });
+    const traceExporter = (_a = options.exporter) !== null && _a !== void 0 ? _a : (options.gcpProjectId
+        ? new opentelemetryCloudTraceExporter.TraceExporter({ projectId: options.gcpProjectId })
+        : new exporterTraceOtlpProto.OTLPTraceExporter({
+            url: `${baseUrl}/v1/traces`,
+            headers,
+        }));
+    _spanProcessor = createSpanProcessor({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        disableBatch: options.disableBatch,
+        exporter: traceExporter,
+        headers,
+        allowedInstrumentationLibraries: ALL_INSTRUMENTATION_LIBRARIES,
+    });
+    const spanProcessors = [_spanProcessor];
+    if (options.processor) {
+        spanProcessors.push(options.processor);
+    }
+    const resource = createResource({
+        [semanticConventions.ATTR_SERVICE_NAME]: options.appName || process.env.npm_package_name || "unknown_service",
+    });
+    _sdk = new sdkNode.NodeSDK({
+        resource,
+        spanProcessors,
+        contextManager: options.contextManager,
+        textMapPropagator: options.propagator,
+        traceExporter,
+        instrumentations,
+        // We should re-consider removing irrelevant spans here in the future
+        // sampler: new TraceloopSampler(),
+    });
+    _sdk.start();
+};
+const shouldSendTraces = () => {
+    if (!_configuration) {
+        api.diag.warn("Traceloop not initialized");
+        return false;
+    }
+    const contextShouldSendPrompts = api.context
+        .active()
+        .getValue(aiSemanticConventions.CONTEXT_KEY_ALLOW_TRACE_CONTENT);
+    if (contextShouldSendPrompts !== undefined) {
+        return contextShouldSendPrompts;
+    }
+    if (_configuration.traceContent === false ||
+        (process.env.ANYWAY_TRACE_CONTENT || "true").toLowerCase() === "false") {
+        return false;
+    }
+    return true;
+};
+const forceFlush = async () => {
+    await _spanProcessor.forceFlush();
+};
+// Compatibility function for creating resources that works with both OTel v1.x and v2.x
+function createResource(attributes) {
+    // Import the resource module at runtime to handle both v1.x and v2.x
+    const resourcesModule = require("@opentelemetry/resources");
+    // Try to use resourceFromAttributes if it exists (OTel v2.x)
+    if (resourcesModule.resourceFromAttributes) {
+        return resourcesModule.resourceFromAttributes(attributes);
+    }
+    // Fallback to constructor for OTel v1.x
+    return new resourcesModule.Resource(attributes);
+}
+
+const fetchRetry = fetchBuilder(fetch$1);
+const fetchPrompts = async (options) => {
+    const { apiKey, baseUrl, traceloopSyncMaxRetries } = options;
+    const response = await fetchRetry(`${baseUrl}/v1/traceloop/prompts`, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+            "X-Traceloop-SDK-Version": "0.0.30",
+        },
+        retries: traceloopSyncMaxRetries,
+        retryOn: function (attempt, error, response) {
+            if (attempt >= traceloopSyncMaxRetries)
+                return false;
+            if ((response === null || response === void 0 ? void 0 : response.status) && response.status >= 500) {
+                return true;
+            }
+            return false;
+        },
+        retryDelay: function (attempt) {
+            return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+        },
+    });
+    return await response.json();
+};
+
+const _prompts = {};
+let _initialized = false;
+let _initializedPromise;
+/**
+ * Returns true once SDK prompt registry has been initialized, else rejects with an error.
+ * @returns Promise<boolean>
+ */
+const waitForInitialization = async () => {
+    if (_initialized) {
+        return true;
+    }
+    return await _initializedPromise;
+};
+const getPromptByKey = (key) => {
+    if (!_prompts[key]) {
+        throw new PromptNotFoundError(key);
+    }
+    return _prompts[key];
+};
+const populateRegistry = (prompts) => {
+    prompts === null || prompts === void 0 ? void 0 : prompts.forEach((prompt) => {
+        _prompts[prompt.key] = prompt;
+    });
+};
+const initializeRegistry = (options) => {
+    const { baseUrl, traceloopSyncEnabled, traceloopSyncPollingInterval, traceloopSyncDevPollingInterval, } = options;
+    if (!traceloopSyncEnabled || !(baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.includes("traceloop")))
+        return;
+    let pollingInterval = traceloopSyncPollingInterval;
+    _initializedPromise = fetchPrompts(options)
+        .then(({ prompts, environment }) => {
+        if (environment === "dev") {
+            pollingInterval = traceloopSyncDevPollingInterval;
+        }
+        populateRegistry(prompts);
+        _initialized = true;
+        setInterval(async () => {
+            try {
+                const { prompts } = await fetchPrompts(options);
+                populateRegistry(prompts);
+            }
+            catch (err) {
+                api.diag.error("Failed to fetch prompt data", err);
+            }
+        }, pollingInterval * 1000).unref();
+        return true;
+    })
+        .catch((e) => {
+        throw new InitializationError("Failed to fetch prompt data to initialize Traceloop SDK", e);
+    });
+};
+
+let _configuration;
+let _client;
+/**
+ * Initializes the Traceloop SDK and creates a singleton client instance if API key is provided.
+ * Must be called once before any other SDK methods.
+ *
+ * @param options - The options to initialize the SDK. See the {@link InitializeOptions} for details.
+ * @returns TraceloopClient - The singleton client instance if API key is provided, otherwise undefined.
+ * @throws {InitializationError} if the configuration is invalid or if failed to fetch feature data.
+ *
+ * @example
+ * ```typescript
+ * initialize({
+ *   apiKey: 'your-api-key',
+ *   appName: 'your-app',
+ * });
+ * ```
+ */
+const initialize = (options = {}) => {
+    if (_configuration) {
+        return;
+    }
+    if (!options.baseUrl) {
+        options.baseUrl =
+            process.env.ANYWAY_BASE_URL || "https://api.traceloop.com";
+    }
+    if (!options.apiKey) {
+        options.apiKey = process.env.ANYWAY_API_KEY;
+    }
+    if (!options.appName) {
+        options.appName = process.env.npm_package_name;
+    }
+    if (!options.experimentSlug) {
+        options.experimentSlug = process.env.ANYWAY_EXP_SLUG;
+    }
+    if (options.traceloopSyncEnabled === undefined) {
+        if (process.env.ANYWAY_SYNC_ENABLED !== undefined) {
+            options.traceloopSyncEnabled = ["1", "true"].includes(process.env.ANYWAY_SYNC_ENABLED.toLowerCase());
+        }
+        else {
+            options.traceloopSyncEnabled = true;
+        }
+    }
+    if (options.traceloopSyncEnabled) {
+        if (!options.traceloopSyncMaxRetries) {
+            options.traceloopSyncMaxRetries =
+                Number(process.env.ANYWAY_SYNC_MAX_RETRIES) || 3;
+        }
+        if (!options.traceloopSyncPollingInterval) {
+            options.traceloopSyncPollingInterval =
+                Number(process.env.ANYWAY_SYNC_POLLING_INTERVAL) || 60;
+        }
+        if (!options.traceloopSyncDevPollingInterval) {
+            options.traceloopSyncDevPollingInterval =
+                Number(process.env.ANYWAY_SYNC_DEV_POLLING_INTERVAL) || 5;
+        }
+    }
+    validateConfiguration(options);
+    _configuration = Object.freeze(options);
+    if (!options.silenceInitializationMessage) {
+        console.log(`Traceloop exporting traces to ${_configuration.exporter ? "a custom exporter" : _configuration.baseUrl}`);
+    }
+    if (options.tracingEnabled === undefined || options.tracingEnabled) {
+        if (options.logLevel) {
+            api.diag.setLogger(new api.DiagConsoleLogger(), logLevelToOtelLogLevel(options.logLevel));
+        }
+        startTracing(_configuration);
+    }
+    initializeRegistry(_configuration);
+    if (options.apiKey) {
+        _client = new TraceloopClient({
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            appName: options.appName,
+            experimentSlug: options.experimentSlug,
+        });
+        return _client;
+    }
+    return;
+};
+const logLevelToOtelLogLevel = (logLevel) => {
+    switch (logLevel) {
+        case "debug":
+            return api.DiagLogLevel.DEBUG;
+        case "info":
+            return api.DiagLogLevel.INFO;
+        case "warn":
+            return api.DiagLogLevel.WARN;
+        case "error":
+            return api.DiagLogLevel.ERROR;
+    }
+};
+/**
+ * Gets the singleton instance of the TraceloopClient.
+ * The SDK must be initialized with an API key before calling this function.
+ *
+ * @returns The TraceloopClient singleton instance
+ * @throws {Error} if the SDK hasn't been initialized or was initialized without an API key
+ *
+ * @example
+ * ```typescript
+ * const client = getClient();
+ * await client.annotation.create({ annotationTask: 'taskId', entityInstanceId: 'entityId', tags: { score: 0.9 } });
+ * ```
+ */
+const getClient = () => {
+    if (!_client) {
+        throw new Error("Traceloop must be initialized before getting client, Call initialize() first." +
+            "If you already called initialize(), make sure you have an api key.");
+    }
+    return _client;
+};
+
+function withEntity(type, { name, version, associationProperties, conversationId, traceContent: overrideTraceContent, inputParameters, suppressTracing: shouldSuppressTracing, }, fn, thisArg, ...args) {
+    let entityContext = api.context.active();
+    if (type === aiSemanticConventions.TraceloopSpanKindValues.WORKFLOW ||
+        type === aiSemanticConventions.TraceloopSpanKindValues.AGENT) {
+        entityContext = entityContext.setValue(WORKFLOW_NAME_KEY, name);
+    }
+    if (type === aiSemanticConventions.TraceloopSpanKindValues.AGENT) {
+        entityContext = entityContext.setValue(AGENT_NAME_KEY, name);
+    }
+    const entityPath = getEntityPath(entityContext);
+    if (type === aiSemanticConventions.TraceloopSpanKindValues.TOOL ||
+        type === aiSemanticConventions.TraceloopSpanKindValues.TASK) {
+        const fullEntityName = entityPath ? `${entityPath}.${name}` : name;
+        entityContext = entityContext.setValue(ENTITY_NAME_KEY, fullEntityName);
+    }
+    if (overrideTraceContent != undefined) {
+        entityContext = entityContext.setValue(aiSemanticConventions.CONTEXT_KEY_ALLOW_TRACE_CONTENT, overrideTraceContent);
+    }
+    if (associationProperties) {
+        entityContext = entityContext.setValue(ASSOCATION_PROPERTIES_KEY, associationProperties);
+    }
+    if (conversationId) {
+        entityContext = entityContext.setValue(CONVERSATION_ID_KEY, conversationId);
+    }
+    if (shouldSuppressTracing) {
+        entityContext = core.suppressTracing(entityContext);
+    }
+    return api.context.with(entityContext, () => getTracer().startActiveSpan(`${name}.${type}`, {}, entityContext, async (span) => {
+        if (type === aiSemanticConventions.TraceloopSpanKindValues.WORKFLOW ||
+            type === aiSemanticConventions.TraceloopSpanKindValues.AGENT) {
+            span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_WORKFLOW_NAME, name);
+        }
+        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_NAME, name);
+        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_PATH, entityPath || "");
+        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_SPAN_KIND, type);
+        // Set agent name on all spans when there's an active agent context
+        const agentName = entityContext.getValue(AGENT_NAME_KEY);
+        if (agentName) {
+            span.setAttribute(incubating.ATTR_GEN_AI_AGENT_NAME, agentName);
+        }
+        // Set conversation ID on all spans when there's an active conversation context
+        const conversationId = entityContext.getValue(CONVERSATION_ID_KEY);
+        if (conversationId) {
+            span.setAttribute(incubating.ATTR_GEN_AI_CONVERSATION_ID, conversationId);
+        }
+        if (version) {
+            span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_VERSION, version);
+        }
+        if (shouldSendTraces()) {
+            try {
+                const input = inputParameters !== null && inputParameters !== void 0 ? inputParameters : args;
+                if (input.length === 1 &&
+                    typeof input[0] === "object" &&
+                    !(input[0] instanceof Map)) {
+                    span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_INPUT, serialize({ args: [], kwargs: input[0] }));
+                }
+                else {
+                    span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_INPUT, serialize({
+                        args: input,
+                        kwargs: {},
+                    }));
+                }
+            }
+            catch (error) {
+                console.debug("Error setting input attributes", error);
+            }
+        }
+        const res = fn.apply(thisArg, args);
+        if (res instanceof Promise) {
+            return res.then((resolvedRes) => {
+                try {
+                    if (shouldSendTraces()) {
+                        span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, serialize(resolvedRes));
+                    }
+                }
+                catch (error) {
+                    console.debug("Error setting output attributes", error);
+                }
+                finally {
+                    span.end();
+                }
+                return resolvedRes;
+            });
+        }
+        try {
+            if (shouldSendTraces()) {
+                span.setAttribute(aiSemanticConventions.SpanAttributes.TRACELOOP_ENTITY_OUTPUT, serialize(res));
+            }
+        }
+        catch (error) {
+            console.debug("Error setting output attributes", error);
+        }
+        finally {
+            span.end();
+        }
+        return res;
+    }));
+}
+function withWorkflow(config, fn, ...args) {
+    return withEntity(aiSemanticConventions.TraceloopSpanKindValues.WORKFLOW, config, fn, undefined, ...args);
+}
+function withTask(config, fn, ...args) {
+    return withEntity(aiSemanticConventions.TraceloopSpanKindValues.TASK, config, fn, undefined, ...args);
+}
+function withAgent(config, fn, ...args) {
+    return withEntity(aiSemanticConventions.TraceloopSpanKindValues.AGENT, config, fn, undefined, ...args);
+}
+function withTool(config, fn, ...args) {
+    return withEntity(aiSemanticConventions.TraceloopSpanKindValues.TOOL, config, fn, undefined, ...args);
+}
+function entity(type, config) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            var _a;
+            let actualConfig;
+            if (typeof config === "function") {
+                actualConfig = config(this, ...args);
+            }
+            else {
+                actualConfig = config;
+            }
+            const entityName = (_a = actualConfig.name) !== null && _a !== void 0 ? _a : originalMethod.name;
+            return withEntity(type, Object.assign(Object.assign({}, actualConfig), { name: entityName }), originalMethod, this, ...args);
+        };
+    };
+}
+function workflow(config) {
+    return entity(aiSemanticConventions.TraceloopSpanKindValues.WORKFLOW, config !== null && config !== void 0 ? config : {});
+}
+function task(config) {
+    return entity(aiSemanticConventions.TraceloopSpanKindValues.TASK, config !== null && config !== void 0 ? config : {});
+}
+function agent(config) {
+    return entity(aiSemanticConventions.TraceloopSpanKindValues.AGENT, config !== null && config !== void 0 ? config : {});
+}
+function tool(config) {
+    return entity(aiSemanticConventions.TraceloopSpanKindValues.TOOL, config !== null && config !== void 0 ? config : {});
+}
+function withConversation(conversationId, fn, thisArg, ...args) {
+    const conversationContext = api.context
+        .active()
+        .setValue(CONVERSATION_ID_KEY, conversationId);
+    return api.context.with(conversationContext, () => withEntity(aiSemanticConventions.TraceloopSpanKindValues.WORKFLOW, { name: `conversation.${conversationId}` }, fn, thisArg, ...args));
+}
+function conversation(conversationId) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            let actualConversationId;
+            if (typeof conversationId === "function") {
+                actualConversationId = conversationId(this, ...args);
+            }
+            else {
+                actualConversationId = conversationId;
+            }
+            return withConversation(actualConversationId, originalMethod, this, ...args);
+        };
+    };
+}
+function cleanInput(input) {
+    if (input instanceof Map) {
+        return Array.from(input.entries());
+    }
+    else if (Array.isArray(input)) {
+        return input.map((value) => cleanInput(value));
+    }
+    else if (!input) {
+        return input;
+    }
+    else if (typeof input === "object") {
+        // serialize object one by one
+        const output = {};
+        Object.entries(input).forEach(([key, value]) => {
+            output[key] = cleanInput(value);
+        });
+        return output;
+    }
+    return input;
+}
+function serialize(input) {
+    return JSON.stringify(cleanInput(input));
+}
+
+class VectorSpan {
+    constructor(span) {
+        this.span = span;
+    }
+    reportQuery({ queryVector }) {
+        if (!shouldSendTraces()) {
+            this.span.addEvent(aiSemanticConventions.Events.DB_QUERY_EMBEDDINGS);
+        }
+        this.span.addEvent(aiSemanticConventions.Events.DB_QUERY_EMBEDDINGS, {
+            [aiSemanticConventions.EventAttributes.DB_QUERY_EMBEDDINGS_VECTOR]: JSON.stringify(queryVector),
+        });
+    }
+    reportResults({ results, }) {
+        for (let i = 0; i < results.length; i++) {
+            this.span.addEvent(aiSemanticConventions.Events.DB_QUERY_RESULT, {
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_ID]: results[i].ids,
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_SCORE]: results[i].scores,
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_DISTANCE]: results[i].distances,
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_METADATA]: JSON.stringify(results[i].metadata),
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_VECTOR]: results[i].vectors,
+                [aiSemanticConventions.EventAttributes.DB_QUERY_RESULT_DOCUMENT]: results[i].documents,
+            });
+        }
+    }
+}
+class LLMSpan {
+    constructor(span) {
+        this.span = span;
+    }
+    reportRequest({ model, messages, }) {
+        this.span.setAttributes({
+            [incubating.ATTR_GEN_AI_REQUEST_MODEL]: model,
+        });
+        messages.forEach((message, index) => {
+            this.span.setAttributes({
+                [`${incubating.ATTR_GEN_AI_PROMPT}.${index}.role`]: message.role,
+                [`${incubating.ATTR_GEN_AI_PROMPT}.${index}.content`]: typeof message.content === "string"
+                    ? message.content
+                    : JSON.stringify(message.content),
+            });
+        });
+    }
+    reportResponse({ model, usage, completions, }) {
+        this.span.setAttribute(incubating.ATTR_GEN_AI_RESPONSE_MODEL, model);
+        if (usage) {
+            this.span.setAttributes({
+                [incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS]: usage.prompt_tokens,
+                [incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: usage.completion_tokens,
+                [aiSemanticConventions.SpanAttributes.LLM_USAGE_TOTAL_TOKENS]: usage.total_tokens,
+            });
+        }
+        completions === null || completions === void 0 ? void 0 : completions.forEach((completion, index) => {
+            this.span.setAttributes({
+                [`${incubating.ATTR_GEN_AI_COMPLETION}.${index}.finish_reason`]: completion.finish_reason,
+                [`${incubating.ATTR_GEN_AI_COMPLETION}.${index}.role`]: completion.message.role,
+                [`${incubating.ATTR_GEN_AI_COMPLETION}.${index}.content`]: completion.message.content || "",
+            });
+        });
+    }
+}
+function withVectorDBCall({ vendor, type }, fn, thisArg) {
+    const entityContext = api.context.active();
+    return getTracer().startActiveSpan(`${vendor}.${type}`, { [aiSemanticConventions.SpanAttributes.LLM_REQUEST_TYPE]: type }, entityContext, (span) => {
+        // Set agent name if there's an active agent context
+        const agentName = entityContext.getValue(AGENT_NAME_KEY);
+        if (agentName) {
+            span.setAttribute(incubating.ATTR_GEN_AI_AGENT_NAME, agentName);
+        }
+        const res = fn.apply(thisArg, [{ span: new VectorSpan(span) }]);
+        if (res instanceof Promise) {
+            return res.then((resolvedRes) => {
+                span.end();
+                return resolvedRes;
+            });
+        }
+        span.end();
+        return res;
+    });
+}
+function withLLMCall({ vendor, type }, fn, thisArg) {
+    const currentContext = api.context.active();
+    const span = getTracer().startSpan(`${vendor}.${type}`, {}, currentContext);
+    span.setAttribute(aiSemanticConventions.SpanAttributes.LLM_REQUEST_TYPE, type);
+    // Set agent name if there's an active agent context
+    const agentName = currentContext.getValue(AGENT_NAME_KEY);
+    if (agentName) {
+        span.setAttribute(incubating.ATTR_GEN_AI_AGENT_NAME, agentName);
+    }
+    api.trace.setSpan(currentContext, span);
+    const res = fn.apply(thisArg, [{ span: new LLMSpan(span) }]);
+    if (res instanceof Promise) {
+        return res.then((resolvedRes) => {
+            span.end();
+            return resolvedRes;
+        });
+    }
+    span.end();
+    return res;
+}
+
+function withAssociationProperties(properties, fn, thisArg, ...args) {
+    if (Object.keys(properties).length === 0) {
+        return fn.apply(thisArg, args);
+    }
+    const newContext = api.context
+        .active()
+        .setValue(ASSOCATION_PROPERTIES_KEY, properties);
+    return api.context.with(newContext, fn, thisArg, ...args);
+}
+
+/**
+ * Reports a custom metric to the current active span.
+ *
+ * This function allows you to add a custom metric to the current span in the trace.
+ * If there is no active span, a warning will be logged.
+ *
+ * @param {string} metricName - The name of the custom metric.
+ * @param {number} metricValue - The numeric value of the custom metric.
+ *
+ * @example
+ * reportCustomMetric('processing_time', 150);
+ */
+const reportCustomMetric = (metricName, metricValue) => {
+    const currentContext = api.context.active();
+    const currentSpan = api.trace.getSpan(currentContext);
+    if (currentSpan) {
+        currentSpan.setAttribute(`traceloop.custom_metric.${metricName}`, metricValue);
+    }
+    else {
+        api.diag.warn(`No active span found to report custom metric: ${metricName}`);
+    }
+};
+
+const TEMPLATING_ENGINE = {
+    JINJA2: "jinja2",
+};
+
+const env = new nunjucks.Environment(null, {
+    throwOnUndefined: true, // throw error if param not found
+});
+const renderMessages = (promptVersion, variables) => {
+    if (promptVersion.templating_engine === TEMPLATING_ENGINE.JINJA2) {
+        return promptVersion.messages.map((message) => {
+            try {
+                if (typeof message.template === "string") {
+                    return {
+                        content: env.renderString(message.template, variables),
+                        role: message.role,
+                    };
+                }
+                else {
+                    return {
+                        content: message.template.map((content) => {
+                            if (content.type === "text") {
+                                return {
+                                    type: "text",
+                                    text: env.renderString(content.text, variables),
+                                };
+                            }
+                            else {
+                                return content;
+                            }
+                        }),
+                        role: message.role,
+                    };
+                }
+            }
+            catch (err) {
+                throw new TraceloopError(`Failed to render message template. Missing variables?`);
+            }
+        });
+    }
+    else {
+        throw new TraceloopError(`Templating engine ${promptVersion.templating_engine} is not supported`);
+    }
+};
+
+const getEffectiveVersion = (prompt) => {
+    const version = prompt.versions.find((v) => v.id === prompt.target.version);
+    if (!version) {
+        throw new TraceloopError(`Prompt version ${prompt.target.version} not found`);
+    }
+    return version;
+};
+const managedPromptTracingAttributes = (prompt, promptVersion, variables) => {
+    const variableAttributes = Object.keys(variables).reduce((acc, key) => {
+        acc[`traceloop.prompt.template_variables.${key}`] = variables[key];
+        return acc;
+    }, {});
+    return Object.assign({ "traceloop.prompt.key": prompt.key, "traceloop.prompt.version": promptVersion.version, "traceloop.prompt.version_hash": promptVersion.hash, "traceloop.prompt.version_name": promptVersion.name }, variableAttributes);
+};
+const getPrompt = (key, variables) => {
+    var _a;
+    const prompt = getPromptByKey(key);
+    const promptVersion = getEffectiveVersion(prompt);
+    let result = {}; //TODO - SDK needs to do work specific to each vendor/model? maybe we do this in the backend?
+    if (promptVersion.llm_config.mode === "completion") {
+        const message = renderMessages(promptVersion, variables);
+        result = Object.assign(Object.assign({}, promptVersion.llm_config), { prompt: (_a = message === null || message === void 0 ? void 0 : message[0]) === null || _a === void 0 ? void 0 : _a.content });
+    }
+    else {
+        result = Object.assign({ messages: renderMessages(promptVersion, variables) }, promptVersion.llm_config);
+    }
+    if ((result === null || result === void 0 ? void 0 : result["stop"].length) === 0)
+        delete result["stop"];
+    delete result["mode"];
+    result.extraAttributes = managedPromptTracingAttributes(prompt, promptVersion, variables);
+    return result;
+};
+
+/**
+ * Standard association properties for tracing.
+ * Use these with withAssociationProperties() or decorator associationProperties config.
+ *
+ * @example
+ * ```typescript
+ * // With withAssociationProperties
+ * await traceloop.withAssociationProperties(
+ *   {
+ *     [traceloop.AssociationProperty.USER_ID]: "12345",
+ *     [traceloop.AssociationProperty.SESSION_ID]: "session-abc"
+ *   },
+ *   async () => {
+ *     await chat();
+ *   }
+ * );
+ *
+ * // With decorator
+ * @traceloop.workflow((thisArg) => ({
+ *   name: "my_workflow",
+ *   associationProperties: {
+ *     [traceloop.AssociationProperty.USER_ID]: (thisArg as MyClass).userId,
+ *   },
+ * }))
+ * ```
+ */
+exports.AssociationProperty = void 0;
+(function (AssociationProperty) {
+    AssociationProperty["CUSTOMER_ID"] = "customer_id";
+    AssociationProperty["USER_ID"] = "user_id";
+    AssociationProperty["SESSION_ID"] = "session_id";
+})(exports.AssociationProperty || (exports.AssociationProperty = {}));
+
+exports.ALL_INSTRUMENTATION_LIBRARIES = ALL_INSTRUMENTATION_LIBRARIES;
+exports.ArgumentNotProvidedError = ArgumentNotProvidedError;
+exports.Attachment = Attachment;
+exports.AttachmentReference = AttachmentReference;
+exports.AttachmentUploader = AttachmentUploader;
+exports.Column = Column;
+exports.Dataset = Dataset;
+exports.Datasets = Datasets;
+exports.Evaluator = Evaluator;
+exports.EvaluatorMadeByTraceloop = EvaluatorMadeByTraceloop;
+exports.Experiment = Experiment;
+exports.ExternalAttachment = ExternalAttachment;
+exports.ImageUploader = ImageUploader;
+exports.InitializationError = InitializationError;
+exports.LLMSpan = LLMSpan;
+exports.NotInitializedError = NotInitializedError;
+exports.PromptNotFoundError = PromptNotFoundError;
+exports.Row = Row;
+exports.SEVERITY = SEVERITY;
+exports.TraceloopClient = TraceloopClient;
+exports.TraceloopError = TraceloopError;
+exports.VectorSpan = VectorSpan;
+exports.agent = agent;
+exports.attachment = attachment;
+exports.conversation = conversation;
+exports.createEvaluator = createEvaluator;
+exports.createSpanProcessor = createSpanProcessor;
+exports.forceFlush = forceFlush;
+exports.getAvailableEvaluatorSlugs = getAvailableEvaluatorSlugs;
+exports.getClient = getClient;
+exports.getEvaluatorSchemaInfo = getEvaluatorSchemaInfo;
+exports.getPrompt = getPrompt;
+exports.getTraceloopTracer = getTraceloopTracer;
+exports.initialize = initialize;
+exports.isAnyAttachment = isAnyAttachment;
+exports.isAttachment = isAttachment;
+exports.isAttachmentReference = isAttachmentReference;
+exports.isExternalAttachment = isExternalAttachment;
+exports.reportCustomMetric = reportCustomMetric;
+exports.task = task;
+exports.tool = tool;
+exports.traceloopInstrumentationLibraries = traceloopInstrumentationLibraries;
+exports.validateEvaluatorInput = validateEvaluatorInput;
+exports.waitForInitialization = waitForInitialization;
+exports.withAgent = withAgent;
+exports.withAssociationProperties = withAssociationProperties;
+exports.withConversation = withConversation;
+exports.withLLMCall = withLLMCall;
+exports.withTask = withTask;
+exports.withTool = withTool;
+exports.withVectorDBCall = withVectorDBCall;
+exports.withWorkflow = withWorkflow;
+exports.workflow = workflow;
+//# sourceMappingURL=index.js.map