@eidentic/studio 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,113 @@
+import * as _eidentic_server from '@eidentic/server';
+export { ApiKeyAuth, NoAuth, ServeNodeHandle, serveNode } from '@eidentic/server';
+import { Hono } from 'hono';
+import { Agent } from '@eidentic/core';
+import { AuthPort, PriceTable } from '@eidentic/types';
+import { WorkflowResult } from '@eidentic/workflow';
+
+/** A SkillBank-shaped interface: only what the studio needs. */
+interface SkillBankLike {
+    list(): unknown[];
+    approve(name: string): boolean;
+}
+/** Summary shape returned by GET /api/workflows (list). */
+interface WorkflowRunSummary {
+    id: string;
+    name: string;
+    status: "ok" | "error";
+    startedAt: number;
+    durationMs: number;
+    stepCount: number;
+}
+/**
+ * The Hono app returned by createStudioApi / createStudio, extended with
+ * workflow recording. It IS a Hono instance (all `app.request(...)` etc. work)
+ * and additionally exposes `recordWorkflow`.
+ */
+type StudioHandle = Hono & {
+    /**
+     * Record a completed workflow run into the in-memory registry.
+     *
+     * @param name   - Human-readable workflow name (e.g. "triage").
+     * @param result - The WorkflowResult returned by `workflow.run()`.
+     *
+     * @example
+     * const r = await wf.run(input);
+     * studio.recordWorkflow("triage", r);
+     */
+    recordWorkflow<O>(name: string, result: WorkflowResult<O>): void;
+};
+interface StudioOptions {
+    /** The agents to inspect/manage, keyed by their id. */
+    agents: Record<string, Agent>;
+    /**
+     * Optional skill banks, keyed by agentId. Each value must be a SkillBank
+     * (from @eidentic/skills) or any object with a `list()` and `approve()` method.
+     */
+    skillBanks?: Record<string, SkillBankLike>;
+    /**
+     * Authentication adapter. Defaults to NoAuth.
+     *
+     * IMPORTANT: The studio exposes agent memory read/write, session traces,
+     * and fact graph data. In production or any networked environment, always
+     * configure ApiKeyAuth (or a custom AuthPort) — never run with NoAuth
+     * on an internet-reachable address.
+     */
+    auth?: AuthPort;
+    /** Base path for the management API. Default "/api". */
+    basePath?: string;
+    /**
+     * USD price table used for cost estimation. Defaults to `defaultPrices` from
+     * @eidentic/model. Pass a custom table to override (e.g. for private deployments
+     * with negotiated pricing). Token counts are always exact; USD is an estimate.
+     */
+    prices?: PriceTable;
+}
+/**
+ * Build a Hono app exposing the Eidentic Studio management API.
+ *
+ * Routes (all JSON, auth-gated except health):
+ *   GET    /api/health
+ *   GET    /api/agents
+ *   GET    /api/agents/:id/sessions?limit=
+ *   GET    /api/agents/:id/sessions/:sid/events
+ *   GET    /api/agents/:id/blocks?userId=
+ *   PUT    /api/agents/:id/blocks/:label
+ *   GET    /api/agents/:id/facts?userId=&subject=
+ *   GET    /api/agents/:id/memories?userId=&q=
+ *   GET    /api/agents/:id/skills
+ *   POST   /api/agents/:id/skills/:skillId/approve
+ *   GET    /api/workflows
+ *   GET    /api/workflows/:id
+ *   POST   /api/workflows  (HTTP ingestion, auth-gated)
+ *
+ * Returns a StudioHandle with `app` (the Hono instance) and `recordWorkflow`.
+ */
+declare function createStudioApi(opts: StudioOptions): StudioHandle;
+/**
+ * Build a Hono app combining the agent query/resume/events run API (from
+ * `@eidentic/server`) with the Studio management API.
+ *
+ * Run routes:  POST /v1/agents/:id/query   (SSE)
+ *              POST /v1/agents/:id/resume  (SSE)
+ * Studio:      GET  /api/health
+ *              GET  /api/agents
+ *              ...all management routes
+ *
+ * Returns a StudioHandle (includes `recordWorkflow` and `app`).
+ */
+declare function createStudio(opts: StudioOptions): StudioHandle;
+interface StudioServeOptions extends StudioOptions {
+}
+/**
+ * Build the combined Hono app (static SPA + /api + /v1 routes) and serve it
+ * via @hono/node-server on the given port.
+ *
+ * The built React SPA (ui/dist) is resolved relative to this source file at
+ * runtime so it works whether installed from npm or used from the monorepo.
+ */
+declare function serveStudio(opts: StudioServeOptions, { port }?: {
+    port?: number;
+}): Promise<_eidentic_server.ServeNodeHandle>;
+
+export { type StudioHandle, type StudioOptions, type StudioServeOptions, type WorkflowRunSummary, createStudio, createStudioApi, serveStudio };

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+import * as _eidentic_server from '@eidentic/server';
+export { ApiKeyAuth, NoAuth, ServeNodeHandle, serveNode } from '@eidentic/server';
+import { Hono } from 'hono';
+import { Agent } from '@eidentic/core';
+import { AuthPort, PriceTable } from '@eidentic/types';
+import { WorkflowResult } from '@eidentic/workflow';
+
+/** A SkillBank-shaped interface: only what the studio needs. */
+interface SkillBankLike {
+    list(): unknown[];
+    approve(name: string): boolean;
+}
+/** Summary shape returned by GET /api/workflows (list). */
+interface WorkflowRunSummary {
+    id: string;
+    name: string;
+    status: "ok" | "error";
+    startedAt: number;
+    durationMs: number;
+    stepCount: number;
+}
+/**
+ * The Hono app returned by createStudioApi / createStudio, extended with
+ * workflow recording. It IS a Hono instance (all `app.request(...)` etc. work)
+ * and additionally exposes `recordWorkflow`.
+ */
+type StudioHandle = Hono & {
+    /**
+     * Record a completed workflow run into the in-memory registry.
+     *
+     * @param name   - Human-readable workflow name (e.g. "triage").
+     * @param result - The WorkflowResult returned by `workflow.run()`.
+     *
+     * @example
+     * const r = await wf.run(input);
+     * studio.recordWorkflow("triage", r);
+     */
+    recordWorkflow<O>(name: string, result: WorkflowResult<O>): void;
+};
+interface StudioOptions {
+    /** The agents to inspect/manage, keyed by their id. */
+    agents: Record<string, Agent>;
+    /**
+     * Optional skill banks, keyed by agentId. Each value must be a SkillBank
+     * (from @eidentic/skills) or any object with a `list()` and `approve()` method.
+     */
+    skillBanks?: Record<string, SkillBankLike>;
+    /**
+     * Authentication adapter. Defaults to NoAuth.
+     *
+     * IMPORTANT: The studio exposes agent memory read/write, session traces,
+     * and fact graph data. In production or any networked environment, always
+     * configure ApiKeyAuth (or a custom AuthPort) — never run with NoAuth
+     * on an internet-reachable address.
+     */
+    auth?: AuthPort;
+    /** Base path for the management API. Default "/api". */
+    basePath?: string;
+    /**
+     * USD price table used for cost estimation. Defaults to `defaultPrices` from
+     * @eidentic/model. Pass a custom table to override (e.g. for private deployments
+     * with negotiated pricing). Token counts are always exact; USD is an estimate.
+     */
+    prices?: PriceTable;
+}
+/**
+ * Build a Hono app exposing the Eidentic Studio management API.
+ *
+ * Routes (all JSON, auth-gated except health):
+ *   GET    /api/health
+ *   GET    /api/agents
+ *   GET    /api/agents/:id/sessions?limit=
+ *   GET    /api/agents/:id/sessions/:sid/events
+ *   GET    /api/agents/:id/blocks?userId=
+ *   PUT    /api/agents/:id/blocks/:label
+ *   GET    /api/agents/:id/facts?userId=&subject=
+ *   GET    /api/agents/:id/memories?userId=&q=
+ *   GET    /api/agents/:id/skills
+ *   POST   /api/agents/:id/skills/:skillId/approve
+ *   GET    /api/workflows
+ *   GET    /api/workflows/:id
+ *   POST   /api/workflows  (HTTP ingestion, auth-gated)
+ *
+ * Returns a StudioHandle with `app` (the Hono instance) and `recordWorkflow`.
+ */
+declare function createStudioApi(opts: StudioOptions): StudioHandle;
+/**
+ * Build a Hono app combining the agent query/resume/events run API (from
+ * `@eidentic/server`) with the Studio management API.
+ *
+ * Run routes:  POST /v1/agents/:id/query   (SSE)
+ *              POST /v1/agents/:id/resume  (SSE)
+ * Studio:      GET  /api/health
+ *              GET  /api/agents
+ *              ...all management routes
+ *
+ * Returns a StudioHandle (includes `recordWorkflow` and `app`).
+ */
+declare function createStudio(opts: StudioOptions): StudioHandle;
+interface StudioServeOptions extends StudioOptions {
+}
+/**
+ * Build the combined Hono app (static SPA + /api + /v1 routes) and serve it
+ * via @hono/node-server on the given port.
+ *
+ * The built React SPA (ui/dist) is resolved relative to this source file at
+ * runtime so it works whether installed from npm or used from the monorepo.
+ */
+declare function serveStudio(opts: StudioServeOptions, { port }?: {
+    port?: number;
+}): Promise<_eidentic_server.ServeNodeHandle>;
+
+export { type StudioHandle, type StudioOptions, type StudioServeOptions, type WorkflowRunSummary, createStudio, createStudioApi, serveStudio };

package/dist/index.js

@@ -0,0 +1,372 @@
+// src/index.ts
+import { Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { createWorkflowRunRegistry } from "@eidentic/workflow";
+import { createServer, NoAuth, ApiKeyAuth, serveNode } from "@eidentic/server";
+import { defaultPrices, pricesUpdatedAt } from "@eidentic/model";
+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 ?? NoAuth;
+  const base = (opts.basePath ?? "/api").replace(/\/$/, "");
+  const app = new Hono({ strict: false });
+  const wfRegistry = 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 ?? 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 ?? 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
+    });
+  });
+  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 = createServer({
+    agents: opts.agents,
+    auth: opts.auth,
+    exposeEvents: true
+  });
+  const studioHandle = createStudioApi(opts);
+  const combined = new 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 = dirname(fileURLToPath(metaUrl));
+    uiDist = join(_dirname, "..", "ui", "dist");
+  } else {
+    const cjsDirname = typeof __dirname !== "undefined" ? __dirname : process.cwd();
+    uiDist = join(cjsDirname, "..", "ui", "dist");
+  }
+  const handle = createStudio(opts);
+  handle.use(
+    "/*",
+    serveStatic({
+      root: uiDist,
+      rewriteRequestPath: (path) => {
+        return path === "/" ? "/index.html" : path;
+      }
+    })
+  );
+  handle.get("/*", serveStatic({ root: uiDist, path: "/index.html" }));
+  return serveNode(handle, { port });
+}
+export {
+  ApiKeyAuth,
+  NoAuth,
+  createStudio,
+  createStudioApi,
+  serveNode,
+  serveStudio
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@eidentic/studio",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eidentic/eidentic.git",
+    "directory": "packages/studio"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "ui/dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@hono/node-server": "^2.0.0",
+    "hono": "^4.12.0",
+    "@eidentic/core": "0.1.0",
+    "@eidentic/model": "0.1.0",
+    "@eidentic/types": "0.1.0",
+    "@eidentic/server": "0.1.0",
+    "@eidentic/workflow": "0.1.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.5.2",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "vite": "^6.3.5"
+  },
+  "description": "Local dev studio for Eidentic — inspect agent sessions, memory, skills, and workflow runs via a web dashboard.",
+  "keywords": [
+    "ai",
+    "agents",
+    "typescript",
+    "eidentic",
+    "studio",
+    "dashboard",
+    "devtools",
+    "debug"
+  ],
+  "homepage": "https://github.com/eidentic/eidentic#readme",
+  "bugs": {
+    "url": "https://github.com/eidentic/eidentic/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "cd ui && vite build && cd .. && tsup src/index.ts --format esm,cjs --dts --clean",
+    "build:ts": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit"
+  }
+}