@tangle-network/agent-eval 0.94.0 → 0.95.0

package/dist/trace-analyst/store-otlp.d.ts

@@ -0,0 +1,126 @@
+/**
+ * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the
+ * trace-analyst.
+ *
+ * Wire shape. Each line of the input file is one OTLP-shaped span. The
+ * store understands flattened OTLP JSONL plus the OpenInference vocab.
+ * We project upstream's full
+ * span shape down to `TraceAnalystSpan` lazily — full materialisation
+ * only happens for the spans the agent actually requests.
+ *
+ * Indexing. On first read the store builds an in-memory index keyed
+ * by `trace_id` carrying:
+ *   - byte offsets + lengths for each span line (for surgical reads
+ *     without re-parsing the whole file)
+ *   - a `TraceAnalystTraceSummary` rollup
+ *   - sets of services / agents / models / tools / has_errors
+ *   - byte size of the trace's JSONL slab
+ *
+ * Memory bound. The index keeps span metadata only — names, kinds,
+ * offsets, status. Attribute payloads stay on disk until requested.
+ * For a 50MB JSONL with 50k spans, the index is ~5MB.
+ *
+ * Concurrency. The store builds the index once on first read and
+ * caches it. Subsequent reads reuse the index. The file is opened on
+ * each read; we never hold a long-lived FD.
+ */
+import { NotFoundError } from '../errors';
+import { type TraceAnalysisStore } from './store';
+import { type DatasetOverview, type QueryTracesPage, type SearchSpanResult, type SearchTraceResult, type TraceAnalystFilters, type ViewSpansResult, type ViewTraceResult } from './types';
+export interface OtlpFileTraceStoreOptions {
+    /** Path to the OTLP-JSONL file. */
+    path: string;
+    /** Override the discovery (`viewTrace`) per-attribute byte cap. */
+    perAttributeViewBudget?: number;
+    /** Override the surgical (`viewSpans`) per-attribute byte cap. */
+    perAttributeSpanBudget?: number;
+    /** Override the per-call ceiling that triggers oversized summaries. */
+    perCallByteCeiling?: number;
+    /** Override the per-match text budget. */
+    perMatchTextBudget?: number;
+    /**
+     * Hard ceiling on the trace file size in bytes. The store reads the
+     * whole file into one Buffer and indexes it in memory, so an
+     * unbounded file OOMs the process. Above this size the store fails
+     * loud with `TraceFileTooLargeError` instead of degrading silently.
+     * Default 256 MiB.
+     */
+    maxFileBytes?: number;
+}
+/** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */
+export declare const DEFAULT_MAX_TRACE_FILE_BYTES: number;
+export declare class OtlpFileTraceStore implements TraceAnalysisStore {
+    private readonly path;
+    private readonly perAttributeViewBudget;
+    private readonly perAttributeSpanBudget;
+    private readonly perCallByteCeiling;
+    private readonly perMatchTextBudget;
+    private readonly maxFileBytes;
+    private indexPromise?;
+    /** Cached UTF-8 buffer of the file. We pin it once because every
+     *  read needs slice access and re-reading on each call balloons the
+     *  syscall count. */
+    private bufferPromise?;
+    constructor(opts: OtlpFileTraceStoreOptions);
+    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
+    queryTraces(opts: {
+        filters?: TraceAnalystFilters;
+        limit: number;
+        offset?: number;
+    }): Promise<QueryTracesPage>;
+    countTraces(filters?: TraceAnalystFilters): Promise<number>;
+    viewTrace(opts: {
+        trace_id: string;
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewTraceResult>;
+    viewSpans(opts: {
+        trace_id: string;
+        span_ids: readonly string[];
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewSpansResult>;
+    searchTrace(opts: {
+        trace_id: string;
+        regex_pattern: string;
+        max_matches?: number;
+    }): Promise<SearchTraceResult>;
+    searchSpan(opts: {
+        trace_id: string;
+        span_id: string;
+        regex_pattern: string;
+        max_matches?: number;
+    }): Promise<SearchSpanResult>;
+    /** Force the index to materialise. Useful to amortise startup cost
+     *  before the first agent call. */
+    ensureIndexed(): Promise<void>;
+    private buffer;
+    /** Stat-then-read so an oversized file fails loud BEFORE we allocate a
+     *  multi-hundred-MB Buffer and OOM the process. A missing file surfaces
+     *  as TraceFileMissingError; any other stat/read error propagates. */
+    private readGuarded;
+    private index;
+    private buildIndex;
+    private matchedTraces;
+    private toSummary;
+    private projectSpan;
+    private buildOversizedSummary;
+    private scanSpanForMatches;
+}
+export declare class TraceFileMissingError extends NotFoundError {
+    constructor(path: string);
+}
+export declare class TraceFileTooLargeError extends Error {
+    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 trace_id: string;
+    constructor(trace_id: string);
+}
+export declare class SpanNotFoundError extends NotFoundError {
+    readonly trace_id: string;
+    readonly span_id: string;
+    constructor(trace_id: string, span_id: string);
+}
+//# sourceMappingURL=store-otlp.d.ts.map

package/dist/trace-analyst/store-otlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-otlp.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/store-otlp.ts"],"names":[],"mappings":"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"}

package/dist/trace-analyst/store-otlp.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for `OtlpFileTraceStore`.
+ *
+ * Each test names the regression it would catch — no `.toBeDefined()`
+ * filler. Real fixtures, real file IO, no mocks.
+ */
+export {};
+//# sourceMappingURL=store-otlp.test.d.ts.map

package/dist/trace-analyst/store-otlp.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-otlp.test.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/store-otlp.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/trace-analyst/store-otlp.timestamps.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=store-otlp.timestamps.test.d.ts.map

package/dist/trace-analyst/store-otlp.timestamps.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-otlp.timestamps.test.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/store-otlp.timestamps.test.ts"],"names":[],"mappings":""}

package/dist/trace-analyst/store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `TraceAnalysisStore` — read-side interface the trace-analyst calls
+ * through. Six operations, all bounded:
+ *
+ *   - `getOverview(filters?)` — dataset rollup + sample trace ids.
+ *   - `queryTraces(filters?, limit, offset)` — paginated summaries.
+ *   - `countTraces(filters?)` — cheap count without materialisation.
+ *   - `viewTrace(trace_id, perAttrCap)` — full span list, oversized → summary.
+ *   - `viewSpans(trace_id, span_ids, perAttrCap)` — surgical span fetch.
+ *   - `searchTrace(trace_id, regex, max_matches)` — bounded regex hits.
+ *   - `searchSpan(trace_id, span_id, regex, max_matches)` — single-span search.
+ *
+ * Multiple implementations ship in the core (`OtlpFileTraceStore`).
+ * Downstream callers can supply their own — e.g. a DuckDB-backed
+ * adapter or an in-memory adapter for tests — by implementing this
+ * interface.
+ *
+ * Filters compose with AND semantics. Empty/undefined fields impose
+ * no constraint. `regex_pattern` is the only opt-in raw-bytes scan —
+ * implementations may skip it via `count`/`overview` when not set.
+ */
+import type { DatasetOverview, QueryTracesPage, SearchSpanResult, SearchTraceResult, TraceAnalystFilters, ViewSpansResult, ViewTraceResult } from './types';
+export interface TraceAnalysisStore {
+    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
+    queryTraces(opts: {
+        filters?: TraceAnalystFilters;
+        limit: number;
+        offset?: number;
+    }): Promise<QueryTracesPage>;
+    countTraces(filters?: TraceAnalystFilters): Promise<number>;
+    viewTrace(opts: {
+        trace_id: string;
+        /** Override per-attribute byte cap. Defaults to discovery budget. */
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewTraceResult>;
+    viewSpans(opts: {
+        trace_id: string;
+        span_ids: readonly string[];
+        /** Override per-attribute byte cap. Defaults to surgical budget. */
+        per_attribute_byte_cap?: number;
+    }): Promise<ViewSpansResult>;
+    searchTrace(opts: {
+        trace_id: string;
+        regex_pattern: string;
+        /** Hard cap on matches returned. Default 50. */
+        max_matches?: number;
+    }): Promise<SearchTraceResult>;
+    searchSpan(opts: {
+        trace_id: string;
+        span_id: string;
+        regex_pattern: string;
+        max_matches?: number;
+    }): Promise<SearchSpanResult>;
+}
+/** Compile a regex with the same anchoring + flags semantics across
+ *  implementations. Throws on invalid pattern — callers should surface
+ *  that to the agent so it can refine instead of looping. */
+export declare function compileSearchRegex(pattern: string): RegExp;
+/** Truncate string payload deterministically for tool responses.
+ *  Marker is parseable so downstream consumers can detect truncation
+ *  and decide whether to fetch surgically. */
+export declare function truncateForBudget(value: string, byteCap: number): string;
+//# sourceMappingURL=store.d.ts.map

package/dist/trace-analyst/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,eAAe,EAChB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAEpE,WAAW,CAAC,IAAI,EAAE;QAChB,OAAO,CAAC,EAAE,mBAAmB,CAAA;QAC7B,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAE5B,WAAW,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE3D,SAAS,CAAC,IAAI,EAAE;QACd,QAAQ,EAAE,MAAM,CAAA;QAChB,qEAAqE;QACrE,sBAAsB,CAAC,EAAE,MAAM,CAAA;KAChC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAE5B,SAAS,CAAC,IAAI,EAAE;QACd,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;QAC3B,oEAAoE;QACpE,sBAAsB,CAAC,EAAE,MAAM,CAAA;KAChC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAE5B,WAAW,CAAC,IAAI,EAAE;QAChB,QAAQ,EAAE,MAAM,CAAA;QAChB,aAAa,EAAE,MAAM,CAAA;QACrB,gDAAgD;QAChD,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;IAE9B,UAAU,CAAC,IAAI,EAAE;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;QACf,aAAa,EAAE,MAAM,CAAA;QACrB,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAC9B;AAED;;6DAE6D;AAC7D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED;;8CAE8C;AAC9C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAexE"}

package/dist/trace-analyst/tools.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Trace-analyst tool surface — six namespaced AxFunctions the analyst
+ * agent calls from generated JS code via `traces.<name>(...)`.
+ *
+ * Discovery → narrow → deep-read protocol. Tool names + ordering
+ * support RLM discovery:
+ *
+ *   1. `getDatasetOverview` (cheap)  — first call, sizes the dataset
+ *   2. `queryTraces`                 — paginated summaries with `raw_jsonl_bytes`
+ *   3. `countTraces`                 — cheap pre-flight before regex
+ *   4. `viewTrace`                   — full span list, oversized → summary
+ *   5. `viewSpans`                   — surgical 16KB-cap reads
+ *   6. `searchTrace` / `searchSpan`  — bounded regex hits
+ *
+ * Failure mode. Tool handlers throw on bad input (invalid trace ids,
+ * out-of-range pagination, malformed regex). Ax converts thrown errors
+ * into actor-visible `[ERROR]` strings so the analyst can adjust on
+ * the next turn instead of looping.
+ */
+import type { AxFunction } from '@ax-llm/ax';
+import type { TraceAnalysisStore } from './store';
+interface BuildTraceAnalystToolsOpts {
+    store: TraceAnalysisStore;
+    /** Override the default sample-trace-id slot count (20). Mostly for tests. */
+    sampleTraceLimit?: number;
+}
+/**
+ * Build the trace-analyst function set. Pass the result into
+ * `agent(...).functions.local`.
+ */
+export declare function buildTraceAnalystTools(opts: BuildTraceAnalystToolsOpts): AxFunction[];
+/**
+ * Convenience: same shape as `buildTraceAnalystTools` but returns the
+ * grouped form expected when registering trace tools alongside other
+ * agent function modules. */
+export declare function traceAnalystFunctionGroup(opts: BuildTraceAnalystToolsOpts): {
+    namespace: string;
+    title: string;
+    selectionCriteria: string;
+    description: string;
+    functions: AxFunction[];
+};
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/trace-analyst/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAKjD,UAAU,0BAA0B;IAClC,KAAK,EAAE,kBAAkB,CAAA;IACzB,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,0BAA0B,GAAG,UAAU,EAAE,CAyIrF;AAED;;;6BAG6B;AAC7B,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,0BAA0B,GAAG;IAC3E,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,UAAU,EAAE,CAAA;CACxB,CAUA"}

package/dist/trace-analyst/tools.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for the AxFunction adapter layer in `tools.ts`. We don't run
+ * a full agent here — we exercise the runtime guards on bad inputs
+ * and confirm the namespace + function-set shape is what AxAgent
+ * expects.
+ *
+ * Each test names the regression it would catch.
+ */
+export {};
+//# sourceMappingURL=tools.test.d.ts.map

package/dist/trace-analyst/tools.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.test.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/tools.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/{store-C1YxJDEK.d.ts → trace-analyst/types.d.ts}

@@ -13,12 +13,12 @@
  * `ViewTraceOversized`.
  */
 /** OTLP span kind (subset we actually use). */
-type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
-type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
+export type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
+export type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
 /** Subset of OTLP span fields the analyst exposes to the agent. The
  *  store's job is to project upstream's full span shape down to this
  *  view — the analyst never sees vendor extensions directly. */
-interface TraceAnalystSpan {
+export interface TraceAnalystSpan {
     trace_id: string;
     span_id: string;
     parent_span_id: string | null;
@@ -37,7 +37,7 @@ interface TraceAnalystSpan {
      *  callers must respect the per-attribute byte cap. */
     attributes: Record<string, unknown>;
 }
-interface TraceAnalystTraceSummary {
+export interface TraceAnalystTraceSummary {
     trace_id: string;
     service_name: string | null;
     agent_name: string | null;
@@ -50,7 +50,7 @@ interface TraceAnalystTraceSummary {
     models: string[];
     tools: string[];
 }
-interface TraceAnalystFilters {
+export interface TraceAnalystFilters {
     /** Restrict to traces that contain at least one error span. */
     has_errors?: boolean;
     /** Match if any span's `service.name` is in this list. */
@@ -74,7 +74,7 @@ interface TraceAnalystFilters {
  *  paths, durations) out of the span `status_message` so semantically identical
  *  failures collapse into one cluster. An analyst that accounts for every
  *  cluster has, by construction, covered every distinct failure mode. */
-interface ErrorCluster {
+export interface ErrorCluster {
     /** Normalized status_message — the cluster key. */
     signature: string;
     /** A verbatim, un-normalized exemplar message (for exact-string citation). */
@@ -92,7 +92,7 @@ interface ErrorCluster {
     /** Real span ids carrying this signature (capped). */
     exemplar_span_ids: string[];
 }
-interface DatasetOverview {
+export interface DatasetOverview {
     total_traces: number;
     raw_jsonl_bytes: number;
     services: string[];
@@ -115,7 +115,7 @@ interface DatasetOverview {
         latest: string;
     } | null;
 }
-interface QueryTracesPage {
+export interface QueryTracesPage {
     traces: TraceAnalystTraceSummary[];
     total: number;
     has_more: boolean;
@@ -123,12 +123,12 @@ interface QueryTracesPage {
 /** Full-trace view. When the response would exceed the per-call byte
  *  budget, `oversized` is populated INSTEAD of `spans` so the agent
  *  knows to switch to `searchTrace` / `viewSpans`. */
-interface ViewTraceResult {
+export interface ViewTraceResult {
     trace_id: string;
     spans?: TraceAnalystSpan[];
     oversized?: ViewTraceOversized;
 }
-interface ViewTraceOversized {
+export interface ViewTraceOversized {
     span_count: number;
     /** Names with their counts, sorted desc. Capped at 20 entries. */
     top_span_names: Array<[string, number]>;
@@ -136,7 +136,7 @@ interface ViewTraceOversized {
     span_response_bytes_max: number;
     error_span_count: number;
 }
-interface ViewSpansResult {
+export interface ViewSpansResult {
     trace_id: string;
     spans: TraceAnalystSpan[];
     /** Number of requested span ids that were not found in the trace. */
@@ -144,7 +144,7 @@ interface ViewSpansResult {
     /** Number of attribute fields truncated to fit the per-attribute cap. */
     truncated_attribute_count: number;
 }
-interface SpanMatchRecord {
+export interface SpanMatchRecord {
     trace_id: string;
     span_id: string;
     span_name: string;
@@ -157,13 +157,13 @@ interface SpanMatchRecord {
     context_after: string;
     match_offset: number;
 }
-interface SearchTraceResult {
+export interface SearchTraceResult {
     trace_id: string;
     hits: SpanMatchRecord[];
     total_matches: number;
     has_more: boolean;
 }
-interface SearchSpanResult {
+export interface SearchSpanResult {
     trace_id: string;
     span_id: string;
     hits: SpanMatchRecord[];
@@ -171,7 +171,7 @@ interface SearchSpanResult {
     has_more: boolean;
 }
 /** Tunable byte budgets for bounded RLM tool output. */
-interface TraceAnalystByteBudgets {
+export interface TraceAnalystByteBudgets {
     /** Max bytes any single tool response may emit. Hard ceiling enforced
      *  by the store; oversized → summary. Default 150_000. */
     perCallByteCeiling: number;
@@ -185,64 +185,8 @@ interface TraceAnalystByteBudgets {
      *  context window. Default 1024. */
     perMatchTextBudget: number;
 }
-declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
+export declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
 /** Marker substituted in place of truncated string payloads. Callers
  *  parsing tool output can detect it deterministically. */
-declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
-
-/**
- * `TraceAnalysisStore` — read-side interface the trace-analyst calls
- * through. Six operations, all bounded:
- *
- *   - `getOverview(filters?)` — dataset rollup + sample trace ids.
- *   - `queryTraces(filters?, limit, offset)` — paginated summaries.
- *   - `countTraces(filters?)` — cheap count without materialisation.
- *   - `viewTrace(trace_id, perAttrCap)` — full span list, oversized → summary.
- *   - `viewSpans(trace_id, span_ids, perAttrCap)` — surgical span fetch.
- *   - `searchTrace(trace_id, regex, max_matches)` — bounded regex hits.
- *   - `searchSpan(trace_id, span_id, regex, max_matches)` — single-span search.
- *
- * Multiple implementations ship in the core (`OtlpFileTraceStore`).
- * Downstream callers can supply their own — e.g. a DuckDB-backed
- * adapter or an in-memory adapter for tests — by implementing this
- * interface.
- *
- * Filters compose with AND semantics. Empty/undefined fields impose
- * no constraint. `regex_pattern` is the only opt-in raw-bytes scan —
- * implementations may skip it via `count`/`overview` when not set.
- */
-
-interface TraceAnalysisStore {
-    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
-    queryTraces(opts: {
-        filters?: TraceAnalystFilters;
-        limit: number;
-        offset?: number;
-    }): Promise<QueryTracesPage>;
-    countTraces(filters?: TraceAnalystFilters): Promise<number>;
-    viewTrace(opts: {
-        trace_id: string;
-        /** Override per-attribute byte cap. Defaults to discovery budget. */
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewTraceResult>;
-    viewSpans(opts: {
-        trace_id: string;
-        span_ids: readonly string[];
-        /** Override per-attribute byte cap. Defaults to surgical budget. */
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewSpansResult>;
-    searchTrace(opts: {
-        trace_id: string;
-        regex_pattern: string;
-        /** Hard cap on matches returned. Default 50. */
-        max_matches?: number;
-    }): Promise<SearchTraceResult>;
-    searchSpan(opts: {
-        trace_id: string;
-        span_id: string;
-        regex_pattern: string;
-        max_matches?: number;
-    }): Promise<SearchSpanResult>;
-}
-
-export { DEFAULT_TRACE_ANALYST_BUDGETS as D, type ErrorCluster as E, type QueryTracesPage as Q, type SearchSpanResult as S, type TraceAnalysisStore as T, type ViewSpansResult as V, type TraceAnalystSpan as a, type DatasetOverview as b, type SearchTraceResult as c, type SpanMatchRecord as d, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as e, type TraceAnalystByteBudgets as f, type TraceAnalystFilters as g, type TraceAnalystSpanKind as h, type TraceAnalystSpanStatus as i, type TraceAnalystTraceSummary as j, type ViewTraceOversized as k, type ViewTraceResult as l };
+export declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
+//# sourceMappingURL=types.d.ts.map

package/dist/trace-analyst/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/trace-analyst/types.ts"],"names":[],"mappings":"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"}

package/dist/trace-contracts.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Trace contracts — finite-trace temporal assertions over span sequences.
+ *
+ * Five LTLf operators over one ordered span sequence — `always(p)`,
+ * `never(p)`, `eventually(p)`, `precedes(a, b)`, `neverUnless(p, prior)` —
+ * deterministic and judge-free. No nesting: each rule is one operator over
+ * flat `SpanPredicate`s; compose richer checks with multiple rules.
+ *
+ * A built `TraceContract` is a serializable plain object (RegExp matchers
+ * are normalized to `SerializedRegex`), so ONE contract definition is
+ * dual-use:
+ *
+ *   - recorded eval traces — `evaluateTraceContract(contract, await
+ *     store.spans({ runId }))`, or via the behavior DSL:
+ *     `expectAgent(store, runId).toSatisfyContract(contract)`.
+ *   - the production OTLP stream — `ExportableSpan`s flattened by
+ *     `trace/otel-bridge` satisfy `ContractSpan` structurally. A production
+ *     monitor implements `OtelExporter`, buffers `exportSpan` payloads per
+ *     trace, and runs `checkTraceContracts(buffer, contracts)` on flush:
+ *
+ *       const buffer: ContractSpan[] = []
+ *       const monitor: OtelExporter = {
+ *         exportSpan: (s) => { buffer.push(s) },
+ *         flush: async () => {
+ *           const { allValid, verdicts } = checkTraceContracts(buffer, contracts)
+ *           if (!allValid) alert(verdicts)
+ *         },
+ *         shutdown: async () => {},
+ *       }
+ *       const store = createOtelTracingStore(inner, monitor, runId)
+ *
+ * `custom` predicate functions are the one non-serializable escape hatch:
+ * the builder stamps `requiresCustom: true` (which DOES survive JSON) so a
+ * deserialized contract that lost its function fails loud at evaluation
+ * instead of silently weakening.
+ *
+ * Naming: the root barrel exports ci-gate's threshold-contract
+ * `evaluateContract`, so the evaluators here are `evaluateTraceContract` /
+ * `checkTraceContracts`.
+ */
+import type { JudgeConfig, Scenario } from './campaign/types';
+import type { DefaultVerdict } from './verdict';
+/**
+ * Minimal structural span the checker reads. Both the eval-side `Span`
+ * (trace/schema) and the OTLP-flattened `ExportableSpan` (trace/otel-export)
+ * satisfy it; any other producer only needs these fields.
+ */
+export interface ContractSpan {
+    spanId?: string;
+    name?: string;
+    kind?: string;
+    startedAt?: number;
+    status?: string;
+    error?: string;
+    /** Typed field on eval-side ToolSpans; OTLP flattenings drop it (see
+     *  `tool` matching order in {@link matchSpan}). */
+    toolName?: string;
+    attributes?: Record<string, unknown>;
+}
+/** JSON-safe RegExp form — what the builder normalizes RegExp matchers to. */
+export interface SerializedRegex {
+    $regex: string;
+    flags: string;
+}
+export type TextMatcher = string | RegExp | SerializedRegex;
+/**
+ * Proposition over one span. All specified fields must match (AND).
+ * At least one field is required — an empty predicate would match every
+ * span and is rejected.
+ *
+ * `tool` resolution order covers both span shapes: `span.toolName` (typed
+ * ToolSpan) → `attributes['tool.name']` / `attributes['toolName']`
+ * (OTLP-flat attribute conventions) → `span.name` when `kind === 'tool'`
+ * (otel-bridge's `ExportableSpan`, which drops `toolName`).
+ *
+ * `attr` values match by strict equality, or regex-test when the value is a
+ * RegExp/SerializedRegex and the attribute is a string. Structured attribute
+ * values need `custom`.
+ */
+export interface SpanPredicate {
+    name?: TextMatcher;
+    tool?: TextMatcher;
+    attr?: Record<string, unknown>;
+    custom?: (span: ContractSpan) => boolean;
+    /** Stamped by the builder when `custom` is present. Survives JSON while
+     *  the function does not, so evaluation of a deserialized contract throws
+     *  instead of silently dropping the check. */
+    requiresCustom?: true;
+}
+export type ContractRuleKind = 'always' | 'never' | 'eventually' | 'precedes' | 'neverUnless';
+export interface ContractRule {
+    kind: ContractRuleKind;
+    /** Unique within the contract — keys the per-rule score. */
+    label: string;
+    /** Subject predicate for always / never / eventually / neverUnless. */
+    p?: SpanPredicate;
+    /** precedes: the required precondition. */
+    a?: SpanPredicate;
+    /** precedes: the guarded match — every b-match needs an earlier a-match. */
+    b?: SpanPredicate;
+    /** neverUnless: the authorizing earlier match. */
+    prior?: SpanPredicate;
+}
+/** Serializable plain object — `traceContract(name)....build()` output. */
+export interface TraceContract {
+    name: string;
+    rules: ContractRule[];
+}
+export interface ContractViolation {
+    rule: string;
+    spanId?: string;
+    detail: string;
+}
+export interface ContractVerdict extends DefaultVerdict {
+    /** Contract name — keys this verdict in multi-contract reports. */
+    contract: string;
+    valid: boolean;
+    /** Fraction of rules passing, in [0, 1]. */
+    score: number;
+    /** Per-rule 0|1 keyed by rule label. */
+    scores: Record<string, number>;
+    violations: ContractViolation[];
+}
+export interface ContractCheckResult {
+    verdicts: ContractVerdict[];
+    allValid: boolean;
+}
+/** Test one span against one predicate. All specified fields must match. */
+export declare function matchSpan(span: ContractSpan, predicate: SpanPredicate): boolean;
+export declare class TraceContractBuilder {
+    private readonly name;
+    private readonly rules;
+    constructor(name: string);
+    /** Every span in the trace must satisfy `p`. */
+    always(p: SpanPredicate, label?: string): this;
+    /** No span in the trace may satisfy `p`. */
+    never(p: SpanPredicate, label?: string): this;
+    /** At least one span in the trace must satisfy `p`. */
+    eventually(p: SpanPredicate, label?: string): this;
+    /** Every `b`-match must have a strictly earlier `a`-match. */
+    precedes(a: SpanPredicate, b: SpanPredicate, label?: string): this;
+    /** Every `p`-match is a violation unless a strictly earlier `prior`-match exists. */
+    neverUnless(p: SpanPredicate, prior: SpanPredicate, label?: string): this;
+    build(): TraceContract;
+    private add;
+}
+export declare function traceContract(name: string): TraceContractBuilder;
+/**
+ * Evaluate one contract over a span sequence. Pure and synchronous — works
+ * on `Span[]` from a TraceStore, `ExportableSpan[]` from the otel-bridge
+ * flattening, or any array satisfying `ContractSpan`.
+ */
+export declare function evaluateTraceContract(contract: TraceContract, spans: readonly ContractSpan[]): ContractVerdict;
+/**
+ * Evaluate many contracts over one span sequence. Throws on an empty
+ * contract list — `allValid: true` over zero contracts is a silent pass.
+ */
+export declare function checkTraceContracts(spans: readonly ContractSpan[], contracts: readonly TraceContract[]): ContractCheckResult;
+export interface ContractJudgeOptions<TArtifact, TScenario extends Scenario = Scenario> {
+    /**
+     * Project the span sequence out of a cell's artifact. `JudgeConfig.score`
+     * receives only `{ artifact, scenario, signal }` (src/campaign/types.ts) —
+     * spans are NOT reachable generically — so the consumer supplies this
+     * explicit extraction (e.g. dispatch writes spans into the artifact, or
+     * closes over a per-cell TraceStore read).
+     */
+    spans: (input: {
+        artifact: TArtifact;
+        scenario: TScenario;
+    }) => readonly ContractSpan[];
+    /** Judge name in campaign reports. Default 'trace-contracts'. */
+    name?: string;
+}
+/**
+ * Adapt trace contracts to a campaign `JudgeConfig`. One judge dimension per
+ * contract (key = contract name, value = its rule-pass fraction); composite
+ * is the mean across contracts. Deterministic — no LLM call.
+ */
+export declare function contractJudge<TArtifact, TScenario extends Scenario = Scenario>(contracts: readonly TraceContract[], opts: ContractJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
+//# sourceMappingURL=trace-contracts.d.ts.map