@anyway-sh/node-server-sdk 0.22.8

package/dist/src/lib/interfaces/experiment.interface.d.ts

@@ -0,0 +1,117 @@
+type dataValue = string | number | boolean;
+export type TaskInput = Record<string, dataValue>;
+export type TaskOutput = Record<string, dataValue>;
+export interface ExperimentTaskFunction<TInput = TaskInput, TOutput = TaskOutput> {
+    (input: TInput): Promise<TOutput> | TOutput;
+}
+export type EvaluatorDetails = string | EvaluatorWithVersion | EvaluatorWithConfig;
+export interface EvaluatorWithVersion {
+    name: string;
+    version: string;
+}
+/**
+ * Evaluator configuration with optional version and config options.
+ * Used for "Made by Traceloop" (MBT) evaluators that support configuration.
+ */
+export interface EvaluatorWithConfig {
+    name: string;
+    version?: string;
+    config?: Record<string, unknown>;
+    requiredInputFields?: string[];
+}
+export interface ExperimentRunOptions {
+    datasetSlug?: string;
+    datasetVersion?: string;
+    evaluators?: EvaluatorDetails[];
+    experimentSlug?: string;
+    relatedRef?: Record<string, string>;
+    aux?: Record<string, string>;
+    stopOnError?: boolean;
+    waitForResults?: boolean;
+}
+import type { InputSchemaMapping } from "./evaluator.interface";
+export interface TaskResponse {
+    input: Record<string, any>;
+    output: Record<string, any>;
+    metadata?: Record<string, any>;
+    timestamp?: number;
+    error?: string;
+    input_schema_mapping?: InputSchemaMapping;
+}
+export interface ExperimentRunResult {
+    taskResults: TaskResponse[];
+    errors: string[];
+    experimentId?: string;
+    runId?: string;
+    evaluations?: Record<string, any>[];
+}
+export 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>;
+}
+export interface ExperimentResponse {
+    id: string;
+    slug: string;
+    metadata?: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+}
+export interface ExperimentRunResponse {
+    id: string;
+    metadata?: Record<string, any>;
+    dataset_id?: string;
+    dataset_version?: string;
+    evaluator_ids?: string[];
+    created_at: string;
+    updated_at: string;
+}
+export interface ExperimentInitResponse {
+    experiment: ExperimentResponse;
+    run: ExperimentRunResponse;
+}
+export interface ExecutionResponse {
+    executionId: string;
+    result: Record<string, any>;
+}
+export interface CreateTaskRequest {
+    input: Record<string, any>;
+    output: Record<string, any>;
+}
+export interface CreateTaskResponse {
+    id: string;
+}
+export interface GithubContext {
+    repository: string;
+    prUrl: string;
+    commitHash: string;
+    actor: string;
+}
+export interface TaskResult {
+    input: Record<string, any>;
+    output?: Record<string, any>;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+export 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>;
+}
+export interface RunInGithubResponse {
+    experimentId: string;
+    experimentSlug: string;
+    runId: string;
+}
+export {};
+//# sourceMappingURL=experiment.interface.d.ts.map

package/dist/src/lib/interfaces/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./initialize-options.interface";
+export * from "./prompts.interface";
+export * from "./annotations.interface";
+export * from "./traceloop-client.interface";
+export * from "./dataset.interface";
+export * from "./experiment.interface";
+export * from "./evaluator.interface";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/interfaces/initialize-options.interface.d.ts

@@ -0,0 +1,133 @@
+import { SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { TextMapPropagator, ContextManager } from "@opentelemetry/api";
+import type * as openai from "openai";
+import type * as anthropic from "@anthropic-ai/sdk";
+import type * as cohere from "cohere-ai";
+import type * as bedrock from "@aws-sdk/client-bedrock-runtime";
+import type * as aiplatform from "@google-cloud/aiplatform";
+import type * as vertexAI from "@google-cloud/vertexai";
+import type * as pinecone from "@pinecone-database/pinecone";
+import type * as together from "together-ai";
+import type * as llamaindex from "llamaindex";
+import type * as chromadb from "chromadb";
+import type * as qdrant from "@qdrant/js-client-rest";
+import type * as mcp from "@modelcontextprotocol/sdk/client/index.js";
+/**
+ * Options for initializing the Traceloop SDK.
+ */
+export 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;
+}
+//# sourceMappingURL=initialize-options.interface.d.ts.map

package/dist/src/lib/interfaces/prompts.interface.d.ts

@@ -0,0 +1,53 @@
+export declare const TEMPLATING_ENGINE: {
+    readonly JINJA2: "jinja2";
+};
+export type TemplatingEngine = (typeof TEMPLATING_ENGINE)[keyof typeof TEMPLATING_ENGINE];
+export type Content = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+};
+export interface PromptMessage {
+    index: number;
+    template: string | Content[];
+    role: string;
+    variables: string[];
+}
+export interface RenderedMessage {
+    role: string;
+    content: string | Content[];
+}
+export interface PromptTarget {
+    id: string;
+    environment: string;
+    version: string;
+    updated_at: string;
+}
+export interface PromptVersion {
+    templating_engine: TemplatingEngine;
+    provider: string;
+    messages: PromptMessage[];
+    id: string;
+    hash: string;
+    version: number;
+    name?: string;
+    updated_at: string;
+    created_at: string;
+    author?: string;
+    publishable: boolean;
+    llm_config: any;
+}
+export interface Prompt {
+    id: string;
+    org_id: string;
+    key: string;
+    updated_at: string;
+    created_at: string;
+    versions: PromptVersion[];
+    target: PromptTarget;
+}
+//# sourceMappingURL=prompts.interface.d.ts.map

package/dist/src/lib/interfaces/traceloop-client.interface.d.ts

@@ -0,0 +1,7 @@
+export interface TraceloopClientOptions {
+    apiKey: string;
+    appName: string;
+    baseUrl?: string;
+    experimentSlug?: string;
+}
+//# sourceMappingURL=traceloop-client.interface.d.ts.map

package/dist/src/lib/node-server-sdk.d.ts

@@ -0,0 +1,19 @@
+export * from "./errors";
+export { InitializeOptions, TraceloopClientOptions, AnnotationCreateOptions, DatasetCreateOptions, DatasetUpdateOptions, DatasetResponse, ColumnDefinition, ColumnResponse, ColumnUpdateOptions, RowData, RowResponse, RowUpdateOptions, DatasetListResponse, DatasetPublishOptions, CSVImportOptions, DatasetVersion, DatasetVersionsResponse, ExperimentTaskFunction, ExperimentRunOptions, ExperimentRunResult, TaskInput, TaskOutput, TaskResponse, ExecutionResponse, EvaluatorDetails, EvaluatorWithConfig, EvaluatorWithVersion, GithubContext, TaskResult, RunInGithubOptions, RunInGithubResponse, StreamEvent, SSEStreamEvent, } from "./interfaces";
+export { TraceloopClient } from "./client/traceloop-client";
+export { Dataset, Datasets, Column, Row, Attachment, ExternalAttachment, AttachmentReference, attachment, isAttachment, isExternalAttachment, isAttachmentReference, isAnyAttachment, AttachmentUploader, } from "./client/dataset";
+export type { FileCellType, FileStorageType, AttachmentMetadata, AttachmentOptions, ExternalAttachmentOptions, UploadUrlResponse, } from "./client/dataset";
+export { Experiment } from "./client/experiment";
+export { Evaluator } from "./client/evaluator";
+export { EvaluatorMadeByTraceloop, createEvaluator, validateEvaluatorInput, getAvailableEvaluatorSlugs, getEvaluatorSchemaInfo, } from "./generated/evaluators";
+export { initialize, getClient } from "./configuration";
+export { forceFlush } from "./tracing";
+export { getTraceloopTracer } from "./tracing/tracing";
+export * from "./tracing/decorators";
+export * from "./tracing/manual";
+export * from "./tracing/association";
+export * from "./tracing/custom-metric";
+export * from "./tracing/span-processor";
+export * from "./prompts";
+export { AssociationProperty } from "./associations/associations";
+//# sourceMappingURL=node-server-sdk.d.ts.map

package/dist/src/lib/prompts/fetch.d.ts

@@ -0,0 +1,3 @@
+import { InitializeOptions } from "../interfaces";
+export declare const fetchPrompts: (options: InitializeOptions) => Promise<any>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/src/lib/prompts/index.d.ts

@@ -0,0 +1,3 @@
+export { waitForInitialization } from "./registry";
+export declare const getPrompt: (key: string, variables: Record<string, string>) => any;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/prompts/registry.d.ts

@@ -0,0 +1,9 @@
+import { InitializeOptions, Prompt } from "../interfaces";
+/**
+ * Returns true once SDK prompt registry has been initialized, else rejects with an error.
+ * @returns Promise<boolean>
+ */
+export declare const waitForInitialization: () => Promise<boolean>;
+export declare const getPromptByKey: (key: string) => Prompt;
+export declare const initializeRegistry: (options: InitializeOptions) => void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/lib/prompts/template.d.ts

@@ -0,0 +1,3 @@
+import { PromptVersion, RenderedMessage } from "../interfaces";
+export declare const renderMessages: (promptVersion: PromptVersion, variables: Record<string, any>) => RenderedMessage[];
+//# sourceMappingURL=template.d.ts.map

package/dist/src/lib/tracing/ai-sdk-transformations.d.ts

@@ -0,0 +1,5 @@
+import { ReadableSpan, Span } from "@opentelemetry/sdk-trace-node";
+export declare const transformLLMSpans: (attributes: Record<string, any>, spanName?: string) => void;
+export declare const transformAiSdkSpanNames: (span: Span) => void;
+export declare const transformAiSdkSpanAttributes: (span: ReadableSpan) => void;
+//# sourceMappingURL=ai-sdk-transformations.d.ts.map

package/dist/src/lib/tracing/association.d.ts

@@ -0,0 +1,4 @@
+export 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>;
+//# sourceMappingURL=association.d.ts.map

package/dist/src/lib/tracing/baggage-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function parseKeyPairsIntoRecord(keyPairs: string): Record<string, string>;
+//# sourceMappingURL=baggage-utils.d.ts.map

package/dist/src/lib/tracing/custom-metric.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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);
+ */
+export declare const reportCustomMetric: (metricName: string, metricValue: number) => void;
+//# sourceMappingURL=custom-metric.d.ts.map

package/dist/src/lib/tracing/decorators.d.ts

@@ -0,0 +1,22 @@
+export type DecoratorConfig = {
+    name: string;
+    version?: number;
+    associationProperties?: {
+        [name: string]: string;
+    };
+    conversationId?: string;
+    traceContent?: boolean;
+    inputParameters?: unknown[];
+    suppressTracing?: boolean;
+};
+export declare function withWorkflow<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+export declare function withTask<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+export declare function withAgent<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+export declare function withTool<A extends unknown[], F extends (...args: A) => ReturnType<F>>(config: DecoratorConfig, fn: F, ...args: A): Promise<any>;
+export declare function workflow(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function task(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function agent(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function tool(config: Partial<DecoratorConfig> | ((thisArg: unknown, ...funcArgs: unknown[]) => Partial<DecoratorConfig>)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function withConversation<A extends unknown[], F extends (...args: A) => ReturnType<F>>(conversationId: string, fn: F, thisArg?: ThisParameterType<F>, ...args: A): Promise<any>;
+export declare function conversation(conversationId: string | ((thisArg: unknown, ...funcArgs: unknown[]) => string)): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/src/lib/tracing/index.d.ts

@@ -0,0 +1,14 @@
+import { InitializeOptions } from "../interfaces";
+export declare const initInstrumentations: (apiKey?: string, baseUrl?: string) => void;
+export declare const manuallyInitInstrumentations: (instrumentModules: InitializeOptions["instrumentModules"], apiKey?: string, baseUrl?: string) => void;
+/**
+ * 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.
+ */
+export declare const startTracing: (options: InitializeOptions) => void;
+export declare const shouldSendTraces: () => {} | null;
+export declare const forceFlush: () => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/tracing/manual.d.ts

@@ -0,0 +1,60 @@
+import { Span } from "@opentelemetry/api";
+type VectorDBCallConfig = {
+    vendor: string;
+    type: "query" | "upsert" | "delete";
+};
+type LLMCallConfig = {
+    vendor: string;
+    type: "chat" | "completion";
+};
+export 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;
+}
+export 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;
+}
+export declare function withVectorDBCall<F extends ({ span }: {
+    span: VectorSpan;
+}) => ReturnType<F>>({ vendor, type }: VectorDBCallConfig, fn: F, thisArg?: ThisParameterType<F>): Promise<any> | ReturnType<F>;
+export declare function withLLMCall<F extends ({ span }: {
+    span: LLMSpan;
+}) => ReturnType<F>>({ vendor, type }: LLMCallConfig, fn: F, thisArg?: ThisParameterType<F>): Promise<any> | ReturnType<F>;
+export {};
+//# sourceMappingURL=manual.d.ts.map

package/dist/src/lib/tracing/sampler.d.ts

@@ -0,0 +1,7 @@
+import { Sampler, SamplingResult } from "@opentelemetry/sdk-trace-base";
+import { Context, SpanKind, Attributes } from "@opentelemetry/api";
+export declare class TraceloopSampler implements Sampler {
+    shouldSample(_context: Context, _traceId: string, _spanName: string, _spanKind: SpanKind, attributes: Attributes): SamplingResult;
+    toString(): string;
+}
+//# sourceMappingURL=sampler.d.ts.map

package/dist/src/lib/tracing/span-processor.d.ts

@@ -0,0 +1,48 @@
+import { SpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { SpanExporter } from "@opentelemetry/sdk-trace-base";
+export declare const ALL_INSTRUMENTATION_LIBRARIES: "all";
+type AllInstrumentationLibraries = typeof ALL_INSTRUMENTATION_LIBRARIES;
+export 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
+ */
+export declare const createSpanProcessor: (options: SpanProcessorOptions) => SpanProcessor;
+export declare const traceloopInstrumentationLibraries: string[];
+export {};
+//# sourceMappingURL=span-processor.d.ts.map

package/dist/src/lib/tracing/tracing.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "@opentelemetry/api";
+export declare const WORKFLOW_NAME_KEY: symbol;
+export declare const ENTITY_NAME_KEY: symbol;
+export declare const AGENT_NAME_KEY: symbol;
+export declare const CONVERSATION_ID_KEY: symbol;
+export declare const ASSOCATION_PROPERTIES_KEY: symbol;
+export declare const getTracer: () => import("@opentelemetry/api").Tracer;
+export declare const getTraceloopTracer: () => import("@opentelemetry/api").Tracer;
+export declare const getEntityPath: (entityContext: Context) => string | undefined;
+//# sourceMappingURL=tracing.d.ts.map

package/dist/src/lib/utils/response-transformer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utility functions for transforming API responses from snake_case to camelCase
+ */
+/**
+ * Recursively transforms all snake_case keys in an object to camelCase
+ * @param obj The object to transform
+ * @returns A new object with camelCase keys
+ */
+export declare function transformResponseKeys(obj: any): any;
+/**
+ * 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
+ */
+export declare function transformApiResponse<T = any>(data: any): T;
+//# sourceMappingURL=response-transformer.d.ts.map