@scoutqa/mastra-core 0.24.6-fork.1

package/dist/ai-tracing/tracers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mastra AI Tracers
+ */
+export * from './base.js';
+export * from './default.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ai-tracing/tracers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/tracers/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC"}

package/dist/ai-tracing/types.d.ts

@@ -0,0 +1,696 @@
+/**
+ * AI Tracing interfaces
+ */
+import type { MastraError } from '../error/index.js';
+import type { IMastraLogger } from '../logger/index.js';
+import type { RuntimeContext } from '../runtime-context/index.js';
+import type { WorkflowRunStatus, WorkflowStepStatus } from '../workflows/index.js';
+/**
+ * AI-specific span types with their associated metadata
+ */
+export declare enum AISpanType {
+    /** Agent run - root span for agent processes */
+    AGENT_RUN = "agent_run",
+    /** Generic span for custom operations */
+    GENERIC = "generic",
+    /** Model generation with model calls, token usage, prompts, completions */
+    MODEL_GENERATION = "model_generation",
+    /** Single model execution step within a generation (one API call) */
+    MODEL_STEP = "model_step",
+    /** Individual model streaming chunk/event */
+    MODEL_CHUNK = "model_chunk",
+    /** MCP (Model Context Protocol) tool execution */
+    MCP_TOOL_CALL = "mcp_tool_call",
+    /** Input or Output Processor execution */
+    PROCESSOR_RUN = "processor_run",
+    /** Function/tool execution with inputs, outputs, errors */
+    TOOL_CALL = "tool_call",
+    /** Workflow run - root span for workflow processes */
+    WORKFLOW_RUN = "workflow_run",
+    /** Workflow step execution with step status, data flow */
+    WORKFLOW_STEP = "workflow_step",
+    /** Workflow conditional execution with condition evaluation */
+    WORKFLOW_CONDITIONAL = "workflow_conditional",
+    /** Individual condition evaluation within conditional */
+    WORKFLOW_CONDITIONAL_EVAL = "workflow_conditional_eval",
+    /** Workflow parallel execution */
+    WORKFLOW_PARALLEL = "workflow_parallel",
+    /** Workflow loop execution */
+    WORKFLOW_LOOP = "workflow_loop",
+    /** Workflow sleep operation */
+    WORKFLOW_SLEEP = "workflow_sleep",
+    /** Workflow wait for event operation */
+    WORKFLOW_WAIT_EVENT = "workflow_wait_event"
+}
+/**
+ * Base attributes that all spans can have
+ */
+export interface AIBaseAttributes {
+}
+/**
+ * Agent Run attributes
+ */
+export interface AgentRunAttributes extends AIBaseAttributes {
+    /** Agent identifier */
+    agentId: string;
+    /** Agent Instructions **/
+    instructions?: string;
+    /** Agent Prompt **/
+    prompt?: string;
+    /** Available tools for this execution */
+    availableTools?: string[];
+    /** Maximum steps allowed */
+    maxSteps?: number;
+}
+/** Token usage statistics - supports both v5 and legacy formats */
+export interface UsageStats {
+    inputTokens?: number;
+    outputTokens?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    reasoningTokens?: number;
+    cachedInputTokens?: number;
+    promptCacheHitTokens?: number;
+    promptCacheMissTokens?: number;
+}
+/**
+ * Model Generation attributes
+ */
+export interface ModelGenerationAttributes extends AIBaseAttributes {
+    /** Model name (e.g., 'gpt-4', 'claude-3') */
+    model?: string;
+    /** Model provider (e.g., 'openai', 'anthropic') */
+    provider?: string;
+    /** Type of result/output this LLM call produced */
+    resultType?: 'tool_selection' | 'response_generation' | 'reasoning' | 'planning';
+    /** Token usage statistics - supports both v5 and legacy formats */
+    usage?: UsageStats;
+    /** Model parameters */
+    parameters?: {
+        maxOutputTokens?: number;
+        temperature?: number;
+        topP?: number;
+        topK?: number;
+        presencePenalty?: number;
+        frequencyPenalty?: number;
+        stopSequences?: string[];
+        seed?: number;
+        maxRetries?: number;
+        abortSignal?: any;
+        headers?: Record<string, string | undefined>;
+    };
+    /** Whether this was a streaming response */
+    streaming?: boolean;
+    /** Reason the generation finished */
+    finishReason?: string;
+}
+/**
+ * Model Step attributes - for a single model execution within a generation
+ */
+export interface ModelStepAttributes extends AIBaseAttributes {
+    /** Index of this step in the generation (0, 1, 2, ...) */
+    stepIndex?: number;
+    /** Token usage statistics */
+    usage?: UsageStats;
+    /** Reason this step finished (stop, tool-calls, length, etc.) */
+    finishReason?: string;
+    /** Should execution continue */
+    isContinued?: boolean;
+    /** Result warnings */
+    warnings?: Record<string, any>;
+}
+/**
+ * Model Chunk attributes - for individual streaming chunks/events
+ */
+export interface ModelChunkAttributes extends AIBaseAttributes {
+    /** Type of chunk (text-delta, reasoning-delta, tool-call, etc.) */
+    chunkType?: string;
+    /** Sequence number of this chunk in the stream */
+    sequenceNumber?: number;
+}
+/**
+ * Tool Call attributes
+ */
+export interface ToolCallAttributes extends AIBaseAttributes {
+    toolId?: string;
+    toolType?: string;
+    toolDescription?: string;
+    success?: boolean;
+}
+/**
+ * MCP Tool Call attributes
+ */
+export interface MCPToolCallAttributes extends AIBaseAttributes {
+    /** Id of the MCP tool/function */
+    toolId: string;
+    /** MCP server identifier */
+    mcpServer: string;
+    /** MCP server version */
+    serverVersion?: string;
+    /** Whether tool execution was successful */
+    success?: boolean;
+}
+/**
+ * Processor attributes
+ */
+export interface ProcessorRunAttributes extends AIBaseAttributes {
+    /** Name of the Processor */
+    processorName: string;
+    /** Processor type (input or output) */
+    processorType: 'input' | 'output';
+    /** Processor index in the agent */
+    processorIndex?: number;
+}
+/**
+ * Workflow Run attributes
+ */
+export interface WorkflowRunAttributes extends AIBaseAttributes {
+    /** Workflow identifier */
+    workflowId: string;
+    /** Workflow status */
+    status?: WorkflowRunStatus;
+}
+/**
+ * Workflow Step attributes
+ */
+export interface WorkflowStepAttributes extends AIBaseAttributes {
+    /** Step identifier */
+    stepId: string;
+    /** Step status */
+    status?: WorkflowStepStatus;
+}
+/**
+ * Workflow Conditional attributes
+ */
+export interface WorkflowConditionalAttributes extends AIBaseAttributes {
+    /** Number of conditions evaluated */
+    conditionCount: number;
+    /** Which condition indexes evaluated to true */
+    truthyIndexes?: number[];
+    /** Which steps will be executed */
+    selectedSteps?: string[];
+}
+/**
+ * Workflow Conditional Evaluation attributes
+ */
+export interface WorkflowConditionalEvalAttributes extends AIBaseAttributes {
+    /** Index of this condition in the conditional */
+    conditionIndex: number;
+    /** Result of condition evaluation */
+    result?: boolean;
+}
+/**
+ * Workflow Parallel attributes
+ */
+export interface WorkflowParallelAttributes extends AIBaseAttributes {
+    /** Number of parallel branches */
+    branchCount: number;
+    /** Step IDs being executed in parallel */
+    parallelSteps?: string[];
+}
+/**
+ * Workflow Loop attributes
+ */
+export interface WorkflowLoopAttributes extends AIBaseAttributes {
+    /** Type of loop (foreach, dowhile, dountil) */
+    loopType?: 'foreach' | 'dowhile' | 'dountil';
+    /** Current iteration number (for individual iterations) */
+    iteration?: number;
+    /** Total iterations (if known) */
+    totalIterations?: number;
+    /** Number of steps to run concurrently in foreach loop */
+    concurrency?: number;
+}
+/**
+ * Workflow Sleep attributes
+ */
+export interface WorkflowSleepAttributes extends AIBaseAttributes {
+    /** Sleep duration in milliseconds */
+    durationMs?: number;
+    /** Sleep until date */
+    untilDate?: Date;
+    /** Sleep type */
+    sleepType?: 'fixed' | 'dynamic';
+}
+/**
+ * Workflow Wait Event attributes
+ */
+export interface WorkflowWaitEventAttributes extends AIBaseAttributes {
+    /** Event name being waited for */
+    eventName?: string;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+    /** Whether event was received or timed out */
+    eventReceived?: boolean;
+    /** Wait duration in milliseconds */
+    waitDurationMs?: number;
+}
+/**
+ * AI-specific span types mapped to their attributes
+ */
+export interface AISpanTypeMap {
+    [AISpanType.AGENT_RUN]: AgentRunAttributes;
+    [AISpanType.WORKFLOW_RUN]: WorkflowRunAttributes;
+    [AISpanType.MODEL_GENERATION]: ModelGenerationAttributes;
+    [AISpanType.MODEL_STEP]: ModelStepAttributes;
+    [AISpanType.MODEL_CHUNK]: ModelChunkAttributes;
+    [AISpanType.TOOL_CALL]: ToolCallAttributes;
+    [AISpanType.MCP_TOOL_CALL]: MCPToolCallAttributes;
+    [AISpanType.PROCESSOR_RUN]: ProcessorRunAttributes;
+    [AISpanType.WORKFLOW_STEP]: WorkflowStepAttributes;
+    [AISpanType.WORKFLOW_CONDITIONAL]: WorkflowConditionalAttributes;
+    [AISpanType.WORKFLOW_CONDITIONAL_EVAL]: WorkflowConditionalEvalAttributes;
+    [AISpanType.WORKFLOW_PARALLEL]: WorkflowParallelAttributes;
+    [AISpanType.WORKFLOW_LOOP]: WorkflowLoopAttributes;
+    [AISpanType.WORKFLOW_SLEEP]: WorkflowSleepAttributes;
+    [AISpanType.WORKFLOW_WAIT_EVENT]: WorkflowWaitEventAttributes;
+    [AISpanType.GENERIC]: AIBaseAttributes;
+}
+/**
+ * Union type for cases that need to handle any span type
+ */
+export type AnyAISpanAttributes = AISpanTypeMap[keyof AISpanTypeMap];
+/**
+ * Base Span interface
+ */
+interface BaseSpan<TType extends AISpanType> {
+    /** Unique span identifier */
+    id: string;
+    /** OpenTelemetry-compatible trace ID (32 hex chars) - present on all spans */
+    traceId: string;
+    /** Name of the span */
+    name: string;
+    /** Type of the span */
+    type: TType;
+    /** When span started */
+    startTime: Date;
+    /** When span ended */
+    endTime?: Date;
+    /** Is an internal span? (spans internal to the operation of mastra) */
+    attributes?: AISpanTypeMap[TType];
+    /** User-defined metadata */
+    metadata?: Record<string, any>;
+    /** Input passed at the start of the span */
+    input?: any;
+    /** Output generated at the end of the span */
+    output?: any;
+    /** Error information if span failed */
+    errorInfo?: {
+        message: string;
+        id?: string;
+        domain?: string;
+        category?: string;
+        details?: Record<string, any>;
+    };
+    /** Is an event span? (event occurs at startTime, has no endTime) */
+    isEvent: boolean;
+}
+/**
+ * AI Span interface, used internally for tracing
+ */
+export interface AISpan<TType extends AISpanType> extends BaseSpan<TType> {
+    /** Is an internal span? (spans internal to the operation of mastra) */
+    isInternal: boolean;
+    /** Parent span reference (undefined for root spans) */
+    parent?: AnyAISpan;
+    /** Pointer to the AITracing instance */
+    aiTracing: AITracing;
+    /** Trace-level state shared across all spans in this trace */
+    traceState?: TraceState;
+    /** End the span */
+    end(options?: EndSpanOptions<TType>): void;
+    /** Record an error for the span, optionally end the span as well */
+    error(options: ErrorSpanOptions<TType>): void;
+    /** Update span attributes */
+    update(options: UpdateSpanOptions<TType>): void;
+    /** Create child span - can be any span type independent of parent */
+    createChildSpan<TChildType extends AISpanType>(options: ChildSpanOptions<TChildType>): AISpan<TChildType>;
+    /** Create event span - can be any span type independent of parent */
+    createEventSpan<TChildType extends AISpanType>(options: ChildEventOptions<TChildType>): AISpan<TChildType>;
+    /** Returns `TRUE` if the span is the root span of a trace */
+    get isRootSpan(): boolean;
+    /** Returns `TRUE` if the span is a valid span (not a NO-OP Span) */
+    get isValid(): boolean;
+    /** Get the closest parent spanId that isn't an internal span */
+    getParentSpanId(includeInternalSpans?: boolean): string | undefined;
+    /** Find the closest parent span of a specific type by walking up the parent chain */
+    findParent<T extends AISpanType>(spanType: T): AISpan<T> | undefined;
+    /** Returns a lightweight span ready for export */
+    exportSpan(includeInternalSpans?: boolean): ExportedAISpan<TType> | undefined;
+}
+/**
+ * Exported AI Span interface, used for tracing exporters
+ */
+export interface ExportedAISpan<TType extends AISpanType> extends BaseSpan<TType> {
+    /** Parent span id reference (undefined for root spans) */
+    parentSpanId?: string;
+    /** `TRUE` if the span is the root span of a trace */
+    isRootSpan: boolean;
+}
+/**
+ * Union type for cases that need to handle any span
+ */
+export type AnyAISpan = AISpan<keyof AISpanTypeMap>;
+/**
+ * Union type for cases that need to handle any exported span
+ */
+export type AnyExportedAISpan = ExportedAISpan<keyof AISpanTypeMap>;
+/**
+ * Primary interface for AI Tracing
+ */
+export interface AITracing {
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<Required<TracingConfig>>;
+    /**
+     * Get all exporters
+     */
+    getExporters(): readonly AITracingExporter[];
+    /**
+     * Get all processors
+     */
+    getProcessors(): readonly AISpanProcessor[];
+    /**
+     * Get the logger instance (for exporters and other components)
+     */
+    getLogger(): IMastraLogger;
+    /**
+     * Start a new span of a specific AISpanType
+     */
+    startSpan<TType extends AISpanType>(options: StartSpanOptions<TType>): AISpan<TType>;
+    /**
+     * Shutdown AI tracing and clean up resources
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Override setLogger to add AI tracing specific initialization log
+     */
+    __setLogger(logger: IMastraLogger): void;
+}
+interface CreateBaseOptions<TType extends AISpanType> {
+    /** Span attributes */
+    attributes?: AISpanTypeMap[TType];
+    /** Span metadata */
+    metadata?: Record<string, any>;
+    /** Span name */
+    name: string;
+    /** Span type */
+    type: TType;
+    /** Policy-level tracing configuration */
+    tracingPolicy?: TracingPolicy;
+    /** Runtime context for metadata extraction */
+    runtimeContext?: RuntimeContext;
+}
+/**
+ * Options for creating new spans
+ */
+export interface CreateSpanOptions<TType extends AISpanType> extends CreateBaseOptions<TType> {
+    /** Input data */
+    input?: any;
+    /** Output data (for event spans) */
+    output?: any;
+    /** Parent span */
+    parent?: AnyAISpan;
+    /** Is an event span? */
+    isEvent?: boolean;
+    /**
+     * Trace ID to use for this span (1-32 hexadecimal characters).
+     * Only used for root spans without a parent.
+     */
+    traceId?: string;
+    /**
+     * Parent span ID to use for this span (1-16 hexadecimal characters).
+     * Only used for root spans without a parent.
+     */
+    parentSpanId?: string;
+    /** Trace-level state shared across all spans in this trace */
+    traceState?: TraceState;
+}
+/**
+ * Options for starting new spans
+ */
+export interface StartSpanOptions<TType extends AISpanType> extends CreateSpanOptions<TType> {
+    /**
+     * Options passed when using a custom sampler strategy
+     */
+    customSamplerOptions?: CustomSamplerOptions;
+    /** Tracing options for this execution */
+    tracingOptions?: TracingOptions;
+}
+/**
+ * Options for new child spans
+ */
+export interface ChildSpanOptions<TType extends AISpanType> extends CreateBaseOptions<TType> {
+    /** Input data */
+    input?: any;
+}
+/**
+ * Options for new child events
+ * Event spans have no input, and no endTime
+ */
+export interface ChildEventOptions<TType extends AISpanType> extends CreateBaseOptions<TType> {
+    /** Output data */
+    output?: any;
+}
+interface UpdateBaseOptions<TType extends AISpanType> {
+    /** Span attributes */
+    attributes?: Partial<AISpanTypeMap[TType]>;
+    /** Span metadata */
+    metadata?: Record<string, any>;
+}
+export interface EndSpanOptions<TType extends AISpanType> extends UpdateBaseOptions<TType> {
+    /** Output data */
+    output?: any;
+}
+export interface UpdateSpanOptions<TType extends AISpanType> extends UpdateBaseOptions<TType> {
+    /** Input data */
+    input?: any;
+    /** Output data */
+    output?: any;
+}
+export interface ErrorSpanOptions<TType extends AISpanType> extends UpdateBaseOptions<TType> {
+    /** The error associated with the issue */
+    error: MastraError | Error;
+    /** End the span when true */
+    endSpan?: boolean;
+}
+/**
+ * Bitwise options to set different types of spans as internal in
+ * a workflow or agent execution.
+ */
+export declare enum InternalSpans {
+    /** No spans are marked internal */
+    NONE = 0,
+    /** Workflow spans are marked internal */
+    WORKFLOW = 1,// 0001
+    /** Agent spans are marked internal */
+    AGENT = 2,// 0010
+    /** Tool spans are marked internal */
+    TOOL = 4,// 0100
+    /** Model spans are marked internal */
+    MODEL = 8,// 1000
+    /** All spans are marked internal */
+    ALL = 15
+}
+/**
+ * Policy-level tracing configuration applied when creating
+ * a workflow or agent. Unlike TracingOptions, which are
+ * provided at execution time, policies define persistent rules
+ * for how spans are treated across all executions of the
+ * workflow/agent.
+ */
+export interface TracingPolicy {
+    /**
+     * Bitwise options to set different types of spans as Internal in
+     * a workflow or agent execution. Internal spans are hidden by
+     * default in exported traces.
+     */
+    internal?: InternalSpans;
+}
+/**
+ * Trace-level state computed once at the start of a trace
+ * and shared by all spans within that trace.
+ */
+export interface TraceState {
+    /**
+     * RuntimeContext keys to extract as metadata for all spans in this trace.
+     * Computed by merging the tracing config's runtimeContextKeys
+     * with the per-request runtimeContextKeys.
+     */
+    runtimeContextKeys: string[];
+}
+/**
+ * Options passed when starting a new agent or workflow execution
+ */
+export interface TracingOptions {
+    /** Metadata to add to the root trace span */
+    metadata?: Record<string, any>;
+    /**
+     * Additional RuntimeContext keys to extract as metadata for this trace.
+     * These keys are added to the runtimeContextKeys config.
+     * Supports dot notation for nested values (e.g., 'user.id', 'session.data.experimentId').
+     */
+    runtimeContextKeys?: string[];
+    /**
+     * Trace ID to use for this execution (1-32 hexadecimal characters).
+     * If provided, this trace will be part of the specified trace rather than starting a new one.
+     */
+    traceId?: string;
+    /**
+     * Parent span ID to use for this execution (1-16 hexadecimal characters).
+     * If provided, the root span will be created as a child of this span.
+     */
+    parentSpanId?: string;
+}
+/**
+ * Context for AI tracing that flows through workflow and agent execution
+ */
+export interface TracingContext {
+    /** Current AI span for creating child spans and adding metadata */
+    currentSpan?: AnyAISpan;
+}
+/**
+ * Properties returned to the user for working with traces externally.
+ */
+export type TracingProperties = {
+    /** Trace ID used on the execution (if the execution was traced). */
+    traceId?: string;
+};
+/**
+ * Configuration for a single tracing instance
+ */
+export interface TracingConfig {
+    /** Unique identifier for this config in the ai tracing registry */
+    name: string;
+    /** Service name for tracing */
+    serviceName: string;
+    /** Sampling strategy - controls whether tracing is collected (defaults to ALWAYS) */
+    sampling?: SamplingStrategy;
+    /** Custom exporters */
+    exporters?: AITracingExporter[];
+    /** Custom processors */
+    processors?: AISpanProcessor[];
+    /** Set to `true` if you want to see spans internal to the operation of mastra */
+    includeInternalSpans?: boolean;
+    /**
+     * RuntimeContext keys to automatically extract as metadata for all spans
+     * created with this tracing configuration.
+     * Supports dot notation for nested values.
+     */
+    runtimeContextKeys?: string[];
+}
+/**
+ * Complete AI Tracing registry configuration
+ */
+export interface ObservabilityRegistryConfig {
+    /** Enables default exporters, with sampling: always, and sensitive data filtering */
+    default?: {
+        enabled?: boolean;
+    };
+    /** Map of tracing instance names to their configurations or pre-instantiated instances */
+    configs?: Record<string, Omit<TracingConfig, 'name'> | AITracing>;
+    /** Optional selector function to choose which tracing instance to use */
+    configSelector?: ConfigSelector;
+}
+/**
+ * Sampling strategy types
+ */
+export declare enum SamplingStrategyType {
+    ALWAYS = "always",
+    NEVER = "never",
+    RATIO = "ratio",
+    CUSTOM = "custom"
+}
+/**
+ * Sampling strategy configuration
+ */
+export type SamplingStrategy = {
+    type: SamplingStrategyType.ALWAYS;
+} | {
+    type: SamplingStrategyType.NEVER;
+} | {
+    type: SamplingStrategyType.RATIO;
+    probability: number;
+} | {
+    type: SamplingStrategyType.CUSTOM;
+    sampler: (options?: CustomSamplerOptions) => boolean;
+};
+/**
+ * Options passed when using a custom sampler strategy
+ */
+export interface CustomSamplerOptions {
+    runtimeContext?: RuntimeContext;
+    metadata?: Record<string, any>;
+}
+/**
+ * AI Tracing event types
+ */
+export declare enum AITracingEventType {
+    SPAN_STARTED = "span_started",
+    SPAN_UPDATED = "span_updated",
+    SPAN_ENDED = "span_ended"
+}
+/**
+ * Tracing events that can be exported
+ */
+export type AITracingEvent = {
+    type: AITracingEventType.SPAN_STARTED;
+    exportedSpan: AnyExportedAISpan;
+} | {
+    type: AITracingEventType.SPAN_UPDATED;
+    exportedSpan: AnyExportedAISpan;
+} | {
+    type: AITracingEventType.SPAN_ENDED;
+    exportedSpan: AnyExportedAISpan;
+};
+/**
+ * Interface for tracing exporters
+ */
+export interface AITracingExporter {
+    /** Exporter name */
+    name: string;
+    /** Initialize exporter with tracing configuration */
+    init?(config: TracingConfig): void;
+    /** Set logger (called by AITracing during initialization) */
+    __setLogger?(logger: IMastraLogger): void;
+    /** Export tracing events */
+    exportEvent(event: AITracingEvent): Promise<void>;
+    addScoreToTrace?({ traceId, spanId, score, reason, scorerName, metadata, }: {
+        traceId: string;
+        spanId?: string;
+        score: number;
+        reason?: string;
+        scorerName: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /** Shutdown exporter */
+    shutdown(): Promise<void>;
+}
+/**
+ * Interface for span processors
+ */
+export interface AISpanProcessor {
+    /** Processor name */
+    name: string;
+    /** Process span before export */
+    process(span?: AnyAISpan): AnyAISpan | undefined;
+    /** Shutdown processor */
+    shutdown(): Promise<void>;
+}
+/**
+ *  Options passed when using a custom tracing config selector
+ */
+export interface ConfigSelectorOptions {
+    /** Runtime context */
+    runtimeContext?: RuntimeContext;
+}
+/**
+ * Function to select which AI tracing instance to use for a given span
+ * Returns the name of the tracing instance, or undefined to use default
+ */
+export type ConfigSelector = (options: ConfigSelectorOptions, availableConfigs: ReadonlyMap<string, AITracing>) => string | undefined;
+export type TracingStrategy = 'realtime' | 'batch-with-updates' | 'insert-only';
+export {};
+//# sourceMappingURL=types.d.ts.map