@tangle-network/agent-eval 0.118.0 → 0.118.2

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.118.0",
+    "version": "0.118.2",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.0.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/{run-campaign-IM26A6PD.js → run-campaign-DWC67KJP.js}

@@ -1,9 +1,9 @@
 import {
   planCampaignRun,
   runCampaign
-} from "./chunk-IDZTTFRR.js";
+} from "./chunk-EGNRE7VA.js";
 import "./chunk-PJQFMIOX.js";
-import "./chunk-VCTY3W6J.js";
+import "./chunk-MLHRFWQK.js";
 import "./chunk-VI2UW6B6.js";
 import "./chunk-ONWEPEDO.js";
 import "./chunk-PZ5AY32C.js";
@@ -11,4 +11,4 @@ export {
   planCampaignRun,
   runCampaign
 };
-//# sourceMappingURL=run-campaign-IM26A6PD.js.map
+//# sourceMappingURL=run-campaign-DWC67KJP.js.map

package/dist/trace-attributes.d.ts

@@ -6,11 +6,31 @@ declare const LLM_OUTPUT_TOKENS = "llm.token_count.completion";
 declare const LLM_REASONING_TOKENS = "llm.token_count.reasoning";
 declare const LLM_CACHED_TOKENS = "llm.token_count.prompt_cache_hit";
 declare const LLM_CACHE_WRITE_TOKENS = "llm.token_count.prompt_cache_write";
+/** Exact prompt context after summing mutually exclusive input/cache categories. */
+declare const LLM_CONTEXT_TOKENS = "tangle.llm.context_tokens";
 declare const LLM_COST_USD = "llm.cost_usd";
 declare const TOOL_NAME = "tool.name";
 declare const TOOL_ARGS_CAPTURED = "tool.args_captured";
 declare const TOOL_LATENCY_MS = "tool.latency_ms";
 declare const INPUT_VALUE = "input.value";
 declare const OUTPUT_VALUE = "output.value";
+/** Sum producer-supplied, mutually exclusive prompt-token categories. */
+declare function contextInputTokens(usage: {
+    inputTokens?: number | null;
+    cachedTokens?: number | null;
+    cacheWriteTokens?: number | null;
+}): number | undefined;
+interface LlmSpanOtlpInput {
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    cachedTokens?: number;
+    cacheWriteTokens?: number;
+    costUsd?: number;
+    finishReason?: string;
+}
+/** Write the canonical LLM attributes shared by trace producers. */
+declare function applyLlmSpanOtlpAttributes(attributes: Record<string, unknown>, span: LlmSpanOtlpInput): void;
 
-export { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHE_WRITE_TOKENS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_REASONING_TOKENS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME };
+export { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHE_WRITE_TOKENS, LLM_CONTEXT_TOKENS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_REASONING_TOKENS, type LlmSpanOtlpInput, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, applyLlmSpanOtlpAttributes, contextInputTokens };

package/dist/trace-attributes.js

@@ -2,6 +2,7 @@ import {
   INPUT_VALUE,
   LLM_CACHED_TOKENS,
   LLM_CACHE_WRITE_TOKENS,
+  LLM_CONTEXT_TOKENS,
   LLM_COST_USD,
   LLM_INPUT_TOKENS,
   LLM_MODEL_NAME,
@@ -11,13 +12,16 @@ import {
   OUTPUT_VALUE,
   TOOL_ARGS_CAPTURED,
   TOOL_LATENCY_MS,
-  TOOL_NAME
-} from "./chunk-WDHBCA3M.js";
+  TOOL_NAME,
+  applyLlmSpanOtlpAttributes,
+  contextInputTokens
+} from "./chunk-NW4AQBXD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   INPUT_VALUE,
   LLM_CACHED_TOKENS,
   LLM_CACHE_WRITE_TOKENS,
+  LLM_CONTEXT_TOKENS,
   LLM_COST_USD,
   LLM_INPUT_TOKENS,
   LLM_MODEL_NAME,
@@ -27,6 +31,8 @@ export {
   OUTPUT_VALUE,
   TOOL_ARGS_CAPTURED,
   TOOL_LATENCY_MS,
-  TOOL_NAME
+  TOOL_NAME,
+  applyLlmSpanOtlpAttributes,
+  contextInputTokens
 };
 //# sourceMappingURL=trace-attributes.js.map

package/dist/traces.d.ts

@@ -1192,12 +1192,32 @@ declare const LLM_OUTPUT_TOKENS = "llm.token_count.completion";
 declare const LLM_REASONING_TOKENS = "llm.token_count.reasoning";
 declare const LLM_CACHED_TOKENS = "llm.token_count.prompt_cache_hit";
 declare const LLM_CACHE_WRITE_TOKENS = "llm.token_count.prompt_cache_write";
+/** Exact prompt context after summing mutually exclusive input/cache categories. */
+declare const LLM_CONTEXT_TOKENS = "tangle.llm.context_tokens";
 declare const LLM_COST_USD = "llm.cost_usd";
 declare const TOOL_NAME = "tool.name";
 declare const TOOL_ARGS_CAPTURED = "tool.args_captured";
 declare const TOOL_LATENCY_MS = "tool.latency_ms";
 declare const INPUT_VALUE = "input.value";
 declare const OUTPUT_VALUE = "output.value";
+/** Sum producer-supplied, mutually exclusive prompt-token categories. */
+declare function contextInputTokens(usage: {
+    inputTokens?: number | null;
+    cachedTokens?: number | null;
+    cacheWriteTokens?: number | null;
+}): number | undefined;
+interface LlmSpanOtlpInput {
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    cachedTokens?: number;
+    cacheWriteTokens?: number;
+    costUsd?: number;
+    finishReason?: string;
+}
+/** Write the canonical LLM attributes shared by trace producers. */
+declare function applyLlmSpanOtlpAttributes(attributes: Record<string, unknown>, span: LlmSpanOtlpInput): void;
 
 /** Canonical OpenInference-over-OTLP attribute vocabulary used at the trace boundary. */
 
@@ -2131,8 +2151,16 @@ interface TraceAggregate {
  * also want the verbatim prompt/completion text alongside each record.
  */
 declare function otlpToRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): RunRecord[];
+/**
+ * Aggregate already-parsed OTLP flat rows without serializing them back to
+ * JSONL. This is the in-memory counterpart to {@link otlpToRunRecords}; both
+ * paths share projection, reconciliation, validation, and ordering.
+ */
+declare function otlpRowsToRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): RunRecord[];
 /** As {@link otlpToRunRecords} but returns the prompt/completion text too. */
 declare function otlpToTraceRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
+/** Parsed-row counterpart to {@link otlpToTraceRunRecords}. */
+declare function otlpRowsToTraceRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
 
 /** 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 \u2192 NARROW \u2192 DEEP-READ protocol \u2014 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 \u2014 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 \u2014 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 \u2014 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\u00D7 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** \u2014 searchTrace and searchSpan return `{ trace_id, hits, total_matches, 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, truncated_attribute_count }`. Never assume a field name \u2014 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 \u2014 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 maxDepth > 0 and the question splits into independent semantic branches, delegate well-defined subtasks to subagents using `await llmQuery(...)`. Pass narrow context and a focused query. Examples:\n\n    const reviews = await llmQuery([\n      { query: 'Drill into trace abc123 \u2014 what tool calls preceded the failure?', context: { trace_id: 'abc123' } },\n      { query: 'Drill into trace def456 \u2014 same failure mode?', context: { trace_id: 'def456' } },\n    ]);\n\nOBSERVABILITY rules:\n- Each non-final actor turn must emit at least one `console.log(...)` for evidence. Up to 3 logs per turn is fine when correlating multiple data sources (e.g. one log for findings list, one for source-file content, one for derived analysis).\n- Do NOT combine `console.log` with `final(...)` or `askClarification(...)` in the same turn \u2014 finish gathering data first, then call final on its own turn.\n- Reuse runtime variables across turns; don't recompute.\n- When done, call `await final(answer)` with the fully-formed report. The responder rewrites the answer into output fields; if you only pass a vague summary string the responder has nothing concrete to format.\n\nCRITICAL \u2014 `final()` payload contract for evidence-grounded analysis tasks:\n- Pass a STRUCTURED object as the second arg with the actual data the responder needs to format the answer. Do NOT pass abstract instructions; pass evidence.\n- Example for per-item verdict tasks:\n  ```js\n  await final(\"Format the per-item verdict report from the evidence below.\", {\n    findings: [\n      { id: 'sub-1-finding-1', claim: '...', verdict: 'TRUE-POSITIVE', evidence: 'lines 42-45 of contracts/X.sol show ...' },\n      ...all items\n    ],\n    systemic_summary: '3 sentences I wrote based on the evidence above'\n  });\n  ```\n- Calling `final(\"answer\", {})` with no evidence is a failure mode \u2014 the responder will hallucinate or echo back the field names. Always include the gathered data.\n- Premature final after a single viewSpans call is INSUFFICIENT for per-finding analysis tasks. Read the requested attributes (e.g. `spans[i].attributes['redteam.finding.title']`), and for each one perform the requested cross-reference (e.g. read the source SPAN's `attributes['source.content']`).\n\nOUTPUT contract \u2014 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\nDo NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.";
@@ -2298,4 +2326,4 @@ declare function traceAnalystFunctionGroup(opts: BuildTraceAnalystToolsOpts): {
     functions: AxFunction[];
 };
 
-export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type Artifact, type BudgetLedgerEntry, type BudgetSpec, type CaptureFetchContext, type CaptureFetchOptions, DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, type EventFilter, type EventKind, type ExportableSpan, 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_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 Message, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type OtelExportConfig, type OtelExporter, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, type OtlpResourceSpans, type OtlpSpan, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, type ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, RUN_COST_ATTR_KEYS, type RawProviderDirection, type RawProviderEvent, type RawProviderSink, type RawProviderSinkFilter, type RedactionReport, type RedactionRule, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, type ReplayFetchOptions, type RetrievalSpan, type Run, type RunCompleteHook, type RunCompleteHookContext, type RunFilter, RunIntegrityError, type RunIntegrityExpectations, type RunIntegrityIssue, type RunIntegrityIssueCode, type RunIntegrityReport, type RunLayer, type RunOutcome$1 as RunOutcome, type RunStatus, SPAN_KIND_ATTR_KEYS, type SandboxSpan, type SearchSpanResult, type SearchTraceResult, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanStatus, type SseUsageMode, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_SUBAGENT_DESCRIPTION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type ToolSpan, type ToolSpanOtlpInput, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, type TraceEmitterOptions, type TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, type TraceStore, type TraceStoreSource, type TraceStoreToOtlpOptions, type TracesToOtlpResult, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, aggregateLlm, analyzeTraces, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, convertTraceStoresToOtlp, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isRetrievalSpan, isSandboxSpan, isToolSpan, iterateRawCalls, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type Artifact, type BudgetLedgerEntry, type BudgetSpec, type CaptureFetchContext, type CaptureFetchOptions, DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, type EventFilter, type EventKind, type ExportableSpan, 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, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type OtelExportConfig, type OtelExporter, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, type OtlpResourceSpans, type OtlpSpan, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, type ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, RUN_COST_ATTR_KEYS, type RawProviderDirection, type RawProviderEvent, type RawProviderSink, type RawProviderSinkFilter, type RedactionReport, type RedactionRule, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, type ReplayFetchOptions, type RetrievalSpan, type Run, type RunCompleteHook, type RunCompleteHookContext, type RunFilter, RunIntegrityError, type RunIntegrityExpectations, type RunIntegrityIssue, type RunIntegrityIssueCode, type RunIntegrityReport, type RunLayer, type RunOutcome$1 as RunOutcome, type RunStatus, SPAN_KIND_ATTR_KEYS, type SandboxSpan, type SearchSpanResult, type SearchTraceResult, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanStatus, type SseUsageMode, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_SUBAGENT_DESCRIPTION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type ToolSpan, type ToolSpanOtlpInput, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, type TraceEmitterOptions, type TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, type TraceStore, type TraceStoreSource, type TraceStoreToOtlpOptions, type TracesToOtlpResult, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, contextInputTokens, convertTraceStoresToOtlp, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isRetrievalSpan, isSandboxSpan, isToolSpan, iterateRawCalls, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };

package/dist/traces.js

@@ -19,14 +19,16 @@ import {
   inferDomainKeywords,
   iterateRawCalls,
   otelRunCompleteHook,
+  otlpRowsToRunRecords,
+  otlpRowsToTraceRunRecords,
   otlpToRunRecords,
   otlpToTraceRunRecords,
   planTraceInsightQuestions,
   scoreTraceInsightReadiness,
   tokenizeDomainWords,
   traceAnalystOnRunComplete
-} from "./chunk-DP3BBMYJ.js";
-import "./chunk-KSDQVPLR.js";
+} from "./chunk-6JQE3YVE.js";
+import "./chunk-TVXPJJ7H.js";
 import {
   extractUsage,
   extractUsageFromResponse,
@@ -48,7 +50,7 @@ import {
   TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
   TRACE_ANALYST_SUBAGENT_DESCRIPTION,
   analyzeTraces
-} from "./chunk-3EHHMC6E.js";
+} from "./chunk-63KG3ASG.js";
 import {
   DEFAULT_REDACTION_RULES,
   REDACTION_VERSION,
@@ -85,7 +87,7 @@ import {
   stringField,
   traceAnalystFunctionGroup,
   traceSpanKindToOpenInferenceKind
-} from "./chunk-QKEGNI5B.js";
+} from "./chunk-BUBU3YHT.js";
 import {
   RunIntegrityError,
   assertRunCaptured,
@@ -119,6 +121,7 @@ import {
   INPUT_VALUE,
   LLM_CACHED_TOKENS,
   LLM_CACHE_WRITE_TOKENS,
+  LLM_CONTEXT_TOKENS,
   LLM_COST_USD,
   LLM_INPUT_TOKENS,
   LLM_MODEL_NAME,
@@ -128,8 +131,10 @@ import {
   OUTPUT_VALUE,
   TOOL_ARGS_CAPTURED,
   TOOL_LATENCY_MS,
-  TOOL_NAME
-} from "./chunk-WDHBCA3M.js";
+  TOOL_NAME,
+  applyLlmSpanOtlpAttributes,
+  contextInputTokens
+} from "./chunk-NW4AQBXD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_REDACTION_RULES,
@@ -144,6 +149,7 @@ export {
   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,
@@ -180,6 +186,7 @@ export {
   TraceNotFoundError,
   aggregateLlm,
   analyzeTraces,
+  applyLlmSpanOtlpAttributes,
   applyToolSpanOtlpAttributes,
   argHash,
   asNumber,
@@ -189,6 +196,7 @@ export {
   buildTraceInsightContext,
   buildTraceInsightPrompt,
   captureFetchToRawSink,
+  contextInputTokens,
   convertTraceStoresToOtlp,
   createOtelExporter,
   createOtelTracingStore,
@@ -219,6 +227,8 @@ export {
   llmSpanFromProvider,
   llmSpans,
   otelRunCompleteHook,
+  otlpRowsToRunRecords,
+  otlpRowsToTraceRunRecords,
   otlpToRunRecords,
   otlpToTraceRunRecords,
   planTraceInsightQuestions,

package/dist/wire/index.d.ts

@@ -146,6 +146,13 @@ declare class CostLedger {
     private ensureCostLimitPersisted;
     private appendEvent;
 }
+/** Public callback surface for a shared cost ledger.
+ *
+ * Declaration bundles may expose this type through multiple package subpaths.
+ * Keeping callback contracts structural lets those subpaths compose while the
+ * concrete {@link CostLedger} retains its private durable state.
+ */
+type CostLedgerHandle = Pick<CostLedger, keyof CostLedger>;
 
 type RunStatus = 'running' | 'completed' | 'failed' | 'aborted';
 interface BudgetSpec {
@@ -1088,7 +1095,7 @@ declare class WireError extends Error {
     constructor(code: string, message: string, status?: number, details?: unknown | undefined);
 }
 interface HandleJudgeOptions {
-    costLedger?: CostLedger;
+    costLedger?: CostLedgerHandle;
     costPhase?: string;
     llm?: LlmClientOptions;
     signal?: AbortSignal;

package/dist/wire/index.js

@@ -34,9 +34,9 @@ import {
   runRpcOnce,
   startServer,
   startServerAsync
-} from "../chunk-LTVG32KX.js";
+} from "../chunk-JTMFT5QZ.js";
 import "../chunk-NJC7U437.js";
-import "../chunk-VCTY3W6J.js";
+import "../chunk-MLHRFWQK.js";
 import "../chunk-VI2UW6B6.js";
 import "../chunk-PC4UYEBM.js";
 import "../chunk-ONWEPEDO.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.118.0",
+  "version": "0.118.2",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {

package/dist/chunk-33JA4TFA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/analyst/chat-client.ts","../src/trace-analyst/behavioral-metrics.ts","../src/analyst/behavioral-analyst.ts","../src/analyst/default-registry.ts"],"sourcesContent":["/**\n * ChatClient — the single LLM abstraction analysts call.\n *\n * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,\n * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two\n * mixed patterns force every analyst author to pick a transport, which\n * couples analyst code to runtime concerns (cli-bridge vs router vs\n * sandbox-sdk) it shouldn't know about.\n *\n * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.\n * The operator decides at the registry boundary which transport binds\n * to it. Analyst code stays transport-agnostic; swapping production\n * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-\n * line factory call.\n *\n * Designed to coexist: existing `LlmClient` callers and existing\n * `TCloud`-based judges keep working untouched. New analyst code uses\n * `ChatClient`. When old call sites migrate, they pick up budgeting,\n * cancellation, and unified telemetry for free.\n */\n\nimport {\n  type LlmCallRequest,\n  type LlmCallResult,\n  LlmClient,\n  type LlmClientOptions,\n} from '../llm-client'\n\n/**\n * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-\n * compatible mental model stays. Two methods: a one-shot `chat()` and\n * an `streamChat()` for future agentic loops (not yet exposed).\n */\nexport interface ChatClient {\n  /** Display name of the bound transport — included in telemetry. */\n  readonly transport: ChatTransport\n  /** Default model when caller omits — operators bind this per environment. */\n  readonly defaultModel?: string\n  /** Total provider attempts this transport can make for one chat call. */\n  readonly maximumAttempts?: number\n\n  /** Implementations must enforce `req.maxTokens` when it is present. */\n  chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>\n}\n\nexport type ChatTransport =\n  | 'router' // router.tangle.tools — production paid models\n  | 'sandbox-sdk' // box.streamPrompt() — chat completion via sandbox SDK\n  | 'cli-bridge' // local cli-bridge for dev / local-only runs\n  | 'direct-provider' // direct OpenAI / Anthropic / etc. — bypass router\n  | 'mock' // test-time injection\n\nexport interface ChatRequest extends Omit<LlmCallRequest, 'model'> {\n  /** Optional — falls back to ChatClient.defaultModel. */\n  model?: string\n}\n\nexport type ChatResponse = LlmCallResult\n\nexport interface ChatCallOpts {\n  /** Cancel the in-flight request. */\n  signal?: AbortSignal\n  /** Hard USD ceiling for this single call (informational; the underlying transport may not enforce). */\n  maxCostUsd?: number\n  /** Correlation tag carried into request headers when the transport allows. */\n  correlationId?: string\n  /** Stable provider idempotency key for retries/redrives of one paid call. */\n  idempotencyKey?: string\n}\n\n// ── Factory ─────────────────────────────────────────────────────────\n\nexport type CreateChatClientOpts =\n  | RouterTransportOpts\n  | CliBridgeTransportOpts\n  | DirectProviderTransportOpts\n  | SandboxSdkTransportOpts\n  | MockTransportOpts\n\ninterface BaseTransportOpts {\n  defaultModel?: string\n  /** Total provider attempts. Required for opaque transports used in capped runs. */\n  maximumAttempts?: number\n}\n\nexport interface RouterTransportOpts extends BaseTransportOpts {\n  transport: 'router'\n  baseUrl?: string\n  apiKey: string\n}\n\nexport interface CliBridgeTransportOpts extends BaseTransportOpts {\n  transport: 'cli-bridge'\n  baseUrl?: string\n  bearer?: string\n}\n\nexport interface DirectProviderTransportOpts extends BaseTransportOpts {\n  transport: 'direct-provider'\n  baseUrl: string\n  apiKey: string\n}\n\n/**\n * Sandbox-SDK transport. Provided as a thin pass-through: the caller\n * supplies a callable that mimics LlmClient.chat() against an already-\n * configured Sandbox handle. We don't import the SDK here to keep\n * agent-eval dep-free of @tangle-network/sandbox.\n */\nexport interface SandboxSdkTransportOpts extends BaseTransportOpts {\n  transport: 'sandbox-sdk'\n  chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>\n}\n\n/**\n * Mock transport for tests. The handler receives the request and returns\n * whatever the test wants. No retries, no JSON-schema degrade.\n */\nexport interface MockTransportOpts extends BaseTransportOpts {\n  transport: 'mock'\n  handler: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>\n}\n\n/**\n * Build a ChatClient bound to a specific transport. The returned client\n * is safe to share across analysts in a single registry run.\n */\nexport function createChatClient(opts: CreateChatClientOpts): ChatClient {\n  switch (opts.transport) {\n    case 'router':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl ?? 'https://router.tangle.tools/v1',\n          apiKey: opts.apiKey,\n          maxRetries: opts.maximumAttempts,\n        } as LlmClientOptions),\n      )\n    case 'cli-bridge':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl ?? 'http://127.0.0.1:3344/v1',\n          apiKey: opts.bearer ?? '',\n          maxRetries: opts.maximumAttempts,\n        } as LlmClientOptions),\n      )\n    case 'direct-provider':\n      return wrapLlmClient(\n        opts.transport,\n        opts.defaultModel,\n        new LlmClient({\n          baseUrl: opts.baseUrl,\n          apiKey: opts.apiKey,\n          maxRetries: opts.maximumAttempts,\n        } as LlmClientOptions),\n      )\n    case 'sandbox-sdk':\n      return {\n        transport: 'sandbox-sdk',\n        defaultModel: opts.defaultModel,\n        maximumAttempts: opts.maximumAttempts,\n        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts),\n      }\n    case 'mock':\n      return {\n        transport: 'mock',\n        defaultModel: opts.defaultModel,\n        maximumAttempts: 1,\n        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts),\n      }\n  }\n}\n\nfunction wrapLlmClient(\n  transport: ChatTransport,\n  defaultModel: string | undefined,\n  inner: LlmClient,\n): ChatClient {\n  return {\n    transport,\n    defaultModel,\n    maximumAttempts: inner.maximumAttempts,\n    chat: (req, callOpts) => {\n      const resolved = resolveModel(req, defaultModel)\n      const request: LlmCallRequest = {\n        model: resolved.model!,\n        messages: req.messages,\n        jsonMode: req.jsonMode,\n        jsonSchema: req.jsonSchema,\n        temperature: req.temperature,\n        maxTokens: req.maxTokens,\n        timeoutMs: req.timeoutMs,\n      }\n      return inner.call(request, {\n        signal: callOpts?.signal,\n        idempotencyKey: callOpts?.idempotencyKey,\n      })\n    },\n  }\n}\n\nfunction resolveModel(req: ChatRequest, defaultModel: string | undefined): ChatRequest {\n  if (req.model) return req\n  if (!defaultModel) {\n    throw new Error(\n      'ChatClient.chat: no model on request and no defaultModel on the client. ' +\n        'Either pass req.model or bind defaultModel at createChatClient().',\n    )\n  }\n  return { ...req, model: defaultModel }\n}\n","/**\n * Deterministic behavioral metrics over OTLP spans — pure arithmetic, no LLM.\n *\n * These are the model-independent multiplier: the four trace-quality signals a\n * tolerant analyzer (e.g. HALO) re-derives per run inside the model — token\n * growth, output decay, tool monoculture, missing self-verification — computed\n * here once, in TypeScript, with zero model judgment. A finding that falls out\n * of arithmetic is trivially model-agnostic and cannot hallucinate the trend.\n *\n * General, not trace-specific: the detectors key off token trajectories and\n * tool usage present in any agentic OTLP trace, not any one benchmark.\n */\n\nimport { executionTrackByLane } from '../trace/execution-tracks'\nimport {\n  LLM_INPUT_TOKEN_ATTR_KEYS,\n  LLM_OUTPUT_TOKEN_ATTR_KEYS,\n  TOOL_NAME_ATTR_KEYS,\n} from '../trace/otlp-attributes'\nimport { spanEpochMillis } from './otlp-span'\nimport type { TraceAnalystSpan } from './types'\n\nexport type SuboptimalCode =\n  | 'monotonic-input-growth'\n  | 'output-length-decay'\n  | 'single-tool-dependency'\n  | 'no-self-verification'\n\nexport interface SuboptimalSignal {\n  code: SuboptimalCode\n  severity: 'high' | 'medium' | 'low'\n  /** Human-readable claim, with the backing numbers inlined. */\n  detail: string\n  /** The exact figures the detector fired on — auditable, no model in the loop. */\n  evidence: Record<string, number | string | boolean>\n}\n\nexport interface BehavioralMetrics {\n  /** The only trace represented by these metrics; null when spans are empty. */\n  traceId: string | null\n  llmCallCount: number\n  /** Causally serial LLM timelines. Parallel branches are never joined. */\n  tokenSequences: BehavioralTokenSequence[]\n  /** Token values from the longest serial timeline, retained for convenience. */\n  inputTokenTrajectory: number[]\n  outputTokenTrajectory: number[]\n  toolHistogram: Record<string, number>\n  totalToolCalls: number\n  distinctTools: number\n  /** distinct/total tool calls; 1.0 when there are no tool calls. */\n  toolDiversityRatio: number\n  hasSelfVerification: boolean\n  signals: SuboptimalSignal[]\n}\n\nexport interface BehavioralTokenSequence {\n  scopeId: string\n  spanIds: string[]\n  inputTokenTrajectory: Array<number | null>\n  outputTokenTrajectory: Array<number | null>\n}\n\ninterface TokenSample {\n  span: TraceAnalystSpan\n  input: number | null\n  output: number | null\n  step: number | null\n}\n\n/** ≥ this input-token growth ratio across a run, with no compression, fires. */\nconst INPUT_GROWTH_FACTOR = 3\n/** Tool-usage signals need at least this many calls to be meaningful. */\nconst MIN_TOOL_CALLS = 3\n/** Tool names that read or check state count as self-verification, not mutation.\n *  Covers the inspect verbs plus the read/search tools real harnesses use to\n *  verify (Claude Code Read/Grep/Glob, codex read_file/ls/cat, git status/diff,\n *  test/lint). A pure shell tool (Bash/exec_command) is intentionally NOT matched\n *  — its name can't tell a `pytest` from an `rm`. */\nconst VERIFY_RE =\n  /verif|eval|inspect|check|assert|validat|review|confirm|read|grep|glob|search|view|\\blist\\b|\\bls\\b|\\bcat\\b|\\bfind\\b|diff|status|\\btest|lint|typecheck/i\n\nfunction num(v: unknown): number | null {\n  return typeof v === 'number' && Number.isFinite(v) ? v : null\n}\nfunction numAttr(attrs: Record<string, unknown>, keys: readonly string[]): number | null {\n  for (const key of keys) {\n    const value = num(attrs[key])\n    if (value !== null) return value\n  }\n  return null\n}\nfunction inputTokensOf(s: TraceAnalystSpan): number | null {\n  return (\n    numAttr(s.attributes, LLM_INPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes['llm.usage.input_tokens'])\n  )\n}\nfunction outputTokensOf(s: TraceAnalystSpan): number | null {\n  return (\n    numAttr(s.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS) ??\n    num(s.attributes['llm.usage.output_tokens'])\n  )\n}\nfunction stepOf(s: TraceAnalystSpan): number | null {\n  return num(s.attributes.step)\n}\nfunction toolNameOf(s: TraceAnalystSpan): string | null {\n  if (s.tool_name) return s.tool_name\n  for (const key of TOOL_NAME_ATTR_KEYS) {\n    const t = s.attributes[key]\n    if (typeof t === 'string' && t.length > 0) return t\n  }\n  return null\n}\n\n/**\n * Reduce a span list to behavioral metrics + fired suboptimality signals.\n * Pure + deterministic: same spans → same output, on any machine, no model.\n */\nexport function computeTraceMetrics(spans: readonly TraceAnalystSpan[]): BehavioralMetrics {\n  const traceIds = new Set(spans.map((span) => span.trace_id))\n  if (traceIds.size > 1) {\n    throw new Error(\n      `computeTraceMetrics: expected spans from one trace, received ${traceIds.size} traces`,\n    )\n  }\n  const traceId = traceIds.values().next().value ?? null\n\n  const samples: TokenSample[] = spans.map((span) => ({\n    span,\n    input: inputTokensOf(span),\n    output: outputTokensOf(span),\n    step: stepOf(span),\n  }))\n  const llmSamples = samples.filter((sample) => sample.span.kind === 'LLM')\n  const tokenSamples =\n    llmSamples.length > 0\n      ? llmSamples\n      : samples.filter((sample) => sample.input !== null || sample.output !== null)\n  const tokenSequences = buildTokenSequences(tokenSamples, spans)\n  const primarySequence = tokenSequences[0]\n  const inputTokenTrajectory =\n    primarySequence?.inputTokenTrajectory.filter((value): value is number => value !== null) ?? []\n  const outputTokenTrajectory =\n    primarySequence?.outputTokenTrajectory.filter((value): value is number => value !== null) ?? []\n  const toolHistogram: Record<string, number> = {}\n  let hasSelfVerification = false\n\n  for (const s of spans) {\n    const tool = toolNameOf(s)\n    if (tool) {\n      toolHistogram[tool] = (toolHistogram[tool] ?? 0) + 1\n      if (VERIFY_RE.test(tool)) hasSelfVerification = true\n    }\n  }\n\n  const totalToolCalls = Object.values(toolHistogram).reduce((a, b) => a + b, 0)\n  const distinctTools = Object.keys(toolHistogram).length\n  const toolDiversityRatio = totalToolCalls === 0 ? 1 : distinctTools / totalToolCalls\n\n  const signals: SuboptimalSignal[] = []\n  const seenTokenSignals = new Set<SuboptimalCode>()\n  for (const sequence of tokenSequences) {\n    for (const signal of tokenSignals(sequence)) {\n      if (seenTokenSignals.has(signal.code)) continue\n      seenTokenSignals.add(signal.code)\n      signals.push(signal)\n    }\n  }\n\n  if (totalToolCalls >= MIN_TOOL_CALLS && distinctTools === 1) {\n    const only = Object.keys(toolHistogram)[0]!\n    signals.push({\n      code: 'single-tool-dependency',\n      severity: 'medium',\n      detail: `All ${totalToolCalls} observed tool calls are \\`${only}\\`; no alternate tool call was observed.`,\n      evidence: { tool: only, calls: totalToolCalls, distinct_tools: 1 },\n    })\n  }\n\n  if (totalToolCalls >= MIN_TOOL_CALLS && !hasSelfVerification) {\n    signals.push({\n      code: 'no-self-verification',\n      severity: 'medium',\n      detail: `${totalToolCalls} tool calls were observed without a verification-named tool call.`,\n      evidence: { tool_calls: totalToolCalls, verification_calls: 0 },\n    })\n  }\n\n  return {\n    traceId,\n    llmCallCount: tokenSamples.length,\n    tokenSequences,\n    inputTokenTrajectory,\n    outputTokenTrajectory,\n    toolHistogram,\n    totalToolCalls,\n    distinctTools,\n    toolDiversityRatio,\n    hasSelfVerification,\n    signals,\n  }\n}\n\nfunction buildTokenSequences(\n  samples: readonly TokenSample[],\n  spans: readonly TraceAnalystSpan[],\n): BehavioralTokenSequence[] {\n  const spansById = new Map(spans.map((span) => [span.span_id, span]))\n  const executionScopeFor = createTokenExecutionScopeResolver(spansById)\n  const scopedSamples = samples.map((sample) => ({\n    sample,\n    ...executionScopeFor(sample.span),\n  }))\n  const trackByLane = executionTrackByLane(scopedSamples)\n  const byTrack = new Map<string, { scopeId: string; samples: TokenSample[] }>()\n  for (const scoped of scopedSamples) {\n    const trackId = trackByLane.get(scoped.key)!\n    const track = byTrack.get(trackId) ?? { scopeId: scoped.scopeId, samples: [] }\n    track.samples.push(scoped.sample)\n    byTrack.set(trackId, track)\n  }\n\n  const sequences: BehavioralTokenSequence[] = []\n  for (const { scopeId, samples: tracked } of byTrack.values()) {\n    const runs = serialTokenRuns([...tracked].sort(compareTokenSamples))\n    runs.forEach((run, index) => {\n      sequences.push({\n        scopeId: runs.length === 1 ? scopeId : `${scopeId}#${index + 1}`,\n        spanIds: run.map((sample) => sample.span.span_id),\n        inputTokenTrajectory: run.map((sample) => sample.input),\n        outputTokenTrajectory: run.map((sample) => sample.output),\n      })\n    })\n  }\n\n  return sequences.sort(\n    (a, b) =>\n      b.spanIds.length - a.spanIds.length ||\n      a.scopeId.localeCompare(b.scopeId) ||\n      a.spanIds[0]!.localeCompare(b.spanIds[0]!),\n  )\n}\n\ninterface AncestorScope {\n  agentId: string | null\n  rootId: string | null\n  missingParentId: string | null\n  laneSpanId: string | null\n}\n\nfunction createTokenExecutionScopeResolver(spansById: ReadonlyMap<string, TraceAnalystSpan>): (\n  span: TraceAnalystSpan,\n) => {\n  key: string\n  scopeKey: string\n  scopeId: string\n  start: number | null\n  end: number | null\n} {\n  const cache = new Map<string, AncestorScope>()\n  return (span) => {\n    const ancestry = resolveAncestorScope(span.parent_span_id, spansById, cache)\n    const rootId = ancestry.rootId\n    const scopeId = ancestry.agentId\n      ? `span:${ancestry.agentId}`\n      : ancestry.missingParentId\n        ? `parent:${ancestry.missingParentId}`\n        : rootId\n          ? `root:${rootId}`\n          : span.agent_name\n            ? `agent:${span.agent_name}`\n            : `trace:${span.trace_id}`\n    const scopeSpanId = ancestry.agentId ?? ancestry.missingParentId ?? rootId\n    const laneSpan = ancestry.laneSpanId ? spansById.get(ancestry.laneSpanId) : undefined\n    const direct = scopeSpanId === null || ancestry.laneSpanId === scopeSpanId\n    const timedSpan = direct ? span : laneSpan\n    return {\n      key: JSON.stringify([scopeId, direct ? span.span_id : ancestry.laneSpanId]),\n      scopeKey: scopeId,\n      scopeId,\n      start: timedSpan ? spanEpochMillis(timedSpan.start_time) : null,\n      end: timedSpan ? spanEpochMillis(timedSpan.end_time) : null,\n    }\n  }\n}\n\nfunction resolveAncestorScope(\n  startId: string | null,\n  spansById: ReadonlyMap<string, TraceAnalystSpan>,\n  cache: Map<string, AncestorScope>,\n): AncestorScope {\n  const empty: AncestorScope = {\n    agentId: null,\n    rootId: null,\n    missingParentId: null,\n    laneSpanId: null,\n  }\n  if (!startId) return empty\n\n  const path: string[] = []\n  const pathIndex = new Map<string, number>()\n  let currentId: string | null = startId\n  let resolved = empty\n  while (currentId) {\n    const cached = cache.get(currentId)\n    if (cached) {\n      resolved = cached\n      break\n    }\n    const cycleStart = pathIndex.get(currentId)\n    if (cycleStart !== undefined) {\n      resolved = {\n        agentId: null,\n        rootId: [...path.slice(cycleStart)].sort()[0]!,\n        missingParentId: null,\n        laneSpanId: [...path.slice(cycleStart)].sort()[0]!,\n      }\n      break\n    }\n    const current = spansById.get(currentId)\n    if (!current) {\n      resolved = {\n        agentId: null,\n        rootId: null,\n        missingParentId: currentId,\n        laneSpanId: currentId,\n      }\n      break\n    }\n    if (current.kind === 'AGENT') {\n      resolved = {\n        agentId: current.span_id,\n        rootId: null,\n        missingParentId: null,\n        laneSpanId: current.span_id,\n      }\n      break\n    }\n    pathIndex.set(currentId, path.length)\n    path.push(currentId)\n    currentId = current.parent_span_id\n  }\n\n  for (let index = path.length - 1; index >= 0; index -= 1) {\n    if (resolved.agentId === null && resolved.rootId === null) {\n      resolved = { ...resolved, rootId: path[index]!, laneSpanId: path[index]! }\n    } else if (\n      resolved.laneSpanId === (resolved.agentId ?? resolved.missingParentId ?? resolved.rootId)\n    ) {\n      resolved = { ...resolved, laneSpanId: path[index]! }\n    }\n    cache.set(path[index]!, resolved)\n  }\n  return resolved\n}\n\nfunction compareTokenSamples(a: TokenSample, b: TokenSample): number {\n  const aStart = spanEpochMillis(a.span.start_time)\n  const bStart = spanEpochMillis(b.span.start_time)\n  if (aStart === null && bStart !== null) return 1\n  if (aStart !== null && bStart === null) return -1\n  if (aStart !== null && bStart !== null && aStart !== bStart) return aStart - bStart\n  if (a.step !== null && b.step !== null && a.step !== b.step) return a.step - b.step\n  return a.span.span_id.localeCompare(b.span.span_id)\n}\n\nfunction serialTokenRuns(ordered: readonly TokenSample[]): TokenSample[][] {\n  const runs: TokenSample[][] = []\n  let serial: TokenSample[] = []\n  let overlap: TokenSample[] = []\n  let overlapEnd = Number.NEGATIVE_INFINITY\n\n  const flushSerial = () => {\n    if (serial.length > 0) runs.push(serial)\n    serial = []\n  }\n  const flushOverlap = () => {\n    if (overlap.length === 1) {\n      serial.push(overlap[0]!)\n    } else if (overlap.length > 1) {\n      flushSerial()\n      for (const sample of overlap) runs.push([sample])\n    }\n    overlap = []\n    overlapEnd = Number.NEGATIVE_INFINITY\n  }\n\n  for (const sample of ordered) {\n    const start = spanEpochMillis(sample.span.start_time)\n    const end = spanEpochMillis(sample.span.end_time)\n    if (start === null || end === null || sample.span.duration_ms <= 0 || end < start) {\n      flushOverlap()\n      flushSerial()\n      runs.push([sample])\n      continue\n    }\n    if (overlap.length > 0 && start >= overlapEnd) flushOverlap()\n    overlap.push(sample)\n    overlapEnd = Math.max(overlapEnd, end)\n  }\n  flushOverlap()\n  flushSerial()\n  return runs\n}\n\nfunction tokenSignals(sequence: BehavioralTokenSequence): SuboptimalSignal[] {\n  const signals: SuboptimalSignal[] = []\n  const inputs = sequence.inputTokenTrajectory\n  const outputs = sequence.outputTokenTrajectory\n  if (inputs.length >= 3 && inputs.every((value): value is number => value !== null)) {\n    const first = inputs[0]!\n    const last = inputs[inputs.length - 1]!\n    const isMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous)\n    const growthFromZero = first === 0 && last > 0\n    const growth = growthFromZero ? Infinity : first > 0 ? last / first : 0\n    if (isMonotonic && last > first && growth >= INPUT_GROWTH_FACTOR) {\n      const growthLabel = growthFromZero ? '0→nonzero (unbounded)' : `${growth.toFixed(1)}x`\n      signals.push({\n        code: 'monotonic-input-growth',\n        severity: 'high',\n        detail: `LLM input tokens grew ${growthLabel} (${first}→${last}) across ${inputs.length} serial calls without an intervening decrease.`,\n        evidence: {\n          first,\n          last,\n          growth_x: growthFromZero ? 'unbounded' : Number(growth.toFixed(2)),\n          calls: inputs.length,\n          scope: sequence.scopeId,\n          first_span_id: sequence.spanIds[0]!,\n          last_span_id: sequence.spanIds[sequence.spanIds.length - 1]!,\n        },\n      })\n    }\n  }\n\n  if (\n    inputs.length >= 3 &&\n    inputs.length === outputs.length &&\n    inputs.every((value): value is number => value !== null) &&\n    outputs.every((value): value is number => value !== null)\n  ) {\n    const first = outputs[0]!\n    const last = outputs[outputs.length - 1]!\n    const inputIsMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous)\n    const outputIsMonotonic = everyAdjacent(outputs, (previous, current) => current <= previous)\n    const inputGrew = inputs[inputs.length - 1]! > inputs[0]!\n    if (inputIsMonotonic && inputGrew && outputIsMonotonic && last < first) {\n      signals.push({\n        code: 'output-length-decay',\n        severity: 'medium',\n        detail: `LLM output tokens shrank ${first}→${last} over ${outputs.length} serial calls while input tokens increased monotonically.`,\n        evidence: {\n          first,\n          last,\n          calls: outputs.length,\n          scope: sequence.scopeId,\n          first_span_id: sequence.spanIds[0]!,\n          last_span_id: sequence.spanIds[sequence.spanIds.length - 1]!,\n        },\n      })\n    }\n  }\n  return signals\n}\n\nfunction everyAdjacent(\n  values: readonly number[],\n  predicate: (previous: number, current: number) => boolean,\n): boolean {\n  return values.slice(1).every((current, index) => predicate(values[index]!, current))\n}\n","/**\n * `behavioralAnalyst` — a DETERMINISTIC analyst (cost.kind = 'deterministic',\n * never calls the LLM). It produces the efficiency/behavioral findings a\n * tolerant agentic analyzer (HALO) re-derives per run inside the model —\n * context bloat, output decay, tool monoculture, missing self-verification —\n * directly from arithmetic over spans (`computeTraceMetrics`).\n *\n * Why it matters: these findings are model-agnostic BY CONSTRUCTION (no model\n * in the loop), so they cannot return 0 on a weak model the way the Ax-RLM\n * does — and they are strictly more reliable than HALO, which spends tokens\n * re-deriving the same numbers and can hallucinate the trend. The agentic\n * RLM kinds remain for SEMANTIC findings that genuinely need a model; this\n * analyst owns the behavioral class.\n */\n\nimport {\n  type BehavioralMetrics,\n  computeTraceMetrics,\n  type SuboptimalCode,\n} from '../trace-analyst/behavioral-metrics'\nimport type { TraceAnalysisStore } from '../trace-analyst/store'\nimport { type Analyst, type AnalystFinding, makeFinding } from './types'\n\nconst RECOMMENDED_ACTION: Record<SuboptimalCode, string> = {\n  'monotonic-input-growth':\n    'Inspect context assembly; if prior history is repeatedly included, summarize completed work before the next model call.',\n  'output-length-decay':\n    'Check late-step completeness; if shorter responses omit required work, add explicit completion criteria to the agent instructions.',\n  'single-tool-dependency':\n    'Test whether an inspect or verification tool improves outcomes after the repeated call fails or returns no progress.',\n  'no-self-verification':\n    'After state-changing actions, require an observable check before the agent proceeds.',\n}\n\nconst ANALYST_ID = 'efficiency-behavioral'\n\nconst AGGREGATE_CLAIM: Record<SuboptimalCode, (observed: number, analyzed: number) => string> = {\n  'monotonic-input-growth': (observed, analyzed) =>\n    `${observed}/${analyzed} analyzed traces showed input tokens grow from zero to nonzero or to at least 3x their initial value across at least 3 serial model calls without a decrease.`,\n  'output-length-decay': (observed, analyzed) =>\n    `${observed}/${analyzed} analyzed traces showed output tokens decrease while input tokens increased monotonically across at least 3 serial model calls.`,\n  'single-tool-dependency': (observed, analyzed) =>\n    `${observed}/${analyzed} analyzed traces used only one named tool across at least 3 tool calls.`,\n  'no-self-verification': (observed, analyzed) =>\n    `${observed}/${analyzed} analyzed traces had at least 3 tool calls without a verification-named tool call.`,\n}\n\n/**\n * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock\n * dependence beyond `produced_at` (overridable for deterministic tests).\n */\nexport function deriveEfficiencyFindings(\n  metrics: BehavioralMetrics,\n  opts: { analystId?: string; producedAt?: string } = {},\n): AnalystFinding[] {\n  const analystId = opts.analystId ?? ANALYST_ID\n  const traceId = metrics.traceId\n  return metrics.signals.map((sig) =>\n    makeFinding({\n      analyst_id: analystId,\n      area: 'efficiency',\n      subject: sig.code,\n      claim: sig.detail,\n      severity: sig.severity,\n      // Deterministic arithmetic over spans, not a model judgment → certain.\n      confidence: 1,\n      evidence_refs: [\n        {\n          kind: 'metric',\n          uri: traceId\n            ? `metric://trace/${encodeURIComponent(traceId)}/efficiency/${sig.code}`\n            : `metric://efficiency/${sig.code}`,\n          excerpt: JSON.stringify(sig.evidence),\n        },\n      ],\n      recommended_action: RECOMMENDED_ACTION[sig.code],\n      metadata: {\n        deterministic: true,\n        evidence: sig.evidence,\n        ...(traceId ? { trace_id: traceId } : {}),\n      },\n      id_basis: sig.code,\n      ...(opts.producedAt ? { produced_at: opts.producedAt } : {}),\n    }),\n  )\n}\n\n/** The deterministic behavioral/efficiency analyst (no LLM, any-model). */\nexport function behavioralAnalyst(): Analyst<TraceAnalysisStore> {\n  return {\n    id: ANALYST_ID,\n    description:\n      'Deterministic behavioral/efficiency findings over OTLP spans — token-growth, output-decay, tool-monoculture, missing self-verification. Zero LLM; model-agnostic by construction.',\n    inputKind: 'trace-store',\n    cost: { kind: 'deterministic' },\n    version: '2.0.0',\n    async analyze(store) {\n      const overview = await store.getOverview()\n      const analyzedTraceIds = [...new Set(overview.sample_trace_ids)].sort()\n      const findingsById = new Map<\n        string,\n        { finding: AnalystFinding; traceIds: string[]; evidence: AnalystFinding['evidence_refs'] }\n      >()\n      for (const traceId of analyzedTraceIds) {\n        const viewed = await store.viewTrace({ trace_id: traceId })\n        if (viewed.trace_id !== traceId) {\n          throw new Error(\n            `behavioralAnalyst: requested trace '${traceId}', received '${viewed.trace_id}'`,\n          )\n        }\n        if (!viewed.spans) {\n          throw new Error(\n            `behavioralAnalyst: trace '${traceId}' is oversized; complete spans are required`,\n          )\n        }\n        const metrics = computeTraceMetrics(viewed.spans)\n        if (metrics.traceId !== null && metrics.traceId !== traceId) {\n          throw new Error(\n            `behavioralAnalyst: requested trace '${traceId}', received '${metrics.traceId}'`,\n          )\n        }\n        for (const finding of deriveEfficiencyFindings(metrics)) {\n          const current = findingsById.get(finding.finding_id)\n          if (!current) {\n            findingsById.set(finding.finding_id, {\n              finding,\n              traceIds: [traceId],\n              evidence: [...finding.evidence_refs],\n            })\n            continue\n          }\n          current.traceIds.push(traceId)\n          current.evidence.push(...finding.evidence_refs)\n        }\n      }\n      return [...findingsById.values()].map(({ finding, traceIds, evidence }) => ({\n        ...finding,\n        claim: AGGREGATE_CLAIM[finding.subject as SuboptimalCode](\n          traceIds.length,\n          analyzedTraceIds.length,\n        ),\n        rationale: `${traceIds.length}/${analyzedTraceIds.length} analyzed traces exhibited this pattern.`,\n        evidence_refs: evidence,\n        metadata: {\n          deterministic: true,\n          trace_ids: traceIds,\n          observed_trace_count: traceIds.length,\n          analyzed_trace_count: analyzedTraceIds.length,\n        },\n      }))\n    },\n  }\n}\n","/**\n * `buildDefaultAnalystRegistry` — the canonical analyst suite, so consumers\n * stop hand-wiring `new AnalystRegistry()` + per-kind `createTraceAnalystKind`.\n *\n * The deterministic `behavioralAnalyst` is ALWAYS registered (it needs no\n * model and is model-agnostic by construction). The agentic RLM kinds are\n * registered only when an `ai` service is supplied — so a caller with no LLM\n * still gets the full behavioral/efficiency diagnosis, and the substrate's\n * \"any model (including no model)\" guarantee holds at the suite level.\n */\n\nimport type { AxAIService } from '@ax-llm/ax'\nimport { behavioralAnalyst } from './behavioral-analyst'\nimport { createTraceAnalystKind, type TraceAnalystKindSpec } from './kind-factory'\nimport { DEFAULT_TRACE_ANALYST_KINDS } from './kinds'\nimport { AnalystRegistry, type AnalystRegistryOptions } from './registry'\n\nexport interface DefaultAnalystRegistryOptions {\n  /** Ax service for the agentic RLM kinds. Omit → only the deterministic analyst. */\n  ai?: AxAIService\n  /** Model for the agentic kinds (falls back to the ai service default). */\n  model?: string\n  /** Which agentic kinds to register when `ai` is present. Default = the shipped suite. */\n  kinds?: readonly TraceAnalystKindSpec[]\n  /** Set false to omit the deterministic behavioral analyst (default: include). */\n  includeBehavioral?: boolean\n  /** Forwarded to the AnalystRegistry constructor (signal, tags, priorFindings). */\n  registry?: AnalystRegistryOptions\n}\n\nexport function buildDefaultAnalystRegistry(\n  opts: DefaultAnalystRegistryOptions = {},\n): AnalystRegistry {\n  const registry = new AnalystRegistry(opts.registry)\n  if (opts.includeBehavioral !== false) {\n    registry.register(behavioralAnalyst())\n  }\n  if (opts.ai) {\n    const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS\n    for (const spec of kinds) {\n      registry.register(createTraceAnalystKind(spec, { ai: opts.ai, model: opts.model }))\n    }\n  }\n  return registry\n}\n"],"mappings":"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","names":[]}