@axlsdk/studio 0.2.0

package/dist/server/index.cjs

@@ -0,0 +1,756 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  ConnectionManager: () => ConnectionManager,
+  CostAggregator: () => CostAggregator,
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_hono12 = require("hono");
+var import_cors = require("hono/cors");
+var import_serve_static = require("@hono/node-server/serve-static");
+
+// src/server/middleware/error-handler.ts
+async function errorHandler(c, next) {
+  try {
+    await next();
+  } catch (err) {
+    const message = 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" || message.includes("not found") || message.includes("not registered")) {
+      status = 404;
+    } else if (code === "VALIDATION_ERROR" || message.includes("Expected") || message.includes("invalid")) {
+      status = 400;
+    }
+    const body = {
+      ok: false,
+      error: { code, message }
+    };
+    return c.json(body, status);
+  }
+}
+
+// src/server/ws/connection-manager.ts
+var ConnectionManager = class {
+  /** channel -> set of WS connections */
+  channels = /* @__PURE__ */ new Map();
+  /** ws -> set of subscribed channels (for cleanup) */
+  connections = /* @__PURE__ */ new Map();
+  /** Register a new WS connection. */
+  add(ws) {
+    this.connections.set(ws, /* @__PURE__ */ new Set());
+  }
+  /** Remove a WS connection and all its subscriptions. */
+  remove(ws) {
+    const channels = this.connections.get(ws);
+    if (channels) {
+      for (const ch of 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. */
+  subscribe(ws, channel) {
+    let subs = this.channels.get(channel);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.channels.set(channel, subs);
+    }
+    subs.add(ws);
+    this.connections.get(ws)?.add(channel);
+  }
+  /** 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)?.delete(channel);
+  }
+  /** Broadcast data to all subscribers of a channel. */
+  broadcast(channel, data) {
+    const subs = this.channels.get(channel);
+    if (!subs || subs.size === 0) return;
+    const msg = JSON.stringify({ type: "event", channel, data });
+    for (const ws of [...subs]) {
+      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) + ":*";
+      this.broadcast(wildcardChannel, data);
+    }
+  }
+  /** 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/handler.ts
+function createWsHandlers(connMgr) {
+  return {
+    onOpen(_event, ws) {
+      connMgr.add(ws);
+    },
+    onMessage(event, ws) {
+      let msg;
+      try {
+        msg = JSON.parse(String(event.data));
+      } catch {
+        const err = { type: "error", message: "Invalid JSON" };
+        ws.send(JSON.stringify(err));
+        return;
+      }
+      switch (msg.type) {
+        case "subscribe": {
+          connMgr.subscribe(ws, msg.channel);
+          const reply = { type: "subscribed", channel: msg.channel };
+          ws.send(JSON.stringify(reply));
+          break;
+        }
+        case "unsubscribe": {
+          connMgr.unsubscribe(ws, msg.channel);
+          const reply = { type: "unsubscribed", channel: msg.channel };
+          ws.send(JSON.stringify(reply));
+          break;
+        }
+        case "ping": {
+          const reply = { type: "pong" };
+          ws.send(JSON.stringify(reply));
+          break;
+        }
+        default: {
+          const err = { type: "error", message: `Unknown message type` };
+          ws.send(JSON.stringify(err));
+        }
+      }
+    },
+    onClose(_event, ws) {
+      connMgr.remove(ws);
+    },
+    onError(_event, ws) {
+      connMgr.remove(ws);
+    }
+  };
+}
+
+// src/server/cost-aggregator.ts
+var CostAggregator = class {
+  constructor(connMgr) {
+    this.connMgr = connMgr;
+  }
+  data = {
+    totalCost: 0,
+    totalTokens: { input: 0, output: 0, reasoning: 0 },
+    byAgent: {},
+    byModel: {},
+    byWorkflow: {}
+  };
+  /** Process a trace event and update cost data. */
+  onTrace(event) {
+    if (!event.cost && !event.tokens) return;
+    const cost = event.cost ?? 0;
+    const tokens = event.tokens ?? {};
+    this.data.totalCost += cost;
+    this.data.totalTokens.input += tokens.input ?? 0;
+    this.data.totalTokens.output += tokens.output ?? 0;
+    this.data.totalTokens.reasoning += tokens.reasoning ?? 0;
+    if (event.agent) {
+      const entry = this.data.byAgent[event.agent] ?? { cost: 0, calls: 0 };
+      entry.cost += cost;
+      entry.calls += 1;
+      this.data.byAgent[event.agent] = entry;
+    }
+    if (event.model) {
+      const entry = this.data.byModel[event.model] ?? {
+        cost: 0,
+        calls: 0,
+        tokens: { input: 0, output: 0 }
+      };
+      entry.cost += cost;
+      entry.calls += 1;
+      entry.tokens.input += tokens.input ?? 0;
+      entry.tokens.output += tokens.output ?? 0;
+      this.data.byModel[event.model] = entry;
+    }
+    if (event.workflow) {
+      const entry = this.data.byWorkflow[event.workflow] ?? { cost: 0, executions: 0 };
+      entry.cost += cost;
+      if (event.type === "workflow_start") entry.executions += 1;
+      this.data.byWorkflow[event.workflow] = entry;
+    }
+    this.connMgr.broadcast("costs", this.data);
+  }
+  /** Get current aggregated cost data. */
+  getData() {
+    return this.data;
+  }
+  /** Reset all accumulated data. */
+  reset() {
+    this.data = {
+      totalCost: 0,
+      totalTokens: { input: 0, output: 0, reasoning: 0 },
+      byAgent: {},
+      byModel: {},
+      byWorkflow: {}
+    };
+  }
+};
+
+// src/server/routes/health.ts
+var import_hono = require("hono");
+var app = new import_hono.Hono();
+app.get("/health", (c) => {
+  const runtime = c.get("runtime");
+  return c.json({
+    ok: true,
+    data: {
+      status: "healthy",
+      workflows: runtime.getWorkflowNames().length,
+      agents: runtime.getAgents().length,
+      tools: runtime.getTools().length
+    }
+  });
+});
+var health_default = app;
+
+// src/server/routes/workflows.ts
+var import_hono2 = require("hono");
+var import_axl = require("@axlsdk/axl");
+function createWorkflowRoutes(connMgr) {
+  const app8 = new import_hono2.Hono();
+  app8.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 });
+  });
+  app8.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 ? (0, import_axl.zodToJsonSchema)(workflow.inputSchema) : null,
+        outputSchema: workflow.outputSchema ? (0, import_axl.zodToJsonSchema)(workflow.outputSchema) : null
+      }
+    });
+  });
+  app8.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()}`;
+      (async () => {
+        try {
+          for await (const event of stream) {
+            connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
+          }
+        } catch (err) {
+          connMgr.broadcastWithWildcard(`execution:${executionId}`, {
+            type: "error",
+            message: err instanceof Error ? err.message : "Stream error"
+          });
+        }
+      })();
+      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 } });
+  });
+  return app8;
+}
+
+// src/server/routes/executions.ts
+var import_hono3 = require("hono");
+var app2 = new import_hono3.Hono();
+app2.get("/executions", (c) => {
+  const runtime = c.get("runtime");
+  const executions = runtime.getExecutions();
+  return c.json({ ok: true, data: executions });
+});
+app2.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
+    );
+  }
+  return c.json({ ok: true, data: execution });
+});
+app2.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 = app2;
+
+// src/server/routes/sessions.ts
+var import_hono4 = require("hono");
+function createSessionRoutes(connMgr) {
+  const app8 = new import_hono4.Hono();
+  app8.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 });
+  });
+  app8.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, handoffHistory: handoffHistory ?? [] } });
+  });
+  app8.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 } });
+  });
+  app8.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 () => {
+      try {
+        for await (const event of stream) {
+          connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
+        }
+      } catch (err) {
+        connMgr.broadcastWithWildcard(`execution:${executionId}`, {
+          type: "error",
+          message: err instanceof Error ? err.message : "Stream error"
+        });
+      }
+    })();
+    return c.json({ ok: true, data: { executionId, streaming: true } });
+  });
+  app8.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 app8;
+}
+
+// src/server/routes/agents.ts
+var import_hono5 = require("hono");
+var import_axl2 = require("@axlsdk/axl");
+var app3 = new import_hono5.Hono();
+app3.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: a._config.handoffs?.map((h) => h.agent._name) ?? [],
+    maxTurns: a._config.maxTurns,
+    temperature: a._config.temperature
+  }));
+  return c.json({ ok: true, data: agents });
+});
+app3.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: (0, import_axl2.zodToJsonSchema)(t.inputSchema)
+      })) ?? [],
+      handoffs: cfg.handoffs?.map((h) => ({
+        agent: h.agent._name,
+        description: h.description,
+        mode: h.mode ?? "oneway"
+      })) ?? [],
+      maxTurns: cfg.maxTurns,
+      temperature: cfg.temperature,
+      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 = app3;
+
+// src/server/routes/tools.ts
+var import_hono6 = require("hono");
+var import_axl3 = require("@axlsdk/axl");
+var app4 = new import_hono6.Hono();
+app4.get("/tools", (c) => {
+  const runtime = c.get("runtime");
+  const tools = runtime.getTools().map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema ? (0, import_axl3.zodToJsonSchema)(t.inputSchema) : {},
+    sensitive: t.sensitive ?? false,
+    requireApproval: t.requireApproval ?? false
+  }));
+  return c.json({ ok: true, data: tools });
+});
+app4.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 ? (0, import_axl3.zodToJsonSchema)(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
+    }
+  });
+});
+app4.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 result = await tool._execute(body.input);
+  return c.json({ ok: true, data: { result } });
+});
+var tools_default = app4;
+
+// src/server/routes/memory.ts
+var import_hono7 = require("hono");
+var app5 = new import_hono7.Hono();
+app5.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: entries });
+});
+app5.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 } });
+});
+app5.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 } });
+});
+app5.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 } });
+});
+app5.post("/memory/search", async (c) => {
+  return c.json({
+    ok: true,
+    data: { results: [], message: "Semantic search requires MemoryManager with vector store" }
+  });
+});
+var memory_default = app5;
+
+// src/server/routes/decisions.ts
+var import_hono8 = require("hono");
+var app6 = new import_hono8.Hono();
+app6.get("/decisions", async (c) => {
+  const runtime = c.get("runtime");
+  const decisions = await runtime.getPendingDecisions();
+  return c.json({ ok: true, data: decisions });
+});
+app6.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 = app6;
+
+// src/server/routes/costs.ts
+var import_hono9 = require("hono");
+function createCostRoutes(costAggregator) {
+  const app8 = new import_hono9.Hono();
+  app8.get("/costs", (c) => {
+    return c.json({ ok: true, data: costAggregator.getData() });
+  });
+  app8.post("/costs/reset", (c) => {
+    costAggregator.reset();
+    return c.json({ ok: true, data: { reset: true } });
+  });
+  return app8;
+}
+
+// src/server/routes/evals.ts
+var import_hono10 = require("hono");
+var app7 = new import_hono10.Hono();
+app7.get("/evals", async (c) => {
+  return c.json({ ok: true, data: { message: "Eval discovery requires @axlsdk/eval" } });
+});
+app7.post("/evals/run", async (c) => {
+  const runtime = c.get("runtime");
+  const body = await c.req.json();
+  try {
+    const result = await runtime.eval(body);
+    return c.json({ ok: true, data: result });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: { code: "EVAL_ERROR", message } }, 400);
+  }
+});
+app7.post("/evals/compare", async (c) => {
+  const runtime = c.get("runtime");
+  const body = await c.req.json();
+  try {
+    const result = await runtime.evalCompare(body.baseline, body.candidate);
+    return c.json({ ok: true, data: result });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ ok: false, error: { code: "EVAL_ERROR", message } }, 400);
+  }
+});
+var evals_default = app7;
+
+// src/server/routes/playground.ts
+var import_hono11 = require("hono");
+function createPlaygroundRoutes(connMgr) {
+  const app8 = new import_hono11.Hono();
+  app8.post("/playground/chat", async (c) => {
+    const runtime = c.get("runtime");
+    const body = await c.req.json();
+    const workflowName = body.workflow ?? runtime.getWorkflowNames()[0];
+    if (!workflowName) {
+      return c.json(
+        { ok: false, error: { code: "NO_WORKFLOW", message: "No workflows registered" } },
+        400
+      );
+    }
+    const sessionId = body.sessionId ?? `playground-${Date.now()}`;
+    const session = runtime.session(sessionId);
+    const stream = await session.stream(workflowName, body.message);
+    const executionId = `playground-${sessionId}-${Date.now()}`;
+    (async () => {
+      try {
+        for await (const event of stream) {
+          connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
+        }
+      } catch (err) {
+        connMgr.broadcastWithWildcard(`execution:${executionId}`, {
+          type: "error",
+          message: err instanceof Error ? err.message : "Stream error"
+        });
+      }
+    })();
+    return c.json({
+      ok: true,
+      data: { sessionId, executionId, streaming: true }
+    });
+  });
+  return app8;
+}
+
+// src/server/index.ts
+function createServer(options) {
+  const { runtime, staticRoot } = options;
+  const app8 = new import_hono12.Hono();
+  const connMgr = new ConnectionManager();
+  const costAggregator = new CostAggregator(connMgr);
+  app8.use("*", (0, import_cors.cors)());
+  app8.use("*", errorHandler);
+  app8.use("*", async (c, next) => {
+    c.set("runtime", runtime);
+    await next();
+  });
+  const api = new import_hono12.Hono();
+  api.route("/", health_default);
+  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("/", evals_default);
+  api.route("/", createPlaygroundRoutes(connMgr));
+  app8.route("/api", api);
+  runtime.on("trace", (event) => {
+    const traceEvent = event;
+    if (traceEvent.executionId) {
+      connMgr.broadcastWithWildcard(`trace:${traceEvent.executionId}`, traceEvent);
+    }
+    costAggregator.onTrace(traceEvent);
+    if (traceEvent.type === "await_human") {
+      connMgr.broadcast("decisions", traceEvent);
+    }
+  });
+  if (staticRoot) {
+    app8.use("/*", (0, import_serve_static.serveStatic)({ root: staticRoot }));
+    app8.get("*", (0, import_serve_static.serveStatic)({ root: staticRoot, path: "/index.html" }));
+  }
+  return { app: app8, connMgr, costAggregator, createWsHandlers: () => createWsHandlers(connMgr) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionManager,
+  CostAggregator,
+  createServer
+});
+//# sourceMappingURL=index.cjs.map