@axlsdk/studio 0.9.1 → 0.10.0

package/dist/middleware.cjs

@@ -0,0 +1,1058 @@
+"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/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  createStudioMiddleware: () => createStudioMiddleware,
+  handleWsMessage: () => handleWsMessage
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_node_path2 = require("path");
+var import_node_fs2 = require("fs");
+var import_node_url = require("url");
+var import_node_server = require("@hono/node-server");
+var import_ws = require("ws");
+
+// src/server/index.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+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();
+  maxConnections = 100;
+  /** Register a new WS connection. */
+  add(ws) {
+    if (this.connections.size >= this.maxConnections) {
+      ws.close?.();
+      return;
+    }
+    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. No-op if the connection was not added. */
+  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).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) + ":*";
+      const subs = this.channels.get(wildcardChannel);
+      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);
+        }
+      }
+    }
+  }
+  /** Close all connections and clear all state. Used during shutdown. */
+  closeAll() {
+    for (const ws of this.connections.keys()) {
+      ws.close?.();
+    }
+    this.connections.clear();
+    this.channels.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:"];
+var VALID_EXACT_CHANNELS = ["costs", "decisions"];
+var MAX_CHANNEL_LENGTH = 256;
+function handleWsMessage(raw, socket, connMgr) {
+  if (raw.length > 65536) {
+    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/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: 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 });
+});
+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: 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 = 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 ctx = runtime.createContext();
+  const result = await tool.run(ctx, 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) => {
+  const runtime = c.get("runtime");
+  const evals = runtime.getRegisteredEvals();
+  return c.json({ ok: true, data: evals });
+});
+app7.post("/evals/:name/run", async (c) => {
+  const runtime = c.get("runtime");
+  const name = c.req.param("name");
+  const entry = runtime.getRegisteredEval(name);
+  if (!entry) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Eval "${name}" not found` } },
+      404
+    );
+  }
+  try {
+    const result = await runtime.runRegisteredEval(name);
+    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, basePath = "", readOnly = false } = options;
+  const app8 = new import_hono12.Hono();
+  const connMgr = new ConnectionManager();
+  const costAggregator = new CostAggregator(connMgr);
+  if (options.cors !== false) {
+    app8.use("*", (0, import_cors.cors)());
+  }
+  app8.use("*", errorHandler);
+  app8.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/costs",
+      "POST /api/tools",
+      "POST /api/evals",
+      "POST /api/playground"
+    ];
+    app8.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((b) => key.startsWith(b))) {
+        return c.json(
+          {
+            ok: false,
+            error: { code: "READ_ONLY", message: "Studio is mounted in read-only mode" }
+          },
+          405
+        );
+      }
+      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);
+  const traceListener = (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);
+    }
+  };
+  runtime.on("trace", traceListener);
+  if (staticRoot) {
+    app8.use(
+      "/*",
+      (0, import_serve_static.serveStatic)({
+        root: staticRoot,
+        rewriteRequestPath: basePath ? (path) => path.startsWith(basePath) ? path.slice(basePath.length) || "/" : path : void 0
+      })
+    );
+    if (basePath) {
+      const indexPath = (0, import_node_path.resolve)(staticRoot, "index.html");
+      if (!(0, import_node_fs.existsSync)(indexPath)) {
+        console.warn(`[axl-studio] index.html not found at ${indexPath}`);
+      } else {
+        const indexHtml = (0, import_node_fs.readFileSync)(indexPath, "utf-8");
+        const safeBasePath = JSON.stringify(basePath).replace(/</g, "\\u003c");
+        const injectedHtml = indexHtml.replace(
+          "</head>",
+          `<base href="${basePath}/">
+<script>window.__AXL_STUDIO_BASE__=${safeBasePath}</script>
+</head>`
+        );
+        if (injectedHtml === indexHtml) {
+          console.warn(
+            "[axl-studio] Could not inject basePath into index.html \u2014 </head> tag not found. The SPA may not route correctly."
+          );
+        }
+        app8.get("*", (c) => c.html(injectedHtml));
+      }
+    } else {
+      app8.get("*", (0, import_serve_static.serveStatic)({ root: staticRoot, path: "/index.html" }));
+    }
+  }
+  return {
+    app: app8,
+    connMgr,
+    costAggregator,
+    createWsHandlers: () => createWsHandlers(connMgr),
+    traceListener
+  };
+}
+
+// src/middleware.ts
+var import_meta = {};
+function createStudioMiddleware(options) {
+  const { runtime, serveClient = true, verifyUpgrade, readOnly = false } = options;
+  const basePath = normalizeBasePath(options.basePath);
+  const staticRoot = serveClient ? resolveClientDist() : void 0;
+  if (serveClient && !staticRoot) {
+    const dir = import_meta.dirname ?? (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+    console.warn(
+      `[axl-studio] serveClient is true but no pre-built client found at ${(0, import_node_path2.resolve)(dir, "client")}. Studio UI will not be available. Set serveClient: false to suppress this warning.`
+    );
+  }
+  const { app: app8, connMgr, traceListener } = createServer({
+    runtime,
+    staticRoot,
+    basePath,
+    readOnly,
+    cors: false
+    // Host framework owns CORS policy
+  });
+  if (process.env.NODE_ENV === "production" && !verifyUpgrade) {
+    console.warn(
+      "[axl-studio] WARNING: Studio middleware mounted in production without verifyUpgrade. WebSocket connections are not authenticated. All registered workflows, tools, and agents are accessible. See https://axlsdk.com/docs/studio/security"
+    );
+  }
+  const listener = (0, import_node_server.getRequestListener)(app8.fetch, {
+    overrideGlobalObjects: false
+  });
+  let closed = false;
+  function handler(req, res) {
+    if (closed) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          ok: false,
+          error: { code: "CLOSED", message: "Studio middleware has been shut down" }
+        })
+      );
+      return;
+    }
+    listener(req, res).catch((err) => {
+      console.error("[axl-studio] Unhandled error in request handler:", err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: { code: "INTERNAL_ERROR", message: "Internal server error" }
+          })
+        );
+      }
+    });
+  }
+  function handleWebSocket(ws) {
+    if (closed) {
+      ws.close();
+      return;
+    }
+    const socket = {
+      send: (data) => ws.send(data),
+      close: () => ws.close()
+    };
+    connMgr.add(socket);
+    ws.on("message", (raw) => {
+      const reply = handleWsMessage(String(raw), socket, connMgr);
+      if (reply) ws.send(reply);
+    });
+    ws.on("close", () => connMgr.remove(socket));
+    ws.on("error", () => connMgr.remove(socket));
+  }
+  let wss;
+  let upgradeHandler;
+  let serverRef;
+  function upgradeWebSocket(server, path) {
+    if (wss) {
+      throw new Error(
+        "[axl-studio] upgradeWebSocket() has already been called. Call close() first if you need to re-attach."
+      );
+    }
+    const wsPath = path ?? (basePath ? `${basePath}/ws` : "/ws");
+    wss = new import_ws.WebSocketServer({ noServer: true });
+    serverRef = server;
+    upgradeHandler = async (req, socket, head) => {
+      const pathname = new URL(req.url, `http://${req.headers.host}`).pathname;
+      if (pathname !== wsPath) return;
+      if (verifyUpgrade) {
+        try {
+          const allowed = await verifyUpgrade(req);
+          if (!allowed) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+          }
+        } catch {
+          socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      }
+      if (!wss) {
+        socket.destroy();
+        return;
+      }
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        handleWebSocket(ws);
+      });
+    };
+    server.on("upgrade", upgradeHandler);
+  }
+  function close() {
+    closed = true;
+    connMgr.closeAll();
+    if (upgradeHandler && serverRef) {
+      serverRef.removeListener("upgrade", upgradeHandler);
+      upgradeHandler = void 0;
+      serverRef = void 0;
+    }
+    if (wss) {
+      wss.close();
+      wss = void 0;
+    }
+    if (traceListener) {
+      runtime.removeListener("trace", traceListener);
+    }
+  }
+  return {
+    handler,
+    handleWebSocket,
+    upgradeWebSocket,
+    app: app8,
+    connectionManager: connMgr,
+    close
+  };
+}
+function normalizeBasePath(raw) {
+  if (!raw) return "";
+  const normalized = raw.replace(/\/+$/, "");
+  if (!normalized) return "";
+  if (!normalized.startsWith("/")) {
+    throw new Error(`basePath must start with '/' (got '${raw}'). Example: '/studio'`);
+  }
+  if (normalized.includes("..")) {
+    throw new Error(`basePath must not contain '..' segments (got '${raw}')`);
+  }
+  if (normalized.includes("//")) {
+    throw new Error(`basePath must not contain consecutive slashes (got '${raw}')`);
+  }
+  if (!/^\/[a-zA-Z0-9/_-]*$/.test(normalized)) {
+    throw new Error(
+      `basePath contains invalid characters (got '${raw}'). Only alphanumeric characters, /, _, and - are allowed.`
+    );
+  }
+  return normalized;
+}
+function resolveClientDist() {
+  const dir = import_meta.dirname ?? (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  const candidate = (0, import_node_path2.resolve)(dir, "client");
+  return (0, import_node_fs2.existsSync)((0, import_node_path2.resolve)(candidate, "index.html")) ? candidate : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStudioMiddleware,
+  handleWsMessage
+});
+//# sourceMappingURL=middleware.cjs.map