@axlsdk/studio 0.15.0 → 0.16.0

package/dist/{chunk-IPDMFFTQ.js → chunk-RE6VPUXA.js}

@@ -6,6 +6,7 @@ import { cors } from "hono/cors";
 import { serveStatic } from "@hono/node-server/serve-static";
 
 // src/server/redact.ts
+import { redactEvent } from "@axlsdk/axl";
 var REDACTED = "[redacted]";
 var SAFE_ERROR_NAMES = /* @__PURE__ */ new Set([
   "QuorumNotMet",
@@ -30,7 +31,8 @@ function redactExecutionInfo(info, redact) {
   return {
     ...info,
     ...info.result !== void 0 ? { result: REDACTED } : {},
-    ...info.error !== void 0 ? { error: REDACTED } : {}
+    ...info.error !== void 0 ? { error: REDACTED } : {},
+    events: info.events.map((e) => redactStreamEvent(e, true))
   };
 }
 function redactExecutionList(infos, redact) {
@@ -71,30 +73,7 @@ function redactSessionHistory(history, redact) {
 }
 function redactStreamEvent(event, redact) {
   if (!redact) return event;
-  switch (event.type) {
-    case "token":
-      return { type: "token", data: REDACTED };
-    case "tool_call":
-      return { ...event, args: REDACTED };
-    case "tool_result":
-      return { ...event, result: REDACTED };
-    case "tool_approval":
-      return {
-        ...event,
-        args: REDACTED,
-        ...event.reason !== void 0 ? { reason: REDACTED } : {}
-      };
-    case "done":
-      return { type: "done", data: REDACTED };
-    case "error":
-      return { type: "error", message: REDACTED };
-    // Structural events have no user content to scrub.
-    case "agent_start":
-    case "agent_end":
-    case "handoff":
-    case "step":
-      return event;
-  }
+  return redactEvent(event);
 }
 function redactEvalItem(item) {
   const scrubbed = {
@@ -180,13 +159,17 @@ async function errorHandler(c, next) {
 
 // src/server/ws/connection-manager.ts
 var BUFFER_TTL_MS = 3e4;
-var MAX_BUFFER_EVENTS = 500;
+var DEFAULT_MAX_BUFFER_EVENTS = 1e3;
+var DEFAULT_MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+var DEFAULT_MAX_ACTIVE_BUFFERS = 256;
+var UNBUFFERED_EVENT_TYPES = /* @__PURE__ */ new Set(["token", "partial_object"]);
 var MAX_WS_FRAME_BYTES = 65536;
 function isBufferedChannel(channel) {
   return channel.startsWith("execution:") || channel.startsWith("eval:");
 }
 function truncateIfOversized(msg, channel, data) {
-  if (msg.length <= MAX_WS_FRAME_BYTES) return msg;
+  const msgBytes = Buffer.byteLength(msg, "utf8");
+  if (msgBytes <= MAX_WS_FRAME_BYTES) return msg;
   const event = data ?? {};
   const truncated = {
     type: "event",
@@ -195,7 +178,7 @@ function truncateIfOversized(msg, channel, data) {
       ...event,
       data: {
         __truncated: true,
-        originalBytes: msg.length,
+        originalBytes: msgBytes,
         maxBytes: MAX_WS_FRAME_BYTES,
         hint: "Event exceeded WS frame budget (likely a verbose agent_call with a large messages[] snapshot). Fetch via REST if you need the full payload."
       }
@@ -212,6 +195,25 @@ var ConnectionManager = class {
   buffers = /* @__PURE__ */ new Map();
   maxConnections = 100;
   filter;
+  /** Resolved replay-buffer caps. Per-instance so embedders can dial them
+   *  without monkey-patching module-level constants. */
+  maxEventsPerBuffer;
+  maxBytesPerBuffer;
+  maxActiveBuffers;
+  constructor(bufferCaps) {
+    const validatePositiveInt = (key, value) => {
+      if (value === void 0) return;
+      if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
+        throw new RangeError(`bufferCaps.${key} must be a positive integer (>= 1); got ${value}`);
+      }
+    };
+    validatePositiveInt("maxEventsPerBuffer", bufferCaps?.maxEventsPerBuffer);
+    validatePositiveInt("maxBytesPerBuffer", bufferCaps?.maxBytesPerBuffer);
+    validatePositiveInt("maxActiveBuffers", bufferCaps?.maxActiveBuffers);
+    this.maxEventsPerBuffer = bufferCaps?.maxEventsPerBuffer ?? DEFAULT_MAX_BUFFER_EVENTS;
+    this.maxBytesPerBuffer = bufferCaps?.maxBytesPerBuffer ?? DEFAULT_MAX_BUFFER_BYTES;
+    this.maxActiveBuffers = bufferCaps?.maxActiveBuffers ?? DEFAULT_MAX_ACTIVE_BUFFERS;
+  }
   /**
    * Register a broadcast filter. Called once at middleware construction.
    * The filter runs on every outbound event and can drop or deliver based
@@ -294,13 +296,37 @@ var ConnectionManager = class {
     if (isBufferedChannel(channel)) {
       let buffer = this.buffers.get(channel);
       if (!buffer) {
-        buffer = { events: [], complete: false };
+        if (this.buffers.size >= this.maxActiveBuffers) {
+          let victim;
+          for (const [ch, buf] of this.buffers) {
+            if (buf.complete) {
+              victim = ch;
+              break;
+            }
+          }
+          if (victim === void 0) {
+            victim = this.buffers.keys().next().value;
+          }
+          if (victim !== void 0) {
+            const old = this.buffers.get(victim);
+            if (old?.timer) clearTimeout(old.timer);
+            this.buffers.delete(victim);
+          }
+        }
+        buffer = { events: [], complete: false, bytes: 0 };
         this.buffers.set(channel, buffer);
       }
       const event = data;
       const isTerminal = event.type === "done" || event.type === "error";
-      if (buffer.events.length < MAX_BUFFER_EVENTS || isTerminal) {
-        buffer.events.push({ msg, data });
+      const isUnbuffered = event.type !== void 0 && UNBUFFERED_EVENT_TYPES.has(event.type);
+      if (!isUnbuffered) {
+        const msgBytes = Buffer.byteLength(msg, "utf8");
+        const atCountCap = buffer.events.length >= this.maxEventsPerBuffer;
+        const atByteCap = buffer.bytes + msgBytes > this.maxBytesPerBuffer;
+        if (isTerminal || !atCountCap && !atByteCap) {
+          buffer.events.push({ msg, data });
+          buffer.bytes += msgBytes;
+        }
       }
       if (isTerminal) {
         buffer.complete = true;
@@ -385,7 +411,7 @@ var VALID_CHANNEL_PREFIXES = ["execution:", "trace:", "eval:"];
 var VALID_EXACT_CHANNELS = ["costs", "decisions", "eval-trends", "workflow-stats", "trace-stats"];
 var MAX_CHANNEL_LENGTH = 256;
 function handleWsMessage(raw, socket, connMgr) {
-  if (raw.length > MAX_WS_FRAME_BYTES) {
+  if (Buffer.byteLength(raw, "utf8") > MAX_WS_FRAME_BYTES) {
     return JSON.stringify({ type: "error", message: "Message too large" });
   }
   let msg;
@@ -541,7 +567,7 @@ var TraceAggregator = class {
       this.options.windows.map((w) => [w, this.options.emptyState()])
     );
     for (const exec of capped) {
-      for (const event of exec.steps) {
+      for (const event of exec.events) {
         for (const window of this.options.windows) {
           if (withinWindow(event.timestamp, window, now)) {
             fresh.set(window, this.options.reducer(fresh.get(window), event));
@@ -563,15 +589,131 @@ var TraceAggregator = class {
   }
 };
 
+// src/server/aggregates/execution-aggregator.ts
+var ExecutionAggregator = class {
+  snaps;
+  interval;
+  listener;
+  options;
+  /** Generation counter to prevent stale async fold after rebuild. */
+  generation = 0;
+  constructor(options) {
+    this.options = options;
+    this.snaps = new AggregateSnapshots(
+      options.windows,
+      options.emptyState,
+      options.connMgr,
+      options.channel,
+      options.broadcastTransform
+    );
+  }
+  async start() {
+    await this.rebuild();
+    this.listener = (event) => {
+      if (event.type !== "workflow_end") return;
+      const gen = this.generation;
+      this.options.runtime.getExecution(event.executionId).then((exec) => {
+        if (this.generation !== gen) return;
+        if (exec) {
+          this.snaps.fold(exec.startedAt, (prev) => this.options.reducer(prev, exec));
+        }
+      }).catch((err) => console.error("[axl-studio] execution fold failed:", err));
+    };
+    this.options.runtime.on("trace", this.listener);
+    this.interval = setInterval(
+      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
+      REBUILD_INTERVAL_MS
+    );
+  }
+  async rebuild() {
+    this.generation++;
+    const executions = await this.options.runtime.getExecutions();
+    const cap = this.options.executionCap ?? 2e3;
+    const capped = executions.slice(0, cap);
+    const now = Date.now();
+    const fresh = new Map(
+      this.options.windows.map((w) => [w, this.options.emptyState()])
+    );
+    for (const exec of capped) {
+      for (const window of this.options.windows) {
+        if (withinWindow(exec.startedAt, window, now)) {
+          fresh.set(window, this.options.reducer(fresh.get(window), exec));
+        }
+      }
+    }
+    this.snaps.replace(fresh);
+  }
+  getSnapshot(window) {
+    return this.snaps.get(window);
+  }
+  getAllSnapshots() {
+    return this.snaps.getAll();
+  }
+  close() {
+    if (this.listener) this.options.runtime.off("trace", this.listener);
+    if (this.interval) clearInterval(this.interval);
+  }
+};
+
+// src/server/aggregates/eval-aggregator.ts
+var EvalAggregator = class {
+  snaps;
+  interval;
+  listener;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.snaps = new AggregateSnapshots(
+      options.windows,
+      options.emptyState,
+      options.connMgr,
+      options.channel,
+      options.broadcastTransform
+    );
+  }
+  async start() {
+    await this.rebuild();
+    this.listener = (entry) => {
+      this.snaps.fold(entry.timestamp, (prev) => this.options.reducer(prev, entry));
+    };
+    this.options.runtime.on("eval_result", this.listener);
+    this.interval = setInterval(
+      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
+      REBUILD_INTERVAL_MS
+    );
+  }
+  async rebuild() {
+    const history = await this.options.runtime.getEvalHistory();
+    const cap = this.options.entryCap ?? 500;
+    const capped = history.slice(0, cap);
+    const now = Date.now();
+    const fresh = new Map(
+      this.options.windows.map((w) => [w, this.options.emptyState()])
+    );
+    for (const entry of capped) {
+      for (const window of this.options.windows) {
+        if (withinWindow(entry.timestamp, window, now)) {
+          fresh.set(window, this.options.reducer(fresh.get(window), entry));
+        }
+      }
+    }
+    this.snaps.replace(fresh);
+  }
+  getSnapshot(window) {
+    return this.snaps.get(window);
+  }
+  getAllSnapshots() {
+    return this.snaps.getAll();
+  }
+  close() {
+    if (this.listener) this.options.runtime.off("eval_result", this.listener);
+    if (this.interval) clearInterval(this.interval);
+  }
+};
+
 // src/server/aggregates/reducers.ts
+import { eventCostContribution } from "@axlsdk/axl";
 var finite = (v) => Number.isFinite(v) ? v : 0;
-function isLogEvent(event, eventName) {
-  if (event.type === eventName) return true;
-  if (event.type === "log" && event.data != null && typeof event.data === "object") {
-    return event.data.event === eventName;
-  }
-  return false;
-}
 function emptyRetry() {
   return {
     primary: 0,
@@ -597,7 +739,7 @@ function emptyCostData() {
   };
 }
 function reduceCost(acc, event) {
-  const isWorkflowStart = isLogEvent(event, "workflow_start");
+  const isWorkflowStart = event.type === "workflow_start";
   if (isWorkflowStart && event.workflow) {
     const byWorkflow2 = { ...acc.byWorkflow };
     const prev = byWorkflow2[event.workflow] ?? { cost: 0, executions: 0 };
@@ -605,9 +747,10 @@ function reduceCost(acc, event) {
     return { ...acc, byWorkflow: byWorkflow2 };
   }
   if (event.cost == null && !event.tokens) return acc;
-  const cost = finite(event.cost);
+  const cost = eventCostContribution(event);
+  if (event.type === "ask_end") return acc;
   const tokens = event.tokens ?? {};
-  const totalTokens = event.type === "agent_call" ? {
+  const totalTokens = event.type === "agent_call_end" ? {
     input: acc.totalTokens.input + finite(tokens.input),
     output: acc.totalTokens.output + finite(tokens.output),
     reasoning: acc.totalTokens.reasoning + finite(tokens.reasoning)
@@ -638,7 +781,7 @@ function reduceCost(acc, event) {
     };
   }
   let retry = acc.retry;
-  if (event.type === "agent_call") {
+  if (event.type === "agent_call_end") {
     const d = event.data ?? {};
     const reason = d.retryReason;
     retry = { ...acc.retry };
@@ -660,19 +803,17 @@ function reduceCost(acc, event) {
     }
   }
   let byEmbedder = acc.byEmbedder;
-  if (event.type === "log") {
-    const d = event.data ?? {};
-    if (d.event === "memory_remember" || d.event === "memory_recall") {
-      byEmbedder = { ...acc.byEmbedder };
-      const modelKey = d.usage?.model ?? "unknown";
-      const embedTokens = typeof d.usage?.tokens === "number" ? finite(d.usage.tokens) : 0;
-      const prev = byEmbedder[modelKey] ?? { cost: 0, calls: 0, tokens: 0 };
-      byEmbedder[modelKey] = {
-        cost: prev.cost + cost,
-        calls: prev.calls + 1,
-        tokens: prev.tokens + embedTokens
-      };
-    }
+  if (event.type === "memory_remember" || event.type === "memory_recall") {
+    const usage = event.data.usage;
+    byEmbedder = { ...acc.byEmbedder };
+    const modelKey = usage?.model ?? "unknown";
+    const embedTokens = typeof usage?.tokens === "number" ? finite(usage.tokens) : 0;
+    const prev = byEmbedder[modelKey] ?? { cost: 0, calls: 0, tokens: 0 };
+    byEmbedder[modelKey] = {
+      cost: prev.cost + cost,
+      calls: prev.calls + 1,
+      tokens: prev.tokens + embedTokens
+    };
   }
   return {
     totalCost: acc.totalCost + cost,
@@ -867,7 +1008,7 @@ function reduceTraceStats(acc, event) {
   const eventTypeCounts = { ...acc.eventTypeCounts };
   eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
   const byTool = { ...acc.byTool };
-  if (event.type === "tool_call" || event.type === "tool_denied" || event.type === "tool_approval") {
+  if (event.type === "tool_call_end" || event.type === "tool_denied" || event.type === "tool_approval") {
     const toolName = event.tool;
     const prev = byTool[toolName] ?? { calls: 0, denied: 0, approved: 0 };
     const isDeniedEvent = event.type === "tool_denied";
@@ -876,13 +1017,13 @@ function reduceTraceStats(acc, event) {
     const isApproved = isDeniedEvent && eventData?.approved === true || isApprovalEvent && eventData?.approved === true;
     const isDenied = isDeniedEvent && !eventData?.approved || isApprovalEvent && eventData?.approved === false;
     byTool[toolName] = {
-      calls: prev.calls + (event.type === "tool_call" ? 1 : 0),
+      calls: prev.calls + (event.type === "tool_call_end" ? 1 : 0),
       denied: prev.denied + (isDenied ? 1 : 0),
       approved: prev.approved + (isApproved ? 1 : 0)
     };
   }
   const retryByAgent = { ...acc.retryByAgent };
-  if (event.agent && event.type === "agent_call") {
+  if (event.agent && event.type === "agent_call_end") {
     const data = event.data;
     if (data?.retryReason) {
       const prev = retryByAgent[event.agent] ?? { schema: 0, validate: 0, guardrail: 0 };
@@ -900,128 +1041,6 @@ function reduceTraceStats(acc, event) {
   };
 }
 
-// src/server/aggregates/execution-aggregator.ts
-var ExecutionAggregator = class {
-  snaps;
-  interval;
-  listener;
-  options;
-  /** Generation counter to prevent stale async fold after rebuild. */
-  generation = 0;
-  constructor(options) {
-    this.options = options;
-    this.snaps = new AggregateSnapshots(
-      options.windows,
-      options.emptyState,
-      options.connMgr,
-      options.channel,
-      options.broadcastTransform
-    );
-  }
-  async start() {
-    await this.rebuild();
-    this.listener = (event) => {
-      if (!isLogEvent(event, "workflow_end")) return;
-      const gen = this.generation;
-      this.options.runtime.getExecution(event.executionId).then((exec) => {
-        if (this.generation !== gen) return;
-        if (exec) {
-          this.snaps.fold(exec.startedAt, (prev) => this.options.reducer(prev, exec));
-        }
-      }).catch((err) => console.error("[axl-studio] execution fold failed:", err));
-    };
-    this.options.runtime.on("trace", this.listener);
-    this.interval = setInterval(
-      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
-      REBUILD_INTERVAL_MS
-    );
-  }
-  async rebuild() {
-    this.generation++;
-    const executions = await this.options.runtime.getExecutions();
-    const cap = this.options.executionCap ?? 2e3;
-    const capped = executions.slice(0, cap);
-    const now = Date.now();
-    const fresh = new Map(
-      this.options.windows.map((w) => [w, this.options.emptyState()])
-    );
-    for (const exec of capped) {
-      for (const window of this.options.windows) {
-        if (withinWindow(exec.startedAt, window, now)) {
-          fresh.set(window, this.options.reducer(fresh.get(window), exec));
-        }
-      }
-    }
-    this.snaps.replace(fresh);
-  }
-  getSnapshot(window) {
-    return this.snaps.get(window);
-  }
-  getAllSnapshots() {
-    return this.snaps.getAll();
-  }
-  close() {
-    if (this.listener) this.options.runtime.off("trace", this.listener);
-    if (this.interval) clearInterval(this.interval);
-  }
-};
-
-// src/server/aggregates/eval-aggregator.ts
-var EvalAggregator = class {
-  snaps;
-  interval;
-  listener;
-  options;
-  constructor(options) {
-    this.options = options;
-    this.snaps = new AggregateSnapshots(
-      options.windows,
-      options.emptyState,
-      options.connMgr,
-      options.channel,
-      options.broadcastTransform
-    );
-  }
-  async start() {
-    await this.rebuild();
-    this.listener = (entry) => {
-      this.snaps.fold(entry.timestamp, (prev) => this.options.reducer(prev, entry));
-    };
-    this.options.runtime.on("eval_result", this.listener);
-    this.interval = setInterval(
-      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
-      REBUILD_INTERVAL_MS
-    );
-  }
-  async rebuild() {
-    const history = await this.options.runtime.getEvalHistory();
-    const cap = this.options.entryCap ?? 500;
-    const capped = history.slice(0, cap);
-    const now = Date.now();
-    const fresh = new Map(
-      this.options.windows.map((w) => [w, this.options.emptyState()])
-    );
-    for (const entry of capped) {
-      for (const window of this.options.windows) {
-        if (withinWindow(entry.timestamp, window, now)) {
-          fresh.set(window, this.options.reducer(fresh.get(window), entry));
-        }
-      }
-    }
-    this.snaps.replace(fresh);
-  }
-  getSnapshot(window) {
-    return this.snaps.get(window);
-  }
-  getAllSnapshots() {
-    return this.snaps.getAll();
-  }
-  close() {
-    if (this.listener) this.options.runtime.off("eval_result", this.listener);
-    if (this.interval) clearInterval(this.interval);
-  }
-};
-
 // src/server/routes/health.ts
 import { Hono } from "hono";
 function createHealthRoutes(readOnly) {
@@ -1130,9 +1149,31 @@ app.get("/executions/:id", async (c) => {
       404
     );
   }
+  const sinceParam = c.req.query("since");
+  let paged = execution;
+  if (sinceParam !== void 0) {
+    const since = Number(sinceParam);
+    if (!Number.isFinite(since) || !Number.isInteger(since)) {
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "INVALID_PARAM",
+            message: `\`since\` must be a finite integer (got "${sinceParam}")`,
+            param: "since"
+          }
+        },
+        400
+      );
+    }
+    paged = {
+      ...execution,
+      events: execution.events.filter((e) => e.step > since)
+    };
+  }
   return c.json({
     ok: true,
-    data: redactExecutionInfo(execution, runtime.isRedactEnabled())
+    data: redactExecutionInfo(paged, runtime.isRedactEnabled())
   });
 });
 app.post("/executions/:id/abort", (c) => {
@@ -1709,10 +1750,14 @@ function createEvalRoutes(connMgr, evalLoader) {
     const runtime = c.get("runtime");
     const redactOn = runtime.isRedactEnabled();
     const body = await c.req.json();
+    const MAX_POOLED_RUNS = 25;
     const validateIdParam = (v, name) => {
       if (typeof v === "string") return v === "" ? `${name} must be non-empty` : null;
       if (Array.isArray(v)) {
         if (v.length === 0) return `${name} must be a non-empty array`;
+        if (v.length > MAX_POOLED_RUNS) {
+          return `${name} may contain at most ${MAX_POOLED_RUNS} ids (pooled comparison)`;
+        }
         for (const elem of v) {
           if (typeof elem !== "string" || elem === "") {
             return `${name} array must contain only non-empty strings`;
@@ -1881,32 +1926,50 @@ function createPlaygroundRoutes(connMgr) {
       );
     }
     const sessionId = body.sessionId ?? `playground-${Date.now()}`;
-    const executionId = `playground-${sessionId}-${Date.now()}`;
     const store = runtime.getStateStore();
     const history = await store.getSession(sessionId);
     history.push({ role: "user", content: body.message });
     const redactOn = runtime.isRedactEnabled();
-    const broadcast = (event) => {
+    const ctx = runtime.createContext({ sessionHistory: history });
+    const executionId = ctx.executionId;
+    const traceListener = (event) => {
+      if (event.executionId !== executionId) return;
       connMgr.broadcastWithWildcard(`execution:${executionId}`, redactStreamEvent(event, redactOn));
     };
-    const ctx = runtime.createContext({
-      sessionHistory: history,
-      onToken: (token) => {
-        broadcast({ type: "token", data: token });
-      }
-    });
+    runtime.on("trace", traceListener);
     (async () => {
+      let stepCounter = Number.MAX_SAFE_INTEGER - 1;
+      const terminalFields = () => ({
+        executionId,
+        step: stepCounter++,
+        timestamp: Date.now()
+      });
       try {
         const result = await ctx.ask(agent, body.message);
         const resultText = typeof result === "string" ? result : JSON.stringify(result);
         history.push({ role: "assistant", content: resultText });
         await store.saveSession(sessionId, history);
-        broadcast({ type: "done", data: resultText });
+        const doneEvent = {
+          ...terminalFields(),
+          type: "done",
+          data: { result: resultText }
+        };
+        connMgr.broadcastWithWildcard(
+          `execution:${executionId}`,
+          redactStreamEvent(doneEvent, redactOn)
+        );
       } catch (err) {
-        broadcast({
+        const errorEvent = {
+          ...terminalFields(),
           type: "error",
-          message: err instanceof Error ? err.message : String(err)
-        });
+          data: { message: err instanceof Error ? err.message : String(err) }
+        };
+        connMgr.broadcastWithWildcard(
+          `execution:${executionId}`,
+          redactStreamEvent(errorEvent, redactOn)
+        );
+      } finally {
+        runtime.off("trace", traceListener);
       }
     })();
     return c.json({
@@ -1954,7 +2017,7 @@ function createTraceStatsRoutes(aggregator) {
 function createServer(options) {
   const { runtime, staticRoot, basePath = "", readOnly = false } = options;
   const app6 = new Hono15();
-  const connMgr = new ConnectionManager();
+  const connMgr = new ConnectionManager(options.bufferCaps);
   const windows = ["24h", "7d", "30d", "all"];
   const costAggregator = new TraceAggregator({
     runtime,
@@ -2048,12 +2111,20 @@ function createServer(options) {
   api.route("/", createPlaygroundRoutes(connMgr));
   app6.route("/api", api);
   const traceListener = (event) => {
-    const traceEvent = event;
-    if (traceEvent.executionId) {
-      connMgr.broadcastWithWildcard(`trace:${traceEvent.executionId}`, traceEvent);
-    }
-    if (traceEvent.type === "await_human") {
-      connMgr.broadcast("decisions", traceEvent);
+    try {
+      const traceEvent = event;
+      const redacted = redactStreamEvent(traceEvent, runtime.isRedactEnabled());
+      if (traceEvent.executionId) {
+        connMgr.broadcastWithWildcard(`trace:${traceEvent.executionId}`, redacted);
+      }
+      if (traceEvent.type === "await_human") {
+        connMgr.broadcast("decisions", redacted);
+      }
+    } catch (err) {
+      console.error(
+        "[axl-studio] trace listener threw; event dropped:",
+        err instanceof Error ? err.message : String(err)
+      );
     }
   };
   runtime.on("trace", traceListener);
@@ -2139,4 +2210,4 @@ export {
   EvalAggregator,
   createServer
 };
-//# sourceMappingURL=chunk-IPDMFFTQ.js.map
+//# sourceMappingURL=chunk-RE6VPUXA.js.map