@anyway-sh/node-server-sdk 0.22.8

package/dist/index.d.ts

@@ -0,0 +1,1957 @@
+import { SpanExporter, SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { TextMapPropagator, ContextManager, Span } from '@opentelemetry/api';
+import * as openai from 'openai';
+import * as anthropic from '@anthropic-ai/sdk';
+import * as cohere from 'cohere-ai';
+import * as bedrock from '@aws-sdk/client-bedrock-runtime';
+import * as aiplatform from '@google-cloud/aiplatform';
+import * as vertexAI from '@google-cloud/vertexai';
+import * as pinecone from '@pinecone-database/pinecone';
+import * as together from 'together-ai';
+import * as llamaindex from 'llamaindex';
+import * as chromadb from 'chromadb';
+import * as qdrant from '@qdrant/js-client-rest';
+import * as mcp from '@modelcontextprotocol/sdk/client/index.js';
+import { SpanProcessor as SpanProcessor$1 } from '@opentelemetry/sdk-trace-node';
+
+/**
+ * The severity of an error.
+ */
+declare const SEVERITY: {
+    readonly Warning: "Warning";
+    readonly Error: "Error";
+    readonly Critical: "Critical";
+};
+type Severity = (typeof SEVERITY)[keyof typeof SEVERITY];
+/**
+ * Base class for all Traceloop errors.
+ */
+declare class TraceloopError extends Error {
+    /**
+     * The severity of the error.
+     */
+    severity: Severity;
+    /**
+     * The underlying cause of the error.
+     */
+    underlyingCause?: Error;
+    constructor(message: string, severity?: Severity);
+}
+declare class NotInitializedError extends TraceloopError {
+    constructor();
+}
+declare class InitializationError extends TraceloopError {
+    constructor(message?: string, cause?: Error);
+}
+declare class ArgumentNotProvidedError extends TraceloopError {
+    constructor(argumentName: string);
+}
+declare class PromptNotFoundError extends TraceloopError {
+    constructor(key: string);
+}
+
+/**
+ * Options for initializing the Traceloop SDK.
+ */
+interface InitializeOptions {
+    /**
+     * The app name to be used when reporting traces. Optional.
+     * Defaults to the package name.
+     */
+    appName?: string;
+    /**
+     * The API Key for sending traces data. Optional.
+     * Defaults to the ANYWAY_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * The OTLP endpoint for sending traces data. Optional.
+     * Defaults to ANYWAY_BASE_URL environment variable or https://api.traceloop.com/
+     */
+    baseUrl?: string;
+    /**
+     * Sends traces and spans without batching, for local developement. Optional.
+     * Defaults to false.
+     */
+    disableBatch?: boolean;
+    /**
+     * Defines default log level for SDK and all instrumentations. Optional.
+     * Defaults to error.
+     */
+    logLevel?: "debug" | "info" | "warn" | "error";
+    /**
+     * Whether to log prompts, completions and embeddings on traces. Optional.
+     * Defaults to true.
+     */
+    traceContent?: boolean;
+    /**
+     * The OpenTelemetry SpanExporter to be used for sending traces data. Optional.
+     * Defaults to the OTLP exporter.
+     */
+    exporter?: SpanExporter;
+    /**
+     * The headers to be sent with the traces data. Optional.
+     */
+    headers?: Record<string, string>;
+    /**
+     * The OpenTelemetry SpanProcessor to be used for processing traces data. Optional.
+     * Defaults to the BatchSpanProcessor.
+     */
+    processor?: SpanProcessor;
+    /**
+     * The OpenTelemetry Propagator to use. Optional.
+     * Defaults to OpenTelemetry SDK defaults.
+     */
+    propagator?: TextMapPropagator;
+    /**
+     * The OpenTelemetry ContextManager to use. Optional.
+     * Defaults to OpenTelemetry SDK defaults.
+     */
+    contextManager?: ContextManager;
+    /**
+     * Explicitly specify modules to instrument. Optional.
+     * This is a workaround specific to Next.js, see https://www.traceloop.com/docs/openllmetry/getting-started-nextjs
+     */
+    instrumentModules?: {
+        openAI?: typeof openai.OpenAI;
+        anthropic?: typeof anthropic;
+        cohere?: typeof cohere;
+        bedrock?: typeof bedrock;
+        google_vertexai?: typeof vertexAI;
+        google_aiplatform?: typeof aiplatform;
+        pinecone?: typeof pinecone;
+        together?: typeof together.Together;
+        langchain?: boolean;
+        llamaIndex?: typeof llamaindex;
+        chromadb?: typeof chromadb;
+        qdrant?: typeof qdrant;
+        mcp?: typeof mcp;
+    };
+    /**
+     * Enables sync with Traceloop servers for the prompt registry functionality. Optional.
+     * Defaults to ANYWAY_SYNC_ENABLED environment variable or true if not set.
+     */
+    traceloopSyncEnabled?: boolean;
+    /**
+     * Defines the number of retires when fetching prompt data for the registry. Optional.
+     * Defaults to ANYWAY_SYNC_MAX_RETRIES environment variable or 3 if not set.
+     */
+    traceloopSyncMaxRetries?: number;
+    /**
+     * Defines the polling interval for the prompt registry. Optional.
+     * Defaults to ANYWAY_SYNC_POLLING_INTERVAL environment variable or 60 if not set.
+     */
+    traceloopSyncPollingInterval?: number;
+    /**
+     * Defines the polling interval for the prompt registry. Optional.
+     * Defaults to ANYWAY_SYNC_DEV_POLLING_INTERVAL environment variable or 5 if not set.
+     */
+    traceloopSyncDevPollingInterval?: number;
+    /**
+     * Whether to silence the initialization message. Optional.
+     * Defaults to false.
+     */
+    silenceInitializationMessage?: boolean;
+    /**
+     * Whether to enable tracing. Optional.
+     * Defaults to true.
+     */
+    tracingEnabled?: boolean;
+    /**
+     * The experiment slug to use when running experiments. Optional.
+     * Defaults to the ANYWAY_EXP_SLUG environment variable.
+     */
+    experimentSlug?: string;
+    /**
+     * The Google Cloud Project ID for sending traces data. Optional.
+     * This is used to configure the Google Cloud Trace Exporter.
+     */
+    gcpProjectId?: string;
+}
+
+/**
+ * Represents an entity in the system that can be annotated.
+ * An entity is typically a unit of content or interaction that needs to be tracked or evaluated.
+ * It is reported as an association property before the annotation is created.
+ */
+interface Entity {
+    /**
+     * Unique identifier for the entity.
+     * This could be a user ID, conversation ID, or any other unique identifier in your system.
+     */
+    id: string;
+}
+/**
+ * Configuration options for creating a new annotation.
+ * Annotations are used to attach metadata, feedback, or evaluation results to specific entities.
+ */
+interface AnnotationCreateOptions {
+    /**
+     * The identifier of the annotation task.
+     * The ID or slug of the annotation task, Can be found at app.traceloop.com/annotation_tasks/:annotationTaskId   */
+    annotationTask: string;
+    /**
+     * The entity to be annotated.
+     * Contains the entity's identifier and optional type information.
+     * Be sure to report the entity instance ID as the association property before
+     * in order to correctly correlate the annotation to the relevant context.
+     */
+    entity: Entity;
+    /**
+     * Key-value pairs of annotation data, should match the tags defined in the annotation task
+     */
+    tags: Record<string, TagValue>;
+}
+type TagValue = string | number | string[];
+
+interface TraceloopClientOptions {
+    apiKey: string;
+    appName: string;
+    baseUrl?: string;
+    experimentSlug?: string;
+}
+
+interface DatasetCreateOptions {
+    name: string;
+    slug?: string;
+    description?: string;
+}
+interface DatasetUpdateOptions {
+    name?: string;
+    description?: string;
+}
+interface DatasetResponse {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string;
+    version?: string;
+    published?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    columns?: Record<string, any>;
+    rows?: RowResponse[];
+}
+interface ColumnDefinition {
+    name: string;
+    type: "string" | "number" | "boolean" | "date" | "file";
+    slug?: string;
+    required?: boolean;
+    description?: string;
+}
+interface ColumnResponse extends ColumnDefinition {
+    slug: string;
+    datasetId: string;
+    datasetSlug: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ColumnUpdateOptions {
+    name?: string;
+    type?: "string" | "number" | "boolean" | "date" | "file";
+    required?: boolean;
+    description?: string;
+}
+interface RowData {
+    [key: string]: string | number | boolean | null | object;
+}
+interface RowResponse {
+    id: string;
+    datasetId: string;
+    datasetSlug: string;
+    data: RowData;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RowUpdateOptions {
+    data: Partial<RowData>;
+}
+interface DatasetListResponse {
+    datasets: DatasetResponse[];
+    total: number;
+}
+interface DatasetPublishOptions {
+    version?: string;
+    description?: string;
+}
+interface CSVImportOptions {
+    hasHeader?: boolean;
+    delimiter?: string;
+    encoding?: string;
+}
+interface DatasetVersion {
+    version: string;
+    publishedBy: string;
+    publishedAt: string;
+}
+interface DatasetVersionsResponse {
+    datasetId: string;
+    datasetSlug: string;
+    versions: DatasetVersion[];
+    total: number;
+}
+type DatasetColumnValue = string | number | boolean | null | undefined;
+
+interface StreamEvent {
+    type: "progress" | "result" | "error" | "complete";
+    data: any;
+    timestamp: string;
+    id?: string;
+    event?: string;
+}
+interface EvaluatorRunOptions {
+    experimentId: string;
+    experimentRunId?: string;
+    taskId: string;
+    taskResult: Record<string, any>;
+    evaluator: EvaluatorDetails;
+    waitForResults?: boolean;
+    timeout?: number;
+}
+interface EvaluatorResult {
+    evaluatorName: string;
+    taskId?: string;
+    score?: number;
+    result?: any;
+    metadata?: Record<string, any>;
+    error?: string;
+}
+interface TriggerEvaluatorRequest {
+    experimentId: string;
+    experimentRunId?: string;
+    taskId?: string;
+    evaluator: EvaluatorDetails;
+    taskResult: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+interface TriggerEvaluatorResponse {
+    executionId: string;
+    streamUrl: string;
+}
+interface StreamProgressEvent {
+    type: "progress";
+    data: {
+        completed: number;
+        total: number;
+        percentage: number;
+        currentTask?: string;
+    };
+}
+interface StreamResultEvent {
+    type: "result";
+    data: {
+        taskId: string;
+        evaluatorName: string;
+        result: EvaluatorResult;
+    };
+}
+interface StreamErrorEvent {
+    type: "error";
+    data: {
+        error: string;
+        taskId?: string;
+        evaluatorName?: string;
+    };
+}
+interface StreamCompleteEvent {
+    type: "complete";
+    data: {
+        executionId: string;
+        totalResults: number;
+        totalErrors: number;
+        duration: number;
+    };
+}
+type SSEStreamEvent = StreamProgressEvent | StreamResultEvent | StreamErrorEvent | StreamCompleteEvent;
+interface InputExtractor {
+    source: string;
+}
+interface InputSchemaMapping {
+    [key: string]: InputExtractor;
+}
+
+type dataValue = string | number | boolean;
+type TaskInput = Record<string, dataValue>;
+type TaskOutput = Record<string, dataValue>;
+interface ExperimentTaskFunction<TInput = TaskInput, TOutput = TaskOutput> {
+    (input: TInput): Promise<TOutput> | TOutput;
+}
+type EvaluatorDetails = string | EvaluatorWithVersion | EvaluatorWithConfig;
+interface EvaluatorWithVersion {
+    name: string;
+    version: string;
+}
+/**
+ * Evaluator configuration with optional version and config options.
+ * Used for "Made by Traceloop" (MBT) evaluators that support configuration.
+ */
+interface EvaluatorWithConfig {
+    name: string;
+    version?: string;
+    config?: Record<string, unknown>;
+    requiredInputFields?: string[];
+}
+interface ExperimentRunOptions {
+    datasetSlug?: string;
+    datasetVersion?: string;
+    evaluators?: EvaluatorDetails[];
+    experimentSlug?: string;
+    relatedRef?: Record<string, string>;
+    aux?: Record<string, string>;
+    stopOnError?: boolean;
+    waitForResults?: boolean;
+}
+
+interface TaskResponse {
+    input: Record<string, any>;
+    output: Record<string, any>;
+    metadata?: Record<string, any>;
+    timestamp?: number;
+    error?: string;
+    input_schema_mapping?: InputSchemaMapping;
+}
+interface ExperimentRunResult {
+    taskResults: TaskResponse[];
+    errors: string[];
+    experimentId?: string;
+    runId?: string;
+    evaluations?: Record<string, any>[];
+}
+interface InitExperimentRequest {
+    slug: string;
+    datasetSlug?: string;
+    datasetVersion?: string;
+    evaluatorSlugs?: string[];
+    experimentMetadata?: Record<string, any>;
+    experimentRunMetadata?: Record<string, any>;
+    relatedRef?: Record<string, string>;
+    aux?: Record<string, string>;
+}
+interface ExperimentResponse {
+    id: string;
+    slug: string;
+    metadata?: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+}
+interface ExperimentRunResponse {
+    id: string;
+    metadata?: Record<string, any>;
+    dataset_id?: string;
+    dataset_version?: string;
+    evaluator_ids?: string[];
+    created_at: string;
+    updated_at: string;
+}
+interface ExperimentInitResponse {
+    experiment: ExperimentResponse;
+    run: ExperimentRunResponse;
+}
+interface ExecutionResponse {
+    executionId: string;
+    result: Record<string, any>;
+}
+interface CreateTaskResponse {
+    id: string;
+}
+interface GithubContext {
+    repository: string;
+    prUrl: string;
+    commitHash: string;
+    actor: string;
+}
+interface TaskResult {
+    input: Record<string, any>;
+    output?: Record<string, any>;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+interface RunInGithubOptions {
+    datasetSlug: string;
+    datasetVersion?: string;
+    evaluators?: EvaluatorDetails[];
+    experimentSlug?: string;
+    experimentMetadata?: Record<string, any>;
+    experimentRunMetadata?: Record<string, any>;
+    relatedRef?: Record<string, string>;
+    aux?: Record<string, string>;
+}
+interface RunInGithubResponse {
+    experimentId: string;
+    experimentSlug: string;
+    runId: string;
+}
+
+type AnnotationFlow = "user_feedback";
+/**
+ * Base class for handling annotation operations with the Traceloop API.
+ * @internal
+ */
+declare class BaseAnnotation {
+    protected client: TraceloopClient;
+    protected flow: AnnotationFlow;
+    constructor(client: TraceloopClient, flow: AnnotationFlow);
+    /**
+     * Creates a new annotation.
+     *
+     * @param options - The annotation creation options
+     * @returns Promise resolving to the fetch Response
+     */
+    create(options: AnnotationCreateOptions): Promise<Response>;
+}
+
+/**
+ * Handles user feedback annotations with the Traceloop API.
+ */
+declare class UserFeedback extends BaseAnnotation {
+    constructor(client: TraceloopClient);
+    /**
+     * 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']
+     *   }
+     * });
+     * ```
+     */
+    create(options: AnnotationCreateOptions): Promise<Response>;
+}
+
+declare abstract class BaseDatasetEntity {
+    protected client: TraceloopClient;
+    constructor(client: TraceloopClient);
+    protected handleResponse(response: Response): Promise<any>;
+    protected validateDatasetId(id: string): void;
+    protected validateDatasetSlug(slug: string): void;
+    protected validateDatasetName(name: string): void;
+}
+
+type FileCellType = "image" | "video" | "audio" | "file";
+type FileStorageType = "internal" | "external";
+interface AttachmentMetadata {
+    [key: string]: string | number | boolean;
+}
+interface AttachmentOptions {
+    filePath?: string;
+    data?: Buffer | Uint8Array;
+    filename?: string;
+    contentType?: string;
+    fileType?: FileCellType;
+    metadata?: AttachmentMetadata;
+}
+declare class Attachment {
+    readonly type: "attachment";
+    private _filePath?;
+    private _data?;
+    private _filename?;
+    private _contentType?;
+    private _fileType?;
+    private _metadata?;
+    constructor(options: AttachmentOptions);
+    getData(): Promise<Buffer>;
+    getFileName(): string;
+    getContentType(): string;
+    get fileType(): FileCellType;
+    get metadata(): AttachmentMetadata | undefined;
+}
+interface ExternalAttachmentOptions {
+    url: string;
+    filename?: string;
+    contentType?: string;
+    fileType?: FileCellType;
+    metadata?: AttachmentMetadata;
+}
+declare class ExternalAttachment {
+    readonly type: "external";
+    private _url;
+    private _filename?;
+    private _contentType?;
+    private _fileType;
+    private _metadata?;
+    constructor(options: ExternalAttachmentOptions);
+    get url(): string;
+    get filename(): string | undefined;
+    get contentType(): string | undefined;
+    get fileType(): FileCellType;
+    get metadata(): AttachmentMetadata | undefined;
+}
+declare class AttachmentReference {
+    readonly storageType: FileStorageType;
+    readonly storageKey: string;
+    readonly url: string | undefined;
+    readonly fileType: FileCellType;
+    readonly metadata?: AttachmentMetadata | undefined;
+    constructor(storageType: FileStorageType, storageKey: string, url: string | undefined, fileType: FileCellType, metadata?: AttachmentMetadata | undefined);
+    download(filePath?: string): Promise<Buffer | void>;
+    getUrl(): string | undefined;
+    toJSON(): Record<string, unknown>;
+}
+declare function isAttachment(value: unknown): value is Attachment;
+declare function isExternalAttachment(value: unknown): value is ExternalAttachment;
+declare function isAttachmentReference(value: unknown): value is AttachmentReference;
+declare function isAnyAttachment(value: unknown): value is Attachment | ExternalAttachment;
+declare const attachment: {
+    file: (filePath: string, options?: {
+        filename?: string;
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => Attachment;
+    buffer: (data: Buffer | Uint8Array, filename: string, options?: {
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => Attachment;
+    url: (url: string, options?: {
+        filename?: string;
+        contentType?: string;
+        fileType?: FileCellType;
+        metadata?: AttachmentMetadata;
+    }) => ExternalAttachment;
+};
+
+declare class Row extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    constructor(client: TraceloopClient, data: RowResponse);
+    get id(): string;
+    get datasetId(): string;
+    get datasetSlug(): string;
+    get data(): RowData;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    getValue(columnName: string): string | number | boolean | Date | null | object;
+    hasColumn(columnName: string): boolean;
+    getColumns(): string[];
+    update(options: RowUpdateOptions): Promise<void>;
+    partialUpdate(updates: Partial<RowData>): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): RowData;
+    toCSVRow(columns?: string[], delimiter?: string): string;
+    validate(columnValidators?: {
+        [columnName: string]: (value: any) => boolean;
+    }): {
+        valid: boolean;
+        errors: string[];
+    };
+    clone(): Row;
+    /**
+     * 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: string): AttachmentReference | null;
+    /**
+     * Checks if a column contains an attachment
+     * @param columnName The name of the column to check
+     */
+    hasAttachment(columnName: string): boolean;
+    /**
+     * 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" }));
+     */
+    setAttachment(columnSlug: string, attachment: Attachment | ExternalAttachment): Promise<AttachmentReference>;
+    /**
+     * 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");
+     */
+    downloadAttachment(columnName: string, outputPath?: string): Promise<Buffer | void>;
+}
+
+declare class Column extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    constructor(client: TraceloopClient, data: ColumnResponse);
+    get slug(): string;
+    get name(): string;
+    get type(): "string" | "number" | "boolean" | "date" | "file";
+    get required(): boolean;
+    get description(): string | undefined;
+    get datasetId(): string;
+    get datasetSlug(): string;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    update(options: ColumnUpdateOptions): Promise<void>;
+    delete(): Promise<void>;
+    validateValue(value: DatasetColumnValue): boolean;
+    convertValue(value: unknown): DatasetColumnValue;
+}
+
+declare class Dataset extends BaseDatasetEntity {
+    private _data;
+    private _deleted;
+    private _attachmentUploader;
+    constructor(client: TraceloopClient, data: DatasetResponse);
+    get id(): string;
+    get slug(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get version(): string | undefined;
+    get published(): boolean;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deleted(): boolean;
+    update(options: DatasetUpdateOptions): Promise<void>;
+    delete(): Promise<void>;
+    publish(options?: DatasetPublishOptions): Promise<void>;
+    addColumn(columns: ColumnDefinition[]): Promise<Column[]>;
+    getColumns(): Promise<Column[]>;
+    addRow(rowData: RowData): Promise<Row>;
+    addRows(rows: RowData[]): Promise<Row[]>;
+    /**
+     * Extracts attachments from rows and returns clean rows with null values
+     */
+    private extractAttachments;
+    /**
+     * Processes attachments for created rows
+     */
+    private processAttachments;
+    private transformValuesBackToNames;
+    getRows(limit?: number, offset?: number): Promise<Row[]>;
+    fromCSV(csvContent: string, options?: CSVImportOptions): Promise<void>;
+    getVersions(): Promise<DatasetVersionsResponse>;
+    getVersion(version: string): Promise<DatasetVersion | null>;
+    private parseCSV;
+    private parseValue;
+}
+
+declare class Datasets extends BaseDatasetEntity {
+    constructor(client: TraceloopClient);
+    create(options: DatasetCreateOptions): Promise<Dataset>;
+    get(slug: string): Promise<Dataset>;
+    list(): Promise<DatasetListResponse>;
+    delete(slug: string): Promise<void>;
+    getVersionCSV(slug: string, version: string): Promise<string>;
+    getVersionAsJsonl(slug: string, version: string): Promise<string>;
+}
+
+declare class Experiment {
+    private client;
+    private evaluator;
+    private datasets;
+    private _lastExperimentSlug?;
+    private _lastRunId?;
+    constructor(client: TraceloopClient);
+    /**
+     * Generate a unique experiment slug
+     */
+    private generateExperimentSlug;
+    private handleResponse;
+    /**
+     * Run an experiment with the given task function and options
+     */
+    run<TInput, TOutput>(task: ExperimentTaskFunction<TInput, TOutput>, options?: ExperimentRunOptions | RunInGithubOptions): Promise<ExperimentRunResult | RunInGithubResponse>;
+    /**
+     * Run an experiment locally (not in GitHub Actions)
+     */
+    private runLocally;
+    /**
+     * Create a task for the experiment
+     */
+    createTask(experimentSlug: string, experimentRunId: string, taskInput: Record<string, any>, taskOutput: Record<string, any>): Promise<CreateTaskResponse>;
+    /**
+     * Initialize a new experiment
+     */
+    initializeExperiment(request: InitExperimentRequest): Promise<ExperimentInitResponse>;
+    /**
+     * Parse JSONL string into list of {col_name: col_value} dictionaries
+     * Skips the first line (columns definition)
+     */
+    private parseJsonlToRows;
+    /**
+     * Get dataset rows for experiment execution
+     */
+    private getDatasetRows;
+    /**
+     * Validate experiment run options
+     */
+    private validateRunOptions;
+    /**
+     * Extract GitHub Actions context from environment variables
+     */
+    private getGithubContext;
+    /**
+     * Execute tasks locally and capture results
+     */
+    private executeTasksLocally;
+    /**
+     * Run an experiment in GitHub Actions environment
+     * This method executes tasks locally and submits results to the backend for evaluation
+     */
+    runInGithub<TInput, TOutput>(task: ExperimentTaskFunction<TInput, TOutput>, options: RunInGithubOptions): Promise<RunInGithubResponse>;
+    /**
+     * Resolve export parameters by falling back to last used values
+     */
+    private resolveExportParams;
+    /**
+     * 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
+     */
+    toCsvString(experimentSlug?: string, runId?: string): Promise<string>;
+    /**
+     * 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
+     */
+    toJsonString(experimentSlug?: string, runId?: string): Promise<string>;
+}
+
+declare class Evaluator extends BaseDatasetEntity {
+    constructor(client: TraceloopClient);
+    /**
+     * Run evaluators on experiment task results and wait for completion
+     */
+    runExperimentEvaluator(options: EvaluatorRunOptions): Promise<ExecutionResponse[]>;
+    /**
+     * Trigger evaluator execution without waiting for results
+     */
+    triggerExperimentEvaluator(request: TriggerEvaluatorRequest): Promise<TriggerEvaluatorResponse>;
+    /**
+     * Wait for execution result via stream URL (actually JSON endpoint)
+     */
+    waitForResult(executionId: string, streamUrl: string): Promise<ExecutionResponse[]>;
+    /**
+     * Validate evaluator run options
+     */
+    private validateEvaluatorOptions;
+    /**
+     * Create InputSchemaMapping from input object
+     */
+    private createInputSchemaMapping;
+}
+
+/**
+ * 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();
+ */
+declare class TraceloopClient {
+    private version;
+    appName: string;
+    private baseUrl;
+    private apiKey;
+    experimentSlug?: string;
+    userFeedback: UserFeedback;
+    datasets: Datasets;
+    experiment: Experiment;
+    evaluator: Evaluator;
+    /**
+     * Creates a new instance of the TraceloopClient.
+     *
+     * @param options - Configuration options for the client
+     */
+    constructor(options: TraceloopClientOptions);
+    post(path: string, body: Record<string, unknown> | any): Promise<Response>;
+    get(path: string): Promise<Response>;
+    put(path: string, body: Record<string, unknown> | any): Promise<Response>;
+    delete(path: string): Promise<Response>;
+}
+
+/**
+ * Response from the upload URL endpoint
+ */
+interface UploadUrlResponse {
+    uploadUrl: string;
+    storageKey: string;
+    expiresAt?: string;
+    method?: string;
+}
+/**
+ * Handles attachment upload and registration operations
+ */
+declare class AttachmentUploader {
+    private client;
+    constructor(client: TraceloopClient);
+    /**
+     * Requests a presigned upload URL from the API
+     */
+    getUploadUrl(datasetSlug: string, rowId: string, columnSlug: string, fileName: string, contentType: string, fileType: FileCellType, metadata?: AttachmentMetadata): Promise<UploadUrlResponse>;
+    /**
+     * Uploads file data directly to S3 using the presigned URL
+     */
+    uploadToS3(uploadUrl: string, data: Buffer, contentType: string): Promise<void>;
+    /**
+     * Confirms the upload status with the API
+     */
+    confirmUpload(datasetSlug: string, rowId: string, columnSlug: string, status: "success" | "failed", metadata?: AttachmentMetadata): Promise<void>;
+    /**
+     * Registers an external URL as an attachment
+     */
+    registerExternalUrl(datasetSlug: string, rowId: string, columnSlug: string, url: string, fileType: FileCellType, metadata?: AttachmentMetadata): Promise<AttachmentReference>;
+    /**
+     * Uploads an Attachment through the full flow:
+     * 1. Get presigned URL
+     * 2. Upload to S3
+     * 3. Confirm upload
+     */
+    uploadAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachment: Attachment): Promise<AttachmentReference>;
+    /**
+     * Processes an ExternalAttachment by registering the URL
+     */
+    processExternalAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachment: ExternalAttachment): Promise<AttachmentReference>;
+    /**
+     * Processes any attachment type (Attachment or ExternalAttachment)
+     */
+    processAnyAttachment(datasetSlug: string, rowId: string, columnSlug: string, attachmentObj: Attachment | ExternalAttachment): Promise<AttachmentReference>;
+}
+
+interface EvaluatorSchema {
+    slug: string;
+    requiredInputFields: string[];
+    optionalConfigFields: string[];
+    description?: string;
+}
+type EvaluatorSlug = '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';
+
+interface components {
+    schemas: {
+        "request.AgentEfficiencyRequest": {
+            input: components["schemas"]["request.AgentEfficiencyInput"];
+        };
+        "request.AgentEfficiencyInput": {
+            /** @example ["User found", "Email updated", "Changes saved"] */
+            trajectory_completions: string;
+            /** @example ["Find user info", "Update email", "Save changes"] */
+            trajectory_prompts: string;
+        };
+        "request.AgentFlowQualityRequest": {
+            config: components["schemas"]["request.AgentFlowQualityConfigRequest"];
+            input: components["schemas"]["request.AgentFlowQualityInput"];
+        };
+        "request.AgentFlowQualityConfigRequest": {
+            /**
+             * @example [
+             *       "no tools called",
+             *       "agent completed task"
+             *     ]
+             */
+            conditions: string[];
+            /** @example 0.5 */
+            threshold: number;
+        };
+        "request.AgentFlowQualityInput": {
+            /** @example ["Found 5 flights", "Selected $299 flight", "Booking confirmed"] */
+            trajectory_completions: string;
+            /** @example ["Search for flights", "Select the cheapest option", "Confirm booking"] */
+            trajectory_prompts: string;
+        };
+        "request.AgentGoalAccuracyRequest": {
+            input: components["schemas"]["request.AgentGoalAccuracyInput"];
+        };
+        "request.AgentGoalAccuracyInput": {
+            /** @example I have booked your flight from New York to Los Angeles departing Monday at 9am. */
+            completion: string;
+            /** @example Book a flight from NYC to LA for next Monday */
+            question: string;
+            /** @example Flight booked: NYC to LA, Monday departure */
+            reference: string;
+        };
+        "request.AgentGoalCompletenessRequest": {
+            config?: components["schemas"]["request.AgentGoalCompletenessConfigRequest"];
+            input: components["schemas"]["request.AgentGoalCompletenessInput"];
+        };
+        "request.AgentGoalCompletenessConfigRequest": {
+            /** @example 0.5 */
+            threshold: number;
+        };
+        "request.AgentGoalCompletenessInput": {
+            /** @example ["Account created", "Preferences saved", "Notifications enabled"] */
+            trajectory_completions: string;
+            /** @example ["Create new account", "Set preferences", "Enable notifications"] */
+            trajectory_prompts: string;
+        };
+        "request.AgentToolErrorDetectorRequest": {
+            input: components["schemas"]["request.AgentToolErrorDetectorInput"];
+        };
+        "request.AgentToolErrorDetectorInput": {
+            /** @example {"action": "search", "query": "flights to Paris"} */
+            tool_input: string;
+            /** @example {"status": "success", "results": [{"flight": "AF123", "price": 450}]} */
+            tool_output: string;
+        };
+        "request.AgentToolTrajectoryRequest": {
+            config?: components["schemas"]["request.AgentToolTrajectoryConfigRequest"];
+            input: components["schemas"]["request.AgentToolTrajectoryInput"];
+        };
+        "request.AgentToolTrajectoryConfigRequest": {
+            /** @example true */
+            input_params_sensitive?: boolean;
+            /** @example false */
+            mismatch_sensitive?: boolean;
+            /** @example false */
+            order_sensitive?: boolean;
+            /** @example 0.5 */
+            threshold?: number;
+        };
+        "request.AgentToolTrajectoryInput": {
+            /** @example [{"name": "search", "input": {"query": "weather"}}] */
+            executed_tool_calls: string;
+            /** @example [{"name": "search", "input": {"query": "weather"}}] */
+            expected_tool_calls: string;
+        };
+        "request.AnswerCompletenessRequest": {
+            input: components["schemas"]["request.AnswerCompletenessInput"];
+        };
+        "request.AnswerCompletenessInput": {
+            /** @example Paris. */
+            completion: string;
+            /** @example The capital of France is Paris. */
+            context: string;
+            /** @example What is the capital of France? */
+            question: string;
+        };
+        "request.AnswerCorrectnessRequest": {
+            input: components["schemas"]["request.AnswerCorrectnessInput"];
+        };
+        "request.AnswerCorrectnessInput": {
+            /** @example World War II ended in 1945. */
+            completion: string;
+            /** @example 1945 */
+            ground_truth: string;
+            /** @example What year did World War II end? */
+            question: string;
+        };
+        "request.AnswerRelevancyRequest": {
+            input: components["schemas"]["request.AnswerRelevancyInput"];
+        };
+        "request.AnswerRelevancyInput": {
+            /** @example The capital of France is Paris. */
+            answer: string;
+            /** @example What is the capital of France? */
+            question: string;
+        };
+        "request.CharCountRequest": {
+            input: components["schemas"]["request.CharCountInput"];
+        };
+        "request.CharCountInput": {
+            /** @example Hello, world! This is a sample text. */
+            text: string;
+        };
+        "request.CharCountRatioRequest": {
+            input: components["schemas"]["request.CharCountRatioInput"];
+        };
+        "request.CharCountRatioInput": {
+            /** @example This is a longer text for comparison */
+            denominator_text: string;
+            /** @example Short text */
+            numerator_text: string;
+        };
+        "request.ContextRelevanceRequest": {
+            config?: components["schemas"]["request.ContextRelevanceConfigRequest"];
+            input: components["schemas"]["request.ContextRelevanceInput"];
+        };
+        "request.ContextRelevanceConfigRequest": {
+            /** @example gpt-4o */
+            model?: string;
+        };
+        "request.ContextRelevanceInput": {
+            /** @example Our store is open Monday to Friday from 9am to 6pm, and Saturday from 10am to 4pm. We are closed on Sundays. */
+            context: string;
+            /** @example What are the business hours? */
+            query: string;
+        };
+        "request.ConversationQualityRequest": {
+            input: components["schemas"]["request.ConversationQualityInput"];
+        };
+        "request.ConversationQualityInput": {
+            /** @example ["Hi! I'd be happy to assist you today.", "We offer consulting, development, and support services."] */
+            completions: string;
+            /** @example ["Hello, how can I help?", "What services do you offer?"] */
+            prompts: string;
+        };
+        "request.FaithfulnessRequest": {
+            input: components["schemas"]["request.FaithfulnessInput"];
+        };
+        "request.FaithfulnessInput": {
+            /** @example The Eiffel Tower is located in Paris and was built in 1889. */
+            completion: string;
+            /** @example The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France. It was constructed from 1887 to 1889. */
+            context: string;
+            /** @example When was the Eiffel Tower built? */
+            question: string;
+        };
+        "request.HtmlComparisonRequest": {
+            input: components["schemas"]["request.HtmlComparisonInput"];
+        };
+        "request.HtmlComparisonInput": {
+            /** @example <html><body><h1>Hello, world!</h1></body></html> */
+            html1: string;
+            /** @example <html><body><h1>Hello, world!</h1></body></html> */
+            html2: string;
+        };
+        "request.InstructionAdherenceRequest": {
+            input: components["schemas"]["request.InstructionAdherenceInput"];
+        };
+        "request.InstructionAdherenceInput": {
+            /** @example Respond in exactly 3 bullet points and use formal language. */
+            instructions: string;
+            /**
+             * @example - First point about the topic
+             *     - Second relevant consideration
+             *     - Final concluding thought
+             */
+            response: string;
+        };
+        "request.IntentChangeRequest": {
+            input: components["schemas"]["request.IntentChangeInput"];
+        };
+        "request.IntentChangeInput": {
+            /** @example ["Sure, I can help with hotel booking", "No problem, let me search for flights"] */
+            completions: string;
+            /** @example ["I want to book a hotel", "Actually, I need a flight instead"] */
+            prompts: string;
+        };
+        "request.JSONValidatorRequest": {
+            config?: components["schemas"]["request.JSONValidatorConfigRequest"];
+            input: components["schemas"]["request.JSONValidatorInput"];
+        };
+        "request.JSONValidatorConfigRequest": {
+            /** @example true */
+            enable_schema_validation?: boolean;
+            /** @example {} */
+            schema_string?: string;
+        };
+        "request.JSONValidatorInput": {
+            /** @example {"name": "John", "age": 30} */
+            text: string;
+        };
+        "request.PerplexityRequest": {
+            input: components["schemas"]["request.PerplexityInput"];
+        };
+        "request.PerplexityInput": {
+            /** @example [-2.3, -1.5, -0.8, -1.2, -0.5] */
+            logprobs: string;
+        };
+        "request.PIIDetectorRequest": {
+            config?: components["schemas"]["request.PIIDetectorConfigRequest"];
+            input: components["schemas"]["request.PIIDetectorInput"];
+        };
+        "request.PIIDetectorConfigRequest": {
+            /** @example 0.8 */
+            probability_threshold?: number;
+        };
+        "request.PIIDetectorInput": {
+            /** @example Please contact John Smith at john.smith@email.com or call 555-123-4567. */
+            text: string;
+        };
+        "request.PlaceholderRegexRequest": {
+            config?: components["schemas"]["request.PlaceholderRegexConfigRequest"];
+            input: components["schemas"]["request.PlaceholderRegexInput"];
+        };
+        "request.PlaceholderRegexConfigRequest": {
+            /** @example true */
+            case_sensitive?: boolean;
+            /** @example true */
+            dot_include_nl?: boolean;
+            /** @example true */
+            multi_line?: boolean;
+            /** @example true */
+            should_match?: boolean;
+        };
+        "request.PlaceholderRegexInput": {
+            /** @example [A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,} */
+            placeholder_value: string;
+            /** @example user@example.com */
+            text: string;
+        };
+        "request.ProfanityDetectorRequest": {
+            input: components["schemas"]["request.ProfanityDetectorInput"];
+        };
+        "request.ProfanityDetectorInput": {
+            /** @example This is a clean and professional message. */
+            text: string;
+        };
+        "request.PromptInjectionRequest": {
+            config?: components["schemas"]["request.PromptInjectionConfigRequest"];
+            input: components["schemas"]["request.PromptInjectionInput"];
+        };
+        "request.PromptInjectionConfigRequest": {
+            /** @example 0.5 */
+            threshold?: number;
+        };
+        "request.PromptInjectionInput": {
+            /** @example What is the weather like today? */
+            prompt: string;
+        };
+        "request.PromptPerplexityRequest": {
+            input: components["schemas"]["request.PromptPerplexityInput"];
+        };
+        "request.PromptPerplexityInput": {
+            /** @example What is the capital of France? */
+            prompt: string;
+        };
+        "request.RegexValidatorRequest": {
+            config?: components["schemas"]["request.RegexValidatorConfigRequest"];
+            input: components["schemas"]["request.RegexValidatorInput"];
+        };
+        "request.RegexValidatorConfigRequest": {
+            /** @example true */
+            case_sensitive?: boolean;
+            /** @example true */
+            dot_include_nl?: boolean;
+            /** @example true */
+            multi_line?: boolean;
+            /** @example .* */
+            regex?: string;
+            /** @example true */
+            should_match?: boolean;
+        };
+        "request.RegexValidatorInput": {
+            /** @example user@example.com */
+            text: string;
+        };
+        "request.SecretsDetectorRequest": {
+            input: components["schemas"]["request.SecretsDetectorInput"];
+        };
+        "request.SecretsDetectorInput": {
+            /** @example Here is some text without any API keys or passwords. */
+            text: string;
+        };
+        "request.SemanticSimilarityRequest": {
+            input: components["schemas"]["request.SemanticSimilarityInput"];
+        };
+        "request.SemanticSimilarityInput": {
+            /** @example The cat sat on the mat. */
+            completion: string;
+            /** @example A feline was resting on the rug. */
+            reference: string;
+        };
+        "request.SexismDetectorRequest": {
+            config?: components["schemas"]["request.SexismDetectorConfigRequest"];
+            input: components["schemas"]["request.SexismDetectorInput"];
+        };
+        "request.SexismDetectorConfigRequest": {
+            /** @example 0.5 */
+            threshold?: number;
+        };
+        "request.SexismDetectorInput": {
+            /** @example All team members should be treated equally regardless of gender. */
+            text: string;
+        };
+        "request.SQLValidatorRequest": {
+            input: components["schemas"]["request.SQLValidatorInput"];
+        };
+        "request.SQLValidatorInput": {
+            /** @example SELECT * FROM users WHERE id = 1; */
+            text: string;
+        };
+        "request.ToneDetectionRequest": {
+            input: components["schemas"]["request.ToneDetectionInput"];
+        };
+        "request.ToneDetectionInput": {
+            /** @example The capital of France is Paris. */
+            text: string;
+        };
+        "request.TopicAdherenceRequest": {
+            input: components["schemas"]["request.TopicAdherenceInput"];
+        };
+        "request.TopicAdherenceInput": {
+            /** @example Machine learning is a subset of AI that enables systems to learn from data. */
+            completion: string;
+            /** @example Tell me about machine learning */
+            question: string;
+            /** @example artificial intelligence, data science, algorithms */
+            reference_topics: string;
+        };
+        "request.ToxicityDetectorRequest": {
+            config?: components["schemas"]["request.ToxicityDetectorConfigRequest"];
+            input: components["schemas"]["request.ToxicityDetectorInput"];
+        };
+        "request.ToxicityDetectorConfigRequest": {
+            /** @example 0.5 */
+            threshold?: number;
+        };
+        "request.ToxicityDetectorInput": {
+            /** @example Thank you for your help with this project. */
+            text: string;
+        };
+        "request.UncertaintyDetectorRequest": {
+            input: components["schemas"]["request.UncertaintyDetectorInput"];
+        };
+        "request.UncertaintyDetectorInput": {
+            /** @example I am not sure, I think the capital of France is Paris. */
+            prompt: string;
+        };
+        "request.WordCountRequest": {
+            input: components["schemas"]["request.WordCountInput"];
+        };
+        "request.WordCountInput": {
+            /** @example This is a sample text with several words. */
+            text: string;
+        };
+        "request.WordCountRatioRequest": {
+            input: components["schemas"]["request.WordCountRatioInput"];
+        };
+        "request.WordCountRatioInput": {
+            /** @example This is a longer input text for comparison */
+            denominator_text: string;
+            /** @example Short response */
+            numerator_text: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+type AgentFlowQualityConfig = components['schemas']['request.AgentFlowQualityRequest']['config'];
+type AgentGoalCompletenessConfig = components['schemas']['request.AgentGoalCompletenessRequest']['config'];
+type AgentToolTrajectoryConfig = components['schemas']['request.AgentToolTrajectoryRequest']['config'];
+type ContextRelevanceConfig = components['schemas']['request.ContextRelevanceRequest']['config'];
+type JsonValidatorConfig = components['schemas']['request.JSONValidatorRequest']['config'];
+type PiiDetectorConfig = components['schemas']['request.PIIDetectorRequest']['config'];
+type PlaceholderRegexConfig = components['schemas']['request.PlaceholderRegexRequest']['config'];
+type PromptInjectionConfig = components['schemas']['request.PromptInjectionRequest']['config'];
+type RegexValidatorConfig = components['schemas']['request.RegexValidatorRequest']['config'];
+type SexismDetectorConfig = components['schemas']['request.SexismDetectorRequest']['config'];
+type ToxicityDetectorConfig = components['schemas']['request.ToxicityDetectorRequest']['config'];
+/**
+ * Create an evaluator configuration object.
+ */
+declare function createEvaluator(slug: EvaluatorSlug, options?: {
+    version?: string;
+    config?: Record<string, unknown>;
+}): EvaluatorWithConfig;
+/**
+ * Validate that required input fields are present in task output.
+ */
+declare function validateEvaluatorInput(slug: EvaluatorSlug, taskOutput: Record<string, unknown>): {
+    valid: boolean;
+    missingFields: string[];
+};
+/**
+ * Get all available evaluator slugs.
+ */
+declare function getAvailableEvaluatorSlugs(): EvaluatorSlug[];
+/**
+ * Get schema information for an evaluator.
+ */
+declare function getEvaluatorSchemaInfo(slug: EvaluatorSlug): EvaluatorSchema | undefined;
+/**
+ * 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(),
+ * ];
+ * ```
+ */
+declare class EvaluatorMadeByTraceloop {
+    static create(slug: EvaluatorSlug, options?: {
+        version?: string;
+        config?: Record<string, unknown>;
+    }): EvaluatorWithConfig;
+    static getAvailableSlugs(): EvaluatorSlug[];
+    static isValidSlug(slug: string): slug is EvaluatorSlug;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: AgentFlowQualityConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: AgentGoalCompletenessConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: AgentToolTrajectoryConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: ContextRelevanceConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: JsonValidatorConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: PiiDetectorConfig): EvaluatorWithConfig;
+    /**
+     * 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?: PlaceholderRegexConfig): EvaluatorWithConfig;
+    /**
+     * Detect profanity in text
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to scan for profanity
+     * Required task output fields: text
+     */
+    static profanityDetector(): EvaluatorWithConfig;
+    /**
+     * 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?: PromptInjectionConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: RegexValidatorConfig): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: SexismDetectorConfig): EvaluatorWithConfig;
+    /**
+     * Validate SQL query syntax
+  
+  **Request Body:**
+  - `input.text` (string, required): The text to validate as SQL
+     * Required task output fields: text
+     */
+    static sqlValidator(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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?: ToxicityDetectorConfig): EvaluatorWithConfig;
+    /**
+     * Detect uncertainty in the text
+  
+  **Request Body:**
+  - `input.prompt` (string, required): The text to detect uncertainty in
+     * Required task output fields: prompt
+     */
+    static uncertaintyDetector(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+    /**
+     * 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(): EvaluatorWithConfig;
+}
+
+/**
+ * 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',
+ * });
+ * ```
+ */
+declare const initialize: (options?: InitializeOptions) => TraceloopClient | undefined;
+/**
+ * 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 } });
+ * ```
+ */
+declare const getClient: () => TraceloopClient;
+
+declare const forceFlush: () => Promise<void>;
+
+declare const getTraceloopTracer: () => _opentelemetry_api.Tracer;
+
+type DecoratorConfig = {
+    name: string;
+    version?: number;
+    associationProperties?: {
+        [name: string]: string;
+    };
+    conversationId?: string;
+    traceContent?: boolean;
+    inputParameters?: unknown[];
+    suppressTracing?: boolean;
+};
+declare function withWorkflow<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+declare function withTask<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+declare function withAgent<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+declare function withTool<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+declare function workflow(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function task(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function agent(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function tool(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function withConversation<A extends unknown[], F extends (...args: A) => ReturnType<F>>(conversationId: string, fn: F, thisArg?: ThisParameterType<F>, ...args: A): Promise<any>;
+declare function conversation(conversationId: string | ((thisArg: unknown, ...funcArgs: unknown[]) => string)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+
+type VectorDBCallConfig = {
+    vendor: string;
+    type: "query" | "upsert" | "delete";
+};
+type LLMCallConfig = {
+    vendor: string;
+    type: "chat" | "completion";
+};
+declare class VectorSpan {
+    private span;
+    constructor(span: Span);
+    reportQuery({ queryVector }: {
+        queryVector: number[];
+    }): void;
+    reportResults({ results, }: {
+        results: {
+            ids?: string;
+            scores?: number;
+            distances?: number;
+            metadata?: Record<string, unknown>;
+            vectors?: number[];
+            documents?: string;
+        }[];
+    }): void;
+}
+declare class LLMSpan {
+    private span;
+    constructor(span: Span);
+    reportRequest({ model, messages, }: {
+        model: string;
+        messages: {
+            role: string;
+            content?: string | unknown;
+        }[];
+    }): void;
+    reportResponse({ model, usage, completions, }: {
+        model: string;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        };
+        completions?: {
+            finish_reason: string;
+            message: {
+                role: "system" | "user" | "assistant";
+                content: string | null;
+            };
+        }[];
+    }): void;
+}
+declare function withVectorDBCall<F extends ({ span }: {
+    span: VectorSpan;
+}) => ReturnType<F>>({ vendor, type }: VectorDBCallConfig, fn: F, thisArg?: ThisParameterType<F>): Promise<any> | ReturnType<F>;
+declare function withLLMCall<F extends ({ span }: {
+    span: LLMSpan;
+}) => ReturnType<F>>({ vendor, type }: LLMCallConfig, fn: F, thisArg?: ThisParameterType<F>): Promise<any> | ReturnType<F>;
+
+declare function withAssociationProperties<A extends unknown[], F extends (...args: A) => ReturnType<F>>(properties: {
+    [name: string]: string;
+}, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+
+/**
+ * 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);
+ */
+declare const reportCustomMetric: (metricName: string, metricValue: number) => void;
+
+declare const ALL_INSTRUMENTATION_LIBRARIES: "all";
+type AllInstrumentationLibraries = typeof ALL_INSTRUMENTATION_LIBRARIES;
+interface SpanProcessorOptions {
+    /**
+     * The API Key for sending traces data. Optional.
+     * Defaults to the ANYWAY_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * The OTLP endpoint for sending traces data. Optional.
+     * Defaults to ANYWAY_BASE_URL environment variable or https://api.traceloop.com/
+     */
+    baseUrl?: string;
+    /**
+     * Sends traces and spans without batching, for local development. Optional.
+     * Defaults to false.
+     */
+    disableBatch?: boolean;
+    /**
+     * The OpenTelemetry SpanExporter to be used for sending traces data. Optional.
+     * Defaults to the OTLP exporter.
+     */
+    exporter?: SpanExporter;
+    /**
+     * The headers to be sent with the traces data. Optional.
+     */
+    headers?: Record<string, string>;
+    /**
+     * The instrumentation libraries to be allowed in the traces. Optional.
+     * Defaults to Traceloop instrumentation libraries.
+     * If set to ALL_INSTRUMENTATION_LIBRARIES, all instrumentation libraries will be allowed.
+     * If set to an array of instrumentation libraries, only traceloop instrumentation libraries and the specified instrumentation libraries will be allowed.
+     */
+    allowedInstrumentationLibraries?: string[] | AllInstrumentationLibraries;
+}
+/**
+ * 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
+ */
+declare const createSpanProcessor: (options: SpanProcessorOptions) => SpanProcessor$1;
+declare const traceloopInstrumentationLibraries: string[];
+
+/**
+ * Returns true once SDK prompt registry has been initialized, else rejects with an error.
+ * @returns Promise<boolean>
+ */
+declare const waitForInitialization: () => Promise<boolean>;
+
+declare const getPrompt: (key: string, variables: Record<string, string>) => any;
+
+/**
+ * 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,
+ *   },
+ * }))
+ * ```
+ */
+declare enum AssociationProperty {
+    CUSTOMER_ID = "customer_id",
+    USER_ID = "user_id",
+    SESSION_ID = "session_id"
+}
+
+declare class ImageUploader {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    uploadBase64Image(traceId: string, spanId: string, imageName: string, base64ImageData: string): Promise<string>;
+    private getImageUrl;
+    private uploadImageData;
+}
+
+export { ALL_INSTRUMENTATION_LIBRARIES, ArgumentNotProvidedError, AssociationProperty, Attachment, AttachmentReference, AttachmentUploader, Column, Dataset, Datasets, Evaluator, EvaluatorMadeByTraceloop, Experiment, ExternalAttachment, ImageUploader, InitializationError, LLMSpan, NotInitializedError, PromptNotFoundError, Row, SEVERITY, TraceloopClient, TraceloopError, VectorSpan, agent, attachment, conversation, createEvaluator, createSpanProcessor, forceFlush, getAvailableEvaluatorSlugs, getClient, getEvaluatorSchemaInfo, getPrompt, getTraceloopTracer, initialize, isAnyAttachment, isAttachment, isAttachmentReference, isExternalAttachment, reportCustomMetric, task, tool, traceloopInstrumentationLibraries, validateEvaluatorInput, waitForInitialization, withAgent, withAssociationProperties, withConversation, withLLMCall, withTask, withTool, withVectorDBCall, withWorkflow, workflow };
+export type { AnnotationCreateOptions, AttachmentMetadata, AttachmentOptions, CSVImportOptions, ColumnDefinition, ColumnResponse, ColumnUpdateOptions, DatasetCreateOptions, DatasetListResponse, DatasetPublishOptions, DatasetResponse, DatasetUpdateOptions, DatasetVersion, DatasetVersionsResponse, DecoratorConfig, EvaluatorDetails, EvaluatorWithConfig, EvaluatorWithVersion, ExecutionResponse, ExperimentRunOptions, ExperimentRunResult, ExperimentTaskFunction, ExternalAttachmentOptions, FileCellType, FileStorageType, GithubContext, InitializeOptions, RowData, RowResponse, RowUpdateOptions, RunInGithubOptions, RunInGithubResponse, SSEStreamEvent, Severity, SpanProcessorOptions, StreamEvent, TaskInput, TaskOutput, TaskResponse, TaskResult, TraceloopClientOptions, UploadUrlResponse };