@anvia/studio 1.0.1 → 1.0.4

package/dist/index.js

@@ -5,6 +5,9 @@ import { serve } from "@hono/node-server";
 import { Hono as HonoApp } from "hono";
 import { WebSocketServer } from "ws";
 
+// src/traces/trace-observer.ts
+import { AgentRunCancelledError } from "@anvia/core/agent";
+
 // src/runtime/json.ts
 function toJsonValue(value) {
   return toJsonValueInternal(value, /* @__PURE__ */ new WeakSet());
@@ -213,7 +216,7 @@ var StudioRunTraceObserver = class {
     });
   }
   async error(args) {
-    await this.save("error", {
+    await this.save(args.status === "cancelled" ? "cancelled" : "error", {
       endedAt: /* @__PURE__ */ new Date(),
       error: serializeUnknown(args.error),
       usage: args.usage,
@@ -355,11 +358,12 @@ var ChildAgentToolTraceAccumulator = class {
     if (child.type === "error") {
       const metadata = this.childMetadata(agentId, agentName, childTurn);
       if (isRecord(child.usage)) metadata.usage = toJsonValue(child.usage);
+      const status = child.error instanceof AgentRunCancelledError ? "cancelled" : "error";
       this.completedObservations.push(
         traceObservation({
           kind: "tool",
           name: `${agentLabel(agentId, agentName)}.error`,
-          status: "error",
+          status,
           turn: this.parent.turn,
           startedAt: /* @__PURE__ */ new Date(),
           error: serializeUnknown(child.error),
@@ -385,7 +389,7 @@ var ChildAgentToolTraceAccumulator = class {
         parentObservationId,
         kind: "agent",
         name: `${agentLabel(agentStart.agentId, agentStart.agentName)}.run`,
-        status: agentChildren.some((observation) => observation.status === "error") ? "error" : "success",
+        status: agentChildren.some((observation) => observation.status === "error") ? "error" : agentChildren.some((observation) => observation.status === "cancelled") ? "cancelled" : "success",
         turn: this.parent.turn,
         startedAt,
         endedAt,
@@ -670,6 +674,7 @@ function registerStudioUi(app, options) {
   app.get(`${options.path}/tools`, (c) => redirectWithQuery(c, "/tools"));
   app.get(`${options.path}/mcps`, (c) => redirectWithQuery(c, "/mcps"));
   app.get(`${options.path}/pipelines`, (c) => redirectWithQuery(c, "/pipelines"));
+  app.get(`${options.path}/graphs`, (c) => redirectWithQuery(c, "/graphs"));
   app.get(`${options.path}/sandboxes`, (c) => redirectWithQuery(c, "/sandboxes"));
   app.get(
     `${options.path}/sandboxes/:sandboxRef`,
@@ -694,6 +699,7 @@ function registerStudioUi(app, options) {
     app.get("/tools", async (c) => c.html(await renderShell()));
     app.get("/mcps", async (c) => c.html(await renderShell()));
     app.get("/pipelines", shellWhenHtml(renderShell));
+    app.get("/graphs", shellWhenHtml(renderShell));
     app.get("/sandboxes", shellWhenHtml(renderShell));
     app.get("/sandboxes/:sandboxRef", shellWhenHtml(renderShell));
     app.get("/memory", async (c) => c.html(await renderShell()));
@@ -787,8 +793,9 @@ function renderLegacyStudioUiShell(props) {
     '<meta charset="utf-8">',
     '<meta name="viewport" content="width=device-width, initial-scale=1">',
     `<title>${title}</title>`,
-    '<script>(()=>{try{const t=localStorage.getItem("anvia-studio-theme");const d=t==="dark"||(t!=="light"&&matchMedia("(prefers-color-scheme: dark)").matches);document.documentElement.classList.toggle("dark",d);document.documentElement.style.colorScheme=d?"dark":"light"}catch{}})();</script>',
-    `<link rel="icon" type="image/svg+xml" href="${escapeHtml(props.compatUiPath)}/assets/favicon.svg">`,
+    '<meta name="theme-color" content="#09090b">',
+    `<link data-anvia-favicon rel="icon" type="image/svg+xml" href="${escapeHtml(props.compatUiPath)}/assets/favicon-dark.svg">`,
+    '<script>(()=>{let m="dark";try{const t=localStorage.getItem("anvia-theme");const l=localStorage.getItem("anvia-studio-theme");if(t==="light"||(t!=="dark"&&l==="light"))m="light"}catch{}const r=document.documentElement;r.classList.toggle("dark",m==="dark");r.dataset.theme=m;r.style.colorScheme=m;document.querySelector(\'meta[name="theme-color"]\')?.setAttribute("content",m==="dark"?"#09090b":"#f4f4f5");const f=document.querySelector("link[data-anvia-favicon]");if(f)f.href=f.href.replace("favicon-dark.svg",`favicon-${m}.svg`)})();</script>',
     `<link rel="stylesheet" href="${escapeHtml(props.stylesheet)}">`,
     "</head>",
     "<body>",
@@ -1005,6 +1012,18 @@ function unsupportedCapability(c, capability) {
     { capability }
   );
 }
+async function parseJsonBody(c, validate) {
+  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") };
+  }
+  return validate(body);
+}
 
 // src/runtime/models.ts
 var STUDIO_MODEL_METADATA_KEY = "studioModel";
@@ -3089,16 +3108,30 @@ function registerAgentRunRoute(app, props) {
   app.post("/agents/:agentId/runs", (c) => handleAgentRun(c, props));
 }
 async function handleAgentRun(c, props) {
-  const prepared = await prepareAgentRun(c, props);
-  if (prepared instanceof Response) {
-    return prepared;
+  const lease = props.runLifecycle.start(c.req.raw.signal);
+  if (lease === void 0) {
+    return errorResponse(c, 503, "service_unavailable", "Anvia Studio is shutting down");
   }
-  if (prepared.body.stream === true) {
-    return handleStreamingAgentRun(c, prepared, props);
+  try {
+    const prepared = await prepareAgentRun(c, props, lease.abortSignal);
+    if (prepared instanceof Response) {
+      lease.finish();
+      return prepared;
+    }
+    if (prepared.body.stream === true) {
+      return handleStreamingAgentRun(c, prepared, props, lease);
+    }
+    try {
+      return await handleBufferedAgentRun(c, prepared, props);
+    } finally {
+      lease.finish();
+    }
+  } catch (error) {
+    lease.finish();
+    throw error;
   }
-  return handleBufferedAgentRun(c, prepared, props);
 }
-async function prepareAgentRun(c, props) {
+async function prepareAgentRun(c, props, abortSignal) {
   const agentId = c.req.param("agentId");
   const agent = props.agentMap.get(agentId);
   if (agent === void 0) {
@@ -3132,7 +3165,7 @@ async function prepareAgentRun(c, props) {
     if (body.stream !== void 0) resumedBody = { ...resumedBody, stream: body.stream };
     if (body.metadata !== void 0) resumedBody = { ...resumedBody, metadata: body.metadata };
     if (body.trace !== void 0) resumedBody = { ...resumedBody, trace: body.trace };
-    const runOptions = createRunOptions(resumedBody, agentId, source.session, c.req.raw.signal);
+    const runOptions = createRunOptions(resumedBody, agentId, source.session, abortSignal);
     const execution2 = {
       generate: (options) => source.runAgent.generate({
         continuation: claimed.continuation,
@@ -3211,7 +3244,7 @@ async function prepareAgentRun(c, props) {
     execution,
     failureMessages: void 0,
     memoryCompactionLogged: false,
-    options: createRunOptions(body, agentId, session, c.req.raw.signal),
+    options: createRunOptions(body, agentId, session, abortSignal),
     runAgent,
     runId,
     runStartedAt,
@@ -3339,7 +3372,7 @@ function createRunOptions(body, agentId, session, abortSignal) {
   }
   return options;
 }
-function handleStreamingAgentRun(c, run, props) {
+function handleStreamingAgentRun(c, run, props, lease) {
   const streamOptions = withInternalAgentRunOptions({ ...run.options }, { runId: run.runId });
   const runStream = registerStreamingContinuation(
     run.execution.stream(streamOptions),
@@ -3367,7 +3400,7 @@ function handleStreamingAgentRun(c, run, props) {
     });
     stream = persistedRun.events;
   }
-  return streamAgentRunEvents(c, stream, {
+  return streamAgentRunEvents(c, finishRunLease(stream, lease), {
     runId: run.runId,
     onCancel: async () => {
       const persistence = [];
@@ -3386,6 +3419,13 @@ function handleStreamingAgentRun(c, run, props) {
     }
   });
 }
+async function* finishRunLease(events, lease) {
+  try {
+    yield* events;
+  } finally {
+    lease.finish();
+  }
+}
 async function handleBufferedAgentRun(c, run, props) {
   try {
     const runtimeOptions = await startBufferedSessionRun(run);
@@ -3680,7 +3720,7 @@ function parseTraceStatus(value) {
   if (status === void 0) {
     return void 0;
   }
-  return status === "running" || status === "success" || status === "suspended" || status === "error" ? status : false;
+  return status === "running" || status === "success" || status === "suspended" || status === "error" || status === "cancelled" ? status : false;
 }
 function parseAfter(value) {
   if (value === void 0 || value.trim().length === 0) {
@@ -4193,12 +4233,33 @@ function pipelineConfig(pipeline) {
   if (pipeline.metadata !== void 0) config.metadata = pipeline.metadata;
   return config;
 }
+function graphConfig(registration) {
+  const config = {
+    id: registration.id,
+    nodeTypes: Object.entries(registration.graph.schema.nodes).map(([name, definition]) => ({
+      name,
+      description: definition.description
+    })),
+    relationshipTypes: Object.entries(registration.graph.schema.relationships).map(
+      ([name, definition]) => ({
+        name,
+        description: definition.description,
+        from: definition.from,
+        to: definition.to
+      })
+    )
+  };
+  if (registration.name !== void 0) config.name = registration.name;
+  if (registration.description !== void 0) config.description = registration.description;
+  return config;
+}
 function buildConfig(options, agents, pipelines, stores, sandboxCount = 0) {
   const models = options.models === void 0 ? void 0 : studioModelsConfig(createStudioModelRegistry(options.models), agents);
   const config = {
     id: runnerId(options),
     agents: agents.map(agentConfig),
     pipelines: pipelines.map(pipelineConfig),
+    graphs: options.graphs.map(graphConfig),
     evals: options.evals.map(evalConfig),
     chat: {
       quickPrompts: Object.fromEntries(agents.map((agent) => [agent.id, agent.quickPrompts ?? []]))
@@ -4230,6 +4291,9 @@ function capabilityConfig(_options, agents, pipelines, stores, sandboxCount = 0)
   if (pipelines.length > 0) {
     capabilities.pipelines = { enabled: true };
   }
+  if (_options.graphs.length > 0) {
+    capabilities.graphs = { enabled: true };
+  }
   if (_options.evals.length > 0) {
     capabilities.evals = { enabled: true };
   }
@@ -4327,6 +4391,110 @@ async function parseEvalRunRequest(c) {
   return request;
 }
 
+// src/runtime/graphs.ts
+import { resolveGraphExploreOptions } from "@anvia/graph/explore";
+function registerGraphRoutes(app, registrations) {
+  const graphs = graphRegistry(registrations);
+  app.get("/graphs", (c) => c.json({ graphs: [...graphs.values()].map(graphConfig) }));
+  app.post("/graphs/:graphId/explore", async (c) => {
+    const registration = graphs.get(c.req.param("graphId"));
+    if (registration === void 0) {
+      return errorResponse(c, 404, "not_found", "Graph not found");
+    }
+    const body = await parseJsonBody(c, (value) => parseExploreRequest(c, value));
+    if ("error" in body) return body.error;
+    const input = exploreOptionsWithSignal(body, c.req.raw.signal);
+    let options;
+    try {
+      options = resolveGraphExploreOptions(registration.graph.schema, input);
+    } catch (error) {
+      return errorResponse(
+        c,
+        400,
+        "bad_request",
+        error instanceof Error ? error.message : "Invalid graph exploration request"
+      );
+    }
+    return c.json(await registration.graph.explore(options));
+  });
+}
+function graphRegistry(registrations) {
+  const graphs = /* @__PURE__ */ new Map();
+  for (const registration of registrations) {
+    if (typeof registration.id !== "string" || registration.id.length === 0) {
+      throw new TypeError("Studio graph id must be a non-empty string.");
+    }
+    if (graphs.has(registration.id)) {
+      throw new TypeError(`Duplicate Studio graph id: ${registration.id}.`);
+    }
+    graphs.set(registration.id, registration);
+  }
+  return graphs;
+}
+function parseExploreRequest(c, value) {
+  if (!isObject(value) || value.mode !== "overview" && value.mode !== "expand") {
+    return { error: errorResponse(c, 400, "bad_request", "mode must be overview or expand") };
+  }
+  const common = parseCommonOptions(c, value);
+  if ("error" in common) return common;
+  if (value.mode === "overview") return { ...common, mode: "overview" };
+  const nodeIds = stringList(value.nodeIds);
+  if (nodeIds === void 0) {
+    return { error: errorResponse(c, 400, "bad_request", "nodeIds must be a string array") };
+  }
+  const request = {
+    ...common,
+    mode: "expand",
+    nodeIds
+  };
+  if (value.direction === "outgoing" || value.direction === "incoming" || value.direction === "both") {
+    request.direction = value.direction;
+  } else if (value.direction !== void 0) {
+    return {
+      error: errorResponse(c, 400, "bad_request", "direction must be outgoing, incoming, or both")
+    };
+  }
+  if (typeof value.maxDepth === "number") request.maxDepth = value.maxDepth;
+  else if (value.maxDepth !== void 0) {
+    return { error: errorResponse(c, 400, "bad_request", "maxDepth must be a number") };
+  }
+  return request;
+}
+function parseCommonOptions(c, value) {
+  const request = {};
+  for (const [key, label] of [
+    ["nodeTypes", "nodeTypes"],
+    ["relationships", "relationships"]
+  ]) {
+    const selected = value[key];
+    if (selected === void 0) continue;
+    const values = stringList(selected);
+    if (values === void 0) {
+      return { error: errorResponse(c, 400, "bad_request", `${label} must be a string array`) };
+    }
+    request[key] = values;
+  }
+  for (const [key, label] of [
+    ["maxNodes", "maxNodes"],
+    ["maxRelationships", "maxRelationships"]
+  ]) {
+    const selected = value[key];
+    if (selected === void 0) continue;
+    if (typeof selected !== "number") {
+      return { error: errorResponse(c, 400, "bad_request", `${label} must be a number`) };
+    }
+    request[key] = selected;
+  }
+  return request;
+}
+function exploreOptionsWithSignal(request, abortSignal) {
+  return { ...request, abortSignal };
+}
+function stringList(value) {
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return void 0;
+  return value;
+}
+
 // src/runtime/interactions.ts
 import {
   assertAgentInteractionResponse
@@ -4997,7 +5165,7 @@ function registerPipelineRoutes(app, props) {
     if ("error" in body) {
       return body.error;
     }
-    return executePipelineRun(c, props, pipeline, body);
+    return executeTrackedPipelineRun(c, props, pipeline, body);
   });
   app.post("/pipelines/:pipelineId/runs/:runId/replay", async (c) => {
     const pipeline = props.pipelineMap.get(c.req.param("pipelineId"));
@@ -5033,10 +5201,22 @@ function registerPipelineRoutes(app, props) {
       metadata: replayMetadata(sourceRun.metadata, body.metadata, sourceRun.runId)
     };
     if (body.stream !== void 0) replayRequest.stream = body.stream;
-    return executePipelineRun(c, props, pipeline, replayRequest);
+    return executeTrackedPipelineRun(c, props, pipeline, replayRequest);
   });
 }
-async function executePipelineRun(c, props, pipeline, body) {
+async function executeTrackedPipelineRun(c, props, pipeline, body) {
+  const lease = props.runLifecycle.start(c.req.raw.signal);
+  if (lease === void 0) {
+    return errorResponse(c, 503, "service_unavailable", "Anvia Studio is shutting down");
+  }
+  try {
+    return await executePipelineRun(c, props, pipeline, body, lease);
+  } catch (error) {
+    lease.finish();
+    throw error;
+  }
+}
+async function executePipelineRun(c, props, pipeline, body, lease) {
   const runId = globalThis.crypto.randomUUID();
   const startedAt = Date.now();
   const startedAtIso = new Date(startedAt).toISOString();
@@ -5063,12 +5243,13 @@ async function executePipelineRun(c, props, pipeline, body) {
       runId,
       input: body.input,
       startedAt,
-      startedAtIso
+      startedAtIso,
+      onFinish: lease.finish
     };
     if (body.metadata !== void 0) streamOptions.metadata = body.metadata;
     if (props.logStore !== void 0) streamOptions.logStore = props.logStore;
     if (props.runStore !== void 0) streamOptions.runStore = props.runStore;
-    streamOptions.abortSignal = c.req.raw.signal;
+    streamOptions.abortSignal = lease.abortSignal;
     return streamPipelineRun(c, streamOptions);
   }
   try {
@@ -5077,7 +5258,7 @@ async function executePipelineRun(c, props, pipeline, body) {
       input: body.input,
       runId,
       metadata: body.metadata,
-      abortSignal: c.req.raw.signal,
+      abortSignal: lease.abortSignal,
       observer: {
         async onEvent(event) {
           await appendPipelineLog(props.logStore, pipelineStageLog(event, pipeline.id));
@@ -5134,6 +5315,8 @@ async function executePipelineRun(c, props, pipeline, body) {
       pipelineRunFailedLog(pipeline.id, runId, error, startedAt)
     );
     return errorResponse(c, 500, "internal_error", "Pipeline run failed", serializeError(error));
+  } finally {
+    lease.finish();
   }
 }
 function pipelineDetail(pipeline) {
@@ -5232,7 +5415,11 @@ async function* pipelineRunEvents(props) {
       yield next.value;
     }
   } finally {
-    await run;
+    try {
+      await run;
+    } finally {
+      props.onFinish();
+    }
   }
 }
 async function savePipelineRun(store, input) {
@@ -5320,6 +5507,61 @@ function parsePipelineLogAfter(value) {
   return after;
 }
 
+// src/runtime/run-lifecycle.ts
+var StudioRunLifecycle = class {
+  shutdownController = new AbortController();
+  active = /* @__PURE__ */ new Set();
+  drainPromise;
+  resolveDrain;
+  closed = false;
+  start(requestSignal) {
+    if (this.closed) return void 0;
+    const token = /* @__PURE__ */ Symbol("studio-run");
+    this.active.add(token);
+    let finished = false;
+    return {
+      abortSignal: AbortSignal.any([requestSignal, this.shutdownController.signal]),
+      finish: () => {
+        if (finished) return;
+        finished = true;
+        this.active.delete(token);
+        if (this.active.size === 0) {
+          this.resolveDrain?.();
+          this.resolveDrain = void 0;
+          this.drainPromise = void 0;
+        }
+      }
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.shutdownController.abort(new Error("Anvia Studio is shutting down."));
+  }
+  async drain(timeoutMs) {
+    this.close();
+    if (this.active.size === 0) return;
+    this.drainPromise ??= new Promise((resolve2) => {
+      this.resolveDrain = resolve2;
+    });
+    await withTimeout(this.drainPromise, timeoutMs);
+  }
+};
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Anvia Studio shutdown timed out after ${timeoutMs}ms.`)),
+      timeoutMs
+    );
+  });
+  try {
+    await Promise.race([promise, timeout]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
 // src/runtime/sandbox-views.ts
 import { upgradeWebSocket } from "@hono/node-server";
 import { getConnInfo } from "@hono/node-server/conninfo";
@@ -6810,7 +7052,8 @@ var Studio = class {
   studio;
   server;
   websocketServer;
-  sigintHandler;
+  signalHandlers;
+  shutdownPromise;
   constructor(targets = [], options = {}) {
     this.options = studioOptionsFromTargets(targets, options);
     this.studio = createStudioApp(this.options);
@@ -6832,6 +7075,7 @@ var Studio = class {
   start(serveOptions = {}) {
     this.close();
     this.studio = createStudioApp(this.options);
+    this.shutdownPromise = void 0;
     const port = serveOptions.port ?? Number(process.env.RUNNER_PORT ?? 4021);
     const serverOptions = {
       fetch: (request, env) => this.studio.app.fetch(request, env),
@@ -6851,16 +7095,27 @@ var Studio = class {
       this.logAddress(host, port);
     }
     if (serveOptions.handleSignals ?? true) {
-      this.sigintHandler = () => {
-        this.close();
-        process.exit(0);
+      const shutdownFor = (signal) => {
+        process.exitCode = signal === "SIGINT" ? 130 : 143;
+        void this.shutdown(shutdownOptions(serveOptions.shutdownTimeoutMs)).catch(
+          (error) => {
+            console.error(error);
+            process.exitCode = 1;
+          }
+        );
+      };
+      this.signalHandlers = {
+        sigint: () => shutdownFor("SIGINT"),
+        sigterm: () => shutdownFor("SIGTERM")
       };
-      process.once("SIGINT", this.sigintHandler);
+      process.once("SIGINT", this.signalHandlers.sigint);
+      process.once("SIGTERM", this.signalHandlers.sigterm);
     }
     return this;
   }
   async serve(serveOptions = {}) {
-    const { onShutdown, signal, ...startOptions } = serveOptions;
+    const { onShutdown, shutdownTimeoutMs, signal, ...startOptions } = serveOptions;
+    const failures = [];
     try {
       this.start({ ...startOptions, log: false, handleSignals: false });
       const server = this.server;
@@ -6875,21 +7130,55 @@ var Studio = class {
         this.logAddress(startOptions.hostname ?? "localhost", port);
       }
       await waitForShutdown(signal);
-    } finally {
-      this.close();
+    } catch (error) {
+      failures.push(error);
+    }
+    try {
+      await this.shutdown(shutdownOptions(shutdownTimeoutMs));
+    } catch (error) {
+      failures.push(error);
+    }
+    try {
       await onShutdown?.();
+    } catch (error) {
+      failures.push(error);
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) {
+      throw new AggregateError(failures, "Failed to run and shut down Anvia Studio.");
     }
   }
   close() {
-    if (this.sigintHandler !== void 0) {
-      process.off("SIGINT", this.sigintHandler);
-      this.sigintHandler = void 0;
+    this.removeSignalHandlers();
+    this.closeNetwork();
+    this.studio.close();
+  }
+  shutdown(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return Promise.reject(
+        new TypeError("Anvia Studio shutdown timeoutMs must be a positive number.")
+      );
     }
+    this.shutdownPromise ??= this.shutdownResources(timeoutMs);
+    return this.shutdownPromise;
+  }
+  async shutdownResources(timeoutMs) {
+    this.removeSignalHandlers();
+    this.closeNetwork();
+    await this.studio.shutdown({ timeoutMs });
+  }
+  removeSignalHandlers() {
+    if (this.signalHandlers === void 0) return;
+    process.off("SIGINT", this.signalHandlers.sigint);
+    process.off("SIGTERM", this.signalHandlers.sigterm);
+    this.signalHandlers = void 0;
+  }
+  closeNetwork() {
     this.server?.close();
     this.server = void 0;
     this.websocketServer?.close();
     this.websocketServer = void 0;
-    this.studio.close();
   }
   logAddress(host, port) {
     if (isStudioUiEnabled(this.options.ui)) {
@@ -6900,6 +7189,9 @@ var Studio = class {
     }
   }
 };
+function shutdownOptions(timeoutMs) {
+  return timeoutMs === void 0 ? {} : { timeoutMs };
+}
 function waitForServerListening(server) {
   if (server.listening) return Promise.resolve();
   return new Promise((resolve2, reject) => {
@@ -6962,7 +7254,8 @@ function studioOptionsFromTargets(targets, options) {
   const runtimeOptions = {
     agents: inferStudioAgents(agents, options.quickPrompts ?? {}),
     pipelines: inferStudioPipelines(pipelines),
-    evals: options.evals ?? []
+    evals: options.evals ?? [],
+    graphs: options.graphs === void 0 ? [] : [...options.graphs]
   };
   if (options.models !== void 0) runtimeOptions.models = options.models;
   if (options.stores !== void 0) runtimeOptions.stores = options.stores;
@@ -7045,6 +7338,7 @@ function createStudioApp(options) {
   const pipelineMap = new Map(pipelines.map((pipeline) => [pipeline.id, pipeline]));
   const evalMap = new Map(options.evals.map((suite) => [suite.id ?? suite.name, suite]));
   const continuationRegistry = createStudioContinuationRegistry();
+  const runLifecycle = new StudioRunLifecycle();
   const sandboxRegistry = createStudioSandboxRegistry(agents, options.sandboxes ?? []);
   const memorySources = createStudioMemorySourceRegistry(agents, stores.sessions);
   const app = new HonoApp();
@@ -7102,12 +7396,14 @@ function createStudioApp(options) {
     evals: options.evals,
     evalMap
   });
+  registerGraphRoutes(app, options.graphs);
   const knowledgeOptions = { agents };
   if (stores.traces !== void 0) knowledgeOptions.traceStore = stores.traces;
   registerKnowledgeRoutes(app, knowledgeOptions);
   const pipelineOptions = {
     pipelines,
-    pipelineMap
+    pipelineMap,
+    runLifecycle
   };
   if (stores.pipelineLogs !== void 0) pipelineOptions.logStore = stores.pipelineLogs;
   if (stores.pipelineRuns !== void 0) pipelineOptions.runStore = stores.pipelineRuns;
@@ -7116,7 +7412,8 @@ function createStudioApp(options) {
     agentMap,
     stores,
     modelRegistry,
-    continuationRegistry
+    continuationRegistry,
+    runLifecycle
   });
   if (memorySources.size > 0 || stores.sessions !== void 0) {
     registerMemoryRoutes(app, {
@@ -7139,6 +7436,14 @@ function createStudioApp(options) {
     app.all(`/${capability}`, (c) => unsupportedCapability(c, capability));
     app.all(`/${capability}/*`, (c) => unsupportedCapability(c, capability));
   }
+  let closing = false;
+  const beginClose = () => {
+    if (closing) return;
+    closing = true;
+    continuationRegistry.clear();
+    closeSandboxViews();
+    runLifecycle.close();
+  };
   const studio = {
     app,
     fetch(request) {
@@ -7148,8 +7453,11 @@ function createStudioApp(options) {
       return buildConfig(options, agents, pipelines, stores, sandboxRegistry.size);
     },
     close() {
-      continuationRegistry.clear();
-      closeSandboxViews();
+      beginClose();
+    },
+    async shutdown(shutdownOptions2 = {}) {
+      beginClose();
+      await runLifecycle.drain(shutdownOptions2.timeoutMs ?? 3e4);
     }
   };
   if (stores.sessions !== void 0) Object.assign(studio, { sessionStore: stores.sessions });