@anvia/studio 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/index.js

@@ -3,6 +3,7 @@ import { Agent, getAgentToolState as getAgentToolState3 } from "@anvia/core/inte
 import { Pipeline } from "@anvia/core/pipeline";
 import { serve } from "@hono/node-server";
 import { Hono as HonoApp } from "hono";
+import { WebSocketServer } from "ws";
 
 // src/runtime/json.ts
 function toJsonValue(value) {
@@ -159,6 +160,20 @@ var StudioRunTraceObserver = class {
         this.observations.push(parentObservation);
         this.observations.push(...childTrace.observations(parentObservation.id));
       },
+      suspend: (suspendArgs) => {
+        this.observations.push(
+          traceObservation({
+            kind: "tool",
+            name: args.toolName,
+            status: "suspended",
+            turn: args.turn,
+            startedAt,
+            input: parseOrString(args.args),
+            output: toJsonValue({ interaction: suspendArgs.interaction }),
+            metadata: toolMetadata(args, false)
+          })
+        );
+      },
       error: (errorArgs) => {
         const parentObservation = traceObservation({
           kind: "tool",
@@ -176,14 +191,23 @@ var StudioRunTraceObserver = class {
     };
   }
   async end(args) {
-    await this.save("success", {
+    const result = {
+      runId: this.props.args.runId,
+      status: args.status,
+      text: args.text
+    };
+    if (args.resumedFrom !== void 0) result.resumedFrom = args.resumedFrom;
+    if (args.status === "completed") {
+      result.output = toJsonValue(args.output);
+    } else if (args.status === "blocked") {
+      result.stage = args.stage;
+    } else {
+      result.interaction = toJsonValue(args.interaction);
+    }
+    await this.save(args.status === "suspended" ? "suspended" : "success", {
       endedAt: /* @__PURE__ */ new Date(),
       output: args.status === "completed" ? traceOutput(args.output) : args.text,
-      result: {
-        status: args.status,
-        text: args.text,
-        ...args.status === "completed" ? { output: toJsonValue(args.output) } : { stage: args.stage }
-      },
+      result,
       usage: args.usage,
       messages: toJsonValue(args.messages)
     });
@@ -1319,7 +1343,7 @@ function requestModalities(request) {
   return modalities;
 }
 function requestMessages(request) {
-  return request.messages;
+  return request.type === "messages" ? request.messages : [];
 }
 function normalizeProviderId(id) {
   const trimmed = id.trim();
@@ -1611,6 +1635,7 @@ function isEventType(value) {
 import {
   customAgentEventsToClientStream
 } from "@anvia/client";
+import { parseAgentInteractionResponse } from "@anvia/core/agent";
 import {
   isJsonValue as isJsonValue2,
   parseMessages
@@ -1644,26 +1669,31 @@ function transcriptFromMessages(messages) {
         }
       }
       if (!textEntryAdded && attachments.length > 0) {
-        transcript.push({
+        const entry = {
           entryId: transcript.length,
           kind: "message",
           role: "user",
           text: "",
           attachments
-        });
+        };
+        transcript.push(entry);
       }
       continue;
     }
     if (message.role === "tool") {
       for (const content of message.content) {
-        transcript.push({
+        if (content.type !== "tool-result") {
+          continue;
+        }
+        const entry = {
           entryId: transcript.length,
           kind: "tool",
           toolName: content.toolName,
           callId: content.callId ?? content.toolCallId,
-          result: toolResultText(content.output),
-          ...content.output.type === "content" ? { structuredResult: content.output.value } : {}
-        });
+          result: toolResultText(content.output)
+        };
+        if (content.output.type === "content") entry.structuredResult = content.output.value;
+        transcript.push(entry);
       }
       continue;
     }
@@ -1774,46 +1804,6 @@ var AsyncEventQueue = class {
     return new Promise((resolve2) => this.resolvers.push(resolve2));
   }
 };
-async function* mergeRunAndApprovalEvents(runEvents, approvalEvents) {
-  const runIterator = runEvents[Symbol.asyncIterator]();
-  let runDone = false;
-  let runNext = runIterator.next();
-  let approvalNext = approvalEvents.next();
-  try {
-    while (runNext !== void 0 || approvalNext !== void 0) {
-      const pending = [];
-      if (runNext !== void 0) {
-        pending.push(runNext.then((value) => ({ source: "run", value })));
-      }
-      if (approvalNext !== void 0) {
-        pending.push(approvalNext.then((value) => ({ source: "approval", value })));
-      }
-      const result = await Promise.race(pending);
-      if (result.source === "run") {
-        if (result.value.done === true) {
-          runDone = true;
-          runNext = void 0;
-          approvalEvents.close();
-        } else {
-          runNext = runIterator.next();
-          yield result.value.value;
-        }
-        continue;
-      }
-      if (result.value.done === true) {
-        approvalNext = void 0;
-      } else {
-        approvalNext = approvalEvents.next();
-        yield result.value.value;
-      }
-    }
-  } finally {
-    if (!runDone && runIterator.return !== void 0) {
-      await runIterator.return();
-    }
-    approvalEvents.close();
-  }
-}
 function streamAgentRunEvents(_c, events, options) {
   return streamStudioClient({
     events: customAgentEventsToClientStream({
@@ -1824,52 +1814,6 @@ function streamAgentRunEvents(_c, events, options) {
   });
 }
 function studioEventToClientEvent(event, context) {
-  if (event.type === "tool_approval_request" || event.type === "tool_approval_result") {
-    return {
-      type: "tool_approval",
-      runId: context.runId,
-      ...context.turn === void 0 ? {} : { turn: context.turn },
-      ...context.scope === void 0 ? {} : { scope: context.scope },
-      approval: {
-        id: event.approval.id,
-        runId: event.approval.runId,
-        agentId: event.approval.agentId,
-        ...event.approval.sessionId === void 0 ? {} : { sessionId: event.approval.sessionId },
-        toolName: event.approval.toolName,
-        ...event.approval.callId === void 0 ? {} : { callId: event.approval.callId },
-        internalCallId: event.approval.internalCallId,
-        input: parseJsonOrString(event.approval.args),
-        status: event.approval.status,
-        requestedAt: event.approval.requestedAt,
-        ...event.approval.resolvedAt === void 0 ? {} : { resolvedAt: event.approval.resolvedAt },
-        ...event.approval.reason === void 0 ? {} : { reason: event.approval.reason }
-      }
-    };
-  }
-  if (event.type === "tool_question_request" || event.type === "tool_question_result") {
-    return {
-      type: "tool_question",
-      runId: context.runId,
-      ...context.turn === void 0 ? {} : { turn: context.turn },
-      ...context.scope === void 0 ? {} : { scope: context.scope },
-      question: {
-        id: event.question.id,
-        runId: event.question.runId,
-        agentId: event.question.agentId,
-        ...event.question.sessionId === void 0 ? {} : { sessionId: event.question.sessionId },
-        toolName: event.question.toolName,
-        ...event.question.callId === void 0 ? {} : { callId: event.question.callId },
-        internalCallId: event.question.internalCallId,
-        input: parseJsonOrString(event.question.args),
-        questions: event.question.questions,
-        status: event.question.status,
-        requestedAt: event.question.requestedAt,
-        ...event.question.answeredAt === void 0 ? {} : { answeredAt: event.question.answeredAt },
-        ...event.question.cancelledAt === void 0 ? {} : { cancelledAt: event.question.cancelledAt },
-        ...event.question.answers === void 0 ? {} : { answers: event.question.answers }
-      }
-    };
-  }
   if (event.type === "session_log" && isJsonValue2(event.log)) {
     return {
       type: "data",
@@ -1898,14 +1842,6 @@ function studioEventToClientEvent(event, context) {
   }
   return void 0;
 }
-function parseJsonOrString(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return isJsonValue2(parsed) ? parsed : value;
-  } catch {
-    return value;
-  }
-}
 function withAgentRunCancellation(events, onCancel) {
   const iterator = events[Symbol.asyncIterator]();
   let done = false;
@@ -2014,7 +1950,7 @@ function createPersistedStreamingSessionTranscript(props) {
         if (event.type === "final" || event.type === "error") {
           assignTranscriptRunDuration(transcript, Date.now() - props.startedAt);
         }
-        const eventStatus = event.type === "final" ? "success" : event.type === "error" ? "error" : "running";
+        const eventStatus = event.type === "final" ? event.result.status === "suspended" ? "suspended" : "success" : event.type === "error" ? "error" : "running";
         const saveInput = {
           id: props.session.id,
           runId: props.runId,
@@ -2024,7 +1960,7 @@ function createPersistedStreamingSessionTranscript(props) {
         };
         if (event.type === "error") saveInput.error = serializeError(event.error);
         await saveTranscript(saveInput);
-        const generatedMessages = event.type === "final" ? event.result.messages.slice(1) : [];
+        const generatedMessages = event.type === "final" ? event.result.messages.slice(props.generatedMessagesStartIndex ?? 1) : [];
         if (props.persistGeneratedMessages === true && generatedMessages.length > 0) {
           await props.store.append({
             scope: { sessionId: props.session.id },
@@ -2172,71 +2108,63 @@ function acceptTranscriptStreamEvent(transcript, event) {
     }
     appendChildAgentTranscriptEvent(matched, event);
   }
-  if (event.type === "tool_approval_request") {
-    const matched = findTranscriptToolEntry(
-      transcript,
-      event.approval.toolName,
-      approvalCallId(event.approval)
-    );
-    if (matched !== void 0) {
-      matched.approval = {
-        id: event.approval.id,
-        status: event.approval.status,
-        requestedAt: event.approval.requestedAt
-      };
-    }
-  }
-  if (event.type === "tool_approval_result") {
+  if (event.type === "final" && event.result.status === "suspended") {
+    const interaction = event.result.interaction;
     const matched = findTranscriptToolEntry(
       transcript,
-      event.approval.toolName,
-      approvalCallId(event.approval)
+      interaction.toolName,
+      interaction.callId ?? interaction.toolCallId
     );
-    if (matched !== void 0) {
+    if (matched !== void 0 && interaction.type === "tool-approval") {
       const approval = {
-        id: event.approval.id,
-        status: event.approval.status,
-        requestedAt: event.approval.requestedAt
+        id: interaction.id,
+        status: "pending",
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      if (event.approval.resolvedAt !== void 0) approval.resolvedAt = event.approval.resolvedAt;
-      if (event.approval.reason !== void 0) approval.reason = event.approval.reason;
+      if (interaction.reason !== void 0) approval.reason = interaction.reason;
       matched.approval = approval;
     }
-  }
-  if (event.type === "tool_question_request") {
-    const matched = findTranscriptToolEntry(
-      transcript,
-      event.question.toolName,
-      questionCallId(event.question)
-    );
-    if (matched !== void 0) {
+    if (matched !== void 0 && interaction.type === "tool-question") {
       matched.question = {
-        id: event.question.id,
-        status: event.question.status,
-        requestedAt: event.question.requestedAt,
-        questions: event.question.questions
+        id: interaction.id,
+        status: "pending",
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        questions: interaction.questions.map((question) => ({
+          id: question.id,
+          question: question.text,
+          choices: [...question.choices ?? []],
+          allowCustom: question.choices === void 0 || question.allowCustom === true
+        }))
       };
     }
   }
-  if (event.type === "tool_question_result") {
+  if (event.type === "interaction_response") {
+    const response = event.response;
     const matched = findTranscriptToolEntry(
       transcript,
-      event.question.toolName,
-      questionCallId(event.question)
+      response.toolName,
+      response.callId ?? response.toolCallId
     );
-    if (matched !== void 0) {
-      const question = {
-        id: event.question.id,
-        status: event.question.status,
-        requestedAt: event.question.requestedAt,
-        questions: event.question.questions
+    const respondedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (matched?.approval !== void 0 && response.type === "tool-approval-response") {
+      const approval = {
+        ...matched.approval,
+        status: response.approved ? "approved" : "rejected",
+        resolvedAt: respondedAt
+      };
+      if (response.reason !== void 0) approval.reason = response.reason;
+      matched.approval = approval;
+    }
+    if (matched?.question !== void 0 && response.type === "tool-question-response") {
+      matched.question = {
+        ...matched.question,
+        status: "answered",
+        answeredAt: respondedAt,
+        answers: response.answers.map((answer) => ({
+          questionId: answer.questionId,
+          answer: answer.value
+        }))
       };
-      if (event.question.answeredAt !== void 0) question.answeredAt = event.question.answeredAt;
-      if (event.question.cancelledAt !== void 0) {
-        question.cancelledAt = event.question.cancelledAt;
-      }
-      if (event.question.answers !== void 0) question.answers = event.question.answers;
-      matched.question = question;
     }
   }
   if (event.type === "final" && event.result.trace?.traceId !== void 0) {
@@ -2246,12 +2174,6 @@ function acceptTranscriptStreamEvent(transcript, event) {
     appendTranscriptAssistantError(transcript, errorText(event.error));
   }
 }
-function approvalCallId(approval) {
-  return approval.callId ?? approval.toolCallId;
-}
-function questionCallId(question) {
-  return question.callId ?? question.toolCallId;
-}
 function appendChildAgentTranscriptEvent(entry, event) {
   const childEvent = childAgentTranscriptEvent(event);
   if (childEvent === void 0) {
@@ -2524,6 +2446,42 @@ async function parseRunRequest(c) {
   return parseRunRequestOptions(c, body, request);
 }
 function parseRunRequestBody(c, body) {
+  if (body.type === "interaction_response") {
+    if (typeof body.interactionId !== "string" || body.interactionId.trim().length === 0) {
+      return { error: errorResponse(c, 400, "bad_request", "interactionId must be a string") };
+    }
+    if (body.messages !== void 0 || body.sessionId !== void 0 || body.model !== void 0) {
+      return {
+        error: errorResponse(
+          c,
+          400,
+          "bad_request",
+          "Interaction responses cannot include messages, sessionId, or model"
+        )
+      };
+    }
+    try {
+      return {
+        type: "interaction_response",
+        interactionId: body.interactionId,
+        response: parseAgentInteractionResponse(body.response)
+      };
+    } catch {
+      return {
+        error: errorResponse(c, 400, "bad_request", "response must be an interaction response")
+      };
+    }
+  }
+  if (body.type !== "messages") {
+    return {
+      error: errorResponse(
+        c,
+        400,
+        "bad_request",
+        'type must be "messages" or "interaction_response"'
+      )
+    };
+  }
   let messages;
   try {
     messages = parseMessages(body.messages);
@@ -2548,10 +2506,10 @@ function parseRunRequestBody(c, body) {
       error: errorResponse(c, 400, "bad_request", "The final message must be user-authored")
     };
   }
-  return { messages };
+  return { type: "messages", messages };
 }
 function parseRunRequestOptions(c, body, request) {
-  if ("sessionId" in body) {
+  if (request.type === "messages" && "sessionId" in body) {
     if (typeof body.sessionId !== "string" || body.sessionId.trim().length === 0) {
       return { error: errorResponse(c, 400, "bad_request", "sessionId must be a string") };
     }
@@ -2568,7 +2526,7 @@ function parseRunRequestOptions(c, body, request) {
     }
     request.stream = body.stream;
   }
-  if ("maxTurns" in body) {
+  if (request.type === "messages" && "maxTurns" in body) {
     if (!isNonNegativeInteger(body.maxTurns)) {
       return {
         error: errorResponse(c, 400, "bad_request", "maxTurns must be a non-negative integer")
@@ -2576,7 +2534,7 @@ function parseRunRequestOptions(c, body, request) {
     }
     request.maxTurns = body.maxTurns;
   }
-  if ("toolConcurrency" in body) {
+  if (request.type === "messages" && "toolConcurrency" in body) {
     if (!isPositiveInteger(body.toolConcurrency)) {
       return {
         error: errorResponse(c, 400, "bad_request", "toolConcurrency must be a positive integer")
@@ -2584,7 +2542,7 @@ function parseRunRequestOptions(c, body, request) {
     }
     request.toolConcurrency = body.toolConcurrency;
   }
-  if ("model" in body) {
+  if (request.type === "messages" && "model" in body) {
     if (isObject(body.model) && typeof body.model.providerId === "string" && typeof body.model.modelId === "string") {
       request.model = {
         providerId: body.model.providerId,
@@ -2877,102 +2835,78 @@ function logsFromStreamEvent(props) {
   }
   if (event.type === "final") {
     const result = event.result;
-    return [
-      runCompletedLog({
-        sessionId,
-        runId,
-        durationMs: Date.now() - props.startedAt,
-        usage: result.usage,
-        output: result.text,
-        messageCount: result.messages.length
-      }),
-      memorySavedLog({ sessionId, runId, messageCount: result.messages.length })
-    ];
-  }
-  if (event.type === "error") {
-    return [runFailedLog(sessionId, runId, event.error, props.startedAt)];
-  }
-  if (event.type === "tool_approval_request") {
-    const metadata = {
-      approvalId: event.approval.id,
-      toolName: event.approval.toolName,
-      status: event.approval.status,
-      hasReason: event.approval.reason !== void 0,
-      argumentBytes: byteLength2(event.approval.args)
-    };
-    if (event.approval.callId !== void 0) metadata.callId = event.approval.callId;
-    return [
-      {
+    const logs = [];
+    if (result.status === "suspended") {
+      logs.push({
         sessionId,
         runId,
         level: "info",
-        category: "approval",
-        event: "approval.requested",
-        message: `Approval requested for ${event.approval.toolName}`,
-        metadata
-      }
-    ];
-  }
-  if (event.type === "tool_approval_result") {
-    const metadata = {
-      approvalId: event.approval.id,
-      toolName: event.approval.toolName,
-      status: event.approval.status,
-      hasReason: event.approval.reason !== void 0
-    };
-    if (event.approval.callId !== void 0) metadata.callId = event.approval.callId;
-    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
-      }
-    ];
-  }
-  if (event.type === "tool_question_request") {
-    const metadata = {
-      questionId: event.question.id,
-      toolName: event.question.toolName,
-      status: event.question.status,
-      questionCount: event.question.questions.length,
-      argumentBytes: byteLength2(event.question.args)
-    };
-    if (event.question.callId !== void 0) metadata.callId = event.question.callId;
-    return [
-      {
+        category: "run",
+        event: "run.suspended",
+        message: `Run suspended for ${result.interaction.type}`,
+        metadata: {
+          interactionId: result.interaction.id,
+          interactionType: result.interaction.type,
+          toolName: result.interaction.toolName,
+          sourceRunId: result.continuation.sourceRunId
+        }
+      });
+    } else {
+      logs.push(
+        runCompletedLog({
+          sessionId,
+          runId,
+          durationMs: Date.now() - props.startedAt,
+          usage: result.usage,
+          output: result.text,
+          messageCount: result.messages.length
+        })
+      );
+    }
+    if (result.resumedFrom !== void 0) {
+      logs.push({
         sessionId,
         runId,
         level: "info",
-        category: "question",
-        event: "question.requested",
-        message: `Question requested by ${event.question.toolName}`,
-        metadata
-      }
-    ];
+        category: "run",
+        event: "interaction.resumed",
+        message: "Interaction resumed in a linked run",
+        metadata: {
+          interactionId: result.resumedFrom.interactionId,
+          sourceRunId: result.resumedFrom.runId,
+          resumedRunId: result.runId
+        }
+      });
+    }
+    logs.push(memorySavedLog({ sessionId, runId, messageCount: result.messages.length }));
+    return logs;
+  }
+  if (event.type === "error") {
+    return [runFailedLog(sessionId, runId, event.error, props.startedAt)];
   }
-  if (event.type === "tool_question_result") {
-    const cancelled = event.question.status === "cancelled";
+  if (event.type === "interaction_response") {
+    const response = event.response;
     const metadata = {
-      questionId: event.question.id,
-      toolName: event.question.toolName,
-      status: event.question.status,
-      questionCount: event.question.questions.length,
-      argumentBytes: byteLength2(event.question.args),
-      answerCount: event.question.answers?.length ?? 0
+      interactionId: response.interactionId,
+      interactionType: response.type === "tool-approval-response" ? "tool-approval" : "tool-question",
+      toolName: response.toolName,
+      sourceRunId: event.sourceRunId
     };
-    if (event.question.callId !== void 0) metadata.callId = event.question.callId;
+    if (response.callId !== void 0) metadata.callId = response.callId;
+    if (response.type === "tool-approval-response") {
+      metadata.approved = response.approved;
+      metadata.hasReason = response.reason !== void 0;
+    } else {
+      metadata.answerCount = response.answers.length;
+    }
     return [
       {
         sessionId,
         runId,
         level: "info",
-        category: "question",
-        event: cancelled ? "question.cancelled" : "question.answered",
-        message: cancelled ? `Question cancelled for ${event.question.toolName}` : `Question answered for ${event.question.toolName}`,
+        category: "run",
+        event: "interaction.responded",
+        message: `Interaction response received for ${response.toolName}`,
         metadata
       }
     ];
@@ -3167,6 +3101,56 @@ async function prepareAgentRun(c, props) {
   if ("error" in body) {
     return body.error;
   }
+  if (body.type === "interaction_response") {
+    const registration = props.continuationRegistry.take(
+      body.interactionId,
+      agentId,
+      body.response
+    );
+    if (registration.status === "missing") {
+      return errorResponse(c, 404, "not_found", "Interaction continuation is unavailable");
+    }
+    if (registration.status === "claimed") {
+      return errorResponse(c, 409, "conflict", "Interaction response was already claimed");
+    }
+    if (registration.status === "invalid") {
+      return errorResponse(c, 400, "bad_request", registration.error.message);
+    }
+    const { registration: claimed } = registration;
+    const source = claimed.context;
+    const runId2 = globalThis.crypto.randomUUID();
+    let resumedBody = {
+      ...source.body
+    };
+    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 execution2 = {
+      generate: (options) => source.runAgent.generate({
+        continuation: claimed.continuation,
+        response: body.response,
+        ...options
+      }),
+      stream: (options) => source.runAgent.stream({
+        continuation: claimed.continuation,
+        response: body.response,
+        ...options
+      })
+    };
+    return {
+      ...source,
+      body: resumedBody,
+      execution: execution2,
+      failureMessages: void 0,
+      memoryCompactionLogged: false,
+      options: runOptions,
+      runId: runId2,
+      runStartedAt: Date.now(),
+      generatedMessagesStartIndex: 0,
+      shouldPersistSessionMessages: source.shouldPersistSessionMessages
+    };
+  }
   const session = await resolveRunSession(c, body, agentId, props.stores);
   if (session instanceof Response) {
     return session;
@@ -3224,6 +3208,7 @@ async function prepareAgentRun(c, props) {
     runAgent,
     runId,
     runStartedAt,
+    generatedMessagesStartIndex: 1,
     selectedModel,
     session,
     sessionStore,
@@ -3336,8 +3321,10 @@ function createRunExecution(props) {
 }
 function createRunOptions(body, agentId, session, abortSignal) {
   const options = { abortSignal };
-  if (body.maxTurns !== void 0) options.maxTurns = body.maxTurns;
-  if (body.toolConcurrency !== void 0) options.toolConcurrency = body.toolConcurrency;
+  if (body.type === "messages" && body.maxTurns !== void 0) options.maxTurns = body.maxTurns;
+  if (body.type === "messages" && body.toolConcurrency !== void 0) {
+    options.toolConcurrency = body.toolConcurrency;
+  }
   if (body.trace !== void 0) {
     options.trace = traceForRun(body.trace, agentId, session);
   } else if (session !== void 0) {
@@ -3346,34 +3333,11 @@ function createRunOptions(body, agentId, session, abortSignal) {
   return options;
 }
 function handleStreamingAgentRun(c, run, props) {
-  const runtimeEvents = new AsyncEventQueue();
-  const approvalContext = {
-    runId: run.runId,
-    agentId: run.agentId,
-    emit: (event) => runtimeEvents.push(event)
-  };
-  if (run.session !== void 0) approvalContext.sessionId = run.session.id;
-  if (run.body.metadata !== void 0) approvalContext.metadata = run.body.metadata;
-  const questionContext = {
-    runId: run.runId,
-    agentId: run.agentId,
-    emit: (event) => runtimeEvents.push(event)
-  };
-  if (run.session !== void 0) questionContext.sessionId = run.session.id;
-  if (run.body.metadata !== void 0) questionContext.metadata = run.body.metadata;
-  const effectiveHook = props.questionRuntime.createHook(questionContext);
-  const streamOptions = withInternalAgentRunOptions(
-    { ...run.options },
-    { hook: effectiveHook, runId: run.runId }
-  );
-  const runStream = mergeRunAndApprovalEvents(
-    resumeStreamingApprovals(
-      run.runAgent,
-      run.execution.stream(streamOptions),
-      props.approvalRuntime,
-      approvalContext
-    ),
-    runtimeEvents
+  const streamOptions = withInternalAgentRunOptions({ ...run.options }, { runId: run.runId });
+  const runStream = registerStreamingContinuation(
+    run.execution.stream(streamOptions),
+    props.continuationRegistry,
+    run
   );
   let stream = runStream;
   let persistedRun;
@@ -3391,15 +3355,14 @@ function handleStreamingAgentRun(c, run, props) {
       message: run.body.messages.at(-1),
       runId: run.runId,
       startedAt: run.runStartedAt,
-      persistGeneratedMessages: run.shouldPersistSessionMessages
+      persistGeneratedMessages: run.shouldPersistSessionMessages,
+      generatedMessagesStartIndex: run.generatedMessagesStartIndex
     });
     stream = persistedRun.events;
   }
   return streamAgentRunEvents(c, stream, {
     runId: run.runId,
     onCancel: async () => {
-      props.approvalRuntime.cancelRun(run.runId);
-      props.questionRuntime.cancelRun(run.runId);
       const persistence = [];
       if (persistedRun !== void 0) {
         persistence.push(persistedRun.cancel());
@@ -3418,35 +3381,29 @@ function handleStreamingAgentRun(c, run, props) {
 }
 async function handleBufferedAgentRun(c, run, props) {
   try {
-    const runtimeOptions = await startBufferedSessionRun(run, props);
-    let result = await run.execution.generate(runtimeOptions);
-    const approvalContext = createApprovalContext(run);
-    while (result.status === "approval_required") {
-      const decision = await props.approvalRuntime.request(approvalContext, result.approval);
-      result = await run.runAgent.resume(result, decision);
-    }
-    const response = result;
-    await completeBufferedSessionRun(run, response);
-    return c.json(response);
+    const runtimeOptions = await startBufferedSessionRun(run);
+    const result = await run.execution.generate(runtimeOptions);
+    if (result.status === "suspended") {
+      props.continuationRegistry.register({ continuation: result.continuation, context: run });
+    }
+    await completeBufferedSessionRun(run, result);
+    return c.json(agentRunResponse(result));
   } catch (error) {
     await failBufferedSessionRun(run, error);
     return errorResponse(c, 500, "internal_error", "Agent run failed", serializeError(error));
   }
 }
-async function startBufferedSessionRun(run, props) {
+function agentRunResponse(result) {
+  if (result.status !== "suspended") return result;
+  const { continuation: _continuation, messages: _messages, ...response } = result;
+  return response;
+}
+async function startBufferedSessionRun(run) {
   if (run.session !== void 0) {
     await appendSessionLog(run.sessionStore, runStartedLog(run.session, run.runId));
     await appendSessionLog(run.sessionStore, memoryLoadedLog(run.session, run.runId));
   }
-  const questionContext = {
-    runId: run.runId,
-    agentId: run.agentId
-  };
-  if (run.session !== void 0) questionContext.sessionId = run.session.id;
-  if (run.body.metadata !== void 0) questionContext.metadata = run.body.metadata;
-  const effectiveHook = props.questionRuntime.createHook(questionContext);
   const internalOptions = {
-    hook: effectiveHook,
     onFailure: ({ messages }) => {
       run.failureMessages = structuredClone(messages);
     },
@@ -3469,30 +3426,12 @@ async function startBufferedSessionRun(run, props) {
   }
   return withInternalAgentRunOptions({ ...run.options }, internalOptions);
 }
-function createApprovalContext(run, emit) {
-  const context = {
-    runId: run.runId,
-    agentId: run.agentId
-  };
-  if (run.session !== void 0) context.sessionId = run.session.id;
-  if (run.body.metadata !== void 0) context.metadata = run.body.metadata;
-  if (emit !== void 0) context.emit = emit;
-  return context;
-}
-async function* resumeStreamingApprovals(agent, initialStream, approvalRuntime, context) {
-  let stream = initialStream;
-  while (true) {
-    let pending;
-    for await (const event of stream) {
-      if (event.type === "approval_required") {
-        pending = event;
-        break;
-      }
-      yield event;
+async function* registerStreamingContinuation(stream, registry, run) {
+  for await (const event of stream) {
+    if (event.type === "final" && event.result.status === "suspended") {
+      registry.register({ continuation: event.result.continuation, context: run });
     }
-    if (pending === void 0) return;
-    const decision = await approvalRuntime.request(context, pending.approval);
-    stream = agent.resume(pending, decision);
+    yield event;
   }
 }
 async function completeBufferedSessionRun(run, response) {
@@ -3500,7 +3439,7 @@ async function completeBufferedSessionRun(run, response) {
     return;
   }
   if (run.shouldPersistSessionMessages) {
-    const generatedMessages = response.messages.slice(1);
+    const generatedMessages = response.messages.slice(run.generatedMessagesStartIndex);
     if (generatedMessages.length > 0) {
       await run.sessionStore.append({
         scope: { sessionId: run.session.id, metadata: run.memoryMetadata },
@@ -3518,7 +3457,7 @@ async function completeBufferedSessionRun(run, response) {
     runId: run.runId,
     ...optionalTitle(run.body.messages.at(-1)),
     transcript,
-    status: "success"
+    status: response.status === "suspended" ? "suspended" : "success"
   });
   if (response.memoryCompaction !== void 0 && !run.memoryCompactionLogged) {
     await appendSessionLog(
@@ -3533,7 +3472,20 @@ async function completeBufferedSessionRun(run, response) {
   }
   await appendSessionLog(
     run.sessionStore,
-    runCompletedLog({
+    response.status === "suspended" ? {
+      sessionId: run.session.id,
+      runId: run.runId,
+      level: "info",
+      category: "run",
+      event: "run.suspended",
+      message: `Run suspended for ${response.interaction.type}`,
+      metadata: {
+        interactionId: response.interaction.id,
+        interactionType: response.interaction.type,
+        toolName: response.interaction.toolName,
+        sourceRunId: response.continuation.sourceRunId
+      }
+    } : runCompletedLog({
       sessionId: run.session.id,
       runId: run.runId,
       durationMs: durationMs2,
@@ -3542,6 +3494,46 @@ async function completeBufferedSessionRun(run, response) {
       messageCount: response.messages.length
     })
   );
+  if (response.resumedFrom !== void 0) {
+    const responseMessage = response.messages[0];
+    const responsePart = responseMessage?.role === "tool" ? responseMessage.content[0] : void 0;
+    if (responsePart !== void 0 && responsePart.type !== "tool-result") {
+      const metadata = {
+        interactionId: responsePart.interactionId,
+        interactionType: responsePart.type === "tool-approval-response" ? "tool-approval" : "tool-question",
+        toolName: responsePart.toolName,
+        sourceRunId: response.resumedFrom.runId
+      };
+      if (responsePart.type === "tool-approval-response") {
+        metadata.approved = responsePart.approved;
+        metadata.hasReason = responsePart.reason !== void 0;
+      } else {
+        metadata.answerCount = responsePart.answers.length;
+      }
+      await appendSessionLog(run.sessionStore, {
+        sessionId: run.session.id,
+        runId: run.runId,
+        level: "info",
+        category: "run",
+        event: "interaction.responded",
+        message: `Interaction response received for ${responsePart.toolName}`,
+        metadata
+      });
+    }
+    await appendSessionLog(run.sessionStore, {
+      sessionId: run.session.id,
+      runId: run.runId,
+      level: "info",
+      category: "run",
+      event: "interaction.resumed",
+      message: "Interaction resumed in a linked run",
+      metadata: {
+        interactionId: response.resumedFrom.interactionId,
+        sourceRunId: response.resumedFrom.runId,
+        resumedRunId: response.runId
+      }
+    });
+  }
   await appendSessionLog(
     run.sessionStore,
     memorySavedLog({
@@ -3577,286 +3569,48 @@ function usesStoreAsAgentMemory(agent, store) {
   return memoryStore !== void 0 && rawObservedStore(memoryStore) === rawObservedStore(store);
 }
 
-// src/runtime/approvals.ts
-import { getAgentApprovalRequestDetails } from "@anvia/core/internal/agent";
+// src/runtime/config.ts
+import { isQuestionTool } from "@anvia/core/tool";
 
-// src/runtime/query.ts
-function optionalQueryString(value) {
-  const trimmed = value?.trim();
-  return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+// src/runtime/eval-config.ts
+var CASE_PREVIEW_LIMIT = 5;
+var PREVIEW_VALUE_MAX_LENGTH = 500;
+function evalConfig(suite) {
+  const casePreviews = suite.cases.slice(0, CASE_PREVIEW_LIMIT).map(casePreview);
+  const metricSummaries = suite.metrics.map(metricSummary);
+  const config = {
+    id: suite.id ?? suite.name,
+    name: suite.name,
+    caseCount: suite.cases.length,
+    metricNames: suite.metrics.map((metric) => metric.name),
+    casePreviewCount: casePreviews.length,
+    casePreviews,
+    metricSummaries
+  };
+  if (suite.description !== void 0) config.description = suite.description;
+  if (suite.concurrency !== void 0) config.concurrency = suite.concurrency;
+  if (suite.metadata !== void 0) config.metadata = suite.metadata;
+  return config;
 }
-function parseLimit(value, defaultMax = 50, max = 100) {
-  if (value === void 0 || value.trim().length === 0) {
-    return defaultMax;
-  }
-  const limit = Number(value);
-  if (!Number.isInteger(limit) || limit <= 0) {
-    return void 0;
+function casePreview(testCase, index) {
+  if (!isRecord2(testCase)) {
+    return {
+      id: `case-${index + 1}`,
+      input: previewValue(testCase)
+    };
   }
-  return Math.min(limit, max);
+  const preview = {
+    id: typeof testCase.id === "string" && testCase.id.length > 0 ? testCase.id : `case-${index + 1}`
+  };
+  if ("input" in testCase) preview.input = previewValue(testCase.input);
+  if ("expected" in testCase) preview.expected = previewValue(testCase.expected);
+  const keys = metadataKeys(testCase.metadata);
+  if (keys !== void 0) preview.metadataKeys = keys;
+  return preview;
 }
-function parseTraceStatus(value) {
-  const status = optionalQueryString(value);
-  if (status === void 0) {
-    return void 0;
-  }
-  return status === "running" || status === "success" || status === "error" ? status : false;
-}
-function parseAfter(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;
-}
-
-// src/runtime/approvals.ts
-function registerApprovalRoutes(app, approvals) {
-  app.get("/approvals", (c) => {
-    const status = parseApprovalStatus(c.req.query("status"));
-    if (status === false) {
-      return errorResponse(c, 400, "bad_request", "status must be pending or resolved");
-    }
-    const options = {};
-    const runId = optionalQueryString(c.req.query("runId"));
-    const agentId = optionalQueryString(c.req.query("agentId"));
-    const sessionId = optionalQueryString(c.req.query("sessionId"));
-    if (status !== void 0) {
-      options.status = status;
-    }
-    if (runId !== void 0) {
-      options.runId = runId;
-    }
-    if (agentId !== void 0) {
-      options.agentId = agentId;
-    }
-    if (sessionId !== void 0) {
-      options.sessionId = sessionId;
-    }
-    return c.json({
-      approvals: approvals.list(options)
-    });
-  });
-  app.post("/approvals/:approvalId/decision", async (c) => {
-    const body = await parseApprovalDecisionRequest(c);
-    if ("error" in body) {
-      return body.error;
-    }
-    const result = approvals.decide(c.req.param("approvalId"), body);
-    if (result === "missing") {
-      return errorResponse(c, 404, "not_found", "Approval not found");
-    }
-    if (result === "resolved") {
-      return errorResponse(c, 409, "conflict", "Approval is already resolved");
-    }
-    return c.json(result);
-  });
-}
-function parseApprovalStatus(value) {
-  const status = optionalQueryString(value);
-  if (status === void 0) {
-    return void 0;
-  }
-  return status === "pending" || status === "resolved" ? status : false;
-}
-async function parseApprovalDecisionRequest(c) {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch {
-    return { error: errorResponse(c, 400, "bad_request", "Request body must be JSON") };
-  }
-  if (!isObject(body)) {
-    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
-  }
-  if (typeof body.approved !== "boolean") {
-    return { error: errorResponse(c, 400, "bad_request", "approved must be a boolean") };
-  }
-  if ("reason" in body && typeof body.reason !== "string") {
-    return { error: errorResponse(c, 400, "bad_request", "reason must be a string") };
-  }
-  const reason = typeof body.reason === "string" && body.reason.trim().length > 0 ? body.reason.trim() : void 0;
-  return approvalDecision(body.approved, reason);
-}
-function createApprovalRuntime() {
-  const approvals = /* @__PURE__ */ new Map();
-  return {
-    approvals,
-    async request(context, approval) {
-      const decision = await requestApproval(approvals, context, approval);
-      return decision.approved ? { approved: true, ...decision.reason === void 0 ? {} : { reason: decision.reason } } : {
-        approved: false,
-        ...decision.reason === void 0 ? {} : { reason: decision.reason }
-      };
-    },
-    list(options) {
-      return [...approvals.values()].filter((approval) => {
-        if (options.status === "pending" && approval.status !== "pending") {
-          return false;
-        }
-        if (options.status === "resolved" && approval.status === "pending") {
-          return false;
-        }
-        if (options.runId !== void 0 && approval.runId !== options.runId) {
-          return false;
-        }
-        if (options.agentId !== void 0 && approval.agentId !== options.agentId) {
-          return false;
-        }
-        if (options.sessionId !== void 0 && approval.sessionId !== options.sessionId) {
-          return false;
-        }
-        return true;
-      }).map(publicApproval);
-    },
-    cancelRun(runId) {
-      const cancelled = [];
-      for (const approval of approvals.values()) {
-        if (!isPendingApproval(approval) || approval.runId !== runId) {
-          continue;
-        }
-        const resolved = resolveApproval(approval, "cancelled", {
-          reason: "Run cancelled in Anvia Studio."
-        });
-        approvals.set(approval.id, resolved);
-        approval.emit?.({ type: "tool_approval_result", approval: resolved });
-        approval.resolve(approvalDecision(false, resolved.reason));
-        cancelled.push(resolved);
-      }
-      return cancelled;
-    },
-    decide(id, decision) {
-      const approval = approvals.get(id);
-      if (approval === void 0) {
-        return "missing";
-      }
-      if (!isPendingApproval(approval)) {
-        return "resolved";
-      }
-      const reason = decision.approved ? decision.reason : decision.reason ?? approval.rejectMessage ?? "Rejected in Anvia Studio.";
-      const resolved = resolveApproval(
-        approval,
-        decision.approved ? "approved" : "rejected",
-        reason === void 0 ? {} : { reason }
-      );
-      approvals.set(id, resolved);
-      approval.emit?.({ type: "tool_approval_result", approval: resolved });
-      approval.resolve(approvalDecision(decision.approved, reason));
-      return publicApproval(resolved);
-    }
-  };
-}
-async function requestApproval(approvals, context, request) {
-  const id = request.id;
-  const details = getAgentApprovalRequestDetails(request);
-  const approval = {
-    id,
-    runId: context.runId,
-    agentId: context.agentId,
-    toolName: request.toolName,
-    internalCallId: details?.internalCallId ?? request.id,
-    args: details?.rawArgs ?? JSON.stringify(request.input) ?? "null",
-    status: "pending",
-    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resolve: () => {
-    }
-  };
-  if (context.sessionId !== void 0) approval.sessionId = context.sessionId;
-  if (request.toolCallId !== void 0) approval.callId = request.toolCallId;
-  if (request.reason !== void 0) approval.reason = request.reason;
-  if (details?.rejectMessage !== void 0) approval.rejectMessage = details.rejectMessage;
-  if (context.emit !== void 0) approval.emit = context.emit;
-  const decision = new Promise((resolve2) => {
-    approval.resolve = (decision2) => {
-      const current = approvals.get(id);
-      if (!isPendingApproval(current)) {
-        if (current !== void 0) {
-          resolve2(approvalDecision(current.status === "approved", current.reason));
-        }
-        return;
-      }
-      const reason = decision2.approved ? decision2.reason : decision2.reason ?? details?.rejectMessage ?? "Rejected in Anvia Studio.";
-      const resolved = resolveApproval(
-        current,
-        decision2.approved ? "approved" : "rejected",
-        reason === void 0 ? {} : { reason }
-      );
-      approvals.set(id, resolved);
-      context.emit?.({ type: "tool_approval_result", approval: resolved });
-      resolve2(approvalDecision(decision2.approved, reason));
-    };
-  });
-  approvals.set(id, approval);
-  context.emit?.({ type: "tool_approval_request", approval: publicApproval(approval) });
-  return decision;
-}
-function isPendingApproval(approval) {
-  return approval !== void 0 && approval.status === "pending" && "resolve" in approval;
-}
-function resolveApproval(approval, status, options = {}) {
-  const resolved = {
-    ...approval,
-    status,
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (options.reason !== void 0) resolved.reason = options.reason;
-  return publicApproval(resolved);
-}
-function approvalDecision(approved, reason) {
-  const decision = { approved };
-  if (reason !== void 0) decision.reason = reason;
-  return decision;
-}
-function publicApproval(approval) {
-  const { emit, rejectMessage, resolve: resolve2, ...rest } = approval;
-  void emit;
-  void rejectMessage;
-  void resolve2;
-  return rest;
-}
-
-// src/runtime/eval-config.ts
-var CASE_PREVIEW_LIMIT = 5;
-var PREVIEW_VALUE_MAX_LENGTH = 500;
-function evalConfig(suite) {
-  const casePreviews = suite.cases.slice(0, CASE_PREVIEW_LIMIT).map(casePreview);
-  const metricSummaries = suite.metrics.map(metricSummary);
-  const config = {
-    id: suite.id ?? suite.name,
-    name: suite.name,
-    caseCount: suite.cases.length,
-    metricNames: suite.metrics.map((metric) => metric.name),
-    casePreviewCount: casePreviews.length,
-    casePreviews,
-    metricSummaries
-  };
-  if (suite.description !== void 0) config.description = suite.description;
-  if (suite.concurrency !== void 0) config.concurrency = suite.concurrency;
-  if (suite.metadata !== void 0) config.metadata = suite.metadata;
-  return config;
-}
-function casePreview(testCase, index) {
-  if (!isRecord2(testCase)) {
-    return {
-      id: `case-${index + 1}`,
-      input: previewValue(testCase)
-    };
-  }
-  const preview = {
-    id: typeof testCase.id === "string" && testCase.id.length > 0 ? testCase.id : `case-${index + 1}`
-  };
-  if ("input" in testCase) preview.input = previewValue(testCase.input);
-  if ("expected" in testCase) preview.expected = previewValue(testCase.expected);
-  const keys = metadataKeys(testCase.metadata);
-  if (keys !== void 0) preview.metadataKeys = keys;
-  return preview;
-}
-function metricSummary(metric, index) {
-  if (!isRecord2(metric)) {
-    return { name: `metric-${index + 1}` };
+function metricSummary(metric, index) {
+  if (!isRecord2(metric)) {
+    return { name: `metric-${index + 1}` };
   }
   const summary = {
     name: typeof metric.name === "string" && metric.name.length > 0 ? metric.name : `metric-${index + 1}`
@@ -3898,6 +3652,41 @@ function isRecord2(value) {
 
 // src/runtime/knowledge.ts
 import { getAgentToolState } from "@anvia/core/internal/agent";
+
+// src/runtime/query.ts
+function optionalQueryString(value) {
+  const trimmed = value?.trim();
+  return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+}
+function parseLimit(value, defaultMax = 50, max = 100) {
+  if (value === void 0 || value.trim().length === 0) {
+    return defaultMax;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    return void 0;
+  }
+  return Math.min(limit, max);
+}
+function parseTraceStatus(value) {
+  const status = optionalQueryString(value);
+  if (status === void 0) {
+    return void 0;
+  }
+  return status === "running" || status === "success" || status === "suspended" || status === "error" ? status : false;
+}
+function parseAfter(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;
+}
+
+// src/runtime/knowledge.ts
 function registerKnowledgeRoutes(app, props) {
   app.get("/knowledge", async (c) => {
     const limit = parseLimit(c.req.query("limit"));
@@ -4446,8 +4235,10 @@ function capabilityConfig(_options, agents, pipelines, stores, sandboxCount = 0)
   if (sandboxCount > 0) {
     capabilities.sandboxes = { enabled: true };
   }
-  if (agents.some((agent) => agent.agent.tools.some(toolRequiresApproval))) {
-    capabilities.approvals = { enabled: true };
+  if (agents.some(
+    (agent) => agent.agent.tools.some((tool) => toolRequiresApproval(tool) || isQuestionTool(tool))
+  )) {
+    capabilities.interactions = { enabled: true };
   }
   if (agents.some(agentHasKnowledge)) {
     capabilities.knowledge = { enabled: true };
@@ -4529,6 +4320,47 @@ async function parseEvalRunRequest(c) {
   return request;
 }
 
+// src/runtime/interactions.ts
+import {
+  assertAgentInteractionResponse
+} from "@anvia/core/agent";
+function createStudioContinuationRegistry() {
+  const pending = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Set();
+  return {
+    register(registration) {
+      const id = registration.continuation.interaction.id;
+      if (pending.has(id) || claimed.has(id)) {
+        throw new TypeError(`Duplicate Studio interaction ID "${id}".`);
+      }
+      pending.set(id, registration);
+    },
+    take(interactionId, agentId, response) {
+      if (claimed.has(interactionId)) return { status: "claimed" };
+      const registration = pending.get(interactionId);
+      if (registration === void 0 || registration.continuation.agentId !== agentId) {
+        return { status: "missing" };
+      }
+      const request = registration.continuation.interaction;
+      try {
+        assertAgentInteractionResponse(request, response);
+      } catch (error) {
+        return {
+          status: "invalid",
+          error: error instanceof TypeError ? error : new TypeError(String(error))
+        };
+      }
+      pending.delete(interactionId);
+      claimed.add(interactionId);
+      return { status: "ready", registration };
+    },
+    clear() {
+      pending.clear();
+      claimed.clear();
+    }
+  };
+}
+
 // src/runtime/mcps.ts
 function registerMcpRoutes(app, props) {
   app.get("/agents/:agentId/mcps", async (c) => {
@@ -5481,272 +5313,284 @@ function parsePipelineLogAfter(value) {
   return after;
 }
 
-// src/runtime/questions.ts
-import { createHook } from "@anvia/core/internal/agent";
-import { parseToolArgs } from "@anvia/core/tool";
-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) });
+// src/runtime/sandbox-views.ts
+import { upgradeWebSocket } from "@hono/node-server";
+import { getConnInfo } from "@hono/node-server/conninfo";
+import { WebSocket } from "ws";
+var minLeaseTimeoutMs = 5e3;
+var maxLeaseTimeoutMs = 12e4;
+var maxPendingWebSocketBytes = 1024 * 1024;
+function registerSandboxViewRoutes(app, registry) {
+  const leases = /* @__PURE__ */ new Map();
+  const upstreamSockets = /* @__PURE__ */ new Set();
+  app.get("/sandboxes/:sandboxRef/views/:viewId/control", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    pruneExpiredLease(leases, viewKey(resolved));
+    return c.json(resolved.view.source.control.snapshot());
   });
-  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);
+  app.get("/sandboxes/:sandboxRef/views/:viewId/connection", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    const response = {
+      sandboxRef: resolved.entry.summary.ref,
+      viewId: resolved.view.id,
+      protocol: "novnc",
+      websocketPath: `/sandboxes/${encodeURIComponent(resolved.entry.summary.ref)}/views/${encodeURIComponent(resolved.view.id)}/ws`,
+      authentication: resolved.view.authentication.type === "password" ? { type: "password", password: resolved.view.authentication.password } : { type: "none" }
+    };
+    c.header("cache-control", "no-store");
+    return c.json(response);
   });
-}
-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") };
+  app.post("/sandboxes/:sandboxRef/views/:viewId/control/acquire", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    const body = await readControlBody(c);
+    if (body instanceof Response) return body;
+    const key = viewKey(resolved);
+    pruneExpiredLease(leases, key);
+    if (leases.has(key)) {
+      return errorResponse(c, 409, "conflict", "Browser view is already controlled");
     }
-    if (typeof answer.answer !== "string" || answer.answer.trim().length === 0) {
-      return { error: errorResponse(c, 400, "bad_request", "answer must be a string") };
+    try {
+      const lease = await resolved.view.source.control.acquireHumanControl({
+        ownerId: body.ownerId,
+        leaseTimeoutMs: body.leaseTimeoutMs,
+        abortSignal: c.req.raw.signal
+      });
+      leases.set(key, lease);
+      return c.json(leaseResponse(lease), 201);
+    } catch (error) {
+      return controlErrorResponse(c, error);
     }
-    if ("choice" in answer && typeof answer.choice !== "string") {
-      return { error: errorResponse(c, 400, "bad_request", "choice must be a string") };
+  });
+  app.post("/sandboxes/:sandboxRef/views/:viewId/control/renew", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    const body = await readLeaseBody(c);
+    if (body instanceof Response) return body;
+    const key = viewKey(resolved);
+    pruneExpiredLease(leases, key);
+    const lease = leases.get(key);
+    if (lease === void 0 || lease.id !== body.leaseId) {
+      return errorResponse(c, 409, "conflict", "Browser control lease is not active");
     }
-    if ("custom" in answer && typeof answer.custom !== "boolean") {
-      return { error: errorResponse(c, 400, "bad_request", "custom must be a boolean") };
+    try {
+      lease.renew({ leaseTimeoutMs: body.leaseTimeoutMs });
+      return c.json(leaseResponse(lease));
+    } catch (error) {
+      leases.delete(key);
+      return controlErrorResponse(c, error);
     }
-    const normalized = {
-      questionId: answer.questionId.trim(),
-      answer: answer.answer.trim()
-    };
-    if (typeof answer.choice === "string") normalized.choice = answer.choice;
-    if (typeof answer.custom === "boolean") normalized.custom = answer.custom;
-    answers.push(normalized);
-  }
-  return { answers };
+  });
+  app.post("/sandboxes/:sandboxRef/views/:viewId/control/release", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    const body = await readReleaseBody(c);
+    if (body instanceof Response) return body;
+    const key = viewKey(resolved);
+    const lease = leases.get(key);
+    if (lease === void 0 || lease.id !== body.leaseId) {
+      return errorResponse(c, 409, "conflict", "Browser control lease is not active");
+    }
+    lease.release();
+    leases.delete(key);
+    return c.json({ released: true });
+  });
+  app.get("/sandboxes/:sandboxRef/views/:viewId/ws", async (c) => {
+    const resolved = await authorizedView(c, registry);
+    if (resolved instanceof Response) return resolved;
+    const upstreamUrl = `ws://${hostForUrl(resolved.host)}:${resolved.port}/websockify`;
+    return upgradeWebSocket(c, createProxyEvents(upstreamUrl, upstreamSockets), {
+      onError: () => void 0
+    });
+  });
+  return () => {
+    for (const lease of leases.values()) lease.release();
+    leases.clear();
+    for (const socket of upstreamSockets) socket.close(1001, "Studio closed");
+    upstreamSockets.clear();
+  };
 }
-function createQuestionRuntime() {
-  const questions = /* @__PURE__ */ new Map();
+function createProxyEvents(upstreamUrl, sockets) {
+  let upstream;
+  let pendingBytes = 0;
+  const pending = [];
   return {
-    questions,
-    createHook(context) {
-      return createHook({
-        async onToolCall({ toolName, toolCallId, internalCallId, args, tool: control }) {
-          if (toolName !== "ask_question") {
-            return control.run();
-          }
-          const prompts = normalizeQuestionPrompts(parseToolArgs(args));
-          if ("error" in prompts) {
-            return control.skip(prompts.error);
-          }
-          const request = {
-            toolName,
-            internalCallId,
-            args,
-            questions: prompts.questions
-          };
-          if (toolCallId !== void 0) request.toolCallId = toolCallId;
-          const answers = await requestQuestion(questions, context, request);
-          return control.skip(JSON.stringify({ answers }));
-        }
+    onOpen(_event, downstream) {
+      const protocols = downstream.protocol === null || downstream.protocol.length === 0 ? void 0 : [downstream.protocol];
+      upstream = new WebSocket(upstreamUrl, protocols, {
+        headers: { origin: "http://127.0.0.1" }
+      });
+      sockets.add(upstream);
+      upstream.binaryType = "arraybuffer";
+      upstream.once("open", () => {
+        for (const message of pending) upstream?.send(message);
+        pending.length = 0;
+        pendingBytes = 0;
       });
+      upstream.on("message", (data, isBinary) => {
+        const value = isBinary ? Uint8Array.from(Buffer.from(data)) : data.toString();
+        downstream.send(value);
+      });
+      upstream.once("close", (code, reason) => {
+        sockets.delete(upstream);
+        downstream.close(normalizeCloseCode(code), reason.toString("utf8").slice(0, 123));
+      });
+      upstream.once("error", () => downstream.close(1011, "noVNC upstream failed"));
     },
-    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;
+    onMessage(event, downstream) {
+      void normalizeWebSocketMessage(event.data).then((message) => {
+        if (upstream?.readyState === WebSocket.OPEN) {
+          upstream.send(message);
+          return;
         }
-        if (options.sessionId !== void 0 && question.sessionId !== options.sessionId) {
-          return false;
+        pendingBytes += typeof message === "string" ? Buffer.byteLength(message) : message.byteLength;
+        if (pendingBytes > maxPendingWebSocketBytes) {
+          downstream.close(1009, "Pending noVNC messages exceeded the limit");
+          return;
         }
-        return true;
-      }).map(publicQuestion);
+        pending.push(message);
+      }).catch(() => downstream.close(1003, "Unsupported noVNC message"));
     },
-    cancelRun(runId) {
-      const cancelled = [];
-      for (const question of questions.values()) {
-        if (!isPendingQuestion(question) || question.runId !== runId) {
-          continue;
-        }
-        const resolved = cancelQuestion(question);
-        questions.set(question.id, resolved);
-        question.emit?.({ type: "tool_question_result", question: resolved });
-        question.resolve([]);
-        cancelled.push(resolved);
-      }
-      return cancelled;
+    onClose() {
+      upstream?.close(1e3, "Viewer disconnected");
+      if (upstream !== void 0) sockets.delete(upstream);
     },
-    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);
+    onError() {
+      upstream?.close(1011, "Viewer connection failed");
     }
   };
 }
-async function requestQuestion(questions, context, request) {
-  const id = globalThis.crypto.randomUUID();
-  const question = {
-    id,
-    runId: context.runId,
-    agentId: context.agentId,
-    toolName: request.toolName,
-    internalCallId: request.internalCallId,
-    args: request.args,
-    questions: request.questions,
-    status: "pending",
-    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resolve: () => {
-    }
-  };
-  if (context.sessionId !== void 0) question.sessionId = context.sessionId;
-  if (request.toolCallId !== void 0) question.callId = request.toolCallId;
-  if (context.emit !== void 0) question.emit = context.emit;
-  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."
-      };
+async function authorizedView(c, registry) {
+  const entry = registry.get(c.req.param("sandboxRef") ?? "");
+  if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+  const view = entry.views.get(c.req.param("viewId") ?? "");
+  if (view === void 0) return errorResponse(c, 404, "not_found", "Sandbox view not found");
+  if (!await authorize(c, entry, view)) {
+    return errorResponse(c, 403, "forbidden", "Sandbox view access denied");
+  }
+  const published = entry.inspector.publishedPorts?.find(
+    (port) => port.containerPort === view.source.containerPort && port.protocol === "tcp" && isLoopbackAddress(port.host)
+  );
+  if (published === void 0) {
+    return errorResponse(c, 503, "internal_error", "Sandbox view port is unavailable");
+  }
+  return { entry, view, host: published.host, port: published.hostPort };
+}
+async function authorize(c, entry, view) {
+  if (view.access.mode === "authorize") {
+    try {
+      return await view.access.authorize({
+        request: c.req.raw,
+        sandboxRef: entry.summary.ref,
+        viewId: view.id
+      }) === true;
+    } catch {
+      return false;
     }
-    questions.push(normalized);
   }
-  return { questions };
+  let remoteAddress;
+  try {
+    const address = getConnInfo(c).remote.address;
+    if (address === void 0) return false;
+    remoteAddress = address;
+  } catch {
+    return false;
+  }
+  if (!isLoopbackAddress(remoteAddress)) return false;
+  const expectedOrigin = new URL(c.req.url).origin;
+  const origin = c.req.header("origin");
+  return origin === expectedOrigin || origin === void 0 && c.req.header("sec-fetch-site") === "same-origin";
 }
-function normalizeQuestionPrompt(value, index) {
-  if (!isObject(value) || typeof value.question !== "string" || value.question.trim().length === 0) {
-    return void 0;
+async function readControlBody(c) {
+  const body = await readJsonObject(c);
+  if (body instanceof Response) return body;
+  if (typeof body.ownerId !== "string" || body.ownerId.length === 0 || body.ownerId.length > 200) {
+    return errorResponse(c, 400, "bad_request", "ownerId must be a non-empty string");
   }
-  const choices = Array.isArray(value.choices) ? value.choices.map(normalizeQuestionChoice).filter((choice) => choice !== void 0) : [];
-  if (choices.length === 0) {
-    return void 0;
+  if (!isLeaseTimeout(body.leaseTimeoutMs)) {
+    return errorResponse(c, 400, "bad_request", "leaseTimeoutMs is outside the allowed range");
   }
-  return {
-    id: typeof value.id === "string" && value.id.trim().length > 0 ? value.id.trim() : `question_${index + 1}`,
-    question: value.question.trim(),
-    choices
-  };
+  return { ownerId: body.ownerId, leaseTimeoutMs: body.leaseTimeoutMs };
 }
-function normalizeQuestionChoice(value) {
-  if (typeof value === "string" && value.trim().length > 0) {
-    return { label: value.trim(), value: value.trim() };
+async function readLeaseBody(c) {
+  const body = await readJsonObject(c);
+  if (body instanceof Response) return body;
+  if (typeof body.leaseId !== "string" || body.leaseId.length === 0) {
+    return errorResponse(c, 400, "bad_request", "leaseId must be a non-empty string");
   }
-  if (!isObject(value) || typeof value.label !== "string" || value.label.trim().length === 0) {
-    return void 0;
+  if (!isLeaseTimeout(body.leaseTimeoutMs)) {
+    return errorResponse(c, 400, "bad_request", "leaseTimeoutMs is outside the allowed range");
   }
-  return {
-    label: value.label.trim(),
-    value: typeof value.value === "string" && value.value.trim().length > 0 ? value.value.trim() : value.label.trim()
-  };
+  return { leaseId: body.leaseId, leaseTimeoutMs: body.leaseTimeoutMs };
 }
-function isPendingQuestion(question) {
-  return question !== void 0 && question.status === "pending" && "resolve" in question;
+async function readReleaseBody(c) {
+  const body = await readJsonObject(c);
+  if (body instanceof Response) return body;
+  if (typeof body.leaseId !== "string" || body.leaseId.length === 0) {
+    return errorResponse(c, 400, "bad_request", "leaseId must be a non-empty string");
+  }
+  return { leaseId: body.leaseId };
 }
-function resolveQuestion(question, answers) {
-  return publicQuestion({
-    ...question,
-    status: "answered",
-    answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    answers
-  });
+async function readJsonObject(c) {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return errorResponse(c, 400, "bad_request", "Request body must be valid JSON");
+  }
+  return isRecord4(body) ? body : errorResponse(c, 400, "bad_request", "Request body must be an object");
 }
-function cancelQuestion(question) {
-  return publicQuestion({
-    ...question,
-    status: "cancelled",
-    cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+function controlErrorResponse(c, error) {
+  if (isRecord4(error) && error.code === "human_controlled") {
+    return errorResponse(c, 409, "conflict", "Browser view is already controlled");
+  }
+  if (isRecord4(error) && error.code === "invalid_state") {
+    return errorResponse(c, 409, "conflict", "Browser control lease is no longer active");
+  }
+  return errorResponse(c, 500, "internal_error", "Browser control operation failed");
+}
+function leaseResponse(lease) {
+  return { id: lease.id, ownerId: lease.ownerId, expiresAt: lease.expiresAt };
 }
-function publicQuestion(question) {
-  const { emit, resolve: resolve2, ...rest } = question;
-  void emit;
-  void resolve2;
-  return rest;
+function pruneExpiredLease(leases, key) {
+  const lease = leases.get(key);
+  if (lease !== void 0 && Date.parse(lease.expiresAt) <= Date.now()) {
+    lease.release();
+    leases.delete(key);
+  }
+}
+function viewKey(resolved) {
+  return `${resolved.entry.summary.ref}\0${resolved.view.id}`;
+}
+function isLeaseTimeout(value) {
+  return Number.isSafeInteger(value) && Number(value) >= minLeaseTimeoutMs && Number(value) <= maxLeaseTimeoutMs;
+}
+function isLoopbackAddress(value) {
+  return value === "localhost" || value === "127.0.0.1" || value === "::1" || value.startsWith("127.") || value.startsWith("::ffff:127.");
+}
+function hostForUrl(host) {
+  return host.includes(":") ? `[${host}]` : host;
+}
+async function normalizeWebSocketMessage(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof ArrayBuffer) return Uint8Array.from(new Uint8Array(value));
+  if (ArrayBuffer.isView(value)) {
+    return Uint8Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  }
+  if (value instanceof Blob) return Uint8Array.from(new Uint8Array(await value.arrayBuffer()));
+  throw new TypeError("Unsupported noVNC WebSocket message type.");
+}
+function normalizeCloseCode(code) {
+  return code >= 1e3 && code <= 4999 && code !== 1004 && code !== 1005 && code !== 1006 ? code : 1001;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/runtime/sandboxes.ts
 import path from "path";
-var sandboxToolMetadataKey = /* @__PURE__ */ Symbol.for("anvia.sandbox.tool.metadata");
 var maxFileResponseBytes = 10 * 1024 * 1024;
 var defaultProcessLogBytes = 64 * 1024;
 var maxProcessLogBytes = 1024 * 1024;
@@ -5765,51 +5609,41 @@ var StudioSandboxRegistry = class {
     return this.entries.get(ref);
   }
 };
-function createStudioSandboxRegistry(agents) {
-  const drafts = /* @__PURE__ */ new Map();
-  for (const agent of agents) {
-    for (const { tool } of agentToolItems(agent)) {
-      const session = sandboxSessionFromTool(tool);
-      if (session === void 0) {
-        continue;
-      }
-      const draft = drafts.get(session) ?? {
-        session,
-        agentIds: /* @__PURE__ */ new Set(),
-        toolNames: /* @__PURE__ */ new Set()
-      };
-      draft.agentIds.add(agent.id);
-      draft.toolNames.add(tool.name);
-      drafts.set(session, draft);
-    }
-  }
-  const refCounts = /* @__PURE__ */ new Map();
-  const entries = [...drafts.values()].sort(
-    (left, right) => `${left.session.provider}\0${left.session.id}`.localeCompare(
-      `${right.session.provider}\0${right.session.id}`
-    )
-  ).map((draft) => {
-    const baseRef = sandboxRef(draft.session.provider, draft.session.id);
-    const occurrence = (refCounts.get(baseRef) ?? 0) + 1;
-    refCounts.set(baseRef, occurrence);
-    const ref = occurrence === 1 ? baseRef : `${baseRef}.${occurrence}`;
+function createStudioSandboxRegistry(agents, registrations) {
+  const agentIds = new Set(agents.map((agent) => agent.id));
+  const refs = /* @__PURE__ */ new Set();
+  const entries = registrations.map((registration, index) => {
+    validateRegistration(registration, index, agentIds);
+    const inspector = registration.inspector;
+    const ref = sandboxRef(inspector.provider, inspector.id);
+    if (refs.has(ref)) {
+      throw new TypeError(
+        `sandboxes contains a duplicate provider/id registration: ${inspector.provider}/${inspector.id}`
+      );
+    }
+    refs.add(ref);
+    const views = new Map((registration.views ?? []).map((view) => [view.id, view]));
     return {
-      session: draft.session,
+      inspector,
+      views,
       summary: {
         ref,
-        id: draft.session.id,
-        provider: draft.session.provider,
-        workdir: draft.session.workdir,
-        agentIds: [...draft.agentIds].sort(),
-        toolNames: [...draft.toolNames].sort(),
+        id: inspector.id,
+        provider: inspector.provider,
+        workdir: inspector.workdir,
+        agentIds: sortedUnique(registration.agentIds ?? []),
+        toolNames: sortedUnique(registration.toolNames ?? []),
+        views: [...views.values()].map((view) => ({ id: view.id, label: view.label, protocol: view.source.protocol })).sort((left, right) => left.id.localeCompare(right.id)),
         capabilities: {
-          files: true,
-          ports: supportsPorts(draft.session),
-          processes: supportsProcesses(draft.session)
+          files: supportsFiles(inspector),
+          ports: supportsPorts(inspector),
+          processes: supportsProcesses(inspector),
+          views: views.size > 0
         }
       }
     };
   });
+  entries.sort((left, right) => left.summary.ref.localeCompare(right.summary.ref));
   return new StudioSandboxRegistry(entries);
 }
 function registerSandboxRoutes(app, registry) {
@@ -5818,24 +5652,19 @@ function registerSandboxRoutes(app, registry) {
   app.get("/sandboxes", (c) => c.json({ sandboxes: registry.list() }));
   app.get("/sandboxes/:sandboxRef", (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
-    return c.json(copySummary(entry.summary));
+    return entry === void 0 ? errorResponse(c, 404, "not_found", "Sandbox not found") : c.json(copySummary(entry.summary));
   });
   app.get("/sandboxes/:sandboxRef/files", async (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
+    if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+    if (!supportsFiles(entry.inspector)) return unsupportedSandboxOperation(c, "files");
     try {
       const requestedPath = c.req.query("path") ?? ".";
       const normalizedPath = normalizeSandboxPath(requestedPath, true);
-      const entries = await listSandboxFiles(entry.session, normalizedPath);
       return c.json({
         sandboxRef: entry.summary.ref,
         path: normalizedPath,
-        entries
+        entries: await listSandboxFiles(entry.inspector, normalizedPath, c.req.raw.signal)
       });
     } catch (error) {
       return sandboxErrorResponse(c, error);
@@ -5843,9 +5672,8 @@ function registerSandboxRoutes(app, registry) {
   });
   app.get("/sandboxes/:sandboxRef/files/content", async (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
+    if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+    if (!supportsFiles(entry.inspector)) return unsupportedSandboxOperation(c, "files.content");
     try {
       const requestedPath = c.req.query("path");
       if (requestedPath === void 0) {
@@ -5856,8 +5684,11 @@ function registerSandboxRoutes(app, registry) {
         throw new SandboxRouteError(400, "bad_request", "download must be 1 when provided");
       }
       const normalizedPath = normalizeSandboxPath(requestedPath, false);
-      const parentPath = path.posix.dirname(normalizedPath);
-      const siblings = await listSandboxFiles(entry.session, parentPath);
+      const siblings = await listSandboxFiles(
+        entry.inspector,
+        path.posix.dirname(normalizedPath),
+        c.req.raw.signal
+      );
       const file = siblings.find((candidate) => candidate.path === normalizedPath);
       if (file === void 0) {
         throw new SandboxRouteError(404, "not_found", "Sandbox file not found");
@@ -5869,25 +5700,24 @@ function registerSandboxRoutes(app, registry) {
           "Sandbox content path must refer to a regular file"
         );
       }
-      if (file.size !== void 0 && file.size > maxFileResponseBytes) {
+      if (file.size !== void 0 && file.size > maxFileResponseBytes)
         throw fileTooLarge(file.size);
-      }
-      const rawBytes = await entry.session.readFile(normalizedPath);
+      const rawBytes = await entry.inspector.readFile({
+        path: normalizedPath,
+        abortSignal: c.req.raw.signal
+      });
       if (!(rawBytes instanceof Uint8Array)) {
         throw new TypeError("Sandbox readFile returned an invalid byte payload");
       }
-      if (rawBytes.byteLength > maxFileResponseBytes) {
-        throw fileTooLarge(rawBytes.byteLength);
-      }
-      const bytes = new Uint8Array(rawBytes.byteLength);
-      bytes.set(rawBytes);
+      if (rawBytes.byteLength > maxFileResponseBytes) throw fileTooLarge(rawBytes.byteLength);
+      const bytes = rawBytes.slice();
       const disposition = download === "1" ? "attachment" : "inline";
       const filename = encodeURIComponent(path.posix.basename(normalizedPath));
       return new Response(bytes, {
         headers: {
           "cache-control": "no-store",
           "content-disposition": `${disposition}; filename*=UTF-8''${filename}`,
-          "content-length": String(bytes.byteLength),
+          "content-length": `${bytes.byteLength}`,
           "content-type": "application/octet-stream",
           "x-content-type-options": "nosniff"
         }
@@ -5898,16 +5728,12 @@ function registerSandboxRoutes(app, registry) {
   });
   app.get("/sandboxes/:sandboxRef/ports", (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
-    if (!supportsPorts(entry.session)) {
-      return unsupportedSandboxOperation(c, "ports");
-    }
+    if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+    if (!supportsPorts(entry.inspector)) return unsupportedSandboxOperation(c, "ports");
     try {
       return c.json({
         sandboxRef: entry.summary.ref,
-        ports: normalizePorts(entry.session.publishedPorts)
+        ports: normalizePorts(entry.inspector.publishedPorts)
       });
     } catch (error) {
       return sandboxErrorResponse(c, error);
@@ -5915,16 +5741,16 @@ function registerSandboxRoutes(app, registry) {
   });
   app.get("/sandboxes/:sandboxRef/processes", async (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
-    if (!supportsProcesses(entry.session)) {
+    if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+    if (!supportsProcesses(entry.inspector)) {
       return unsupportedSandboxOperation(c, "processes");
     }
     try {
       return c.json({
         sandboxRef: entry.summary.ref,
-        processes: normalizeProcesses(await entry.session.listProcesses())
+        processes: normalizeProcesses(
+          await entry.inspector.listProcesses({ abortSignal: c.req.raw.signal })
+        )
       });
     } catch (error) {
       return sandboxErrorResponse(c, error);
@@ -5932,21 +5758,25 @@ function registerSandboxRoutes(app, registry) {
   });
   app.get("/sandboxes/:sandboxRef/processes/:processId/logs", async (c) => {
     const entry = registry.get(c.req.param("sandboxRef"));
-    if (entry === void 0) {
-      return errorResponse(c, 404, "not_found", "Sandbox not found");
-    }
-    if (!supportsProcesses(entry.session)) {
+    if (entry === void 0) return errorResponse(c, 404, "not_found", "Sandbox not found");
+    if (!supportsProcesses(entry.inspector)) {
       return unsupportedSandboxOperation(c, "processes.logs");
     }
     try {
       const tailBytes = parseTailBytes(c.req.query("tailBytes"));
       const processId = c.req.param("processId");
-      const processes = normalizeProcesses(await entry.session.listProcesses());
+      const processes = normalizeProcesses(
+        await entry.inspector.listProcesses({ abortSignal: c.req.raw.signal })
+      );
       if (!processes.some((process2) => process2.id === processId)) {
         throw new SandboxRouteError(404, "not_found", "Sandbox process not found");
       }
       const logs = normalizeProcessLogs(
-        await entry.session.readProcessLogs(processId, { tailBytes }),
+        await entry.inspector.readProcessLogs({
+          processId,
+          tailBytes,
+          abortSignal: c.req.raw.signal
+        }),
         tailBytes
       );
       return c.json({
@@ -5963,21 +5793,86 @@ async function sandboxNoStore(c, next) {
   c.header("cache-control", "no-store");
   await next();
 }
-function sandboxSessionFromTool(tool) {
-  const metadata = tool[sandboxToolMetadataKey];
-  if (!isRecord4(metadata)) {
-    return void 0;
+function validateRegistration(registration, index, knownAgentIds) {
+  if (!isRecord5(registration) || !isInspector(registration.inspector)) {
+    throw new TypeError(`sandboxes[${index}] must contain a valid inspector.`);
+  }
+  const inspector = registration.inspector;
+  const files = supportsFiles(inspector);
+  if (inspector.listFiles === void 0 !== (inspector.readFile === void 0)) {
+    throw new TypeError(`sandboxes[${index}] must register both file inspector methods.`);
   }
-  return isSandboxSession(metadata.session) ? metadata.session : void 0;
+  const processes = supportsProcesses(inspector);
+  if (inspector.listProcesses === void 0 !== (inspector.readProcessLogs === void 0)) {
+    throw new TypeError(`sandboxes[${index}] must register both process inspector methods.`);
+  }
+  if (!files && !supportsPorts(inspector) && !processes) {
+    throw new TypeError(`sandboxes[${index}] inspector exposes no capabilities.`);
+  }
+  for (const agentId of sortedUnique(registration.agentIds ?? [])) {
+    if (!knownAgentIds.has(agentId)) {
+      throw new TypeError(`sandboxes[${index}] references an unknown agent: ${agentId}`);
+    }
+  }
+  sortedUnique(registration.toolNames ?? []);
+  validateViews(registration.views, inspector, index);
 }
-function isSandboxSession(value) {
-  return isRecord4(value) && typeof value.id === "string" && value.id.length > 0 && typeof value.provider === "string" && value.provider.length > 0 && typeof value.workdir === "string" && value.workdir.length > 0 && typeof value.listFiles === "function" && typeof value.readFile === "function";
+function validateViews(views, inspector, registrationIndex) {
+  if (views === void 0) return;
+  if (!Array.isArray(views))
+    throw new TypeError(`sandboxes[${registrationIndex}].views must be an array.`);
+  if (!supportsPorts(inspector)) {
+    throw new TypeError(`sandboxes[${registrationIndex}] views require published port inspection.`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const [viewIndex, view] of views.entries()) {
+    const prefix = `sandboxes[${registrationIndex}].views[${viewIndex}]`;
+    const candidate = view;
+    if (!isRecord5(candidate) || typeof candidate.id !== "string" || !/^[a-z0-9](?:[a-z0-9_-]{0,62})$/.test(candidate.id)) {
+      throw new TypeError(`${prefix}.id must be a stable lowercase identifier.`);
+    }
+    if (ids.has(candidate.id)) throw new TypeError(`${prefix}.id is duplicated: ${candidate.id}`);
+    ids.add(candidate.id);
+    if (typeof candidate.label !== "string" || candidate.label.length === 0) {
+      throw new TypeError(`${prefix}.label must be a non-empty string.`);
+    }
+    const source = candidate.source;
+    if (!isRecord5(source) || source.protocol !== "novnc" || !isPort(source.containerPort) || !isRecord5(source.control) || typeof source.control.snapshot !== "function" || typeof source.control.acquireHumanControl !== "function") {
+      throw new TypeError(`${prefix}.source must be a valid noVNC view source.`);
+    }
+    const port = inspector.publishedPorts?.find(
+      (candidate2) => candidate2.containerPort === source.containerPort && candidate2.protocol === "tcp"
+    );
+    if (port === void 0 || !isLoopbackHost(port.host)) {
+      throw new TypeError(`${prefix}.source must resolve to a loopback-published TCP port.`);
+    }
+    const access = candidate.access;
+    if (!isRecord5(access) || access.mode !== "local" && access.mode !== "authorize") {
+      throw new TypeError(`${prefix}.access must explicitly select local or authorize mode.`);
+    }
+    if (access.mode === "authorize" && typeof access.authorize !== "function") {
+      throw new TypeError(`${prefix}.access.authorize must be a function.`);
+    }
+    const authentication = candidate.authentication;
+    if (!isRecord5(authentication) || authentication.type !== "none" && authentication.type !== "password") {
+      throw new TypeError(`${prefix}.authentication must explicitly select none or password.`);
+    }
+    if (authentication.type === "password" && (typeof authentication.password !== "string" || authentication.password.length === 0)) {
+      throw new TypeError(`${prefix}.authentication.password must be a non-empty string.`);
+    }
+  }
 }
-function supportsPorts(session) {
-  return Array.isArray(session.publishedPorts);
+function isInspector(value) {
+  return isRecord5(value) && typeof value.id === "string" && value.id.length > 0 && typeof value.provider === "string" && value.provider.length > 0 && typeof value.workdir === "string" && value.workdir.length > 0;
 }
-function supportsProcesses(session) {
-  return typeof session.listProcesses === "function" && typeof session.readProcessLogs === "function";
+function supportsFiles(inspector) {
+  return typeof inspector.listFiles === "function" && typeof inspector.readFile === "function";
+}
+function supportsPorts(inspector) {
+  return Array.isArray(inspector.publishedPorts);
+}
+function supportsProcesses(inspector) {
+  return typeof inspector.listProcesses === "function" && typeof inspector.readProcessLogs === "function";
 }
 function sandboxRef(provider, id) {
   return Buffer.from(JSON.stringify([provider, id]), "utf8").toString("base64url");
@@ -5987,22 +5882,26 @@ function copySummary(summary) {
     ...summary,
     agentIds: [...summary.agentIds],
     toolNames: [...summary.toolNames],
+    views: summary.views.map((view) => ({ ...view })),
     capabilities: { ...summary.capabilities }
   };
 }
-async function listSandboxFiles(session, filePath) {
-  return normalizeFileEntries(await session.listFiles(filePath)).sort((left, right) => {
-    if (left.type === "directory" && right.type !== "directory") return -1;
-    if (left.type !== "directory" && right.type === "directory") return 1;
-    return left.path.localeCompare(right.path);
-  });
+function isLoopbackHost(host) {
+  return host === "127.0.0.1" || host === "::1" || host === "localhost";
+}
+async function listSandboxFiles(inspector, filePath, abortSignal) {
+  return normalizeFileEntries(await inspector.listFiles({ path: filePath, abortSignal })).sort(
+    (left, right) => {
+      if (left.type === "directory" && right.type !== "directory") return -1;
+      if (left.type !== "directory" && right.type === "directory") return 1;
+      return left.path.localeCompare(right.path);
+    }
+  );
 }
 function normalizeFileEntries(value) {
-  if (!Array.isArray(value)) {
-    throw new TypeError("Sandbox listFiles returned an invalid payload");
-  }
+  if (!Array.isArray(value)) throw new TypeError("Sandbox listFiles returned an invalid payload");
   return value.map((item) => {
-    if (!isRecord4(item) || typeof item.path !== "string" || !isFileType(item.type)) {
+    if (!isRecord5(item) || typeof item.path !== "string" || !isFileType(item.type)) {
       throw new TypeError("Sandbox listFiles returned an invalid entry");
     }
     let entryPath;
@@ -6013,7 +5912,7 @@ function normalizeFileEntries(value) {
     }
     const entry = { path: entryPath, type: item.type };
     if (item.size !== void 0) {
-      if (typeof item.size !== "number" || !Number.isFinite(item.size) || item.size < 0) {
+      if (!Number.isSafeInteger(item.size) || Number(item.size) < 0) {
         throw new TypeError("Sandbox listFiles returned an invalid file size");
       }
       entry.size = item.size;
@@ -6022,11 +5921,10 @@ function normalizeFileEntries(value) {
   });
 }
 function normalizePorts(value) {
-  if (!Array.isArray(value)) {
+  if (!Array.isArray(value))
     throw new TypeError("Sandbox publishedPorts returned an invalid payload");
-  }
   return value.map((item) => {
-    if (!isRecord4(item) || !isPort(item.containerPort) || typeof item.host !== "string" || !isPort(item.hostPort) || typeof item.protocol !== "string") {
+    if (!isRecord5(item) || !isPort(item.containerPort) || typeof item.host !== "string" || !isPort(item.hostPort) || typeof item.protocol !== "string") {
       throw new TypeError("Sandbox publishedPorts returned an invalid entry");
     }
     return {
@@ -6038,17 +5936,16 @@ function normalizePorts(value) {
   });
 }
 function normalizeProcesses(value) {
-  if (!Array.isArray(value)) {
+  if (!Array.isArray(value))
     throw new TypeError("Sandbox listProcesses returned an invalid payload");
-  }
   return value.map((item) => {
-    if (!isRecord4(item) || typeof item.id !== "string" || typeof item.command !== "string" || !Array.isArray(item.args) || !item.args.every((arg) => typeof arg === "string") || !isProcessStatus(item.status) || typeof item.startedAt !== "string") {
+    if (!isRecord5(item) || typeof item.id !== "string" || typeof item.command !== "string" || !Array.isArray(item.args) || !item.args.every((arg) => typeof arg === "string") || !isProcessStatus(item.status) || typeof item.startedAt !== "string") {
       throw new TypeError("Sandbox listProcesses returned an invalid entry");
     }
     const process2 = {
       id: item.id,
       command: item.command,
-      args: item.args,
+      args: [...item.args],
       status: item.status,
       startedAt: item.startedAt
     };
@@ -6059,11 +5956,11 @@ function normalizeProcesses(value) {
   });
 }
 function normalizeProcessLogs(value, maxBytes) {
-  if (!isRecord4(value) || typeof value.stdout !== "string" || typeof value.stderr !== "string" || typeof value.stdoutTruncated !== "boolean" || typeof value.stderrTruncated !== "boolean") {
+  if (!isRecord5(value) || !(value.stdout instanceof Uint8Array) || !(value.stderr instanceof Uint8Array) || typeof value.stdoutTruncated !== "boolean" || typeof value.stderrTruncated !== "boolean") {
     throw new TypeError("Sandbox readProcessLogs returned an invalid payload");
   }
-  const stdout = boundedLogText(value.stdout, maxBytes);
-  const stderr = boundedLogText(value.stderr, maxBytes);
+  const stdout = boundedLogBytes(value.stdout, maxBytes);
+  const stderr = boundedLogBytes(value.stderr, maxBytes);
   return {
     stdout: stdout.text,
     stderr: stderr.text,
@@ -6071,21 +5968,13 @@ function normalizeProcessLogs(value, maxBytes) {
     stderrTruncated: value.stderrTruncated || stderr.truncated
   };
 }
-function boundedLogText(value, maxBytes) {
-  const bytes = new TextEncoder().encode(value);
-  if (bytes.byteLength <= maxBytes) {
-    return { text: value, truncated: false };
-  }
-  if (maxBytes === 0) {
-    return { text: "", truncated: true };
-  }
-  let start = bytes.byteLength - maxBytes;
-  while (start < bytes.byteLength && (bytes[start] ?? 0) >> 6 === 2) {
-    start += 1;
-  }
+function boundedLogBytes(value, maxBytes) {
+  if (maxBytes === 0) return { text: "", truncated: value.byteLength > 0 };
+  let start = Math.max(0, value.byteLength - maxBytes);
+  while (start < value.byteLength && ((value[start] ?? 0) & 192) === 128) start += 1;
   return {
-    text: new TextDecoder().decode(bytes.subarray(start)),
-    truncated: true
+    text: new TextDecoder("utf-8", { fatal: true }).decode(value.subarray(start)),
+    truncated: start > 0
   };
 }
 function normalizeSandboxPath(input, allowRoot) {
@@ -6108,9 +5997,7 @@ function normalizeSandboxPath(input, allowRoot) {
   return normalized;
 }
 function parseTailBytes(value) {
-  if (value === void 0) {
-    return defaultProcessLogBytes;
-  }
+  if (value === void 0) return defaultProcessLogBytes;
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 0 || parsed > maxProcessLogBytes) {
     throw new SandboxRouteError(
@@ -6131,15 +6018,13 @@ function sandboxErrorResponse(c, error) {
   if (error instanceof SandboxRouteError) {
     return errorResponse(c, error.status, error.code, error.message);
   }
-  const name = errorName(error);
-  if (name === "SandboxPathError") {
-    return errorResponse(c, 400, "bad_request", errorMessage(error));
-  }
-  if (name === "SandboxFileSizeError") {
+  const code = errorCode(error);
+  if (code === "invalid_path") return errorResponse(c, 400, "bad_request", errorMessage(error));
+  if (code === "file_too_large") {
     return errorResponse(c, 413, "payload_too_large", errorMessage(error));
   }
-  if (name === "SandboxSessionDestroyedError") {
-    return errorResponse(c, 409, "conflict", "Sandbox session is no longer available");
+  if (code === "invalid_state" || code === "sandbox_not_found") {
+    return errorResponse(c, 409, "conflict", "Sandbox is no longer available");
   }
   return errorResponse(
     c,
@@ -6165,6 +6050,18 @@ var SandboxRouteError = class extends Error {
   status;
   code;
 };
+function sortedUnique(values) {
+  if (!Array.isArray(values)) throw new TypeError("Sandbox associations must be arrays.");
+  const result = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new TypeError("Sandbox associations must contain non-empty strings.");
+    }
+    if (result.has(value)) throw new TypeError(`Sandbox association is duplicated: ${value}`);
+    result.add(value);
+  }
+  return [...result].sort();
+}
 function isFileType(value) {
   return value === "file" || value === "directory" || value === "symlink" || value === "other";
 }
@@ -6174,14 +6071,14 @@ function isProcessStatus(value) {
 function isPort(value) {
   return Number.isInteger(value) && Number(value) >= 1 && Number(value) <= 65535;
 }
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function errorName(error) {
-  return isRecord4(error) && typeof error.name === "string" ? error.name : "";
+function errorCode(error) {
+  return isRecord5(error) && typeof error.code === "string" ? error.code : void 0;
 }
 function errorMessage(error) {
-  return isRecord4(error) && typeof error.message === "string" ? error.message : String(error);
+  return isRecord5(error) && typeof error.message === "string" ? error.message : "Sandbox failed";
 }
 
 // src/runtime/sessions.ts
@@ -6905,6 +6802,7 @@ var Studio = class {
   options;
   studio;
   server;
+  websocketServer;
   sigintHandler;
   constructor(targets = [], options = {}) {
     this.options = studioOptionsFromTargets(targets, options);
@@ -6929,9 +6827,15 @@ var Studio = class {
     this.studio = createStudioApp(this.options);
     const port = serveOptions.port ?? Number(process.env.RUNNER_PORT ?? 4021);
     const serverOptions = {
-      fetch: (request) => this.fetch(request),
+      fetch: (request, env) => this.studio.app.fetch(request, env),
       port
     };
+    this.websocketServer = new WebSocketServer({ noServer: true });
+    serverOptions.websocket = {
+      // @types/ws overloads are stricter than Hono's structural adapter, while Hono officially
+      // supports ws.WebSocketServer. Keep the interop assertion at this single ownership boundary.
+      server: this.websocketServer
+    };
     if (serveOptions.hostname !== void 0) serverOptions.hostname = serveOptions.hostname;
     this.server = serve(serverOptions);
     const log = serveOptions.log ?? true;
@@ -6976,6 +6880,8 @@ var Studio = class {
     }
     this.server?.close();
     this.server = void 0;
+    this.websocketServer?.close();
+    this.websocketServer = void 0;
     this.studio.close();
   }
   logAddress(host, port) {
@@ -7054,6 +6960,21 @@ function studioOptionsFromTargets(targets, options) {
   if (options.models !== void 0) runtimeOptions.models = options.models;
   if (options.stores !== void 0) runtimeOptions.stores = options.stores;
   if (options.ui !== void 0) runtimeOptions.ui = options.ui;
+  if (options.sandboxes !== void 0) {
+    runtimeOptions.sandboxes = options.sandboxes.map((registration) => {
+      let snapshot = { inspector: registration.inspector };
+      if (registration.agentIds !== void 0) {
+        snapshot = { ...snapshot, agentIds: [...registration.agentIds] };
+      }
+      if (registration.toolNames !== void 0) {
+        snapshot = { ...snapshot, toolNames: [...registration.toolNames] };
+      }
+      if (registration.views !== void 0) {
+        snapshot = { ...snapshot, views: [...registration.views] };
+      }
+      return snapshot;
+    });
+  }
   return runtimeOptions;
 }
 function inferStudioAgents(agents, quickPrompts) {
@@ -7116,9 +7037,8 @@ function createStudioApp(options) {
   const agentMap = new Map(agents.map((agent) => [agent.id, agent]));
   const pipelineMap = new Map(pipelines.map((pipeline) => [pipeline.id, pipeline]));
   const evalMap = new Map(options.evals.map((suite) => [suite.id ?? suite.name, suite]));
-  const approvalRuntime = createApprovalRuntime();
-  const questionRuntime = createQuestionRuntime();
-  const sandboxRegistry = createStudioSandboxRegistry(agents);
+  const continuationRegistry = createStudioContinuationRegistry();
+  const sandboxRegistry = createStudioSandboxRegistry(agents, options.sandboxes ?? []);
   const memorySources = createStudioMemorySourceRegistry(agents, stores.sessions);
   const app = new HonoApp();
   const uiOptions = isStudioUiEnabled(options.ui) ? resolveStudioUiOptions(options.ui) : void 0;
@@ -7169,8 +7089,7 @@ function createStudioApp(options) {
   registerMcpRoutes(app, { agentMap });
   registerToolRoutes(app, { agentMap });
   registerSandboxRoutes(app, sandboxRegistry);
-  registerApprovalRoutes(app, approvalRuntime);
-  registerQuestionRoutes(app, questionRuntime);
+  const closeSandboxViews = registerSandboxViewRoutes(app, sandboxRegistry);
   registerObservabilityRoutes(app, observabilityHub);
   registerEvalRoutes(app, {
     evals: options.evals,
@@ -7190,8 +7109,7 @@ function createStudioApp(options) {
     agentMap,
     stores,
     modelRegistry,
-    approvalRuntime,
-    questionRuntime
+    continuationRegistry
   });
   if (memorySources.size > 0 || stores.sessions !== void 0) {
     registerMemoryRoutes(app, {
@@ -7223,6 +7141,8 @@ function createStudioApp(options) {
       return buildConfig(options, agents, pipelines, stores, sandboxRegistry.size);
     },
     close() {
+      continuationRegistry.clear();
+      closeSandboxViews();
     }
   };
   if (stores.sessions !== void 0) Object.assign(studio, { sessionStore: stores.sessions });
@@ -8271,36 +8191,36 @@ function messageFromRows(row, partRows) {
     throw new TypeError("Stored Studio message metadata is not a strict JSON object.");
   }
   if (row.role === "system") {
-    const message = {
+    let message = {
       role: "system",
-      content: systemContentFromParts(parts),
-      ...metadata === void 0 ? {} : { metadata }
+      content: systemContentFromParts(parts)
     };
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   if (row.role === "user") {
-    const message = {
+    let message = {
       role: "user",
-      content: parts,
-      ...metadata === void 0 ? {} : { metadata }
+      content: parts
     };
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   if (row.role === "assistant") {
-    const message = {
+    let message = {
       role: "assistant",
-      content: parts,
-      ...row.message_id === null ? {} : { id: row.message_id },
-      ...metadata === void 0 ? {} : { metadata }
+      content: parts
     };
+    if (row.message_id !== null) message = { ...message, id: row.message_id };
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   if (row.role === "tool") {
-    const message = {
+    let message = {
       role: "tool",
-      content: parts,
-      ...metadata === void 0 ? {} : { metadata }
+      content: parts
     };
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   throw new Error(`Unsupported stored message role: ${row.role}`);