@warlock.js/ai-panoptic 4.8.1 → 4.8.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@warlock.js/ai-panoptic` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.8.2 - 2026-07-22
+
+### Added
+
+- **`DashboardOptions.evaluate`** — an "Evaluate system prompt" drawer action that grades a trace's last captured system prompt via an LLM judge, editable per-run instructions included; the dashboard's first and only write-capable route (`POST .../spans/:spanId/evaluate`), off unless configured and gated by the same `authToken` / `allowedHosts` checks as every other route
+- `evaluateSystemPrompt` / `extractLastSystemPrompt` / `findSpanById` — the building blocks behind the drawer action, exported for scripting a grade outside the UI
+
+### Fixed
+
+- The dashboard's client-side poll (`GET {basePath}api/aggregate` / `api/traces`) now carries the page's `?token=` as an `Authorization: Bearer` header on every request — previously, once `authToken` was configured the initial page load succeeded (the browser's navigation request carries the query string) but every subsequent 2s poll had no auth attached and 401'd forever, leaving the dashboard stuck on an empty/error state despite loading successfully
+- `PanopticConfig.cache` failures (hydrate-on-startup or write-through — bad URL, unreachable Redis, auth failure) are no longer swallowed into total silence: a new `PanopticConfig.onError` hook fires on every failure, defaulting to `log.error("ai-panoptic", "cacheStore", error)` when not supplied, so a misconfigured cache driver now surfaces in logs instead of leaving the dashboard permanently empty with zero diagnostic
+
 ## 4.5.0 - 2026-07-01
 
 ### Added

package/cjs/index.cjs

@@ -3,6 +3,7 @@ let _warlock_js_ai = require("@warlock.js/ai");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let node_http = require("node:http");
+let _warlock_js_logger = require("@warlock.js/logger");
 
 //#region ../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts
 /**
@@ -1917,6 +1918,57 @@ function panoptic(options = {}) {
 	return new PanopticSubscriber(options);
 }
 
+//#endregion
+//#region ../@warlock.js/ai-panoptic/src/evaluate/evaluate-system-prompt.ts
+/**
+* Grade `systemPrompt` with the configured judge model, reusing
+* `ai.prompts().validate()`'s own `judgePromptBody` — never a second
+* judging implementation. `instructionsOverride` (the dashboard's
+* per-run textarea) wins over `config.instructions`; with neither, the
+* judge falls back to `judgePromptBody`'s built-in prompt-quality rubric.
+*
+* The judge itself never throws (`judgePromptBody` degrades to an
+* issues-only outcome on failure) — the only thing that CAN throw here is
+* resolving `config.model` (a factory constructing an SDK client), which
+* the caller (the dashboard route) is expected to catch.
+*/
+async function evaluateSystemPrompt(systemPrompt, config, instructionsOverride) {
+	return (0, _warlock_js_ai.judgePromptBody)(systemPrompt, typeof config.model === "function" ? await config.model() : config.model, instructionsOverride?.trim() || config.instructions);
+}
+
+//#endregion
+//#region ../@warlock.js/ai-panoptic/src/evaluate/extract-last-system-prompt.ts
+/**
+* Pull the LAST `{role: "system"}` message off a span's captured `input`.
+*
+* Only present under `captureContent` (off by default), and only shaped
+* this way for non-tool spans — either the `[system, user]` first-trip pair
+* or, under `fullHistory`, the full `CapturedMessage[]` conversation (see
+* `collector/report-to-span.ts`). "Last" (not "only") matters for
+* `fullHistory`: a long-running agent can carry more than one system-role
+* turn, and the most recent one is the one actually in effect. Returns
+* `undefined` for a tool span, an agent with no system prompt, or when
+* content capture is off — the caller treats that as "nothing to evaluate."
+*/
+function extractLastSystemPrompt(span) {
+	if (!Array.isArray(span.input)) return;
+	for (let index = span.input.length - 1; index >= 0; index -= 1) {
+		const entry = span.input[index];
+		if (entry && typeof entry === "object" && entry.role === "system") return typeof entry.content === "string" ? entry.content : void 0;
+	}
+}
+
+//#endregion
+//#region ../@warlock.js/ai-panoptic/src/evaluate/find-span-by-id.ts
+/** Depth-first search for the span with `spanId` inside a trace's span tree. */
+function findSpanById(root, spanId) {
+	if (root.spanId === spanId) return root;
+	for (const child of root.children) {
+		const found = findSpanById(child, spanId);
+		if (found !== void 0) return found;
+	}
+}
+
 //#endregion
 //#region ../@warlock.js/ai-panoptic/src/dashboard/parse-query.ts
 /**
@@ -2021,7 +2073,7 @@ const WARLOCK_LOGO_DATA_URI = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEA
 * @param basePath Normalized mount path ending in `/` (e.g. `"/"`).
 * @param title Header title shown in the page.
 */
-function dashboardHtml(basePath, title) {
+function dashboardHtml(basePath, title, evaluateEnabled = false, evaluateDefaultInstructions = "") {
 	const apiBase = `${basePath}api`;
 	const safeTitle = escapeHtml(title);
 	return `<!doctype html>
@@ -2202,6 +2254,18 @@ function dashboardHtml(basePath, title) {
   .legend { margin-left: auto; display: flex; align-items: center; gap: 6px; font-size: 11px; color: var(--dim); }
   .legend .grad { width: 64px; height: 8px; border-radius: 4px; background: linear-gradient(90deg, var(--surface2), var(--cost)); border: 1px solid var(--border); }
   .gantt { padding: 8px 10px; }
+
+  /* Evaluate — the drawer's one write action (config-gated). */
+  .eval-btn { background: transparent; border: 1px solid var(--border); color: var(--text2); cursor: pointer; font-size: 12px; padding: 4px 10px; border-radius: 6px; margin: 10px 0 0; }
+  .eval-btn:hover:not(:disabled) { color: var(--text); border-color: var(--border2); }
+  .eval-btn:disabled { opacity: .6; cursor: default; }
+  .eval-panel { margin-top: 8px; padding: 10px; border: 1px solid var(--border); border-radius: 8px; background: var(--surface2); }
+  .eval-panel textarea { width: 100%; min-height: 64px; background: var(--panel); color: var(--text); border: 1px solid var(--border); border-radius: 6px; padding: 8px; font: 12px/1.5 ui-sans-serif, system-ui, sans-serif; resize: vertical; }
+  .eval-actions { display: flex; align-items: center; gap: 8px; margin-top: 8px; }
+  .eval-error { color: var(--fail); font-size: 12px; }
+  .eval-result { margin-top: 10px; padding-top: 10px; border-top: 1px solid var(--border); font-size: 12px; }
+  .eval-score { font-weight: 600; }
+  .eval-issues { margin: 6px 0 0; padding-left: 18px; }
   .grow { display: flex; align-items: center; gap: 8px; padding: 2px 0; font-size: 12px; cursor: pointer; border-radius: 4px; }
   .grow:hover { background: var(--surface); }
   .grow.selected { background: var(--sel-bg); }
@@ -2266,7 +2330,21 @@ function dashboardHtml(basePath, title) {
 <script>
 (function () {
   var API = ${JSON.stringify(apiBase)};
+  var EVALUATE_ENABLED = ${JSON.stringify(evaluateEnabled)};
   var BT = String.fromCharCode(96);
+  var EVALUATE_DEFAULT_INSTRUCTIONS = ${encodeForInlineScript(evaluateDefaultInstructions)};
+
+  // Carry the ?token= the page itself was loaded with onto every
+  // subsequent poll — otherwise the API calls below inherit no auth and
+  // 401 forever once authToken is configured (the initial page load is
+  // the only request the URL's query string naturally reaches).
+  var TOKEN = new URLSearchParams(window.location.search).get("token");
+  function fetchAuthed(url, options) {
+    var opts = options || {};
+    var headers = opts.headers || {};
+    if (TOKEN) headers = Object.assign({}, headers, { Authorization: "Bearer " + TOKEN });
+    return fetch(url, Object.assign({}, opts, { headers: headers }));
+  }
 
   var state = {
     traces: [], selectedId: null, selectedSpanId: null, collapsed: {}, sig: null,
@@ -2278,7 +2356,8 @@ function dashboardHtml(basePath, title) {
     showStats: false,             // per-type aggregate-stats panel toggle (independent of grouping)
     collapsedGroups: {},          // collapsed group headers (session, prompt, or type)
     view: "tree",                 // drawer left pane: "tree" | "timeline"
-    hashApplied: false            // guards one-time deep-link open on load
+    hashApplied: false,           // guards one-time deep-link open on load
+    evaluate: {}                  // per-span evaluate UI state, keyed by spanId
   };
 
   var STATUS_FILTERS = ["completed", "failed", "cancelled"];
@@ -2987,6 +3066,80 @@ function dashboardHtml(basePath, title) {
     return '<div class="meta-sec"><div class="meta-title">metadata</div><div class="kv">' + kv + "</div></div>";
   }
 
+  // --- Evaluate: grade a span's last captured system prompt -------------
+  // Config-gated (EVALUATE_ENABLED) — the drawer's only write action, POSTing
+  // to a route that itself only exists when the server was configured with
+  // evaluate. UI state lives in state.evaluate, keyed by spanId, so it
+  // survives a re-render (e.g. switching to a sibling span and back).
+  function extractLastSystemPrompt(span) {
+    if (!Array.isArray(span.input)) return null;
+    for (var i = span.input.length - 1; i >= 0; i--) {
+      var m = span.input[i];
+      if (m && typeof m === "object" && m.role === "system" && typeof m.content === "string") return m.content;
+    }
+    return null;
+  }
+  function evalState(spanId) {
+    return state.evaluate[spanId] || (state.evaluate[spanId] = {
+      open: false, instructions: EVALUATE_DEFAULT_INSTRUCTIONS, status: "idle", result: null, error: null
+    });
+  }
+  function evalResultHtml(result) {
+    var score = typeof result.score === "number" ? Math.round(result.score * 100) + "%" : "n/a";
+    var issues = (result.issues || []).map(function (i) { return "<li>" + esc(i) + "</li>"; }).join("");
+    return '<div class="eval-result"><span class="eval-score">Score: ' + score + "</span>"
+      + (issues ? '<ul class="eval-issues">' + issues + "</ul>" : "") + "</div>";
+  }
+  function evalSectionHtml(span) {
+    if (!EVALUATE_ENABLED) return "";
+    var sysPrompt = extractLastSystemPrompt(span);
+    if (!sysPrompt) return "";
+    var st = evalState(span.spanId);
+    var btn = '<button type="button" class="eval-btn" data-evaluate-toggle="' + esc(span.spanId) + '">'
+      + (st.open ? "Hide evaluate" : "Evaluate system prompt") + "</button>";
+    if (!st.open) return btn;
+    var running = st.status === "running";
+    return btn + '<div class="eval-panel">'
+      + '<textarea id="eval-instructions" placeholder="Grading instructions (optional — falls back to the configured default)"' + (running ? " disabled" : "") + ">" + esc(st.instructions || "") + "</textarea>"
+      + '<div class="eval-actions">'
+      + '<button type="button" class="eval-btn" data-evaluate-run="' + esc(span.spanId) + '"' + (running ? " disabled" : "") + ">" + (running ? "Evaluating…" : "Run") + "</button>"
+      + (st.error ? '<span class="eval-error">' + esc(st.error) + "</span>" : "")
+      + "</div>"
+      + (st.result ? evalResultHtml(st.result) : "")
+      + "</div>";
+  }
+  function rerenderDetail() {
+    var t = findTrace(state.selectedId);
+    if (!t) return;
+    var sel = findSpan(t.root, state.selectedSpanId) || t.root;
+    document.getElementById("drawer-detail").innerHTML = renderDetail(sel, t);
+  }
+  function toggleEvalPanel(spanId) {
+    evalState(spanId).open = !evalState(spanId).open;
+    rerenderDetail();
+  }
+  function runEvaluate(traceId, spanId) {
+    var st = evalState(spanId);
+    var textarea = document.getElementById("eval-instructions");
+    if (textarea) st.instructions = textarea.value;
+    st.status = "running"; st.error = null;
+    rerenderDetail();
+    fetchAuthed(API + "/traces/" + encodeURIComponent(traceId) + "/spans/" + encodeURIComponent(spanId) + "/evaluate", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ instructions: st.instructions })
+    }).then(function (r) {
+      return r.json().then(function (data) { return { ok: r.ok, data: data }; });
+    }).then(function (res) {
+      if (res.ok) { st.status = "done"; st.result = res.data; st.error = null; }
+      else { st.status = "error"; st.error = (res.data && (res.data.message || res.data.error)) || "evaluate failed"; st.result = null; }
+      rerenderDetail();
+    }).catch(function () {
+      st.status = "error"; st.error = "network error"; st.result = null;
+      rerenderDetail();
+    });
+  }
+
   function renderDetail(span, trace) {
     var path = findPath(trace.root, span.spanId) || [span];
     var crumb = path.map(function (p, i) { return (i ? '<span class="sep"> › </span>' : "") + "<span>" + esc(p.name) + "</span>"; }).join("");
@@ -3009,6 +3162,7 @@ function dashboardHtml(basePath, title) {
       + '<span class="dim">· ' + dur(span.duration) + "</span></div>"
       + metaLine
       + io
+      + evalSectionHtml(span, trace)
       + renderMeta(span, trace);
   }
 
@@ -3171,9 +3325,20 @@ function dashboardHtml(basePath, title) {
     if (vb) { setView(vb.getAttribute("data-view")); return; }
     var tog = e.target.closest ? e.target.closest("[data-toggle]") : null;
     if (tog) { toggleSpan(tog.getAttribute("data-toggle")); return; }
+    var evalToggle = e.target.closest ? e.target.closest("[data-evaluate-toggle]") : null;
+    if (evalToggle) { toggleEvalPanel(evalToggle.getAttribute("data-evaluate-toggle")); return; }
+    var evalRun = e.target.closest ? e.target.closest("[data-evaluate-run]") : null;
+    if (evalRun && state.selectedId) { runEvaluate(state.selectedId, evalRun.getAttribute("data-evaluate-run")); return; }
     var node = e.target.closest ? e.target.closest(".tnode[data-span], .grow[data-span]") : null;
     if (node) selectSpan(node.getAttribute("data-span"));
   });
+  // Track the instructions textarea live (no re-render on keystroke, so
+  // typing never loses focus/cursor position).
+  document.getElementById("drawer-body").addEventListener("input", function (e) {
+    if (e.target && e.target.id === "eval-instructions" && state.selectedSpanId) {
+      evalState(state.selectedSpanId).instructions = e.target.value;
+    }
+  });
   document.getElementById("backdrop").addEventListener("click", closeDrawer);
   document.addEventListener("keydown", function (e) { if (e.key === "Escape" || e.keyCode === 27) closeDrawer(); });
 
@@ -3269,8 +3434,8 @@ function dashboardHtml(basePath, title) {
 
   function poll() {
     Promise.all([
-      fetch(API + "/aggregate").then(function (r) { return r.json(); }),
-      fetch(API + "/traces").then(function (r) { return r.json(); })
+      fetchAuthed(API + "/aggregate").then(function (r) { return r.json(); }),
+      fetchAuthed(API + "/traces").then(function (r) { return r.json(); })
     ]).then(function (res) {
       renderStats(res[0]);
       state.traces = res[1] || [];
@@ -3305,9 +3470,27 @@ function dashboardHtml(basePath, title) {
 function escapeHtml(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+/**
+* Encode free-form text (e.g. `evaluate.instructions`, which an operator
+* could type anything into) as a JS EXPRESSION that reconstructs it at
+* runtime, WITHOUT ever emitting a literal backtick into the served page —
+* the client script is itself built from a TS template literal, so a raw
+* backtick in the output would be a real syntax hazard (see the `BT =
+* String.fromCharCode(96)` construction already in the client script for
+* the same reason). `JSON.stringify` alone doesn't escape backticks (they
+* aren't JSON-significant), so a value containing one is split around it
+* and rejoined with the client's own `BT` constant. No backticks in the
+* input ⇒ a single plain `JSON.stringify(value)` — no unnecessary
+* concatenation in the common case.
+*/
+function encodeForInlineScript(value) {
+	return value.split("`").map((part) => JSON.stringify(part)).join(" + BT + ");
+}
 
 //#endregion
 //#region ../@warlock.js/ai-panoptic/src/dashboard/serve.ts
+/** Hard cap on the evaluate route's request body — well beyond a real instructions string. */
+const MAX_EVALUATE_BODY_BYTES = 64 * 1024;
 /**
 * Security response headers added to every dashboard response (S4):
 * block MIME-sniffing, framing, referrer leakage, and lock the page's
@@ -3337,15 +3520,22 @@ function isAuthorized(req, url, token) {
 * trace store. Kept separate from the server lifecycle so it can be unit
 * tested by feeding it a fake `req`/`res` without binding a port.
 *
-* Routes (all under `config.basePath`, all read-only):
+* Routes (all under `config.basePath`):
 *
 * - `GET api/traces`        → `store.query(parseQuery(searchParams))`
 * - `GET api/traces/:id`    → `store.get(id)` or `404`
 * - `GET api/aggregate`     → `store.aggregate(parseQuery(searchParams))`
 * - `GET {basePath}`        → the self-contained HTML page
+* - `POST api/traces/:traceId/spans/:spanId/evaluate` → ONLY when
+*   `config.evaluate` is set; grades the span's last captured system
+*   prompt and returns a {@link EvaluateVerdict}. The dashboard's one
+*   write route — absent config, POST 405s like it would against any
+*   other route (the path is never even pattern-matched).
 *
-* Anything else → `404`. Non-`GET` methods → `405`. The store shapes
-* ({@link Trace}/{@link TraceSpan}) are already JSON-safe, so responses
+* Anything else → `404`. A method the matched route doesn't accept → `405`.
+* Host allowlist + bearer-token auth (S4) are checked for EVERY request,
+* regardless of method, before any routing. The store shapes
+* ({@link Trace}/{@link TraceSpan}) are already JSON-safe, so GET responses
 * are a plain `JSON.stringify` with no serializer.
 *
 * @example
@@ -3356,10 +3546,6 @@ function createRequestHandler(store, config) {
 	const base = config.basePath;
 	const apiPrefix = `${base}api`;
 	return function handle(req, res) {
-		if (req.method !== "GET") {
-			sendJson(res, 405, { error: "method_not_allowed" });
-			return;
-		}
 		const url = new URL(req.url ?? "/", "http://localhost");
 		const pathname = url.pathname;
 		const host = hostHeaderName(req.headers.host);
@@ -3371,6 +3557,17 @@ function createRequestHandler(store, config) {
 			sendJson(res, 401, { error: "unauthorized" });
 			return;
 		}
+		if (req.method === "POST" && config.evaluate) {
+			const match = matchEvaluatePath(pathname, apiPrefix);
+			if (match) {
+				handleEvaluate(store, config.evaluate, match.traceId, match.spanId, req, res);
+				return;
+			}
+		}
+		if (req.method !== "GET") {
+			sendJson(res, 405, { error: "method_not_allowed" });
+			return;
+		}
 		if (pathname === `${apiPrefix}/traces`) {
 			sendJson(res, 200, store.query(parseQuery(url.searchParams)));
 			return;
@@ -3397,7 +3594,7 @@ function createRequestHandler(store, config) {
 				"content-type": "text/html; charset=utf-8",
 				...SECURITY_HEADERS
 			});
-			res.end(dashboardHtml(base, config.title));
+			res.end(dashboardHtml(base, config.title, Boolean(config.evaluate), config.evaluate?.instructions ?? ""));
 			return;
 		}
 		sendJson(res, 404, { error: "not_found" });
@@ -3411,6 +3608,102 @@ function sendJson(res, status, body) {
 	});
 	res.end(JSON.stringify(body));
 }
+/**
+* Match `{apiPrefix}/traces/:traceId/spans/:spanId/evaluate` — the one
+* write route. Returns `undefined` for anything else, including the plain
+* `{apiPrefix}/traces/:id` read route (no `/spans/.../evaluate` suffix),
+* so the two never collide.
+*/
+function matchEvaluatePath(pathname, apiPrefix) {
+	const prefix = `${apiPrefix}/traces/`;
+	if (!pathname.startsWith(prefix)) return;
+	const match = /^([^/]+)\/spans\/([^/]+)\/evaluate$/.exec(pathname.slice(prefix.length));
+	if (!match) return;
+	return {
+		traceId: decodeURIComponent(match[1]),
+		spanId: decodeURIComponent(match[2])
+	};
+}
+/**
+* Collect and JSON-parse a request body, capped at
+* {@link MAX_EVALUATE_BODY_BYTES} so an oversized body can't hold the
+* connection open indefinitely. An empty body resolves to `undefined` —
+* the evaluate route treats that as "no per-run override".
+*/
+function readJsonBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > MAX_EVALUATE_BODY_BYTES) {
+				req.destroy();
+				reject(/* @__PURE__ */ new Error("payload_too_large"));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (chunks.length === 0) {
+				resolve(void 0);
+				return;
+			}
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+			} catch {
+				reject(/* @__PURE__ */ new Error("invalid_json"));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+/**
+* Handle `POST {apiPrefix}/traces/:traceId/spans/:spanId/evaluate`. Looks
+* up the trace + span, extracts its last captured system prompt, and
+* grades it via {@link evaluateSystemPrompt}. `judgePromptBody` itself
+* never throws (a broken judge degrades to an issues-only outcome) — the
+* try/catch here only guards `config.evaluate.model` resolution, the one
+* step that CAN throw (e.g. a factory constructing an SDK client).
+*/
+async function handleEvaluate(store, evaluate, traceId, spanId, req, res) {
+	const trace = store.get(traceId);
+	if (trace === void 0) {
+		sendJson(res, 404, {
+			error: "trace_not_found",
+			traceId
+		});
+		return;
+	}
+	const span = findSpanById(trace.root, spanId);
+	if (span === void 0) {
+		sendJson(res, 404, {
+			error: "span_not_found",
+			spanId
+		});
+		return;
+	}
+	const systemPrompt = extractLastSystemPrompt(span);
+	if (systemPrompt === void 0) {
+		sendJson(res, 422, { error: "no_system_prompt" });
+		return;
+	}
+	let body;
+	try {
+		body = await readJsonBody(req);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "invalid_json";
+		sendJson(res, message === "payload_too_large" ? 413 : 400, { error: message });
+		return;
+	}
+	try {
+		sendJson(res, 200, await evaluateSystemPrompt(systemPrompt, evaluate, body?.instructions));
+	} catch (error) {
+		sendJson(res, 502, {
+			error: "evaluate_failed",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
 
 //#endregion
 //#region ../@warlock.js/ai-panoptic/src/dashboard/dashboard.ts
@@ -3452,7 +3745,8 @@ function dashboard(store, options = {}) {
 		basePath,
 		title,
 		authToken: options.authToken,
-		allowedHosts
+		allowedHosts,
+		evaluate: options.evaluate
 	}));
 	return new Promise((resolve, reject) => {
 		const onError = (error) => {
@@ -3839,7 +4133,8 @@ function applyPanopticConfig(config) {
 		let cacheStore;
 		if (store === void 0 && config.dashboard) {
 			if (config.cache !== void 0) {
-				cacheStore = createCacheTraceStore(config.cache);
+				const onError = config.onError ?? ((error) => _warlock_js_logger.log.error("ai-panoptic", "cacheStore", error));
+				cacheStore = createCacheTraceStore(config.cache, { onError });
 				store = cacheStore;
 			} else store = createInMemoryTraceStore();
 			exporters.push(store);
@@ -3910,9 +4205,12 @@ exports.createInMemoryTraceStore = createInMemoryTraceStore;
 exports.createPanopticMiddleware = createPanopticMiddleware;
 exports.dashboard = dashboard;
 exports.emptyUsage = emptyUsage;
+exports.evaluateSystemPrompt = evaluateSystemPrompt;
+exports.extractLastSystemPrompt = extractLastSystemPrompt;
 exports.extractSpanAttributes = extractSpanAttributes;
 exports.fileExporter = fileExporter;
 exports.filterTraces = filterTraces;
+exports.findSpanById = findSpanById;
 exports.formatSpanIO = formatSpanIO;
 exports.formatSpanLine = formatSpanLine;
 exports.groupByPrompt = groupByPrompt;