observability-toolkit 2.0.0 → 2.1.0

package/dist/backends/index.d.ts

@@ -1,85 +1,11 @@
 /**
  * Backend interface for telemetry data sources
  */
-/**
- * InstrumentationScope identifies the library/module that produced the telemetry
- * https://opentelemetry.io/docs/specs/otel/common/
- */
-export interface InstrumentationScope {
-    name: string;
-    version?: string;
-    schemaUrl?: string;
-}
-/**
- * SpanLink connects a span to another span in the same or different trace.
- * Used for batch processing, fan-out operations, or causal relationships.
- * https://opentelemetry.io/docs/concepts/signals/traces/#span-links
- */
-export interface SpanLink {
-    traceId: string;
-    spanId: string;
-    attributes?: Record<string, unknown>;
-}
-export interface TraceSpan {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    name: string;
-    kind?: string;
-    startTimeUnixNano: number;
-    endTimeUnixNano?: number;
-    durationMs?: number;
-    status?: {
-        code: number;
-        message?: string;
-    };
-    /** Human-readable status code: 'UNSET' (0), 'OK' (1), 'ERROR' (2) */
-    statusCode?: 'UNSET' | 'OK' | 'ERROR';
-    attributes?: Record<string, unknown>;
-    events?: Array<{
-        name: string;
-        timestamp: number;
-        attributes?: Record<string, unknown>;
-    }>;
-    /** SpanLinks connect this span to other spans in the same or different traces */
-    links?: SpanLink[];
-    /** InstrumentationScope identifies the library/module that produced this span */
-    instrumentationScope?: InstrumentationScope;
-}
-export interface LogRecord {
-    timestamp: string;
-    severity: string;
-    severityNumber?: number;
-    body: string;
-    traceId?: string;
-    spanId?: string;
-    attributes?: Record<string, unknown>;
-    /** InstrumentationScope identifies the library/module that produced this log */
-    instrumentationScope?: InstrumentationScope;
-    /** Extracted field values from JSON log body */
-    extractedFields?: Record<string, unknown>;
-}
-export interface HistogramBucket {
-    le: number;
-    count: number;
-}
-export interface HistogramData {
-    buckets: HistogramBucket[];
-    sum: number;
-    count: number;
-}
-/**
- * Exemplar links a metric data point to a specific trace span.
- * Useful for debugging high latency, errors, or other notable measurements.
- * https://opentelemetry.io/docs/specs/otel/metrics/data-model/#exemplars
- */
-export interface Exemplar {
-    timestamp: string;
-    value: number;
-    traceId?: string;
-    spanId?: string;
-    attributes?: Record<string, unknown>;
-}
+import { z } from 'zod';
+import { genAIOperationNameSchema, genAIOutputTypeSchema, evaluationAggregationSchema, evaluationGroupByFieldSchema, metricAggregationSchema, type GenAIOperationName, type GenAIOutputType, type EvaluationAggregation, type EvaluationGroupByField, type MetricAggregation } from '../lib/core/shared-schemas.js';
+import { type InstrumentationScope, type SpanLink, type TraceSpan, type LogRecord, type HistogramBucket, type HistogramData, type Exemplar, type MetricDataPoint, type HistogramDataPoint, type LLMEvent, type EvaluatorType, type StepScore, type ToolVerification, type EvaluationResult, type CostDataPoint, type DatasetRecord, type DatasetTraceRecord, type DatasetRunRecord } from './backend-schemas.js';
+export type { InstrumentationScope, SpanLink, TraceSpan, LogRecord, HistogramBucket, HistogramData, Exemplar, MetricDataPoint, HistogramDataPoint, LLMEvent, EvaluatorType, StepScore, ToolVerification, EvaluationResult, CostDataPoint, DatasetRecord, DatasetTraceRecord, DatasetRunRecord, };
+export { instrumentationScopeSchema, spanLinkSchema, traceSpanSchema, logRecordSchema, histogramBucketSchema, histogramDataSchema, exemplarSchema, metricDataPointSchema, histogramDataPointSchema, llmEventSchema, evaluatorTypeSchema, stepScoreSchema, toolVerificationSchema, evaluationResultSchema, costDataPointSchema, datasetRecordSchema, datasetTraceRecordSchema, datasetRunRecordSchema, isIndexedStep, isNamedStep, MAX_STEP_ID_LENGTH, } from './backend-schemas.js';
 /**
  * Aggregation temporality for metrics
  * https://opentelemetry.io/docs/specs/otel/metrics/data-model/#temporality
@@ -88,37 +14,41 @@ export interface Exemplar {
  * - DELTA: Values represent change since last report (e.g., requests in the last minute)
  * - CUMULATIVE: Values represent total since start (e.g., total requests since process start)
  */
-export type AggregationTemporality = 'UNSPECIFIED' | 'DELTA' | 'CUMULATIVE';
-export interface MetricDataPoint {
-    timestamp: string;
-    name: string;
-    value: number;
-    unit?: string;
-    attributes?: Record<string, unknown>;
-    histogram?: HistogramData;
-    exemplars?: Exemplar[];
-    aggregationTemporality?: AggregationTemporality;
-}
-export interface QueryOptions {
-    startDate?: string;
-    endDate?: string;
-    limit?: number;
-    offset?: number;
-    cursor?: string;
-}
+export declare const aggregationTemporalitySchema: z.ZodEnum<{
+    UNSPECIFIED: "UNSPECIFIED";
+    DELTA: "DELTA";
+    CUMULATIVE: "CUMULATIVE";
+}>;
+export type AggregationTemporality = z.infer<typeof aggregationTemporalitySchema>;
+export declare const queryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+}, z.core.$strip>;
+export type QueryOptions = z.infer<typeof queryOptionsSchema>;
 /**
  * Paginated result wrapper for cursor-based pagination
  */
 export interface PaginatedResult<T> {
     data: T[];
+    /** base64url-encoded (RFC 4648 §5) — matches cursor input validation */
     nextCursor?: string;
     hasMore: boolean;
 }
-export interface NumericFilterCondition {
-    attribute: string;
-    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq';
-    value: number;
-}
+export declare const numericFilterConditionSchema: z.ZodObject<{
+    attribute: z.ZodString;
+    operator: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+    }>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export type NumericFilterCondition = z.infer<typeof numericFilterConditionSchema>;
 /**
  * OTel GenAI agent and tool attribute names
  * https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
@@ -127,11 +57,17 @@ export declare const GENAI_AGENT_ATTRIBUTES: {
     readonly AGENT_ID: "gen_ai.agent.id";
     readonly AGENT_NAME: "gen_ai.agent.name";
     readonly AGENT_DESCRIPTION: "gen_ai.agent.description";
+    /** Agent version string (v1.40.0, Opt-In) */
+    readonly AGENT_VERSION: "gen_ai.agent.version";
 };
 export declare const GENAI_TOOL_ATTRIBUTES: {
     readonly TOOL_NAME: "gen_ai.tool.name";
     readonly TOOL_CALL_ID: "gen_ai.tool.call.id";
     readonly TOOL_TYPE: "gen_ai.tool.type";
+    /** @security Opt-In — may contain PII, credentials, or sensitive data (v1.38.0) */
+    readonly TOOL_CALL_ARGUMENTS: "gen_ai.tool.call.arguments";
+    /** @security Opt-In — may contain PII, credentials, or sensitive data (v1.38.0) */
+    readonly TOOL_CALL_RESULT: "gen_ai.tool.call.result";
 };
 /**
  * OTel GenAI request attribute names
@@ -141,6 +77,11 @@ export declare const GENAI_REQUEST_ATTRIBUTES: {
     readonly MODEL: "gen_ai.request.model";
     readonly TEMPERATURE: "gen_ai.request.temperature";
     readonly MAX_TOKENS: "gen_ai.request.max_tokens";
+    readonly TOP_P: "gen_ai.request.top_p";
+    readonly TOP_K: "gen_ai.request.top_k";
+    readonly STOP_SEQUENCES: "gen_ai.request.stop_sequences";
+    readonly FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty";
+    readonly PRESENCE_PENALTY: "gen_ai.request.presence_penalty";
 };
 /**
  * OTel GenAI response attribute names
@@ -149,6 +90,8 @@ export declare const GENAI_REQUEST_ATTRIBUTES: {
 export declare const GENAI_RESPONSE_ATTRIBUTES: {
     readonly MODEL: "gen_ai.response.model";
     readonly FINISH_REASONS: "gen_ai.response.finish_reasons";
+    /** Provider-assigned response/completion ID (Recommended, pre-v1.27) */
+    readonly ID: "gen_ai.response.id";
 };
 /**
  * OTel GenAI usage attribute names
@@ -157,6 +100,10 @@ export declare const GENAI_RESPONSE_ATTRIBUTES: {
 export declare const GENAI_USAGE_ATTRIBUTES: {
     readonly INPUT_TOKENS: "gen_ai.usage.input_tokens";
     readonly OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
+    /** Tokens served from prompt cache — Anthropic: usage.cache_read_input_tokens (v1.40.0) */
+    readonly CACHE_READ_INPUT_TOKENS: "gen_ai.usage.cache_read.input_tokens";
+    /** Tokens written to prompt cache — Anthropic: usage.cache_creation_input_tokens (v1.40.0) */
+    readonly CACHE_CREATION_INPUT_TOKENS: "gen_ai.usage.cache_creation.input_tokens";
 };
 /**
  * OTel GenAI core attribute names
@@ -167,6 +114,27 @@ export declare const GENAI_CORE_ATTRIBUTES: {
     readonly PROVIDER_NAME: "gen_ai.provider.name";
     readonly SYSTEM: "gen_ai.system";
     readonly CONVERSATION_ID: "gen_ai.conversation.id";
+    /** Output format: 'text' | 'json' | 'image' | 'speech' (v1.37.0, Conditionally Required) */
+    readonly OUTPUT_TYPE: "gen_ai.output.type";
+};
+/**
+ * OTel server attribute names (Stable)
+ * https://opentelemetry.io/docs/specs/semconv/attributes-registry/server/
+ */
+export declare const SERVER_ATTRIBUTES: {
+    /** Hostname of the LLM API endpoint (Recommended) */
+    readonly ADDRESS: "server.address";
+    /** Port of the LLM API endpoint (Conditionally Required when address is set) */
+    readonly PORT: "server.port";
+};
+/**
+ * Routing decision span attribute names
+ * Custom extension for LLM routing telemetry analysis
+ */
+export declare const ROUTING_ATTRIBUTES: {
+    readonly STRATEGY: "routing.strategy";
+    readonly FALLBACK_TRIGGERED: "routing.fallback_triggered";
+    readonly CLASSIFICATION_TIME_MS: "routing.classification.time_ms";
 };
 /**
  * OTel GenAI supported provider identifiers
@@ -209,84 +177,204 @@ export declare const GENAI_PROVIDERS: {
 };
 /** Type for supported provider identifiers */
 export type GenAIProvider = (typeof GENAI_PROVIDERS)[keyof typeof GENAI_PROVIDERS];
+/**
+ * OTel GenAI client metric names (emitted by LLM client instrumentation)
+ * https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
+ */
+export declare const GENAI_CLIENT_METRICS: {
+    /** Token usage histogram — input/output token distributions per request */
+    readonly TOKEN_USAGE: "gen_ai.client.token.usage";
+    /** Operation duration histogram — end-to-end latency per LLM API call (seconds) */
+    readonly OPERATION_DURATION: "gen_ai.client.operation.duration";
+    /** Cost histogram — per-request USD cost (toolkit extension, not in OTel semconv) */
+    readonly COST: "gen_ai.client.cost";
+};
+/**
+ * OTel GenAI server metric names (emitted by LLM hosting infrastructure)
+ * https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
+ * These are passively stored when received via OTLP — not synthesized by the toolkit.
+ */
+export declare const GENAI_SERVER_METRICS: {
+    /** Total request duration histogram (prefill + decode + queue) in seconds */
+    readonly REQUEST_DURATION: "gen_ai.server.request.duration";
+    /** Time from request receipt to first output token (prefill + queue latency) in seconds */
+    readonly TIME_TO_FIRST_TOKEN: "gen_ai.server.time_to_first_token";
+    /** Decode phase latency per output token in seconds */
+    readonly TIME_PER_OUTPUT_TOKEN: "gen_ai.server.time_per_output_token";
+};
+/**
+ * Standard OTel histogram bucket boundaries for GenAI metrics.
+ * Use these when instrumenting a client or server to ensure consistent bucket alignment
+ * across providers and tooling.
+ *
+ * Sources: OTel GenAI semantic conventions v1.39.0, section 3.5
+ */
+export declare const GENAI_HISTOGRAM_BUCKETS: {
+    readonly TOKEN_USAGE: readonly [1, 4, 16, 64, 256, 1024, 4096, 16384, 65536];
+    readonly OPERATION_DURATION: readonly [0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.56, 5, 10, 25, 60, 120, 300];
+    readonly SERVER_TIMING: readonly [0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+    readonly COST_USD: readonly [0.0001, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10];
+};
 /** Array of all supported provider identifiers for validation/documentation */
 export declare const SUPPORTED_PROVIDERS: GenAIProvider[];
-export interface TraceQueryOptions extends QueryOptions {
-    traceId?: string;
-    serviceName?: string;
-    spanName?: string;
-    /** Filter spans by name using regex pattern */
-    spanNameRegex?: string;
-    minDurationMs?: number;
-    maxDurationMs?: number;
-    attributeFilter?: Record<string, string | number | boolean>;
-    /** Exclude spans matching this name (substring match) */
-    excludeSpanName?: string;
-    /** Only include spans where these attributes exist */
-    attributeExists?: string[];
-    /** Exclude spans where these attributes exist */
-    attributeNotExists?: string[];
-    /** Numeric comparison filters for attributes */
-    numericFilter?: NumericFilterCondition[];
-    /** Filter by agent ID (gen_ai.agent.id) */
-    agentId?: string;
-    /** Filter by agent name (gen_ai.agent.name) */
-    agentName?: string;
-    /** Filter by tool name (gen_ai.tool.name) */
-    toolName?: string;
-    /** Filter by tool call ID (gen_ai.tool.call.id) */
-    toolCallId?: string;
-    /** Filter by tool type (gen_ai.tool.type) */
-    toolType?: string;
-    /** Filter by operation name (gen_ai.operation.name) */
-    operationName?: GenAIOperationName;
-}
-export interface LogQueryOptions extends QueryOptions {
-    severity?: string;
-    search?: string;
-    traceId?: string;
-    /** Exclude logs containing this text (case-insensitive) */
-    excludeSearch?: string;
-    /** Only include logs where these attributes exist */
-    attributeExists?: string[];
-    /** Exclude logs where these attributes exist */
-    attributeNotExists?: string[];
-    /** Numeric comparison filters for attributes */
-    numericFilter?: NumericFilterCondition[];
-    /** Multiple search terms for boolean search */
-    searchTerms?: string[];
-    /** Boolean operator for searchTerms: 'AND' (all must match) or 'OR' (any can match). Defaults to 'AND' */
-    searchOperator?: 'AND' | 'OR';
-    /** JSON paths to extract from log body (e.g., ['user.id', 'request.method']) */
-    extractFields?: string[];
-}
-export interface MetricQueryOptions extends QueryOptions {
-    metricName?: string;
-    aggregation?: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'p50' | 'p95' | 'p99' | 'rate';
-    groupBy?: string[];
-    /** Time bucket size for grouping (e.g., '1m', '5m', '1h', '1d') */
-    timeBucket?: string;
-}
-export interface LLMEvent {
-    timestamp: string;
-    name: string;
-    attributes: Record<string, unknown>;
-}
 /**
  * OTel GenAI operation types
  * https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
  */
-export type GenAIOperationName = 'chat' | 'embeddings' | 'invoke_agent' | 'execute_tool';
-export interface LLMEventQueryOptions extends QueryOptions {
-    eventName?: string;
-    model?: string;
-    provider?: string;
-    search?: string;
-    /** Filter by OTel GenAI operation name (chat, embeddings, invoke_agent, execute_tool) */
-    operationName?: GenAIOperationName;
-    /** Filter by conversation/session ID (gen_ai.conversation.id) */
-    conversationId?: string;
-}
+export { genAIOperationNameSchema, type GenAIOperationName };
+/** OTel GenAI output types (v1.37.0, Conditionally Required) */
+export { genAIOutputTypeSchema, type GenAIOutputType };
+export declare const traceQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    traceId: z.ZodOptional<z.ZodString>;
+    serviceName: z.ZodOptional<z.ZodString>;
+    spanName: z.ZodOptional<z.ZodString>;
+    spanNameRegex: z.ZodOptional<z.ZodString>;
+    minDurationMs: z.ZodOptional<z.ZodNumber>;
+    maxDurationMs: z.ZodOptional<z.ZodNumber>;
+    attributeFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    excludeSpanName: z.ZodOptional<z.ZodString>;
+    attributeExists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attributeNotExists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    numericFilter: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        operator: z.ZodEnum<{
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            eq: "eq";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    agentId: z.ZodOptional<z.ZodString>;
+    agentName: z.ZodOptional<z.ZodString>;
+    agentDescription: z.ZodOptional<z.ZodString>;
+    agentVersion: z.ZodOptional<z.ZodString>;
+    toolName: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    toolType: z.ZodOptional<z.ZodString>;
+    operationName: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        embeddings: "embeddings";
+        invoke_agent: "invoke_agent";
+        execute_tool: "execute_tool";
+        text_completion: "text_completion";
+        generate_content: "generate_content";
+        retrieval: "retrieval";
+        create_agent: "create_agent";
+        invoke_workflow: "invoke_workflow";
+    }>>;
+    outputType: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        text: "text";
+        image: "image";
+        speech: "speech";
+    }>>;
+}, z.core.$strip>;
+export type TraceQueryOptions = z.infer<typeof traceQueryOptionsSchema>;
+export declare const logQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    severity: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    excludeSearch: z.ZodOptional<z.ZodString>;
+    attributeExists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attributeNotExists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    numericFilter: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        operator: z.ZodEnum<{
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            eq: "eq";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    searchTerms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    searchOperator: z.ZodOptional<z.ZodEnum<{
+        AND: "AND";
+        OR: "OR";
+    }>>;
+    extractFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type LogQueryOptions = z.infer<typeof logQueryOptionsSchema>;
+export { metricAggregationSchema, type MetricAggregation };
+export declare const metricQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    metricName: z.ZodOptional<z.ZodString>;
+    aggregation: z.ZodOptional<z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+        sum: "sum";
+        rate: "rate";
+    }>>;
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeBucket: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MetricQueryOptions = z.infer<typeof metricQueryOptionsSchema>;
+/** OTLP AggregationTemporality numeric values */
+export declare const AGGREGATION_TEMPORALITY: {
+    readonly UNSPECIFIED: 0;
+    readonly DELTA: 1;
+    readonly CUMULATIVE: 2;
+};
+export declare const aggregationTemporalityNumericSchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+export type AggregationTemporalityNumeric = z.infer<typeof aggregationTemporalityNumericSchema>;
+export declare const histogramQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    metricName: z.ZodOptional<z.ZodString>;
+    serviceName: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    aggregationTemporality: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+}, z.core.$strip>;
+export type HistogramQueryOptions = z.infer<typeof histogramQueryOptionsSchema>;
+export declare const llmEventQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    eventName: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    operationName: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        embeddings: "embeddings";
+        invoke_agent: "invoke_agent";
+        execute_tool: "execute_tool";
+        text_completion: "text_completion";
+        generate_content: "generate_content";
+        retrieval: "retrieval";
+        create_agent: "create_agent";
+        invoke_workflow: "invoke_workflow";
+    }>>;
+    conversationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LLMEventQueryOptions = z.infer<typeof llmEventQueryOptionsSchema>;
 /**
  * OTel GenAI evaluation attribute names
  * https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-events/
@@ -303,8 +391,6 @@ export declare const GENAI_EVALUATION_ATTRIBUTES: {
     /** Custom extension: Type of evaluator */
     readonly EVALUATOR_TYPE: "gen_ai.evaluation.evaluator.type";
 };
-/** Evaluator types for LLM quality evaluation */
-export type EvaluatorType = 'llm' | 'human' | 'rule' | 'classifier';
 /**
  * Custom OTel attribute extensions for Agent-as-Judge evaluation.
  * These extend the official OTel GenAI semantic conventions (as of 2026-02).
@@ -318,214 +404,395 @@ export declare const AGENT_JUDGE_ATTRIBUTES: {
     /** Custom: integer count of steps in agent trajectory */
     readonly TRAJECTORY_LENGTH: "gen_ai.evaluation.trajectory_length";
 };
-/** Maximum recommended step scores per evaluation for performance */
-export declare const MAX_STEP_SCORES = 1000;
-/** Maximum recommended tool verifications per evaluation for performance */
-export declare const MAX_TOOL_VERIFICATIONS = 500;
-/** Maximum step identifier length */
-export declare const MAX_STEP_ID_LENGTH = 256;
-/**
- * Per-step evaluation score for agent trajectory analysis.
- * Captures evaluation of individual steps in an agent's execution.
- *
- * @remarks
- * - Maximum 1000 steps recommended per evaluation for query performance
- * - Step identifiers limited to 256 characters
- * - Scores must be in normalized range [0, 1]
- * - Evidence MUST be JSON-serializable (no functions, symbols, circular refs)
- *
- * Stored as custom OTel attribute: `gen_ai.evaluation.step_scores` (JSON array)
- *
- * @example
- * ```typescript
- * const stepScores: StepScore[] = [
- *   { step: 0, score: 0.9, explanation: 'Correct tool selection' },
- *   { step: 1, score: 0.7, explanation: 'Valid arguments but suboptimal' },
- *   { step: 'final_response', score: 1.0, evidence: { matched: true } },
- * ];
- * ```
- */
-export interface StepScore {
-    /** Step identifier (max 256 chars) or zero-based index (non-negative integer) */
-    step: string | number;
-    /** Normalized score for this step (0-1 inclusive) */
-    score: number;
-    /**
-     * Evidence supporting the score.
-     * @security MUST be JSON-serializable (no functions, symbols, circular refs)
-     */
-    evidence?: Record<string, unknown> | string | number | boolean | null;
-    /** Optional explanation for the score */
-    explanation?: string;
-}
-/**
- * Type guard for indexed step scores (numeric trajectory index).
- * Use for type narrowing when processing agent trajectory steps.
- *
- * @param score - StepScore to check
- * @returns true if step is a numeric index
- *
- * @example
- * ```typescript
- * if (isIndexedStep(score)) {
- *   console.log(`Step ${score.step + 1} of ${total}`); // step is number
- * }
- * ```
- */
-export declare function isIndexedStep(score: StepScore): score is StepScore & {
-    step: number;
-};
+export { evaluationAggregationSchema, type EvaluationAggregation };
+export { evaluationGroupByFieldSchema, type EvaluationGroupByField };
+export declare const evaluationQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    evaluationName: z.ZodOptional<z.ZodString>;
+    scoreMin: z.ZodOptional<z.ZodNumber>;
+    scoreMax: z.ZodOptional<z.ZodNumber>;
+    scoreLabel: z.ZodOptional<z.ZodString>;
+    evaluator: z.ZodOptional<z.ZodString>;
+    evaluatorType: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        human: "human";
+        rule: "rule";
+        classifier: "classifier";
+        seed: "seed";
+        canary: "canary";
+    }>>;
+    responseId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    aggregation: z.ZodOptional<z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>>;
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        evaluationName: "evaluationName";
+        scoreLabel: "scoreLabel";
+        evaluator: "evaluator";
+    }>>>;
+    agentId: z.ZodOptional<z.ZodString>;
+    agentName: z.ZodOptional<z.ZodString>;
+    datasetId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EvaluationQueryOptions = z.infer<typeof evaluationQueryOptionsSchema>;
+export type { OTLPTraceExport, OTLPLogExport, OTLPMetricExport, } from '../lib/exports/otlp-export.js';
+export type { VerificationType, HumanVerificationEvent, VerificationQueryOptions, } from '../lib/audit/verification-events.js';
+export { VALID_VERIFICATION_TYPES, recordVerification, queryVerifications, } from '../lib/audit/verification-events.js';
 /**
- * Type guard for named step scores (semantic step identifier).
- * Use for type narrowing when processing named evaluation steps.
- *
- * @param score - StepScore to check
- * @returns true if step is a string identifier
- *
- * @example
- * ```typescript
- * if (isNamedStep(score)) {
- *   console.log(`Evaluating: ${score.step}`); // step is string
- * }
- * ```
+ * /v1/cost is aggregated and server-capped at 100 rows.
+ * limit/cursor/offset from the base QueryOptions are not forwarded to the API.
  */
-export declare function isNamedStep(score: StepScore): score is StepScore & {
-    step: string;
-};
-/**
- * Tool call verification result for agent evaluation.
- * Records correctness of individual tool invocations.
- *
- * @remarks
- * - Maximum 500 verifications recommended per evaluation for query performance
- * - Score is typically a weighted average of toolCorrect, argsCorrect, resultCorrect
- * - Score formula: (toolCorrect * 0.4 + argsCorrect * 0.3 + resultCorrect * 0.3)
- *
- * Stored as custom OTel attribute: `gen_ai.evaluation.tool_verifications` (JSON array)
- *
- * @example
- * ```typescript
- * const verification: ToolVerification = {
- *   toolName: 'search',
- *   toolCallId: 'call_abc123',
- *   toolCorrect: true,
- *   argsCorrect: true,
- *   resultCorrect: true,
- *   score: 1.0,
- *   expectedTool: 'search',
- *   evidence: { query: 'test', results: 5 },
- * };
- * ```
- */
-export interface ToolVerification {
-    /** Name of the tool that was called */
-    toolName: string;
-    /** Tool call ID for correlation (gen_ai.tool.call.id) */
-    toolCallId?: string;
-    /** Whether the tool selection was correct */
-    toolCorrect: boolean;
-    /** Whether the arguments were valid/correct */
-    argsCorrect: boolean;
-    /** Whether the result was as expected (if verifiable) */
-    resultCorrect?: boolean;
-    /**
-     * Combined correctness score (0-1).
-     * Typically computed as weighted average of correctness flags.
-     */
-    score: number;
-    /** Expected tool name (for comparison in evaluation) */
-    expectedTool?: string;
-    /**
-     * Evidence or execution result.
-     * @security MUST be JSON-serializable (no functions, symbols, circular refs)
-     */
-    evidence?: Record<string, unknown> | string | number | boolean | null;
-}
-/**
- * Normalized evaluation result from gen_ai.evaluation.result events
- */
-export interface EvaluationResult {
-    /** ISO timestamp of the evaluation */
-    timestamp: string;
-    /** Evaluation metric name (gen_ai.evaluation.name) - required */
-    evaluationName: string;
-    /** Numeric score (gen_ai.evaluation.score.value) */
-    scoreValue?: number;
-    /** Human-readable score label (gen_ai.evaluation.score.label) */
-    scoreLabel?: string;
-    /** Score unit/scale (e.g., "ratio_0_1", "percentage") */
-    scoreUnit?: string;
-    /** Free-form explanation (gen_ai.evaluation.explanation) */
-    explanation?: string;
-    /** Identity of the evaluator - model name, human ID, or system name */
-    evaluator?: string;
-    /** Type of evaluator (llm, human, rule, classifier) */
-    evaluatorType?: EvaluatorType;
-    /** Response ID for correlation (gen_ai.response.id) */
-    responseId?: string;
-    /** Trace ID for correlation */
-    traceId?: string;
-    /** Span ID for correlation */
-    spanId?: string;
-    /** Session ID for session-scoped queries */
-    sessionId?: string;
-    /** Subject agent ID being evaluated (gen_ai.agent.id) */
-    agentId?: string;
-    /** Subject agent name being evaluated (gen_ai.agent.name) */
-    agentName?: string;
-    /**
-     * Per-step evaluation breakdown for agent trajectory.
-     * - `undefined`: No trajectory evaluation performed
-     * - `[]`: Zero-step execution (rare, usually indicates error)
-     * Max recommended: 1000 steps
-     */
-    stepScores?: StepScore[];
-    /**
-     * Tool call correctness verifications.
-     * Max recommended: 500 verifications
-     */
-    toolVerifications?: ToolVerification[];
-    /**
-     * Number of steps/actions in agent trajectory (efficiency metric).
-     * Stored as: gen_ai.evaluation.trajectory_length
-     */
-    trajectoryLength?: number;
-}
-/** Aggregation functions for evaluation scores */
-export type EvaluationAggregation = 'avg' | 'min' | 'max' | 'count' | 'p50' | 'p95' | 'p99';
-/** Fields that can be used for groupBy in evaluation queries */
-export type EvaluationGroupByField = 'evaluationName' | 'scoreLabel' | 'evaluator';
-export interface EvaluationQueryOptions extends QueryOptions {
-    /** Filter by evaluation metric name (gen_ai.evaluation.name) */
-    evaluationName?: string;
-    /** Minimum score threshold */
-    scoreMin?: number;
-    /** Maximum score threshold */
-    scoreMax?: number;
-    /** Filter by score label (e.g., "pass", "fail", "relevant") */
-    scoreLabel?: string;
-    /** Filter by evaluator identity (exact match, e.g., "gpt-4-as-judge") */
-    evaluator?: string;
-    /** Filter by evaluator type (llm, human, rule, classifier) */
-    evaluatorType?: EvaluatorType;
-    /** Filter by response ID for correlation */
-    responseId?: string;
-    /** Filter by trace ID */
-    traceId?: string;
-    /** Filter by session ID */
-    sessionId?: string;
-    /** Aggregation function for scores */
-    aggregation?: EvaluationAggregation;
-    /** Group aggregations by these fields */
-    groupBy?: EvaluationGroupByField[];
-    /** Filter by subject agent ID (gen_ai.agent.id) */
-    agentId?: string;
-    /** Filter by subject agent name (gen_ai.agent.name) */
-    agentName?: string;
-}
-export type { OTLPTraceExport, OTLPLogExport, OTLPMetricExport, } from '../lib/otlp-export.js';
-export type { VerificationType, HumanVerificationEvent, VerificationQueryOptions, } from '../lib/verification-events.js';
-export { VALID_VERIFICATION_TYPES, recordVerification, queryVerifications, } from '../lib/verification-events.js';
+export declare const costQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodISODate>;
+    endDate: z.ZodOptional<z.ZodISODate>;
+    serviceName: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CostQueryOptions = z.infer<typeof costQueryOptionsSchema>;
+/** Discriminated union for dataset management actions */
+export declare const datasetManageOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    frozen: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    traceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    evaluationNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    selectionCriteria: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    fieldMapping: z.ZodOptional<z.ZodObject<{
+        input: z.ZodString;
+        expectedOutput: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    filterFrozen: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"get">;
+    datasetId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    datasetId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"add_traces">;
+    datasetId: z.ZodString;
+    traceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"remove_traces">;
+    datasetId: z.ZodString;
+    traceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"get_version">;
+    datasetId: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list_versions">;
+    datasetId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"promote">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    traceIds: z.ZodArray<z.ZodString>;
+    evaluationNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    frozen: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list_runs">;
+    datasetId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "action">;
+export type DatasetManageOptions = z.infer<typeof datasetManageOptionsSchema>;
+/** Discriminated union for dataset management results — per-action success + unified failure */
+export declare const datasetManageResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    datasets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"get">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+    traces: z.ZodArray<z.ZodObject<{
+        datasetId: z.ZodString;
+        traceId: z.ZodString;
+        addedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    traceCount: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    deleted: z.ZodBoolean;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"add_traces">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+    tracesAdded: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"remove_traces">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+    tracesRemoved: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"get_version">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+    traces: z.ZodArray<z.ZodObject<{
+        datasetId: z.ZodString;
+        traceId: z.ZodString;
+        addedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list_versions">;
+    versions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"promote">;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        frozen: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+        traceCount: z.ZodNumber;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        selectionCriteria: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        version: z.ZodOptional<z.ZodNumber>;
+        parentVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        versionCreatedAt: z.ZodOptional<z.ZodISODateTime>;
+        versionReason: z.ZodOptional<z.ZodEnum<{
+            created: "created";
+            traces_added: "traces_added";
+            traces_removed: "traces_removed";
+            metadata_updated: "metadata_updated";
+        }>>;
+        fieldMapping: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        traceSnapshot: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dateRangeStart: z.ZodNullable<z.ZodISODate>;
+        dateRangeEnd: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"list_runs">;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        datasetId: z.ZodString;
+        datasetVersion: z.ZodNumber;
+        runAt: z.ZodISODateTime;
+        evaluationNames: z.ZodArray<z.ZodString>;
+        resultCount: z.ZodNumber;
+        evaluator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "action">;
+export type DatasetManageResult = z.infer<typeof datasetManageResultSchema>;
 export interface TelemetryBackend {
     name: string;
     queryTraces(options: TraceQueryOptions): Promise<TraceSpan[]>;
@@ -533,13 +800,19 @@ export interface TelemetryBackend {
     queryMetrics(options: MetricQueryOptions): Promise<MetricDataPoint[]>;
     queryLLMEvents?(options: LLMEventQueryOptions): Promise<LLMEvent[]>;
     queryEvaluations?(options: EvaluationQueryOptions): Promise<EvaluationResult[]>;
+    /** Query metric_histograms table (cloud backend) or histogram-typed entries from JSONL (local) */
+    queryMetricHistograms?(options: HistogramQueryOptions): Promise<HistogramDataPoint[]>;
+    /** Query aggregated LLM token cost by model from GET /v1/cost (cloud backend only) */
+    queryCost?(options: CostQueryOptions): Promise<CostDataPoint[]>;
+    /** Manage evaluation datasets (CRUD, versioning, promotion) */
+    manageDatasets?(options: DatasetManageOptions): Promise<DatasetManageResult>;
     healthCheck(): Promise<{
         status: 'ok' | 'error';
         message?: string;
     }>;
-    getCacheStats?(): Record<string, import('../lib/cache.js').CacheStats>;
-    exportTracesOTLP?(options: TraceQueryOptions): Promise<import('../lib/otlp-export.js').OTLPTraceExport>;
-    exportLogsOTLP?(options: LogQueryOptions): Promise<import('../lib/otlp-export.js').OTLPLogExport>;
-    exportMetricsOTLP?(options: MetricQueryOptions): Promise<import('../lib/otlp-export.js').OTLPMetricExport>;
+    getCacheStats?(): Record<string, import('../lib/resilience/cache.js').CacheStats>;
+    exportTracesOTLP?(options: TraceQueryOptions): Promise<import('../lib/exports/otlp-export.js').OTLPTraceExport>;
+    exportLogsOTLP?(options: LogQueryOptions): Promise<import('../lib/exports/otlp-export.js').OTLPLogExport>;
+    exportMetricsOTLP?(options: MetricQueryOptions): Promise<import('../lib/exports/otlp-export.js').OTLPMetricExport>;
 }
 //# sourceMappingURL=index.d.ts.map