netra-sdk 1.0.6 → 1.1.0-beta

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Span, Context, TracerProvider } from '@opentelemetry/api';
+import { Span, Context, TracerProvider, Tracer, SpanContext } from '@opentelemetry/api';
 import { SpanProcessor, ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
 import { ExportResultCode, ExportResult } from '@opentelemetry/core';
 
@@ -18,11 +18,18 @@ interface NetraConfig {
     blockedSpans?: string[];
     instruments?: Set<NetraInstruments>;
     blockInstruments?: Set<NetraInstruments>;
+    rootInstruments?: Set<NetraInstruments>;
 }
 declare enum NetraInstruments {
+    /**
+     * Sentinel value: when included in `instruments` or `rootInstruments`,
+     * restores the legacy behaviour where every available instrumentation is
+     * enabled automatically (no curated default list is applied).
+     */
+    ALL = "__all__",
     OPENAI = "openai",
     GOOGLE_GENERATIVE_AI = "google_genai",
-    MISTRAL = "mistral",
+    MISTRAL = "mistral_ai",
     GROQ = "groq",
     VERTEX_AI = "vertexai",
     TOGETHER = "together",
@@ -30,24 +37,25 @@ declare enum NetraInstruments {
     LANGCHAIN = "langchain",
     LANGGRAPH = "langgraph",
     LLAMA_INDEX = "llama_index",
+    OPENAI_AGENTS = "openai_agents",
     PINECONE = "pinecone",
     QDRANT = "qdrant",
     CHROMADB = "chromadb",
     HTTP = "http",
-    HTTPS = "https",
-    FETCH = "fetch",
     PRISMA = "prisma",
     TYPEORM = "typeorm",
-    MONGODB = "mongodb",
-    POSTGRES = "postgres",
-    MYSQL = "mysql",
-    REDIS = "redis",
-    EXPRESS = "express",
-    FASTIFY = "fastify",
-    NESTJS = "nestjs",
-    KAFKA = "kafka",
-    RABBITMQ = "rabbitmq"
+    EXPRESS = "express"
 }
+/**
+ * Subset of DEFAULT_INSTRUMENTS allowed to produce root-level spans.
+ * Covers core LLM/AI providers and agent frameworks.
+ */
+declare const DEFAULT_INSTRUMENTS_FOR_ROOT: Set<NetraInstruments>;
+/**
+ * Full set of instrumentations installed by default. Includes the root
+ * defaults plus common vector DBs, HTTP clients, and database libraries.
+ */
+declare const DEFAULT_INSTRUMENTS: Set<NetraInstruments>;
 declare class Config {
     static readonly SDK_NAME = "netra";
     static readonly LIBRARY_NAME = "netra";
@@ -89,235 +97,190 @@ declare class Config {
 }
 
 /**
- * Dashboard API Models
+ * Usage API Models
  */
-declare enum Scope {
-    SPANS = "Spans",
-    TRACES = "Traces"
-}
-declare enum ChartType {
-    LINE_TIME_SERIES = "Line Time Series",
-    BAR_TIME_SERIES = "Bar Time Series",
-    HORIZONTAL_BAR = "Horizontal Bar",
-    VERTICAL_BAR = "Vertical Bar",
-    PIE = "Pie",
-    NUMBER = "Number"
+interface SessionUsageData {
+    sessionId: string;
+    tokenCount: number;
+    requestCount: number;
+    totalCost: number;
 }
-declare enum Measure {
-    LATENCY = "Latency",
-    ERROR_RATE = "Error Rate",
-    PII_COUNT = "PII Count",
-    REQUEST_COUNT = "Request Count",
-    TOTAL_COST = "Total Cost",
-    VIOLATIONS = "Violations",
-    TOTAL_TOKENS = "Total Tokens",
-    AUDIO_DURATION = "Audio Duration",
-    CHARACTER_COUNT = "Character Count"
+interface TenantUsageData {
+    tenantId: string;
+    organisationId: string;
+    tokenCount: number;
+    requestCount: number;
+    sessionCount: number;
+    totalCost: number;
 }
-declare enum Aggregation {
-    AVERAGE = "Average",
-    P50 = "p50",
-    P90 = "p90",
-    P95 = "p95",
-    P99 = "p99",
-    MEDIAN = "Median (p50)",
-    PERCENTAGE = "Percentage",
-    TOTAL_COUNT = "Total Count"
+interface TraceSummary {
+    id: string;
+    name: string;
+    kind: string;
+    latencyMs: number;
+    startTime: string;
+    endTime: string;
+    cursor: string;
+    organisationId: string;
+    projectId: string;
+    sessionId?: string;
+    tenantId?: string;
+    userId?: string;
+    environment?: string;
+    models?: string[];
+    promptTokens?: number;
+    completionTokens?: number;
+    cachedTokens?: number;
+    totalTokens?: number;
+    promptTokensCost?: number;
+    completionTokensCost?: number;
+    cachedTokensCost?: number;
+    totalCost?: number;
+    hasPii?: boolean;
+    piiEntities?: any[];
+    hasViolation?: boolean;
+    violations?: any[];
+    hasError?: boolean;
+    service?: string;
 }
-declare enum GroupBy {
-    DAY = "day",
-    HOUR = "hour",
-    MINUTE = "minute"
+interface TracesPage {
+    traces: TraceSummary[];
+    hasNextPage: boolean;
+    nextCursor?: string;
 }
-declare enum DimensionField {
-    ENVIRONMENT = "environment",
-    SERVICE = "service",
-    MODEL_NAME = "model_name"
+interface TraceSpan {
+    id: string;
+    traceId: string;
+    name: string;
+    kind: string;
+    parentSpanId?: string;
+    latencyMs?: number;
+    startTimeMs?: string;
+    endTimeMs?: string;
+    organisationId: string;
+    projectId: string;
+    sessionId?: string;
+    tenantId?: string;
+    userId?: string;
+    environment?: string;
+    modelName?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    cachedTokens?: number;
+    totalTokens?: number;
+    promptTokensCost?: number;
+    completionTokensCost?: number;
+    cachedTokensCost?: number;
+    totalCost?: number;
+    hasPii?: boolean;
+    piiEntities?: any[];
+    piiActions?: Record<string, any>;
+    hasViolation?: boolean;
+    violations?: any[];
+    violationActions?: Record<string, any>;
+    status?: string;
+    attributes?: string;
+    events?: string;
+    links?: string;
+    resources?: string;
+    metadata?: Record<string, any>;
+    hasError?: boolean;
+    createdAt: string;
+    cursor: string;
 }
-declare enum Operator {
-    EQUALS = "equals",
-    NOT_EQUALS = "not_equals",
-    CONTAINS = "contains",
-    NOT_CONTAINS = "not_contains",
-    STARTS_WITH = "starts_with",
-    ENDS_WITH = "ends_with",
-    GREATER_THAN = "greater_than",
-    LESS_THAN = "less_than",
-    GREATER_EQUAL_TO = "greater_equal_to",
-    LESS_EQUAL_TO = "less_equal_to",
-    ANY_OF = "any_of",
-    NONE_OF = "none_of"
+interface SpansPage {
+    spans: TraceSpan[];
+    hasNextPage: boolean;
+    nextCursor?: string;
 }
-declare enum FilterType {
-    STRING = "string",
-    NUMBER = "number",
-    BOOLEAN = "boolean",
-    ARRAY_OPTIONS = "arrayOptions",
-    OBJECT = "object"
+interface ListTracesParams {
+    startTime: string;
+    endTime: string;
+    traceId?: string;
+    sessionId?: string;
+    userId?: string;
+    tenantId?: string;
+    limit?: number;
+    cursor?: string;
+    direction?: "up" | "down";
+    sortField?: string;
+    sortOrder?: "asc" | "desc";
 }
-declare enum FilterField {
-    TOTAL_COST = "total_cost",
-    SERVICE = "service",
-    TENANT_ID = "tenant_id",
-    USER_ID = "user_id",
-    SESSION_ID = "session_id",
-    ENVIRONMENT = "environment",
-    LATENCY = "latency",
-    MODEL_NAME = "model_name",
-    MODELS = "models",
-    METADATA = "metadata"
+interface ListSpansParams {
+    traceId: string;
+    cursor?: string;
+    direction?: "up" | "down";
+    limit?: number;
+    spanName?: string;
 }
-declare enum SessionFilterField {
-    TENANT_ID = "tenant_id"
+
+/**
+ * Public Usage API
+ * Exposed as Netra.usage
+ */
+
+declare class Usage {
+    private config;
+    private client;
+    constructor(config: Config);
+    /**
+     * Get session usage data
+     * @param sessionId Session identifier
+     * @param startTime Start time for the usage data (in ISO 8601 UTC format)
+     * @param endTime End time for the usage data (in ISO 8601 UTC format)
+     * @returns Session usage data or null on error
+     */
+    getSessionUsage(sessionId: string, startTime: string, endTime: string): Promise<SessionUsageData | null>;
+    /**
+     * Get tenant usage data
+     * @param tenantId Tenant identifier
+     * @param startTime Start time for the usage data (in ISO 8601 UTC format)
+     * @param endTime End time for the usage data (in ISO 8601 UTC format)
+     * @returns Tenant usage data or null on error
+     */
+    getTenantUsage(tenantId: string, startTime: string, endTime: string): Promise<TenantUsageData | null>;
+    /**
+     * List all traces
+     * @param params List traces parameters
+     * @returns Traces page or null on error
+     */
+    listTraces(params: ListTracesParams): Promise<TracesPage | null>;
+    /**
+     * List all spans for a given trace
+     * @param params List spans parameters
+     * @returns Spans page or null on error
+     */
+    listSpansByTraceId(params: ListSpansParams): Promise<SpansPage | null>;
+    /**
+     * Iterate over traces using cursor-based pagination
+     * @param params List traces parameters
+     * @returns Async generator yielding TraceSummary items
+     */
+    iterTraces(params: ListTracesParams): AsyncGenerator<TraceSummary, void, unknown>;
+    /**
+     * Iterate over spans for a given trace using cursor-based pagination
+     * @param params List spans parameters
+     * @returns Async generator yielding TraceSpan items
+     */
+    iterSpansByTraceId(params: ListSpansParams): AsyncGenerator<TraceSpan, void, unknown>;
+    private mapToTraceSummary;
+    private mapToTraceSpan;
 }
-declare enum SessionOperator {
-    ANY_OF = "any_of"
+
+/**
+ * Evaluation API Models
+ */
+interface DatasetEntry {
+    id: string;
+    input: string;
+    datasetId: string;
+    expectedOutput?: any;
 }
-declare enum SessionFilterType {
-    ARRAY = "arrayOptions"
-}
-declare enum SortField {
-    SESSION_ID = "session_id",
-    START_TIME = "start_time",
-    TOTAL_REQUESTS = "totalRequests",
-    TOTAL_COST = "totalCost"
-}
-declare enum SortOrder {
-    ASC = "asc",
-    DESC = "desc"
-}
-/**
- * Create a metadata filter field
- * @param key The metadata key to filter on
- * @returns The formatted metadata field string
- * @example
- * metadataField("customer_tier") // returns "metadata['customer_tier']"
- */
-declare function metadataField(key: string): string;
-interface Filter {
-    field: FilterField | string;
-    operator: Operator;
-    type: FilterType;
-    value: any;
-    key?: string;
-}
-interface Metrics {
-    measure: Measure;
-    aggregation: Aggregation;
-}
-interface Dimension {
-    field: DimensionField;
-}
-interface FilterConfig {
-    startTime: string;
-    endTime: string;
-    groupBy: GroupBy;
-    filters?: Filter[];
-}
-interface TimeRange {
-    startTime: string;
-    endTime: string;
-}
-interface TimeSeriesDataPoint {
-    date: string;
-    value: number;
-}
-interface DimensionValue {
-    dimension: string;
-    value: number;
-}
-interface TimeSeriesWithDimension {
-    date: string;
-    values: DimensionValue[];
-}
-interface TimeSeriesResponse {
-    timeSeries: TimeSeriesWithDimension[];
-    dimensions: string[];
-}
-interface CategoricalDataPoint {
-    dimension: string;
-    value: number;
-}
-interface NumberResponse {
-    value: number;
-}
-type DashboardData = TimeSeriesDataPoint[] | TimeSeriesResponse | CategoricalDataPoint[] | NumberResponse | Record<string, any>;
-interface QueryResponse {
-    timeRange: TimeRange;
-    data: DashboardData;
-}
-interface QueryDataParams {
-    scope: Scope;
-    chartType: ChartType;
-    metrics: Metrics;
-    filter: FilterConfig;
-    dimension?: Dimension;
-}
-interface SessionFilter {
-    field: SessionFilterField;
-    operator: SessionOperator;
-    type: SessionFilterType;
-    value: string[];
-}
-interface SessionStatsResult {
-    data: SessionStatsData[];
-    hasNextPage: boolean;
-    nextCursor?: string;
-}
-interface SessionFilterConfig {
-    startTime: string;
-    endTime: string;
-    filters?: SessionFilter[];
-}
-interface SessionStatsData {
-    session_id: string;
-    session_start_time: string;
-    totalRequests: number;
-    totalCost: number;
-    session_duration: string;
-    cursor: string;
-}
-
-/**
- * Public Dashboard API
- * Exposed as Netra.dashboard
- */
-
-declare class Dashboard {
-    private config;
-    private client;
-    constructor(config: Config);
-    /**
-     * Execute a dynamic query for dashboards to retrieve metrics and time-series data
-     * @param params Query parameters
-     * @returns Query response containing timeRange and data, or null on error
-     */
-    queryData(params: QueryDataParams): Promise<QueryResponse | null>;
-    getSessionStats(startTime: string, endTime: string, limit?: number, filters?: SessionFilter[], cursor?: string, sortField?: SortField, sortOrder?: SortOrder): Promise<SessionStatsResult | null>;
-    iterSessionStats(startTime: string, endTime: string, filters?: SessionFilter[], sortField?: SortField, sortOrder?: SortOrder): AsyncGenerator<SessionStatsData, void, unknown>;
-    getSessionSummary(filter: SessionFilterConfig): Promise<any | null>;
-    private isValidScope;
-    private isValidChartType;
-    private isValidMetrics;
-    private isValidFilterConfig;
-    private isValidDimension;
-    private isSessionFilterConfig;
-}
-
-/**
- * Evaluation API Models
- */
-interface DatasetEntry {
-    id: string;
-    input: string;
-    datasetId: string;
-    expectedOutput?: any;
-}
-interface DatasetItem {
-    input: any;
-    expectedOutput?: any;
-    metadata?: Record<string, any>;
-    tags?: string[];
+interface DatasetItem {
+    input: any;
+    expectedOutput?: any;
+    metadata?: Record<string, any>;
+    tags?: string[];
 }
 interface DatasetRecord {
     id: string;
@@ -452,6 +415,12 @@ declare class Evaluation {
      * @returns runId: The id of the created run
      */
     createRun(name: string, datasetId?: string, evaluatorsConfig?: EvaluatorConfig[]): Promise<string | null>;
+    /**
+     * Fetch test run results based on run ID
+     * @param runId The id of the run to fetch
+     * @returns The run results data
+     */
+    getRunResults(runId: string): Promise<any>;
     /**
      * Netra evaluation function to initiate a test suite
      * @param name The name of the run
@@ -566,6 +535,12 @@ declare class EvaluationHttpClient extends NetraHttpClient {
      * Add a single item to an existing dataset
      */
     addDatasetItem(datasetId: string, itemPayload: Record<string, any>): Promise<any>;
+    /**
+     * Fetch test run results by run ID
+     * @param runId The id of the run to fetch
+     * @returns The run results data
+     */
+    getRunResults(runId: string): Promise<any>;
     /**
      * Submit a new run item to the backend
      */
@@ -631,320 +606,371 @@ declare class RunEntryContext {
 }
 
 /**
- * Usage API Models
+ * Dashboard API Models
  */
-interface SessionUsageData {
-    sessionId: string;
-    tokenCount: number;
-    requestCount: number;
-    totalCost: number;
+declare enum Scope {
+    SPANS = "Spans",
+    TRACES = "Traces"
 }
-interface TenantUsageData {
-    tenantId: string;
-    organisationId: string;
-    tokenCount: number;
-    requestCount: number;
-    sessionCount: number;
-    totalCost: number;
+declare enum ChartType {
+    LINE_TIME_SERIES = "Line Time Series",
+    BAR_TIME_SERIES = "Bar Time Series",
+    HORIZONTAL_BAR = "Horizontal Bar",
+    VERTICAL_BAR = "Vertical Bar",
+    PIE = "Pie",
+    NUMBER = "Number"
 }
-interface TraceSummary {
-    id: string;
-    name: string;
-    kind: string;
-    latencyMs: number;
-    startTime: string;
-    endTime: string;
-    cursor: string;
-    organisationId: string;
-    projectId: string;
-    sessionId?: string;
-    tenantId?: string;
-    userId?: string;
-    environment?: string;
-    models?: string[];
-    promptTokens?: number;
-    completionTokens?: number;
-    cachedTokens?: number;
-    totalTokens?: number;
-    promptTokensCost?: number;
-    completionTokensCost?: number;
-    cachedTokensCost?: number;
-    totalCost?: number;
-    hasPii?: boolean;
-    piiEntities?: any[];
-    hasViolation?: boolean;
-    violations?: any[];
-    hasError?: boolean;
-    service?: string;
+declare enum Measure {
+    LATENCY = "Latency",
+    ERROR_RATE = "Error Rate",
+    PII_COUNT = "PII Count",
+    REQUEST_COUNT = "Request Count",
+    TOTAL_COST = "Total Cost",
+    VIOLATIONS = "Violations",
+    TOTAL_TOKENS = "Total Tokens",
+    AUDIO_DURATION = "Audio Duration",
+    CHARACTER_COUNT = "Character Count"
 }
-interface TracesPage {
-    traces: TraceSummary[];
-    hasNextPage: boolean;
-    nextCursor?: string;
+declare enum Aggregation {
+    AVERAGE = "Average",
+    P50 = "p50",
+    P90 = "p90",
+    P95 = "p95",
+    P99 = "p99",
+    MEDIAN = "Median (p50)",
+    PERCENTAGE = "Percentage",
+    TOTAL_COUNT = "Total Count"
 }
-interface TraceSpan {
-    id: string;
-    traceId: string;
-    name: string;
-    kind: string;
-    parentSpanId?: string;
-    latencyMs?: number;
-    startTimeMs?: string;
-    endTimeMs?: string;
-    organisationId: string;
-    projectId: string;
-    sessionId?: string;
-    tenantId?: string;
-    userId?: string;
-    environment?: string;
-    modelName?: string;
-    promptTokens?: number;
-    completionTokens?: number;
-    cachedTokens?: number;
-    totalTokens?: number;
-    promptTokensCost?: number;
-    completionTokensCost?: number;
-    cachedTokensCost?: number;
-    totalCost?: number;
-    hasPii?: boolean;
-    piiEntities?: any[];
-    piiActions?: Record<string, any>;
-    hasViolation?: boolean;
-    violations?: any[];
-    violationActions?: Record<string, any>;
-    status?: string;
-    attributes?: string;
-    events?: string;
-    links?: string;
-    resources?: string;
-    metadata?: Record<string, any>;
-    hasError?: boolean;
-    createdAt: string;
-    cursor: string;
+declare enum GroupBy {
+    DAY = "day",
+    HOUR = "hour",
+    MINUTE = "minute"
 }
-interface SpansPage {
-    spans: TraceSpan[];
+declare enum DimensionField {
+    ENVIRONMENT = "environment",
+    SERVICE = "service",
+    MODEL_NAME = "model_name"
+}
+declare enum Operator {
+    EQUALS = "equals",
+    NOT_EQUALS = "not_equals",
+    CONTAINS = "contains",
+    NOT_CONTAINS = "not_contains",
+    STARTS_WITH = "starts_with",
+    ENDS_WITH = "ends_with",
+    GREATER_THAN = "greater_than",
+    LESS_THAN = "less_than",
+    GREATER_EQUAL_TO = "greater_equal_to",
+    LESS_EQUAL_TO = "less_equal_to",
+    ANY_OF = "any_of",
+    NONE_OF = "none_of"
+}
+declare enum FilterType {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    ARRAY_OPTIONS = "arrayOptions",
+    OBJECT = "object"
+}
+declare enum FilterField {
+    TOTAL_COST = "total_cost",
+    SERVICE = "service",
+    TENANT_ID = "tenant_id",
+    USER_ID = "user_id",
+    SESSION_ID = "session_id",
+    ENVIRONMENT = "environment",
+    LATENCY = "latency",
+    MODEL_NAME = "model_name",
+    MODELS = "models",
+    METADATA = "metadata"
+}
+declare enum SessionFilterField {
+    TENANT_ID = "tenant_id"
+}
+declare enum SessionOperator {
+    ANY_OF = "any_of"
+}
+declare enum SessionFilterType {
+    ARRAY = "arrayOptions"
+}
+declare enum SortField {
+    SESSION_ID = "session_id",
+    START_TIME = "start_time",
+    TOTAL_REQUESTS = "totalRequests",
+    TOTAL_COST = "totalCost"
+}
+declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+/**
+ * Create a metadata filter field
+ * @param key The metadata key to filter on
+ * @returns The formatted metadata field string
+ * @example
+ * metadataField("customer_tier") // returns "metadata['customer_tier']"
+ */
+declare function metadataField(key: string): string;
+interface Filter {
+    field: FilterField | string;
+    operator: Operator;
+    type: FilterType;
+    value: any;
+    key?: string;
+}
+interface Metrics {
+    measure: Measure;
+    aggregation: Aggregation;
+}
+interface Dimension {
+    field: DimensionField;
+}
+interface FilterConfig {
+    startTime: string;
+    endTime: string;
+    groupBy: GroupBy;
+    filters?: Filter[];
+}
+interface TimeRange {
+    startTime: string;
+    endTime: string;
+}
+interface TimeSeriesDataPoint {
+    date: string;
+    value: number;
+}
+interface DimensionValue {
+    dimension: string;
+    value: number;
+}
+interface TimeSeriesWithDimension {
+    date: string;
+    values: DimensionValue[];
+}
+interface TimeSeriesResponse {
+    timeSeries: TimeSeriesWithDimension[];
+    dimensions: string[];
+}
+interface CategoricalDataPoint {
+    dimension: string;
+    value: number;
+}
+interface NumberResponse {
+    value: number;
+}
+type DashboardData = TimeSeriesDataPoint[] | TimeSeriesResponse | CategoricalDataPoint[] | NumberResponse | Record<string, any>;
+interface QueryResponse {
+    timeRange: TimeRange;
+    data: DashboardData;
+}
+interface QueryDataParams {
+    scope: Scope;
+    chartType: ChartType;
+    metrics: Metrics;
+    filter: FilterConfig;
+    dimension?: Dimension;
+}
+interface SessionFilter {
+    field: SessionFilterField;
+    operator: SessionOperator;
+    type: SessionFilterType;
+    value: string[];
+}
+interface SessionStatsResult {
+    data: SessionStatsData[];
     hasNextPage: boolean;
     nextCursor?: string;
 }
-interface ListTracesParams {
+interface SessionFilterConfig {
     startTime: string;
     endTime: string;
-    traceId?: string;
-    sessionId?: string;
-    userId?: string;
-    tenantId?: string;
-    limit?: number;
-    cursor?: string;
-    direction?: "up" | "down";
-    sortField?: string;
-    sortOrder?: "asc" | "desc";
+    filters?: SessionFilter[];
 }
-interface ListSpansParams {
-    traceId: string;
-    cursor?: string;
-    direction?: "up" | "down";
-    limit?: number;
-    spanName?: string;
+interface SessionStatsData {
+    session_id: string;
+    session_start_time: string;
+    totalRequests: number;
+    totalCost: number;
+    session_duration: string;
+    cursor: string;
 }
 
 /**
- * Public Usage API
- * Exposed as Netra.usage
+ * Public Dashboard API
+ * Exposed as Netra.dashboard
  */
 
-declare class Usage {
+declare class Dashboard {
     private config;
     private client;
     constructor(config: Config);
     /**
-     * Get session usage data
-     * @param sessionId Session identifier
-     * @param startTime Start time for the usage data (in ISO 8601 UTC format)
-     * @param endTime End time for the usage data (in ISO 8601 UTC format)
-     * @returns Session usage data or null on error
+     * Execute a dynamic query for dashboards to retrieve metrics and time-series data
+     * @param params Query parameters
+     * @returns Query response containing timeRange and data, or null on error
      */
-    getSessionUsage(sessionId: string, startTime: string, endTime: string): Promise<SessionUsageData | null>;
+    queryData(params: QueryDataParams): Promise<QueryResponse | null>;
+    getSessionStats(startTime: string, endTime: string, limit?: number, filters?: SessionFilter[], cursor?: string, sortField?: SortField, sortOrder?: SortOrder): Promise<SessionStatsResult | null>;
+    iterSessionStats(startTime: string, endTime: string, filters?: SessionFilter[], sortField?: SortField, sortOrder?: SortOrder): AsyncGenerator<SessionStatsData, void, unknown>;
+    getSessionSummary(filter: SessionFilterConfig): Promise<any | null>;
+    private isValidScope;
+    private isValidChartType;
+    private isValidMetrics;
+    private isValidFilterConfig;
+    private isValidDimension;
+    private isSessionFilterConfig;
+}
+
+/**
+ * Prompts API Models
+ */
+interface GetPromptParams {
+    name: string;
+    label?: string;
+}
+/**
+ * Prompt response is intentionally flexible because
+ * backend prompt structures may evolve (variables, templates, metadata etc.)
+ */
+type PromptResponse = Record<string, any>;
+
+declare class Prompts {
+    private config;
+    private client;
+    constructor(config: Config);
     /**
-     * Get tenant usage data
-     * @param tenantId Tenant identifier
-     * @param startTime Start time for the usage data (in ISO 8601 UTC format)
-     * @param endTime End time for the usage data (in ISO 8601 UTC format)
-     * @returns Tenant usage data or null on error
+     * Fetch prompt version by name and label.
+     *
+     * @param params.name  - Name of the prompt (required)
+     * @param params.label - Label of the prompt version (default: "production")
      */
-    getTenantUsage(tenantId: string, startTime: string, endTime: string): Promise<TenantUsageData | null>;
+    getPrompt(params: GetPromptParams): Promise<PromptResponse | null>;
+}
+
+/**
+ * Instrumentation Span Processor
+ *
+ * OpenTelemetry span processor that:
+ * 1. Records the raw instrumentation scope name for each span
+ * 2. Truncates attribute values to prevent oversized payloads
+ */
+
+declare class InstrumentationSpanProcessor implements SpanProcessor {
+    private maxAttributeLength;
+    constructor(maxAttributeLength?: number);
     /**
-     * List all traces
-     * @param params List traces parameters
-     * @returns Traces page or null on error
+     * Detect the raw instrumentation name from the span's instrumentation scope.
      */
-    listTraces(params: ListTracesParams): Promise<TracesPage | null>;
+    private detectRawInstrumentationName;
     /**
-     * List all spans for a given trace
-     * @param params List spans parameters
-     * @returns Spans page or null on error
+     * Truncate a value to the maximum allowed length.
+     * Handles strings, bytes, and recursively handles lists and objects.
      */
-    listSpansByTraceId(params: ListSpansParams): Promise<SpansPage | null>;
+    private truncateValue;
     /**
-     * Iterate over traces using cursor-based pagination
-     * @param params List traces parameters
-     * @returns Async generator yielding TraceSummary items
+     * Called when a span starts. Wraps setAttribute to truncate values
+     * and records the instrumentation name.
      */
-    iterTraces(params: ListTracesParams): AsyncGenerator<TraceSummary, void, unknown>;
+    onStart(span: Span, parentContext: Context): void;
     /**
-     * Iterate over spans for a given trace using cursor-based pagination
-     * @param params List spans parameters
-     * @returns Async generator yielding TraceSpan items
+     * Called when a span ends. No-op for this processor.
      */
-    iterSpansByTraceId(params: ListSpansParams): AsyncGenerator<TraceSpan, void, unknown>;
-    private mapToTraceSummary;
-    private mapToTraceSpan;
+    onEnd(span: ReadableSpan): void;
+    /**
+     * Shuts down the processor.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Forces a flush of any pending spans.
+     */
+    forceFlush(): Promise<void>;
 }
 
-declare function withBlockedSpansLocal<T>(patterns: readonly string[], fn: () => Promise<T> | T): Promise<T>;
+declare function withBlockedSpansLocal<T>(patterns: readonly string[], fn: () => Promise<T>): Promise<T>;
+declare function withBlockedSpansLocal<T>(patterns: readonly string[], fn: () => T): T;
 
 /**
- * Session Manager for tracking user sessions and context
+ * Scrubbing Span Processor
  *
- * Uses AsyncLocalStorage for entity stacks (workflow, task, agent)
- * and OpenTelemetry's baggage API for session context (session_id, user_id, tenant_id).
- * This provides proper concurrency support for multi-request environments.
- */
-
-declare enum ConversationType {
-    INPUT = "input",
-    OUTPUT = "output"
-}
-
-/**
- * Represents a single item in a simulation run.
- */
-interface SimulationItem {
-    runItemId: string;
-    message: string;
-    turnId: string;
-}
-/**
- * Response from the conversation trigger API.
- */
-interface ConversationResponse {
-    decision: string;
-    reason?: string;
-    nextTurnId?: string;
-    nextUserMessage?: string;
-    nextRunItemId?: string;
-}
-/**
- * Result returned from the user's task function.
- */
-interface TaskResult {
-    message: string;
-    sessionId: string;
-}
-/**
- * Result of a single conversation execution.
- */
-interface ConversationResult {
-    runItemId: string;
-    success: boolean;
-    error?: string;
-    finalTurnId?: string;
-    turnId?: string;
-}
-/**
- * Overall simulation run result.
+ * OpenTelemetry span processor that scrubs sensitive data from span attributes.
+ * This includes API keys, emails, phone numbers, SSNs, credit cards, passwords,
+ * bearer tokens, and other sensitive information.
  */
-interface SimulationResult {
-    success: boolean;
-    completed: ConversationResult[];
-    failed: ConversationResult[];
-    totalItems: number;
-}
 
-declare abstract class BaseTask {
+declare class ScrubbingSpanProcessor implements SpanProcessor {
     /**
-     * @param message - The input message from the simulation.
-     * @param sessionId - The Session identifier.
-     * @returns The task result containing:
-     *            - message (string): The response message from the task.
-     *            - sessionId (string): The session identifier.
+     * Check if a key is considered sensitive.
      */
-    abstract run(message: string, sessionId?: string | null): Promise<TaskResult> | TaskResult;
+    private isSensitiveKey;
+    /**
+     * Scrub sensitive patterns from a string value.
+     */
+    private scrubStringValue;
+    /**
+     * Recursively scrub sensitive data from a dictionary value.
+     */
+    private scrubDictValue;
+    /**
+     * Recursively scrub sensitive data from a list value.
+     */
+    private scrubListValue;
+    /**
+     * Scrub sensitive data from a key-value pair.
+     */
+    private scrubKeyValue;
+    /**
+     * Called when a span starts. No-op for this processor.
+     */
+    onStart(span: Span, parentContext: Context): void;
+    /**
+     * Called when a span ends. Scrubs sensitive data from span attributes.
+     */
+    onEnd(span: ReadableSpan): void;
+    /**
+     * Shuts down the processor.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Forces a flush of any pending spans.
+     */
+    forceFlush(): Promise<void>;
 }
 
 /**
- * Public API for running multi-turn conversation simulations.
+ * Session Span Processor
+ *
+ * OpenTelemetry span processor that automatically adds session attributes to spans.
+ * This includes session_id, user_id, tenant_id from OpenTelemetry baggage, and entity context
+ * (workflow, task, agent names) from SessionManager.
+ *
+ * Uses OpenTelemetry's baggage API for automatic context propagation across async boundaries.
  */
 
-interface SimulationOptions {
-    name: string;
-    datasetId: string;
-    task: BaseTask;
-    context?: Record<string, any>;
-    maxConcurrency?: number;
-}
-/**
- * Public API for running multi-turn conversation simulations.
- */
-declare class Simulation {
-    private _config;
-    private _client;
-    constructor(config: Config);
+declare class SessionSpanProcessor implements SpanProcessor {
     /**
-     * Run a multi-turn conversation simulation.
-     *
-     * @param options - Simulation configuration options
-     * @returns Dictionary with simulation results, or null on failure
+     * Called when a span starts. Adds session and entity context attributes.
      */
-    runSimulation(options: SimulationOptions): Promise<SimulationResult | null>;
+    onStart(span: Span, parentContext: Context): void;
     /**
-     * Async implementation of run_simulation with concurrency control.
+     * Called when a span ends. No-op for this processor.
      */
-    private _runSimulationAsync;
+    onEnd(_span: ReadableSpan): void;
     /**
-     * Execute a multi-turn conversation for a single simulation item.
+     * Shuts down the processor.
      */
-    private _executeConversation;
-}
-
-/**
- * Result from creating a simulation run.
- */
-interface CreateRunResult {
-    runId: string;
-    simulationItems: SimulationItem[];
+    shutdown(): Promise<void>;
+    /**
+     * Forces a flush of any pending spans.
+     */
+    forceFlush(): Promise<void>;
 }
 
-/**
- * Type definitions for Netra SDK
- */
-declare enum SpanType {
-    SPAN = "SPAN",
-    GENERATION = "GENERATION",
-    TOOL = "TOOL",
-    EMBEDDING = "EMBEDDING",
-    AGENT = "AGENT"
-}
-interface UsageModel {
-    model: string;
-    usage_type: string;
-    units_used?: number;
-    cost_in_usd?: number;
-}
-interface ActionModel {
-    start_time: string;
-    action: string;
-    action_type: string;
-    success: boolean;
-    affected_records?: Array<{
-        record_id: string;
-        record_type: string;
-    }>;
-    metadata?: Record<string, string>;
-}
-interface DecoratorOptions {
-    name?: string;
-    asType?: SpanType;
+declare class SpanIOProcessor implements SpanProcessor {
+    onStart(span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    private _wrapSetAttribute;
 }
 
 /**
@@ -962,19 +988,18 @@ declare class SpanWrapper {
     private span?;
     private activeContext?;
     private tracer?;
-    constructor(name: string, attributes?: Record<string, string>, moduleName?: string, asType?: SpanType, tracer?: any);
+    private blockedSpanPatterns?;
+    constructor(name: string, attributes?: SpanAttributes, moduleName?: string, asType?: SpanType, tracer?: any, blockedSpanPatterns?: string[]);
     start(): this;
     end(): this;
-    setAttribute(key: string, value: string): this;
+    setAttribute(key: string, value: string | string[] | boolean): this;
     /**
      * Run a function with this span set as the active span in the OTel context.
-     * Useful for nesting spans.
+     * Child spans created inside `fn` will have this span as their parent and will
+     * also inherit any blocking baggage set via `blockedSpans`. Works for both
+     * sync and async functions — context.with() passes through the return value as-is.
      */
     withActive<T>(fn: () => T): T;
-    /**
-     * Async version of withActive(). Keeps the context active across async work.
-     */
-    withActiveAsync<T>(fn: () => Promise<T>): Promise<T>;
     setPrompt(prompt: string): this;
     setNegativePrompt(negativePrompt: string): this;
     setUsage(usage: UsageModel[]): this;
@@ -985,162 +1010,177 @@ declare class SpanWrapper {
     setSuccess(): this;
     addEvent(name: string, attributes?: Record<string, string>): this;
     getCurrentSpan(): Span | undefined;
+    private decodeBaggagePatterns;
+}
+
+/**
+ * Type definitions for Netra SDK
+ */
+
+declare enum SpanType {
+    SPAN = "SPAN",
+    GENERATION = "GENERATION",
+    TOOL = "TOOL",
+    EMBEDDING = "EMBEDDING",
+    AGENT = "AGENT",
+    HANDOFF = "HANDOFF",
+    GUARDRAIL = "GUARDRAIL"
+}
+declare enum ConversationType {
+    INPUT = "input",
+    OUTPUT = "output"
+}
+interface UsageModel {
+    model: string;
+    usage_type: string;
+    units_used?: number;
+    cost_in_usd?: number;
+}
+interface ActionModel {
+    start_time: string;
+    action: string;
+    action_type: string;
+    success: boolean;
+    affected_records?: Array<{
+        record_id: string;
+        record_type: string;
+    }>;
+    metadata?: Record<string, string>;
+}
+type SpanAttributes = Record<string, string | string[] | boolean>;
+interface SpanOptions {
+    attributes?: SpanAttributes;
+    moduleName?: string;
+    asType?: SpanType;
+    /** Patterns for blocking descendant spans (e.g. ["http.*", "*.resolve"]) */
+    blockedSpans?: string[];
+}
+interface DecoratorOptions {
+    name?: string;
+    asType?: SpanType;
 }
+type SpanCallback<T> = (span: SpanWrapper) => T;
 
 /**
- * Prompts API Models
+ * Represents a single item in a simulation run.
  */
-interface GetPromptParams {
-    name: string;
-    label?: string;
+interface SimulationItem {
+    runItemId: string;
+    message: string;
+    turnId: string;
 }
 /**
- * Prompt response is intentionally flexible because
- * backend prompt structures may evolve (variables, templates, metadata etc.)
+ * Response from the conversation trigger API.
  */
-type PromptResponse = Record<string, any>;
+interface ConversationResponse {
+    decision: string;
+    reason?: string;
+    nextTurnId?: string;
+    nextUserMessage?: string;
+    nextRunItemId?: string;
+}
+/**
+ * Result returned from the user's task function.
+ */
+interface TaskResult {
+    message: string;
+    sessionId: string;
+}
+/**
+ * Result of a single conversation execution.
+ */
+interface ConversationResult {
+    runItemId: string;
+    success: boolean;
+    error?: string;
+    finalTurnId?: string;
+    turnId?: string;
+}
+/**
+ * Overall simulation run result.
+ */
+interface SimulationResult {
+    success: boolean;
+    completed: ConversationResult[];
+    failed: ConversationResult[];
+    totalItems: number;
+}
 
-declare class Prompts {
-    private config;
-    private client;
-    constructor(config: Config);
+declare abstract class BaseTask {
     /**
-     * Fetch prompt version by name and label.
-     *
-     * @param params.name  - Name of the prompt (required)
-     * @param params.label - Label of the prompt version (default: "production")
+     * @param message - The input message from the simulation.
+     * @param sessionId - The Session identifier.
+     * @returns The task result containing:
+     *            - message (string): The response message from the task.
+     *            - sessionId (string): The session identifier.
      */
-    getPrompt(params: GetPromptParams): Promise<PromptResponse | null>;
+    abstract run(message: string, sessionId?: string | null): Promise<TaskResult> | TaskResult;
 }
 
 /**
- * Decorators for easy instrumentation
+ * Public API for running multi-turn conversation simulations.
  */
 
-type AnyFunction = (...args: any[]) => any;
-declare function workflow<T extends AnyFunction>(target: T, options?: DecoratorOptions): T;
-declare function workflow<T extends AnyFunction>(options?: DecoratorOptions): (target: T) => T;
-declare function agent<T extends AnyFunction>(target: T, options?: DecoratorOptions): T;
-declare function agent<T extends AnyFunction>(options?: DecoratorOptions): (target: T) => T;
-declare function task<T extends AnyFunction>(target: T, options?: DecoratorOptions): T;
-declare function task<T extends AnyFunction>(options?: DecoratorOptions): (target: T) => T;
-declare function span<T extends AnyFunction>(target: T, options?: DecoratorOptions): T;
-declare function span<T extends AnyFunction>(options?: DecoratorOptions): (target: T) => T;
-
+interface SimulationOptions {
+    name: string;
+    datasetId: string;
+    task: BaseTask;
+    context?: Record<string, any>;
+    maxConcurrency?: number;
+}
 /**
- * Session Span Processor
- *
- * OpenTelemetry span processor that automatically adds session attributes to spans.
- * This includes session_id, user_id, tenant_id from OpenTelemetry baggage, and entity context
- * (workflow, task, agent names) from SessionManager.
- *
- * Uses OpenTelemetry's baggage API for automatic context propagation across async boundaries.
+ * Public API for running multi-turn conversation simulations.
  */
-
-declare class SessionSpanProcessor implements SpanProcessor {
-    /**
-     * Called when a span starts. Adds session and entity context attributes.
-     */
-    onStart(span: Span, parentContext: Context): void;
+declare class Simulation {
+    private _config;
+    private _client;
+    constructor(config: Config);
     /**
-     * Called when a span ends. No-op for this processor.
+     * Run a multi-turn conversation simulation.
+     *
+     * @param options - Simulation configuration options
+     * @returns Dictionary with simulation results, or null on failure
      */
-    onEnd(span: ReadableSpan): void;
+    runSimulation(options: SimulationOptions): Promise<SimulationResult | null>;
     /**
-     * Shuts down the processor.
+     * Async implementation of run_simulation with concurrency control.
      */
-    shutdown(): Promise<void>;
+    private _runSimulationAsync;
     /**
-     * Forces a flush of any pending spans.
+     * Execute a multi-turn conversation for a single simulation item.
      */
-    forceFlush(): Promise<void>;
+    private _executeConversation;
 }
 
 /**
- * Instrumentation Span Processor
- *
- * OpenTelemetry span processor that:
- * 1. Records the raw instrumentation scope name for each span
- * 2. Truncates attribute values to prevent oversized payloads
+ * Result from creating a simulation run.
  */
-
-declare class InstrumentationSpanProcessor implements SpanProcessor {
-    private maxAttributeLength;
-    constructor(maxAttributeLength?: number);
-    /**
-     * Detect the raw instrumentation name from the span's instrumentation scope.
-     */
-    private detectRawInstrumentationName;
-    /**
-     * Truncate a value to the maximum allowed length.
-     * Handles strings, bytes, and recursively handles lists and objects.
-     */
-    private truncateValue;
-    /**
-     * Called when a span starts. Wraps setAttribute to truncate values
-     * and records the instrumentation name.
-     */
-    onStart(span: Span, parentContext: Context): void;
-    /**
-     * Called when a span ends. No-op for this processor.
-     */
-    onEnd(span: ReadableSpan): void;
-    /**
-     * Shuts down the processor.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Forces a flush of any pending spans.
-     */
-    forceFlush(): Promise<void>;
+interface CreateRunResult {
+    runId: string;
+    simulationItems: SimulationItem[];
 }
 
 /**
- * Scrubbing Span Processor
- *
- * OpenTelemetry span processor that scrubs sensitive data from span attributes.
- * This includes API keys, emails, phone numbers, SSNs, credit cards, passwords,
- * bearer tokens, and other sensitive information.
+ * Decorators for easy instrumentation
  */
 
-declare class ScrubbingSpanProcessor implements SpanProcessor {
-    /**
-     * Check if a key is considered sensitive.
-     */
-    private isSensitiveKey;
-    /**
-     * Scrub sensitive patterns from a string value.
-     */
-    private scrubStringValue;
-    /**
-     * Recursively scrub sensitive data from a dictionary value.
-     */
-    private scrubDictValue;
-    /**
-     * Recursively scrub sensitive data from a list value.
-     */
-    private scrubListValue;
-    /**
-     * Scrub sensitive data from a key-value pair.
-     */
-    private scrubKeyValue;
-    /**
-     * Called when a span starts. No-op for this processor.
-     */
-    onStart(span: Span, parentContext: Context): void;
-    /**
-     * Called when a span ends. Scrubs sensitive data from span attributes.
-     */
-    onEnd(span: ReadableSpan): void;
-    /**
-     * Shuts down the processor.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Forces a flush of any pending spans.
-     */
-    forceFlush(): Promise<void>;
-}
+type AnyFunction = (...args: any[]) => any;
+type AnyClass = new (...args: any[]) => any;
+type ClassDecoratorFn = (target: AnyClass) => void;
+type MethodDecoratorFn = (target: any, key: string | symbol, descriptor: PropertyDescriptor) => void;
+type UnifiedDecorator = ClassDecoratorFn & MethodDecoratorFn;
+declare function workflow(target: AnyClass): void;
+declare function workflow<T extends AnyFunction>(target: T): T;
+declare function workflow(options?: DecoratorOptions): UnifiedDecorator;
+declare function agent(target: AnyClass): void;
+declare function agent<T extends AnyFunction>(target: T): T;
+declare function agent(options?: DecoratorOptions): UnifiedDecorator;
+declare function task(target: AnyClass): void;
+declare function task<T extends AnyFunction>(target: T): T;
+declare function task(options?: DecoratorOptions): UnifiedDecorator;
+declare function span(target: AnyClass): void;
+declare function span<T extends AnyFunction>(target: T): T;
+declare function span(options?: DecoratorOptions): UnifiedDecorator;
 
 /**
  * Custom MistralAI instrumentor for Netra SDK
@@ -1149,7 +1189,7 @@ declare class ScrubbingSpanProcessor implements SpanProcessor {
  * to ensure we patch the same module instance the application uses.
  */
 
-interface InstrumentorOptions {
+interface InstrumentorOptions$1 {
     tracerProvider?: TracerProvider;
 }
 /**
@@ -1169,12 +1209,12 @@ declare class NetraMistralAIInstrumentor {
      * Uses dynamic import() to ensure we get the same ES module instance
      * that the application uses.
      */
-    instrumentAsync(options?: InstrumentorOptions): Promise<NetraMistralAIInstrumentor>;
+    instrumentAsync(options?: InstrumentorOptions$1): Promise<NetraMistralAIInstrumentor>;
     /**
      * Instrument MistralAI client methods (sync version - for backwards compatibility)
      * Note: This uses a cached Mistral class. Call instrumentAsync() for proper initialization.
      */
-    instrument(options?: InstrumentorOptions): NetraMistralAIInstrumentor;
+    instrument(options?: InstrumentorOptions$1): NetraMistralAIInstrumentor;
     /**
      * Uninstrument MistralAI client methods
      */
@@ -1203,21 +1243,135 @@ declare class NetraMistralAIInstrumentor {
 }
 declare const mistralAIInstrumentor: NetraMistralAIInstrumentor;
 
+interface AgentTrace {
+    traceId: string;
+    name: string;
+    groupId?: string;
+    metadata?: Record<string, unknown>;
+    disabled?: boolean;
+}
+interface AgentSpan {
+    spanId: string;
+    traceId: string;
+    parentId?: string | null;
+    startedAt?: string | null;
+    endedAt?: string | null;
+    spanData: SpanData;
+    error?: {
+        message: string;
+        data?: Record<string, unknown>;
+    } | null;
+}
+interface SpanData {
+    type: string;
+    name?: string;
+    input?: unknown;
+    output?: unknown;
+    model?: string;
+    model_config?: Record<string, unknown>;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        details?: Record<string, unknown> | null;
+    };
+    to_agent?: string;
+    from_agent?: string;
+    response_id?: string;
+    _input?: unknown;
+    _response?: unknown;
+    triggered?: boolean;
+    mcp_data?: string;
+    handoffs?: string[];
+    tools?: string[];
+    output_type?: string;
+    data?: Record<string, unknown>;
+    server?: string;
+    result?: string[];
+}
+interface TracingProcessor {
+    start?(): void;
+    onTraceStart(trace: AgentTrace): Promise<void> | void;
+    onTraceEnd(trace: AgentTrace): Promise<void> | void;
+    onSpanStart(span: AgentSpan): Promise<void> | void;
+    onSpanEnd(span: AgentSpan): Promise<void> | void;
+    forceFlush(): Promise<void> | void;
+    shutdown(timeout?: number): Promise<void> | void;
+}
+interface InstrumentorOptions {
+    tracerProvider?: {
+        getTracer(name: string, version?: string): any;
+    };
+    /** Override the `llm.system` attribute value (default: `"openai"`). */
+    systemName?: string;
+}
+
+declare class NetraAgentsTracingProcessor implements TracingProcessor {
+    private static readonly MAX_TRACKED_SPANS;
+    private static readonly MAX_TRACKED_TRACES;
+    private _tracer;
+    private _systemName;
+    private _isShutdown;
+    private _rootSpans;
+    private _otelSpans;
+    private _handoffs;
+    private _traceErrors;
+    private _traceSpans;
+    constructor(tracer: Tracer, systemName?: string);
+    private _parseTimestamp;
+    private _evictOldestSpan;
+    private _evictOldestTrace;
+    onTraceStart(agentTrace: AgentTrace): void;
+    onTraceEnd(agentTrace: AgentTrace): void;
+    onSpanStart(agentSpan: AgentSpan): void;
+    onSpanEnd(agentSpan: AgentSpan): void;
+    forceFlush(): void;
+    shutdown(): void;
+}
+
+declare class NetraOpenAIAgentsInstrumentor {
+    isInstrumented(): boolean;
+    /**
+     * Register the Netra tracing processor with the OpenAI Agents SDK.
+     *
+     * Returns `this` in all cases (success **and** failure) so the call can be
+     * chained. Check {@link isInstrumented} afterwards to verify the processor
+     * was registered successfully.
+     */
+    instrument(options?: InstrumentorOptions): Promise<NetraOpenAIAgentsInstrumentor>;
+    uninstrument(): void;
+}
+declare const openaiAgentsInstrumentor: NetraOpenAIAgentsInstrumentor;
+
 declare class FilteringSpanExporter implements SpanExporter {
     private readonly exporter;
-    private exact;
-    private prefixes;
-    private suffixes;
-    private rememberedBlockedParentMap;
-    constructor(exporter: SpanExporter, patterns: string[]);
+    private readonly localBlockedMap?;
+    private static readonly MAX_REMEMBERED_ENTRIES;
+    /** Pre-compiled global patterns — compiled once in the constructor. */
+    private readonly compiled;
+    /**
+     * Spans that were blocked in a previous export() call but whose children
+     * may still arrive in a later call (e.g. out-of-order export batches).
+     */
+    private readonly rememberedBlockedParentMap;
+    /** Cache for compiled local pattern sets to avoid per-span recompilation. */
+    private readonly localPatternCache;
+    private static readonly MAX_LOCAL_PATTERN_CACHE;
+    constructor(exporter: SpanExporter, globalPatterns: string[], localBlockedMap?: ReadonlyMap<string, SpanContext | undefined> | undefined);
     export(spans: ReadableSpan[], resultCallback: (result: {
         code: ExportResultCode;
     }) => void): void;
     shutdown(): Promise<void>;
     forceFlush(): Promise<void>;
-    private isBlocked;
-    private matchesLocalPatterns;
+    private getCompiledLocalPatterns;
+    private evictRememberedIfNeeded;
+    private getLocalPatterns;
     private hasLocalBlockFlag;
+    /**
+     * Walk up the blocked-parent chain for each surviving span and wrap it
+     * with a ReparentedSpan pointing to the nearest non-blocked ancestor.
+     *
+     * A cycle guard (visited set) prevents infinite loops in malformed traces.
+     */
     private reparentBlockedChildren;
 }
 
@@ -1243,107 +1397,32 @@ declare class TrialAwareOTLPExporter implements SpanExporter {
  */
 
 declare class Netra {
+    private static _SDK_NAME;
     private static _initialized;
     private static _config;
     private static _tracer;
-    /**
-     * Usage API client for usage and traces
-     * Available after calling Netra.init()
-     */
+    private static _rootSpan;
+    private static _metricsEnabled;
     static usage: Usage;
-    /**
-     * Evaluation API client for datasets, runs, and test suites
-     * Available after calling Netra.init()
-     */
     static evaluation: Evaluation;
-    /**
-     * Dashboard API client for querying metrics and time-series data
-     * Available after calling Netra.init()
-     */
     static dashboard: Dashboard;
     static simulation: Simulation;
-    /**
-     * Prompts API client for prompt versioning
-     * Available after calling Netra.init()
-     */
     static prompts: Prompts;
-    /**
-     * Get the current Netra configuration
-     */
     static getConfig(): Config;
-    /**
-     * Check if Netra has been initialized
-     */
     static isInitialized(): boolean;
-    /**
-     * Initialize the Netra SDK
-     *
-     * This method is async and must be awaited to ensure all instrumentations
-     * are ready before your application starts using instrumented modules.
-     *
-     * @example
-     * await Netra.init({ appName: 'my-app', instruments: new Set([NetraInstruments.OPENAI]) });
-     * // Now all instrumentations are ready
-     * const openai = new OpenAI();
-     */
     static init(config?: NetraConfig): Promise<void>;
-    /**
-     * @deprecated Use `Netra.init()` instead. The init method is now async by default.
-     *
-     * Initialize the Netra SDK and wait for all instrumentations to be ready.
-     * This method is kept for backwards compatibility.
-     */
-    static initAsync(config?: NetraConfig): Promise<void>;
-    /**
-     * @deprecated Since `Netra.init()` is now async and waits for instrumentations,
-     * this method is no longer necessary. It's kept for backwards compatibility.
-     *
-     * Returns a promise that resolves when all async instrumentations are ready.
-     */
-    static ready(): Promise<void>;
-    /**
-     * Optional cleanup to end the root span and uninstrument all.
-     * Now async to ensure spans are flushed.
-     */
     static shutdown(): Promise<void>;
+    static getTraceId(): string | undefined;
+    static setInput(value: any): void;
+    static setOutput(value: any): void;
+    static setRootInput(value: any): void;
+    static setRootOutput(value: any): void;
     /**
      * Run a function with the root span as the active parent context.
      * All spans created within this function will be children of the root span.
-     *
-     * @param fn The function to run within the root span context
-     * @returns The result of the function
+     * Note: required in JS because OTel JS has no persistent context.attach()
      */
     static runWithRootSpan<T>(fn: () => T): T;
-    /**
-     * Run an async function with the root span as the active parent context.
-     * All spans created within this function will be children of the root span.
-     *
-     * @param fn The async function to run within the root span context
-     * @returns A promise that resolves with the result of the function
-     */
-    static runWithRootSpanAsync<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Run a function within an isolated entity context.
-     * This ensures that entity stacks (workflow, task, agent, span) are isolated
-     * per request in concurrent environments.
-     *
-     * Note: Session context (session_id, user_id, tenant_id) is automatically
-     * isolated via OpenTelemetry's baggage API and AsyncLocalStorage.
-     * This method is primarily needed if you're using workflow/task/agent decorators
-     * or span wrappers in concurrent environments.
-     *
-     * @param fn The function to run with isolated entity context
-     * @returns The result of the function
-     *
-     */
-    static runWithContext<T>(fn: () => T): T;
-    /**
-     * Set session_id context attributes for all spans.
-     * Uses OpenTelemetry baggage API for automatic context propagation.
-     *
-     * Context automatically propagates across async boundaries in concurrent environments
-     * thanks to AsyncLocalStorage in @opentelemetry/sdk-node.
-     */
     static setSessionId(sessionId: string): void;
     /**
      * Set user_id context attributes for all spans.
@@ -1367,11 +1446,11 @@ declare class Netra {
      * Append a conversation entry to the current active span
      */
     static addConversation(conversationType: ConversationType, role: string, content: string | Record<string, any>): void;
-    /**
-     * Start a new span
-     */
-    static startSpan(name: string, attributes?: Record<string, string>, moduleName?: string, asType?: SpanType): SpanWrapper;
+    static startSpan(name: string): SpanWrapper;
+    static startSpan(name: string, options: SpanOptions): SpanWrapper;
+    static startActiveSpan<T>(name: string, fn: SpanCallback<T>): T;
+    static startActiveSpan<T>(name: string, options: SpanOptions, fn: SpanCallback<T>): T;
     static withBlockedSpansLocal: typeof withBlockedSpansLocal;
 }
 
-export { type ActionModel, Aggregation, BaseTask, type CategoricalDataPoint, ChartType, Config, type ConversationResponse, type ConversationResult, ConversationType, type CreateDatasetParams, type CreateRunResult, Dashboard, type DashboardData, type Dataset, type DatasetEntry, type DatasetItem, type Dimension, DimensionField, type DimensionValue, EntryStatus, Evaluation, type EvaluationScore, type EvaluatorFunction, type Filter, type FilterConfig, FilterField, FilterType, FilteringSpanExporter, type GetPromptParams, GroupBy, InstrumentationSpanProcessor, type ListSpansParams, type ListTracesParams, Measure, type Metrics, Netra, NetraInstruments, type NumberResponse, Operator, type PromptResponse, Prompts, type QueryDataParams, type QueryResponse, type Run, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, type SessionUsageData, Simulation, type SimulationItem, type SimulationOptions, type SimulationResult, SpanType, type SpansPage, type TaskFunction, type TaskResult, type TenantUsageData, type TestSuiteResult, type TimeRange, type TimeSeriesDataPoint, type TimeSeriesResponse, type TimeSeriesWithDimension, type TraceSpan, type TraceSummary, type TracesPage, TrialAwareOTLPExporter, Usage, type UsageModel, agent, Netra as default, metadataField, mistralAIInstrumentor, span, task, workflow };
+export { type ActionModel, Aggregation, BaseTask, type CategoricalDataPoint, ChartType, Config, type ConversationResponse, type ConversationResult, ConversationType, type CreateDatasetParams, type CreateRunResult, DEFAULT_INSTRUMENTS, DEFAULT_INSTRUMENTS_FOR_ROOT, Dashboard, type DashboardData, type Dataset, type DatasetEntry, type DatasetItem, type Dimension, DimensionField, type DimensionValue, EntryStatus, Evaluation, type EvaluationScore, type EvaluatorFunction, type Filter, type FilterConfig, FilterField, FilterType, FilteringSpanExporter, type GetPromptParams, GroupBy, InstrumentationSpanProcessor, type ListSpansParams, type ListTracesParams, Measure, type Metrics, Netra, NetraAgentsTracingProcessor, NetraInstruments, NetraOpenAIAgentsInstrumentor, type NumberResponse, Operator, type PromptResponse, Prompts, type QueryDataParams, type QueryResponse, type Run, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, type SessionUsageData, Simulation, type SimulationItem, type SimulationOptions, type SimulationResult, SpanIOProcessor, type SpanOptions, SpanType, type SpansPage, type TaskFunction, type TaskResult, type TenantUsageData, type TestSuiteResult, type TimeRange, type TimeSeriesDataPoint, type TimeSeriesResponse, type TimeSeriesWithDimension, type TraceSpan, type TraceSummary, type TracesPage, TrialAwareOTLPExporter, Usage, type UsageModel, agent, Netra as default, metadataField, mistralAIInstrumentor, openaiAgentsInstrumentor, span, task, workflow };