@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/traces.d.ts

@@ -1,79 +1,39 @@
-import { c as ValidationError, o as LimitExceededError, r as CaptureIntegrityError, s as NotFoundError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
-import { C as ToolSpan, D as isToolSpan, E as isLlmSpan, S as TRACE_SCHEMA_VERSION, T as isJudgeSpan, _ as SandboxSpan, a as FAILURE_CLASSES, b as SpanKind, c as JudgeSpan, d as RetrievalSpan, f as Run, g as RunStatus, h as RunOutcome, i as EventKind, l as LlmSpan, m as RunLayer, n as BudgetLedgerEntry, o as FailureClass, p as RunCaptureReport, r as BudgetSpec, s as GenericSpan, t as Artifact, u as Message, v as Span, w as TraceEvent, x as SpanStatus, y as SpanBase } from "./schema-2g7trUwH.js";
-import { a as RunRecord, c as RunSplitTag, d as RunTokenUsage, u as RunTerminalOutcome } from "./run-record-D1Hw-Jml.js";
-import { $ as DatasetOverview, G as BoundedTraceAnalysisStoreOptions, J as SpanSourceReader, K as ReadSpanSourceInput, Q as DEFAULT_TRACE_ANALYST_BUDGETS, W as createBoundedTraceAnalysisStore, X as TraceAnalysisStore, Y as TRACE_ANALYSIS_LIMITS, Z as TraceAnalysisStoreContext, at as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, ct as TraceAnalystSpan, dt as TraceAnalystTraceSummary, et as ErrorCluster, ft as ViewSpansResult, it as SpanMatchRecord, lt as TraceAnalystSpanKind, mt as ViewTraceResult, nt as SearchSpanResult, ot as TraceAnalystByteBudgets, pt as ViewTraceOversized, q as ReadSpanSourceResult, rt as SearchTraceResult, st as TraceAnalystFilters, tt as QueryTracesPage, ut as TraceAnalystSpanStatus } from "./types-oKRhQAde.js";
-import { $ as NoopRawProviderSink, Q as InMemoryRawProviderSinkOptions, X as FileSystemRawProviderSinkOptions, Y as FileSystemRawProviderSink, Z as InMemoryRawProviderSink, at as defaultProviderRedactor, et as ProviderRedactor, it as RawProviderSinkFilter, nt as RawProviderEvent, ot as providerFromBaseUrl, rt as RawProviderSink, tt as RawProviderDirection } from "./types-DBZ7keha.js";
-import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o as SpanFilter, r as FileSystemTraceStoreOptions, s as TraceStore, t as EventFilter } from "./store-C4avFjIi.js";
-import { _ as buildTraceAnalysisToolDescriptors, g as UNTRUSTED_TRACE_TEXT, h as TraceAnalysisToolDescriptor, m as TRACE_ANALYST_TOOL_NAMESPACE, p as BuildTraceAnalysisToolsOptions } from "./engine-C_zNWfM8.js";
-import { a as SpanHandle, i as RunCompleteHookContext, n as CaptureWrite, o as TraceEmitter, r as RunCompleteHook, s as TraceEmitterOptions, t as CaptureErrorHandler } from "./emitter-HcCmFQl_.js";
-import { S as shareAllowed, _ as emptyRedactionReport, a as RedactionFinding, b as redactForShare, c as SafetyCategory, d as ShareSafetyVerdict, f as assessShareSafety, g as detectPersonalData, h as detectCredential, i as RedactOptions, l as ShareSafetyFinding, m as combineVerdicts, n as REDACTION_PROFILES, o as RedactionProfile, p as classifyKey, r as REDACTION_VERSION, s as RedactionReport, t as AssessOptions, u as ShareSafetyStatus, v as normalizeKey, x as redactText, y as redact } from "./redact-Cveoq6fJ.js";
-import { C as TOOL_LATENCY_MS, D as asNumber, E as applyLlmSpanOtlpAttributes, O as contextInputTokens, S as TOOL_ARGS_CAPTURED, T as TOOL_NAME_ATTR_KEYS, _ as LlmSpanOtlpInput, a as LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, b as RUN_COST_ATTR_KEYS, c as LLM_COST_USD, d as LLM_MODEL_ATTR_KEYS, f as LLM_MODEL_NAME, g as LLM_REASONING_TOKEN_ATTR_KEYS, h as LLM_REASONING_TOKENS, i as LLM_CACHE_WRITE_TOKENS, k as firstNumberAttr, l as LLM_INPUT_TOKENS, m as LLM_OUTPUT_TOKEN_ATTR_KEYS, n as LLM_CACHED_TOKENS, o as LLM_CONTEXT_TOKENS, p as LLM_OUTPUT_TOKENS, r as LLM_CACHED_TOKEN_ATTR_KEYS, s as LLM_COST_ATTR_KEYS, t as INPUT_VALUE, u as LLM_INPUT_TOKEN_ATTR_KEYS, v as OPENINFERENCE_SPAN_KIND, w as TOOL_NAME, x as SPAN_KIND_ATTR_KEYS, y as OUTPUT_VALUE } from "./attribute-vocabulary-CcXqHODT.js";
-import { A as scoreTraceInsightReadiness, B as OtlpSpan, C as describeTraceInsightScope, D as isTraceInsightAttribution, E as isTraceInsightArtifact, F as analyzeTraces, G as ExtractUsageFromSseOptions, H as CaptureFetchContext, I as OtlpFlatLine, J as extractUsage, K as ExtractedUsage, L as OTEL_AGENT_EVAL_SCOPE, M as AnalyzeTracesInput, N as AnalyzeTracesOptions, O as isTraceInsightEvidence, P as AnalyzeTracesResult, R as OtlpExport, S as defaultTraceInsightPanel, T as inferDomainKeywords, U as CaptureFetchOptions, V as exportRunAsOtlp, W as captureFetchToRawSink, X as extractUsageFromSse, Y as extractUsageFromResponse, _ as TraceInsightReadiness, a as SpanRecordsToTraceAnalysisStoreOptions, b as buildTraceInsightContext, c as spanRecordsToTraceAnalysisStore, d as TraceInsightEvidence, f as TraceInsightFinding, g as TraceInsightQuestion, h as TraceInsightQualityGate, i as OtlpFileTraceStoreOptions, j as tokenizeDomainWords, k as planTraceInsightQuestions, l as TraceInsightAttribution, m as TraceInsightPromptInput, n as toolSpansToTraceAnalysisStore, o as ToolSpansToTraceAnalysisStoreOptions, p as TraceInsightPanelRole, q as SseUsageMode, r as OtlpFileTraceStore, s as otlpTextToTraceAnalysisStore, t as ToolTraceMissingError, u as TraceInsightContext, v as TraceInsightSuite, w as domainEvidencePattern, x as buildTraceInsightPrompt, y as TraceInsightTask, z as OtlpResourceSpans } from "./store-tool-spans-DR1SrCLK.js";
-import { a as RunIntegrityReport, i as RunIntegrityIssueCode, n as RunIntegrityExpectations, o as assertRunCaptured, r as RunIntegrityIssue, s as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-CCAxGVK6.js";
-import { a as groupBy, c as llmSpans, d as runsForScenario, f as toolSpans, i as argHash, l as runFailureClass, n as RunMetric, o as hasCapturedToolArgs, r as aggregateLlm, s as judgeSpans, t as RUN_METRICS, u as runMetricExtractor } from "./query-DK1nWcmp.js";
+import { c as ValidationError, o as LimitExceededError, s as NotFoundError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
+import { C as TraceRunOutcome, E as isToolSpan, S as TraceEvent, T as isLlmSpan, _ as Span, a as FAILURE_CLASSES, b as SpanStatus, c as JudgeSpan, d as RetrievalSpan, f as Run, g as SandboxSpan, h as RunStatus, i as EventKind, l as LlmSpan, m as RunLayer, n as BudgetLedgerEntry, o as FailureClass, p as RunCaptureReport, r as BudgetSpec, s as GenericSpan, t as Artifact, u as Message, v as SpanBase, w as isJudgeSpan, x as ToolSpan, y as SpanKind } from "./schema-D6EVKzTB.js";
+import { a as RunRecord, c as RunSplitTag, d as RunTokenUsage, u as RunTerminalOutcome } from "./run-record-CaxbLq6Y.js";
+import { $ as TraceAnalystByteBudgets, B as ReadSpanSourceInput, G as TraceAnalysisStoreContext, H as SpanSourceReader, J as ErrorCluster, K as DEFAULT_TRACE_ANALYST_BUDGETS, Q as SpanMatchRecord, R as createBoundedTraceAnalysisStore, U as TRACE_ANALYSIS_LIMITS, V as ReadSpanSourceResult, W as TraceAnalysisStore, X as SearchSpanResult, Y as QueryTracesPage, Z as SearchTraceResult, at as ViewSpansResult, et as TraceAnalystFilters, it as TraceAnalystTraceSummary, nt as TraceAnalystSpanKind, ot as ViewTraceOversized, q as DatasetOverview, rt as TraceAnalystSpanStatus, st as ViewTraceResult, tt as TraceAnalystSpan, z as BoundedTraceAnalysisStoreOptions } from "./types-CW8ewATZ.js";
+import { G as InMemoryRawProviderSinkOptions, H as FileSystemRawProviderSink, J as RawProviderDirection, K as NoopRawProviderSink, U as FileSystemRawProviderSinkOptions, W as InMemoryRawProviderSink, X as RawProviderSink, Y as RawProviderEvent, Z as RawProviderSinkFilter, q as ProviderRedactor } from "./types-D-mgRzlh.js";
+import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o as SpanFilter, r as FileSystemTraceStoreOptions, s as TraceStore, t as EventFilter } from "./store-B3nWRy3B.js";
+import { d as BuildTraceAnalysisToolsOptions, f as TRACE_ANALYST_TOOL_NAMESPACE, h as buildTraceAnalysisToolDescriptors, m as UNTRUSTED_TRACE_TEXT, p as TraceAnalysisToolDescriptor } from "./engine-BvZ0R-36.js";
+import { a as SpanHandle, i as RunCompleteHookContext, n as CaptureWrite, o as TraceEmitter, r as RunCompleteHook, s as TraceEmitterOptions, t as CaptureErrorHandler } from "./emitter-DABYYTcH.js";
+import { _ as shareAllowed, a as RedactionProfile, c as ShareSafetyFinding, d as assessShareSafety, f as combineVerdicts, g as redactText, h as redactForShare, i as RedactionFinding, l as ShareSafetyStatus, m as redact, n as REDACTION_VERSION, o as RedactionReport, p as emptyRedactionReport, r as RedactOptions, s as SafetyCategory, t as AssessOptions, u as ShareSafetyVerdict } from "./redact-DXdlFb_U.js";
+import { A as TraceInsightReadiness, B as isTraceInsightEvidence, C as TraceInsightContext, D as TraceInsightPromptInput, E as TraceInsightPanelRole, F as describeTraceInsightScope, G as AnalyzeTracesResult, H as tokenizeDomainWords, I as domainEvidencePattern, K as analyzeTraces, L as inferDomainKeywords, M as TraceInsightTask, N as buildTraceInsightContext, O as TraceInsightQualityGate, P as buildTraceInsightPrompt, R as isTraceInsightArtifact, S as TraceInsightAttribution, T as TraceInsightFinding, U as AnalyzeTracesInput, V as scoreTraceInsightReadiness, W as AnalyzeTracesOptions, _ as ToolSpansToTraceAnalysisStoreOptions, a as captureFetchToRawSink, b as OtlpSpan, c as ExtractedUsage, d as extractUsageFromSse, f as OtlpFileTraceStore, g as spanRecordsToTraceAnalysisStore, h as otlpTextToTraceAnalysisStore, i as CaptureFetchOptions, j as TraceInsightSuite, k as TraceInsightQuestion, l as SseUsageMode, m as SpanRecordsToTraceAnalysisStoreOptions, n as toolSpansToTraceAnalysisStore, o as OtlpFlatLine, p as OtlpFileTraceStoreOptions, r as CaptureFetchContext, s as ExtractUsageFromSseOptions, t as ToolTraceMissingError, u as extractUsage, v as OtlpExport, w as TraceInsightEvidence, x as exportRunAsOtlp, y as OtlpResourceSpans, z as isTraceInsightAttribution } from "./store-tool-spans-DZS0HWVf.js";
+import { a as RunIntegrityReport, i as RunIntegrityIssueCode, n as RunIntegrityExpectations, o as assertRunCaptured, r as RunIntegrityIssue, t as RunIntegrityError } from "./integrity-_qgZLA5p.js";
+import { D as asNumber, E as applyLlmSpanOtlpAttributes, O as contextInputTokens, T as TOOL_NAME_ATTR_KEYS, _ as LlmSpanOtlpInput, a as LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, c as LLM_COST_USD, d as LLM_MODEL_ATTR_KEYS, f as LLM_MODEL_NAME, g as LLM_REASONING_TOKEN_ATTR_KEYS, h as LLM_REASONING_TOKENS, i as LLM_CACHE_WRITE_TOKENS, k as firstNumberAttr, l as LLM_INPUT_TOKENS, m as LLM_OUTPUT_TOKEN_ATTR_KEYS, n as LLM_CACHED_TOKENS, o as LLM_CONTEXT_TOKENS, p as LLM_OUTPUT_TOKENS, r as LLM_CACHED_TOKEN_ATTR_KEYS, s as LLM_COST_ATTR_KEYS, t as INPUT_VALUE, u as LLM_INPUT_TOKEN_ATTR_KEYS, v as OPENINFERENCE_SPAN_KIND, w as TOOL_NAME, x as SPAN_KIND_ATTR_KEYS, y as OUTPUT_VALUE } from "./attribute-vocabulary-CcXqHODT.js";
+import { a as llmSpans, c as toolSpans, i as judgeSpans, n as argHash, o as runFailureClass, r as groupBy, s as runsForScenario, t as RunMetric } from "./query-Cmv_U8vf.js";
 import { SpanKind as SpanKind$1 } from "@tangle-network/agent-trace-contract";
-//#region src/trace-analyst/errors.d.ts
-/** Invalid trace-tool arguments, including malformed filters and regexes. */
-export declare class TraceAnalysisValidationError extends ValidationError {
-  readonly code: 'validation';
-}
-/** A trace read cannot fit within a documented count or byte limit. */
-export declare class TraceAnalysisLimitError extends LimitExceededError {
-  readonly code: 'limit_exceeded';
-  readonly operation: string;
-  readonly actual: number;
-  readonly limit: number;
-  constructor(operation: string, actual: number, limit: number, message?: string);
-}
-/** A supplied store returned a shape that violates the trace read contract. */
-export declare class TraceAnalysisStoreContractError extends AgentEvalError {
-  readonly code: 'backend_integrity';
-  readonly operation: string;
-  constructor(operation: string, message: string, options?: {
-    cause?: unknown;
-  });
-}
-export declare class TraceFileMissingError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly path: string;
-  constructor(path: string);
-}
-export declare class TraceFileTooLargeError extends TraceAnalysisLimitError {
-  readonly path: string;
-  readonly size_bytes: number;
-  readonly max_bytes: number;
-  constructor(path: string, size_bytes: number, max_bytes: number);
-}
-export declare class TraceFileMalformedError extends CaptureIntegrityError {
-  readonly path: string;
-  readonly line_number: number;
-  readonly byte_offset: number;
-  constructor(path: string, line_number: number, byte_offset: number, cause?: unknown);
-}
-export declare class TraceNotFoundError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly trace_id: string;
-  constructor(trace_id: string);
-}
-export declare class SpanNotFoundError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly trace_id: string;
-  readonly span_id: string;
-  constructor(trace_id: string, span_id: string);
-}
-//#endregion
 //#region src/trace/otlp-attributes.d.ts
-export type ToolSpanOtlpInput = Pick<ToolSpan, 'toolName' | 'args' | 'argsCaptured' | 'result' | 'latencyMs'>;
+type ToolSpanOtlpInput = Pick<ToolSpan, 'toolName' | 'args' | 'argsCaptured' | 'result' | 'latencyMs'>;
 export declare function applyToolSpanOtlpAttributes(attributes: Record<string, unknown>, span: ToolSpanOtlpInput): void;
+//#endregion
+//#region src/trace/redaction/detectors.d.ts
+/**
+ * Canonical snake_case form of a field name, so camelCase, kebab-case, dotted
+ * and snake_case spellings match one list: `userPassword`, `user-password` and
+ * `user.password` all become `user_password`.
+ */
+export declare function normalizeKey(key: string): string;
 /**
- * The contract kind this package writes for one of its own span kinds. A kind
- * with no contract equivalent is written as `UNKNOWN`, which the contract
- * accepts, rather than a word no reader knows.
+ * The safety category a field name puts its value in, or undefined for an
+ * ordinary field. Token counts and model limits (`inputTokens`, `max_tokens`,
+ * `token_count`) and names such as `author` are not credentials.
  */
-export declare function traceSpanKindToOpenInferenceKind(kind: string): SpanKind$1;
+export declare function classifyKey(key: string): SafetyCategory | undefined;
+/** The first credential detector that matches, or undefined. */
+export declare function detectCredential(text: string): string | undefined;
 //#endregion
 //#region src/trace/store-to-otlp.d.ts
-export interface TracesToOtlpResult {
+interface TracesToOtlpResult {
   /** Total spans emitted across every cell. */
   spanCount: number;
   /** Total run-anchor spans (one per Run) appended for analyst visibility. */
@@ -94,7 +54,7 @@ export interface TracesToOtlpResult {
  *     production-ingestion sidecar that appends one ndjson set directly under
  *     the chosen directory).
  */
-export interface TraceStoreSource {
+interface TraceStoreSource {
   /** Absolute path to the trace store root. */
   root: string;
   /** Layout — `celled` (default) or `flat`. */
@@ -104,7 +64,7 @@ export interface TraceStoreSource {
 }
 /** Domain hooks. The walker is generic; consumers inject the namespaced
  *  attributes that ride along on every run + span for analyst discovery. */
-export interface TraceStoreToOtlpOptions {
+interface TraceStoreToOtlpOptions {
   /** Default OTLP `service.name` when a source doesn't set its own.
    *  Default `agent-eval`. */
   serviceName?: string;
@@ -125,6 +85,50 @@ export interface TraceStoreToOtlpOptions {
  */
 export declare function convertTraceStoresToOtlp(source: string | TraceStoreSource | readonly TraceStoreSource[], outPath: string, opts?: TraceStoreToOtlpOptions): TracesToOtlpResult;
 //#endregion
+//#region src/trace-analyst/errors.d.ts
+/** Invalid trace-tool arguments, including malformed filters and regexes. */
+export declare class TraceAnalysisValidationError extends ValidationError {
+  readonly code: 'validation';
+}
+/** A trace read cannot fit within a documented count or byte limit. */
+export declare class TraceAnalysisLimitError extends LimitExceededError {
+  readonly code: 'limit_exceeded';
+  readonly operation: string;
+  readonly actual: number;
+  readonly limit: number;
+  constructor(operation: string, actual: number, limit: number, message?: string);
+}
+/** A supplied store returned a shape that violates the trace read contract. */
+export declare class TraceAnalysisStoreContractError extends AgentEvalError {
+  readonly code: 'backend_integrity';
+  readonly operation: string;
+  constructor(operation: string, message: string, options?: {
+    cause?: unknown;
+  });
+}
+export declare class TraceFileMissingError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly path: string;
+  constructor(path: string);
+}
+export declare class TraceFileTooLargeError extends TraceAnalysisLimitError {
+  readonly path: string;
+  readonly size_bytes: number;
+  readonly max_bytes: number;
+  constructor(path: string, size_bytes: number, max_bytes: number);
+}
+export declare class TraceNotFoundError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly trace_id: string;
+  constructor(trace_id: string);
+}
+export declare class SpanNotFoundError extends NotFoundError {
+  readonly code: 'not_found';
+  readonly trace_id: string;
+  readonly span_id: string;
+  constructor(trace_id: string, span_id: string);
+}
+//#endregion
 //#region src/trace-analyst/hook.d.ts
 interface TraceAnalystHookOptions {
   /**
@@ -202,13 +206,6 @@ interface ProjectedOtlpSpan {
  * when the line is missing the mandatory `trace_id` + `span_id`.
  */
 export declare function projectOtlpFlatLine(raw: Record<string, unknown>): ProjectedOtlpSpan | null;
-/**
- * Flatten OTLP `attributes` + `resource.attributes` into a single
- * dotted-key map. Span attributes override resource attributes when keys
- * overlap. Nested objects/arrays are preserved as-is.
- */
-export declare function extractOtlpAttributes(raw: Record<string, unknown>): Record<string, unknown>;
-export declare function stringField(raw: Record<string, unknown>, key: string): string | undefined;
 export declare function asString(v: unknown): string | null;
 /** First non-empty string value across a list of candidate attribute keys. */
 export declare function firstStringAttr(attrs: Record<string, unknown>, keys: readonly string[]): string | null;
@@ -319,13 +316,6 @@ export declare function otlpToRunRecords(otlpJsonl: string, opts: OtlpToRunRecor
  * paths share projection, reconciliation, validation, and ordering.
  */
 export declare function otlpRowsToRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): RunRecord[];
-/** As {@link otlpToRunRecords} but returns the prompt/completion text too. */
-export declare function otlpToTraceRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
-//#endregion
-//#region src/trace-analyst/prompts.d.ts
-/** General policy for recursive, evidence-backed trace analysis. */
-export declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "Answer the question by inspecting the OTLP trace dataset with the available tools.\n\n1. Call getDatasetOverview first. Use its real trace ids and dataset size to plan the investigation.\n2. Narrow with queryTraces and countTraces before scanning large payloads.\n3. For a small trace, use viewTrace. For a large trace, use searchTrace and then viewSpans or searchSpan.\n4. Never invent a trace id, span id, tool result, error, frequency, or final outcome.\n5. When a search reports has_more, refine the query before drawing a conclusion.\n6. Use llm_query only over evidence already loaded. A recursive query cannot inspect traces itself.\n7. Cite exact evidence URIs returned by the tools. Include a short exact excerpt when it supports the claim.\n8. Return no finding when the available evidence cannot support one.\n\nThe prose answer must directly answer the question and state important uncertainty.\nThe findings array contains only actionable or decision-relevant claims supported by inspected evidence.";
-export declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-research-v1-2026-07-30";
 //#endregion
-export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, Artifact, AssessOptions, type BoundedTraceAnalysisStoreOptions, BudgetLedgerEntry, BudgetSpec, type BuildTraceAnalysisToolsOptions, CaptureErrorHandler, CaptureFetchContext, CaptureFetchOptions, CaptureWrite, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, EventFilter, EventKind, ExtractUsageFromSseOptions, ExtractedUsage, FAILURE_CLASSES, FailureClass, FileSystemRawProviderSink, FileSystemRawProviderSinkOptions, FileSystemTraceStore, FileSystemTraceStoreOptions, type FlattenOtlpOptions, GenericSpan, INPUT_VALUE, InMemoryRawProviderSink, InMemoryRawProviderSinkOptions, InMemoryTraceStore, JudgeSpan, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, LlmSpan, LlmSpanOtlpInput, Message, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, OtlpResourceSpans, OtlpSpan, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, ProviderRedactor, type QueryTracesPage, REDACTION_PROFILES, REDACTION_VERSION, RUN_COST_ATTR_KEYS, RUN_METRICS, RawProviderDirection, RawProviderEvent, RawProviderSink, RawProviderSinkFilter, type ReadSpanSourceInput, type ReadSpanSourceResult, RedactOptions, RedactionFinding, RedactionProfile, RedactionReport, RetrievalSpan, Run, RunCaptureReport, RunCompleteHook, RunCompleteHookContext, RunFilter, RunIntegrityError, RunIntegrityExpectations, RunIntegrityIssue, RunIntegrityIssueCode, RunIntegrityReport, RunLayer, RunMetric, RunOutcome, RunStatus, SPAN_KIND_ATTR_KEYS, SafetyCategory, SandboxSpan, type SearchSpanResult, type SearchTraceResult, ShareSafetyFinding, ShareSafetyStatus, ShareSafetyVerdict, Span, SpanBase, SpanFilter, SpanHandle, SpanKind, type SpanMatchRecord, type SpanRecordsToTraceAnalysisStoreOptions, type SpanSourceReader, SpanStatus, SseUsageMode, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolSpan, type ToolSpansToTraceAnalysisStoreOptions, ToolTraceMissingError, type TraceAggregate, type TraceAnalysisStore, type TraceAnalysisStoreContext, type TraceAnalysisToolDescriptor, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, TraceEmitterOptions, TraceEvent, type TraceInsightAttribution, type TraceInsightContext, type TraceInsightEvidence, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceStore, UNTRUSTED_TRACE_TEXT, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, argHash, asNumber, assertRunCaptured, assessShareSafety, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyKey, combineVerdicts, contextInputTokens, createBoundedTraceAnalysisStore, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, detectCredential, detectPersonalData, domainEvidencePattern, emptyRedactionReport, exportRunAsOtlp, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, groupBy, hasCapturedToolArgs, inferDomainKeywords, isJudgeSpan, isLlmSpan, isToolSpan, isTraceInsightArtifact, isTraceInsightAttribution, isTraceInsightEvidence, judgeSpans, llmSpans, normalizeKey, otlpTextToTraceAnalysisStore, planTraceInsightQuestions, providerFromBaseUrl, redact, redactForShare, redactText, runFailureClass, runMetricExtractor, runsForScenario, scoreTraceInsightReadiness, shareAllowed, spanRecordsToTraceAnalysisStore, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore };
+export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type Artifact, type AssessOptions, type BoundedTraceAnalysisStoreOptions, type BudgetLedgerEntry, type BudgetSpec, type BuildTraceAnalysisToolsOptions, type CaptureErrorHandler, type CaptureFetchContext, type CaptureFetchOptions, type CaptureWrite, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, type EventFilter, type EventKind, type ExtractUsageFromSseOptions, type ExtractedUsage, FAILURE_CLASSES, type FailureClass, FileSystemRawProviderSink, type FileSystemRawProviderSinkOptions, FileSystemTraceStore, type FileSystemTraceStoreOptions, type FlattenOtlpOptions, type GenericSpan, INPUT_VALUE, InMemoryRawProviderSink, type InMemoryRawProviderSinkOptions, InMemoryTraceStore, type JudgeSpan, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, type LlmSpan, type LlmSpanOtlpInput, type Message, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, type OtlpResourceSpans, type OtlpSpan, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, type ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, type RawProviderDirection, type RawProviderEvent, type RawProviderSink, type RawProviderSinkFilter, type ReadSpanSourceInput, type ReadSpanSourceResult, type RedactOptions, type RedactionFinding, type RedactionProfile, type RedactionReport, type RetrievalSpan, type Run, type RunCaptureReport, type RunCompleteHook, type RunCompleteHookContext, type RunFilter, RunIntegrityError, type RunIntegrityExpectations, type RunIntegrityIssue, type RunIntegrityIssueCode, type RunIntegrityReport, type RunLayer, type RunMetric, type RunStatus, SPAN_KIND_ATTR_KEYS, type SafetyCategory, type SandboxSpan, type SearchSpanResult, type SearchTraceResult, type ShareSafetyFinding, type ShareSafetyStatus, type ShareSafetyVerdict, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, type SpanRecordsToTraceAnalysisStoreOptions, type SpanSourceReader, type SpanStatus, type SseUsageMode, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_TOOL_NAMESPACE, type ToolSpan, type ToolSpanOtlpInput, type ToolSpansToTraceAnalysisStoreOptions, ToolTraceMissingError, type TraceAggregate, type TraceAnalysisStore, type TraceAnalysisStoreContext, type TraceAnalysisToolDescriptor, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, type TraceEmitterOptions, type TraceEvent, type TraceInsightAttribution, type TraceInsightContext, type TraceInsightEvidence, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, type TraceRunOutcome, type TraceStore, type TraceStoreSource, type TraceStoreToOtlpOptions, type TracesToOtlpResult, UNTRUSTED_TRACE_TEXT, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, analyzeTraces, applyLlmSpanOtlpAttributes, argHash, asNumber, assertRunCaptured, assessShareSafety, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, combineVerdicts, contextInputTokens, createBoundedTraceAnalysisStore, describeTraceInsightScope, domainEvidencePattern, emptyRedactionReport, exportRunAsOtlp, extractUsage, extractUsageFromSse, firstNumberAttr, groupBy, inferDomainKeywords, isJudgeSpan, isLlmSpan, isToolSpan, isTraceInsightArtifact, isTraceInsightAttribution, isTraceInsightEvidence, judgeSpans, llmSpans, otlpTextToTraceAnalysisStore, redact, redactForShare, redactText, runFailureClass, runsForScenario, scoreTraceInsightReadiness, shareAllowed, spanRecordsToTraceAnalysisStore, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore };
 //# sourceMappingURL=traces.d.ts.map

package/dist/traces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traces.d.ts","names":["SpanKind"],"sources":["../src/trace-analyst/errors.ts","../src/trace/otlp-attributes.ts","../src/trace/store-to-otlp.ts","../src/trace-analyst/hook.ts","../src/trace-analyst/otlp-flatten.ts","../src/trace-analyst/otlp-span.ts","../src/trace-analyst/otlp-to-run-records.ts","../src/trace-analyst/prompts.ts"],"mappings":";;;;;;;;;;;;;;;;qBASa,qCAAqC;WAC/B;;;qBAIN,gCAAgC;WAC1B;WACR;WACA;WACA;EAET,YAAY,mBAAmB,gBAAgB,eAAe;;;qBASnD,wCAAwC;WAClC;WACR;EAET,YAAY,mBAAmB,iBAAiB;IAAY;;;qBAMjD,8BAA8B;WACxB;WACR;EAET,YAAY;;qBAMD,+BAA+B;WACjC;WACA;WACA;EAET,YAAY,cAAc,oBAAoB;;qBAcnC,gCAAgC;WAClC;WACA;WACA;EAET,YAAY,cAAc,qBAAqB,qBAAqB;;qBAQzD,2BAA2B;WACrB;WACR;EAET,YAAY;;qBAMD,0BAA0B;WACpB;WACR;WACA;EAET,YAAY,kBAAkB;;;;YC1EpB,oBAAoB,KAC9B;wBAkBc,4BACd,YAAY,yBACZ,MAAM;;;;;;wBAWQ,iCAAiC,eAAeA;;;iBCjB/C;;EAEf;;EAEA;;EAEA;;;EAGA;;;;;;;;;;;;iBAae;;EAEf;;EAEA;;EAEA;;;;iBAKe;;;EAGf;;;EAGA,sBAAsB,KAAK,QAAQ;;EAEnC,iBAAiB,KAAK,QAAQ;;;;;;;;;;;wBAYhB,yBACd,iBAAiB,4BAA4B,oBAC7C,iBACA,OAAM,0BACL;;;UCxEc;;;;;;EAMf,SAAS,KAAK;IAAoC,SAAS;;;;;;;EAM3D;;;;;;EAMA,QAAQ,QAAQ,qBAAqB,KAAK,2BAA2B;;;;;EAKrE,aAAa,KAAK;;;;;;EAMlB,UAAU,QAAQ,qBAAqB,KAAK;;wBAM9B,0BAA0B,MAAM,0BAA0B;;;UCnCzD;;;;EAIf;;EAEA,UAAU,QAAQ;;wBA+DJ,0BACd,YAAY,YACZ,OAAM,qBACL;;;;;;;;;UC7Dc;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;EAEA,YAAY;;;;;;wBAOE,oBAAoB,KAAK,0BAA0B;;;;;;wBA2FnD,sBAAsB,KAAK,0BAA0B;wBAoBrD,YAAY,KAAK,yBAAyB;wBAK1C,SAAS;;wBAKT,gBACd,OAAO,yBACP;;;UChHe;;EAEf;;;EAGA;;;EAGA,WAAW;;EAEX;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;;;;;EAMA;;;;;;;;;EASA,wBAAwB;;;;;;;;;EASxB,iBAAiB,eAAe,MAAM;;;;;EAKtC,yBAAyB,kBAAkB;;;;;;UAO5B;EACf,QAAQ;;EAER;;EAEA;;;UAIe;EACf;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,YAAY;;EAEZ;EACA;EACA;EACA;EACA;;EAEA,iBAAiB;;;;;;;wBAeH,iBAAiB,mBAAmB,MAAM,0BAA0B;;;;;;wBASpE,qBACd,MAAM,kBACN,MAAM,0BACL;;wBAKa,sBACd,mBACA,MAAM,0BACL;;;;qBCjMU;qBAcA"}
+{"version":3,"file":"traces.d.ts","names":[],"sources":["../src/trace/otlp-attributes.ts","../src/trace/redaction/detectors.ts","../src/trace/store-to-otlp.ts","../src/trace-analyst/errors.ts","../src/trace-analyst/hook.ts","../src/trace-analyst/otlp-flatten.ts","../src/trace-analyst/otlp-span.ts","../src/trace-analyst/otlp-to-run-records.ts"],"mappings":";;;;;;;;;;;;;;;KAsBY,oBAAoB,KAC9B;wBAkBc,4BACd,YAAY,yBACZ,MAAM;;;;;;;;wBClCQ,aAAa;;;;;;wBAmNb,YAAY,cAAc;;wBAyN1B,iBAAiB;;;UChZhB;;EAEf;;EAEA;;EAEA;;;EAGA;;;;;;;;;;;;UAae;;EAEf;;EAEA;;EAEA;;;;UAKe;;;EAGf;;;EAGA,sBAAsB,KAAK,QAAQ;;EAEnC,iBAAiB,KAAK,QAAQ;;;;;;;;;;;wBAYhB,yBACd,iBAAiB,4BAA4B,oBAC7C,iBACA,OAAM,0BACL;;;;qBCrFU,qCAAqC;WAC/B;;;qBAIN,gCAAgC;WAC1B;WACR;WACA;WACA;EAET,YAAY,mBAAmB,gBAAgB,eAAe;;;qBASnD,wCAAwC;WAClC;WACR;EAET,YAAY,mBAAmB,iBAAiB;IAAY;;;qBAMjD,8BAA8B;WACxB;WACR;EAET,YAAY;;qBAMD,+BAA+B;WACjC;WACA;WACA;EAET,YAAY,cAAc,oBAAoB;;qBA2BnC,2BAA2B;WACrB;WACR;EAET,YAAY;;qBAMD,0BAA0B;WACpB;WACR;WACA;EAET,YAAY,kBAAkB;;;;UC1Ef;;;;;;EAMf,SAAS,KAAK;IAAoC,SAAS;;;;;;;EAM3D;;;;;;EAMA,QAAQ,QAAQ,qBAAqB,KAAK,2BAA2B;;;;;EAKrE,aAAa,KAAK;;;;;;EAMlB,UAAU,QAAQ,qBAAqB,KAAK;;wBAM9B,0BAA0B,MAAM,0BAA0B;;;UCnCzD;;;;EAIf;;EAEA,UAAU,QAAQ;;wBA+DJ,0BACd,YAAY,YACZ,OAAM,qBACL;;;;;;;;;UC7Dc;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;EAEA,YAAY;;;;;;wBAOE,oBAAoB,KAAK,0BAA0B;wBAoHnD,SAAS;;wBAKT,gBACd,OAAO,yBACP;;;UChHe;;EAEf;;;EAGA;;;EAGA,WAAW;;EAEX;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;;;;;EAMA;;;;;;;;;EASA,wBAAwB;;;;;;;;;EASxB,iBAAiB,eAAe,MAAM;;;;;EAKtC,yBAAyB,kBAAkB;;;;;;UAO5B;EACf,QAAQ;;EAER;;EAEA;;;UAIe;EACf;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,YAAY;;EAEZ;EACA;EACA;EACA;EACA;;EAEA,iBAAiB;;;;;;;wBAeH,iBAAiB,mBAAmB,MAAM,0BAA0B;;;;;;wBASpE,qBACd,MAAM,kBACN,MAAM,0BACL"}

package/dist/traces.js

@@ -1,18 +1,18 @@
-import { a as isToolSpan, i as isLlmSpan, n as TRACE_SCHEMA_VERSION, r as isJudgeSpan, t as FAILURE_CLASSES } from "./schema-CSf6qWgZ.js";
-import { a as hasCapturedToolArgs, c as runFailureClass, d as toolSpans, i as groupBy, l as runMetricExtractor, n as aggregateLlm, o as judgeSpans, r as argHash, s as llmSpans, t as RUN_METRICS, u as runsForScenario } from "./query-B1D1qp2Z.js";
-import { c as validateRunRecord, i as modelHasSnapshot } from "./run-record-DlTZ_lqe.js";
-import { a as combineVerdicts, c as emptyRedactionReport, d as redactForShare, f as redactText, i as classifyKey, l as normalizeKey, n as REDACTION_VERSION, o as detectCredential, p as shareAllowed, r as assessShareSafety, s as detectPersonalData, t as REDACTION_PROFILES, u as redact } from "./redact-Dk1ZdJEm.js";
+import { i as isToolSpan, n as isJudgeSpan, r as isLlmSpan, t as FAILURE_CLASSES } from "./schema-Bt2vLFm3.js";
+import { c as validateRunRecord, i as modelHasSnapshot } from "./run-record-DhEJgoPz.js";
+import { a as llmSpans, c as runsForScenario, i as judgeSpans, l as toolSpans, n as groupBy, o as runFailureClass, t as argHash } from "./query-B_RZ36an.js";
+import { a as redact, c as shareAllowed, f as normalizeKey, i as emptyRedactionReport, l as classifyKey, n as assessShareSafety, o as redactForShare, r as combineVerdicts, s as redactText, t as REDACTION_VERSION, u as detectCredential } from "./redact-mtkTiJVk.js";
+import { C as asString, D as projectOtlpFlatLine, E as firstStringAttr, O as spanEpochMillis, S as TraceNotFoundError, _ as TraceAnalysisStoreContractError, a as UNTRUSTED_TRACE_TEXT, b as TraceFileMissingError, c as createBoundedTraceAnalysisStore, g as TraceAnalysisLimitError, h as SpanNotFoundError, i as TRACE_ANALYST_TOOL_NAMESPACE, m as TRACE_ANALYSIS_LIMITS, o as buildTraceAnalysisToolDescriptors, p as DEFAULT_TRACE_ANALYST_BUDGETS, v as TraceAnalysisValidationError, w as compareSpanTime, x as TraceFileTooLargeError } from "./kind-factory-Gy4fXixd.js";
+import { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, SPAN_KIND_ATTR_KEYS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, applyLlmSpanOtlpAttributes, asNumber, contextInputTokens, firstNumberAttr } from "./trace-attributes.js";
+import { n as extractUsageFromSse, t as extractUsage } from "./extract-usage-BZLU01kR.js";
+import { n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-75w4FWBj.js";
+import { _ as exportRunAsOtlp, a as spanStatusToOtlp, b as captureFetchToRawSink, c as describeTraceInsightScope, d as isTraceInsightArtifact, f as isTraceInsightAttribution, g as analyzeTraces, h as tokenizeDomainWords, i as epochMillisToIso, l as domainEvidencePattern, m as scoreTraceInsightReadiness, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, p as isTraceInsightEvidence, r as createOtlpFlatLine, s as buildTraceInsightPrompt, t as ToolTraceMissingError, u as inferDomainKeywords, v as spanIdForWire, y as traceIdForWire } from "./store-tool-spans-D5l_OfTJ.js";
 import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
-import { A as spanEpochMillis, C as TraceFileTooLargeError, D as extractOtlpAttributes, E as compareSpanTime, O as firstStringAttr, S as TraceFileMissingError, T as asString, _ as SpanNotFoundError, a as TRACE_ANALYST_TOOL_NAMESPACE, b as TraceAnalysisValidationError, g as TRACE_ANALYSIS_LIMITS, h as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, j as stringField, k as projectOtlpFlatLine, l as createBoundedTraceAnalysisStore, m as DEFAULT_TRACE_ANALYST_BUDGETS, o as UNTRUSTED_TRACE_TEXT, s as buildTraceAnalysisToolDescriptors, v as TraceAnalysisLimitError, w as TraceNotFoundError, x as TraceFileMalformedError, y as TraceAnalysisStoreContractError } from "./kind-factory-CbZ-6tvu.js";
-import { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, RUN_COST_ATTR_KEYS, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, applyLlmSpanOtlpAttributes, asNumber, contextInputTokens, firstNumberAttr } from "./trace-attributes.js";
-import { n as extractUsageFromResponse, r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrnzRJ6H.js";
-import { a as providerFromBaseUrl, i as defaultProviderRedactor, n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-rB2DYxr6.js";
-import { C as spanIdForWire, S as exportRunAsOtlp, T as captureFetchToRawSink, _ as tokenizeDomainWords, a as spanStatusToOtlp, b as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, c as defaultTraceInsightPanel, d as inferDomainKeywords, f as isTraceInsightArtifact, g as scoreTraceInsightReadiness, h as planTraceInsightQuestions, i as epochMillisToIso, l as describeTraceInsightScope, m as isTraceInsightEvidence, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, p as isTraceInsightAttribution, r as createOtlpFlatLine, s as buildTraceInsightPrompt, t as ToolTraceMissingError, u as domainEvidencePattern, v as analyzeTraces, w as traceIdForWire, x as OTEL_AGENT_EVAL_SCOPE, y as TRACE_ANALYST_ACTOR_DESCRIPTION } from "./store-tool-spans-fZIigrpP.js";
-import { n as assertRunCaptured, r as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-BvnVARVl.js";
+import { n as assertRunCaptured, t as RunIntegrityError } from "./integrity-W4CADcFc.js";
 import { n as traceSpanKindToOpenInferenceKind, t as applyToolSpanOtlpAttributes } from "./otlp-attributes-D9ptWaIJ.js";
 import { n as InMemoryTraceStore, t as FileSystemTraceStore } from "./store-BhNuLdJw.js";
-import { a as spanRecordsToTraceAnalysisStore, i as otlpTextToTraceAnalysisStore, n as OtlpFileTraceStore } from "./store-otlp-DtB4Slsr.js";
-import { i as summarizeTraceErrors, n as recordAggregateMeasurements, r as summarizeExecutionMeasurements, t as readTaskFailureLabels } from "./task-failure-attributes-DngaLdE4.js";
+import { a as spanRecordsToTraceAnalysisStore, i as otlpTextToTraceAnalysisStore, r as OtlpFileTraceStore } from "./store-otlp-BteDAbHK.js";
+import { i as summarizeTraceErrors, n as recordAggregateMeasurements, r as summarizeExecutionMeasurements, t as readTaskFailureLabels } from "./task-failure-attributes-BMsblaDh.js";
 import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { resolveSpanKind } from "@tangle-network/agent-trace-contract";
@@ -803,6 +803,6 @@ function ensureSnapshot(model, fallbackModel) {
 	return `${model}${fallbackModel.includes("@") ? fallbackModel.slice(fallbackModel.indexOf("@")) : "@otlp"}`;
 }
 //#endregion
-export { DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_PROFILES, REDACTION_VERSION, RUN_COST_ATTR_KEYS, RUN_METRICS, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolTraceMissingError, TraceAnalysisLimitError, TraceAnalysisStoreContractError, TraceAnalysisValidationError, TraceEmitter, TraceFileMalformedError, TraceFileMissingError, TraceFileTooLargeError, TraceNotFoundError, UNTRUSTED_TRACE_TEXT, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, assessShareSafety, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyKey, combineVerdicts, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, detectCredential, detectPersonalData, domainEvidencePattern, emptyRedactionReport, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, isJudgeSpan, isLlmSpan, isToolSpan, isTraceInsightArtifact, isTraceInsightAttribution, isTraceInsightEvidence, judgeSpans, llmSpans, normalizeKey, otlpRowsToRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, redact, redactForShare, redactText, runFailureClass, runMetricExtractor, runsForScenario, scoreTraceInsightReadiness, shareAllowed, spanRecordsToTraceAnalysisStore, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+export { DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_VERSION, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_TOOL_NAMESPACE, ToolTraceMissingError, TraceAnalysisLimitError, TraceAnalysisStoreContractError, TraceAnalysisValidationError, TraceEmitter, TraceFileMissingError, TraceFileTooLargeError, TraceNotFoundError, UNTRUSTED_TRACE_TEXT, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, assessShareSafety, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyKey, combineVerdicts, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, describeTraceInsightScope, detectCredential, domainEvidencePattern, emptyRedactionReport, exportRunAsOtlp, extractUsage, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, inferDomainKeywords, isJudgeSpan, isLlmSpan, isToolSpan, isTraceInsightArtifact, isTraceInsightAttribution, isTraceInsightEvidence, judgeSpans, llmSpans, normalizeKey, otlpRowsToRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, projectOtlpFlatLine, redact, redactForShare, redactText, runFailureClass, runsForScenario, scoreTraceInsightReadiness, shareAllowed, spanRecordsToTraceAnalysisStore, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystOnRunComplete };
 
 //# sourceMappingURL=traces.js.map