@tangle-network/agent-eval 0.138.0 → 0.139.0

package/dist/{replay-DbIYwso6.d.ts → replay-DjG4IG60.d.ts}

@@ -1,14 +1,12 @@
 import { c as ReplayError, l as ValidationError, o as LimitExceededError, r as CaptureIntegrityError, s as NotFoundError, t as AgentEvalError } from "./errors-DkfjIDvD.js";
+import { c as CostLedgerHandle } from "./cost-ledger-DKgyIWRj.js";
 import { S as ToolSpan, f as Run } from "./schema-BtVldJ3T.js";
-import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-DwHMk1Ai.js";
-import { _t as RawProviderSink, gt as RawProviderEvent } from "./types-5q2T25iW.js";
+import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-CztDMXVF.js";
+import { _t as RawProviderSink, gt as RawProviderEvent } from "./types-uPrS6mD-.js";
 import { s as TraceStore } from "./store-CT9YIIve.js";
 import { n as RunCompleteHookContext, t as RunCompleteHook } from "./emitter-DGQGoLyj.js";
-import { D as SearchSpanResult, E as QueryTracesPage, F as TraceAnalystSpanStatus, L as ViewSpansResult, M as TraceAnalystFilters, O as SearchTraceResult, P as TraceAnalystSpanKind, S as TraceAnalysisStoreContext, w as DatasetOverview, x as TraceAnalysisStore, y as BoundedTraceAnalysisStoreOptions, z as ViewTraceResult } from "./types-BtJhn8v6.js";
-import { S as JudgeConfig } from "./types-zFYez3PK.js";
-import { r as CorrectnessChecker } from "./completion-verifier-B4-IMYcS.js";
-import { t as AnalyzeRunsOptions } from "./analyze-runs-CPYxfPWT.js";
-import { AxAIService, AxAgentActorTurnCallbackArgs, AxFunction } from "@ax-llm/ax";
+import { D as SearchSpanResult, E as QueryTracesPage, F as TraceAnalystSpanStatus, L as ViewSpansResult, M as TraceAnalystFilters, O as SearchTraceResult, P as TraceAnalystSpanKind, S as TraceAnalysisStoreContext, f as AnalystUsageReceipt, i as AnalystFinding, w as DatasetOverview, x as TraceAnalysisStore, y as BoundedTraceAnalysisStoreOptions, z as ViewTraceResult } from "./types-DoEYskCd.js";
+import { i as TraceAnalysisEngine, o as TraceAnalysisEngineResult, s as TraceAnalystLimits, t as TraceToolGroupName } from "./tool-groups-CdYq22lX.js";
 //#region src/trace/otel.d.ts
 declare const OTEL_AGENT_EVAL_SCOPE: {
   name: string;
@@ -243,86 +241,38 @@ declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, opt
 //#endregion
 //#region src/trace-analyst/analyst.d.ts
 interface AnalyzeTracesInput {
-  /** The user-facing question. Domain framing belongs here, not in the
-   *  actor description. */
   question: string;
+  id?: string;
+  description?: string;
+  area?: string;
 }
-interface AnalyzeTracesResult {
-  /** The actor's submitted prose answer. */
-  answer: string;
-  /** Bulleted findings from the actor's structured completion. */
-  findings: string[];
-  /** Per-turn snapshots captured via `actorTurnCallback`. */
-  turns: AnalyzeTracesTurnSnapshot[];
-  /** Total turns the actor took. */
-  turnCount: number;
-  /** Token usage by role. */
-  usage: TraceAnalystUsage;
-  /** Full system + assistant + tool message log by role. */
-  chatLog: TraceAnalystChatLog;
-  /** Prompt version that produced this run. */
-  actorPromptVersion: string;
-}
-interface TraceAnalystUsage {
-  actor: TraceAnalystUsageEntry[];
-  responder: TraceAnalystUsageEntry[];
-}
-interface TraceAnalystUsageEntry {
-  [key: string]: unknown;
-}
-interface TraceAnalystChatLog {
-  actor: TraceAnalystChatMessage[];
-  responder: TraceAnalystChatMessage[];
-}
-interface TraceAnalystChatMessage {
-  [key: string]: unknown;
-}
-interface AnalyzeTracesTurnSnapshot {
-  stage: AxAgentActorTurnCallbackArgs['stage'];
-  turn: number;
-  isError: boolean;
-  /** The JS code the actor produced for this turn. */
-  code: string;
-  /** The formatted action-log entry the actor sees on the next turn. */
-  output: string;
-  /** Provider thought (when `executorOptions.showThoughts` is true and the
-   *  provider returns it). */
-  thought?: string;
-}
+type AnalyzeTracesResult = TraceAnalysisEngineResult;
 interface AnalyzeTracesOptions {
-  /** Trace data source. Pass either an OTLP-JSONL path or a custom store. */
+  /** OTLP JSONL path or a caller-owned store. */
   source: string | TraceAnalysisStore;
-  /** Caller-provided AxAIService. */
-  ai: AxAIService;
-  /** Model id forwarded to the actor. */
-  model?: string;
-  /** Maximum model subqueries. 0 disables model fan-out. Default 4. */
-  maxSubqueries?: number;
-  /** Maximum actor turns. Default 12. */
-  maxTurns?: number;
-  /** Maximum parallel model subqueries. Default 2. */
-  maxParallelSubqueries?: number;
-  /** Cancels in-flight model and tool work. */
+  /** Recursive research engine. */
+  engine: TraceAnalysisEngine;
+  /** Override the general trace-research policy. */
+  instructions?: string;
+  /** Smallest tool set that can answer the question. Default: all. */
+  toolGroup?: TraceToolGroupName;
+  limits?: Partial<TraceAnalystLimits>;
+  runId?: string;
+  budgetUsd?: number;
+  costLedger?: CostLedgerHandle;
+  costPhase?: string;
+  priorFindings?: readonly AnalystFinding[];
+  upstreamFindings?: readonly AnalystFinding[];
+  recordUsage?: (receipt: AnalystUsageReceipt) => void;
+  tags?: Record<string, string>;
+  log?: (message: string, fields?: Record<string, unknown>) => void;
   signal?: AbortSignal;
-  /** Override the actor description. */
-  actorDescription?: string;
-  /** Per-turn observability hook. */
-  onTurn?: (turn: AnalyzeTracesTurnSnapshot) => void | Promise<void>;
-  /** Override max runtime characters per turn. Default 6000. */
-  maxRuntimeChars?: number;
-  /** When set, every turn's snapshot is appended to this JSONL file
-   *  immediately. If the analyst crashes mid-loop (provider 503,
-   *  network error, validator reject) the partial reasoning is still
-   *  on disk for diagnosis and recovery. */
-  progressLogPath?: string;
 }
 /**
- * Run the trace analyst.
+ * Answer one question by recursively inspecting a trace store.
  *
- * Throws:
- *   - `TraceFileMissingError` if `source` is a path and doesn't exist.
- *   - `AxAgentClarificationError` if the analyst asks for clarification.
- *   - Provider errors (auth, rate limits) propagate from the AI service.
+ * The returned answer, cited findings, engine steps, call counts, and runtime
+ * identity are one audit record. A direct one-shot model call is not used.
  */
 declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
 //#endregion
@@ -678,9 +628,9 @@ declare function otlpToTraceRunRecords(otlpJsonl: string, opts: OtlpToRunRecords
 declare function otlpRowsToTraceRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
 //#endregion
 //#region src/trace-analyst/prompts.d.ts
-/** Ax RLM prompt for bounded trace discovery and evidence-backed analysis. */
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the `traces` namespace.\n\nDISCOVERY → NARROW → DEEP-READ protocol — follow exactly:\n\n1. ALWAYS call `traces.getDatasetOverview({})` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids — never fabricate one).\n\n2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. `filters.regex_pattern` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces — narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.\n\n3. To list more traces than the sample, call `traces.queryTraces({ filters?, limit, offset? })`. Each summary carries raw_jsonl_bytes — use it to choose between viewTrace and searchTrace BEFORE calling either.\n\n4. Per-trace inspection:\n   - SMALL trace (raw_jsonl_bytes well under 150_000): call `traces.viewTrace({ trace_id })`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large `input.value` / `output.value` / `llm.input_messages` will show a `[trace-analyst truncated: N bytes]` marker.\n   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an `oversized` response): use `traces.searchTrace({ trace_id, regex_pattern })` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call `traces.viewSpans({ trace_id, span_ids: [...] })` for surgical reads (~16KB cap, 4× higher than discovery), or `traces.searchSpan({ trace_id, span_id, regex_pattern })` for one large span. Stays bounded regardless of trace size.\n   - Useful regex patterns: `STATUS_CODE_ERROR` (failures), tool names like `grep` or `view_trace`, error strings like `MaxTurnsExceeded`, model names, attribute keys.\n\n5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.\n\n5a. **Result-shape contract** — searchTrace and searchSpan return `{ trace_id, hits, has_more }`. Iterate `result.hits` (NOT result.matches). Each hit has `{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }`. viewTrace returns `{ trace_id, spans }` (or `oversized`). viewSpans returns `{ trace_id, spans, missing_span_ids, omitted_span_ids, has_more, truncated_attribute_count }`; retry only `omitted_span_ids`. Never assume a field name — log the result shape first if unsure.\n\n6. If viewTrace returns an `oversized` summary instead of `spans`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.\n\n7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.\n\n8. If a tool errors (invalid regex, range error), STOP and reconsider — don't retry with a guessed id or argument. Use the discovery tools above to recover.\n\n9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.\n\n10. If the question splits into independent reasoning branches, use bounded `llmQuery(...)` calls over evidence you already loaded. Subqueries cannot inspect the trace store, so pass the exact trace excerpts they need. Example:\n\n    const reviews = await llmQuery([\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceAbcExcerpt },\n      { query: 'Classify the failure mechanism in this excerpt.', context: traceDefExcerpt },\n    ]);\n\nOBSERVABILITY rules:\n- Each discovery turn must emit at least one concise `console.log(...)` showing what evidence was learned.\n- Finish gathering evidence before submitting the analysis.\n- Reuse runtime variables across turns; don't recompute.\n\nOUTPUT contract — your final answer must include:\n- A clear prose conclusion answering the user's question.\n- Trace ids and span ids cited as evidence for each claim.\n- Failure modes named in the user's domain language, with frequency and concrete examples.\n- A concise findings array containing only claims supported by inspected evidence.\n\nDo NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.";
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v6-2026-07-14";
+/** General policy for recursive, evidence-backed trace analysis. */
+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.";
+declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-research-v1-2026-07-30";
 //#endregion
 //#region src/trace-analyst/store-otlp.d.ts
 interface ToolSpansToTraceAnalysisStoreOptions {
@@ -785,65 +735,6 @@ declare class ToolTraceMissingError extends CaptureIntegrityError {
  */
 declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
-//#region src/eval-tools.d.ts
-/** One agent-callable tool. `parameters` is a JSON Schema (draft-07+) object. */
-interface EvalToolDef {
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-  handler: (args: unknown, ctx?: {
-    signal?: AbortSignal;
-  }) => Promise<unknown>;
-}
-interface MakeEvalToolsConfig {
-  /** Judges available to `run_judges`. Omit to exclude the tool. */
-  judges?: Array<JudgeConfig<unknown>>;
-  /** Host-side correctness checker for `verify_completion` (the third
-   *  `verifyCompletion` argument — a function, so it cannot cross the wire).
-   *  Omit to exclude the tool. */
-  completion?: {
-    checkCorrectness: CorrectnessChecker;
-  };
-  /** `analyzeRuns` options minus `runs` (runs arrive as tool args, inline or
-   *  via `path`). Omit to exclude the tool. */
-  analyze?: Omit<AnalyzeRunsOptions, 'runs'>;
-}
-/** OpenAI function-tool wire shape for an `EvalToolDef`. */
-declare function toOpenAiTool(def: EvalToolDef): {
-  type: 'function';
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-};
-/**
- * Build the eval toolset for the supplied config. Only sections present in
- * `cfg` produce tools, so the agent's tool list mirrors what the host
- * actually wired. Handlers fail loud on malformed args — no silent defaults.
- */
-declare function makeEvalTools(cfg: MakeEvalToolsConfig): EvalToolDef[];
-//#endregion
-//#region src/trace-analyst/tools.d.ts
-declare const TRACE_ANALYST_TOOL_NAMESPACE: 'traces';
-interface BuildTraceAnalysisToolsOptions extends BoundedTraceAnalysisStoreOptions {
-  store: TraceAnalysisStore;
-}
-interface TraceAnalysisToolDescriptor extends EvalToolDef {
-  namespace: typeof TRACE_ANALYST_TOOL_NAMESPACE;
-}
-/** Bind all seven trace reads without exposing an agent framework type. */
-declare function buildTraceAnalysisToolDescriptors(options: BuildTraceAnalysisToolsOptions): TraceAnalysisToolDescriptor[];
-/** Adapt the canonical descriptors into Ax functions used by the built-in analyst. */
-declare function buildTraceAnalystTools(options: BuildTraceAnalysisToolsOptions): AxFunction[];
-declare function traceAnalystFunctionGroup(options: BuildTraceAnalysisToolsOptions): {
-  namespace: string;
-  title: string;
-  selectionCriteria: string;
-  description: string;
-  functions: AxFunction[];
-};
-//#endregion
 //#region src/replay.d.ts
 declare class ReplayCacheMissError extends ReplayError {
   readonly url: string;
@@ -938,5 +829,5 @@ declare function iterateRawCalls(sink: RawProviderSink, filter?: {
   spanId?: string;
 }): AsyncGenerator<ReplayCacheEntry>;
 //#endregion
-export { buildTraceInsightContext as $, otlpRowsToTraceRunRecords as A, RedactionReport as At, stringField as B, OtlpSpanRole as Bt, otlpTextToTraceAnalysisStore as C, createBoundedTraceAnalysisStore as Ct, OtlpTraceRunRecord as D, convertTraceStoresToOtlp as Dt, OtlpToRunRecordsOptions as E, TracesToOtlpResult as Et, extractOtlpAttributes as F, otelRunCompleteHook as Ft, TraceInsightFinding as G, isOtlpModelCall as Gt, flattenOtlpExportToNdjson as H, ToolSpanOtlpInput as Ht, firstStringAttr as I, ExportableSpan as It, TraceInsightQualityGate as J, OtlpExport as Jt, TraceInsightPanelRole as K, traceSpanKindToOpenInferenceKind as Kt, inferOtlpKind as L, OtelExportConfig as Lt, otlpToTraceRunRecords as M, redactString as Mt, ProjectedOtlpSpan as N, redactValue as Nt, TraceAggregate as O, DEFAULT_REDACTION_RULES as Ot, asString as P, createOtelTracingStore as Pt, TraceInsightTask as Q, projectOtlpFlatLine as R, OtelExporter as Rt, ToolSpansToTraceAnalysisStoreOptions as S, analyzeTraces as St, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as T, TraceStoreToOtlpOptions as Tt, OtlpFlatLine as U, applyToolSpanOtlpAttributes as Ut, FlattenOtlpOptions as V, OtlpSpanRoleInput as Vt, TraceInsightContext as W, classifyOtlpSpanRole as Wt, TraceInsightReadiness as X, OtlpSpan as Xt, TraceInsightQuestion as Y, OtlpResourceSpans as Yt, TraceInsightSuite as Z, exportRunAsOtlp as Zt, toOpenAiTool as _, TraceNotFoundError as _t, ReplayFetchOptions as a, planTraceInsightQuestions as at, OtlpFileTraceStore as b, AnalyzeTracesResult as bt, BuildTraceAnalysisToolsOptions as c, TraceAnalystHookOptions as ct, buildTraceAnalysisToolDescriptors as d, TraceAnalysisLimitError as dt, buildTraceInsightPrompt as et, buildTraceAnalystTools as f, TraceAnalysisStoreContractError as ft, makeEvalTools as g, TraceFileTooLargeError as gt, MakeEvalToolsConfig as h, TraceFileMissingError as ht, ReplayCacheStats as i, inferDomainKeywords as it, otlpToRunRecords as j, RedactionRule as jt, otlpRowsToRunRecords as k, REDACTION_VERSION as kt, TRACE_ANALYST_TOOL_NAMESPACE as l, traceAnalystOnRunComplete as lt, EvalToolDef as m, TraceFileMalformedError as mt, ReplayCacheEntry as n, describeTraceInsightScope as nt, createReplayFetch as o, scoreTraceInsightReadiness as ot, traceAnalystFunctionGroup as p, TraceAnalysisValidationError as pt, TraceInsightPromptInput as q, OTEL_AGENT_EVAL_SCOPE as qt, ReplayCacheMissError as r, domainEvidencePattern as rt, iterateRawCalls as s, tokenizeDomainWords as st, ReplayCache as t, defaultTraceInsightPanel as tt, TraceAnalysisToolDescriptor as u, SpanNotFoundError as ut, ToolTraceMissingError as v, AnalyzeTracesInput as vt, TRACE_ANALYST_ACTOR_DESCRIPTION as w, TraceStoreSource as wt, OtlpFileTraceStoreOptions as x, AnalyzeTracesTurnSnapshot as xt, toolSpansToTraceAnalysisStore as y, AnalyzeTracesOptions as yt, readOtlpStatus as z, createOtelExporter as zt };
-//# sourceMappingURL=replay-DbIYwso6.d.ts.map
+export { traceAnalystOnRunComplete as $, stringField as A, OtlpSpanRoleInput as At, TraceInsightReadiness as B, exportRunAsOtlp as Bt, ProjectedOtlpSpan as C, createOtelTracingStore as Ct, inferOtlpKind as D, OtelExporter as Dt, firstStringAttr as E, OtelExportConfig as Et, TraceInsightFinding as F, traceSpanKindToOpenInferenceKind as Ft, defaultTraceInsightPanel as G, TraceInsightTask as H, TraceInsightPanelRole as I, OTEL_AGENT_EVAL_SCOPE as It, inferDomainKeywords as J, describeTraceInsightScope as K, TraceInsightPromptInput as L, OtlpExport as Lt, flattenOtlpExportToNdjson as M, applyToolSpanOtlpAttributes as Mt, OtlpFlatLine as N, classifyOtlpSpanRole as Nt, projectOtlpFlatLine as O, createOtelExporter as Ot, TraceInsightContext as P, isOtlpModelCall as Pt, TraceAnalystHookOptions as Q, TraceInsightQualityGate as R, OtlpResourceSpans as Rt, otlpToTraceRunRecords as S, redactValue as St, extractOtlpAttributes as T, ExportableSpan as Tt, buildTraceInsightContext as U, TraceInsightSuite as V, buildTraceInsightPrompt as W, scoreTraceInsightReadiness as X, planTraceInsightQuestions as Y, tokenizeDomainWords as Z, OtlpTraceRunRecord as _, DEFAULT_REDACTION_RULES as _t, ReplayFetchOptions as a, TraceFileMissingError as at, otlpRowsToTraceRunRecords as b, RedactionRule as bt, ToolTraceMissingError as c, AnalyzeTracesInput as ct, OtlpFileTraceStoreOptions as d, analyzeTraces as dt, SpanNotFoundError as et, ToolSpansToTraceAnalysisStoreOptions as f, createBoundedTraceAnalysisStore as ft, OtlpToRunRecordsOptions as g, convertTraceStoresToOtlp as gt, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as h, TracesToOtlpResult as ht, ReplayCacheStats as i, TraceFileMalformedError as it, FlattenOtlpOptions as j, ToolSpanOtlpInput as jt, readOtlpStatus as k, OtlpSpanRole as kt, toolSpansToTraceAnalysisStore as l, AnalyzeTracesOptions as lt, TRACE_ANALYST_ACTOR_DESCRIPTION as m, TraceStoreToOtlpOptions as mt, ReplayCacheEntry as n, TraceAnalysisStoreContractError as nt, createReplayFetch as o, TraceFileTooLargeError as ot, otlpTextToTraceAnalysisStore as p, TraceStoreSource as pt, domainEvidencePattern as q, ReplayCacheMissError as r, TraceAnalysisValidationError as rt, iterateRawCalls as s, TraceNotFoundError as st, ReplayCache as t, TraceAnalysisLimitError as tt, OtlpFileTraceStore as u, AnalyzeTracesResult as ut, TraceAggregate as v, REDACTION_VERSION as vt, asString as w, otelRunCompleteHook as wt, otlpToRunRecords as x, redactString as xt, otlpRowsToRunRecords as y, RedactionReport as yt, TraceInsightQuestion as z, OtlpSpan as zt };
+//# sourceMappingURL=replay-DjG4IG60.d.ts.map

package/dist/replay-DjG4IG60.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-DjG4IG60.d.ts","names":[],"sources":["../src/trace/otel.ts","../src/trace/otlp-attributes.ts","../src/trace/otel-export.ts","../src/trace/otel-bridge.ts","../src/trace/redact.ts","../src/trace/store-to-otlp.ts","../src/trace-analyst/store-boundary.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/errors.ts","../src/trace-analyst/hook.ts","../src/trace-analyst/insights.ts","../src/trace/otlp-flat.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","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts","../src/replay.ts"],"mappings":"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"}

package/dist/{replay-Cb-4Vf0k.js → replay-SA4OB7O7.js}

@@ -2,158 +2,69 @@ import { n as CaptureIntegrityError, s as ReplayError } from "./errors-D-LKuDhb.
 import { h as hashJson, p as canonicalize } from "./agent-profile-cell-CbfBm2g6.js";
 import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-BQd7mzyT.js";
 import { LLM_INPUT_TOKENS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, OPENINFERENCE_SPAN_KIND, TOOL_NAME, applyLlmSpanOtlpAttributes } from "./trace-attributes.js";
-import { A as classifyOtlpSpanRole, C as firstStringAttr, D as spanEpochMillis, M as traceSpanKindToOpenInferenceKind, T as projectOtlpFlatLine, j as isOtlpModelCall, k as applyToolSpanOtlpAttributes, n as OtlpFileTraceStore, r as createOtlpBufferTraceStore, x as compareSpanTime } from "./store-otlp-BenKynPE.js";
-import { a as runTraceAnalysisLoop, r as buildTraceAnalystTools } from "./tools-DZGdROtG.js";
+import { $ as spanEpochMillis, Y as firstStringAttr, Z as projectOtlpFlatLine, i as runTraceAnalyst, it as traceSpanKindToOpenInferenceKind, nt as classifyOtlpSpanRole, q as compareSpanTime, rt as isOtlpModelCall, tt as applyToolSpanOtlpAttributes } from "./kind-factory-CFxA0JQX.js";
 import { s as validateRunRecord } from "./run-record-vRgqWmJw.js";
-import { a as recordAggregateMeasurements, i as readTaskFailureLabels, o as summarizeExecutionMeasurements, r as extractUsageFromSse, s as summarizeTraceErrors, t as extractUsage } from "./extract-usage-CS391dOE.js";
+import { n as OtlpFileTraceStore, r as createOtlpBufferTraceStore } from "./store-otlp-DX4fGIcf.js";
+import { a as recordAggregateMeasurements, i as readTaskFailureLabels, o as summarizeExecutionMeasurements, r as extractUsageFromSse, s as summarizeTraceErrors, t as extractUsage } from "./extract-usage-DZs601Va.js";
 import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
 //#region src/trace-analyst/prompts.ts
-/** Ax RLM prompt for bounded trace discovery and evidence-backed analysis. */
-const TRACE_ANALYST_ACTOR_DESCRIPTION = `You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the \`traces\` namespace.
+/** General policy for recursive, evidence-backed trace analysis. */
+const TRACE_ANALYST_ACTOR_DESCRIPTION = `Answer the question by inspecting the OTLP trace dataset with the available tools.
 
-DISCOVERY → NARROW → DEEP-READ protocol — follow exactly:
+1. Call getDatasetOverview first. Use its real trace ids and dataset size to plan the investigation.
+2. Narrow with queryTraces and countTraces before scanning large payloads.
+3. For a small trace, use viewTrace. For a large trace, use searchTrace and then viewSpans or searchSpan.
+4. Never invent a trace id, span id, tool result, error, frequency, or final outcome.
+5. When a search reports has_more, refine the query before drawing a conclusion.
+6. Use llm_query only over evidence already loaded. A recursive query cannot inspect traces itself.
+7. Cite exact evidence URIs returned by the tools. Include a short exact excerpt when it supports the claim.
+8. Return no finding when the available evidence cannot support one.
 
-1. ALWAYS call \`traces.getDatasetOverview({})\` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids — never fabricate one).
-
-2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. \`filters.regex_pattern\` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces — narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.
-
-3. To list more traces than the sample, call \`traces.queryTraces({ filters?, limit, offset? })\`. Each summary carries raw_jsonl_bytes — use it to choose between viewTrace and searchTrace BEFORE calling either.
-
-4. Per-trace inspection:
-   - SMALL trace (raw_jsonl_bytes well under 150_000): call \`traces.viewTrace({ trace_id })\`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large \`input.value\` / \`output.value\` / \`llm.input_messages\` will show a \`[trace-analyst truncated: N bytes]\` marker.
-   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an \`oversized\` response): use \`traces.searchTrace({ trace_id, regex_pattern })\` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call \`traces.viewSpans({ trace_id, span_ids: [...] })\` for surgical reads (~16KB cap, 4× higher than discovery), or \`traces.searchSpan({ trace_id, span_id, regex_pattern })\` for one large span. Stays bounded regardless of trace size.
-   - Useful regex patterns: \`STATUS_CODE_ERROR\` (failures), tool names like \`grep\` or \`view_trace\`, error strings like \`MaxTurnsExceeded\`, model names, attribute keys.
-
-5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.
-
-5a. **Result-shape contract** — searchTrace and searchSpan return \`{ trace_id, hits, has_more }\`. Iterate \`result.hits\` (NOT result.matches). Each hit has \`{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }\`. viewTrace returns \`{ trace_id, spans }\` (or \`oversized\`). viewSpans returns \`{ trace_id, spans, missing_span_ids, omitted_span_ids, has_more, truncated_attribute_count }\`; retry only \`omitted_span_ids\`. Never assume a field name — log the result shape first if unsure.
-
-6. If viewTrace returns an \`oversized\` summary instead of \`spans\`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.
-
-7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.
-
-8. If a tool errors (invalid regex, range error), STOP and reconsider — don't retry with a guessed id or argument. Use the discovery tools above to recover.
-
-9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.
-
-10. If the question splits into independent reasoning branches, use bounded \`llmQuery(...)\` calls over evidence you already loaded. Subqueries cannot inspect the trace store, so pass the exact trace excerpts they need. Example:
-
-    const reviews = await llmQuery([
-      { query: 'Classify the failure mechanism in this excerpt.', context: traceAbcExcerpt },
-      { query: 'Classify the failure mechanism in this excerpt.', context: traceDefExcerpt },
-    ]);
-
-OBSERVABILITY rules:
-- Each discovery turn must emit at least one concise \`console.log(...)\` showing what evidence was learned.
-- Finish gathering evidence before submitting the analysis.
-- Reuse runtime variables across turns; don't recompute.
-
-OUTPUT contract — your final answer must include:
-- A clear prose conclusion answering the user's question.
-- Trace ids and span ids cited as evidence for each claim.
-- Failure modes named in the user's domain language, with frequency and concrete examples.
-- A concise findings array containing only claims supported by inspected evidence.
-
-Do NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.`;
-const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v6-2026-07-14";
+The prose answer must directly answer the question and state important uncertainty.
+The findings array contains only actionable or decision-relevant claims supported by inspected evidence.`;
+const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-research-v1-2026-07-30";
 //#endregion
 //#region src/trace-analyst/analyst.ts
 /**
-* Run the trace analyst.
+* Answer one question by recursively inspecting a trace store.
 *
-* Throws:
-*   - `TraceFileMissingError` if `source` is a path and doesn't exist.
-*   - `AxAgentClarificationError` if the analyst asks for clarification.
-*   - Provider errors (auth, rate limits) propagate from the AI service.
+* The returned answer, cited findings, engine steps, call counts, and runtime
+* identity are one audit record. A direct one-shot model call is not used.
 */
 async function analyzeTraces(input, options) {
-	if (!input.question || typeof input.question !== "string") throw new TypeError("analyzeTraces: input.question must be a non-empty string");
-	rejectRemovedOptions(options);
+	if (typeof input.question !== "string" || !input.question.trim()) throw new TypeError("analyzeTraces: input.question must be a non-empty string");
+	const id = input.id?.trim() || "trace-analysis";
 	const store = typeof options.source === "string" ? new OtlpFileTraceStore({ path: options.source }) : options.source;
 	if (store instanceof OtlpFileTraceStore) await store.ensureIndexed(options.signal ? { signal: options.signal } : void 0);
-	const tools = buildTraceAnalystTools({ store });
-	const turns = [];
-	let progressFs;
-	if (options.progressLogPath) {
-		const { createWriteStream } = await import("node:fs");
-		const { mkdir } = await import("node:fs/promises");
-		const { dirname } = await import("node:path");
-		await mkdir(dirname(options.progressLogPath), { recursive: true });
-		progressFs = createWriteStream(options.progressLogPath, { flags: "a" });
-	}
-	const actorTurnCallback = async (turn) => {
-		const snap = {
-			stage: turn.stage,
-			turn: turn.turn,
-			isError: turn.isError,
-			code: turn.code,
-			output: turn.output,
-			thought: turn.thought
-		};
-		turns.push(snap);
-		if (progressFs) try {
-			progressFs.write(`${JSON.stringify({
-				...snap,
-				ts: Date.now()
-			})}\n`);
-		} catch {}
-		if (options.onTurn) await options.onTurn(snap);
-	};
-	const maxSubqueries = options.maxSubqueries ?? 4;
-	const maxTurns = options.maxTurns ?? 12;
-	const maxParallelSubqueries = options.maxParallelSubqueries ?? 2;
-	const maxRuntimeChars = options.maxRuntimeChars ?? 6e3;
-	let completed;
-	try {
-		completed = await runTraceAnalysisLoop({
-			id: "TraceAnalyst",
-			description: "Analyzes OTLP-shaped JSONL traces using bounded discovery tools to identify systemic failure modes.",
-			prompt: `${options.actorDescription ?? TRACE_ANALYST_ACTOR_DESCRIPTION}
-
-The report must answer the user's question, and findings must be an array of concise evidence-backed strings.`,
+	return runTraceAnalyst({
+		definition: {
+			id,
+			description: input.description?.trim() || "Answers a caller-defined question by recursively inspecting trace evidence.",
+			area: input.area?.trim() || "trace-analysis",
+			version: TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
 			question: input.question,
-			ai: options.ai,
-			...options.model ? { model: options.model } : {},
-			tools,
-			findingType: "string",
-			maxSubqueries,
-			maxParallelSubqueries,
-			maxTurns,
-			maxRuntimeChars,
-			...options.signal ? { signal: options.signal } : {},
-			onTurn: actorTurnCallback
-		});
-	} finally {
-		if (progressFs) await new Promise((resolve) => progressFs.end(() => resolve()));
-	}
-	return {
-		answer: completed.report,
-		findings: completed.findings,
-		turns,
-		turnCount: turns.length,
-		usage: {
-			actor: normalizeRecordArray(completed.usage.actor),
-			responder: normalizeRecordArray(completed.usage.responder)
-		},
-		chatLog: {
-			actor: normalizeRecordArray(completed.chatLog.actor),
-			responder: normalizeRecordArray(completed.chatLog.responder)
+			instructions: options.instructions ?? TRACE_ANALYST_ACTOR_DESCRIPTION,
+			toolGroup: options.toolGroup ?? "all",
+			limits: options.limits
 		},
-		actorPromptVersion: TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION
-	};
-}
-function rejectRemovedOptions(options) {
-	const supplied = options;
-	for (const [removed, replacement] of [
-		["maxDepth", "maxSubqueries"],
-		["maxParallelSubagents", "maxParallelSubqueries"],
-		["subagentDescription", "actorDescription"]
-	]) if (removed in supplied) throw new TypeError(`analyzeTraces: '${removed}' is unsupported; use '${replacement}'`);
-}
-function normalizeRecordArray(value) {
-	if (!Array.isArray(value)) return [];
-	return value.map((item) => item && typeof item === "object" ? { ...item } : { value: item });
+		engine: options.engine,
+		store,
+		context: {
+			runId: options.runId ?? id,
+			correlationId: randomUUID(),
+			budgetUsd: options.budgetUsd,
+			costLedger: options.costLedger,
+			costPhase: options.costPhase ?? "trace-analysis",
+			priorFindings: options.priorFindings,
+			upstreamFindings: options.upstreamFindings,
+			recordUsage: options.recordUsage,
+			tags: options.tags,
+			log: options.log,
+			signal: options.signal
+		}
+	});
 }
 //#endregion
 //#region src/trace-analyst/hook.ts
@@ -1960,4 +1871,4 @@ async function keyFromBody(body) {
 //#endregion
 export { TRACE_ANALYST_ACTOR_DESCRIPTION as A, domainEvidencePattern as C, tokenizeDomainWords as D, scoreTraceInsightReadiness as E, traceAnalystOnRunComplete as O, describeTraceInsightScope as S, planTraceInsightQuestions as T, otlpToTraceRunRecords as _, convertTraceStoresToOtlp as a, buildTraceInsightPrompt as b, otelRunCompleteHook as c, captureFetchToRawSink as d, ToolTraceMissingError as f, otlpToRunRecords as g, otlpRowsToTraceRunRecords as h, iterateRawCalls as i, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as j, analyzeTraces as k, OTEL_AGENT_EVAL_SCOPE as l, otlpRowsToRunRecords as m, ReplayCacheMissError as n, createOtelExporter as o, toolSpansToTraceAnalysisStore as p, createReplayFetch as r, createOtelTracingStore as s, ReplayCache as t, exportRunAsOtlp as u, flattenOtlpExportToNdjson as v, inferDomainKeywords as w, defaultTraceInsightPanel as x, buildTraceInsightContext as y };
 
-//# sourceMappingURL=replay-Cb-4Vf0k.js.map
+//# sourceMappingURL=replay-SA4OB7O7.js.map