@axlsdk/studio 0.13.8 → 0.15.0

package/dist/chunk-YWRYXT7U.js

@@ -1,1021 +0,0 @@
-// src/server/index.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
-import { Hono as Hono12 } from "hono";
-import { cors } from "hono/cors";
-import { serveStatic } from "@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
-function isBufferedChannel(channel) {
-  return channel.startsWith("execution:");
-}
-var BUFFER_TTL_MS = 3e4;
-var MAX_BUFFER_EVENTS = 500;
-var ConnectionManager = class {
-  /** channel -> set of WS connections */
-  channels = /* @__PURE__ */ new Map();
-  /** ws -> set of subscribed channels (for cleanup) */
-  connections = /* @__PURE__ */ new Map();
-  /** channel -> replay buffer for execution streams */
-  buffers = /* @__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. 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).add(channel);
-    const buffer = this.buffers.get(channel);
-    if (buffer) {
-      for (const msg of buffer.events) {
-        try {
-          ws.send(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)?.delete(channel);
-  }
-  /** Broadcast data to all subscribers of a channel. Buffers events for execution channels. */
-  broadcast(channel, data) {
-    const msg = JSON.stringify({ type: "event", channel, data });
-    if (isBufferedChannel(channel)) {
-      let buffer = this.buffers.get(channel);
-      if (!buffer) {
-        buffer = { events: [], complete: false };
-        this.buffers.set(channel, buffer);
-      }
-      const event = data;
-      const isTerminal = event.type === "done" || event.type === "error";
-      if (buffer.events.length < MAX_BUFFER_EVENTS || isTerminal) {
-        buffer.events.push(msg);
-      }
-      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]) {
-      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, 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:"];
-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 == null && !event.tokens) return;
-    const cost = Number.isFinite(event.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
-import { Hono } from "hono";
-var app = new 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
-import { Hono as Hono2 } from "hono";
-import { zodToJsonSchema } from "@axlsdk/axl";
-function createWorkflowRoutes(connMgr) {
-  const app7 = new Hono2();
-  app7.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 });
-  });
-  app7.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
-      }
-    });
-  });
-  app7.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 () => {
-        for await (const event of stream) {
-          connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
-        }
-      })();
-      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 app7;
-}
-
-// src/server/routes/executions.ts
-import { Hono as Hono3 } from "hono";
-var app2 = new Hono3();
-app2.get("/executions", async (c) => {
-  const runtime = c.get("runtime");
-  const executions = await 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
-import { Hono as Hono4 } from "hono";
-function createSessionRoutes(connMgr) {
-  const app7 = new Hono4();
-  app7.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 });
-  });
-  app7.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 ?? [] } });
-  });
-  app7.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 } });
-  });
-  app7.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 } });
-  });
-  app7.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 app7;
-}
-
-// src/server/routes/agents.ts
-import { Hono as Hono5 } from "hono";
-import { zodToJsonSchema as zodToJsonSchema2 } from "@axlsdk/axl";
-var app3 = new Hono5();
-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: 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 = app3;
-
-// src/server/routes/tools.ts
-import { Hono as Hono6 } from "hono";
-import { zodToJsonSchema as zodToJsonSchema3 } from "@axlsdk/axl";
-var app4 = new Hono6();
-app4.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 });
-});
-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 ? 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
-    }
-  });
-});
-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
-import { Hono as Hono7 } from "hono";
-var app5 = new Hono7();
-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
-import { Hono as Hono8 } from "hono";
-var app6 = new Hono8();
-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
-import { Hono as Hono9 } from "hono";
-function createCostRoutes(costAggregator) {
-  const app7 = new Hono9();
-  app7.get("/costs", (c) => {
-    return c.json({ ok: true, data: costAggregator.getData() });
-  });
-  app7.post("/costs/reset", (c) => {
-    costAggregator.reset();
-    return c.json({ ok: true, data: { reset: true } });
-  });
-  return app7;
-}
-
-// src/server/routes/evals.ts
-import { Hono as Hono10 } from "hono";
-function createEvalRoutes(evalLoader) {
-  const app7 = new Hono10();
-  app7.get("/evals", async (c) => {
-    if (evalLoader) await evalLoader();
-    const runtime = c.get("runtime");
-    const evals = runtime.getRegisteredEvals();
-    return c.json({ ok: true, data: evals });
-  });
-  app7.get("/evals/history", async (c) => {
-    const runtime = c.get("runtime");
-    const history = await runtime.getEvalHistory();
-    return c.json({ ok: true, data: history });
-  });
-  app7.post("/evals/:name/run", async (c) => {
-    if (evalLoader) await evalLoader();
-    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
-      );
-    }
-    let runs = 1;
-    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);
-      }
-    } catch {
-    }
-    try {
-      if (runs > 1) {
-        const { randomUUID } = await import("crypto");
-        const { aggregateRuns } = await import("@axlsdk/eval");
-        const runGroupId = randomUUID();
-        const results = [];
-        for (let r = 0; r < runs; r++) {
-          const result2 = await runtime.runRegisteredEval(name, {
-            metadata: { runGroupId, runIndex: r }
-          });
-          results.push(result2);
-        }
-        const typedResults = results;
-        const aggregate = aggregateRuns(typedResults);
-        const first = typedResults[0];
-        const result = { ...first, _multiRun: { aggregate, allRuns: typedResults } };
-        return c.json({ ok: true, data: result });
-      } else {
-        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/:name/rescore", async (c) => {
-    if (evalLoader) await evalLoader();
-    const runtime = c.get("runtime");
-    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: 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, body.options);
-      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);
-    }
-  });
-  return app7;
-}
-
-// src/server/routes/playground.ts
-import { Hono as Hono11 } from "hono";
-function createPlaygroundRoutes(connMgr) {
-  const app7 = new Hono11();
-  app7.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 executionId = `playground-${sessionId}-${Date.now()}`;
-    const store = runtime.getStateStore();
-    const history = await store.getSession(sessionId);
-    history.push({ role: "user", content: body.message });
-    const ctx = runtime.createContext({
-      sessionHistory: history,
-      onToken: (token) => {
-        connMgr.broadcastWithWildcard(`execution:${executionId}`, {
-          type: "token",
-          data: token
-        });
-      }
-    });
-    (async () => {
-      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);
-        connMgr.broadcastWithWildcard(`execution:${executionId}`, {
-          type: "done",
-          data: resultText
-        });
-      } catch (err) {
-        connMgr.broadcastWithWildcard(`execution:${executionId}`, {
-          type: "error",
-          message: err instanceof Error ? err.message : String(err)
-        });
-      }
-    })();
-    return c.json({
-      ok: true,
-      data: { sessionId, executionId, streaming: true }
-    });
-  });
-  return app7;
-}
-
-// src/server/index.ts
-function createServer(options) {
-  const { runtime, staticRoot, basePath = "", readOnly = false } = options;
-  const app7 = new Hono12();
-  const connMgr = new ConnectionManager();
-  const costAggregator = new CostAggregator(connMgr);
-  if (options.cors !== false) {
-    app7.use("*", cors());
-  }
-  app7.use("*", errorHandler);
-  app7.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"
-    ];
-    app7.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 Hono12();
-  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("/", createEvalRoutes(options.evalLoader));
-  api.route("/", createPlaygroundRoutes(connMgr));
-  app7.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) {
-    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
-    });
-    app7.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) {
-      app7.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: app7,
-    connMgr,
-    costAggregator,
-    /** Create WS handlers. Call before registering static/SPA routes are reached. */
-    createWsHandlers: () => createWsHandlers(connMgr),
-    traceListener
-  };
-}
-
-export {
-  ConnectionManager,
-  handleWsMessage,
-  CostAggregator,
-  createServer
-};
-//# sourceMappingURL=chunk-YWRYXT7U.js.map