@axlsdk/studio 0.17.3 → 0.17.5

package/dist/chunk-7RBO72NQ.js

@@ -1,2302 +0,0 @@
-// src/server/index.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
-import { Hono as Hono15 } from "hono";
-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",
-  "NoConsensus",
-  "TimeoutError",
-  "MaxTurnsError",
-  "BudgetExceededError",
-  "ToolDenied"
-]);
-function redactErrorMessage(err, redact) {
-  const raw = err instanceof Error ? err.message : String(err);
-  if (!redact) return raw;
-  const name = err instanceof Error ? err.name : "";
-  return SAFE_ERROR_NAMES.has(name) ? raw : REDACTED;
-}
-function redactValue(value, redact) {
-  if (!redact) return value;
-  return REDACTED;
-}
-function redactExecutionInfo(info, redact) {
-  if (!redact) return info;
-  return {
-    ...info,
-    ...info.result !== void 0 ? { result: REDACTED } : {},
-    ...info.error !== void 0 ? { error: REDACTED } : {},
-    events: info.events.map((e) => redactStreamEvent(e, true))
-  };
-}
-function redactExecutionList(infos, redact) {
-  if (!redact) return infos;
-  return infos.map((info) => redactExecutionInfo(info, redact));
-}
-function redactMemoryValue(value, redact) {
-  if (!redact) return value;
-  return REDACTED;
-}
-function redactMemoryList(entries, redact) {
-  if (!redact) return entries;
-  return entries.map((entry) => ({ key: entry.key, value: REDACTED }));
-}
-function redactChatMessage(msg) {
-  const scrubbed = {
-    role: msg.role,
-    content: REDACTED,
-    ...msg.name !== void 0 ? { name: msg.name } : {},
-    ...msg.agent !== void 0 ? { agent: msg.agent } : {},
-    ...msg.tool_call_id !== void 0 ? { tool_call_id: msg.tool_call_id } : {},
-    ...msg.tool_calls !== void 0 ? {
-      tool_calls: msg.tool_calls.map((tc) => ({
-        id: tc.id,
-        type: tc.type,
-        function: {
-          name: tc.function.name,
-          arguments: REDACTED
-        }
-      }))
-    } : {}
-    // providerMetadata deliberately omitted — opaque content.
-  };
-  return scrubbed;
-}
-function redactSessionHistory(history, redact) {
-  if (!redact) return history;
-  return history.map(redactChatMessage);
-}
-function redactStreamEvent(event, redact) {
-  if (!redact) return event;
-  return redactEvent(event);
-}
-function redactEvalItem(item) {
-  const scrubbed = {
-    ...item,
-    input: REDACTED,
-    output: REDACTED,
-    ...item.annotations !== void 0 ? { annotations: REDACTED } : {},
-    ...item.error !== void 0 ? { error: REDACTED } : {},
-    ...item.scorerErrors !== void 0 ? { scorerErrors: item.scorerErrors.map(() => REDACTED) } : {}
-  };
-  if (item.scoreDetails) {
-    const detailsOut = {};
-    for (const [name, detail] of Object.entries(item.scoreDetails)) {
-      detailsOut[name] = {
-        score: detail.score,
-        ...detail.duration !== void 0 ? { duration: detail.duration } : {},
-        ...detail.cost !== void 0 ? { cost: detail.cost } : {}
-        // metadata deliberately omitted — may contain LLM scorer reasoning
-      };
-    }
-    scrubbed.scoreDetails = detailsOut;
-  }
-  return scrubbed;
-}
-function redactEvalResult(result, redact) {
-  if (!redact) return result;
-  const meta = result.metadata;
-  const scrubbedMetadata = meta && typeof meta.batchFailure === "string" ? { ...meta, batchFailure: REDACTED } : result.metadata;
-  return {
-    ...result,
-    metadata: scrubbedMetadata,
-    items: result.items.map(redactEvalItem)
-  };
-}
-function redactEvalHistoryEntry(entry, redact) {
-  if (!redact) return entry;
-  return {
-    ...entry,
-    data: redactEvalResult(entry.data, redact)
-  };
-}
-function redactEvalHistoryList(entries, redact) {
-  if (!redact) return entries;
-  return entries.map((e) => redactEvalHistoryEntry(e, redact));
-}
-function redactPendingDecision(decision, redact) {
-  if (!redact) return decision;
-  return {
-    ...decision,
-    prompt: REDACTED,
-    ...decision.metadata !== void 0 ? { metadata: { redacted: true } } : {}
-  };
-}
-function redactPendingDecisionList(decisions, redact) {
-  if (!redact) return decisions;
-  return decisions.map((d) => redactPendingDecision(d, redact));
-}
-
-// src/server/middleware/error-handler.ts
-async function errorHandler(c, next) {
-  try {
-    await next();
-  } catch (err) {
-    const rawMessage = err instanceof Error ? err.message : String(err);
-    const code = err.code ?? "INTERNAL_ERROR";
-    let status = 500;
-    if ("status" in err) {
-      const errStatus = err.status;
-      if (typeof errStatus === "number" && errStatus >= 400 && errStatus < 600) {
-        status = errStatus;
-      }
-    } else if (code === "NOT_FOUND" || rawMessage.includes("not found") || rawMessage.includes("not registered")) {
-      status = 404;
-    } else if (code === "VALIDATION_ERROR" || rawMessage.includes("Expected") || rawMessage.includes("invalid")) {
-      status = 400;
-    }
-    const runtime = c.get("runtime");
-    const redactOn = runtime?.isRedactEnabled?.() ?? false;
-    const body = {
-      ok: false,
-      error: { code, message: redactErrorMessage(err, redactOn) }
-    };
-    return c.json(body, status);
-  }
-}
-
-// src/server/ws/connection-manager.ts
-var BUFFER_TTL_MS = 3e4;
-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) {
-  const msgBytes = Buffer.byteLength(msg, "utf8");
-  if (msgBytes <= MAX_WS_FRAME_BYTES) return msg;
-  const event = data ?? {};
-  const truncated = {
-    type: "event",
-    channel,
-    data: {
-      ...event,
-      data: {
-        __truncated: true,
-        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."
-      }
-    }
-  };
-  return JSON.stringify(truncated);
-}
-var ConnectionManager = class {
-  /** channel -> set of WS connections */
-  channels = /* @__PURE__ */ new Map();
-  /** ws -> subscribed channels + optional integrator-supplied metadata */
-  connections = /* @__PURE__ */ new Map();
-  /** channel -> replay buffer for execution streams */
-  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
-   * on the destination connection's metadata.
-   */
-  setFilter(filter) {
-    this.filter = filter;
-  }
-  /** Attach integrator-supplied metadata to an already-added connection. */
-  setMetadata(ws, metadata) {
-    const entry = this.connections.get(ws);
-    if (entry) entry.metadata = metadata;
-  }
-  /** Register a new WS connection. */
-  add(ws) {
-    if (this.connections.size >= this.maxConnections) {
-      ws.close?.();
-      return;
-    }
-    this.connections.set(ws, { channels: /* @__PURE__ */ new Set() });
-  }
-  /** Remove a WS connection and all its subscriptions. */
-  remove(ws) {
-    const entry = this.connections.get(ws);
-    if (entry) {
-      for (const ch of entry.channels) {
-        this.channels.get(ch)?.delete(ws);
-        if (this.channels.get(ch)?.size === 0) {
-          this.channels.delete(ch);
-        }
-      }
-    }
-    this.connections.delete(ws);
-  }
-  /** Subscribe a connection to a channel. Replays buffered events for execution channels. */
-  subscribe(ws, channel) {
-    if (!this.connections.has(ws)) return;
-    let subs = this.channels.get(channel);
-    if (!subs) {
-      subs = /* @__PURE__ */ new Set();
-      this.channels.set(channel, subs);
-    }
-    subs.add(ws);
-    this.connections.get(ws).channels.add(channel);
-    const buffer = this.buffers.get(channel);
-    if (buffer) {
-      const metadata = this.connections.get(ws)?.metadata;
-      for (const event of buffer.events) {
-        if (this.filter) {
-          try {
-            if (!this.filter(event.data, metadata)) continue;
-          } catch {
-            continue;
-          }
-        }
-        try {
-          ws.send(event.msg);
-        } catch {
-          this.remove(ws);
-          return;
-        }
-      }
-    }
-  }
-  /** Unsubscribe a connection from a channel. */
-  unsubscribe(ws, channel) {
-    this.channels.get(channel)?.delete(ws);
-    if (this.channels.get(channel)?.size === 0) {
-      this.channels.delete(channel);
-    }
-    this.connections.get(ws)?.channels.delete(channel);
-  }
-  /** Broadcast data to all subscribers of a channel. Buffers events for execution channels. */
-  broadcast(channel, data) {
-    const msg = truncateIfOversized(
-      JSON.stringify({ type: "event", channel, data }),
-      channel,
-      data
-    );
-    if (isBufferedChannel(channel)) {
-      let buffer = this.buffers.get(channel);
-      if (!buffer) {
-        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";
-      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;
-        if (buffer.timer) clearTimeout(buffer.timer);
-        buffer.timer = setTimeout(() => {
-          this.buffers.delete(channel);
-        }, BUFFER_TTL_MS);
-      }
-    }
-    const subs = this.channels.get(channel);
-    if (!subs || subs.size === 0) return;
-    for (const ws of [...subs]) {
-      if (this.filter) {
-        const metadata = this.connections.get(ws)?.metadata;
-        try {
-          if (!this.filter(data, metadata)) continue;
-        } catch {
-          continue;
-        }
-      }
-      try {
-        ws.send(msg);
-      } catch {
-        this.remove(ws);
-      }
-    }
-  }
-  /** Broadcast to channel and all wildcard subscribers (e.g., trace:* matches trace:abc). */
-  broadcastWithWildcard(channel, data) {
-    this.broadcast(channel, data);
-    const colonIdx = channel.indexOf(":");
-    if (colonIdx > 0) {
-      const wildcardChannel = channel.substring(0, colonIdx) + ":*";
-      const subs = this.channels.get(wildcardChannel);
-      if (!subs || subs.size === 0) return;
-      const msg = truncateIfOversized(
-        JSON.stringify({ type: "event", channel, data }),
-        channel,
-        data
-      );
-      for (const ws of [...subs]) {
-        if (this.filter) {
-          const metadata = this.connections.get(ws)?.metadata;
-          try {
-            if (!this.filter(data, metadata)) continue;
-          } catch {
-            continue;
-          }
-        }
-        try {
-          ws.send(msg);
-        } catch {
-          this.remove(ws);
-        }
-      }
-    }
-  }
-  /** Close all connections, clear all state and buffers. Used during shutdown. */
-  closeAll() {
-    for (const ws of this.connections.keys()) {
-      ws.close?.();
-    }
-    for (const buffer of this.buffers.values()) {
-      if (buffer.timer) clearTimeout(buffer.timer);
-    }
-    this.connections.clear();
-    this.channels.clear();
-    this.buffers.clear();
-  }
-  /** Get the number of active connections. */
-  get connectionCount() {
-    return this.connections.size;
-  }
-  /** Check if any connections are subscribed to a channel. */
-  hasSubscribers(channel) {
-    return (this.channels.get(channel)?.size ?? 0) > 0;
-  }
-};
-
-// src/server/ws/protocol.ts
-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 (Buffer.byteLength(raw, "utf8") > MAX_WS_FRAME_BYTES) {
-    return JSON.stringify({ type: "error", message: "Message too large" });
-  }
-  let msg;
-  try {
-    msg = JSON.parse(raw);
-  } catch {
-    return JSON.stringify({ type: "error", message: "Invalid JSON" });
-  }
-  switch (msg.type) {
-    case "subscribe": {
-      const error = validateChannel(msg.channel);
-      if (error) return JSON.stringify({ type: "error", message: error });
-      connMgr.subscribe(socket, msg.channel);
-      return JSON.stringify({ type: "subscribed", channel: msg.channel });
-    }
-    case "unsubscribe": {
-      const error = validateChannel(msg.channel);
-      if (error) return JSON.stringify({ type: "error", message: error });
-      connMgr.unsubscribe(socket, msg.channel);
-      return JSON.stringify({ type: "unsubscribed", channel: msg.channel });
-    }
-    case "ping":
-      return JSON.stringify({ type: "pong" });
-    default:
-      return JSON.stringify({ type: "error", message: "Unknown message type" });
-  }
-}
-function validateChannel(channel) {
-  if (typeof channel !== "string" || !channel) {
-    return "Missing or invalid channel";
-  }
-  if (channel.length > MAX_CHANNEL_LENGTH) {
-    return `Channel name exceeds ${MAX_CHANNEL_LENGTH} characters`;
-  }
-  if (!VALID_EXACT_CHANNELS.includes(channel) && !VALID_CHANNEL_PREFIXES.some((p) => channel.startsWith(p))) {
-    return `Invalid channel: ${channel}`;
-  }
-  return null;
-}
-
-// src/server/ws/handler.ts
-function createWsHandlers(connMgr) {
-  return {
-    onOpen(_event, ws) {
-      connMgr.add(ws);
-    },
-    onMessage(event, ws) {
-      const reply = handleWsMessage(String(event.data), ws, connMgr);
-      if (reply) ws.send(reply);
-    },
-    onClose(_event, ws) {
-      connMgr.remove(ws);
-    },
-    onError(_event, ws) {
-      connMgr.remove(ws);
-    }
-  };
-}
-
-// src/server/aggregates/aggregate-snapshots.ts
-var WINDOW_MS = {
-  "24h": 24 * 60 * 60 * 1e3,
-  "7d": 7 * 24 * 60 * 60 * 1e3,
-  "30d": 30 * 24 * 60 * 60 * 1e3,
-  all: Number.POSITIVE_INFINITY
-};
-function withinWindow(ts, window, now) {
-  return ts >= now - WINDOW_MS[window];
-}
-var REBUILD_INTERVAL_MS = 5 * 6e4;
-var ALL_WINDOWS = new Set(Object.keys(WINDOW_MS));
-function parseWindowParam(raw, fallback = "7d") {
-  return raw && ALL_WINDOWS.has(raw) ? raw : fallback;
-}
-var AggregateSnapshots = class {
-  constructor(windows, emptyState, connMgr, channel, broadcastTransform) {
-    this.windows = windows;
-    this.emptyState = emptyState;
-    this.connMgr = connMgr;
-    this.channel = channel;
-    this.broadcastTransform = broadcastTransform;
-    this.snapshots = new Map(windows.map((w) => [w, emptyState()]));
-  }
-  snapshots;
-  /** Replace all snapshots atomically — used after a full rebuild. */
-  replace(fresh) {
-    this.snapshots = fresh;
-    this.broadcast();
-  }
-  /** Apply a reducer update to every window where `ts` falls inside the window. */
-  fold(ts, update) {
-    const now = Date.now();
-    let changed = false;
-    for (const window of this.windows) {
-      if (withinWindow(ts, window, now)) {
-        const prev = this.snapshots.get(window);
-        this.snapshots.set(window, update(prev));
-        changed = true;
-      }
-    }
-    if (changed) this.broadcast();
-  }
-  get(window) {
-    return this.snapshots.get(window) ?? this.emptyState();
-  }
-  getAll() {
-    return Object.fromEntries(this.snapshots);
-  }
-  broadcast() {
-    const snapshots = this.broadcastTransform ? Object.fromEntries(
-      this.windows.map((w) => [w, this.broadcastTransform(this.snapshots.get(w))])
-    ) : this.getAll();
-    this.connMgr.broadcast(this.channel, {
-      snapshots,
-      updatedAt: Date.now()
-    });
-  }
-};
-
-// src/server/aggregates/trace-aggregator.ts
-var TraceAggregator = 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 = (event) => {
-      this.snaps.fold(event.timestamp, (prev) => this.options.reducer(prev, event));
-    };
-    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() {
-    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 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));
-          }
-        }
-      }
-    }
-    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/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 emptyRetry() {
-  return {
-    primary: 0,
-    primaryCalls: 0,
-    schema: 0,
-    schemaCalls: 0,
-    validate: 0,
-    validateCalls: 0,
-    guardrail: 0,
-    guardrailCalls: 0,
-    retryCalls: 0
-  };
-}
-function emptyCostData() {
-  return {
-    totalCost: 0,
-    totalTokens: { input: 0, output: 0, reasoning: 0 },
-    byAgent: {},
-    byModel: {},
-    byWorkflow: {},
-    retry: emptyRetry(),
-    byEmbedder: {}
-  };
-}
-function reduceCost(acc, event) {
-  const isWorkflowStart = event.type === "workflow_start";
-  if (isWorkflowStart && event.workflow) {
-    const byWorkflow2 = { ...acc.byWorkflow };
-    const prev = byWorkflow2[event.workflow] ?? { cost: 0, executions: 0 };
-    byWorkflow2[event.workflow] = { ...prev, executions: prev.executions + 1 };
-    return { ...acc, byWorkflow: byWorkflow2 };
-  }
-  if (event.cost == null && !event.tokens) return acc;
-  const cost = eventCostContribution(event);
-  if (event.type === "ask_end") return acc;
-  const tokens = event.tokens ?? {};
-  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)
-  } : acc.totalTokens;
-  const byAgent = { ...acc.byAgent };
-  if (event.agent) {
-    const prev = byAgent[event.agent] ?? { cost: 0, calls: 0 };
-    byAgent[event.agent] = { cost: prev.cost + cost, calls: prev.calls + 1 };
-  }
-  const byModel = { ...acc.byModel };
-  if (event.model) {
-    const prev = byModel[event.model] ?? { cost: 0, calls: 0, tokens: { input: 0, output: 0 } };
-    byModel[event.model] = {
-      cost: prev.cost + cost,
-      calls: prev.calls + 1,
-      tokens: {
-        input: prev.tokens.input + finite(tokens.input),
-        output: prev.tokens.output + finite(tokens.output)
-      }
-    };
-  }
-  const byWorkflow = { ...acc.byWorkflow };
-  if (event.workflow) {
-    const prev = byWorkflow[event.workflow] ?? { cost: 0, executions: 0 };
-    byWorkflow[event.workflow] = {
-      cost: prev.cost + cost,
-      executions: prev.executions + (isWorkflowStart ? 1 : 0)
-    };
-  }
-  let retry = acc.retry;
-  if (event.type === "agent_call_end") {
-    const d = event.data ?? {};
-    const reason = d.retryReason;
-    retry = { ...acc.retry };
-    if (reason === "schema") {
-      retry.schema += cost;
-      retry.schemaCalls += 1;
-      retry.retryCalls += 1;
-    } else if (reason === "validate") {
-      retry.validate += cost;
-      retry.validateCalls += 1;
-      retry.retryCalls += 1;
-    } else if (reason === "guardrail") {
-      retry.guardrail += cost;
-      retry.guardrailCalls += 1;
-      retry.retryCalls += 1;
-    } else {
-      retry.primary += cost;
-      retry.primaryCalls += 1;
-    }
-  }
-  let byEmbedder = acc.byEmbedder;
-  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,
-    totalTokens,
-    byAgent,
-    byModel,
-    byWorkflow,
-    retry,
-    byEmbedder
-  };
-}
-function emptyEvalTrendData() {
-  return { byEval: {}, totalRuns: 0, totalCost: 0 };
-}
-function extractScores(data) {
-  if (!data || typeof data !== "object") return {};
-  const result = data;
-  const summary = result.summary;
-  const scorers = summary?.scorers;
-  if (!scorers) return {};
-  const out = {};
-  for (const [name, entry] of Object.entries(scorers)) {
-    if (typeof entry === "number" && Number.isFinite(entry)) {
-      out[name] = entry;
-    } else if (entry && typeof entry === "object" && Number.isFinite(entry.mean)) {
-      out[name] = entry.mean;
-    }
-  }
-  return out;
-}
-function extractCost(data) {
-  if (!data || typeof data !== "object") return 0;
-  const result = data;
-  if (Number.isFinite(result.totalCost)) return result.totalCost;
-  const summary = result.summary;
-  return Number.isFinite(summary?.totalCost) ? summary.totalCost : 0;
-}
-function extractModel(data) {
-  if (!data || typeof data !== "object") return void 0;
-  const result = data;
-  const metadata = result.metadata;
-  const counts = metadata?.modelCounts;
-  if (counts && typeof counts === "object" && !Array.isArray(counts)) {
-    const entries = Object.entries(counts).filter(
-      ([, v]) => typeof v === "number"
-    );
-    if (entries.length > 0) {
-      entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
-      return entries[0][0];
-    }
-  }
-  const models = metadata?.models;
-  if (Array.isArray(models) && typeof models[0] === "string") return models[0];
-  return void 0;
-}
-function extractDuration(data) {
-  if (!data || typeof data !== "object") return void 0;
-  const result = data;
-  return Number.isFinite(result.duration) ? result.duration : void 0;
-}
-function computeScoreStats(runs) {
-  const scorerNames = /* @__PURE__ */ new Set();
-  for (const run of runs) {
-    for (const name of Object.keys(run.scores)) scorerNames.add(name);
-  }
-  const mean = {};
-  const std = {};
-  for (const name of scorerNames) {
-    const values = runs.map((r) => r.scores[name]).filter((v) => v != null);
-    if (values.length === 0) continue;
-    const m = values.reduce((a, b) => a + b, 0) / values.length;
-    mean[name] = m;
-    const variance = values.reduce((sum, v) => sum + (v - m) ** 2, 0) / values.length;
-    std[name] = Math.sqrt(variance);
-  }
-  return { mean, std };
-}
-function reduceEvalTrends(acc, entry) {
-  const scores = extractScores(entry.data);
-  const cost = extractCost(entry.data);
-  const model = extractModel(entry.data);
-  const duration = extractDuration(entry.data);
-  const metadata = entry.data?.metadata;
-  const runGroupId = typeof metadata?.runGroupId === "string" ? metadata.runGroupId : void 0;
-  const batchAttempted = typeof metadata?.batchAttempted === "number" && Number.isFinite(metadata.batchAttempted) ? metadata.batchAttempted : void 0;
-  const run = {
-    timestamp: entry.timestamp,
-    id: entry.id,
-    scores,
-    cost,
-    ...model !== void 0 ? { model } : {},
-    ...duration !== void 0 ? { duration } : {},
-    ...runGroupId !== void 0 ? { runGroupId } : {},
-    ...batchAttempted !== void 0 ? { batchAttempted } : {}
-  };
-  const byEval = { ...acc.byEval };
-  const prev = byEval[entry.eval];
-  const MAX_EVAL_RUNS = 50;
-  const allRuns = prev ? [...prev.runs, run] : [run];
-  const runs = allRuns.length > MAX_EVAL_RUNS ? allRuns.slice(-MAX_EVAL_RUNS) : allRuns;
-  const { mean, std } = computeScoreStats(runs);
-  const latestScores = prev && prev.runs.length > 0 && prev.runs[prev.runs.length - 1].timestamp > run.timestamp ? prev.latestScores : scores;
-  byEval[entry.eval] = {
-    runs,
-    latestScores,
-    scoreMean: mean,
-    scoreStd: std,
-    costTotal: (prev?.costTotal ?? 0) + cost,
-    runCount: (prev?.runCount ?? 0) + 1
-  };
-  return {
-    byEval,
-    totalRuns: acc.totalRuns + 1,
-    totalCost: acc.totalCost + cost
-  };
-}
-var MAX_DURATIONS = 200;
-function emptyWorkflowStatsData() {
-  return { byWorkflow: {}, totalExecutions: 0, failureRate: 0 };
-}
-function percentile(sorted, p) {
-  if (sorted.length === 0) return 0;
-  const idx = p / 100 * (sorted.length - 1);
-  const lower = Math.floor(idx);
-  const upper = Math.ceil(idx);
-  if (lower === upper) return sorted[lower];
-  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
-}
-function reduceWorkflowStats(acc, execution) {
-  const byWorkflow = { ...acc.byWorkflow };
-  const prev = byWorkflow[execution.workflow] ?? {
-    total: 0,
-    completed: 0,
-    failed: 0,
-    durations: [],
-    durationSum: 0,
-    avgDuration: 0
-  };
-  const dur = finite(execution.duration);
-  const durations = [...prev.durations];
-  const insertIdx = durations.findIndex((d) => d > dur);
-  if (insertIdx === -1) durations.push(dur);
-  else durations.splice(insertIdx, 0, dur);
-  if (durations.length > MAX_DURATIONS) durations.shift();
-  const total = prev.total + 1;
-  const completed = prev.completed + (execution.status === "completed" ? 1 : 0);
-  const failed = prev.failed + (execution.status === "failed" ? 1 : 0);
-  const durationSum = prev.durationSum + dur;
-  const avgDuration = durationSum / total;
-  byWorkflow[execution.workflow] = {
-    total,
-    completed,
-    failed,
-    durations,
-    durationSum,
-    avgDuration
-  };
-  const totalExecutions = acc.totalExecutions + 1;
-  const totalFailed = Object.values(byWorkflow).reduce((sum, w) => sum + w.failed, 0);
-  const failureRate = totalExecutions > 0 ? totalFailed / totalExecutions : 0;
-  return { byWorkflow, totalExecutions, failureRate };
-}
-function getWorkflowPercentiles(entry) {
-  return {
-    durationP50: percentile(entry.durations, 50),
-    durationP95: percentile(entry.durations, 95)
-  };
-}
-function enrichWorkflowStats(data) {
-  const byWorkflow = {};
-  for (const [name, entry] of Object.entries(data.byWorkflow)) {
-    const { durationP50, durationP95 } = getWorkflowPercentiles(entry);
-    byWorkflow[name] = {
-      total: entry.total,
-      completed: entry.completed,
-      failed: entry.failed,
-      durationP50,
-      durationP95,
-      avgDuration: entry.avgDuration
-    };
-  }
-  return {
-    byWorkflow,
-    totalExecutions: data.totalExecutions,
-    failureRate: data.failureRate
-  };
-}
-function emptyTraceStatsData() {
-  return {
-    eventTypeCounts: {},
-    byTool: {},
-    retryByAgent: {},
-    totalEvents: 0
-  };
-}
-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_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";
-    const isApprovalEvent = event.type === "tool_approval";
-    const eventData = isDeniedEvent || isApprovalEvent ? event.data : void 0;
-    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_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_end") {
-    const data = event.data;
-    if (data?.retryReason) {
-      const prev = retryByAgent[event.agent] ?? { schema: 0, validate: 0, guardrail: 0 };
-      const reason = data.retryReason;
-      if (reason in prev) {
-        retryByAgent[event.agent] = { ...prev, [reason]: prev[reason] + 1 };
-      }
-    }
-  }
-  return {
-    eventTypeCounts,
-    byTool,
-    retryByAgent,
-    totalEvents: acc.totalEvents + 1
-  };
-}
-
-// src/server/routes/health.ts
-import { Hono } from "hono";
-function createHealthRoutes(readOnly) {
-  const app6 = new Hono();
-  app6.get("/health", (c) => {
-    const runtime = c.get("runtime");
-    return c.json({
-      ok: true,
-      data: {
-        status: "healthy",
-        readOnly,
-        workflows: runtime.getWorkflowNames().length,
-        agents: runtime.getAgents().length,
-        tools: runtime.getTools().length
-      }
-    });
-  });
-  return app6;
-}
-
-// src/server/routes/workflows.ts
-import { Hono as Hono2 } from "hono";
-import { zodToJsonSchema } from "@axlsdk/axl";
-function createWorkflowRoutes(connMgr) {
-  const app6 = new Hono2();
-  app6.get("/workflows", (c) => {
-    const runtime = c.get("runtime");
-    const workflows = runtime.getWorkflows().map((w) => ({
-      name: w.name,
-      hasInputSchema: !!w.inputSchema,
-      hasOutputSchema: !!w.outputSchema
-    }));
-    return c.json({ ok: true, data: workflows });
-  });
-  app6.get("/workflows/:name", (c) => {
-    const runtime = c.get("runtime");
-    const name = c.req.param("name");
-    const workflow = runtime.getWorkflow(name);
-    if (!workflow) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: `Workflow "${name}" not found` } },
-        404
-      );
-    }
-    return c.json({
-      ok: true,
-      data: {
-        name: workflow.name,
-        inputSchema: workflow.inputSchema ? zodToJsonSchema(workflow.inputSchema) : null,
-        outputSchema: workflow.outputSchema ? zodToJsonSchema(workflow.outputSchema) : null
-      }
-    });
-  });
-  app6.post("/workflows/:name/execute", async (c) => {
-    const runtime = c.get("runtime");
-    const name = c.req.param("name");
-    const workflow = runtime.getWorkflow(name);
-    if (!workflow) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: `Workflow "${name}" not found` } },
-        404
-      );
-    }
-    const body = await c.req.json();
-    if (body.stream) {
-      const stream = runtime.stream(name, body.input ?? {}, { metadata: body.metadata });
-      const executionId = `stream-${Date.now()}`;
-      const redactOn = runtime.isRedactEnabled();
-      (async () => {
-        for await (const event of stream) {
-          connMgr.broadcastWithWildcard(
-            `execution:${executionId}`,
-            redactStreamEvent(event, redactOn)
-          );
-        }
-      })();
-      return c.json({ ok: true, data: { executionId, streaming: true } });
-    }
-    const result = await runtime.execute(name, body.input ?? {}, { metadata: body.metadata });
-    return c.json({
-      ok: true,
-      data: { result: redactValue(result, runtime.isRedactEnabled()) }
-    });
-  });
-  return app6;
-}
-
-// src/server/routes/executions.ts
-import { Hono as Hono3 } from "hono";
-var app = new Hono3();
-app.get("/executions", async (c) => {
-  const runtime = c.get("runtime");
-  const executions = await runtime.getExecutions();
-  return c.json({
-    ok: true,
-    data: redactExecutionList(executions, runtime.isRedactEnabled())
-  });
-});
-app.get("/executions/:id", async (c) => {
-  const runtime = c.get("runtime");
-  const id = c.req.param("id");
-  const execution = await runtime.getExecution(id);
-  if (!execution) {
-    return c.json(
-      { ok: false, error: { code: "NOT_FOUND", message: `Execution "${id}" not found` } },
-      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(paged, runtime.isRedactEnabled())
-  });
-});
-app.post("/executions/:id/abort", (c) => {
-  const runtime = c.get("runtime");
-  const id = c.req.param("id");
-  runtime.abort(id);
-  return c.json({ ok: true, data: { aborted: true } });
-});
-var executions_default = app;
-
-// src/server/routes/sessions.ts
-import { Hono as Hono4 } from "hono";
-function createSessionRoutes(connMgr) {
-  const app6 = new Hono4();
-  app6.get("/sessions", async (c) => {
-    const runtime = c.get("runtime");
-    const store = runtime.getStateStore();
-    if (!store.listSessions) {
-      return c.json({ ok: true, data: [] });
-    }
-    const ids = await store.listSessions();
-    const sessions = [];
-    for (const id of ids) {
-      const history = await store.getSession(id);
-      sessions.push({ id, messageCount: history.length });
-    }
-    return c.json({ ok: true, data: sessions });
-  });
-  app6.get("/sessions/:id", async (c) => {
-    const runtime = c.get("runtime");
-    const store = runtime.getStateStore();
-    const id = c.req.param("id");
-    const history = await store.getSession(id);
-    const handoffHistory = await store.getSessionMeta(id, "handoffHistory");
-    return c.json({
-      ok: true,
-      data: {
-        id,
-        history: redactSessionHistory(history, runtime.isRedactEnabled()),
-        // HandoffRecord has no content fields (source/target/mode/
-        // timestamp/duration) — nothing to scrub.
-        handoffHistory: handoffHistory ?? []
-      }
-    });
-  });
-  app6.post("/sessions/:id/send", async (c) => {
-    const runtime = c.get("runtime");
-    const id = c.req.param("id");
-    const body = await c.req.json();
-    const session = runtime.session(id);
-    const result = await session.send(body.workflow, body.message);
-    return c.json({ ok: true, data: { result } });
-  });
-  app6.post("/sessions/:id/stream", async (c) => {
-    const runtime = c.get("runtime");
-    const id = c.req.param("id");
-    const body = await c.req.json();
-    const session = runtime.session(id);
-    const stream = await session.stream(body.workflow, body.message);
-    const executionId = `session-${id}-${Date.now()}`;
-    (async () => {
-      for await (const event of stream) {
-        connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
-      }
-    })();
-    return c.json({ ok: true, data: { executionId, streaming: true } });
-  });
-  app6.delete("/sessions/:id", async (c) => {
-    const runtime = c.get("runtime");
-    const store = runtime.getStateStore();
-    const id = c.req.param("id");
-    await store.deleteSession(id);
-    return c.json({ ok: true, data: { deleted: true } });
-  });
-  return app6;
-}
-
-// src/server/routes/agents.ts
-import { Hono as Hono5 } from "hono";
-import { zodToJsonSchema as zodToJsonSchema2 } from "@axlsdk/axl";
-var app2 = new Hono5();
-app2.get("/agents", (c) => {
-  const runtime = c.get("runtime");
-  const agents = runtime.getAgents().map((a) => ({
-    name: a._name,
-    model: a.resolveModel(),
-    system: a.resolveSystem(),
-    tools: a._config.tools?.map((t) => t.name) ?? [],
-    handoffs: typeof a._config.handoffs === "function" ? ["(dynamic)"] : a._config.handoffs?.map((h) => h.agent._name) ?? [],
-    maxTurns: a._config.maxTurns,
-    temperature: a._config.temperature,
-    maxTokens: a._config.maxTokens,
-    effort: a._config.effort,
-    thinkingBudget: a._config.thinkingBudget,
-    includeThoughts: a._config.includeThoughts,
-    toolChoice: a._config.toolChoice,
-    stop: a._config.stop
-  }));
-  return c.json({ ok: true, data: agents });
-});
-app2.get("/agents/:name", (c) => {
-  const runtime = c.get("runtime");
-  const name = c.req.param("name");
-  const agent = runtime.getAgent(name);
-  if (!agent) {
-    return c.json(
-      { ok: false, error: { code: "NOT_FOUND", message: `Agent "${name}" not found` } },
-      404
-    );
-  }
-  const cfg = agent._config;
-  return c.json({
-    ok: true,
-    data: {
-      name: agent._name,
-      model: agent.resolveModel(),
-      system: agent.resolveSystem(),
-      tools: cfg.tools?.map((t) => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: zodToJsonSchema2(t.inputSchema)
-      })) ?? [],
-      handoffs: typeof cfg.handoffs === "function" ? [
-        {
-          agent: "(dynamic)",
-          description: "Resolved at runtime from metadata",
-          mode: "oneway"
-        }
-      ] : cfg.handoffs?.map((h) => ({
-        agent: h.agent._name,
-        description: h.description,
-        mode: h.mode ?? "oneway"
-      })) ?? [],
-      maxTurns: cfg.maxTurns,
-      temperature: cfg.temperature,
-      maxTokens: cfg.maxTokens,
-      effort: cfg.effort,
-      thinkingBudget: cfg.thinkingBudget,
-      includeThoughts: cfg.includeThoughts,
-      toolChoice: cfg.toolChoice,
-      stop: cfg.stop,
-      timeout: cfg.timeout,
-      maxContext: cfg.maxContext,
-      version: cfg.version,
-      mcp: cfg.mcp,
-      mcpTools: cfg.mcpTools,
-      hasGuardrails: !!cfg.guardrails,
-      guardrails: cfg.guardrails ? {
-        hasInput: !!cfg.guardrails.input,
-        hasOutput: !!cfg.guardrails.output,
-        onBlock: cfg.guardrails.onBlock ?? "throw",
-        maxRetries: cfg.guardrails.maxRetries
-      } : null
-    }
-  });
-});
-var agents_default = app2;
-
-// src/server/routes/tools.ts
-import { Hono as Hono6 } from "hono";
-import { zodToJsonSchema as zodToJsonSchema3 } from "@axlsdk/axl";
-var app3 = new Hono6();
-app3.get("/tools", (c) => {
-  const runtime = c.get("runtime");
-  const tools = runtime.getTools().map((t) => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: t.inputSchema ? zodToJsonSchema3(t.inputSchema) : {},
-    sensitive: t.sensitive ?? false,
-    requireApproval: t.requireApproval ?? false
-  }));
-  return c.json({ ok: true, data: tools });
-});
-app3.get("/tools/:name", (c) => {
-  const runtime = c.get("runtime");
-  const name = c.req.param("name");
-  const tool = runtime.getTool(name);
-  if (!tool) {
-    return c.json(
-      { ok: false, error: { code: "NOT_FOUND", message: `Tool "${name}" not found` } },
-      404
-    );
-  }
-  return c.json({
-    ok: true,
-    data: {
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema ? zodToJsonSchema3(tool.inputSchema) : {},
-      sensitive: tool.sensitive,
-      requireApproval: tool.requireApproval,
-      retry: tool.retry,
-      hasHooks: !!tool.hooks,
-      hooks: tool.hooks ? {
-        hasBefore: !!tool.hooks.before,
-        hasAfter: !!tool.hooks.after
-      } : null
-    }
-  });
-});
-app3.post("/tools/:name/test", async (c) => {
-  const runtime = c.get("runtime");
-  const name = c.req.param("name");
-  const tool = runtime.getTool(name);
-  if (!tool) {
-    return c.json(
-      { ok: false, error: { code: "NOT_FOUND", message: `Tool "${name}" not found` } },
-      404
-    );
-  }
-  const body = await c.req.json();
-  const ctx = runtime.createContext();
-  const result = await tool.run(ctx, body.input);
-  return c.json({
-    ok: true,
-    data: { result: redactValue(result, runtime.isRedactEnabled()) }
-  });
-});
-var tools_default = app3;
-
-// src/server/routes/memory.ts
-import { Hono as Hono7 } from "hono";
-var app4 = new Hono7();
-app4.get("/memory/:scope", async (c) => {
-  const runtime = c.get("runtime");
-  const store = runtime.getStateStore();
-  const scope = c.req.param("scope");
-  if (!store.getAllMemory) {
-    return c.json({ ok: true, data: [] });
-  }
-  const entries = await store.getAllMemory(scope);
-  return c.json({ ok: true, data: redactMemoryList(entries, runtime.isRedactEnabled()) });
-});
-app4.get("/memory/:scope/:key", async (c) => {
-  const runtime = c.get("runtime");
-  const store = runtime.getStateStore();
-  const scope = c.req.param("scope");
-  const key = c.req.param("key");
-  if (!store.getMemory) {
-    return c.json(
-      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
-      501
-    );
-  }
-  const value = await store.getMemory(scope, key);
-  if (value === null) {
-    return c.json(
-      { ok: false, error: { code: "NOT_FOUND", message: `Memory "${scope}/${key}" not found` } },
-      404
-    );
-  }
-  return c.json({
-    ok: true,
-    data: { key, value: redactMemoryValue(value, runtime.isRedactEnabled()) }
-  });
-});
-app4.put("/memory/:scope/:key", async (c) => {
-  const runtime = c.get("runtime");
-  const store = runtime.getStateStore();
-  const scope = c.req.param("scope");
-  const key = c.req.param("key");
-  if (!store.saveMemory) {
-    return c.json(
-      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
-      501
-    );
-  }
-  const body = await c.req.json();
-  await store.saveMemory(scope, key, body.value);
-  return c.json({ ok: true, data: { saved: true } });
-});
-app4.delete("/memory/:scope/:key", async (c) => {
-  const runtime = c.get("runtime");
-  const store = runtime.getStateStore();
-  const scope = c.req.param("scope");
-  const key = c.req.param("key");
-  if (!store.deleteMemory) {
-    return c.json(
-      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
-      501
-    );
-  }
-  await store.deleteMemory(scope, key);
-  return c.json({ ok: true, data: { deleted: true } });
-});
-app4.post("/memory/search", async (c) => {
-  return c.json({
-    ok: true,
-    data: { results: [], message: "Semantic search requires MemoryManager with vector store" }
-  });
-});
-var memory_default = app4;
-
-// src/server/routes/decisions.ts
-import { Hono as Hono8 } from "hono";
-var app5 = new Hono8();
-app5.get("/decisions", async (c) => {
-  const runtime = c.get("runtime");
-  const decisions = await runtime.getPendingDecisions();
-  return c.json({
-    ok: true,
-    data: redactPendingDecisionList(decisions, runtime.isRedactEnabled())
-  });
-});
-app5.post("/decisions/:executionId/resolve", async (c) => {
-  const runtime = c.get("runtime");
-  const executionId = c.req.param("executionId");
-  const body = await c.req.json();
-  await runtime.resolveDecision(executionId, body);
-  return c.json({ ok: true, data: { resolved: true } });
-});
-var decisions_default = app5;
-
-// src/server/routes/costs.ts
-import { Hono as Hono9 } from "hono";
-function createCostRoutes(costAggregator) {
-  const app6 = new Hono9();
-  app6.get("/costs", (c) => {
-    if (c.req.query("windows") === "all") {
-      return c.json({ ok: true, data: costAggregator.getAllSnapshots() });
-    }
-    const window = parseWindowParam(c.req.query("window"));
-    return c.json({ ok: true, data: costAggregator.getSnapshot(window) });
-  });
-  app6.post("/costs/reset", (c) => {
-    return c.json(
-      {
-        ok: false,
-        error: {
-          code: "GONE",
-          message: "POST /api/costs/reset was removed in @axlsdk/studio 0.15. Cost aggregates are now time-windowed and rebuilt from StateStore history. Use GET /api/costs?window=24h|7d|30d|all to narrow the view instead of resetting."
-        }
-      },
-      410
-    );
-  });
-  return app6;
-}
-
-// src/server/routes/evals.ts
-import { randomUUID } from "crypto";
-import { Hono as Hono10 } from "hono";
-function createEvalRoutes(connMgr, evalLoader) {
-  const app6 = new Hono10();
-  const activeRuns = /* @__PURE__ */ new Map();
-  app6.get("/evals", async (c) => {
-    if (evalLoader) await evalLoader();
-    const runtime = c.get("runtime");
-    const evals = runtime.getRegisteredEvals();
-    return c.json({ ok: true, data: evals });
-  });
-  app6.get("/evals/history", async (c) => {
-    const runtime = c.get("runtime");
-    const history = await runtime.getEvalHistory();
-    return c.json({
-      ok: true,
-      data: redactEvalHistoryList(history, runtime.isRedactEnabled())
-    });
-  });
-  app6.delete("/evals/history/:id", async (c) => {
-    const runtime = c.get("runtime");
-    const id = c.req.param("id");
-    const deleted = await runtime.deleteEvalResult(id);
-    if (!deleted) {
-      return c.json(
-        {
-          ok: false,
-          error: { code: "NOT_FOUND", message: `Eval history entry "${id}" not found` }
-        },
-        404
-      );
-    }
-    return c.json({ ok: true, data: { id, deleted: true } });
-  });
-  app6.post("/evals/:name/run", async (c) => {
-    if (evalLoader) await evalLoader();
-    const runtime = c.get("runtime");
-    const name = c.req.param("name");
-    const redactOn = runtime.isRedactEnabled();
-    const entry = runtime.getRegisteredEval(name);
-    if (!entry) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: `Eval "${name}" not found` } },
-        404
-      );
-    }
-    let runs = 1;
-    let stream = false;
-    let captureTraces = false;
-    try {
-      const body = await c.req.json().catch(() => ({}));
-      if (typeof body.runs === "number" && Number.isFinite(body.runs) && body.runs > 1) {
-        runs = Math.min(Math.floor(body.runs), 25);
-      }
-      if (body.stream === true) {
-        stream = true;
-      }
-      if (body.captureTraces === true) {
-        captureTraces = true;
-      }
-    } catch {
-    }
-    if (stream) {
-      const evalRunId = `eval-${randomUUID()}`;
-      const ac = new AbortController();
-      activeRuns.set(evalRunId, ac);
-      (async () => {
-        try {
-          if (runs > 1) {
-            const runGroupId = randomUUID();
-            const results = [];
-            let runFailure;
-            let cancelled = false;
-            for (let r = 0; r < runs; r++) {
-              if (ac.signal.aborted) {
-                cancelled = true;
-                break;
-              }
-              try {
-                const result = await runtime.runRegisteredEval(name, {
-                  metadata: { runGroupId, runIndex: r, batchAttempted: runs },
-                  signal: ac.signal,
-                  captureTraces,
-                  onProgress: (event) => {
-                    if (event.type === "run_done") return;
-                    connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                      ...event,
-                      run: r + 1,
-                      totalRuns: runs
-                    });
-                  }
-                });
-                results.push(result);
-                connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                  type: "run_done",
-                  run: r + 1,
-                  totalRuns: runs
-                });
-              } catch (err) {
-                const isAbort = ac.signal.aborted || err instanceof Error && err.name === "AbortError";
-                if (isAbort) {
-                  cancelled = true;
-                  connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                    type: "run_cancelled",
-                    run: r + 1,
-                    totalRuns: runs
-                  });
-                  break;
-                }
-                runFailure = err instanceof Error ? err : new Error(String(err));
-                connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                  type: "run_failed",
-                  run: r + 1,
-                  totalRuns: runs,
-                  message: redactErrorMessage(runFailure, redactOn)
-                });
-                break;
-              }
-            }
-            if (results.length > 0) {
-              const partial = results.length < runs;
-              const failureMsg = runFailure ? redactErrorMessage(runFailure, redactOn) || String(runFailure) || void 0 : void 0;
-              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                type: "done",
-                evalResultId: results[0].id,
-                runGroupId,
-                ...partial && {
-                  partial: true,
-                  batchCompleted: results.length,
-                  batchAttempted: runs,
-                  // `cancelled` and `batchFailure` are mutually exclusive:
-                  // the catch block sets at most one of {cancelled,
-                  // runFailure}. The client uses `cancelled` to render a
-                  // neutral "Cancelled — X of N runs completed" caption
-                  // instead of the amber "Stopped after: <message>"
-                  // failure caption.
-                  ...cancelled ? { cancelled: true } : {},
-                  ...failureMsg ? { batchFailure: failureMsg } : {}
-                }
-              });
-            } else if (runFailure) {
-              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                type: "error",
-                message: redactErrorMessage(runFailure, redactOn)
-              });
-            } else {
-              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-                type: "error",
-                message: "All runs were cancelled"
-              });
-            }
-          } else {
-            const result = await runtime.runRegisteredEval(name, {
-              signal: ac.signal,
-              captureTraces,
-              onProgress: (event) => {
-                if (event.type === "run_done") return;
-                connMgr.broadcastWithWildcard(`eval:${evalRunId}`, event);
-              }
-            });
-            connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-              type: "done",
-              evalResultId: result.id
-            });
-          }
-        } catch (err) {
-          connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
-            type: "error",
-            message: redactErrorMessage(err, redactOn)
-          });
-        } finally {
-          activeRuns.delete(evalRunId);
-        }
-      })();
-      return c.json({ ok: true, data: { evalRunId } });
-    }
-    try {
-      if (runs > 1) {
-        const { aggregateRuns } = await import("@axlsdk/eval");
-        const runGroupId = randomUUID();
-        const results = [];
-        let runFailure;
-        for (let r = 0; r < runs; r++) {
-          try {
-            const result2 = await runtime.runRegisteredEval(name, {
-              metadata: { runGroupId, runIndex: r, batchAttempted: runs },
-              captureTraces
-            });
-            results.push(result2);
-          } catch (err) {
-            runFailure = err instanceof Error ? err : new Error(String(err));
-            break;
-          }
-        }
-        if (results.length === 0) {
-          throw runFailure ?? new Error("No runs completed");
-        }
-        const aggregate = aggregateRuns(results);
-        const first = results[0];
-        const partial = results.length < runs;
-        const failureMsg = runFailure ? redactErrorMessage(runFailure, redactOn) || String(runFailure) || void 0 : void 0;
-        const result = {
-          ...first,
-          _multiRun: {
-            aggregate,
-            allRuns: results,
-            ...partial && {
-              partial: true,
-              batchCompleted: results.length,
-              batchAttempted: runs,
-              ...failureMsg ? { batchFailure: failureMsg } : {}
-            }
-          }
-        };
-        return c.json({
-          ok: true,
-          data: redactEvalResult(result, redactOn)
-        });
-      } else {
-        const result = await runtime.runRegisteredEval(name, { captureTraces });
-        return c.json({
-          ok: true,
-          data: redactEvalResult(result, redactOn)
-        });
-      }
-    } catch (err) {
-      return c.json(
-        { ok: false, error: { code: "EVAL_ERROR", message: redactErrorMessage(err, redactOn) } },
-        400
-      );
-    }
-  });
-  app6.post("/evals/runs/:evalRunId/cancel", (c) => {
-    const evalRunId = c.req.param("evalRunId");
-    const ac = activeRuns.get(evalRunId);
-    if (!ac) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: "No active eval run found" } },
-        404
-      );
-    }
-    ac.abort();
-    activeRuns.delete(evalRunId);
-    return c.json({ ok: true, data: { cancelled: true } });
-  });
-  app6.post("/evals/:name/rescore", async (c) => {
-    if (evalLoader) await evalLoader();
-    const runtime = c.get("runtime");
-    const redactOn = runtime.isRedactEnabled();
-    const name = c.req.param("name");
-    const body = await c.req.json();
-    if (!body.resultId || typeof body.resultId !== "string") {
-      return c.json(
-        { ok: false, error: { code: "BAD_REQUEST", message: "resultId is required" } },
-        400
-      );
-    }
-    const entry = runtime.getRegisteredEval(name);
-    if (!entry) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: `Eval "${name}" not found` } },
-        404
-      );
-    }
-    const history = await runtime.getEvalHistory();
-    const historyEntry = history.find((h) => h.id === body.resultId);
-    if (!historyEntry) {
-      return c.json(
-        { ok: false, error: { code: "NOT_FOUND", message: `Result "${body.resultId}" not found` } },
-        404
-      );
-    }
-    try {
-      const { rescore } = await import("@axlsdk/eval");
-      const config = entry.config;
-      const result = await rescore(
-        historyEntry.data,
-        config.scorers,
-        runtime
-      );
-      await runtime.saveEvalResult({
-        id: result.id,
-        eval: name,
-        timestamp: Date.now(),
-        data: result
-      });
-      return c.json({
-        ok: true,
-        data: redactEvalResult(result, redactOn)
-      });
-    } catch (err) {
-      return c.json(
-        { ok: false, error: { code: "EVAL_ERROR", message: redactErrorMessage(err, redactOn) } },
-        400
-      );
-    }
-  });
-  app6.post("/evals/compare", async (c) => {
-    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`;
-          }
-        }
-        return null;
-      }
-      return `${name} is required (string or string[])`;
-    };
-    const baselineErr = validateIdParam(body.baselineId, "baselineId");
-    const candidateErr = validateIdParam(body.candidateId, "candidateId");
-    if (baselineErr || candidateErr) {
-      return c.json(
-        {
-          ok: false,
-          error: {
-            code: "BAD_REQUEST",
-            message: [baselineErr, candidateErr].filter(Boolean).join("; ")
-          }
-        },
-        400
-      );
-    }
-    const history = await runtime.getEvalHistory();
-    const byId = new Map(history.map((h) => [h.id, h.data]));
-    const missing = [];
-    const resolveOne = (id) => {
-      const data = byId.get(id);
-      if (!data) missing.push(id);
-      return data;
-    };
-    const resolveSelection = (idOrIds) => {
-      if (Array.isArray(idOrIds)) {
-        const unique = Array.from(new Set(idOrIds));
-        if (unique.length === 1) return resolveOne(unique[0]);
-        const results = [];
-        for (const id of unique) {
-          const data = resolveOne(id);
-          if (data) results.push(data);
-        }
-        return results;
-      }
-      return resolveOne(idOrIds);
-    };
-    const baseline = resolveSelection(body.baselineId);
-    const candidate = resolveSelection(body.candidateId);
-    if (missing.length > 0) {
-      return c.json(
-        {
-          ok: false,
-          error: {
-            code: "NOT_FOUND",
-            message: `Eval result(s) not found in history: ${missing.join(", ")}`
-          }
-        },
-        404
-      );
-    }
-    try {
-      const result = await runtime.evalCompare(baseline, candidate, body.options);
-      return c.json({ ok: true, data: result });
-    } catch (err) {
-      return c.json(
-        {
-          ok: false,
-          error: { code: "COMPARE_FAILED", message: redactErrorMessage(err, redactOn) }
-        },
-        400
-      );
-    }
-  });
-  app6.post("/evals/import", async (c) => {
-    const runtime = c.get("runtime");
-    const body = await c.req.json();
-    const bad = (message) => c.json({ ok: false, error: { code: "BAD_REQUEST", message } }, 400);
-    if (body.result === void 0 || body.result === null) {
-      return bad("result is required");
-    }
-    const resultsRaw = Array.isArray(body.result) ? body.result : [body.result];
-    if (resultsRaw.length === 0) {
-      return bad("result must be a non-empty array or object");
-    }
-    const validatedResults = [];
-    for (let i = 0; i < resultsRaw.length; i++) {
-      const entry = resultsRaw[i];
-      const prefix = resultsRaw.length > 1 ? `result[${i}]` : "result";
-      if (!entry || typeof entry !== "object") {
-        return bad(`${prefix} must be an object`);
-      }
-      const r = entry;
-      if (!Array.isArray(r.items)) {
-        return bad(`${prefix}.items must be an array`);
-      }
-      if (typeof r.summary !== "object" || r.summary == null) {
-        return bad(`${prefix}.summary must be an object`);
-      }
-      if (typeof r.dataset !== "string" || !r.dataset) {
-        return bad(`${prefix}.dataset must be a non-empty string (required for compare)`);
-      }
-      const summary = r.summary;
-      if (typeof summary.scorers !== "object" || summary.scorers == null) {
-        return bad(`${prefix}.summary.scorers must be an object`);
-      }
-      const summaryScorerNames = Object.keys(summary.scorers);
-      const items = r.items;
-      const summaryScorerSet = new Set(summaryScorerNames);
-      const uncoveredAcrossItems = /* @__PURE__ */ new Set();
-      for (const item of items) {
-        const itemScores = item?.scores;
-        if (itemScores && typeof itemScores === "object") {
-          for (const name of Object.keys(itemScores)) {
-            if (!summaryScorerSet.has(name)) uncoveredAcrossItems.add(name);
-          }
-        }
-      }
-      if (uncoveredAcrossItems.size > 0) {
-        return bad(
-          `${prefix} item scores reference scorer(s) not in summary.scorers: ${[...uncoveredAcrossItems].join(", ")}`
-        );
-      }
-      validatedResults.push(r);
-    }
-    const trim = (v) => typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
-    const firstResult = validatedResults[0];
-    const metadataObj = typeof firstResult.metadata === "object" && firstResult.metadata != null ? firstResult.metadata : {};
-    const workflowsFromMeta = Array.isArray(metadataObj.workflows) ? metadataObj.workflows : [];
-    const primaryWorkflow = workflowsFromMeta.find((w) => typeof w === "string");
-    const evalName = trim(body.eval) ?? trim(primaryWorkflow) ?? trim(firstResult.workflow) ?? "imported";
-    const timestamp = Date.now();
-    const imported = [];
-    for (const r of validatedResults) {
-      const id = randomUUID();
-      const entry = {
-        ...r,
-        id,
-        metadata: typeof r.metadata === "object" && r.metadata != null ? r.metadata : {}
-      };
-      await runtime.saveEvalResult({ id, eval: evalName, timestamp, data: entry });
-      imported.push({ id, eval: evalName, timestamp });
-    }
-    if (imported.length === 1) {
-      return c.json({ ok: true, data: imported[0] });
-    }
-    return c.json({ ok: true, data: { imported } });
-  });
-  function closeActiveRuns() {
-    for (const ac of activeRuns.values()) ac.abort();
-    activeRuns.clear();
-  }
-  return { app: app6, closeActiveRuns };
-}
-
-// src/server/routes/playground.ts
-import { Hono as Hono11 } from "hono";
-function createPlaygroundRoutes(connMgr) {
-  const app6 = new Hono11();
-  app6.post("/playground/chat", async (c) => {
-    const runtime = c.get("runtime");
-    const body = await c.req.json();
-    if (!body.message || typeof body.message !== "string" || !body.message.trim()) {
-      return c.json(
-        {
-          ok: false,
-          error: {
-            code: "INVALID_INPUT",
-            message: "message is required and must be a non-empty string"
-          }
-        },
-        400
-      );
-    }
-    const agents = runtime.getAgents();
-    const agent = body.agent ? agents.find((a) => a._name === body.agent) : agents[0];
-    if (!agent) {
-      return c.json(
-        {
-          ok: false,
-          error: { code: "NO_AGENT", message: `Agent "${body.agent ?? ""}" not found` }
-        },
-        400
-      );
-    }
-    const sessionId = body.sessionId ?? `playground-${Date.now()}`;
-    const store = runtime.getStateStore();
-    const history = await store.getSession(sessionId);
-    history.push({ role: "user", content: body.message });
-    const redactOn = runtime.isRedactEnabled();
-    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));
-    };
-    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);
-        const doneEvent = {
-          ...terminalFields(),
-          type: "done",
-          data: { result: resultText }
-        };
-        connMgr.broadcastWithWildcard(
-          `execution:${executionId}`,
-          redactStreamEvent(doneEvent, redactOn)
-        );
-      } catch (err) {
-        const errorEvent = {
-          ...terminalFields(),
-          type: "error",
-          data: { message: err instanceof Error ? err.message : String(err) }
-        };
-        connMgr.broadcastWithWildcard(
-          `execution:${executionId}`,
-          redactStreamEvent(errorEvent, redactOn)
-        );
-      } finally {
-        runtime.off("trace", traceListener);
-      }
-    })();
-    return c.json({
-      ok: true,
-      data: { sessionId, executionId, streaming: true }
-    });
-  });
-  return app6;
-}
-
-// src/server/routes/eval-trends.ts
-import { Hono as Hono12 } from "hono";
-function createEvalTrendsRoutes(aggregator) {
-  const app6 = new Hono12();
-  app6.get("/eval-trends", (c) => {
-    const window = parseWindowParam(c.req.query("window"));
-    return c.json({ ok: true, data: aggregator.getSnapshot(window) });
-  });
-  return app6;
-}
-
-// src/server/routes/workflow-stats.ts
-import { Hono as Hono13 } from "hono";
-function createWorkflowStatsRoutes(aggregator) {
-  const app6 = new Hono13();
-  app6.get("/workflow-stats", (c) => {
-    const window = parseWindowParam(c.req.query("window"));
-    return c.json({ ok: true, data: enrichWorkflowStats(aggregator.getSnapshot(window)) });
-  });
-  return app6;
-}
-
-// src/server/routes/trace-stats.ts
-import { Hono as Hono14 } from "hono";
-function createTraceStatsRoutes(aggregator) {
-  const app6 = new Hono14();
-  app6.get("/trace-stats", (c) => {
-    const window = parseWindowParam(c.req.query("window"));
-    return c.json({ ok: true, data: aggregator.getSnapshot(window) });
-  });
-  return app6;
-}
-
-// src/server/index.ts
-function createServer(options) {
-  const { runtime, staticRoot, basePath = "", readOnly = false } = options;
-  const app6 = new Hono15();
-  const connMgr = new ConnectionManager(options.bufferCaps);
-  const windows = ["24h", "7d", "30d", "all"];
-  const costAggregator = new TraceAggregator({
-    runtime,
-    connMgr,
-    channel: "costs",
-    reducer: reduceCost,
-    emptyState: emptyCostData,
-    windows
-  });
-  const workflowStatsAggregator = new ExecutionAggregator({
-    runtime,
-    connMgr,
-    channel: "workflow-stats",
-    reducer: reduceWorkflowStats,
-    emptyState: emptyWorkflowStatsData,
-    windows,
-    broadcastTransform: enrichWorkflowStats
-  });
-  const traceStatsAggregator = new TraceAggregator({
-    runtime,
-    connMgr,
-    channel: "trace-stats",
-    reducer: reduceTraceStats,
-    emptyState: emptyTraceStatsData,
-    windows
-  });
-  const evalTrendsAggregator = new EvalAggregator({
-    runtime,
-    connMgr,
-    channel: "eval-trends",
-    reducer: reduceEvalTrends,
-    emptyState: emptyEvalTrendData,
-    windows
-  });
-  if (options.cors !== false) {
-    app6.use("*", cors());
-  }
-  app6.use("*", errorHandler);
-  app6.use("*", async (c, next) => {
-    c.set("runtime", runtime);
-    await next();
-  });
-  if (readOnly) {
-    const blocked = [
-      /^POST \/api\/workflows(\/|$)/,
-      /^POST \/api\/executions(\/|$)/,
-      /^POST \/api\/sessions(\/|$)/,
-      /^DELETE \/api\/sessions(\/|$)/,
-      /^PUT \/api\/memory(\/|$)/,
-      /^DELETE \/api\/memory(\/|$)/,
-      /^POST \/api\/decisions(\/|$)/,
-      /^POST \/api\/tools(\/|$)/,
-      /^POST \/api\/evals\/import$/,
-      /^POST \/api\/evals\/[^/]+\/run$/,
-      /^POST \/api\/evals\/[^/]+\/rescore$/,
-      /^POST \/api\/evals\/runs\/[^/]+\/cancel$/,
-      /^DELETE \/api\/evals\/history\/[^/]+$/,
-      /^POST \/api\/playground(\/|$)/
-    ];
-    app6.use("/api/*", async (c, next) => {
-      const apiIdx = c.req.path.indexOf("/api/");
-      const apiPath = apiIdx >= 0 ? c.req.path.slice(apiIdx) : c.req.path;
-      const key = `${c.req.method} ${apiPath}`;
-      if (blocked.some((re) => re.test(key))) {
-        return c.json(
-          {
-            ok: false,
-            error: { code: "READ_ONLY", message: "Studio is mounted in read-only mode" }
-          },
-          405
-        );
-      }
-      await next();
-    });
-  }
-  const api = new Hono15();
-  api.route("/", createHealthRoutes(readOnly));
-  api.route("/", createWorkflowRoutes(connMgr));
-  api.route("/", executions_default);
-  api.route("/", createSessionRoutes(connMgr));
-  api.route("/", agents_default);
-  api.route("/", tools_default);
-  api.route("/", memory_default);
-  api.route("/", decisions_default);
-  api.route("/", createCostRoutes(costAggregator));
-  api.route("/", createEvalTrendsRoutes(evalTrendsAggregator));
-  api.route("/", createWorkflowStatsRoutes(workflowStatsAggregator));
-  api.route("/", createTraceStatsRoutes(traceStatsAggregator));
-  const { app: evalApp, closeActiveRuns } = createEvalRoutes(connMgr, options.evalLoader);
-  api.route("/", evalApp);
-  api.route("/", createPlaygroundRoutes(connMgr));
-  app6.route("/api", api);
-  const traceListener = (event) => {
-    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);
-  const aggregatorStartPromise = Promise.all([
-    costAggregator.start(),
-    workflowStatsAggregator.start(),
-    traceStatsAggregator.start(),
-    evalTrendsAggregator.start()
-  ]).catch((err) => console.error("[axl-studio] aggregator start failed:", err));
-  if (staticRoot) {
-    const indexPath = resolve(staticRoot, "index.html");
-    let spaHtml;
-    if (!existsSync(indexPath)) {
-      console.warn(`[axl-studio] index.html not found at ${indexPath}`);
-    } else {
-      const rawHtml = readFileSync(indexPath, "utf-8");
-      if (basePath) {
-        const safeBasePath = JSON.stringify(basePath).replace(/</g, "\\u003c");
-        const injected = rawHtml.replace(
-          "<head>",
-          `<head>
-<base href="${basePath}/">
-<script>window.__AXL_STUDIO_BASE__=${safeBasePath}</script>`
-        );
-        if (injected === rawHtml) {
-          console.warn(
-            "[axl-studio] Could not inject basePath into index.html \u2014 <head> tag not found. The SPA may not route correctly."
-          );
-        }
-        spaHtml = injected;
-      } else {
-        spaHtml = rawHtml;
-      }
-    }
-    const staticHandler = serveStatic({
-      root: staticRoot,
-      rewriteRequestPath: basePath ? (path) => path.startsWith(basePath) ? path.slice(basePath.length) || "/" : path : void 0
-    });
-    app6.use("/*", async (c, next) => {
-      const reqPath = c.req.path;
-      const resolved = basePath && reqPath.startsWith(basePath) ? reqPath.slice(basePath.length) || "/" : reqPath;
-      if (resolved === "/" || resolved === "/index.html" || resolved === "/ws") {
-        return next();
-      }
-      return staticHandler(c, next);
-    });
-    if (spaHtml) {
-      app6.get("*", async (c, next) => {
-        const resolved = basePath && c.req.path.startsWith(basePath) ? c.req.path.slice(basePath.length) || "/" : c.req.path;
-        if (resolved === "/ws") return next();
-        return c.html(spaHtml);
-      });
-    }
-  }
-  return {
-    app: app6,
-    connMgr,
-    costAggregator,
-    workflowStatsAggregator,
-    traceStatsAggregator,
-    evalTrendsAggregator,
-    aggregatorStartPromise,
-    /** Create WS handlers. Call before registering static/SPA routes are reached. */
-    createWsHandlers: () => createWsHandlers(connMgr),
-    traceListener,
-    /** Abort all active streaming eval runs. */
-    closeActiveRuns,
-    /** Close all aggregators (clear intervals and unsubscribe listeners). */
-    closeAggregators: () => {
-      costAggregator.close();
-      workflowStatsAggregator.close();
-      traceStatsAggregator.close();
-      evalTrendsAggregator.close();
-    }
-  };
-}
-
-export {
-  ConnectionManager,
-  handleWsMessage,
-  TraceAggregator,
-  ExecutionAggregator,
-  EvalAggregator,
-  createServer
-};
-//# sourceMappingURL=chunk-7RBO72NQ.js.map