@tangle-network/agent-eval 0.136.0 → 0.138.0

package/dist/tools-DZGdROtG.js

@@ -0,0 +1,255 @@
+import { _ as TraceFileMissingError, a as createBoundedTraceAnalysisStore, c as traceStoreInputSchemas, d as TRACE_ANALYSIS_LIMITS, o as parseTraceInput, s as toTraceJsonSchema } from "./store-otlp-BenKynPE.js";
+import { AxJSRuntime, agent } from "@ax-llm/ax";
+//#region src/trace-analyst/loop.ts
+const TRACE_ANALYSIS_TOOL_INSTRUCTION = `Gather the evidence needed for the report with the trace tools.
+When the evidence is sufficient, call final(task, evidence) and let the response stage produce the declared report and findings fields.`;
+const TRACE_ANALYSIS_CONTEXT_INSTRUCTION = `The complete bounded trace data is available as inputs.context.
+Inspect it in the runtime, then call respond(task, evidence) and let the response stage produce the declared report and findings fields.`;
+const TRACE_ANALYSIS_RESPONDER_INSTRUCTION = `Use only evidence produced by the analysis stage.
+Do not invent trace ids, span ids, steps, tool results, or final verification outcomes.`;
+var TraceAnalysisTurnLimitError = class extends Error {
+	analystId;
+	stage;
+	maxTurns;
+	constructor(analystId, stage, maxTurns) {
+		super(`Trace analyst '${analystId}' reached maxTurns=${maxTurns} in the ${stage} stage without explicit completion`);
+		this.name = "TraceAnalysisTurnLimitError";
+		this.analystId = analystId;
+		this.stage = stage;
+		this.maxTurns = maxTurns;
+	}
+};
+async function runTraceAnalysisLoop(options) {
+	validateLoopLimits(options);
+	let turnCount = 0;
+	const completedStages = /* @__PURE__ */ new Set();
+	const onTurn = async (turn) => {
+		if (turn.stage === "executor") turnCount = Math.max(turnCount, turn.turn);
+		if (isExplicitCompletionTurn(turn)) completedStages.add(turn.stage);
+		await options.onTurn?.(turn);
+		if (turn.turn >= options.maxTurns && !completedStages.has(turn.stage)) throw new TraceAnalysisTurnLimitError(options.id, turn.stage, options.maxTurns);
+	};
+	const hasPreparedContext = options.context !== void 0;
+	const config = {
+		agentIdentity: {
+			name: options.id,
+			description: options.description
+		},
+		contextFields: hasPreparedContext ? ["context"] : [],
+		runtime: new AxJSRuntime({
+			permissions: [],
+			blockDynamicImport: true,
+			allowedModules: [],
+			freezeIntrinsics: true,
+			blockShadowRealm: true,
+			preventGlobalThisExtensions: false
+		}),
+		maxSubAgentCalls: options.maxSubqueries,
+		maxTurns: options.maxTurns,
+		maxRuntimeChars: options.maxRuntimeChars,
+		maxBatchedLlmQueryConcurrency: options.maxParallelSubqueries,
+		promptLevel: "detailed",
+		contextPolicy: {
+			preset: "full",
+			budget: "balanced"
+		},
+		directResponse: hasPreparedContext && options.tools.length === 0 ? "auto" : "off",
+		functions: options.tools,
+		executorOptions: {
+			description: `${options.prompt.trim()}\n\n${hasPreparedContext ? TRACE_ANALYSIS_CONTEXT_INSTRUCTION : TRACE_ANALYSIS_TOOL_INSTRUCTION}`,
+			...options.model ? { model: options.model } : {},
+			showThoughts: false,
+			thinkingTokenBudget: "none"
+		},
+		responderOptions: {
+			description: `${TRACE_ANALYSIS_RESPONDER_INSTRUCTION}\n\n${options.prompt.trim()}`,
+			...options.model ? { model: options.model } : {},
+			showThoughts: false,
+			thinkingTokenBudget: "none"
+		},
+		actorTurnCallback: onTurn,
+		bubbleErrors: [TraceFileMissingError]
+	};
+	const analyst = hasPreparedContext ? options.findingType === "string" ? agent("context:string, question:string -> report:string, findings:string[]", config) : agent("context:string, question:string -> report:string, findings:json[]", config) : options.findingType === "string" ? agent("question:string -> report:string, findings:string[]", config) : agent("question:string -> report:string, findings:json[]", config);
+	const output = hasPreparedContext ? await analyst.forward(options.ai, {
+		context: options.context,
+		question: options.question
+	}, options.signal ? { abortSignal: options.signal } : void 0) : await analyst.forward(options.ai, { question: options.question }, options.signal ? { abortSignal: options.signal } : void 0);
+	assertStageDidNotExhaust(options.id, "distiller", options.maxTurns, analyst.distiller?.getState()?.actionLogEntries);
+	assertStageDidNotExhaust(options.id, "executor", options.maxTurns, analyst.executor?.getState()?.actionLogEntries);
+	const completed = options.findingType === "string" ? readTraceAnalysisOutput(output, "string") : readTraceAnalysisOutput(output, "object");
+	const usage = analyst.getUsage();
+	const chatLog = splitChatLog(analyst.getChatLog());
+	return {
+		...completed,
+		usage: {
+			actor: usage.actor,
+			responder: usage.responder
+		},
+		chatLog,
+		turnCount
+	};
+}
+function isExplicitCompletionTurn(turn) {
+	return !turn.isError && isExplicitCompletionCode(turn.code);
+}
+function isExplicitCompletionCode(code) {
+	const executable = trimLeadingComments(code);
+	return /^(?:await\s+)?(?:final|respond|askClarification)\s*\(/.test(executable);
+}
+function assertStageDidNotExhaust(analystId, stage, maxTurns, entries) {
+	if (!entries || entries.length < maxTurns) return;
+	const last = entries.at(-1);
+	if (last && !last.tags.includes("error") && isExplicitCompletionCode(last.code)) return;
+	throw new TraceAnalysisTurnLimitError(analystId, stage, maxTurns);
+}
+function trimLeadingComments(code) {
+	let remaining = code.trimStart();
+	while (remaining.startsWith("//") || remaining.startsWith("/*")) {
+		if (remaining.startsWith("//")) {
+			const lineEnd = remaining.indexOf("\n");
+			if (lineEnd === -1) return "";
+			remaining = remaining.slice(lineEnd + 1).trimStart();
+			continue;
+		}
+		const commentEnd = remaining.indexOf("*/", 2);
+		if (commentEnd === -1) return "";
+		remaining = remaining.slice(commentEnd + 2).trimStart();
+	}
+	return remaining;
+}
+function splitChatLog(entries) {
+	const actor = [];
+	const responder = [];
+	for (const entry of entries) {
+		const name = entry && typeof entry === "object" && "name" in entry ? entry.name : void 0;
+		if (typeof name === "string" && (name === "responder" || name.endsWith(".responder"))) responder.push(entry);
+		else actor.push(entry);
+	}
+	return {
+		actor,
+		responder
+	};
+}
+function readTraceAnalysisOutput(value, findingType) {
+	if (!value || typeof value !== "object") throw new Error("Trace analyst response must contain report and findings");
+	const { report, findings } = value;
+	if (typeof report !== "string" || !Array.isArray(findings)) throw new Error("Trace analyst response must contain report and findings");
+	if (findingType === "string") {
+		if (findings.some((finding) => typeof finding !== "string")) throw new Error("Trace analyst response must contain string findings");
+		return {
+			report,
+			findings
+		};
+	}
+	return {
+		report,
+		findings
+	};
+}
+function validateLoopLimits(options) {
+	if (!Number.isSafeInteger(options.maxSubqueries) || options.maxSubqueries < 0) throw new TypeError("maxSubqueries must be a non-negative integer");
+	if (!Number.isSafeInteger(options.maxParallelSubqueries) || options.maxParallelSubqueries < 1) throw new TypeError("maxParallelSubqueries must be a positive integer");
+}
+//#endregion
+//#region src/trace-analyst/tools.ts
+const TRACE_ANALYST_TOOL_NAMESPACE = "traces";
+/** Bind all seven trace reads without exposing an agent framework type. */
+function buildTraceAnalysisToolDescriptors(options) {
+	const store = createBoundedTraceAnalysisStore(options.store, { budgets: options.budgets });
+	return [
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "getDatasetOverview",
+			description: "Dataset rollup: total traces, raw_jsonl_bytes, services, agents, models, tools, and sample_trace_ids. Always call this first without a regex_pattern.",
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.getOverview),
+			handler: async (args, context) => {
+				const { filters } = parseTraceInput("getDatasetOverview", traceStoreInputSchemas.getOverview, args ?? {});
+				return store.getOverview(filters, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "queryTraces",
+			description: `Paginated trace summaries, at most ${TRACE_ANALYSIS_LIMITS.queryTraces} per call. Each summary carries raw_jsonl_bytes; narrow with indexed filters before regex_pattern.`,
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.queryTraces),
+			handler: async (args, context) => {
+				const input = parseTraceInput("queryTraces", traceStoreInputSchemas.queryTraces, args);
+				return store.queryTraces(input, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "countTraces",
+			description: "Count traces matching filters. Use as a cheap pre-flight before a regex_pattern scan.",
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.countTraces),
+			handler: async (args, context) => {
+				const { filters } = parseTraceInput("countTraces", traceStoreInputSchemas.countTraces, args ?? {});
+				return store.countTraces(filters, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "viewTrace",
+			description: "Return all spans for one trace with bounded attributes. Oversized responses carry an oversized summary instead of spans; continue with searchTrace or viewSpans.",
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.viewTrace.omit({ per_attribute_byte_cap: true })),
+			handler: async (args, context) => {
+				const input = parseTraceInput("viewTrace", traceStoreInputSchemas.viewTrace.omit({ per_attribute_byte_cap: true }), args);
+				return store.viewTrace(input, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "viewSpans",
+			description: `Read 1..${TRACE_ANALYSIS_LIMITS.viewSpans} specific spans. Every requested id is accounted for in spans, missing_span_ids, or omitted_span_ids; retry omitted ids.`,
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.viewSpans.omit({ per_attribute_byte_cap: true })),
+			handler: async (args, context) => {
+				const input = parseTraceInput("viewSpans", traceStoreInputSchemas.viewSpans.omit({ per_attribute_byte_cap: true }), args);
+				return store.viewSpans(input, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "searchTrace",
+			description: `Regex search across one trace, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. When has_more is true, refine the regex instead of treating the result as complete.`,
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.searchTrace),
+			handler: async (args, context) => {
+				const input = parseTraceInput("searchTrace", traceStoreInputSchemas.searchTrace, args);
+				return store.searchTrace(input, context);
+			}
+		},
+		{
+			namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+			name: "searchSpan",
+			description: `Regex search inside one span, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. Use after viewSpans omits or truncates a large span payload.`,
+			parameters: toTraceJsonSchema(traceStoreInputSchemas.searchSpan),
+			handler: async (args, context) => {
+				const input = parseTraceInput("searchSpan", traceStoreInputSchemas.searchSpan, args);
+				return store.searchSpan(input, context);
+			}
+		}
+	];
+}
+/** Adapt the canonical descriptors into Ax functions used by the built-in analyst. */
+function buildTraceAnalystTools(options) {
+	return buildTraceAnalysisToolDescriptors(options).map((descriptor) => ({
+		namespace: descriptor.namespace,
+		name: descriptor.name,
+		description: descriptor.description,
+		parameters: descriptor.parameters,
+		func: (args, extra) => descriptor.handler(args, extra?.abortSignal ? { signal: extra.abortSignal } : void 0)
+	}));
+}
+function traceAnalystFunctionGroup(options) {
+	return {
+		namespace: TRACE_ANALYST_TOOL_NAMESPACE,
+		title: "Trace Analysis",
+		selectionCriteria: "Use for any inspection of OTLP-shaped trace data.",
+		description: "Discovery, narrowing, and bounded deep reads over a JSONL trace dataset. Always call getDatasetOverview first.",
+		functions: buildTraceAnalystTools(options)
+	};
+}
+//#endregion
+export { runTraceAnalysisLoop as a, traceAnalystFunctionGroup as i, buildTraceAnalysisToolDescriptors as n, buildTraceAnalystTools as r, TRACE_ANALYST_TOOL_NAMESPACE as t };
+
+//# sourceMappingURL=tools-DZGdROtG.js.map

package/dist/tools-DZGdROtG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-DZGdROtG.js","names":[],"sources":["../src/trace-analyst/loop.ts","../src/trace-analyst/tools.ts"],"sourcesContent":["import {\n  type AxAgentActorTurnCallback,\n  type AxAIService,\n  type AxFunction,\n  AxJSRuntime,\n  agent,\n} from '@ax-llm/ax'\nimport { TraceFileMissingError } from './store-otlp'\n\nconst TRACE_ANALYSIS_TOOL_INSTRUCTION = `Gather the evidence needed for the report with the trace tools.\nWhen the evidence is sufficient, call final(task, evidence) and let the response stage produce the declared report and findings fields.`\n\nconst TRACE_ANALYSIS_CONTEXT_INSTRUCTION = `The complete bounded trace data is available as inputs.context.\nInspect it in the runtime, then call respond(task, evidence) and let the response stage produce the declared report and findings fields.`\n\nconst TRACE_ANALYSIS_RESPONDER_INSTRUCTION = `Use only evidence produced by the analysis stage.\nDo not invent trace ids, span ids, steps, tool results, or final verification outcomes.`\n\nexport interface TraceAnalysisLoopResult<TFinding> {\n  report: string\n  findings: TFinding[]\n  usage: {\n    actor: readonly unknown[]\n    responder: readonly unknown[]\n  }\n  chatLog: {\n    actor: readonly unknown[]\n    responder: readonly unknown[]\n  }\n  turnCount: number\n}\n\nexport class TraceAnalysisTurnLimitError extends Error {\n  readonly analystId: string\n  readonly stage: 'distiller' | 'executor'\n  readonly maxTurns: number\n\n  constructor(analystId: string, stage: 'distiller' | 'executor', maxTurns: number) {\n    super(\n      `Trace analyst '${analystId}' reached maxTurns=${maxTurns} in the ${stage} stage without explicit completion`,\n    )\n    this.name = 'TraceAnalysisTurnLimitError'\n    this.analystId = analystId\n    this.stage = stage\n    this.maxTurns = maxTurns\n  }\n}\n\ninterface TraceAnalysisLoopOptions {\n  id: string\n  description: string\n  prompt: string\n  question: string\n  context?: string\n  ai: AxAIService\n  model?: string\n  tools: readonly AxFunction[]\n  maxSubqueries: number\n  maxParallelSubqueries: number\n  maxTurns: number\n  maxRuntimeChars: number\n  signal?: AbortSignal\n  onTurn?: AxAgentActorTurnCallback\n}\n\nexport function runTraceAnalysisLoop(\n  options: TraceAnalysisLoopOptions & { findingType: 'string' },\n): Promise<TraceAnalysisLoopResult<string>>\nexport function runTraceAnalysisLoop(\n  options: TraceAnalysisLoopOptions & { findingType: 'object' },\n): Promise<TraceAnalysisLoopResult<unknown>>\nexport async function runTraceAnalysisLoop(\n  options: TraceAnalysisLoopOptions & { findingType: 'string' | 'object' },\n): Promise<TraceAnalysisLoopResult<unknown>> {\n  validateLoopLimits(options)\n\n  let turnCount = 0\n  const completedStages = new Set<'distiller' | 'executor'>()\n  const onTurn: AxAgentActorTurnCallback = async (turn) => {\n    if (turn.stage === 'executor') turnCount = Math.max(turnCount, turn.turn)\n    if (isExplicitCompletionTurn(turn)) completedStages.add(turn.stage)\n    await options.onTurn?.(turn)\n    if (turn.turn >= options.maxTurns && !completedStages.has(turn.stage)) {\n      throw new TraceAnalysisTurnLimitError(options.id, turn.stage, options.maxTurns)\n    }\n  }\n  const hasPreparedContext = options.context !== undefined\n  const config = {\n    agentIdentity: { name: options.id, description: options.description },\n    contextFields: hasPreparedContext ? (['context'] as const) : ([] as const),\n    runtime: new AxJSRuntime({\n      permissions: [],\n      blockDynamicImport: true,\n      allowedModules: [],\n      freezeIntrinsics: true,\n      blockShadowRealm: true,\n      preventGlobalThisExtensions: false,\n    }),\n    maxSubAgentCalls: options.maxSubqueries,\n    maxTurns: options.maxTurns,\n    maxRuntimeChars: options.maxRuntimeChars,\n    maxBatchedLlmQueryConcurrency: options.maxParallelSubqueries,\n    promptLevel: 'detailed' as const,\n    contextPolicy: { preset: 'full' as const, budget: 'balanced' as const },\n    directResponse:\n      hasPreparedContext && options.tools.length === 0 ? ('auto' as const) : ('off' as const),\n    functions: options.tools,\n    executorOptions: {\n      description: `${options.prompt.trim()}\\n\\n${\n        hasPreparedContext ? TRACE_ANALYSIS_CONTEXT_INSTRUCTION : TRACE_ANALYSIS_TOOL_INSTRUCTION\n      }`,\n      ...(options.model ? { model: options.model } : {}),\n      showThoughts: false,\n      thinkingTokenBudget: 'none' as const,\n    },\n    responderOptions: {\n      description: `${TRACE_ANALYSIS_RESPONDER_INSTRUCTION}\\n\\n${options.prompt.trim()}`,\n      ...(options.model ? { model: options.model } : {}),\n      showThoughts: false,\n      thinkingTokenBudget: 'none' as const,\n    },\n    actorTurnCallback: onTurn,\n    bubbleErrors: [TraceFileMissingError],\n  }\n  const analyst = hasPreparedContext\n    ? options.findingType === 'string'\n      ? agent('context:string, question:string -> report:string, findings:string[]', config)\n      : agent('context:string, question:string -> report:string, findings:json[]', config)\n    : options.findingType === 'string'\n      ? agent('question:string -> report:string, findings:string[]', config)\n      : agent('question:string -> report:string, findings:json[]', config)\n\n  const output = hasPreparedContext\n    ? await analyst.forward(\n        options.ai,\n        { context: options.context!, question: options.question } as never,\n        options.signal ? { abortSignal: options.signal } : undefined,\n      )\n    : await analyst.forward(\n        options.ai,\n        { question: options.question },\n        options.signal ? { abortSignal: options.signal } : undefined,\n      )\n  assertStageDidNotExhaust(\n    options.id,\n    'distiller',\n    options.maxTurns,\n    analyst.distiller?.getState()?.actionLogEntries,\n  )\n  assertStageDidNotExhaust(\n    options.id,\n    'executor',\n    options.maxTurns,\n    analyst.executor?.getState()?.actionLogEntries,\n  )\n  const completed =\n    options.findingType === 'string'\n      ? readTraceAnalysisOutput(output, 'string')\n      : readTraceAnalysisOutput(output, 'object')\n  const usage = analyst.getUsage()\n  const chatLog = splitChatLog(analyst.getChatLog())\n\n  return {\n    ...completed,\n    usage: {\n      actor: usage.actor,\n      responder: usage.responder,\n    },\n    chatLog,\n    turnCount,\n  }\n}\n\nfunction isExplicitCompletionTurn(turn: Parameters<AxAgentActorTurnCallback>[0]): boolean {\n  return !turn.isError && isExplicitCompletionCode(turn.code)\n}\n\nfunction isExplicitCompletionCode(code: string): boolean {\n  const executable = trimLeadingComments(code)\n  return /^(?:await\\s+)?(?:final|respond|askClarification)\\s*\\(/.test(executable)\n}\n\nfunction assertStageDidNotExhaust(\n  analystId: string,\n  stage: 'distiller' | 'executor',\n  maxTurns: number,\n  entries:\n    | readonly {\n        code: string\n        tags: readonly string[]\n      }[]\n    | undefined,\n): void {\n  if (!entries || entries.length < maxTurns) return\n  const last = entries.at(-1)\n  if (last && !last.tags.includes('error') && isExplicitCompletionCode(last.code)) return\n  throw new TraceAnalysisTurnLimitError(analystId, stage, maxTurns)\n}\n\nfunction trimLeadingComments(code: string): string {\n  let remaining = code.trimStart()\n  while (remaining.startsWith('//') || remaining.startsWith('/*')) {\n    if (remaining.startsWith('//')) {\n      const lineEnd = remaining.indexOf('\\n')\n      if (lineEnd === -1) return ''\n      remaining = remaining.slice(lineEnd + 1).trimStart()\n      continue\n    }\n    const commentEnd = remaining.indexOf('*/', 2)\n    if (commentEnd === -1) return ''\n    remaining = remaining.slice(commentEnd + 2).trimStart()\n  }\n  return remaining\n}\n\nfunction splitChatLog(entries: readonly unknown[]): {\n  actor: readonly unknown[]\n  responder: readonly unknown[]\n} {\n  const actor: unknown[] = []\n  const responder: unknown[] = []\n  for (const entry of entries) {\n    const name =\n      entry && typeof entry === 'object' && 'name' in entry\n        ? (entry as { name?: unknown }).name\n        : undefined\n    if (typeof name === 'string' && (name === 'responder' || name.endsWith('.responder'))) {\n      responder.push(entry)\n    } else {\n      actor.push(entry)\n    }\n  }\n  return { actor, responder }\n}\n\ninterface CompletedTraceAnalysis<TFinding> {\n  report: string\n  findings: TFinding[]\n}\n\nexport function readTraceAnalysisOutput(\n  value: unknown,\n  findingType: 'string',\n): CompletedTraceAnalysis<string>\nexport function readTraceAnalysisOutput(\n  value: unknown,\n  findingType: 'object',\n): CompletedTraceAnalysis<unknown>\nexport function readTraceAnalysisOutput(\n  value: unknown,\n  findingType: 'string' | 'object',\n): CompletedTraceAnalysis<unknown> {\n  if (!value || typeof value !== 'object') {\n    throw new Error('Trace analyst response must contain report and findings')\n  }\n  const { report, findings } = value as { report?: unknown; findings?: unknown }\n  if (typeof report !== 'string' || !Array.isArray(findings)) {\n    throw new Error('Trace analyst response must contain report and findings')\n  }\n  if (findingType === 'string') {\n    if (findings.some((finding) => typeof finding !== 'string')) {\n      throw new Error('Trace analyst response must contain string findings')\n    }\n    return { report, findings: findings as string[] }\n  }\n  return { report, findings }\n}\n\nfunction validateLoopLimits(options: TraceAnalysisLoopOptions): void {\n  if (!Number.isSafeInteger(options.maxSubqueries) || options.maxSubqueries < 0) {\n    throw new TypeError('maxSubqueries must be a non-negative integer')\n  }\n  if (!Number.isSafeInteger(options.maxParallelSubqueries) || options.maxParallelSubqueries < 1) {\n    throw new TypeError('maxParallelSubqueries must be a positive integer')\n  }\n}\n","/**\n * Canonical transport-neutral trace tools plus the Ax adapter used by the\n * built-in analyst. Schemas and handlers originate here; provider adapters\n * only translate descriptor fields and cancellation context.\n */\n\nimport type { AxFunction } from '@ax-llm/ax'\n\nimport type { EvalToolDef } from '../eval-tools'\nimport {\n  type BoundedTraceAnalysisStoreOptions,\n  createBoundedTraceAnalysisStore,\n  TRACE_ANALYSIS_LIMITS,\n  type TraceAnalysisStore,\n} from './store'\nimport { parseTraceInput, toTraceJsonSchema, traceStoreInputSchemas } from './store-schemas'\n\nexport const TRACE_ANALYST_TOOL_NAMESPACE = 'traces' as const\n\nexport interface BuildTraceAnalysisToolsOptions extends BoundedTraceAnalysisStoreOptions {\n  store: TraceAnalysisStore\n}\n\nexport interface TraceAnalysisToolDescriptor extends EvalToolDef {\n  namespace: typeof TRACE_ANALYST_TOOL_NAMESPACE\n}\n\n/** Bind all seven trace reads without exposing an agent framework type. */\nexport function buildTraceAnalysisToolDescriptors(\n  options: BuildTraceAnalysisToolsOptions,\n): TraceAnalysisToolDescriptor[] {\n  const store = createBoundedTraceAnalysisStore(options.store, { budgets: options.budgets })\n\n  return [\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'getDatasetOverview',\n      description:\n        'Dataset rollup: total traces, raw_jsonl_bytes, services, agents, models, tools, ' +\n        'and sample_trace_ids. Always call this first without a regex_pattern.',\n      parameters: toTraceJsonSchema(traceStoreInputSchemas.getOverview),\n      handler: async (args, context) => {\n        const { filters } = parseTraceInput(\n          'getDatasetOverview',\n          traceStoreInputSchemas.getOverview,\n          args ?? {},\n        )\n        return store.getOverview(filters, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'queryTraces',\n      description:\n        `Paginated trace summaries, at most ${TRACE_ANALYSIS_LIMITS.queryTraces} per call. ` +\n        'Each summary carries raw_jsonl_bytes; narrow with indexed filters before regex_pattern.',\n      parameters: toTraceJsonSchema(traceStoreInputSchemas.queryTraces),\n      handler: async (args, context) => {\n        const input = parseTraceInput('queryTraces', traceStoreInputSchemas.queryTraces, args)\n        return store.queryTraces(input, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'countTraces',\n      description:\n        'Count traces matching filters. Use as a cheap pre-flight before a regex_pattern scan.',\n      parameters: toTraceJsonSchema(traceStoreInputSchemas.countTraces),\n      handler: async (args, context) => {\n        const { filters } = parseTraceInput(\n          'countTraces',\n          traceStoreInputSchemas.countTraces,\n          args ?? {},\n        )\n        return store.countTraces(filters, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'viewTrace',\n      description:\n        'Return all spans for one trace with bounded attributes. Oversized responses carry ' +\n        'an oversized summary instead of spans; continue with searchTrace or viewSpans.',\n      parameters: toTraceJsonSchema(\n        traceStoreInputSchemas.viewTrace.omit({\n          per_attribute_byte_cap: true,\n        }),\n      ),\n      handler: async (args, context) => {\n        const input = parseTraceInput(\n          'viewTrace',\n          traceStoreInputSchemas.viewTrace.omit({ per_attribute_byte_cap: true }),\n          args,\n        )\n        return store.viewTrace(input, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'viewSpans',\n      description:\n        `Read 1..${TRACE_ANALYSIS_LIMITS.viewSpans} specific spans. Every requested id is ` +\n        'accounted for in spans, missing_span_ids, or omitted_span_ids; retry omitted ids.',\n      parameters: toTraceJsonSchema(\n        traceStoreInputSchemas.viewSpans.omit({\n          per_attribute_byte_cap: true,\n        }),\n      ),\n      handler: async (args, context) => {\n        const input = parseTraceInput(\n          'viewSpans',\n          traceStoreInputSchemas.viewSpans.omit({ per_attribute_byte_cap: true }),\n          args,\n        )\n        return store.viewSpans(input, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'searchTrace',\n      description:\n        `Regex search across one trace, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. ` +\n        'When has_more is true, refine the regex instead of treating the result as complete.',\n      parameters: toTraceJsonSchema(traceStoreInputSchemas.searchTrace),\n      handler: async (args, context) => {\n        const input = parseTraceInput('searchTrace', traceStoreInputSchemas.searchTrace, args)\n        return store.searchTrace(input, context)\n      },\n    },\n    {\n      namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n      name: 'searchSpan',\n      description:\n        `Regex search inside one span, bounded to ${TRACE_ANALYSIS_LIMITS.searchMatches} hits. ` +\n        'Use after viewSpans omits or truncates a large span payload.',\n      parameters: toTraceJsonSchema(traceStoreInputSchemas.searchSpan),\n      handler: async (args, context) => {\n        const input = parseTraceInput('searchSpan', traceStoreInputSchemas.searchSpan, args)\n        return store.searchSpan(input, context)\n      },\n    },\n  ]\n}\n\n/** Adapt the canonical descriptors into Ax functions used by the built-in analyst. */\nexport function buildTraceAnalystTools(options: BuildTraceAnalysisToolsOptions): AxFunction[] {\n  return buildTraceAnalysisToolDescriptors(options).map((descriptor) => ({\n    namespace: descriptor.namespace,\n    name: descriptor.name,\n    description: descriptor.description,\n    parameters: descriptor.parameters as AxFunction['parameters'],\n    func: (args, extra) =>\n      descriptor.handler(args, extra?.abortSignal ? { signal: extra.abortSignal } : undefined),\n  }))\n}\n\nexport function traceAnalystFunctionGroup(options: BuildTraceAnalysisToolsOptions): {\n  namespace: string\n  title: string\n  selectionCriteria: string\n  description: string\n  functions: AxFunction[]\n} {\n  return {\n    namespace: TRACE_ANALYST_TOOL_NAMESPACE,\n    title: 'Trace Analysis',\n    selectionCriteria: 'Use for any inspection of OTLP-shaped trace data.',\n    description:\n      'Discovery, narrowing, and bounded deep reads over a JSONL trace dataset. ' +\n      'Always call getDatasetOverview first.',\n    functions: buildTraceAnalystTools(options),\n  }\n}\n"],"mappings":"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"}

package/dist/traces.d.ts

@@ -1,12 +1,11 @@
 import { C as TraceEvent, D as isSandboxSpan, E as isRetrievalSpan, O as isToolSpan, S as ToolSpan, T as isLlmSpan, _ as Span, a as FAILURE_CLASSES, b as SpanStatus, c as JudgeSpan, d as RetrievalSpan, f as Run, g as SandboxSpan, h as RunStatus, i as EventKind, l as LlmSpan, m as RunOutcome, n as BudgetLedgerEntry, o as FailureClass, p as RunLayer, r as BudgetSpec, s as GenericSpan, t as Artifact, u as Message, v as SpanBase, w as isJudgeSpan, x as TRACE_SCHEMA_VERSION, y as SpanKind } from "./schema-BtVldJ3T.js";
-import { a as ExtractedUsage, c as extractUsageFromResponse, i as ExtractUsageFromSseOptions, l as extractUsageFromSse, n as CaptureFetchOptions, o as SseUsageMode, r as captureFetchToRawSink, s as extractUsage, t as CaptureFetchContext } from "./index-C2fkZhv_.js";
-import { a as NoopRawProviderSink, c as RawProviderEvent, d as defaultProviderRedactor, f as providerFromBaseUrl, i as InMemoryRawProviderSinkOptions, l as RawProviderSink, n as FileSystemRawProviderSinkOptions, o as ProviderRedactor, r as InMemoryRawProviderSink, s as RawProviderDirection, t as FileSystemRawProviderSink, u as RawProviderSinkFilter } from "./raw-provider-sink-BU29Sh8h.js";
+import { a as ExtractedUsage, c as extractUsageFromResponse, i as ExtractUsageFromSseOptions, l as extractUsageFromSse, n as CaptureFetchOptions, o as SseUsageMode, r as captureFetchToRawSink, s as extractUsage, t as CaptureFetchContext } from "./index-sMN_hI4E.js";
+import { _t as RawProviderSink, bt as providerFromBaseUrl, dt as InMemoryRawProviderSink, ft as InMemoryRawProviderSinkOptions, gt as RawProviderEvent, ht as RawProviderDirection, lt as FileSystemRawProviderSink, mt as ProviderRedactor, pt as NoopRawProviderSink, ut as FileSystemRawProviderSinkOptions, vt as RawProviderSinkFilter, yt as defaultProviderRedactor } from "./types-5q2T25iW.js";
 import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o as SpanFilter, r as FileSystemTraceStoreOptions, s as TraceStore, t as EventFilter } from "./store-CT9YIIve.js";
 import { a as TraceEmitterOptions, i as TraceEmitter, n as RunCompleteHookContext, o as llmSpanFromProvider, r as SpanHandle, t as RunCompleteHook } from "./emitter-DGQGoLyj.js";
-import { a as RunIntegrityReport, i as RunIntegrityIssueCode, n as RunIntegrityExpectations, o as assertRunCaptured, r as RunIntegrityIssue, s as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-rmVhXWA7.js";
-import { $ as planTraceInsightQuestions, A as firstStringAttr, At as OtlpSpan, B as TraceInsightPanelRole, C as otlpRowsToRunRecords, Ct as applyToolSpanOtlpAttributes, D as ProjectedOtlpSpan, Dt as OTEL_AGENT_EVAL_SCOPE, E as otlpToTraceRunRecords, Et as traceSpanKindToOpenInferenceKind, F as FlattenOtlpOptions, G as TraceInsightSuite, H as TraceInsightQualityGate, I as flattenOtlpExportToNdjson, J as buildTraceInsightPrompt, K as TraceInsightTask, L as OtlpFlatLine, M as projectOtlpFlatLine, N as readOtlpStatus, O as asString, Ot as OtlpExport, P as stringField, Q as inferDomainKeywords, R as TraceInsightContext, S as TraceAggregate, St as ToolSpanOtlpInput, T as otlpToRunRecords, Tt as isOtlpModelCall, U as TraceInsightQuestion, V as TraceInsightPromptInput, W as TraceInsightReadiness, X as describeTraceInsightScope, Y as defaultTraceInsightPanel, Z as domainEvidencePattern, _ as toolSpansToTraceAnalysisStore, _t as OtelExportConfig, a as ReplayFetchOptions, at as TraceStoreToOtlpOptions, b as OtlpToRunRecordsOptions, bt as OtlpSpanRole, c as buildTraceAnalystTools, ct as DEFAULT_REDACTION_RULES, d as OtlpFileTraceStoreOptions, dt as RedactionRule, et as scoreTraceInsightReadiness, f as SpanNotFoundError, ft as redactString, g as TraceNotFoundError, gt as ExportableSpan, h as TraceFileMissingError, ht as otelRunCompleteHook, i as ReplayCacheStats, it as TraceStoreSource, j as inferOtlpKind, jt as exportRunAsOtlp, k as extractOtlpAttributes, kt as OtlpResourceSpans, l as traceAnalystFunctionGroup, lt as REDACTION_VERSION, m as ToolTraceMissingError, mt as createOtelTracingStore, n as ReplayCacheEntry, nt as TraceAnalystHookOptions, o as createReplayFetch, ot as TracesToOtlpResult, p as ToolSpansToTraceAnalysisStoreOptions, pt as redactValue, q as buildTraceInsightContext, r as ReplayCacheMissError, rt as traceAnalystOnRunComplete, s as iterateRawCalls, st as convertTraceStoresToOtlp, t as ReplayCache, tt as tokenizeDomainWords, u as OtlpFileTraceStore, ut as RedactionReport, v as TRACE_ANALYST_ACTOR_DESCRIPTION, vt as OtelExporter, w as otlpRowsToTraceRunRecords, wt as classifyOtlpSpanRole, x as OtlpTraceRunRecord, xt as OtlpSpanRoleInput, y as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, yt as createOtelExporter, z as TraceInsightFinding } from "./replay-BRfMIs81.js";
+import { a as RunIntegrityReport, i as RunIntegrityIssueCode, n as RunIntegrityExpectations, o as assertRunCaptured, r as RunIntegrityIssue, s as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-B-MLFz0I.js";
+import { $ as buildTraceInsightContext, A as otlpRowsToTraceRunRecords, At as RedactionReport, B as stringField, Bt as OtlpSpanRole, C as otlpTextToTraceAnalysisStore, Ct as createBoundedTraceAnalysisStore, D as OtlpTraceRunRecord, Dt as convertTraceStoresToOtlp, E as OtlpToRunRecordsOptions, Et as TracesToOtlpResult, F as extractOtlpAttributes, Ft as otelRunCompleteHook, G as TraceInsightFinding, Gt as isOtlpModelCall, H as flattenOtlpExportToNdjson, Ht as ToolSpanOtlpInput, I as firstStringAttr, It as ExportableSpan, J as TraceInsightQualityGate, Jt as OtlpExport, K as TraceInsightPanelRole, Kt as traceSpanKindToOpenInferenceKind, L as inferOtlpKind, Lt as OtelExportConfig, M as otlpToTraceRunRecords, Mt as redactString, N as ProjectedOtlpSpan, Nt as redactValue, O as TraceAggregate, Ot as DEFAULT_REDACTION_RULES, P as asString, Pt as createOtelTracingStore, Q as TraceInsightTask, R as projectOtlpFlatLine, Rt as OtelExporter, S as ToolSpansToTraceAnalysisStoreOptions, St as analyzeTraces, T as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, Tt as TraceStoreToOtlpOptions, U as OtlpFlatLine, Ut as applyToolSpanOtlpAttributes, V as FlattenOtlpOptions, Vt as OtlpSpanRoleInput, W as TraceInsightContext, Wt as classifyOtlpSpanRole, X as TraceInsightReadiness, Xt as OtlpSpan, Y as TraceInsightQuestion, Yt as OtlpResourceSpans, Z as TraceInsightSuite, Zt as exportRunAsOtlp, _t as TraceNotFoundError, a as ReplayFetchOptions, at as planTraceInsightQuestions, b as OtlpFileTraceStore, bt as AnalyzeTracesResult, c as BuildTraceAnalysisToolsOptions, ct as TraceAnalystHookOptions, d as buildTraceAnalysisToolDescriptors, dt as TraceAnalysisLimitError, et as buildTraceInsightPrompt, f as buildTraceAnalystTools, ft as TraceAnalysisStoreContractError, gt as TraceFileTooLargeError, ht as TraceFileMissingError, i as ReplayCacheStats, it as inferDomainKeywords, j as otlpToRunRecords, jt as RedactionRule, k as otlpRowsToRunRecords, kt as REDACTION_VERSION, l as TRACE_ANALYST_TOOL_NAMESPACE, lt as traceAnalystOnRunComplete, mt as TraceFileMalformedError, n as ReplayCacheEntry, nt as describeTraceInsightScope, o as createReplayFetch, ot as scoreTraceInsightReadiness, p as traceAnalystFunctionGroup, pt as TraceAnalysisValidationError, q as TraceInsightPromptInput, qt as OTEL_AGENT_EVAL_SCOPE, r as ReplayCacheMissError, rt as domainEvidencePattern, s as iterateRawCalls, st as tokenizeDomainWords, t as ReplayCache, tt as defaultTraceInsightPanel, u as TraceAnalysisToolDescriptor, ut as SpanNotFoundError, v as ToolTraceMissingError, vt as AnalyzeTracesInput, w as TRACE_ANALYST_ACTOR_DESCRIPTION, wt as TraceStoreSource, x as OtlpFileTraceStoreOptions, xt as AnalyzeTracesTurnSnapshot, y as toolSpansToTraceAnalysisStore, yt as AnalyzeTracesOptions, z as readOtlpStatus, zt as createOtelExporter } from "./replay-DbIYwso6.js";
 import { C as TOOL_LATENCY_MS, D as asNumber, E as applyLlmSpanOtlpAttributes, O as contextInputTokens, S as TOOL_ARGS_CAPTURED, T as TOOL_NAME_ATTR_KEYS, _ as LlmSpanOtlpInput, a as LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, b as RUN_COST_ATTR_KEYS, c as LLM_COST_USD, d as LLM_MODEL_ATTR_KEYS, f as LLM_MODEL_NAME, g as LLM_REASONING_TOKEN_ATTR_KEYS, h as LLM_REASONING_TOKENS, i as LLM_CACHE_WRITE_TOKENS, k as firstNumberAttr, l as LLM_INPUT_TOKENS, m as LLM_OUTPUT_TOKEN_ATTR_KEYS, n as LLM_CACHED_TOKENS, o as LLM_CONTEXT_TOKENS, p as LLM_OUTPUT_TOKENS, r as LLM_CACHED_TOKEN_ATTR_KEYS, s as LLM_COST_ATTR_KEYS, t as INPUT_VALUE, u as LLM_INPUT_TOKEN_ATTR_KEYS, v as OPENINFERENCE_SPAN_KIND, w as TOOL_NAME, x as SPAN_KIND_ATTR_KEYS, y as OUTPUT_VALUE } from "./attribute-vocabulary-DLJ6303h.js";
 import { a as judgeSpans, c as runsForScenario, i as hasCapturedToolArgs, l as toolSpans, n as argHash, o as llmSpans, r as groupBy, s as runFailureClass, t as aggregateLlm } from "./query-CJ_DX8vl.js";
-import { _ as ViewTraceOversized, a as QueryTracesPage, c as SpanMatchRecord, d as TraceAnalystFilters, f as TraceAnalystSpan, g as ViewSpansResult, h as TraceAnalystTraceSummary, i as ErrorCluster, l as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, m as TraceAnalystSpanStatus, n as DEFAULT_TRACE_ANALYST_BUDGETS, o as SearchSpanResult, p as TraceAnalystSpanKind, r as DatasetOverview, s as SearchTraceResult, t as TraceAnalysisStore, u as TraceAnalystByteBudgets, v as ViewTraceResult } from "./store-CxJry_cs.js";
-import { a as analyzeTraces, i as AnalyzeTracesTurnSnapshot, n as AnalyzeTracesOptions, r as AnalyzeTracesResult, t as AnalyzeTracesInput } from "./analyst-BkTS3C58.js";
-export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, Artifact, BudgetLedgerEntry, BudgetSpec, CaptureFetchContext, CaptureFetchOptions, DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, EventFilter, EventKind, ExportableSpan, ExtractUsageFromSseOptions, ExtractedUsage, FAILURE_CLASSES, FailureClass, FileSystemRawProviderSink, FileSystemRawProviderSinkOptions, FileSystemTraceStore, FileSystemTraceStoreOptions, type FlattenOtlpOptions, GenericSpan, INPUT_VALUE, InMemoryRawProviderSink, InMemoryRawProviderSinkOptions, InMemoryTraceStore, JudgeSpan, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, LlmSpan, LlmSpanOtlpInput, Message, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtelExportConfig, OtelExporter, OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, OtlpResourceSpans, OtlpSpan, OtlpSpanRole, OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, RUN_COST_ATTR_KEYS, RawProviderDirection, RawProviderEvent, RawProviderSink, RawProviderSinkFilter, RedactionReport, RedactionRule, ReplayCache, ReplayCacheEntry, ReplayCacheMissError, ReplayCacheStats, ReplayFetchOptions, RetrievalSpan, Run, RunCompleteHook, RunCompleteHookContext, RunFilter, RunIntegrityError, RunIntegrityExpectations, RunIntegrityIssue, RunIntegrityIssueCode, RunIntegrityReport, RunLayer, RunOutcome, RunStatus, SPAN_KIND_ATTR_KEYS, SandboxSpan, type SearchSpanResult, type SearchTraceResult, Span, SpanBase, SpanFilter, SpanHandle, SpanKind, type SpanMatchRecord, SpanNotFoundError, SpanStatus, SseUsageMode, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolSpan, ToolSpanOtlpInput, type ToolSpansToTraceAnalysisStoreOptions, ToolTraceMissingError, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, TraceEmitterOptions, TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, TraceStore, TraceStoreSource, TraceStoreToOtlpOptions, TracesToOtlpResult, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, 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, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+import { A as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, C as DEFAULT_TRACE_ANALYST_BUDGETS, D as SearchSpanResult, E as QueryTracesPage, F as TraceAnalystSpanStatus, I as TraceAnalystTraceSummary, L as ViewSpansResult, M as TraceAnalystFilters, N as TraceAnalystSpan, O as SearchTraceResult, P as TraceAnalystSpanKind, R as ViewTraceOversized, S as TraceAnalysisStoreContext, T as ErrorCluster, b as TRACE_ANALYSIS_LIMITS, j as TraceAnalystByteBudgets, k as SpanMatchRecord, w as DatasetOverview, x as TraceAnalysisStore, y as BoundedTraceAnalysisStoreOptions, z as ViewTraceResult } from "./types-BtJhn8v6.js";
+export { type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, Artifact, type BoundedTraceAnalysisStoreOptions, BudgetLedgerEntry, BudgetSpec, type BuildTraceAnalysisToolsOptions, CaptureFetchContext, CaptureFetchOptions, DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, type DatasetOverview, type ErrorCluster, EventFilter, EventKind, ExportableSpan, ExtractUsageFromSseOptions, ExtractedUsage, FAILURE_CLASSES, FailureClass, FileSystemRawProviderSink, FileSystemRawProviderSinkOptions, FileSystemTraceStore, FileSystemTraceStoreOptions, type FlattenOtlpOptions, GenericSpan, INPUT_VALUE, InMemoryRawProviderSink, InMemoryRawProviderSinkOptions, InMemoryTraceStore, JudgeSpan, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, LlmSpan, LlmSpanOtlpInput, Message, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtelExportConfig, OtelExporter, OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, OtlpResourceSpans, OtlpSpan, OtlpSpanRole, OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type ProjectedOtlpSpan, ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, RUN_COST_ATTR_KEYS, RawProviderDirection, RawProviderEvent, RawProviderSink, RawProviderSinkFilter, RedactionReport, RedactionRule, ReplayCache, ReplayCacheEntry, ReplayCacheMissError, ReplayCacheStats, ReplayFetchOptions, RetrievalSpan, Run, RunCompleteHook, RunCompleteHookContext, RunFilter, RunIntegrityError, RunIntegrityExpectations, RunIntegrityIssue, RunIntegrityIssueCode, RunIntegrityReport, RunLayer, RunOutcome, RunStatus, SPAN_KIND_ATTR_KEYS, SandboxSpan, type SearchSpanResult, type SearchTraceResult, Span, SpanBase, SpanFilter, SpanHandle, SpanKind, type SpanMatchRecord, SpanNotFoundError, SpanStatus, SseUsageMode, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolSpan, ToolSpanOtlpInput, type ToolSpansToTraceAnalysisStoreOptions, ToolTraceMissingError, type TraceAggregate, TraceAnalysisLimitError, type TraceAnalysisStore, type TraceAnalysisStoreContext, TraceAnalysisStoreContractError, type TraceAnalysisToolDescriptor, TraceAnalysisValidationError, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystHookOptions, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, TraceEmitterOptions, TraceEvent, TraceFileMalformedError, TraceFileMissingError, TraceFileTooLargeError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, TraceStore, TraceStoreSource, TraceStoreToOtlpOptions, TracesToOtlpResult, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalysisToolDescriptors, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, isRetrievalSpan, isSandboxSpan, isToolSpan, iterateRawCalls, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };

package/dist/traces.js

@@ -1,12 +1,12 @@
 import { a as providerFromBaseUrl, i as defaultProviderRedactor, n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-BQd7mzyT.js";
 import { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, RUN_COST_ATTR_KEYS, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, applyLlmSpanOtlpAttributes, asNumber, contextInputTokens, firstNumberAttr } from "./trace-attributes.js";
-import { C as stringField, D as traceSpanKindToOpenInferenceKind, E as isOtlpModelCall, T as classifyOtlpSpanRole, _ as extractOtlpAttributes, a as SpanNotFoundError, b as projectOtlpFlatLine, c as TraceNotFoundError, d as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, h as asString, i as OtlpFileTraceStore, l as toolSpansToTraceAnalysisStore, n as traceAnalystFunctionGroup, o as ToolTraceMissingError, s as TraceFileMissingError, t as buildTraceAnalystTools, u as DEFAULT_TRACE_ANALYST_BUDGETS, v as firstStringAttr, w as applyToolSpanOtlpAttributes, x as readOtlpStatus, y as inferOtlpKind } from "./tools-D8yTtNSN.js";
+import { A as classifyOtlpSpanRole, C as firstStringAttr, E as readOtlpStatus, M as traceSpanKindToOpenInferenceKind, O as stringField, S as extractOtlpAttributes, T as projectOtlpFlatLine, _ as TraceFileMissingError, a as createBoundedTraceAnalysisStore, b as asString, d as TRACE_ANALYSIS_LIMITS, f as SpanNotFoundError, g as TraceFileMalformedError, h as TraceAnalysisValidationError, i as otlpTextToTraceAnalysisStore, j as isOtlpModelCall, k as applyToolSpanOtlpAttributes, l as DEFAULT_TRACE_ANALYST_BUDGETS, m as TraceAnalysisStoreContractError, n as OtlpFileTraceStore, p as TraceAnalysisLimitError, u as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, v as TraceFileTooLargeError, w as inferOtlpKind, y as TraceNotFoundError } from "./store-otlp-BenKynPE.js";
+import { i as traceAnalystFunctionGroup, n as buildTraceAnalysisToolDescriptors, r as buildTraceAnalystTools, t as TRACE_ANALYST_TOOL_NAMESPACE } from "./tools-DZGdROtG.js";
 import { n as llmSpanFromProvider, t as TraceEmitter } from "./emitter-CPBAhxum.js";
 import { a as isRetrievalSpan, i as isLlmSpan, n as TRACE_SCHEMA_VERSION, o as isSandboxSpan, r as isJudgeSpan, s as isToolSpan, t as FAILURE_CLASSES } from "./schema-CRhEY1SO.js";
-import { n as TRACE_ANALYST_ACTOR_DESCRIPTION, r as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, t as analyzeTraces } from "./analyst-j5je5J7c.js";
-import { C as planTraceInsightQuestions, E as traceAnalystOnRunComplete, S as inferDomainKeywords, T as tokenizeDomainWords, _ as buildTraceInsightContext, a as convertTraceStoresToOtlp, b as describeTraceInsightScope, c as otelRunCompleteHook, d as captureFetchToRawSink, f as otlpRowsToRunRecords, g as flattenOtlpExportToNdjson, h as otlpToTraceRunRecords, i as iterateRawCalls, l as OTEL_AGENT_EVAL_SCOPE, m as otlpToRunRecords, n as ReplayCacheMissError, o as createOtelExporter, p as otlpRowsToTraceRunRecords, r as createReplayFetch, s as createOtelTracingStore, t as ReplayCache, u as exportRunAsOtlp, v as buildTraceInsightPrompt, w as scoreTraceInsightReadiness, x as domainEvidencePattern, y as defaultTraceInsightPanel } from "./replay-C6wRg47C.js";
-import { n as extractUsageFromResponse, r as extractUsageFromSse, t as extractUsage } from "./extract-usage-DIQpN-ww.js";
+import { A as TRACE_ANALYST_ACTOR_DESCRIPTION, C as domainEvidencePattern, D as tokenizeDomainWords, E as scoreTraceInsightReadiness, O as traceAnalystOnRunComplete, S as describeTraceInsightScope, T as planTraceInsightQuestions, _ as otlpToTraceRunRecords, a as convertTraceStoresToOtlp, b as buildTraceInsightPrompt, c as otelRunCompleteHook, d as captureFetchToRawSink, f as ToolTraceMissingError, g as otlpToRunRecords, h as otlpRowsToTraceRunRecords, i as iterateRawCalls, j as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, k as analyzeTraces, l as OTEL_AGENT_EVAL_SCOPE, m as otlpRowsToRunRecords, n as ReplayCacheMissError, o as createOtelExporter, p as toolSpansToTraceAnalysisStore, r as createReplayFetch, s as createOtelTracingStore, t as ReplayCache, u as exportRunAsOtlp, v as flattenOtlpExportToNdjson, w as inferDomainKeywords, x as defaultTraceInsightPanel, y as buildTraceInsightContext } from "./replay-Cb-4Vf0k.js";
+import { n as extractUsageFromResponse, r as extractUsageFromSse, t as extractUsage } from "./extract-usage-CS391dOE.js";
 import { a as judgeSpans, c as runsForScenario, i as hasCapturedToolArgs, l as toolSpans, n as argHash, o as llmSpans, r as groupBy, s as runFailureClass, t as aggregateLlm } from "./query-Di7eEQ79.js";
-import { a as InMemoryTraceStore, i as FileSystemTraceStore, n as assertRunCaptured, r as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-BzRbCHzi.js";
+import { a as InMemoryTraceStore, i as FileSystemTraceStore, n as assertRunCaptured, r as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-fdt8XPAv.js";
 import { i as redactValue, n as REDACTION_VERSION, r as redactString, t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
-export { DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_VERSION, RUN_COST_ATTR_KEYS, ReplayCache, ReplayCacheMissError, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolTraceMissingError, TraceEmitter, TraceFileMissingError, TraceNotFoundError, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, 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, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+export { DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_VERSION, RUN_COST_ATTR_KEYS, ReplayCache, ReplayCacheMissError, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolTraceMissingError, TraceAnalysisLimitError, TraceAnalysisStoreContractError, TraceAnalysisValidationError, TraceEmitter, TraceFileMalformedError, TraceFileMissingError, TraceFileTooLargeError, TraceNotFoundError, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalysisToolDescriptors, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, isRetrievalSpan, isSandboxSpan, isToolSpan, iterateRawCalls, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };