@anvia/studio 0.1.0

package/dist/index.js

@@ -0,0 +1,2657 @@
+// src/runtime/studio.ts
+import {
+  Agent,
+  createHook as createHook3
+} from "@anvia/core";
+import { serve } from "@hono/node-server";
+import { Hono as HonoApp } from "hono";
+
+// src/traces/trace-observer.ts
+var StudioTraceObserver = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  startRun(args) {
+    const traceId = args.trace?.traceId ?? globalThis.crypto.randomUUID().replaceAll("-", "");
+    const observationId = globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, 16);
+    return new StudioRunTraceObserver({
+      id: traceId,
+      observationId,
+      args,
+      store: this.store()
+    });
+  }
+  store() {
+    return typeof this.options.store === "function" ? this.options.store() : this.options.store;
+  }
+};
+var StudioRunTraceObserver = class {
+  constructor(props) {
+    this.props = props;
+    this.trace = { traceId: props.id, observationId: props.observationId };
+  }
+  props;
+  trace;
+  startedAt = /* @__PURE__ */ new Date();
+  observations = [];
+  startGeneration(args) {
+    const startedAt = /* @__PURE__ */ new Date();
+    return {
+      end: (endArgs) => {
+        this.observations.push(
+          traceObservation({
+            kind: "generation",
+            name: `model.turn.${args.turn}`,
+            status: "success",
+            turn: args.turn,
+            startedAt,
+            input: toJsonValue(args.request),
+            output: toJsonValue(endArgs.response),
+            metadata: {
+              model: args.request.model ?? "default",
+              toolCount: args.request.tools.length,
+              ...endArgs.firstDeltaMs === void 0 ? {} : { firstDeltaMs: endArgs.firstDeltaMs }
+            }
+          })
+        );
+      },
+      error: (errorArgs) => {
+        this.observations.push(
+          traceObservation({
+            kind: "generation",
+            name: `model.turn.${args.turn}`,
+            status: "error",
+            turn: args.turn,
+            startedAt,
+            input: toJsonValue(args.request),
+            error: serializeError(errorArgs.error),
+            metadata: {
+              model: args.request.model ?? "default",
+              toolCount: args.request.tools.length
+            }
+          })
+        );
+      }
+    };
+  }
+  startTool(args) {
+    const startedAt = /* @__PURE__ */ new Date();
+    return {
+      end: (endArgs) => {
+        this.observations.push(
+          traceObservation({
+            kind: "tool",
+            name: args.toolName,
+            status: "success",
+            turn: args.turn,
+            startedAt,
+            input: parseOrString(args.args),
+            output: parseOrString(endArgs.result),
+            metadata: toolMetadata(args, endArgs.skipped)
+          })
+        );
+      },
+      error: (errorArgs) => {
+        this.observations.push(
+          traceObservation({
+            kind: "tool",
+            name: args.toolName,
+            status: "error",
+            turn: args.turn,
+            startedAt,
+            input: parseOrString(args.args),
+            error: serializeError(errorArgs.error),
+            metadata: toolMetadata(args, false)
+          })
+        );
+      }
+    };
+  }
+  async end(args) {
+    await this.save("success", {
+      endedAt: /* @__PURE__ */ new Date(),
+      output: args.output,
+      usage: args.usage,
+      messages: toJsonValue(args.messages)
+    });
+  }
+  async error(args) {
+    await this.save("error", {
+      endedAt: /* @__PURE__ */ new Date(),
+      error: serializeError(args.error),
+      usage: args.usage,
+      messages: toJsonValue(args.messages)
+    });
+  }
+  async save(status, result) {
+    const sessionId = this.props.args.trace?.sessionId;
+    const store = this.props.store;
+    if (sessionId === void 0 || store === void 0) {
+      return;
+    }
+    const metadata = traceMetadata(this.props.args, result.messages);
+    const trace = {
+      id: this.props.id,
+      sessionId,
+      ...this.props.args.trace?.name === void 0 ? {} : { name: this.props.args.trace.name },
+      status,
+      trace: this.trace,
+      startedAt: this.startedAt.toISOString(),
+      endedAt: result.endedAt.toISOString(),
+      durationMs: durationMs(this.startedAt, result.endedAt),
+      input: toJsonValue({
+        instructions: this.props.args.instructions,
+        prompt: this.props.args.prompt,
+        history: this.props.args.history
+      }),
+      ...result.output === void 0 ? {} : { output: result.output },
+      ...result.error === void 0 ? {} : { error: result.error },
+      ...result.usage === void 0 ? {} : { usage: result.usage },
+      metadata,
+      observations: this.observations,
+      observationCount: this.observations.length
+    };
+    await store.saveTrace(trace);
+  }
+};
+function traceObservation(props) {
+  const endedAt = /* @__PURE__ */ new Date();
+  return {
+    id: globalThis.crypto.randomUUID(),
+    kind: props.kind,
+    name: props.name,
+    status: props.status,
+    turn: props.turn,
+    startedAt: props.startedAt.toISOString(),
+    endedAt: endedAt.toISOString(),
+    durationMs: durationMs(props.startedAt, endedAt),
+    ...props.input === void 0 ? {} : { input: props.input },
+    ...props.output === void 0 ? {} : { output: props.output },
+    ...props.error === void 0 ? {} : { error: props.error },
+    ...props.metadata === void 0 ? {} : { metadata: props.metadata }
+  };
+}
+function traceMetadata(args, messages) {
+  return compactJsonObject({
+    agentName: args.agentName,
+    agentDescription: args.agentDescription,
+    maxTurns: args.maxTurns,
+    userId: args.trace?.userId,
+    tags: args.trace?.tags,
+    version: args.trace?.version,
+    metadata: toJsonValue(args.trace?.metadata ?? {}),
+    messages
+  });
+}
+function toolMetadata(args, skipped) {
+  return compactJsonObject({
+    internalCallId: args.internalCallId,
+    toolCallId: args.toolCallId,
+    skipped
+  });
+}
+function compactJsonObject(values) {
+  const entries = Object.entries(values).flatMap(
+    ([key, value]) => value === void 0 ? [] : [[key, toJsonValue(value)]]
+  );
+  return Object.fromEntries(entries);
+}
+function durationMs(startedAt, endedAt) {
+  return Math.max(0, endedAt.getTime() - startedAt.getTime());
+}
+function parseOrString(value) {
+  try {
+    return toJsonValue(JSON.parse(value));
+  } catch {
+    return value;
+  }
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return compactJsonObject({
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    });
+  }
+  return toJsonValue(error);
+}
+function toJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value === void 0) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toJsonValue(item));
+  }
+  if (typeof value === "object") {
+    return compactJsonObject(value);
+  }
+  return String(value);
+}
+
+// src/ui/routes.tsx
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+function resolveStudioUiOptions(ui) {
+  const options = typeof ui === "object" ? ui : {};
+  return {
+    path: normalizeUiPath(options.path ?? "/ui"),
+    title: options.title ?? "Anvia Studio",
+    rootRoutes: options.rootRoutes ?? true,
+    redirectRoot: options.redirectRoot ?? true,
+    ...options.clientScript === void 0 ? {} : { clientScript: options.clientScript },
+    protectShell: options.protectShell ?? false
+  };
+}
+function isStudioUiEnabled(ui) {
+  return ui !== false;
+}
+function registerStudioUi(app, options) {
+  const scriptPath = `${options.path}/assets/client.js`;
+  const stylePath = `${options.path}/assets/styles.css`;
+  const renderShell = () => renderStudioUi({
+    options,
+    routePath: options.path,
+    clientScript: scriptPath,
+    stylesheet: stylePath
+  });
+  const renderRootShell = () => renderStudioUi({
+    options,
+    routePath: "",
+    clientScript: scriptPath,
+    stylesheet: stylePath
+  });
+  if (options.redirectRoot) {
+    app.get("/", (c) => c.redirect(studioUiEntryPath(options)));
+  }
+  app.get(options.path, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/:sessionId`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/playground`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/playground/:sessionId`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/tracing`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/tracing/:traceId`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/tracing/sessions/:sessionId`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/tracing/*`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/sessions`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/agents`, async (c) => c.html(await renderShell()));
+  app.get(`${options.path}/knowledge`, async (c) => c.html(await renderShell()));
+  if (options.rootRoutes) {
+    app.get("/playground", async (c) => c.html(await renderRootShell()));
+    app.get("/playground/:sessionId", async (c) => c.html(await renderRootShell()));
+    app.get("/tracing", async (c) => c.html(await renderRootShell()));
+    app.get("/tracing/:traceId", async (c) => c.html(await renderRootShell()));
+    app.get("/tracing/sessions/:sessionId", async (c) => c.html(await renderRootShell()));
+    app.get("/tracing/*", async (c) => c.html(await renderRootShell()));
+  }
+  app.get(scriptPath, async () => {
+    if (options.clientScript === void 0) {
+      return new Response(null, { status: 404 });
+    }
+    return new Response(options.clientScript, {
+      headers: {
+        "content-type": "text/javascript; charset=utf-8",
+        "cache-control": "no-cache"
+      }
+    });
+  });
+  app.get(stylePath, async () => {
+    const source = await readBundledLegacyStylesheet();
+    return new Response(source, {
+      headers: {
+        "content-type": "text/css; charset=utf-8",
+        "cache-control": "no-cache"
+      }
+    });
+  });
+  app.get(`${options.path}/assets/:asset`, async (c) => {
+    const asset = c.req.param("asset");
+    if (asset.includes("/") || asset.includes("..")) {
+      return new Response(null, { status: 404 });
+    }
+    const source = await readBundledUiAsset(asset);
+    if (source === void 0) {
+      return new Response(null, { status: 404 });
+    }
+    const body = new ArrayBuffer(source.byteLength);
+    new Uint8Array(body).set(source);
+    return new Response(body, {
+      headers: {
+        "content-type": contentTypeForAsset(asset),
+        "cache-control": "no-cache"
+      }
+    });
+  });
+}
+async function renderStudioUi(props) {
+  const { options } = props;
+  if (options.clientScript !== void 0) {
+    return renderLegacyStudioUiShell({
+      title: options.title,
+      uiPath: props.routePath,
+      compatUiPath: options.path,
+      clientScript: props.clientScript,
+      stylesheet: props.stylesheet
+    });
+  }
+  const index = await readBundledUiIndex();
+  return index.replace(/<title>.*?<\/title>/, `<title>${escapeHtml(options.title)}</title>`).replace(
+    'data-ui-path="/ui"',
+    `data-ui-path="${escapeHtml(props.routePath)}" data-ui-compat-path="${escapeHtml(options.path)}"`
+  ).replaceAll('"/ui/', `"${escapeHtml(options.path)}/`);
+}
+function renderLegacyStudioUiShell(props) {
+  const title = escapeHtml(props.title);
+  return [
+    "<!doctype html>",
+    '<html lang="en" class="dark">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${title}</title>`,
+    '<script>(()=>{try{if((localStorage.getItem("anvia-studio-theme")??localStorage.getItem("aion-studio-theme"))==="light"){document.documentElement.classList.remove("dark")}}catch{}})();</script>',
+    `<link rel="icon" type="image/png" href="${escapeHtml(props.compatUiPath)}/assets/logo.png">`,
+    `<link rel="stylesheet" href="${escapeHtml(props.stylesheet)}">`,
+    "</head>",
+    "<body>",
+    `<div id="anvia-ui" data-ui-path="${escapeHtml(props.uiPath)}" data-ui-compat-path="${escapeHtml(props.compatUiPath)}">`,
+    '<main class="shell-loading">',
+    "<div>",
+    `<img src="${escapeHtml(props.compatUiPath)}/assets/logo.png" alt="" width="32" height="32">`,
+    '<p class="eyebrow">Anvia</p>',
+    `<h1>${title}</h1>`,
+    "</div>",
+    "</main>",
+    "</div>",
+    `<script type="module" src="${escapeHtml(props.clientScript)}"></script>`,
+    "</body>",
+    "</html>"
+  ].join("");
+}
+function normalizeUiPath(path) {
+  const trimmed = path.trim();
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const withoutTrailingSlash = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  if (withoutTrailingSlash.length === 0 || withoutTrailingSlash === "/") {
+    return "/ui";
+  }
+  return withoutTrailingSlash;
+}
+function studioUiEntryPath(options) {
+  return options.rootRoutes ? "/playground" : options.path;
+}
+async function readBundledUiIndex() {
+  try {
+    return await readFile(fileURLToPath(new URL("./ui/index.html", import.meta.url)), "utf8");
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
+  }
+  try {
+    return await readFile(
+      fileURLToPath(new URL("../../dist/ui/index.html", import.meta.url)),
+      "utf8"
+    );
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
+    return readFile(fileURLToPath(new URL("./app/index.html", import.meta.url)), "utf8");
+  }
+}
+async function readBundledUiAsset(asset) {
+  try {
+    return await readFile(fileURLToPath(new URL(`./assets/${asset}`, import.meta.url)));
+  } catch (sourceError) {
+    if (!isNotFoundError(sourceError)) {
+      throw sourceError;
+    }
+  }
+  try {
+    return await readFile(fileURLToPath(new URL(`./ui/assets/${asset}`, import.meta.url)));
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
+    try {
+      return await readFile(
+        fileURLToPath(new URL(`../../dist/ui/assets/${asset}`, import.meta.url))
+      );
+    } catch (fallbackError) {
+      if (!isNotFoundError(fallbackError)) {
+        throw fallbackError;
+      }
+      return void 0;
+    }
+  }
+}
+async function readBundledLegacyStylesheet() {
+  try {
+    return await readFile(fileURLToPath(new URL("./ui/styles.css", import.meta.url)), "utf8");
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
+    try {
+      return await readFile(
+        fileURLToPath(new URL("../../dist/ui/styles.css", import.meta.url)),
+        "utf8"
+      );
+    } catch (fallbackError) {
+      if (!isNotFoundError(fallbackError)) {
+        throw fallbackError;
+      }
+      return "";
+    }
+  }
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function contentTypeForAsset(asset) {
+  if (asset.endsWith(".js")) {
+    return "text/javascript; charset=utf-8";
+  }
+  if (asset.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (asset.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (asset.endsWith(".png")) {
+    return "image/png";
+  }
+  if (asset.endsWith(".woff2")) {
+    return "font/woff2";
+  }
+  return "application/octet-stream";
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// src/runtime/approvals.ts
+import { createHook, parseToolArgs } from "@anvia/core";
+
+// src/runtime/shared.ts
+import { join } from "path";
+
+// src/storage/sqlite-store.ts
+import { mkdirSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve } from "path";
+var { DatabaseSync } = createRequire(import.meta.url)(
+  "node:sqlite"
+);
+function createSqliteSessionStore(options = {}) {
+  return new SqliteSessionStore(options.path ?? ":memory:");
+}
+var SqliteSessionStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  kind = "sqlite";
+  db;
+  listSessions(options) {
+    const db = this.database();
+    const agentClause = options.agentId === void 0 ? "" : "WHERE agent_id = $agentId";
+    const rows = db.prepare(
+      `SELECT id, agent_id, title, metadata_json, messages_json, transcript_json, created_at, updated_at
+         FROM runner_sessions
+         ${agentClause}
+         ORDER BY updated_at DESC
+         LIMIT $limit`
+    ).all({
+      $agentId: options.agentId ?? null,
+      $limit: options.limit
+    });
+    return rows.map(toSessionSummary);
+  }
+  createSession(input) {
+    const db = this.database();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    db.prepare(
+      `INSERT INTO runner_sessions (
+        id,
+        agent_id,
+        title,
+        metadata_json,
+        messages_json,
+        transcript_json,
+        created_at,
+        updated_at
+      ) VALUES ($id, $agentId, $title, $metadata, '[]', '[]', $now, $now)`
+    ).run({
+      $id: input.id,
+      $agentId: input.agentId,
+      $title: input.title ?? null,
+      $metadata: input.metadata === void 0 ? null : JSON.stringify(input.metadata),
+      $now: now
+    });
+    return {
+      id: input.id,
+      agentId: input.agentId,
+      ...input.title === void 0 ? {} : { title: input.title },
+      createdAt: now,
+      updatedAt: now,
+      messageCount: 0,
+      ...input.metadata === void 0 ? {} : { metadata: input.metadata }
+    };
+  }
+  getSession(id) {
+    const db = this.database();
+    const row = db.prepare(
+      `SELECT id, agent_id, title, metadata_json, messages_json, transcript_json, created_at, updated_at
+         FROM runner_sessions
+         WHERE id = $id`
+    ).get({ $id: id });
+    return row === void 0 ? void 0 : toSession(row);
+  }
+  appendSessionRun(input) {
+    const db = this.database();
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      const row = db.prepare(
+        `SELECT id, agent_id, title, metadata_json, messages_json, transcript_json, created_at, updated_at
+           FROM runner_sessions
+           WHERE id = $id`
+      ).get({ $id: input.id });
+      if (row === void 0) {
+        db.exec("ROLLBACK");
+        return void 0;
+      }
+      const current = toSession(row);
+      const messages = [...current.messages, ...input.messages];
+      const transcript = renumberTranscript([...current.transcript, ...input.transcript]);
+      const title = current.title ?? input.title;
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      db.prepare(
+        `UPDATE runner_sessions
+         SET title = $title,
+             messages_json = $messages,
+             transcript_json = $transcript,
+             updated_at = $updatedAt
+         WHERE id = $id`
+      ).run({
+        $id: input.id,
+        $title: title ?? null,
+        $messages: JSON.stringify(messages),
+        $transcript: JSON.stringify(transcript),
+        $updatedAt: updatedAt
+      });
+      db.exec("COMMIT");
+      return {
+        ...current,
+        ...title === void 0 ? {} : { title },
+        updatedAt,
+        messageCount: messages.length,
+        messages,
+        transcript
+      };
+    } catch (error) {
+      if (db.isTransaction) {
+        db.exec("ROLLBACK");
+      }
+      throw error;
+    }
+  }
+  deleteSession(id) {
+    const db = this.database();
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      db.prepare("DELETE FROM runner_traces WHERE session_id = $id").run({ $id: id });
+      const result = db.prepare("DELETE FROM runner_sessions WHERE id = $id").run({ $id: id });
+      db.exec("COMMIT");
+      return Number(result.changes) > 0;
+    } catch (error) {
+      if (db.isTransaction) {
+        db.exec("ROLLBACK");
+      }
+      throw error;
+    }
+  }
+  listTraces(options) {
+    const db = this.database();
+    const filters = [];
+    const values = {
+      $limit: options.limit
+    };
+    if (options.agentId !== void 0) {
+      filters.push(
+        "(s.agent_id = $agentId OR json_extract(t.metadata_json, '$.metadata.agentId') = $agentId)"
+      );
+      values.$agentId = options.agentId;
+    }
+    if (options.sessionId !== void 0) {
+      filters.push("t.session_id = $sessionId");
+      values.$sessionId = options.sessionId;
+    }
+    if (options.status !== void 0) {
+      filters.push("t.status = $status");
+      values.$status = options.status;
+    }
+    const whereClause = filters.length === 0 ? "" : `WHERE ${filters.join(" AND ")}`;
+    const rows = db.prepare(
+      `SELECT t.id, t.session_id, t.name, t.status, t.trace_json, t.input_json, t.output,
+                t.error_json, t.usage_json, t.metadata_json, t.observations_json,
+                t.started_at, t.ended_at, t.duration_ms
+         FROM runner_traces t
+         LEFT JOIN runner_sessions s ON s.id = t.session_id
+         ${whereClause}
+         ORDER BY t.started_at DESC
+         LIMIT $limit`
+    ).all(values);
+    return rows.map(toTraceSummary);
+  }
+  listSessionTraces(options) {
+    const db = this.database();
+    const rows = db.prepare(
+      `SELECT id, session_id, name, status, trace_json, input_json, output, error_json,
+                usage_json, metadata_json, observations_json, started_at, ended_at, duration_ms
+         FROM runner_traces
+         WHERE session_id = $sessionId
+         ORDER BY started_at DESC
+         LIMIT $limit`
+    ).all({
+      $sessionId: options.sessionId,
+      $limit: options.limit
+    });
+    return rows.map(toTraceSummary);
+  }
+  getTrace(id) {
+    const db = this.database();
+    const row = db.prepare(
+      `SELECT id, session_id, name, status, trace_json, input_json, output, error_json,
+                usage_json, metadata_json, observations_json, started_at, ended_at, duration_ms
+         FROM runner_traces
+         WHERE id = $id`
+    ).get({ $id: id });
+    return row === void 0 ? void 0 : toTrace(row);
+  }
+  saveTrace(trace) {
+    const db = this.database();
+    db.prepare(
+      `INSERT INTO runner_traces (
+        id,
+        session_id,
+        name,
+        status,
+        trace_json,
+        input_json,
+        output,
+        error_json,
+        usage_json,
+        metadata_json,
+        observations_json,
+        started_at,
+        ended_at,
+        duration_ms
+      ) VALUES (
+        $id,
+        $sessionId,
+        $name,
+        $status,
+        $trace,
+        $input,
+        $output,
+        $error,
+        $usage,
+        $metadata,
+        $observations,
+        $startedAt,
+        $endedAt,
+        $durationMs
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        session_id = excluded.session_id,
+        name = excluded.name,
+        status = excluded.status,
+        trace_json = excluded.trace_json,
+        input_json = excluded.input_json,
+        output = excluded.output,
+        error_json = excluded.error_json,
+        usage_json = excluded.usage_json,
+        metadata_json = excluded.metadata_json,
+        observations_json = excluded.observations_json,
+        started_at = excluded.started_at,
+        ended_at = excluded.ended_at,
+        duration_ms = excluded.duration_ms`
+    ).run({
+      $id: trace.id,
+      $sessionId: trace.sessionId,
+      $name: trace.name ?? null,
+      $status: trace.status,
+      $trace: trace.trace === void 0 ? null : JSON.stringify(trace.trace),
+      $input: trace.input === void 0 ? null : JSON.stringify(trace.input),
+      $output: trace.output ?? null,
+      $error: trace.error === void 0 ? null : JSON.stringify(trace.error),
+      $usage: trace.usage === void 0 ? null : JSON.stringify(trace.usage),
+      $metadata: trace.metadata === void 0 ? null : JSON.stringify(trace.metadata),
+      $observations: JSON.stringify(trace.observations),
+      $startedAt: trace.startedAt,
+      $endedAt: trace.endedAt ?? null,
+      $durationMs: trace.durationMs ?? null
+    });
+    return trace;
+  }
+  database() {
+    if (this.db !== void 0) {
+      return this.db;
+    }
+    if (this.path !== ":memory:") {
+      mkdirSync(dirname(resolve(this.path)), { recursive: true });
+    }
+    const db = new DatabaseSync(this.path, {
+      allowUnknownNamedParameters: true,
+      timeout: 5e3
+    });
+    db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA foreign_keys = ON;
+      CREATE TABLE IF NOT EXISTS runner_sessions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        title TEXT,
+        metadata_json TEXT,
+        messages_json TEXT NOT NULL,
+        transcript_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_sessions_agent_updated_idx
+        ON runner_sessions(agent_id, updated_at DESC);
+      CREATE TABLE IF NOT EXISTS runner_traces (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        name TEXT,
+        status TEXT NOT NULL,
+        trace_json TEXT,
+        input_json TEXT,
+        output TEXT,
+        error_json TEXT,
+        usage_json TEXT,
+        metadata_json TEXT,
+        observations_json TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        duration_ms INTEGER
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_traces_session_started_idx
+        ON runner_traces(session_id, started_at DESC);
+    `);
+    this.db = db;
+    return db;
+  }
+};
+function toSession(row) {
+  const summary = toSessionSummary(row);
+  return {
+    ...summary,
+    messages: parseJsonArray(row.messages_json),
+    transcript: renumberTranscript(parseJsonArray(row.transcript_json))
+  };
+}
+function toSessionSummary(row) {
+  const messages = parseJsonArray(row.messages_json);
+  const metadata = parseJsonValue(row.metadata_json);
+  return {
+    id: row.id,
+    agentId: row.agent_id,
+    ...row.title === null ? {} : { title: row.title },
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    messageCount: messages.length,
+    ...metadata === void 0 ? {} : { metadata }
+  };
+}
+function toTrace(row) {
+  const trace = parseJsonValue(row.trace_json);
+  const input = parseJsonValue(row.input_json);
+  return {
+    ...toTraceSummary(row),
+    ...trace === void 0 ? {} : { trace },
+    ...input === void 0 ? {} : { input },
+    observations: parseJsonArray(row.observations_json)
+  };
+}
+function toTraceSummary(row) {
+  const observations = parseJsonArray(row.observations_json);
+  const error = parseJsonValue(row.error_json);
+  const usage = parseJsonValue(row.usage_json);
+  const metadata = parseJsonValue(row.metadata_json);
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    ...row.name === null ? {} : { name: row.name },
+    status: row.status,
+    startedAt: row.started_at,
+    ...row.ended_at === null ? {} : { endedAt: row.ended_at },
+    ...row.duration_ms === null ? {} : { durationMs: row.duration_ms },
+    ...row.output === null ? {} : { output: row.output },
+    ...error === void 0 ? {} : { error },
+    ...usage === void 0 ? {} : { usage },
+    ...metadata === void 0 ? {} : { metadata },
+    observationCount: observations.length
+  };
+}
+function parseJsonArray(value) {
+  const parsed = JSON.parse(value);
+  return Array.isArray(parsed) ? parsed : [];
+}
+function parseJsonValue(value) {
+  if (value === null) {
+    return void 0;
+  }
+  return JSON.parse(value);
+}
+function renumberTranscript(entries) {
+  return entries.map((entry, entryId) => ({ ...entry, entryId }));
+}
+
+// src/runtime/shared.ts
+function resolveStores(options) {
+  const defaultPath = process.env.ANVIA_STUDIO_DB ?? process.env.AION_STUDIO_DB ?? join(process.cwd(), ".anvia-studio", `${safeFileName(runnerId(options))}.sqlite`);
+  const defaultStore = createSqliteSessionStore({ path: defaultPath });
+  const sessions = resolveSessionStore(options, defaultStore);
+  const traces = resolveTraceStore(options, sessions, defaultStore);
+  return {
+    ...sessions === void 0 ? {} : { sessions },
+    ...traces === void 0 ? {} : { traces }
+  };
+}
+function resolveSessionStore(options, defaultStore) {
+  if (options.stores?.sessions === false) {
+    return void 0;
+  }
+  if (options.stores?.sessions !== void 0) {
+    return options.stores.sessions;
+  }
+  return defaultStore;
+}
+function resolveTraceStore(options, sessionStore, defaultStore) {
+  if (options.stores?.traces !== void 0) {
+    return options.stores.traces;
+  }
+  if (sessionStore === void 0) {
+    return void 0;
+  }
+  if (isTraceStore(sessionStore)) {
+    return sessionStore;
+  }
+  return defaultStore;
+}
+function isTraceStore(store) {
+  const candidate = store;
+  return typeof candidate.listSessionTraces === "function" && typeof candidate.getTrace === "function" && typeof candidate.saveTrace === "function";
+}
+function unsupportedCapabilities(stores) {
+  return [
+    ...stores.sessions === void 0 ? ["sessions"] : [],
+    ...stores.traces === void 0 ? ["traces"] : []
+  ];
+}
+function normalizeAgents(agents) {
+  const ids = /* @__PURE__ */ new Set();
+  return agents.map((agent) => {
+    const id = agent.id.trim();
+    if (id.length === 0) {
+      throw new Error("Studio agent id cannot be empty");
+    }
+    if (ids.has(id)) {
+      throw new Error(`Duplicate runner agent id: ${id}`);
+    }
+    ids.add(id);
+    return { ...agent, id };
+  });
+}
+function buildConfig(options, agents, stores) {
+  return {
+    id: runnerId(options),
+    ...options.name === void 0 ? {} : { name: options.name },
+    ...options.description === void 0 ? {} : { description: options.description },
+    ...options.version === void 0 ? {} : { version: options.version },
+    agents: agents.map(agentConfig),
+    chat: {
+      quickPrompts: Object.fromEntries(agents.map((agent) => [agent.id, agent.quickPrompts ?? []]))
+    },
+    capabilities: capabilityConfig(options, agents, stores),
+    unsupportedCapabilities: unsupportedCapabilities(stores)
+  };
+}
+function runnerId(options) {
+  return options.id ?? "anvia-studio";
+}
+function agentConfig(agent) {
+  const name = agent.name ?? agent.agent.name;
+  const description = agent.description ?? agent.agent.description;
+  return {
+    id: agent.id,
+    ...name === void 0 ? {} : { name },
+    ...description === void 0 ? {} : { description },
+    quickPrompts: agent.quickPrompts ?? [],
+    ...agent.metadata === void 0 ? {} : { metadata: agent.metadata }
+  };
+}
+function capabilityConfig(_options, agents, stores) {
+  const capabilities = {
+    agents: { enabled: true }
+  };
+  if (stores.sessions !== void 0) {
+    capabilities.sessions = { enabled: true };
+  }
+  if (stores.traces !== void 0) {
+    capabilities.traces = { enabled: true };
+  }
+  if (agents.some((agent) => agent.agent.observers.length > 0)) {
+    capabilities.observability = { enabled: true };
+  }
+  if (agents.some((agent) => agent.agent.toolSet.values().some((tool) => tool.approval))) {
+    capabilities.approvals = { enabled: true };
+  }
+  if (agents.some(
+    (agent) => agent.agent.staticContext.length > 0 || agent.agent.dynamicContexts.length > 0 || agent.agent.dynamicTools.length > 0
+  )) {
+    capabilities.knowledge = { enabled: true };
+  }
+  return capabilities;
+}
+function optionalQueryString(value) {
+  const trimmed = value?.trim();
+  return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+}
+function parseLimit(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return 50;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    return void 0;
+  }
+  return Math.min(limit, 100);
+}
+function parseTraceStatus(value) {
+  const status = optionalQueryString(value);
+  if (status === void 0) {
+    return void 0;
+  }
+  return status === "running" || status === "success" || status === "error" ? status : false;
+}
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_") || "anvia-studio";
+}
+function isMessageInput(value) {
+  return typeof value === "string" || isMessage(value);
+}
+function isMessage(value) {
+  if (!isObject(value) || typeof value.role !== "string") {
+    return false;
+  }
+  if (value.role === "system") {
+    return typeof value.content === "string";
+  }
+  if (value.role === "user" || value.role === "assistant" || value.role === "tool") {
+    return Array.isArray(value.content);
+  }
+  return false;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonObject(value) {
+  return isObject(value) && Object.values(value).every(isJsonValue);
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  return isJsonObject(value);
+}
+function isAgentTraceOptions(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  return optionalString(value.name) && optionalString(value.userId) && optionalString(value.sessionId) && optionalString(value.version) && optionalString(value.traceId) && optionalBoolean(value.failOnObserverError) && optionalStringArray(value.tags) && optionalObject(value.metadata);
+}
+function optionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function optionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function optionalStringArray(value) {
+  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function optionalObject(value) {
+  return value === void 0 || isObject(value);
+}
+function isNonNegativeInteger(value) {
+  return Number.isInteger(value) && typeof value === "number" && value >= 0;
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && typeof value === "number" && value > 0;
+}
+function unsupportedCapability(c, capability) {
+  return errorResponse(
+    c,
+    501,
+    "unsupported_capability",
+    `Capability "${capability}" is not implemented by this runner`,
+    { capability }
+  );
+}
+function errorResponse(c, status, code, message, details) {
+  const body = {
+    error: {
+      code,
+      message
+    }
+  };
+  if (details !== void 0) {
+    body.error.details = details;
+  }
+  return c.json(body, status);
+}
+function serializeError2(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      ...error.stack === void 0 ? {} : { stack: error.stack }
+    };
+  }
+  return isJsonValue(error) ? error : String(error);
+}
+
+// src/runtime/approvals.ts
+function registerApprovalRoutes(app, approvals) {
+  app.get("/approvals", (c) => {
+    const status = parseApprovalStatus(c.req.query("status"));
+    if (status === false) {
+      return errorResponse(c, 400, "bad_request", "status must be pending or resolved");
+    }
+    const options = {};
+    const runId = optionalQueryString(c.req.query("runId"));
+    const agentId = optionalQueryString(c.req.query("agentId"));
+    const sessionId = optionalQueryString(c.req.query("sessionId"));
+    if (status !== void 0) {
+      options.status = status;
+    }
+    if (runId !== void 0) {
+      options.runId = runId;
+    }
+    if (agentId !== void 0) {
+      options.agentId = agentId;
+    }
+    if (sessionId !== void 0) {
+      options.sessionId = sessionId;
+    }
+    return c.json({
+      approvals: approvals.list(options)
+    });
+  });
+  app.post("/approvals/:approvalId/decision", async (c) => {
+    const body = await parseApprovalDecisionRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    const result = approvals.decide(c.req.param("approvalId"), body);
+    if (result === "missing") {
+      return errorResponse(c, 404, "not_found", "Approval not found");
+    }
+    if (result === "resolved") {
+      return errorResponse(c, 409, "conflict", "Approval is already resolved");
+    }
+    return c.json(result);
+  });
+}
+function parseApprovalStatus(value) {
+  const status = optionalQueryString(value);
+  if (status === void 0) {
+    return void 0;
+  }
+  return status === "pending" || status === "resolved" ? status : false;
+}
+async function parseApprovalDecisionRequest(c) {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be JSON") };
+  }
+  if (!isObject(body)) {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
+  }
+  if (typeof body.approved !== "boolean") {
+    return { error: errorResponse(c, 400, "bad_request", "approved must be a boolean") };
+  }
+  if ("reason" in body && typeof body.reason !== "string") {
+    return { error: errorResponse(c, 400, "bad_request", "reason must be a string") };
+  }
+  return {
+    approved: body.approved,
+    ...typeof body.reason === "string" && body.reason.trim().length > 0 ? { reason: body.reason.trim() } : {}
+  };
+}
+function createApprovalRuntime() {
+  const approvals = /* @__PURE__ */ new Map();
+  return {
+    approvals,
+    createHook(context) {
+      return createHook({
+        async onToolCall({ toolName, toolCallId, internalCallId, args, tool: control }) {
+          const registeredTool = context.getTool(toolName);
+          if (registeredTool?.approval === void 0) {
+            return control.run();
+          }
+          const approval = registeredTool.approval;
+          const rawParsedArgs = parseToolArgs(args);
+          const parsedArgs = registeredTool.parseApprovalArgs?.(rawParsedArgs) ?? rawParsedArgs;
+          const approvalContext = {
+            toolName,
+            args: parsedArgs,
+            rawArgs: args,
+            ...toolCallId === void 0 ? {} : { toolCallId },
+            internalCallId,
+            run: {
+              agentId: context.agentId,
+              runId: context.runId,
+              ...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+              ...context.metadata === void 0 ? {} : { metadata: context.metadata }
+            }
+          };
+          const required = await approval.when(approvalContext);
+          if (!required) {
+            return control.run();
+          }
+          const reason = await resolveApprovalText(approval.reason, approvalContext);
+          const rejectMessage = await resolveApprovalText(approval.rejectMessage, approvalContext);
+          const decision = await requestApproval(approvals, context, {
+            toolName,
+            ...toolCallId === void 0 ? {} : { toolCallId },
+            internalCallId,
+            args,
+            ...reason === void 0 ? {} : { reason },
+            ...rejectMessage === void 0 ? {} : { rejectMessage }
+          });
+          return decision.approved ? control.run() : control.skip(decision.reason ?? rejectMessage ?? "Rejected in Anvia Studio.");
+        }
+      });
+    },
+    list(options) {
+      return [...approvals.values()].filter((approval) => {
+        if (options.status === "pending" && approval.status !== "pending") {
+          return false;
+        }
+        if (options.status === "resolved" && approval.status === "pending") {
+          return false;
+        }
+        if (options.runId !== void 0 && approval.runId !== options.runId) {
+          return false;
+        }
+        if (options.agentId !== void 0 && approval.agentId !== options.agentId) {
+          return false;
+        }
+        if (options.sessionId !== void 0 && approval.sessionId !== options.sessionId) {
+          return false;
+        }
+        return true;
+      }).map(publicApproval);
+    },
+    decide(id, decision) {
+      const approval = approvals.get(id);
+      if (approval === void 0) {
+        return "missing";
+      }
+      if (!isPendingApproval(approval)) {
+        return "resolved";
+      }
+      const reason = decision.approved ? decision.reason : decision.reason ?? approval.rejectMessage ?? "Rejected in Anvia Studio.";
+      const resolved = resolveApproval(approval, decision.approved ? "approved" : "rejected", {
+        ...reason === void 0 ? {} : { reason }
+      });
+      approvals.set(id, resolved);
+      approval.emit?.({ type: "tool_approval_result", approval: resolved });
+      approval.resolve({
+        approved: decision.approved,
+        ...reason === void 0 ? {} : { reason }
+      });
+      return publicApproval(resolved);
+    }
+  };
+}
+async function requestApproval(approvals, context, request) {
+  const id = globalThis.crypto.randomUUID();
+  const approval = {
+    id,
+    runId: context.runId,
+    agentId: context.agentId,
+    ...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+    toolName: request.toolName,
+    ...request.toolCallId === void 0 ? {} : { callId: request.toolCallId },
+    internalCallId: request.internalCallId,
+    args: request.args,
+    status: "pending",
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...request.reason === void 0 ? {} : { reason: request.reason },
+    ...request.rejectMessage === void 0 ? {} : { rejectMessage: request.rejectMessage },
+    ...context.emit === void 0 ? {} : { emit: context.emit },
+    resolve: () => {
+    }
+  };
+  const decision = new Promise((resolve2) => {
+    approval.resolve = (decision2) => {
+      const current = approvals.get(id);
+      if (!isPendingApproval(current)) {
+        if (current !== void 0) {
+          resolve2({
+            approved: current.status === "approved",
+            ...current.reason === void 0 ? {} : { reason: current.reason }
+          });
+        }
+        return;
+      }
+      const reason = decision2.approved ? decision2.reason : decision2.reason ?? request.rejectMessage ?? "Rejected in Anvia Studio.";
+      const resolved = resolveApproval(current, decision2.approved ? "approved" : "rejected", {
+        ...reason === void 0 ? {} : { reason }
+      });
+      approvals.set(id, resolved);
+      context.emit?.({ type: "tool_approval_result", approval: resolved });
+      resolve2({
+        approved: decision2.approved,
+        ...reason === void 0 ? {} : { reason }
+      });
+    };
+  });
+  approvals.set(id, approval);
+  context.emit?.({ type: "tool_approval_request", approval: publicApproval(approval) });
+  return decision;
+}
+async function resolveApprovalText(value, context) {
+  return typeof value === "function" ? value(context) : value;
+}
+function isPendingApproval(approval) {
+  return approval !== void 0 && approval.status === "pending" && "resolve" in approval;
+}
+function resolveApproval(approval, status, options = {}) {
+  return publicApproval({
+    ...approval,
+    status,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.reason === void 0 ? {} : { reason: options.reason }
+  });
+}
+function publicApproval(approval) {
+  const { emit, rejectMessage, resolve: resolve2, ...rest } = approval;
+  void emit;
+  void rejectMessage;
+  void resolve2;
+  return rest;
+}
+
+// src/runtime/json.ts
+function toJsonValue2(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value === void 0) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toJsonValue2(item));
+  }
+  if (typeof value === "object") {
+    return compactJsonObject2(value);
+  }
+  return String(value);
+}
+function compactJsonObject2(values) {
+  const entries = Object.entries(values).flatMap(
+    ([key, value]) => value === void 0 ? [] : [[key, toJsonValue2(value)]]
+  );
+  return Object.fromEntries(entries);
+}
+
+// src/runtime/knowledge.ts
+function registerKnowledgeRoutes(app, props) {
+  app.get("/knowledge", async (c) => {
+    const limit = parseLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "Invalid limit");
+    }
+    const summary = {
+      agents: props.agents.map(agentKnowledgeConfig),
+      evidence: await recentKnowledgeEvidence(props.traceStore, limit)
+    };
+    return c.json(summary);
+  });
+}
+function agentKnowledgeConfig(agent) {
+  const agentName = agent.name ?? agent.agent.name;
+  return {
+    agentId: agent.id,
+    ...agentName === void 0 ? {} : { agentName },
+    sources: [
+      { kind: "static_context", count: agent.agent.staticContext.length },
+      { kind: "dynamic_context", count: agent.agent.dynamicContexts.length },
+      { kind: "dynamic_tools", count: agent.agent.dynamicTools.length }
+    ],
+    staticContext: agent.agent.staticContext.map((document) => ({
+      id: document.id,
+      text: document.text,
+      ...document.additionalProps === void 0 ? {} : { additionalProps: jsonObjectFromRecord(document.additionalProps) }
+    }))
+  };
+}
+async function recentKnowledgeEvidence(traceStore, limit) {
+  if (traceStore?.listTraces === void 0) {
+    return [];
+  }
+  const store = traceStore;
+  const listTraces = store.listTraces;
+  if (listTraces === void 0) {
+    return [];
+  }
+  const summaries = await listTraces.call(store, { limit });
+  const traces = await Promise.all(
+    summaries.map((summary) => Promise.resolve(store.getTrace(summary.id)).catch(() => void 0))
+  );
+  return traces.flatMap(
+    (trace) => trace === void 0 ? [] : evidenceFromTrace(trace)
+  );
+}
+function evidenceFromTrace(trace) {
+  return trace.observations.flatMap((observation) => {
+    if (observation.kind !== "generation" || !isRecord(observation.input)) {
+      return [];
+    }
+    const documents = Array.isArray(observation.input.documents) ? observation.input.documents.flatMap((document) => evidenceDocument(document)) : [];
+    const tools = Array.isArray(observation.input.tools) ? observation.input.tools.flatMap((tool) => evidenceToolName(tool)) : [];
+    if (documents.length === 0 && tools.length === 0) {
+      return [];
+    }
+    const query = queryFromGenerationInput(observation.input);
+    return [
+      {
+        traceId: trace.id,
+        sessionId: trace.sessionId,
+        observationId: observation.id,
+        observationName: observation.name,
+        turn: observation.turn,
+        startedAt: observation.startedAt,
+        ...query === void 0 ? {} : { query },
+        documentCount: documents.length,
+        toolCount: tools.length,
+        documents,
+        tools
+      }
+    ];
+  });
+}
+function queryFromGenerationInput(value) {
+  const promptText = messageText(value.prompt);
+  if (promptText.length > 0) {
+    return promptText;
+  }
+  if (Array.isArray(value.chatHistory)) {
+    for (let index = value.chatHistory.length - 1; index >= 0; index -= 1) {
+      const text = messageText(value.chatHistory[index]);
+      if (text.length > 0) {
+        return text;
+      }
+    }
+  }
+  if (Array.isArray(value.history)) {
+    for (let index = value.history.length - 1; index >= 0; index -= 1) {
+      const text = messageText(value.history[index]);
+      if (text.length > 0) {
+        return text;
+      }
+    }
+  }
+  return void 0;
+}
+function messageText(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (!isRecord(value)) {
+    return "";
+  }
+  if (typeof value.text === "string") {
+    return value.text.trim();
+  }
+  if (typeof value.content === "string") {
+    return value.content.trim();
+  }
+  if (Array.isArray(value.content)) {
+    return value.content.map(contentText).filter(Boolean).join("\n").trim();
+  }
+  return "";
+}
+function contentText(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (!isRecord(value)) {
+    return "";
+  }
+  if (typeof value.text === "string") {
+    return value.text.trim();
+  }
+  return "";
+}
+function evidenceDocument(value) {
+  if (!isRecord(value)) {
+    return [];
+  }
+  const id = typeof value.id === "string" ? value.id : void 0;
+  const text = typeof value.text === "string" ? value.text : void 0;
+  const additionalProps = isRecord(value.additionalProps) ? jsonObjectFromRecord(value.additionalProps) : void 0;
+  if (id === void 0 && text === void 0 && additionalProps === void 0) {
+    return [];
+  }
+  return [
+    {
+      ...id === void 0 ? {} : { id },
+      ...text === void 0 ? {} : { text },
+      ...additionalProps === void 0 ? {} : { additionalProps }
+    }
+  ];
+}
+function evidenceToolName(value) {
+  if (!isRecord(value) || typeof value.name !== "string") {
+    return [];
+  }
+  return [value.name];
+}
+function jsonObjectFromRecord(value) {
+  return compactJsonObject2(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/runtime/questions.ts
+import { createHook as createHook2, parseToolArgs as parseToolArgs2 } from "@anvia/core";
+function registerQuestionRoutes(app, questions) {
+  app.get("/questions", (c) => {
+    const status = parseQuestionStatus(c.req.query("status"));
+    if (status === false) {
+      return errorResponse(c, 400, "bad_request", "status must be pending or resolved");
+    }
+    const options = {};
+    const runId = optionalQueryString(c.req.query("runId"));
+    const agentId = optionalQueryString(c.req.query("agentId"));
+    const sessionId = optionalQueryString(c.req.query("sessionId"));
+    if (status !== void 0) {
+      options.status = status;
+    }
+    if (runId !== void 0) {
+      options.runId = runId;
+    }
+    if (agentId !== void 0) {
+      options.agentId = agentId;
+    }
+    if (sessionId !== void 0) {
+      options.sessionId = sessionId;
+    }
+    return c.json({ questions: questions.list(options) });
+  });
+  app.post("/questions/:questionId/answer", async (c) => {
+    const body = await parseQuestionAnswerRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    const result = questions.answer(c.req.param("questionId"), body.answers);
+    if (result === "missing") {
+      return errorResponse(c, 404, "not_found", "Question not found");
+    }
+    if (result === "resolved") {
+      return errorResponse(c, 409, "conflict", "Question is already answered");
+    }
+    return c.json(result);
+  });
+}
+function parseQuestionStatus(value) {
+  const status = optionalQueryString(value);
+  if (status === void 0) {
+    return void 0;
+  }
+  return status === "pending" || status === "resolved" ? status : false;
+}
+async function parseQuestionAnswerRequest(c) {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be JSON") };
+  }
+  if (!isObject(body)) {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
+  }
+  if (!Array.isArray(body.answers)) {
+    return { error: errorResponse(c, 400, "bad_request", "answers must be an array") };
+  }
+  const answers = [];
+  for (const answer of body.answers) {
+    if (!isObject(answer)) {
+      return { error: errorResponse(c, 400, "bad_request", "answers must contain objects") };
+    }
+    if (typeof answer.questionId !== "string" || answer.questionId.trim().length === 0) {
+      return { error: errorResponse(c, 400, "bad_request", "questionId must be a string") };
+    }
+    if (typeof answer.answer !== "string" || answer.answer.trim().length === 0) {
+      return { error: errorResponse(c, 400, "bad_request", "answer must be a string") };
+    }
+    if ("choice" in answer && typeof answer.choice !== "string") {
+      return { error: errorResponse(c, 400, "bad_request", "choice must be a string") };
+    }
+    if ("custom" in answer && typeof answer.custom !== "boolean") {
+      return { error: errorResponse(c, 400, "bad_request", "custom must be a boolean") };
+    }
+    answers.push({
+      questionId: answer.questionId.trim(),
+      answer: answer.answer.trim(),
+      ...typeof answer.choice === "string" ? { choice: answer.choice } : {},
+      ...typeof answer.custom === "boolean" ? { custom: answer.custom } : {}
+    });
+  }
+  return { answers };
+}
+function createQuestionRuntime() {
+  const questions = /* @__PURE__ */ new Map();
+  return {
+    questions,
+    createHook(context) {
+      return createHook2({
+        async onToolCall({ toolName, toolCallId, internalCallId, args, tool: control }) {
+          if (toolName !== "ask_question") {
+            return control.run();
+          }
+          const prompts = normalizeQuestionPrompts(parseToolArgs2(args));
+          if ("error" in prompts) {
+            return control.skip(prompts.error);
+          }
+          const answers = await requestQuestion(questions, context, {
+            toolName,
+            ...toolCallId === void 0 ? {} : { toolCallId },
+            internalCallId,
+            args,
+            questions: prompts.questions
+          });
+          return control.skip(JSON.stringify({ answers }));
+        }
+      });
+    },
+    list(options) {
+      return [...questions.values()].filter((question) => {
+        if (options.status === "pending" && question.status !== "pending") {
+          return false;
+        }
+        if (options.status === "resolved" && question.status === "pending") {
+          return false;
+        }
+        if (options.runId !== void 0 && question.runId !== options.runId) {
+          return false;
+        }
+        if (options.agentId !== void 0 && question.agentId !== options.agentId) {
+          return false;
+        }
+        if (options.sessionId !== void 0 && question.sessionId !== options.sessionId) {
+          return false;
+        }
+        return true;
+      }).map(publicQuestion);
+    },
+    answer(id, answers) {
+      const question = questions.get(id);
+      if (question === void 0) {
+        return "missing";
+      }
+      if (!isPendingQuestion(question)) {
+        return "resolved";
+      }
+      const resolved = resolveQuestion(question, answers);
+      questions.set(id, resolved);
+      question.emit?.({ type: "tool_question_result", question: resolved });
+      question.resolve(answers);
+      return publicQuestion(resolved);
+    }
+  };
+}
+async function requestQuestion(questions, context, request) {
+  const id = globalThis.crypto.randomUUID();
+  const question = {
+    id,
+    runId: context.runId,
+    agentId: context.agentId,
+    ...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+    toolName: request.toolName,
+    ...request.toolCallId === void 0 ? {} : { callId: request.toolCallId },
+    internalCallId: request.internalCallId,
+    args: request.args,
+    questions: request.questions,
+    status: "pending",
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...context.emit === void 0 ? {} : { emit: context.emit },
+    resolve: () => {
+    }
+  };
+  const answer = new Promise((resolve2) => {
+    question.resolve = (answers) => {
+      resolve2(answers);
+    };
+  });
+  questions.set(id, question);
+  context.emit?.({ type: "tool_question_request", question: publicQuestion(question) });
+  return answer;
+}
+function normalizeQuestionPrompts(args) {
+  if (!isObject(args)) {
+    return { error: "ask_question requires a JSON object with questions." };
+  }
+  const rawQuestions = Array.isArray(args.questions) ? args.questions : [args];
+  if (rawQuestions.length === 0) {
+    return { error: "ask_question requires at least one question." };
+  }
+  const questions = [];
+  for (const [index, question] of rawQuestions.entries()) {
+    const normalized = normalizeQuestionPrompt(question, index);
+    if (normalized === void 0) {
+      return {
+        error: "ask_question requires every question to include text and at least one choice."
+      };
+    }
+    questions.push(normalized);
+  }
+  return { questions };
+}
+function normalizeQuestionPrompt(value, index) {
+  if (!isObject(value) || typeof value.question !== "string" || value.question.trim().length === 0) {
+    return void 0;
+  }
+  const choices = Array.isArray(value.choices) ? value.choices.map(normalizeQuestionChoice).filter((choice) => choice !== void 0) : [];
+  if (choices.length === 0) {
+    return void 0;
+  }
+  return {
+    id: typeof value.id === "string" && value.id.trim().length > 0 ? value.id.trim() : `question_${index + 1}`,
+    question: value.question.trim(),
+    choices
+  };
+}
+function normalizeQuestionChoice(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return { label: value.trim(), value: value.trim() };
+  }
+  if (!isObject(value) || typeof value.label !== "string" || value.label.trim().length === 0) {
+    return void 0;
+  }
+  return {
+    label: value.label.trim(),
+    value: typeof value.value === "string" && value.value.trim().length > 0 ? value.value.trim() : value.label.trim()
+  };
+}
+function isPendingQuestion(question) {
+  return question !== void 0 && question.status === "pending" && "resolve" in question;
+}
+function resolveQuestion(question, answers) {
+  return publicQuestion({
+    ...question,
+    status: "answered",
+    answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    answers
+  });
+}
+function publicQuestion(question) {
+  const { emit, resolve: resolve2, ...rest } = question;
+  void emit;
+  void resolve2;
+  return rest;
+}
+
+// src/runtime/runs.ts
+import { stream as streamResponse } from "hono/streaming";
+var AsyncEventQueue = class {
+  values = [];
+  resolvers = [];
+  closed = false;
+  push(value) {
+    if (this.closed) {
+      return;
+    }
+    const resolver = this.resolvers.shift();
+    if (resolver !== void 0) {
+      resolver({ done: false, value });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    this.closed = true;
+    for (const resolver of this.resolvers.splice(0)) {
+      resolver({ done: true, value: void 0 });
+    }
+  }
+  next() {
+    const value = this.values.shift();
+    if (value !== void 0) {
+      return Promise.resolve({ done: false, value });
+    }
+    if (this.closed) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    return new Promise((resolve2) => this.resolvers.push(resolve2));
+  }
+};
+async function* mergeRunAndApprovalEvents(runEvents, approvalEvents) {
+  const runIterator = runEvents[Symbol.asyncIterator]();
+  let runDone = false;
+  let runNext = runIterator.next();
+  let approvalNext = approvalEvents.next();
+  try {
+    while (runNext !== void 0 || approvalNext !== void 0) {
+      const pending = [];
+      if (runNext !== void 0) {
+        pending.push(runNext.then((value) => ({ source: "run", value })));
+      }
+      if (approvalNext !== void 0) {
+        pending.push(approvalNext.then((value) => ({ source: "approval", value })));
+      }
+      const result = await Promise.race(pending);
+      if (result.source === "run") {
+        if (result.value.done === true) {
+          runDone = true;
+          runNext = void 0;
+          approvalEvents.close();
+        } else {
+          runNext = runIterator.next();
+          yield result.value.value;
+        }
+        continue;
+      }
+      if (result.value.done === true) {
+        approvalNext = void 0;
+      } else {
+        approvalNext = approvalEvents.next();
+        yield result.value.value;
+      }
+    }
+  } finally {
+    if (!runDone && runIterator.return !== void 0) {
+      await runIterator.return();
+    }
+    approvalEvents.close();
+  }
+}
+function streamAgentRunEvents(c, events) {
+  c.header("content-type", "application/x-ndjson; charset=utf-8");
+  c.header("cache-control", "no-cache, no-transform");
+  c.header("connection", "keep-alive");
+  c.header("transfer-encoding", "chunked");
+  c.header("x-accel-buffering", "no");
+  return streamResponse(
+    c,
+    async (stream) => {
+      for await (const event of events) {
+        await stream.write(`${JSON.stringify(event)}
+`);
+      }
+    },
+    async (error, stream) => {
+      await stream.write(`${JSON.stringify({ type: "error", error: serializeError2(error) })}
+`);
+    }
+  );
+}
+function traceForRun(trace, agentId, session) {
+  const metadata = {
+    ...trace?.metadata ?? {},
+    agentId
+  };
+  return {
+    ...trace ?? {},
+    metadata,
+    ...trace?.sessionId !== void 0 ? { sessionId: trace.sessionId } : session === void 0 ? {} : { sessionId: session.id }
+  };
+}
+async function* persistStreamingSessionRun(props) {
+  const transcript = [messageToTranscriptEntry(props.message, 0)];
+  for await (const event of props.stream) {
+    acceptTranscriptStreamEvent(transcript, event);
+    if (event.type === "final") {
+      const nextSession = await props.store.appendSessionRun({
+        id: props.session.id,
+        ...optionalTitle(props.message),
+        messages: event.messages,
+        transcript
+      });
+      if (nextSession === void 0) {
+        throw new Error("Session not found");
+      }
+    }
+    yield event;
+  }
+}
+function acceptTranscriptStreamEvent(transcript, event) {
+  if (event.type === "text_delta") {
+    appendTranscriptAssistantText(transcript, event.delta);
+  }
+  if (event.type === "reasoning_delta") {
+    appendTranscriptReasoningText(transcript, event.delta, event.id);
+  }
+  if (event.type === "tool_call") {
+    transcript.push({
+      entryId: transcript.length,
+      kind: "tool",
+      toolName: event.toolCall.function.name,
+      callId: event.toolCall.callId ?? event.toolCall.id,
+      args: formatJson(event.toolCall.function.arguments)
+    });
+  }
+  if (event.type === "tool_result") {
+    const matched = findTranscriptToolEntry(transcript, event.toolName, event.toolCallId);
+    if (matched === void 0) {
+      transcript.push({
+        entryId: transcript.length,
+        kind: "tool",
+        toolName: event.toolName,
+        ...event.toolCallId === void 0 ? {} : { callId: event.toolCallId },
+        args: event.args,
+        result: event.result
+      });
+      return;
+    }
+    matched.args = matched.args ?? event.args;
+    matched.result = event.result;
+  }
+  if (event.type === "tool_approval_request") {
+    const matched = findTranscriptToolEntry(
+      transcript,
+      event.approval.toolName,
+      approvalCallId(event.approval)
+    );
+    if (matched !== void 0) {
+      matched.approval = {
+        id: event.approval.id,
+        status: event.approval.status,
+        requestedAt: event.approval.requestedAt
+      };
+    }
+  }
+  if (event.type === "tool_approval_result") {
+    const matched = findTranscriptToolEntry(
+      transcript,
+      event.approval.toolName,
+      approvalCallId(event.approval)
+    );
+    if (matched !== void 0) {
+      matched.approval = {
+        id: event.approval.id,
+        status: event.approval.status,
+        requestedAt: event.approval.requestedAt,
+        ...event.approval.resolvedAt === void 0 ? {} : { resolvedAt: event.approval.resolvedAt },
+        ...event.approval.reason === void 0 ? {} : { reason: event.approval.reason }
+      };
+    }
+  }
+  if (event.type === "tool_question_request") {
+    const matched = findTranscriptToolEntry(
+      transcript,
+      event.question.toolName,
+      questionCallId(event.question)
+    );
+    if (matched !== void 0) {
+      matched.question = {
+        id: event.question.id,
+        status: event.question.status,
+        requestedAt: event.question.requestedAt,
+        questions: event.question.questions
+      };
+    }
+  }
+  if (event.type === "tool_question_result") {
+    const matched = findTranscriptToolEntry(
+      transcript,
+      event.question.toolName,
+      questionCallId(event.question)
+    );
+    if (matched !== void 0) {
+      matched.question = {
+        id: event.question.id,
+        status: event.question.status,
+        requestedAt: event.question.requestedAt,
+        ...event.question.answeredAt === void 0 ? {} : { answeredAt: event.question.answeredAt },
+        questions: event.question.questions,
+        ...event.question.answers === void 0 ? {} : { answers: event.question.answers }
+      };
+    }
+  }
+  if (event.type === "final" && event.trace?.traceId !== void 0) {
+    assignTranscriptTraceId(transcript, event.trace.traceId);
+  }
+}
+function approvalCallId(approval) {
+  return approval.callId ?? approval.toolCallId;
+}
+function questionCallId(question) {
+  return question.callId ?? question.toolCallId;
+}
+function transcriptFromMessages(messages) {
+  const transcript = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      continue;
+    }
+    if (message.role === "user") {
+      for (const content of message.content) {
+        if (content.type === "text") {
+          transcript.push({
+            entryId: transcript.length,
+            kind: "message",
+            role: "user",
+            text: content.text
+          });
+        }
+      }
+      continue;
+    }
+    if (message.role === "tool") {
+      for (const content of message.content) {
+        transcript.push({
+          entryId: transcript.length,
+          kind: "tool",
+          toolName: "tool_result",
+          callId: content.callId ?? content.id,
+          result: content.content.map((item) => "text" in item ? item.text : "[image]").join("\n")
+        });
+      }
+      continue;
+    }
+    for (const content of message.content) {
+      if (content.type === "text") {
+        appendTranscriptAssistantText(transcript, content.text);
+      } else if (content.type === "reasoning") {
+        appendTranscriptReasoningText(transcript, content.text, content.id);
+      } else if (content.type === "tool_call") {
+        transcript.push({
+          entryId: transcript.length,
+          kind: "tool",
+          toolName: content.function.name,
+          callId: content.callId ?? content.id,
+          args: formatJson(content.function.arguments)
+        });
+      }
+    }
+  }
+  return transcript;
+}
+function messageToTranscriptEntry(message, entryId) {
+  const role = typeof message === "string" || message.role !== "assistant" ? "user" : "assistant";
+  return {
+    entryId,
+    kind: "message",
+    role,
+    text: extractMessageText(message)
+  };
+}
+function appendTranscriptAssistantText(transcript, delta) {
+  const last = transcript.at(-1);
+  if (last?.kind === "message" && last.role === "assistant") {
+    last.text = `${last.text}${delta}`;
+    return;
+  }
+  transcript.push({
+    entryId: transcript.length,
+    kind: "message",
+    role: "assistant",
+    text: delta
+  });
+}
+function assignTranscriptTraceId(transcript, traceId) {
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    const entry = transcript[index];
+    if (entry?.kind === "message" && entry.role === "assistant") {
+      transcript[index] = { ...entry, traceId };
+      return;
+    }
+  }
+}
+function appendTranscriptReasoningText(transcript, delta, reasoningId) {
+  const last = transcript.at(-1);
+  if (last?.kind === "reasoning" && (last.reasoningId ?? "") === (reasoningId ?? "")) {
+    last.text = `${last.text}${delta}`;
+    return;
+  }
+  transcript.push({
+    entryId: transcript.length,
+    kind: "reasoning",
+    ...reasoningId === void 0 ? {} : { reasoningId },
+    text: delta
+  });
+}
+function findTranscriptToolEntry(transcript, toolName, callId) {
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    const entry = transcript[index];
+    if (entry?.kind !== "tool" || entry.toolName !== toolName || entry.result !== void 0) {
+      continue;
+    }
+    if (callId === void 0 || entry.callId === callId) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function titleFromMessage(message) {
+  const text = extractMessageText(message).replace(/\s+/g, " ").trim();
+  if (text.length === 0) {
+    return void 0;
+  }
+  return text.length > 72 ? `${text.slice(0, 69)}...` : text;
+}
+function optionalTitle(message) {
+  const title = titleFromMessage(message);
+  return title === void 0 ? {} : { title };
+}
+function extractMessageText(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message.role === "system") {
+    return message.content;
+  }
+  return message.content.flatMap((item) => {
+    if (item.type === "text" || item.type === "reasoning") {
+      return [item.text];
+    }
+    if (item.type === "tool_call") {
+      return [`${item.function.name}(${formatJson(item.function.arguments)})`];
+    }
+    if (item.type === "tool_result") {
+      return item.content.map((result) => "text" in result ? result.text : "[image]");
+    }
+    return [];
+  }).join("\n");
+}
+function formatJson(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+async function parseRunRequest(c) {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be JSON") };
+  }
+  if (!isObject(body)) {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
+  }
+  if (!("message" in body) || !isMessageInput(body.message)) {
+    return {
+      error: errorResponse(c, 400, "bad_request", "Request body requires a string or Message")
+    };
+  }
+  const request = {
+    message: typeof body.message === "string" ? body.message : body.message
+  };
+  if ("history" in body) {
+    if (!Array.isArray(body.history) || !body.history.every(isMessage)) {
+      return { error: errorResponse(c, 400, "bad_request", "history must be a Message array") };
+    }
+    request.history = body.history;
+  }
+  if ("sessionId" in body) {
+    if (typeof body.sessionId !== "string" || body.sessionId.trim().length === 0) {
+      return { error: errorResponse(c, 400, "bad_request", "sessionId must be a string") };
+    }
+    if (request.history !== void 0) {
+      return {
+        error: errorResponse(c, 400, "bad_request", "sessionId cannot be combined with history")
+      };
+    }
+    request.sessionId = body.sessionId;
+  }
+  if ("stream" in body) {
+    if (typeof body.stream !== "boolean") {
+      return { error: errorResponse(c, 400, "bad_request", "stream must be a boolean") };
+    }
+    request.stream = body.stream;
+  }
+  if ("maxTurns" in body) {
+    if (!isNonNegativeInteger(body.maxTurns)) {
+      return {
+        error: errorResponse(c, 400, "bad_request", "maxTurns must be a non-negative integer")
+      };
+    }
+    request.maxTurns = body.maxTurns;
+  }
+  if ("toolConcurrency" in body) {
+    if (!isPositiveInteger(body.toolConcurrency)) {
+      return {
+        error: errorResponse(c, 400, "bad_request", "toolConcurrency must be a positive integer")
+      };
+    }
+    request.toolConcurrency = body.toolConcurrency;
+  }
+  if ("metadata" in body) {
+    if (!isJsonObject(body.metadata)) {
+      return { error: errorResponse(c, 400, "bad_request", "metadata must be an object") };
+    }
+    request.metadata = body.metadata;
+  }
+  if ("trace" in body) {
+    if (!isAgentTraceOptions(body.trace)) {
+      return {
+        error: errorResponse(c, 400, "bad_request", "trace must be an AgentTraceOptions object")
+      };
+    }
+    request.trace = body.trace;
+  }
+  return request;
+}
+
+// src/runtime/sessions.ts
+function registerSessionRoutes(app, props) {
+  app.get("/sessions", async (c) => {
+    const agentId = optionalQueryString(c.req.query("agentId"));
+    if (agentId !== void 0 && !props.agentMap.has(agentId)) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    const limit = parseLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
+    }
+    const sessions = await props.sessionStore.listSessions({
+      ...agentId === void 0 ? {} : { agentId },
+      limit
+    });
+    return c.json({ sessions });
+  });
+  app.post("/sessions", async (c) => {
+    const body = await parseCreateSessionRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    if (!props.agentMap.has(body.agentId)) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    const session = await props.sessionStore.createSession({
+      id: globalThis.crypto.randomUUID(),
+      agentId: body.agentId,
+      ...body.title === void 0 ? {} : { title: body.title },
+      ...body.metadata === void 0 ? {} : { metadata: body.metadata }
+    });
+    return c.json(session, 201);
+  });
+  app.get("/sessions/:sessionId", async (c) => {
+    const session = await props.sessionStore.getSession(c.req.param("sessionId"));
+    if (session === void 0) {
+      return errorResponse(c, 404, "not_found", "Session not found");
+    }
+    return c.json(session);
+  });
+  app.delete("/sessions/:sessionId", async (c) => {
+    if (props.sessionStore.deleteSession === void 0) {
+      return errorResponse(
+        c,
+        501,
+        "unsupported_capability",
+        'Capability "sessions.delete" is not implemented by this runner',
+        { capability: "sessions", operation: "delete" }
+      );
+    }
+    const deleted = await props.sessionStore.deleteSession(c.req.param("sessionId"));
+    if (!deleted) {
+      return errorResponse(c, 404, "not_found", "Session not found");
+    }
+    return c.body(null, 204);
+  });
+  app.get("/sessions/:sessionId/traces", async (c) => {
+    if (props.traceStore === void 0) {
+      return unsupportedCapability(c, "traces");
+    }
+    const sessionId = c.req.param("sessionId");
+    const session = await props.sessionStore.getSession(sessionId);
+    if (session === void 0) {
+      return errorResponse(c, 404, "not_found", "Session not found");
+    }
+    const limit = parseLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
+    }
+    const traces = await props.traceStore.listSessionTraces({ sessionId, limit });
+    return c.json({ traces });
+  });
+}
+async function parseCreateSessionRequest(c) {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be JSON") };
+  }
+  if (!isObject(body)) {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
+  }
+  if (typeof body.agentId !== "string" || body.agentId.trim().length === 0) {
+    return { error: errorResponse(c, 400, "bad_request", "agentId must be a string") };
+  }
+  const request = {
+    agentId: body.agentId.trim()
+  };
+  if ("title" in body) {
+    if (typeof body.title !== "string") {
+      return { error: errorResponse(c, 400, "bad_request", "title must be a string") };
+    }
+    const title = body.title.trim();
+    if (title.length > 0) {
+      request.title = title;
+    }
+  }
+  if ("metadata" in body) {
+    if (!isJsonObject(body.metadata)) {
+      return { error: errorResponse(c, 400, "bad_request", "metadata must be an object") };
+    }
+    request.metadata = body.metadata;
+  }
+  return request;
+}
+
+// src/runtime/trace-routes.ts
+function registerTraceRoutes(app, traceStore) {
+  app.get("/traces", async (c) => {
+    if (traceStore.listTraces === void 0) {
+      return errorResponse(
+        c,
+        501,
+        "unsupported_capability",
+        'Capability "traces.list" is not implemented by this runner',
+        { capability: "traces", operation: "list" }
+      );
+    }
+    const limit = parseLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
+    }
+    const status = parseTraceStatus(c.req.query("status"));
+    if (status === false) {
+      return errorResponse(c, 400, "bad_request", "status must be running, success, or error");
+    }
+    const agentId = optionalQueryString(c.req.query("agentId"));
+    const sessionId = optionalQueryString(c.req.query("sessionId"));
+    const traces = await traceStore.listTraces({
+      limit,
+      ...agentId === void 0 ? {} : { agentId },
+      ...sessionId === void 0 ? {} : { sessionId },
+      ...status === void 0 ? {} : { status }
+    });
+    return c.json({ traces });
+  });
+  app.get("/traces/:traceId", async (c) => {
+    const trace = await traceStore.getTrace(c.req.param("traceId"));
+    if (trace === void 0) {
+      return errorResponse(c, 404, "not_found", "Trace not found");
+    }
+    return c.json(trace);
+  });
+}
+
+// src/runtime/studio.ts
+var Studio = class {
+  options;
+  studio;
+  server;
+  sigintHandler;
+  constructor(agents = [], options = {}) {
+    this.options = studioOptionsFromAgents(agents, options);
+    this.studio = createStudioApp(this.options);
+  }
+  get app() {
+    return this.studio.app;
+  }
+  fetch(request) {
+    return this.studio.fetch(request);
+  }
+  config() {
+    return this.studio.config();
+  }
+  traceObserver() {
+    return new StudioTraceObserver({
+      store: () => this.studio.traceStore
+    });
+  }
+  start(serveOptions = {}) {
+    this.close();
+    this.studio = createStudioApp(this.options);
+    const port = serveOptions.port ?? Number(process.env.RUNNER_PORT ?? 4021);
+    this.server = serve({
+      fetch: (request) => this.fetch(request),
+      ...serveOptions.hostname === void 0 ? {} : { hostname: serveOptions.hostname },
+      port
+    });
+    const log = serveOptions.log ?? true;
+    if (log) {
+      const host = serveOptions.hostname ?? "localhost";
+      if (isStudioUiEnabled(this.options.ui)) {
+        const uiPath = studioUiEntryPath(resolveStudioUiOptions(this.options.ui));
+        console.log(`Studio UI: http://${host}:${port}${uiPath}`);
+      } else {
+        console.log(`Studio API: http://${host}:${port}`);
+      }
+    }
+    this.sigintHandler = () => {
+      this.close();
+      process.exit(0);
+    };
+    process.once("SIGINT", this.sigintHandler);
+    return this;
+  }
+  close() {
+    if (this.sigintHandler !== void 0) {
+      process.off("SIGINT", this.sigintHandler);
+      this.sigintHandler = void 0;
+    }
+    this.server?.close();
+    this.server = void 0;
+    this.studio.close();
+  }
+};
+function studioOptionsFromAgents(agents, options) {
+  return {
+    agents: inferStudioAgents(agents, options.quickPrompts ?? {})
+  };
+}
+function inferStudioAgents(agents, quickPrompts) {
+  const ids = /* @__PURE__ */ new Set();
+  return agents.map((agent) => {
+    const id = uniqueAgentId(agent.id, ids);
+    return {
+      id,
+      agent,
+      quickPrompts: quickPrompts[id] ?? [],
+      metadata: agentMetadata(agent)
+    };
+  });
+}
+function uniqueAgentId(baseId, ids) {
+  let id = baseId;
+  let suffix = 2;
+  while (ids.has(id)) {
+    id = `${baseId}-${suffix}`;
+    suffix += 1;
+  }
+  ids.add(id);
+  return id;
+}
+function agentMetadata(agent) {
+  return {
+    ...agent.defaultMaxTurns === void 0 ? {} : { defaultMaxTurns: agent.defaultMaxTurns },
+    staticContextCount: agent.staticContext.length,
+    dynamicContextCount: agent.dynamicContexts.length,
+    dynamicToolCount: agent.dynamicTools.length,
+    hasOutputSchema: agent.outputSchema !== void 0,
+    observerCount: agent.observers.length,
+    approvalToolCount: agent.toolSet.values().filter((tool) => tool.approval !== void 0).length
+  };
+}
+function createStudioApp(options) {
+  const stores = resolveStores(options);
+  const agents = normalizeAgents(options.agents).map(
+    (agent) => withStudioTraceObserver(agent, stores.traces)
+  );
+  const agentMap = new Map(agents.map((agent) => [agent.id, agent]));
+  const approvalRuntime = createApprovalRuntime();
+  const questionRuntime = createQuestionRuntime();
+  const app = new HonoApp();
+  const uiOptions = isStudioUiEnabled(options.ui) ? resolveStudioUiOptions(options.ui) : void 0;
+  if (uiOptions !== void 0 && !uiOptions.protectShell) {
+    registerStudioUi(app, uiOptions);
+  }
+  if (uiOptions?.protectShell) {
+    registerStudioUi(app, uiOptions);
+  }
+  app.get(
+    "/health",
+    (c) => c.json({
+      status: "ok",
+      runner: {
+        id: runnerId(options),
+        name: options.name,
+        version: options.version
+      }
+    })
+  );
+  app.get("/config", (c) => c.json(buildConfig(options, agents, stores)));
+  app.get("/agents", (c) => c.json({ agents: agents.map(agentConfig) }));
+  app.get("/agents/:agentId", (c) => {
+    const agent = agentMap.get(c.req.param("agentId"));
+    if (agent === void 0) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    return c.json(agentConfig(agent));
+  });
+  registerApprovalRoutes(app, approvalRuntime);
+  registerQuestionRoutes(app, questionRuntime);
+  registerKnowledgeRoutes(app, {
+    agents,
+    ...stores.traces === void 0 ? {} : { traceStore: stores.traces }
+  });
+  app.post("/agents/:agentId/runs", async (c) => {
+    const agentId = c.req.param("agentId");
+    const agent = agentMap.get(agentId);
+    if (agent === void 0) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    const body = await parseRunRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    if (body.sessionId !== void 0 && stores.sessions === void 0) {
+      return unsupportedCapability(c, "sessions");
+    }
+    const session = body.sessionId === void 0 ? void 0 : await stores.sessions?.getSession(body.sessionId);
+    if (body.sessionId !== void 0 && session === void 0) {
+      return errorResponse(c, 404, "not_found", "Session not found");
+    }
+    if (session !== void 0 && session.agentId !== agentId) {
+      return errorResponse(c, 400, "bad_request", "Session belongs to another agent");
+    }
+    const runId = globalThis.crypto.randomUUID();
+    const request = agent.agent.prompt(body.message);
+    if (session !== void 0) {
+      request.withHistory(session.messages);
+    } else if (body.history !== void 0) {
+      request.withHistory(body.history);
+    }
+    if (body.maxTurns !== void 0) {
+      request.maxTurns(body.maxTurns);
+    }
+    if (body.toolConcurrency !== void 0) {
+      request.withToolConcurrency(body.toolConcurrency);
+    }
+    if (body.trace !== void 0) {
+      request.withTrace(traceForRun(body.trace, agentId, session));
+    } else if (session !== void 0) {
+      request.withTrace(traceForRun(void 0, agentId, session));
+    }
+    if (body.stream === true) {
+      const runtimeEvents = new AsyncEventQueue();
+      const effectiveHook = composeHooks(
+        composeHooks(
+          agent.agent.hook,
+          approvalRuntime.createHook({
+            runId,
+            agentId,
+            ...session?.id === void 0 ? {} : { sessionId: session.id },
+            ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+            getTool: (toolName) => agent.agent.getTool(toolName),
+            emit: (event) => runtimeEvents.push(event)
+          })
+        ),
+        questionRuntime.createHook({
+          runId,
+          agentId,
+          ...session?.id === void 0 ? {} : { sessionId: session.id },
+          ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+          emit: (event) => runtimeEvents.push(event)
+        })
+      );
+      if (effectiveHook !== void 0) {
+        request.requestHook(effectiveHook);
+      }
+      const runStream = mergeRunAndApprovalEvents(request.stream(), runtimeEvents);
+      const stream = session === void 0 || stores.sessions === void 0 ? runStream : persistStreamingSessionRun({
+        stream: runStream,
+        store: stores.sessions,
+        session,
+        message: body.message
+      });
+      return streamAgentRunEvents(c, stream);
+    }
+    try {
+      const effectiveHook = composeHooks(
+        composeHooks(
+          agent.agent.hook,
+          approvalRuntime.createHook({
+            runId,
+            agentId,
+            ...session?.id === void 0 ? {} : { sessionId: session.id },
+            ...body.metadata === void 0 ? {} : { metadata: body.metadata },
+            getTool: (toolName) => agent.agent.getTool(toolName)
+          })
+        ),
+        questionRuntime.createHook({
+          runId,
+          agentId,
+          ...session?.id === void 0 ? {} : { sessionId: session.id },
+          ...body.metadata === void 0 ? {} : { metadata: body.metadata }
+        })
+      );
+      if (effectiveHook !== void 0) {
+        request.requestHook(effectiveHook);
+      }
+      const response = await request.send();
+      if (session !== void 0 && stores.sessions !== void 0) {
+        await stores.sessions.appendSessionRun({
+          id: session.id,
+          ...optionalTitle(body.message),
+          messages: response.messages,
+          transcript: transcriptFromMessages(response.messages)
+        });
+      }
+      return c.json(response);
+    } catch (error) {
+      return errorResponse(c, 500, "internal_error", "Agent run failed", serializeError2(error));
+    }
+  });
+  if (stores.sessions !== void 0) {
+    registerSessionRoutes(app, {
+      agentMap,
+      sessionStore: stores.sessions,
+      ...stores.traces === void 0 ? {} : { traceStore: stores.traces }
+    });
+  }
+  if (stores.traces !== void 0) {
+    registerTraceRoutes(app, stores.traces);
+  }
+  for (const capability of unsupportedCapabilities(stores)) {
+    app.all(`/${capability}`, (c) => unsupportedCapability(c, capability));
+    app.all(`/${capability}/*`, (c) => unsupportedCapability(c, capability));
+  }
+  return {
+    app,
+    fetch(request) {
+      return app.fetch(request);
+    },
+    config() {
+      return buildConfig(options, agents, stores);
+    },
+    close() {
+    },
+    ...stores.sessions === void 0 ? {} : { sessionStore: stores.sessions },
+    ...stores.traces === void 0 ? {} : { traceStore: stores.traces }
+  };
+}
+function withStudioTraceObserver(studioAgent, traceStore) {
+  if (traceStore === void 0 || hasStudioTraceObserver(studioAgent.agent)) {
+    return studioAgent;
+  }
+  return {
+    ...studioAgent,
+    agent: new Agent({
+      id: studioAgent.agent.id,
+      name: studioAgent.agent.name,
+      description: studioAgent.agent.description,
+      model: studioAgent.agent.model,
+      instructions: studioAgent.agent.instructions,
+      staticContext: studioAgent.agent.staticContext,
+      temperature: studioAgent.agent.temperature,
+      maxTokens: studioAgent.agent.maxTokens,
+      additionalParams: studioAgent.agent.additionalParams,
+      toolSet: studioAgent.agent.toolSet,
+      toolChoice: studioAgent.agent.toolChoice,
+      defaultMaxTurns: studioAgent.agent.defaultMaxTurns,
+      hook: studioAgent.agent.hook,
+      outputSchema: studioAgent.agent.outputSchema,
+      observers: [
+        ...studioAgent.agent.observers,
+        { observer: new StudioTraceObserver({ store: traceStore }) }
+      ],
+      dynamicContexts: studioAgent.agent.dynamicContexts,
+      dynamicTools: studioAgent.agent.dynamicTools
+    })
+  };
+}
+function hasStudioTraceObserver(agent) {
+  return agent.observers.some(
+    (registration) => registration.observer instanceof StudioTraceObserver
+  );
+}
+function composeHooks(first, second) {
+  if (first === void 0) {
+    return second;
+  }
+  if (second === void 0) {
+    return first;
+  }
+  return createHook3({
+    async onCompletionCall(args) {
+      const firstAction = await first.onCompletionCall?.(args);
+      return firstAction?.type === "terminate" ? firstAction : await second.onCompletionCall?.(args) ?? void 0;
+    },
+    async onCompletionResponse(args) {
+      const firstAction = await first.onCompletionResponse?.(args);
+      return firstAction?.type === "terminate" ? firstAction : await second.onCompletionResponse?.(args) ?? void 0;
+    },
+    async onToolCall(args) {
+      const firstAction = await first.onToolCall?.(args);
+      if (firstAction?.type === "skip" || firstAction?.type === "terminate") {
+        return firstAction;
+      }
+      const secondAction = await second.onToolCall?.(args);
+      return secondAction ?? firstAction ?? void 0;
+    },
+    async onToolResult(args) {
+      const firstAction = await first.onToolResult?.(args);
+      return firstAction?.type === "terminate" ? firstAction : await second.onToolResult?.(args) ?? void 0;
+    }
+  });
+}
+export {
+  Studio,
+  StudioTraceObserver,
+  createSqliteSessionStore
+};
+//# sourceMappingURL=index.js.map