@anvia/studio 0.1.2 → 0.2.0

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   Agent,
   createHook as createHook3,
   Message,
+  Pipeline,
   resolveMemoryOptions
 } from "@anvia/core";
 import { serve } from "@hono/node-server";
@@ -692,12 +693,15 @@ var SqliteSessionStore = class {
   db;
   listSessions(options) {
     const db = this.database();
-    const agentClause = options.agentId === void 0 ? "" : "WHERE agent_id = $agentId";
+    const agentClause = options.agentId === void 0 ? "" : "WHERE s.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
+      `SELECT s.id, s.agent_id, s.title, s.metadata_json, s.created_at, s.updated_at,
+                COUNT(m.message_index) AS message_count
+         FROM runner_sessions s
+         LEFT JOIN runner_session_messages m ON m.session_id = s.id
          ${agentClause}
-         ORDER BY updated_at DESC
+         GROUP BY s.id, s.agent_id, s.title, s.metadata_json, s.created_at, s.updated_at
+         ORDER BY s.updated_at DESC
          LIMIT $limit`
     ).all({
       $agentId: options.agentId ?? null,
@@ -714,11 +718,9 @@ var SqliteSessionStore = class {
         agent_id,
         title,
         metadata_json,
-        messages_json,
-        transcript_json,
         created_at,
         updated_at
-      ) VALUES ($id, $agentId, $title, $metadata, '[]', '[]', $now, $now)`
+      ) VALUES ($id, $agentId, $title, $metadata, $now, $now)`
     ).run({
       $id: input.id,
       $agentId: input.agentId,
@@ -738,7 +740,7 @@ var SqliteSessionStore = class {
   }
   getSession(id) {
     const row = this.getSessionRow(id);
-    return row === void 0 ? void 0 : toSession(row, this.listSessionRunRows(id));
+    return row === void 0 ? void 0 : toSession(row, this.listSessionMessages(id), this.listSessionRunRows(id));
   }
   load(context) {
     const session = this.getSession(context.sessionId);
@@ -749,7 +751,7 @@ var SqliteSessionStore = class {
     try {
       db.exec("BEGIN IMMEDIATE");
       const row = db.prepare(
-        `SELECT id, agent_id, title, metadata_json, messages_json, transcript_json, created_at, updated_at
+        `SELECT id, agent_id, title, metadata_json, created_at, updated_at
            FROM runner_sessions
            WHERE id = $id`
       ).get({ $id: input.context.sessionId });
@@ -757,17 +759,15 @@ var SqliteSessionStore = class {
         db.exec("ROLLBACK");
         return Promise.resolve();
       }
-      const current = toSession(row);
-      const messages = [...current.messages, ...input.messages];
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const nextIndex = this.nextMessageIndex(input.context.sessionId);
+      this.insertMessages(input.context.sessionId, input.messages, nextIndex, updatedAt);
       db.prepare(
         `UPDATE runner_sessions
-         SET messages_json = $messages,
-             updated_at = $updatedAt
+         SET updated_at = $updatedAt
          WHERE id = $id`
       ).run({
         $id: input.context.sessionId,
-        $messages: JSON.stringify(messages),
         $updatedAt: updatedAt
       });
       db.exec("COMMIT");
@@ -786,14 +786,15 @@ var SqliteSessionStore = class {
       db.exec("BEGIN IMMEDIATE");
       db.prepare(
         `UPDATE runner_sessions
-         SET messages_json = '[]',
-             transcript_json = '[]',
-             updated_at = $updatedAt
+         SET updated_at = $updatedAt
          WHERE id = $id`
       ).run({
         $id: context.sessionId,
         $updatedAt: updatedAt
       });
+      db.prepare("DELETE FROM runner_session_messages WHERE session_id = $id").run({
+        $id: context.sessionId
+      });
       db.prepare("DELETE FROM runner_session_runs WHERE session_id = $id").run({
         $id: context.sessionId
       });
@@ -828,7 +829,11 @@ var SqliteSessionStore = class {
         db.exec("ROLLBACK");
         return void 0;
       }
-      const current = toSession(row, this.listSessionRunRows(input.id));
+      const current = toSession(
+        row,
+        this.listSessionMessages(input.id),
+        this.listSessionRunRows(input.id)
+      );
       const title = current.title ?? input.title;
       db.prepare(
         `INSERT INTO runner_session_runs (
@@ -885,12 +890,179 @@ var SqliteSessionStore = class {
       throw error;
     }
   }
+  appendSessionLog(input) {
+    const db = this.database();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      const row = this.getSessionRow(input.sessionId);
+      if (row === void 0) {
+        throw new Error("Session not found");
+      }
+      const sequence = this.nextSessionLogSequence(input.sessionId);
+      const entry = {
+        id: globalThis.crypto.randomUUID(),
+        sessionId: input.sessionId,
+        ...input.runId === void 0 ? {} : { runId: input.runId },
+        sequence,
+        timestamp: now,
+        level: input.level,
+        category: input.category,
+        event: input.event,
+        message: input.message,
+        ...input.metadata === void 0 ? {} : { metadata: input.metadata }
+      };
+      db.prepare(
+        `INSERT INTO runner_session_logs (
+          id,
+          session_id,
+          run_id,
+          sequence,
+          timestamp,
+          level,
+          category,
+          event,
+          message,
+          metadata_json
+        ) VALUES (
+          $id,
+          $sessionId,
+          $runId,
+          $sequence,
+          $timestamp,
+          $level,
+          $category,
+          $event,
+          $message,
+          $metadata
+        )`
+      ).run({
+        $id: entry.id,
+        $sessionId: entry.sessionId,
+        $runId: entry.runId ?? null,
+        $sequence: entry.sequence,
+        $timestamp: entry.timestamp,
+        $level: entry.level,
+        $category: entry.category,
+        $event: entry.event,
+        $message: entry.message,
+        $metadata: entry.metadata === void 0 ? null : JSON.stringify(entry.metadata)
+      });
+      db.exec("COMMIT");
+      return entry;
+    } catch (error) {
+      if (db.isTransaction) {
+        db.exec("ROLLBACK");
+      }
+      throw error;
+    }
+  }
+  listSessionLogs(options) {
+    const db = this.database();
+    const afterClause = options.after === void 0 ? "" : "AND sequence > $after";
+    const rows = db.prepare(
+      `SELECT id, session_id, run_id, sequence, timestamp, level, category, event, message,
+                metadata_json
+         FROM runner_session_logs
+         WHERE session_id = $sessionId
+         ${afterClause}
+         ORDER BY sequence ASC
+         LIMIT $limit`
+    ).all({
+      $sessionId: options.sessionId,
+      $after: options.after ?? null,
+      $limit: options.limit
+    });
+    return rows.map(toSessionLog);
+  }
+  appendPipelineLog(input) {
+    const db = this.database();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      const sequence = this.nextPipelineLogSequence(input.pipelineId);
+      const entry = {
+        id: globalThis.crypto.randomUUID(),
+        pipelineId: input.pipelineId,
+        ...input.runId === void 0 ? {} : { runId: input.runId },
+        sequence,
+        timestamp: now,
+        level: input.level,
+        category: input.category,
+        event: input.event,
+        message: input.message,
+        ...input.metadata === void 0 ? {} : { metadata: input.metadata }
+      };
+      db.prepare(
+        `INSERT INTO runner_pipeline_logs (
+          id,
+          pipeline_id,
+          run_id,
+          sequence,
+          timestamp,
+          level,
+          category,
+          event,
+          message,
+          metadata_json
+        ) VALUES (
+          $id,
+          $pipelineId,
+          $runId,
+          $sequence,
+          $timestamp,
+          $level,
+          $category,
+          $event,
+          $message,
+          $metadata
+        )`
+      ).run({
+        $id: entry.id,
+        $pipelineId: entry.pipelineId,
+        $runId: entry.runId ?? null,
+        $sequence: entry.sequence,
+        $timestamp: entry.timestamp,
+        $level: entry.level,
+        $category: entry.category,
+        $event: entry.event,
+        $message: entry.message,
+        $metadata: entry.metadata === void 0 ? null : JSON.stringify(entry.metadata)
+      });
+      db.exec("COMMIT");
+      return entry;
+    } catch (error) {
+      if (db.isTransaction) {
+        db.exec("ROLLBACK");
+      }
+      throw error;
+    }
+  }
+  listPipelineLogs(options) {
+    const db = this.database();
+    const afterClause = options.after === void 0 ? "" : "AND sequence > $after";
+    const rows = db.prepare(
+      `SELECT id, pipeline_id, run_id, sequence, timestamp, level, category, event, message,
+                metadata_json
+         FROM runner_pipeline_logs
+         WHERE pipeline_id = $pipelineId
+         ${afterClause}
+         ORDER BY sequence ASC
+         LIMIT $limit`
+    ).all({
+      $pipelineId: options.pipelineId,
+      $after: options.after ?? null,
+      $limit: options.limit
+    });
+    return rows.map(toPipelineLog);
+  }
   deleteSession(id) {
     const db = this.database();
     try {
       db.exec("BEGIN IMMEDIATE");
       db.prepare("DELETE FROM runner_traces WHERE session_id = $id").run({ $id: id });
       db.prepare("DELETE FROM runner_session_runs WHERE session_id = $id").run({ $id: id });
+      db.prepare("DELETE FROM runner_session_logs 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;
@@ -1039,18 +1211,41 @@ var SqliteSessionStore = class {
     db.exec(`
       PRAGMA journal_mode = WAL;
       PRAGMA foreign_keys = ON;
+    `);
+    guardAgainstLegacySessionSchema(db);
+    db.exec(`
       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_session_messages (
+        session_id TEXT NOT NULL,
+        message_index INTEGER NOT NULL,
+        role TEXT NOT NULL,
+        message_id TEXT,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY(session_id, message_index),
+        FOREIGN KEY(session_id) REFERENCES runner_sessions(id) ON DELETE CASCADE
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_session_messages_session_idx
+        ON runner_session_messages(session_id, message_index ASC);
+      CREATE TABLE IF NOT EXISTS runner_session_message_parts (
+        session_id TEXT NOT NULL,
+        message_index INTEGER NOT NULL,
+        part_index INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        part_json TEXT NOT NULL,
+        PRIMARY KEY(session_id, message_index, part_index),
+        FOREIGN KEY(session_id, message_index)
+          REFERENCES runner_session_messages(session_id, message_index)
+          ON DELETE CASCADE
+      ) STRICT;
       CREATE TABLE IF NOT EXISTS runner_session_runs (
         run_id TEXT PRIMARY KEY,
         session_id TEXT NOT NULL,
@@ -1064,6 +1259,37 @@ var SqliteSessionStore = class {
       ) STRICT;
       CREATE INDEX IF NOT EXISTS runner_session_runs_session_created_idx
         ON runner_session_runs(session_id, created_at ASC);
+      CREATE TABLE IF NOT EXISTS runner_session_logs (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        run_id TEXT,
+        sequence INTEGER NOT NULL,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        category TEXT NOT NULL,
+        event TEXT NOT NULL,
+        message TEXT NOT NULL,
+        metadata_json TEXT,
+        UNIQUE(session_id, sequence),
+        FOREIGN KEY(session_id) REFERENCES runner_sessions(id) ON DELETE CASCADE
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_session_logs_session_sequence_idx
+        ON runner_session_logs(session_id, sequence ASC);
+      CREATE TABLE IF NOT EXISTS runner_pipeline_logs (
+        id TEXT PRIMARY KEY,
+        pipeline_id TEXT NOT NULL,
+        run_id TEXT,
+        sequence INTEGER NOT NULL,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        category TEXT NOT NULL,
+        event TEXT NOT NULL,
+        message TEXT NOT NULL,
+        metadata_json TEXT,
+        UNIQUE(pipeline_id, sequence)
+      ) STRICT;
+      CREATE INDEX IF NOT EXISTS runner_pipeline_logs_pipeline_sequence_idx
+        ON runner_pipeline_logs(pipeline_id, sequence ASC);
       CREATE TABLE IF NOT EXISTS runner_traces (
         id TEXT PRIMARY KEY,
         session_id TEXT NOT NULL,
@@ -1088,7 +1314,7 @@ var SqliteSessionStore = class {
   }
   getSessionRow(id) {
     return this.database().prepare(
-      `SELECT id, agent_id, title, metadata_json, messages_json, transcript_json, created_at, updated_at
+      `SELECT id, agent_id, title, metadata_json, created_at, updated_at
          FROM runner_sessions
          WHERE id = $id`
     ).get({ $id: id });
@@ -1108,21 +1334,110 @@ var SqliteSessionStore = class {
          ORDER BY created_at ASC`
     ).all({ $sessionId: sessionId });
   }
+  nextSessionLogSequence(sessionId) {
+    const row = this.database().prepare(
+      `SELECT COALESCE(MAX(sequence) + 1, 0) AS next_sequence
+         FROM runner_session_logs
+         WHERE session_id = $sessionId`
+    ).get({ $sessionId: sessionId });
+    return row.next_sequence;
+  }
+  nextPipelineLogSequence(pipelineId) {
+    const row = this.database().prepare(
+      `SELECT COALESCE(MAX(sequence) + 1, 0) AS next_sequence
+         FROM runner_pipeline_logs
+         WHERE pipeline_id = $pipelineId`
+    ).get({ $pipelineId: pipelineId });
+    return row.next_sequence;
+  }
+  listSessionMessages(sessionId) {
+    const db = this.database();
+    const messageRows = db.prepare(
+      `SELECT session_id, message_index, role, message_id, created_at
+         FROM runner_session_messages
+         WHERE session_id = $sessionId
+         ORDER BY message_index ASC`
+    ).all({ $sessionId: sessionId });
+    if (messageRows.length === 0) {
+      return [];
+    }
+    const partRows = db.prepare(
+      `SELECT session_id, message_index, part_index, type, part_json
+         FROM runner_session_message_parts
+         WHERE session_id = $sessionId
+         ORDER BY message_index ASC, part_index ASC`
+    ).all({ $sessionId: sessionId });
+    const partsByMessage = /* @__PURE__ */ new Map();
+    for (const partRow of partRows) {
+      const parts = partsByMessage.get(partRow.message_index) ?? [];
+      parts.push(partRow);
+      partsByMessage.set(partRow.message_index, parts);
+    }
+    return messageRows.map(
+      (row) => messageFromRows(row, partsByMessage.get(row.message_index) ?? [])
+    );
+  }
+  nextMessageIndex(sessionId) {
+    const row = this.database().prepare(
+      `SELECT COALESCE(MAX(message_index) + 1, 0) AS next_index
+         FROM runner_session_messages
+         WHERE session_id = $sessionId`
+    ).get({ $sessionId: sessionId });
+    return row.next_index;
+  }
+  insertMessages(sessionId, messages, startIndex, createdAt) {
+    const db = this.database();
+    const insertMessage = db.prepare(
+      `INSERT INTO runner_session_messages (
+        session_id,
+        message_index,
+        role,
+        message_id,
+        created_at
+      ) VALUES ($sessionId, $messageIndex, $role, $messageId, $createdAt)`
+    );
+    const insertPart = db.prepare(
+      `INSERT INTO runner_session_message_parts (
+        session_id,
+        message_index,
+        part_index,
+        type,
+        part_json
+      ) VALUES ($sessionId, $messageIndex, $partIndex, $type, $partJson)`
+    );
+    messages.forEach((message, messageOffset) => {
+      const messageIndex = startIndex + messageOffset;
+      insertMessage.run({
+        $sessionId: sessionId,
+        $messageIndex: messageIndex,
+        $role: message.role,
+        $messageId: message.role === "assistant" ? message.id ?? null : null,
+        $createdAt: createdAt
+      });
+      messageParts(message).forEach((part, partIndex) => {
+        insertPart.run({
+          $sessionId: sessionId,
+          $messageIndex: messageIndex,
+          $partIndex: partIndex,
+          $type: part.type,
+          $partJson: JSON.stringify(part.value)
+        });
+      });
+    });
+  }
 };
-function toSession(row, runRows = []) {
-  const summary = toSessionSummary(row);
-  const legacyTranscript = parseJsonArray(row.transcript_json);
+function toSession(row, messages, runRows = []) {
+  const summary = toSessionSummary({ ...row, message_count: messages.length });
   const runTranscript = runRows.flatMap(
     (runRow) => parseJsonArray(runRow.transcript_json)
   );
   return {
     ...summary,
-    messages: parseJsonArray(row.messages_json),
-    transcript: renumberTranscript([...legacyTranscript, ...runTranscript])
+    messages,
+    transcript: renumberTranscript(runTranscript)
   };
 }
 function toSessionSummary(row) {
-  const messages = parseJsonArray(row.messages_json);
   const metadata = parseJsonValue(row.metadata_json);
   return {
     id: row.id,
@@ -1130,10 +1445,90 @@ function toSessionSummary(row) {
     ...row.title === null ? {} : { title: row.title },
     createdAt: row.created_at,
     updatedAt: row.updated_at,
-    messageCount: messages.length,
+    messageCount: row.message_count,
+    ...metadata === void 0 ? {} : { metadata }
+  };
+}
+function toSessionLog(row) {
+  const metadata = parseJsonValue(row.metadata_json);
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    ...row.run_id === null ? {} : { runId: row.run_id },
+    sequence: row.sequence,
+    timestamp: row.timestamp,
+    level: row.level,
+    category: row.category,
+    event: row.event,
+    message: row.message,
+    ...metadata === void 0 ? {} : { metadata }
+  };
+}
+function toPipelineLog(row) {
+  const metadata = parseJsonValue(row.metadata_json);
+  return {
+    id: row.id,
+    pipelineId: row.pipeline_id,
+    ...row.run_id === null ? {} : { runId: row.run_id },
+    sequence: row.sequence,
+    timestamp: row.timestamp,
+    level: row.level,
+    category: row.category,
+    event: row.event,
+    message: row.message,
     ...metadata === void 0 ? {} : { metadata }
   };
 }
+function messageParts(message) {
+  if (message.role === "system") {
+    return [{ type: "text", value: { type: "text", text: message.content } }];
+  }
+  return message.content.map((content) => ({
+    type: content.type,
+    value: content
+  }));
+}
+function messageFromRows(row, partRows) {
+  const parts = partRows.map((partRow) => JSON.parse(partRow.part_json));
+  if (row.role === "system") {
+    return { role: "system", content: systemContentFromParts(parts) };
+  }
+  if (row.role === "user") {
+    return {
+      role: "user",
+      content: parts
+    };
+  }
+  if (row.role === "assistant") {
+    return {
+      role: "assistant",
+      ...row.message_id === null ? {} : { id: row.message_id },
+      content: parts
+    };
+  }
+  if (row.role === "tool") {
+    return {
+      role: "tool",
+      content: parts
+    };
+  }
+  throw new Error(`Unsupported stored message role: ${row.role}`);
+}
+function systemContentFromParts(parts) {
+  const first = parts[0];
+  if (typeof first === "object" && first !== null && "type" in first && first.type === "text" && "text" in first && typeof first.text === "string") {
+    return first.text;
+  }
+  return "";
+}
+function guardAgainstLegacySessionSchema(db) {
+  const columns = db.prepare("PRAGMA table_info('runner_sessions')").all();
+  if (columns.some((column) => column.name === "messages_json")) {
+    throw new Error(
+      "Existing Studio SQLite DB uses the legacy messages_json schema. Delete or recreate the Studio SQLite DB to use normalized session messages."
+    );
+  }
+}
 function toTrace(row) {
   const trace = parseJsonValue(row.trace_json);
   const input = parseJsonValue(row.input_json);
@@ -1268,15 +1663,56 @@ function formatJson(value) {
   }
 }
 
+// src/runtime/tool-metadata.ts
+import { ToolSet } from "@anvia/core";
+var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
+function agentToolItems(agent) {
+  return [
+    ...agent.agent.toolSet.values().map((tool) => ({ tool, source: "static" })),
+    ...agent.agent.dynamicTools.flatMap((registration) => {
+      const maybeToolSet = registration.index.toolSet;
+      if (!(maybeToolSet instanceof ToolSet)) {
+        return [];
+      }
+      return maybeToolSet.values().map((tool) => ({ tool, source: "dynamic" }));
+    })
+  ];
+}
+function approvalMetadata(tool) {
+  const approval = tool.approval;
+  if (approval === void 0 || typeof approval !== "object" || approval === null) {
+    return { required: false };
+  }
+  const policy = approval;
+  return {
+    required: true,
+    ...typeof policy.reason === "string" ? { reason: policy.reason } : {},
+    ...typeof policy.rejectMessage === "string" ? { rejectMessage: policy.rejectMessage } : {}
+  };
+}
+function mcpServerName(tool) {
+  const metadata = tool[MCP_TOOL_METADATA_KEY];
+  if (typeof metadata !== "object" || metadata === null) {
+    return void 0;
+  }
+  const serverName = metadata.serverName;
+  return typeof serverName === "string" && serverName.length > 0 ? serverName : void 0;
+}
+function agentHasMcpTools(agent) {
+  return agentToolItems(agent).some(({ tool }) => mcpServerName(tool) !== void 0);
+}
+
 // 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);
+  const pipelineLogs = resolvePipelineLogStore(options, sessions, defaultStore);
   return {
     ...sessions === void 0 ? {} : { sessions },
-    ...traces === void 0 ? {} : { traces }
+    ...traces === void 0 ? {} : { traces },
+    ...pipelineLogs === void 0 ? {} : { pipelineLogs }
   };
 }
 function resolveSessionStore(options, defaultStore) {
@@ -1300,10 +1736,26 @@ function resolveTraceStore(options, sessionStore, defaultStore) {
   }
   return defaultStore;
 }
+function resolvePipelineLogStore(options, sessionStore, defaultStore) {
+  if (options.stores?.pipelineLogs === false) {
+    return void 0;
+  }
+  if (options.stores?.pipelineLogs !== void 0) {
+    return options.stores.pipelineLogs;
+  }
+  if (sessionStore !== void 0 && isPipelineLogStore(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 isPipelineLogStore(store) {
+  const candidate = store;
+  return typeof candidate.appendPipelineLog === "function" && typeof candidate.listPipelineLogs === "function";
+}
 function unsupportedCapabilities(stores) {
   return [
     ...stores.sessions === void 0 ? ["sessions"] : [],
@@ -1324,17 +1776,32 @@ function normalizeAgents(agents) {
     return { ...agent, id };
   });
 }
-function buildConfig(options, agents, stores) {
+function normalizePipelines(pipelines) {
+  const ids = /* @__PURE__ */ new Set();
+  return pipelines.map((pipeline) => {
+    const id = pipeline.id.trim();
+    if (id.length === 0) {
+      throw new Error("Studio pipeline id cannot be empty");
+    }
+    if (ids.has(id)) {
+      throw new Error(`Duplicate Studio pipeline id: ${id}`);
+    }
+    ids.add(id);
+    return { ...pipeline, id };
+  });
+}
+function buildConfig(options, agents, pipelines, 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),
+    pipelines: pipelines.map(pipelineConfig),
     chat: {
       quickPrompts: Object.fromEntries(agents.map((agent) => [agent.id, agent.quickPrompts ?? []]))
     },
-    capabilities: capabilityConfig(options, agents, stores),
+    capabilities: capabilityConfig(options, agents, pipelines, stores),
     unsupportedCapabilities: unsupportedCapabilities(stores)
   };
 }
@@ -1352,7 +1819,22 @@ function agentConfig(agent) {
     ...agent.metadata === void 0 ? {} : { metadata: agent.metadata }
   };
 }
-function capabilityConfig(_options, agents, stores) {
+function pipelineConfig(pipeline) {
+  const graph = pipeline.pipeline.graph();
+  const stageNodes = graph.nodes.filter((node) => node.kind !== "input" && node.kind !== "output");
+  return {
+    id: pipeline.id,
+    ...pipeline.name === void 0 ? {} : { name: pipeline.name },
+    ...pipeline.description === void 0 ? {} : { description: pipeline.description },
+    ...pipeline.metadata === void 0 ? {} : { metadata: pipeline.metadata },
+    stageCount: stageNodes.length,
+    edgeCount: graph.edges.length,
+    hasParallelStages: graph.nodes.some((node) => node.kind === "parallel"),
+    agentCount: graph.nodes.filter((node) => node.kind === "agent").length,
+    extractorCount: graph.nodes.filter((node) => node.kind === "extractor").length
+  };
+}
+function capabilityConfig(_options, agents, pipelines, stores) {
   const capabilities = {
     agents: { enabled: true }
   };
@@ -1362,10 +1844,23 @@ function capabilityConfig(_options, agents, stores) {
   if (stores.traces !== void 0) {
     capabilities.traces = { enabled: true };
   }
+  if (pipelines.length > 0) {
+    capabilities.pipelines = { enabled: true };
+  }
+  if (agents.some(
+    (agent) => agent.agent.toolSet.values().length > 0 || agent.agent.dynamicTools.length > 0
+  )) {
+    capabilities.tools = { enabled: true };
+  }
+  if (agents.some(agentHasMcpTools)) {
+    capabilities.mcps = { 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))) {
+  if (agents.some(
+    (agent) => agent.agent.hook !== void 0 || agent.agent.toolSet.values().some((tool) => tool.approval)
+  )) {
     capabilities.approvals = { enabled: true };
   }
   if (agents.some(
@@ -1560,45 +2055,62 @@ function createApprovalRuntime() {
   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 handleApprovalRequest = async ({ toolName, toolCallId, internalCallId, args, tool: control }, request) => {
+        const decision = await requestApproval(approvals, context, {
+          toolName,
+          ...toolCallId === void 0 ? {} : { toolCallId },
+          internalCallId,
+          args,
+          ...request.reason === void 0 ? {} : { reason: request.reason },
+          ...request.rejectMessage === void 0 ? {} : { rejectMessage: request.rejectMessage }
+        });
+        return decision.approved ? control.run() : control.skip(decision.reason ?? request.rejectMessage ?? "Rejected in Anvia Studio.");
+      };
+      return {
+        ...createHook({
+          async onToolCall({ toolName, toolCallId, internalCallId, args, tool: control }) {
+            const registeredTool = context.getTool(toolName);
+            if (registeredTool?.approval === void 0) {
+              return control.run();
             }
-          };
-          const required = await approval.when(approvalContext);
-          if (!required) {
-            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.");
           }
-          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.");
-        }
-      });
+        }),
+        handleApprovalRequest
+      };
     },
     list(options) {
       return [...approvals.values()].filter((approval) => {
@@ -1894,243 +2406,207 @@ function isRecord2(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;
+// src/runtime/mcps.ts
+function registerMcpRoutes(app, props) {
+  app.get("/agents/:agentId/mcps", async (c) => {
+    const agentId = c.req.param("agentId");
+    const agent = props.agentMap.get(agentId);
+    if (agent === void 0) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
     }
-    return c.json({ questions: questions.list(options) });
+    return c.json({
+      agentId,
+      servers: await agentMcpMetadata(agent)
+    });
   });
-  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");
+}
+async function agentMcpMetadata(agent) {
+  const servers = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const { tool, source } of agentToolItems(agent)) {
+    const serverName = mcpServerName(tool);
+    if (serverName === void 0) {
+      continue;
     }
-    if (result === "resolved") {
-      return errorResponse(c, 409, "conflict", "Question is already answered");
+    const definition = await tool.definition("");
+    const key = `${serverName}:${source}:${definition.name}`;
+    if (seen.has(key)) {
+      continue;
     }
-    return c.json(result);
-  });
-}
-function parseQuestionStatus(value) {
-  const status = optionalQueryString(value);
-  if (status === void 0) {
-    return void 0;
+    seen.add(key);
+    const tools = servers.get(serverName) ?? [];
+    tools.push({
+      name: definition.name,
+      description: definition.description,
+      parameters: definition.parameters,
+      source
+    });
+    servers.set(serverName, tools);
   }
-  return status === "pending" || status === "resolved" ? status : false;
+  return [...servers.entries()].map(([name, tools]) => {
+    const sortedTools = tools.sort((left, right) => {
+      if (left.source !== right.source) {
+        return left.source === "static" ? -1 : 1;
+      }
+      return left.name.localeCompare(right.name);
+    });
+    return {
+      agentId: agent.id,
+      name,
+      toolCount: sortedTools.length,
+      tools: sortedTools
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
 }
-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 } : {}
-    });
+
+// src/runtime/pipelines.ts
+import { stream as streamResponse2 } from "hono/streaming";
+
+// src/runtime/pipeline-logs.ts
+async function appendPipelineLog(store, input) {
+  return store?.appendPipelineLog(input);
+}
+async function* emitPipelineLog(store, input) {
+  const log = await appendPipelineLog(store, input);
+  if (log !== void 0) {
+    yield { type: "pipeline_log", log };
   }
-  return { answers };
 }
-function createQuestionRuntime() {
-  const questions = /* @__PURE__ */ new Map();
+function pipelineRunReceivedLog(props) {
   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);
-    }
+    pipelineId: props.pipeline.id,
+    runId: props.runId,
+    level: "info",
+    category: "api",
+    event: "pipeline.run_received",
+    message: "Pipeline run request received",
+    metadata: cleanMetadata({
+      stream: props.stream,
+      inputBytes: byteLength(formatUnknown(props.input)),
+      metadataKeys: Object.keys(props.metadata ?? {})
+    })
   };
 }
-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: () => {
-    }
+function pipelineRunStartedLog(pipeline, runId) {
+  const graph = pipeline.pipeline.graph();
+  return {
+    pipelineId: pipeline.id,
+    runId,
+    level: "info",
+    category: "run",
+    event: "pipeline.run_started",
+    message: "Pipeline run started",
+    metadata: cleanMetadata({
+      stageCount: graph.nodes.filter((node) => node.kind !== "input" && node.kind !== "output").length,
+      edgeCount: graph.edges.length
+    })
   };
-  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 pipelineRunCompletedLog(props) {
+  return {
+    pipelineId: props.pipelineId,
+    runId: props.runId,
+    level: "info",
+    category: "run",
+    event: "pipeline.run_completed",
+    message: "Pipeline run completed",
+    metadata: cleanMetadata({
+      durationMs: props.durationMs,
+      outputBytes: byteLength(formatUnknown(props.output))
+    })
+  };
 }
-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;
-  }
+function pipelineRunFailedLog(pipelineId, runId, error, startedAt) {
   return {
-    id: typeof value.id === "string" && value.id.trim().length > 0 ? value.id.trim() : `question_${index + 1}`,
-    question: value.question.trim(),
-    choices
+    pipelineId,
+    runId,
+    level: "error",
+    category: "run",
+    event: "pipeline.run_failed",
+    message: "Pipeline run failed",
+    metadata: cleanMetadata({
+      durationMs: Date.now() - startedAt,
+      error: serializeError2(error)
+    })
   };
 }
-function normalizeQuestionChoice(value) {
-  if (typeof value === "string" && value.trim().length > 0) {
-    return { label: value.trim(), value: value.trim() };
+function pipelineStageLog(pipelineId, runId, event) {
+  const category = stageCategory(event.node);
+  if (event.type === "stage_started") {
+    return {
+      pipelineId,
+      runId,
+      level: "debug",
+      category,
+      event: `${event.node.kind}.started`,
+      message: `${event.node.label} started`,
+      metadata: nodeMetadata(event.node)
+    };
   }
-  if (!isObject(value) || typeof value.label !== "string" || value.label.trim().length === 0) {
-    return void 0;
+  if (event.type === "stage_completed") {
+    return {
+      pipelineId,
+      runId,
+      level: "debug",
+      category,
+      event: `${event.node.kind}.completed`,
+      message: `${event.node.label} completed`,
+      metadata: cleanMetadata({
+        ...nodeMetadata(event.node),
+        durationMs: event.durationMs
+      })
+    };
   }
   return {
-    label: value.label.trim(),
-    value: typeof value.value === "string" && value.value.trim().length > 0 ? value.value.trim() : value.label.trim()
+    pipelineId,
+    runId,
+    level: "error",
+    category,
+    event: `${event.node.kind}.failed`,
+    message: `${event.node.label} failed`,
+    metadata: cleanMetadata({
+      ...nodeMetadata(event.node),
+      durationMs: event.durationMs,
+      error: serializeError2(event.error)
+    })
   };
 }
-function isPendingQuestion(question) {
-  return question !== void 0 && question.status === "pending" && "resolve" in question;
+function stageCategory(node) {
+  if (node.kind === "parallel" || node.kind === "branch") {
+    return "parallel";
+  }
+  if (node.kind === "agent") {
+    return "agent";
+  }
+  if (node.kind === "extractor") {
+    return "extractor";
+  }
+  return "stage";
 }
-function resolveQuestion(question, answers) {
-  return publicQuestion({
-    ...question,
-    status: "answered",
-    answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    answers
+function nodeMetadata(node) {
+  return cleanMetadata({
+    nodeId: node.id,
+    kind: node.kind,
+    label: node.label,
+    agentId: node.agentId,
+    pipelineId: node.pipelineId,
+    branchKey: node.branchKey
   });
 }
-function publicQuestion(question) {
-  const { emit, resolve: resolve2, ...rest } = question;
-  void emit;
-  void resolve2;
-  return rest;
+function cleanMetadata(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0)
+  );
+}
+function byteLength(value) {
+  return value === void 0 ? void 0 : new TextEncoder().encode(value).length;
+}
+function formatUnknown(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
 }
 
 // src/runtime/runs.ts
@@ -2719,69 +3195,1102 @@ async function parseRunRequest(c) {
   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");
+// src/runtime/pipelines.ts
+function registerPipelineRoutes(app, props) {
+  app.get(
+    "/pipelines",
+    (c) => c.json({
+      pipelines: props.pipelines.map(pipelineConfig)
+    })
+  );
+  app.get("/pipelines/:pipelineId", (c) => {
+    const pipeline = props.pipelineMap.get(c.req.param("pipelineId"));
+    if (pipeline === void 0) {
+      return errorResponse(c, 404, "not_found", "Pipeline 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);
+    return c.json(pipelineDetail(pipeline));
   });
-  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");
+  app.get("/pipelines/:pipelineId/logs", async (c) => {
+    const pipelineId = c.req.param("pipelineId");
+    if (!props.pipelineMap.has(pipelineId)) {
+      return errorResponse(c, 404, "not_found", "Pipeline not found");
     }
-    return c.json(session);
-  });
-  app.delete("/sessions/:sessionId", async (c) => {
-    if (props.sessionStore.deleteSession === void 0) {
+    if (props.store === void 0) {
       return errorResponse(
         c,
         501,
         "unsupported_capability",
-        'Capability "sessions.delete" is not implemented by this runner',
-        { capability: "sessions", operation: "delete" }
+        'Capability "pipelines.logs" is not implemented by this runner',
+        { capability: "pipelines", operation: "logs" }
       );
     }
-    const deleted = await props.sessionStore.deleteSession(c.req.param("sessionId"));
-    if (!deleted) {
-      return errorResponse(c, 404, "not_found", "Session not found");
+    const limit = parsePipelineLogLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
     }
-    return c.body(null, 204);
-  });
-  app.get("/sessions/:sessionId/traces", async (c) => {
-    if (props.traceStore === void 0) {
-      return unsupportedCapability(c, "traces");
+    const after = parsePipelineLogAfter(c.req.query("after"));
+    if (after === false) {
+      return errorResponse(c, 400, "bad_request", "after must be a non-negative integer");
     }
-    const sessionId = c.req.param("sessionId");
-    const session = await props.sessionStore.getSession(sessionId);
-    if (session === void 0) {
+    const logs = await props.store.listPipelineLogs({
+      pipelineId,
+      limit,
+      ...after === void 0 ? {} : { after }
+    });
+    const last = logs.at(-1);
+    return c.json({
+      logs,
+      ...logs.length === limit && last !== void 0 ? { nextCursor: last.sequence } : {}
+    });
+  });
+  app.post("/pipelines/:pipelineId/runs", async (c) => {
+    const pipeline = props.pipelineMap.get(c.req.param("pipelineId"));
+    if (pipeline === void 0) {
+      return errorResponse(c, 404, "not_found", "Pipeline not found");
+    }
+    const body = await parsePipelineRunRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    const runId = globalThis.crypto.randomUUID();
+    const startedAt = Date.now();
+    await appendPipelineLog(
+      props.store,
+      pipelineRunReceivedLog({
+        pipeline,
+        runId,
+        stream: body.stream === true,
+        input: body.input,
+        ...body.metadata === void 0 ? {} : { metadata: body.metadata }
+      })
+    );
+    if (body.stream === true) {
+      return streamPipelineRun(c, {
+        pipeline,
+        runId,
+        input: body.input,
+        startedAt,
+        ...props.store === void 0 ? {} : { store: props.store }
+      });
+    }
+    try {
+      await appendPipelineLog(props.store, pipelineRunStartedLog(pipeline, runId));
+      const output = await pipeline.pipeline.run(body.input, {
+        observer: {
+          async onEvent(event) {
+            await appendPipelineLog(props.store, pipelineStageLog(pipeline.id, runId, event));
+          }
+        }
+      });
+      const jsonOutput = toJsonValue3(output);
+      await appendPipelineLog(
+        props.store,
+        pipelineRunCompletedLog({
+          pipelineId: pipeline.id,
+          runId,
+          durationMs: Date.now() - startedAt,
+          output: jsonOutput
+        })
+      );
+      const response = {
+        runId,
+        pipelineId: pipeline.id,
+        output: jsonOutput
+      };
+      return c.json(response);
+    } catch (error) {
+      await appendPipelineLog(
+        props.store,
+        pipelineRunFailedLog(pipeline.id, runId, error, startedAt)
+      );
+      return errorResponse(c, 500, "internal_error", "Pipeline run failed", serializeError2(error));
+    }
+  });
+}
+function pipelineDetail(pipeline) {
+  const graph = pipeline.pipeline.graph();
+  graph.id = pipeline.id;
+  return {
+    ...pipelineConfig(pipeline),
+    graph
+  };
+}
+function streamPipelineRun(c, props) {
+  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 streamResponse2(
+    c,
+    async (stream) => {
+      for await (const event of pipelineRunEvents(props)) {
+        await stream.write(`${JSON.stringify(event)}
+`);
+      }
+    },
+    async (error, stream) => {
+      await stream.write(`${JSON.stringify({ type: "error", error: serializeError2(error) })}
+`);
+    }
+  );
+}
+async function* pipelineRunEvents(props) {
+  yield* emitPipelineLog(props.store, pipelineRunStartedLog(props.pipeline, props.runId));
+  const events = new AsyncEventQueue();
+  const run = props.pipeline.pipeline.run(props.input, {
+    observer: {
+      async onEvent(event) {
+        const log = await appendPipelineLog(
+          props.store,
+          pipelineStageLog(props.pipeline.id, props.runId, event)
+        );
+        if (log !== void 0) {
+          events.push({ type: "pipeline_log", log });
+        }
+      }
+    }
+  }).then(async (output) => {
+    const jsonOutput = toJsonValue3(output);
+    const log = await appendPipelineLog(
+      props.store,
+      pipelineRunCompletedLog({
+        pipelineId: props.pipeline.id,
+        runId: props.runId,
+        durationMs: Date.now() - props.startedAt,
+        output: jsonOutput
+      })
+    );
+    if (log !== void 0) {
+      events.push({ type: "pipeline_log", log });
+    }
+    events.push({
+      type: "pipeline_final",
+      runId: props.runId,
+      pipelineId: props.pipeline.id,
+      output: jsonOutput
+    });
+  }).catch(async (error) => {
+    const log = await appendPipelineLog(
+      props.store,
+      pipelineRunFailedLog(props.pipeline.id, props.runId, error, props.startedAt)
+    );
+    if (log !== void 0) {
+      events.push({ type: "pipeline_log", log });
+    }
+    events.push({ type: "error", error: serializeError2(error) });
+  }).finally(() => events.close());
+  try {
+    while (true) {
+      const next = await events.next();
+      if (next.done === true) {
+        break;
+      }
+      yield next.value;
+    }
+  } finally {
+    await run;
+  }
+}
+async function parsePipelineRunRequest(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 (!("input" in body) || !isJsonValue2(body.input)) {
+    return { error: errorResponse(c, 400, "bad_request", "input must be JSON-compatible") };
+  }
+  const request = {
+    input: body.input
+  };
+  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 ("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;
+}
+function parsePipelineLogLimit(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return 200;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    return void 0;
+  }
+  return Math.min(limit, 1e3);
+}
+function parsePipelineLogAfter(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return void 0;
+  }
+  const after = Number(value);
+  if (!Number.isInteger(after) || after < 0) {
+    return false;
+  }
+  return after;
+}
+function isJsonValue2(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return Number.isFinite(value) || typeof value !== "number";
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue2);
+  }
+  if (isObject(value)) {
+    return Object.values(value).every((item) => item === void 0 || isJsonValue2(item));
+  }
+  return false;
+}
+function toJsonValue3(value) {
+  if (isJsonValue2(value)) {
+    return value;
+  }
+  if (value === void 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(JSON.stringify(value));
+    return isJsonValue2(parsed) ? parsed : String(value);
+  } catch {
+    return String(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/session-logs.ts
+async function appendSessionLog(store, input) {
+  return store?.appendSessionLog?.(input);
+}
+async function* streamSessionRunLogs(props) {
+  yield* emitLog(props.store, runStartedLog(props.session, props.runId));
+  yield* emitLog(props.store, memoryLoadedLog(props.session, props.runId));
+  try {
+    for await (const event of props.stream) {
+      for (const input of logsFromStreamEvent({
+        event,
+        runId: props.runId,
+        sessionId: props.session.id,
+        startedAt: props.startedAt
+      })) {
+        yield* emitLog(props.store, input);
+      }
+      yield event;
+    }
+  } catch (error) {
+    yield* emitLog(
+      props.store,
+      runFailedLog(props.session.id, props.runId, error, props.startedAt)
+    );
+    throw error;
+  }
+}
+function sessionCreatedLog(session) {
+  return {
+    sessionId: session.id,
+    level: "info",
+    category: "session",
+    event: "session.created",
+    message: "Session created",
+    metadata: cleanMetadata2({
+      agentId: session.agentId,
+      hasTitle: session.title !== void 0,
+      titleLength: session.title?.length ?? 0
+    })
+  };
+}
+function runReceivedLog(props) {
+  return {
+    sessionId: props.sessionId,
+    runId: props.runId,
+    level: "info",
+    category: "api",
+    event: "run.received",
+    message: "Run request received",
+    metadata: cleanMetadata2({
+      agentId: props.agentId,
+      stream: props.stream,
+      message: messageSummary(props.message),
+      maxTurns: props.maxTurns,
+      toolConcurrency: props.toolConcurrency,
+      hasTrace: props.hasTrace,
+      metadataKeys: Object.keys(props.metadata ?? {})
+    })
+  };
+}
+function runStartedLog(session, runId) {
+  return {
+    sessionId: session.id,
+    runId,
+    level: "info",
+    category: "run",
+    event: "run.started",
+    message: "Run started",
+    metadata: cleanMetadata2({
+      agentId: session.agentId,
+      existingMessageCount: session.messageCount
+    })
+  };
+}
+function memoryLoadedLog(session, runId) {
+  return {
+    sessionId: session.id,
+    runId,
+    level: "debug",
+    category: "memory",
+    event: "memory.loaded",
+    message: "Session memory loaded",
+    metadata: cleanMetadata2({
+      messageCount: session.messageCount,
+      transcriptEntries: session.transcript.length
+    })
+  };
+}
+function runCompletedLog(props) {
+  return {
+    sessionId: props.sessionId,
+    runId: props.runId,
+    level: "info",
+    category: "run",
+    event: "run.completed",
+    message: "Run completed",
+    metadata: cleanMetadata2({
+      durationMs: props.durationMs,
+      usage: usageSummary(props.usage),
+      outputBytes: byteLength2(props.output),
+      messageCount: props.messageCount
+    })
+  };
+}
+function memorySavedLog(props) {
+  return {
+    sessionId: props.sessionId,
+    runId: props.runId,
+    level: "debug",
+    category: "memory",
+    event: "memory.saved",
+    message: "Session memory saved",
+    metadata: cleanMetadata2({
+      messageCount: props.messageCount
+    })
+  };
+}
+function runFailedLog(sessionId, runId, error, startedAt) {
+  return {
+    sessionId,
+    runId,
+    level: "error",
+    category: "run",
+    event: "run.failed",
+    message: "Run failed",
+    metadata: cleanMetadata2({
+      durationMs: Date.now() - startedAt,
+      error: serializeError2(error)
+    })
+  };
+}
+function logsFromStreamEvent(props) {
+  const { event, sessionId, runId } = props;
+  if (event.type === "turn_start") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "prompt",
+        event: "prompt.prepared",
+        message: `Turn ${event.turn} prompt prepared`,
+        metadata: cleanMetadata2({
+          turn: event.turn,
+          prompt: messageSummary(event.prompt),
+          historyCount: event.history.length
+        })
+      }
+    ];
+  }
+  if (event.type === "tool_call") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "info",
+        category: "tool",
+        event: "tool.called",
+        message: `Tool ${event.toolCall.function.name} called`,
+        metadata: cleanMetadata2({
+          turn: event.turn,
+          toolName: event.toolCall.function.name,
+          callId: event.toolCall.callId ?? event.toolCall.id,
+          argumentBytes: byteLength2(formatUnknown2(event.toolCall.function.arguments))
+        })
+      }
+    ];
+  }
+  if (event.type === "tool_result") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "info",
+        category: "tool",
+        event: "tool.completed",
+        message: `Tool ${event.toolName} completed`,
+        metadata: cleanMetadata2({
+          turn: event.turn,
+          toolName: event.toolName,
+          callId: event.toolCallId,
+          internalCallId: event.internalCallId,
+          argumentBytes: byteLength2(event.args),
+          resultBytes: byteLength2(event.result)
+        })
+      }
+    ];
+  }
+  if (event.type === "turn_end") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "model",
+        event: "model.turn.completed",
+        message: `Model turn ${event.turn} completed`,
+        metadata: cleanMetadata2({
+          turn: event.turn,
+          contentCount: event.response.choice.length,
+          usage: usageSummary(event.response.usage)
+        })
+      }
+    ];
+  }
+  if (event.type === "final") {
+    return [
+      runCompletedLog({
+        sessionId,
+        runId,
+        durationMs: Date.now() - props.startedAt,
+        usage: event.usage,
+        output: event.output,
+        messageCount: event.messages.length
+      }),
+      memorySavedLog({ sessionId, runId, messageCount: event.messages.length })
+    ];
+  }
+  if (event.type === "error") {
+    return [runFailedLog(sessionId, runId, event.error, props.startedAt)];
+  }
+  if (event.type === "tool_approval_request") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "info",
+        category: "approval",
+        event: "approval.requested",
+        message: `Approval requested for ${event.approval.toolName}`,
+        metadata: cleanMetadata2({
+          approvalId: event.approval.id,
+          toolName: event.approval.toolName,
+          callId: event.approval.callId,
+          status: event.approval.status,
+          hasReason: event.approval.reason !== void 0,
+          argumentBytes: byteLength2(event.approval.args)
+        })
+      }
+    ];
+  }
+  if (event.type === "tool_approval_result") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: event.approval.status === "approved" ? "info" : "warn",
+        category: "approval",
+        event: "approval.resolved",
+        message: `Approval ${event.approval.status} for ${event.approval.toolName}`,
+        metadata: cleanMetadata2({
+          approvalId: event.approval.id,
+          toolName: event.approval.toolName,
+          callId: event.approval.callId,
+          status: event.approval.status,
+          hasReason: event.approval.reason !== void 0
+        })
+      }
+    ];
+  }
+  if (event.type === "tool_question_request") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "info",
+        category: "question",
+        event: "question.requested",
+        message: `Question requested by ${event.question.toolName}`,
+        metadata: cleanMetadata2({
+          questionId: event.question.id,
+          toolName: event.question.toolName,
+          callId: event.question.callId,
+          status: event.question.status,
+          questionCount: event.question.questions.length,
+          argumentBytes: byteLength2(event.question.args)
+        })
+      }
+    ];
+  }
+  if (event.type === "tool_question_result") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "info",
+        category: "question",
+        event: "question.answered",
+        message: `Question answered for ${event.question.toolName}`,
+        metadata: cleanMetadata2({
+          questionId: event.question.id,
+          toolName: event.question.toolName,
+          callId: event.question.callId,
+          status: event.question.status,
+          answerCount: event.question.answers?.length ?? 0
+        })
+      }
+    ];
+  }
+  if (event.type === "agent_tool_event") {
+    return childAgentLog(event, sessionId, runId);
+  }
+  return [];
+}
+async function* emitLog(store, input) {
+  const log = await appendSessionLog(store, input);
+  if (log !== void 0) {
+    yield { type: "session_log", log };
+  }
+}
+function childAgentLog(event, sessionId, runId) {
+  const child = event.event;
+  if (child.type === "tool_call") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "tool",
+        event: "child_tool.called",
+        message: `Child agent ${event.agentName ?? event.agentId} called ${child.toolCall.function.name}`,
+        metadata: cleanMetadata2({
+          parentToolName: event.toolName,
+          agentId: event.agentId,
+          hasAgentName: event.agentName !== void 0,
+          turn: event.turn,
+          childTurn: child.turn,
+          toolName: child.toolCall.function.name,
+          callId: child.toolCall.callId ?? child.toolCall.id,
+          argumentBytes: byteLength2(formatUnknown2(child.toolCall.function.arguments))
+        })
+      }
+    ];
+  }
+  if (child.type === "tool_result") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "tool",
+        event: "child_tool.completed",
+        message: `Child agent ${event.agentName ?? event.agentId} completed ${child.toolName}`,
+        metadata: cleanMetadata2({
+          parentToolName: event.toolName,
+          agentId: event.agentId,
+          hasAgentName: event.agentName !== void 0,
+          turn: event.turn,
+          childTurn: child.turn,
+          toolName: child.toolName,
+          callId: child.toolCallId,
+          resultBytes: byteLength2(child.result)
+        })
+      }
+    ];
+  }
+  if (child.type === "turn_start") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "run",
+        event: "child_agent.turn_started",
+        message: `Child agent ${event.agentName ?? event.agentId} turn ${child.turn} started`,
+        metadata: cleanMetadata2({
+          parentToolName: event.toolName,
+          agentId: event.agentId,
+          hasAgentName: event.agentName !== void 0,
+          childTurn: child.turn,
+          historyCount: child.history.length
+        })
+      }
+    ];
+  }
+  if (child.type === "final") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "debug",
+        category: "run",
+        event: "child_agent.completed",
+        message: `Child agent ${event.agentName ?? event.agentId} completed`,
+        metadata: cleanMetadata2({
+          parentToolName: event.toolName,
+          agentId: event.agentId,
+          hasAgentName: event.agentName !== void 0,
+          usage: usageSummary(child.usage),
+          outputBytes: byteLength2(child.output),
+          messageCount: child.messages.length
+        })
+      }
+    ];
+  }
+  if (child.type === "error") {
+    return [
+      {
+        sessionId,
+        runId,
+        level: "error",
+        category: "run",
+        event: "child_agent.failed",
+        message: `Child agent ${event.agentName ?? event.agentId} failed`,
+        metadata: cleanMetadata2({
+          parentToolName: event.toolName,
+          agentId: event.agentId,
+          hasAgentName: event.agentName !== void 0,
+          error: serializeError2(child.error)
+        })
+      }
+    ];
+  }
+  return [];
+}
+function messageSummary(message) {
+  if (typeof message === "string") {
+    return {
+      role: "user",
+      contentKind: "text",
+      byteLength: byteLength2(message)
+    };
+  }
+  return {
+    role: message.role,
+    contentKind: Array.isArray(message.content) ? "parts" : "text",
+    partCount: Array.isArray(message.content) ? message.content.length : 1,
+    byteLength: byteLength2(formatUnknown2(message.content))
+  };
+}
+function usageSummary(value) {
+  if (value === void 0 || value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  return cleanMetadata2({
+    inputTokens: numericValue(record.inputTokens),
+    outputTokens: numericValue(record.outputTokens),
+    totalTokens: numericValue(record.totalTokens),
+    cachedInputTokens: numericValue(record.cachedInputTokens),
+    cacheCreationInputTokens: numericValue(record.cacheCreationInputTokens)
+  });
+}
+function cleanMetadata2(value) {
+  const cleaned = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === void 0) {
+      continue;
+    }
+    const jsonValue = cleanJsonValue(item);
+    if (jsonValue !== void 0) {
+      cleaned[key] = jsonValue;
+    }
+  }
+  return cleaned;
+}
+function cleanJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cleanJsonValue(item)).filter((item) => item !== void 0);
+  }
+  if (typeof value === "object" && value !== null) {
+    return cleanMetadata2(value);
+  }
+  return void 0;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function byteLength2(value) {
+  return value === void 0 ? 0 : new TextEncoder().encode(value).byteLength;
+}
+function formatUnknown2(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// 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 }
+    });
+    await appendSessionLog(props.sessionStore, sessionCreatedLog(session));
+    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.get("/sessions/:sessionId/logs", async (c) => {
+    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");
+    }
+    if (props.sessionStore.listSessionLogs === void 0) {
+      return errorResponse(
+        c,
+        501,
+        "unsupported_capability",
+        'Capability "sessions.logs" is not implemented by this runner',
+        { capability: "sessions", operation: "logs" }
+      );
+    }
+    const limit = parseSessionLogLimit(c.req.query("limit"));
+    if (limit === void 0) {
+      return errorResponse(c, 400, "bad_request", "limit must be a positive integer");
+    }
+    const after = parseSessionLogAfter(c.req.query("after"));
+    if (after === false) {
+      return errorResponse(c, 400, "bad_request", "after must be a non-negative integer");
+    }
+    const logs = await props.sessionStore.listSessionLogs({
+      sessionId,
+      limit,
+      ...after === void 0 ? {} : { after }
+    });
+    const last = logs.at(-1);
+    return c.json({
+      logs,
+      ...logs.length === limit && last !== void 0 ? { nextCursor: last.sequence } : {}
+    });
+  });
+  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"));
@@ -2792,6 +4301,26 @@ function registerSessionRoutes(app, props) {
     return c.json({ traces });
   });
 }
+function parseSessionLogLimit(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return 200;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    return void 0;
+  }
+  return Math.min(limit, 1e3);
+}
+function parseSessionLogAfter(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return void 0;
+  }
+  const after = Number(value);
+  if (!Number.isInteger(after) || after < 0) {
+    return false;
+  }
+  return after;
+}
 async function parseCreateSessionRequest(c) {
   let body;
   try {
@@ -2826,6 +4355,47 @@ async function parseCreateSessionRequest(c) {
   return request;
 }
 
+// src/runtime/tools.ts
+function registerToolRoutes(app, props) {
+  app.get("/agents/:agentId/tools", async (c) => {
+    const agentId = c.req.param("agentId");
+    const agent = props.agentMap.get(agentId);
+    if (agent === void 0) {
+      return errorResponse(c, 404, "not_found", "Agent not found");
+    }
+    return c.json({
+      agentId,
+      tools: await agentToolMetadata(agent)
+    });
+  });
+}
+async function agentToolMetadata(agent) {
+  const seen = /* @__PURE__ */ new Set();
+  const metadata = [];
+  for (const { tool, source } of agentToolItems(agent)) {
+    const key = `${source}:${tool.name}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    const definition = await tool.definition("");
+    metadata.push({
+      agentId: agent.id,
+      name: definition.name,
+      description: definition.description,
+      parameters: definition.parameters,
+      source,
+      approval: approvalMetadata(tool)
+    });
+  }
+  return metadata.sort((left, right) => {
+    if (left.source !== right.source) {
+      return left.source === "static" ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+
 // src/runtime/trace-routes.ts
 function registerTraceRoutes(app, traceStore) {
   app.get("/traces", async (c) => {
@@ -2871,8 +4441,8 @@ var Studio = class {
   studio;
   server;
   sigintHandler;
-  constructor(agents = [], options = {}) {
-    this.options = studioOptionsFromAgents(agents, options);
+  constructor(targets = [], options = {}) {
+    this.options = studioOptionsFromTargets(targets, options);
     this.studio = createStudioApp(this.options);
   }
   get app() {
@@ -2925,9 +4495,14 @@ var Studio = class {
     this.studio.close();
   }
 };
-function studioOptionsFromAgents(agents, options) {
+function studioOptionsFromTargets(targets, options) {
+  const agents = targets.filter((target) => target instanceof Agent);
+  const pipelines = targets.filter(
+    (target) => target instanceof Pipeline
+  );
   return {
-    agents: inferStudioAgents(agents, options.quickPrompts ?? {})
+    agents: inferStudioAgents(agents, options.quickPrompts ?? {}),
+    pipelines: inferStudioPipelines(pipelines)
   };
 }
 function inferStudioAgents(agents, quickPrompts) {
@@ -2942,6 +4517,19 @@ function inferStudioAgents(agents, quickPrompts) {
     };
   });
 }
+function inferStudioPipelines(pipelines) {
+  const ids = /* @__PURE__ */ new Set();
+  return pipelines.map((pipeline) => {
+    const id = uniqueAgentId(pipeline.id || "pipeline", ids);
+    return {
+      id,
+      pipeline,
+      ...pipeline.name === void 0 ? {} : { name: pipeline.name },
+      ...pipeline.description === void 0 ? {} : { description: pipeline.description },
+      ...pipeline.metadata === void 0 ? {} : { metadata: pipeline.metadata }
+    };
+  });
+}
 function uniqueAgentId(baseId, ids) {
   let id = baseId;
   let suffix = 2;
@@ -2959,6 +4547,7 @@ function agentMetadata(agent) {
     dynamicContextCount: agent.dynamicContexts.length,
     dynamicToolCount: agent.dynamicTools.length,
     hasOutputSchema: agent.outputSchema !== void 0,
+    hasHook: agent.hook !== void 0,
     observerCount: agent.observers.length,
     approvalToolCount: agent.toolSet.values().filter((tool) => tool.approval !== void 0).length
   };
@@ -2966,7 +4555,9 @@ function agentMetadata(agent) {
 function createStudioApp(options) {
   const stores = resolveStores(options);
   const agents = normalizeAgents(options.agents).map((agent) => withStudioSessionMemory(agent, stores.sessions)).map((agent) => withStudioTraceObserver(agent, stores.traces));
+  const pipelines = normalizePipelines(options.pipelines);
   const agentMap = new Map(agents.map((agent) => [agent.id, agent]));
+  const pipelineMap = new Map(pipelines.map((pipeline) => [pipeline.id, pipeline]));
   const approvalRuntime = createApprovalRuntime();
   const questionRuntime = createQuestionRuntime();
   const app = new HonoApp();
@@ -2988,7 +4579,7 @@ function createStudioApp(options) {
       }
     })
   );
-  app.get("/config", (c) => c.json(buildConfig(options, agents, stores)));
+  app.get("/config", (c) => c.json(buildConfig(options, agents, pipelines, stores)));
   app.get("/agents", (c) => c.json({ agents: agents.map(agentConfig) }));
   app.get("/agents/:agentId", (c) => {
     const agent = agentMap.get(c.req.param("agentId"));
@@ -2997,12 +4588,19 @@ function createStudioApp(options) {
     }
     return c.json(agentConfig(agent));
   });
+  registerMcpRoutes(app, { agentMap });
+  registerToolRoutes(app, { agentMap });
   registerApprovalRoutes(app, approvalRuntime);
   registerQuestionRoutes(app, questionRuntime);
   registerKnowledgeRoutes(app, {
     agents,
     ...stores.traces === void 0 ? {} : { traceStore: stores.traces }
   });
+  registerPipelineRoutes(app, {
+    pipelines,
+    pipelineMap,
+    ...stores.pipelineLogs === void 0 ? {} : { store: stores.pipelineLogs }
+  });
   app.post("/agents/:agentId/runs", async (c) => {
     const agentId = c.req.param("agentId");
     const agent = agentMap.get(agentId);
@@ -3024,6 +4622,23 @@ function createStudioApp(options) {
       return errorResponse(c, 400, "bad_request", "Session belongs to another agent");
     }
     const runId = globalThis.crypto.randomUUID();
+    const runStartedAt = Date.now();
+    if (session !== void 0) {
+      await appendSessionLog(
+        stores.sessions,
+        runReceivedLog({
+          sessionId: session.id,
+          runId,
+          agentId,
+          message: body.message,
+          stream: body.stream === true,
+          ...body.maxTurns === void 0 ? {} : { maxTurns: body.maxTurns },
+          ...body.toolConcurrency === void 0 ? {} : { toolConcurrency: body.toolConcurrency },
+          hasTrace: body.trace !== void 0,
+          ...body.metadata === void 0 ? {} : { metadata: body.metadata }
+        })
+      );
+    }
     const memoryMetadata = {
       agentId,
       ...body.metadata ?? {},
@@ -3070,7 +4685,13 @@ function createStudioApp(options) {
       }
       const runStream = mergeRunAndApprovalEvents(request.stream(), runtimeEvents);
       const stream = session === void 0 || stores.sessions === void 0 ? runStream : persistStreamingSessionTranscript({
-        stream: runStream,
+        stream: streamSessionRunLogs({
+          stream: runStream,
+          store: stores.sessions,
+          session,
+          runId,
+          startedAt: runStartedAt
+        }),
         store: stores.sessions,
         session,
         message: body.message,
@@ -3079,6 +4700,10 @@ function createStudioApp(options) {
       return streamAgentRunEvents(c, stream);
     }
     try {
+      if (session !== void 0) {
+        await appendSessionLog(stores.sessions, runStartedLog(session, runId));
+        await appendSessionLog(stores.sessions, memoryLoadedLog(session, runId));
+      }
       const effectiveHook = composeHooks(
         composeHooks(
           agent.agent.hook,
@@ -3109,6 +4734,25 @@ function createStudioApp(options) {
           transcript: transcriptFromMessages(response.messages),
           status: "success"
         });
+        await appendSessionLog(
+          stores.sessions,
+          runCompletedLog({
+            sessionId: session.id,
+            runId,
+            durationMs: Date.now() - runStartedAt,
+            usage: response.usage,
+            output: response.output,
+            messageCount: response.messages.length
+          })
+        );
+        await appendSessionLog(
+          stores.sessions,
+          memorySavedLog({
+            sessionId: session.id,
+            runId,
+            messageCount: response.messages.length
+          })
+        );
       }
       return c.json(response);
     } catch (error) {
@@ -3125,6 +4769,10 @@ function createStudioApp(options) {
           status: "error",
           error: serializeError2(error)
         });
+        await appendSessionLog(
+          stores.sessions,
+          runFailedLog(session.id, runId, error, runStartedAt)
+        );
       }
       return errorResponse(c, 500, "internal_error", "Agent run failed", serializeError2(error));
     }
@@ -3149,7 +4797,7 @@ function createStudioApp(options) {
       return app.fetch(request);
     },
     config() {
-      return buildConfig(options, agents, stores);
+      return buildConfig(options, agents, pipelines, stores);
     },
     close() {
     },
@@ -3237,6 +4885,9 @@ function composeHooks(first, second) {
       if (firstAction?.type === "skip" || firstAction?.type === "terminate") {
         return firstAction;
       }
+      if (firstAction?.type === "approval_request") {
+        return await approvalRequestHandler(second)?.(args, firstAction) ?? firstAction;
+      }
       const secondAction = await second.onToolCall?.(args);
       return secondAction ?? firstAction ?? void 0;
     },
@@ -3246,6 +4897,10 @@ function composeHooks(first, second) {
     }
   });
 }
+function approvalRequestHandler(hook) {
+  const candidate = hook;
+  return typeof candidate.handleApprovalRequest === "function" ? candidate.handleApprovalRequest : void 0;
+}
 export {
   Studio,
   StudioTraceObserver,