@axlsdk/studio 0.2.0

package/dist/cli.cjs

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_path = require("path");
+var import_node_fs = require("fs");
+var import_node_server = require("@hono/node-server");
+var import_node_ws = require("@hono/node-ws");
+
+// src/server/index.ts
+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) };
+}
+
+// src/cli.ts
+var import_meta = {};
+function parseArgs(argv) {
+  let port = 4400;
+  let config = "./axl.config.ts";
+  let open = false;
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--port" && argv[i + 1]) {
+      port = parseInt(argv[i + 1], 10);
+      i++;
+    } else if (arg === "--config" && argv[i + 1]) {
+      config = argv[i + 1];
+      i++;
+    } else if (arg === "--open") {
+      open = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`
+Axl Studio \u2014 Local development UI for Axl agents and workflows
+
+Usage:
+  axl-studio [options]
+
+Options:
+  --port <number>    Server port (default: 4400)
+  --config <path>    Path to axl.config.ts (default: ./axl.config.ts)
+  --open             Auto-open browser
+  -h, --help         Show this help message
+`);
+      process.exit(0);
+    }
+  }
+  if (isNaN(port) || port < 1 || port > 65535) {
+    console.error(`Invalid port: ${port}. Must be between 1 and 65535.`);
+    process.exit(1);
+  }
+  return { port, config, open };
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  const configPath = (0, import_node_path.resolve)(process.cwd(), args.config);
+  if (!(0, import_node_fs.existsSync)(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    console.error(`Create an axl.config.ts that exports a default AxlRuntime instance.`);
+    process.exit(1);
+  }
+  if (configPath.endsWith(".ts") || configPath.endsWith(".tsx")) {
+    try {
+      const { register } = await import("tsx/esm/api");
+      register();
+    } catch {
+    }
+  }
+  console.log(`[axl-studio] Loading config from ${configPath}`);
+  let runtime;
+  try {
+    const mod = await import(configPath);
+    runtime = mod.default ?? mod.runtime;
+    if (!runtime || typeof runtime.execute !== "function") {
+      console.error(`Config must export a default AxlRuntime instance.`);
+      console.error(
+        `Example:
+  import { AxlRuntime } from '@axlsdk/axl';
+  export default new AxlRuntime({ ... });`
+      );
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`Failed to load config:`, err);
+    process.exit(1);
+  }
+  const staticRoot = (0, import_node_path.resolve)(import_meta.dirname ?? __dirname, "client");
+  const hasStaticAssets = (0, import_node_fs.existsSync)((0, import_node_path.resolve)(staticRoot, "index.html"));
+  const { app: app8, createWsHandlers: createWsHandlers2 } = createServer({
+    runtime,
+    staticRoot: hasStaticAssets ? staticRoot : void 0
+  });
+  const { injectWebSocket, upgradeWebSocket } = (0, import_node_ws.createNodeWebSocket)({ app: void 0 });
+  const wsHandlers = createWsHandlers2();
+  app8.get(
+    "/ws",
+    upgradeWebSocket(() => wsHandlers)
+  );
+  const server = (0, import_node_server.serve)(
+    {
+      fetch: app8.fetch,
+      port: args.port
+    },
+    (info) => {
+      console.log(`[axl-studio] Server running at http://localhost:${info.port}`);
+      console.log(`[axl-studio] Workflows: ${runtime.getWorkflowNames().join(", ") || "(none)"}`);
+      console.log(
+        `[axl-studio] Agents: ${runtime.getAgents().map((a) => a._name).join(", ") || "(none)"}`
+      );
+      console.log(
+        `[axl-studio] Tools: ${runtime.getTools().map((t) => t.name).join(", ") || "(none)"}`
+      );
+      if (!hasStaticAssets) {
+        console.log(
+          `[axl-studio] No pre-built UI found. Run 'pnpm build:client' or use Vite dev server on port 4401.`
+        );
+      }
+    }
+  );
+  injectWebSocket(server);
+  if (args.open) {
+    const url = `http://localhost:${args.port}`;
+    const { exec } = await import("child_process");
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} ${url}`);
+  }
+  const shutdown = async () => {
+    console.log("\n[axl-studio] Shutting down...");
+    await runtime.shutdown().catch(() => {
+    });
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error("[axl-studio] Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map