@eidentic/studio 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work, excluding
+          those notices that do not pertain to any part of the Derivative
+          Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and do
+          not modify the License. You may add Your own attribution notices
+          within Derivative Works that You distribute, alongside or as an
+          addendum to the NOTICE text from the Work, provided that such
+          additional attribution notices cannot be construed as modifying
+          the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Baran Özdemir
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,47 @@
+# @eidentic/studio
+
+Local dev studio for Eidentic — inspect agent sessions, memory blocks, knowledge graph
+facts, skill banks, and workflow run history via a built-in web dashboard. Designed as a
+local development tool; not intended for production exposure without authentication.
+
+## Install
+
+```bash
+pnpm add @eidentic/studio
+```
+
+Or run it without installing via the CLI:
+
+```bash
+eidentic studio
+```
+
+## Usage
+
+```ts
+import { createStudio, serveNode } from "@eidentic/studio";
+
+const studio = createStudio({
+  agents: { support: myAgent },
+  // auth: ApiKeyAuth({ "dev-key": { userId: "dev" } }), // optional
+});
+
+await serveNode(studio, { port: 4000 });
+// Open http://localhost:4000 in your browser
+```
+
+The Studio dashboard provides:
+
+- **Sessions** — browse event streams for past and live sessions
+- **Memory** — view and edit memory blocks and knowledge graph facts per scope
+- **Skills** — list and approve skill bank entries
+- **Workflows** — inspect step traces and outcomes of workflow runs
+- **Costs** — per-session token usage and USD cost breakdown
+
+## Links
+
+- [GitHub](https://github.com/eidentic/eidentic)
+- [Issue tracker](https://github.com/eidentic/eidentic/issues)
+- [Root README](https://github.com/eidentic/eidentic#readme)
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,403 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiKeyAuth: () => import_server.ApiKeyAuth,
+  NoAuth: () => import_server.NoAuth,
+  createStudio: () => createStudio,
+  createStudioApi: () => createStudioApi,
+  serveNode: () => import_server.serveNode,
+  serveStudio: () => serveStudio
+});
+module.exports = __toCommonJS(index_exports);
+var import_hono = require("hono");
+var import_serve_static = require("@hono/node-server/serve-static");
+var import_node_url = require("node:url");
+var import_node_path = require("node:path");
+var import_workflow = require("@eidentic/workflow");
+var import_server = require("@eidentic/server");
+var import_model = require("@eidentic/model");
+var import_meta = {};
+async function runAuth(auth, req) {
+  const headers = {};
+  req.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  const url = new URL(req.url);
+  const authReq = {
+    method: req.method,
+    path: url.pathname,
+    headers
+  };
+  const principal = await auth.authenticate(authReq);
+  return principal !== null;
+}
+function hasGraph(store) {
+  return typeof store["queryFacts"] === "function";
+}
+function parseLimit(raw) {
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
+}
+function sessionUsage(events) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedInputTokens = 0;
+  let messages = 0;
+  for (const e of events) {
+    if (e.kind !== "assistant") continue;
+    messages++;
+    const usage = e.meta?.["usage"];
+    if (!usage) continue;
+    inputTokens += usage.inputTokens ?? 0;
+    outputTokens += usage.outputTokens ?? 0;
+    cachedInputTokens += usage.cachedInputTokens ?? 0;
+  }
+  return { inputTokens, outputTokens, cachedInputTokens, messages };
+}
+function usdForUsage(usage, prices, modelId) {
+  if (!modelId) return void 0;
+  const p = prices[modelId];
+  if (!p) return void 0;
+  const cachedToks = Math.min(usage.cachedInputTokens, usage.inputTokens);
+  const uncachedToks = usage.inputTokens - cachedToks;
+  const cacheRate = p.cachedInputPerMTok ?? p.inputPerMTok;
+  return (uncachedToks * p.inputPerMTok + cachedToks * cacheRate + usage.outputTokens * p.outputPerMTok) / 1e6;
+}
+function createStudioApi(opts) {
+  const auth = opts.auth ?? import_server.NoAuth;
+  const base = (opts.basePath ?? "/api").replace(/\/$/, "");
+  const app = new import_hono.Hono({ strict: false });
+  const wfRegistry = (0, import_workflow.createWorkflowRunRegistry)({ limit: 100 });
+  app.get(`${base}/health`, (c) => c.json({ ok: true }));
+  app.use(`${base}/*`, async (c, next) => {
+    if (c.req.path === `${base}/health`) {
+      return next();
+    }
+    const ok = await runAuth(auth, c.req.raw);
+    if (!ok) return c.json({ error: "Unauthorized" }, 401);
+    return next();
+  });
+  app.get(`${base}/agents`, (c) => {
+    const agents = Object.entries(opts.agents).map(([id, agent]) => {
+      const store = agent.store;
+      const hasMemory = typeof store["getBlocks"] === "function";
+      const hasSkills = opts.skillBanks?.[id] !== void 0 || agent.skillCatalog().length > 0;
+      const hasGraphFeature = hasGraph(store);
+      return {
+        id,
+        hasMemory,
+        hasSkills,
+        hasGraph: hasGraphFeature,
+        toolCount: agent.toolSchemas().length
+      };
+    });
+    return c.json(agents);
+  });
+  app.get(`${base}/agents/:id`, (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const store = agent.store;
+    const hasMemory = typeof store["getBlocks"] === "function";
+    const hasSkillsFlag = opts.skillBanks?.[id] !== void 0 || agent.skillCatalog().length > 0;
+    const hasGraphFeature = hasGraph(store);
+    return c.json({
+      id,
+      instructions: agent.instructions,
+      model: agent.modelId,
+      tools: agent.toolSchemas(),
+      hasMemory,
+      hasSkills: hasSkillsFlag,
+      hasGraph: hasGraphFeature
+    });
+  });
+  app.get(`${base}/agents/:id/sessions`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const limit = parseLimit(c.req.query("limit"));
+    const sessions = await agent.store.listSessions({ agentId: id, limit });
+    const priceTable = opts.prices ?? import_model.defaultPrices;
+    const modelId = agent.modelId;
+    const enriched = await Promise.all(
+      sessions.map(async (s) => {
+        try {
+          const events = await agent.store.readEvents(s.id);
+          const usage = sessionUsage(events);
+          const usd = usdForUsage(usage, priceTable, modelId);
+          return { ...s, usage, usd };
+        } catch {
+          return s;
+        }
+      })
+    );
+    return c.json(enriched);
+  });
+  app.get(`${base}/agents/:id/sessions/:sid/events`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const sid = c.req.param("sid");
+    const events = await agent.store.readEvents(sid);
+    return c.json({ events });
+  });
+  app.get(`${base}/agents/:id/cost`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const priceTable = opts.prices ?? import_model.defaultPrices;
+    const pricedFrom = opts.prices ? "configured" : "default";
+    const modelId = agent.modelId;
+    const sessions = await agent.store.listSessions({ agentId: id });
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCached = 0;
+    let totalMessages = 0;
+    let totalUsd = 0;
+    let hasUsd = false;
+    for (const s of sessions) {
+      try {
+        const events = await agent.store.readEvents(s.id);
+        const usage = sessionUsage(events);
+        totalInput += usage.inputTokens;
+        totalOutput += usage.outputTokens;
+        totalCached += usage.cachedInputTokens;
+        totalMessages += usage.messages;
+        const usd = usdForUsage(usage, priceTable, modelId);
+        if (usd !== void 0) {
+          totalUsd += usd;
+          hasUsd = true;
+        }
+      } catch {
+      }
+    }
+    return c.json({
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      cachedInputTokens: totalCached,
+      usd: hasUsd ? totalUsd : void 0,
+      messages: totalMessages,
+      sessions: sessions.length,
+      modelId: modelId ?? null,
+      pricedFrom,
+      pricesUpdatedAt: import_model.pricesUpdatedAt
+    });
+  });
+  app.get(`${base}/agents/:id/blocks`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const userId = c.req.query("userId");
+    const scope = userId ? { kind: "user", agentId: id, userId } : { kind: "agent", agentId: id };
+    const blocks = await agent.store.listBlocks(scope);
+    return c.json(blocks);
+  });
+  app.put(`${base}/agents/:id/blocks/:label`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const label = c.req.param("label");
+    const userId = c.req.query("userId");
+    const scope = userId ? { kind: "user", agentId: id, userId } : { kind: "agent", agentId: id };
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (typeof body !== "object" || body === null) {
+      return c.json({ error: "Body must be a JSON object" }, 400);
+    }
+    const { value, expectVersion } = body;
+    if (typeof value !== "string") {
+      return c.json({ error: "Missing or invalid 'value' field (string required)" }, 400);
+    }
+    if (expectVersion !== void 0 && typeof expectVersion !== "number") {
+      return c.json({ error: "'expectVersion' must be a number when provided" }, 400);
+    }
+    try {
+      const block = await agent.store.upsertBlock(
+        scope,
+        { label, value },
+        typeof expectVersion === "number" ? expectVersion : void 0
+      );
+      return c.json(block);
+    } catch (err) {
+      if (err instanceof Error && /conflict/i.test(err.message)) {
+        return c.json({ error: "conflict", message: err.message }, 409);
+      }
+      throw err;
+    }
+  });
+  app.get(`${base}/agents/:id/facts`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const userId = c.req.query("userId");
+    const subject = c.req.query("subject");
+    const scope = userId ? { kind: "user", agentId: id, userId } : { kind: "agent", agentId: id };
+    if (!hasGraph(agent.store)) {
+      return c.json([]);
+    }
+    const facts = await agent.store.queryFacts({ scope, ...subject ? { subject } : {} });
+    return c.json(facts);
+  });
+  app.get(`${base}/agents/:id/memories`, async (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const userId = c.req.query("userId");
+    const q = c.req.query("q") ?? "";
+    const scope = userId ? { kind: "user", agentId: id, userId } : { kind: "agent", agentId: id };
+    const snippets = await agent.store.searchMemory(scope, q, 20);
+    return c.json(snippets);
+  });
+  app.get(`${base}/agents/:id/skills`, (c) => {
+    const id = c.req.param("id");
+    const agent = opts.agents[id];
+    if (!agent) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const promptSkills = agent.skillCatalog().map((s) => ({
+      name: s.name,
+      description: s.description,
+      type: "prompt"
+    }));
+    const bank = opts.skillBanks?.[id];
+    const bankSkills = (bank ? bank.list() : []).map((rawLock) => {
+      const lock = rawLock;
+      return {
+        name: lock["name"] ?? lock["skillId"] ?? "?",
+        description: lock["description"] ?? "",
+        type: "executable",
+        quarantined: !!lock["quarantined"],
+        version: lock["version"],
+        author: lock["author"]
+      };
+    });
+    return c.json([...promptSkills, ...bankSkills]);
+  });
+  app.post(`${base}/agents/:id/skills/:skillId/approve`, (c) => {
+    const id = c.req.param("id");
+    if (!opts.agents[id]) return c.json({ error: `Unknown agent: ${id}` }, 404);
+    const bank = opts.skillBanks?.[id];
+    if (!bank) return c.json({ error: "No skill bank configured for this agent" }, 404);
+    const skillId = c.req.param("skillId");
+    const ok = bank.approve(skillId);
+    if (!ok) return c.json({ error: `Skill not found: ${skillId}` }, 404);
+    return c.json({ approved: true, name: skillId });
+  });
+  app.get(`${base}/workflows`, (c) => {
+    const runs = wfRegistry.list();
+    const summaries = runs.map((r) => ({
+      id: r.id,
+      name: r.name,
+      status: r.status,
+      startedAt: r.startedAt,
+      durationMs: r.durationMs,
+      stepCount: r.stepCount
+    }));
+    return c.json(summaries);
+  });
+  app.get(`${base}/workflows/:wid`, (c) => {
+    const wid = c.req.param("wid");
+    const run = wfRegistry.get(wid);
+    if (!run) return c.json({ error: `Unknown workflow run: ${wid}` }, 404);
+    return c.json(run);
+  });
+  app.post(`${base}/workflows`, async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (typeof body !== "object" || body === null) {
+      return c.json({ error: "Body must be a JSON object" }, 400);
+    }
+    const b = body;
+    const name = b["name"];
+    if (typeof name !== "string" || !name) {
+      return c.json({ error: "Missing or invalid 'name' field (non-empty string required)" }, 400);
+    }
+    const trace = b["trace"];
+    if (!Array.isArray(trace)) {
+      return c.json({ error: "Missing or invalid 'trace' field (array required)" }, 400);
+    }
+    const result = {
+      output: b["output"],
+      trace
+    };
+    const record = wfRegistry.record(name, result);
+    return c.json({ id: record.id, name: record.name, status: record.status }, 201);
+  });
+  const handle = app;
+  handle.recordWorkflow = function recordWorkflow(name, result) {
+    wfRegistry.record(name, result);
+  };
+  return handle;
+}
+function createStudio(opts) {
+  const run = (0, import_server.createServer)({
+    agents: opts.agents,
+    auth: opts.auth,
+    exposeEvents: true
+  });
+  const studioHandle = createStudioApi(opts);
+  const combined = new import_hono.Hono({ strict: false });
+  combined.route("/", run);
+  combined.route("/", studioHandle);
+  const handle = combined;
+  handle.recordWorkflow = studioHandle.recordWorkflow.bind(studioHandle);
+  return handle;
+}
+async function serveStudio(opts, { port = 3535 } = {}) {
+  let uiDist;
+  const metaUrl = import_meta.url;
+  if (metaUrl) {
+    const _dirname = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(metaUrl));
+    uiDist = (0, import_node_path.join)(_dirname, "..", "ui", "dist");
+  } else {
+    const cjsDirname = typeof __dirname !== "undefined" ? __dirname : process.cwd();
+    uiDist = (0, import_node_path.join)(cjsDirname, "..", "ui", "dist");
+  }
+  const handle = createStudio(opts);
+  handle.use(
+    "/*",
+    (0, import_serve_static.serveStatic)({
+      root: uiDist,
+      rewriteRequestPath: (path) => {
+        return path === "/" ? "/index.html" : path;
+      }
+    })
+  );
+  handle.get("/*", (0, import_serve_static.serveStatic)({ root: uiDist, path: "/index.html" }));
+  return (0, import_server.serveNode)(handle, { port });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKeyAuth,
+  NoAuth,
+  createStudio,
+  createStudioApi,
+  serveNode,
+  serveStudio
+});