@anvia/studio 1.0.0-rc.1 → 1.0.0-rc.3

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,9 +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.output,
+      output: args.status === "completed" ? traceOutput(args.output) : args.text,
+      result,
       usage: args.usage,
       messages: toJsonValue(args.messages)
     });
@@ -198,12 +227,13 @@ var StudioRunTraceObserver = class {
       return;
     }
     const metadata = traceMetadata(this.props.args, result.messages);
+    if (result.result !== void 0) metadata.result = result.result;
     const trace = {
       id: this.props.id,
       runId: this.props.args.runId,
       sessionId,
       status,
-      trace: this.trace,
+      trace: { observer: "studio", ...this.trace },
       startedAt: this.startedAt.toISOString(),
       endedAt: result.endedAt.toISOString(),
       durationMs: durationMs(this.startedAt, result.endedAt),
@@ -282,15 +312,14 @@ var ChildAgentToolTraceAccumulator = class {
     }
     if (child.type === "tool_call" && isRecord(child.toolCall)) {
       const toolCall = child.toolCall;
-      const toolCallFunction = isRecord(toolCall.function) ? toolCall.function : void 0;
-      const toolName = typeof toolCallFunction?.name === "string" ? toolCallFunction.name : "tool";
-      const callId = typeof toolCall.callId === "string" ? toolCall.callId : typeof toolCall.id === "string" ? toolCall.id : void 0;
+      const toolName = typeof toolCall.toolName === "string" ? toolCall.toolName : "tool";
+      const callId = typeof toolCall.toolCallId === "string" ? toolCall.toolCallId : typeof toolCall.callId === "string" ? toolCall.callId : void 0;
       const start = {
         startedAt: /* @__PURE__ */ new Date(),
         agentId,
         childTurn,
         toolName,
-        input: toJsonValue(toolCallFunction?.arguments ?? {}),
+        input: toJsonValue("input" in toolCall ? toolCall.input : {}),
         completed: false
       };
       if (agentName !== void 0) start.agentName = agentName;
@@ -443,14 +472,12 @@ function generationMetadata(args, endArgs) {
   const request = args.request;
   const response = endArgs?.response;
   const rawResponse = isRecord(response?.rawResponse) ? response.rawResponse : void 0;
-  const effectiveModel = request.model ?? stringValue(rawResponse?.model) ?? args.modelInfo?.defaultModel ?? "default";
+  const modelId = args.modelInfo?.modelId ?? stringValue(rawResponse?.model) ?? "unknown";
   const providerResponse = providerResponseSummary(rawResponse);
   const usage = response?.usage;
   return compactJsonObject({
     provider: args.modelInfo?.provider,
-    model: effectiveModel,
-    requestedModel: request.model,
-    defaultModel: args.modelInfo?.defaultModel,
+    modelId,
     messageId: response?.messageId,
     usage,
     toolCount: request.tools.length,
@@ -460,15 +487,13 @@ function generationMetadata(args, endArgs) {
     temperature: request.temperature,
     maxTokens: request.maxTokens,
     toolChoice: request.toolChoice,
-    additionalParamKeys: isRecord(request.additionalParams) ? Object.keys(request.additionalParams).sort() : void 0,
+    providerOptionKeys: isRecord(request.providerOptions) ? Object.keys(request.providerOptions).sort() : void 0,
     hasOutputSchema: request.outputSchema !== void 0,
     firstDeltaMs: endArgs?.firstDeltaMs,
     providerResponse,
     modelInfo: compactJsonObject({
       provider: args.modelInfo?.provider,
-      model: effectiveModel,
-      requestedModel: request.model,
-      defaultModel: args.modelInfo?.defaultModel,
+      modelId,
       capabilities: args.modelInfo?.capabilities
     }),
     modelCall: compactJsonObject({
@@ -494,7 +519,6 @@ function generationMetadata(args, endArgs) {
 }
 function completionRequestSummary(request) {
   return compactJsonObject({
-    model: request.model,
     instructions: request.instructions === void 0 ? void 0 : { present: true },
     messageCount: request.chatHistory.length,
     documentCount: request.documents.length,
@@ -504,7 +528,7 @@ function completionRequestSummary(request) {
     temperature: request.temperature,
     maxTokens: request.maxTokens,
     toolChoice: request.toolChoice,
-    additionalParamKeys: isRecord(request.additionalParams) ? Object.keys(request.additionalParams).sort() : void 0,
+    providerOptionKeys: isRecord(request.providerOptions) ? Object.keys(request.providerOptions).sort() : void 0,
     hasOutputSchema: request.outputSchema !== void 0
   });
 }
@@ -541,7 +565,6 @@ function toolMetadata(args, skipped, result) {
     argumentBytes: byteLength(args.args),
     resultBytes: result === void 0 ? void 0 : byteLength(result),
     hasCallSignature: args.toolCall.signature !== void 0,
-    hasAdditionalParams: args.toolCall.additionalParams !== void 0,
     toolDescription: args.toolDefinition?.description,
     parameterKeys: Object.keys(properties).sort(),
     requiredParameterKeys: required,
@@ -559,8 +582,7 @@ function toolMetadata(args, skipped, result) {
       mcpServerName: args.toolMetadata?.mcpServerName,
       argumentBytes: byteLength(args.args),
       resultBytes: result === void 0 ? void 0 : byteLength(result),
-      hasCallSignature: args.toolCall.signature !== void 0,
-      hasAdditionalParams: args.toolCall.additionalParams !== void 0
+      hasCallSignature: args.toolCall.signature !== void 0
     })
   });
 }
@@ -577,6 +599,16 @@ function parseOrString(value) {
     return value;
   }
 }
+function traceOutput(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(toJsonValue(value));
+  } catch {
+    return String(value);
+  }
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -877,17 +909,18 @@ function escapeHtml(value) {
 }
 
 // src/runtime/agent-context.ts
-import { isContextIndex } from "@anvia/core/agent";
+import { isVectorContext } from "@anvia/core/agent";
 function staticContextDocuments(agent) {
-  return agent.context.filter((input) => !isContextIndex(input));
+  return agent.context.filter((input) => !isVectorContext(input));
 }
-function contextIndexes(agent) {
-  return agent.context.filter(isContextIndex);
+function vectorContexts(agent) {
+  return agent.context.filter(isVectorContext);
 }
 
 // src/runtime/agent-runs.ts
-import { Message } from "@anvia/core/completion";
-import { withInternalAgentRunOptions } from "@anvia/core/internal/agent";
+import {
+  withInternalAgentRunOptions
+} from "@anvia/core/internal/agent";
 
 // src/runtime/agent-utils.ts
 import {
@@ -914,7 +947,8 @@ function serializeError(error) {
 
 // src/runtime/type-guards.ts
 import {
-  isJsonValue as isCoreJsonValue
+  isJsonValue as isCoreJsonValue,
+  isMessage
 } from "@anvia/core/completion";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -925,26 +959,16 @@ function isJsonObject(value) {
 function isJsonValue(value) {
   return isCoreJsonValue(value);
 }
-function isMessageInput(value) {
-  return typeof value === "string" || isMessage(value);
-}
-function isMessage(value) {
-  if (!isObject(value) || typeof value.role !== "string") {
-    return false;
-  }
-  if (value.role === "system") {
-    return typeof value.content === "string";
-  }
-  if (value.role === "user" || value.role === "assistant" || value.role === "tool") {
-    return Array.isArray(value.content);
-  }
-  return false;
-}
 function isAgentTraceOptions(value) {
   if (!isObject(value)) {
     return false;
   }
-  return optionalString(value.name) && optionalString(value.userId) && optionalString(value.sessionId) && optionalString(value.version) && optionalString(value.traceId) && optionalBoolean(value.failOnObserverError) && optionalStringArray(value.tags) && optionalObject(value.metadata);
+  if (!Object.keys(value).every(
+    (key) => ["name", "userId", "sessionId", "metadata", "tags", "version", "traceId"].includes(key)
+  )) {
+    return false;
+  }
+  return optionalString(value.name) && optionalString(value.userId) && optionalString(value.sessionId) && optionalString(value.version) && optionalString(value.traceId) && optionalStringArray(value.tags) && (value.metadata === void 0 || isJsonObject(value.metadata));
 }
 function isNonNegativeInteger(value) {
   return Number.isInteger(value) && typeof value === "number" && value >= 0;
@@ -955,15 +979,9 @@ function isPositiveInteger(value) {
 function optionalString(value) {
   return value === void 0 || typeof value === "string";
 }
-function optionalBoolean(value) {
-  return value === void 0 || typeof value === "boolean";
-}
 function optionalStringArray(value) {
   return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function optionalObject(value) {
-  return value === void 0 || isObject(value);
-}
 
 // src/runtime/http.ts
 function errorResponse(c, status, code, message, details) {
@@ -1013,8 +1031,8 @@ function createStudioModelRegistry(config) {
       id,
       staticModels
     };
-    if (provider.defaultModel !== void 0) {
-      runtimeProvider.defaultModel = normalizeModelId(provider.defaultModel);
+    if (provider.defaultModelId !== void 0) {
+      runtimeProvider.defaultModelId = normalizeModelId(provider.defaultModelId);
     }
     providers.set(id, runtimeProvider);
   }
@@ -1023,8 +1041,10 @@ function createStudioModelRegistry(config) {
     agentPolicies: normalizeAgentPolicies(config.agents ?? {}),
     modelCache: /* @__PURE__ */ new Map()
   };
-  if (config.default !== void 0) {
-    Object.assign(registry, { defaultModel: normalizeModelRef(config.default) });
+  if (config.defaultModelRef !== void 0) {
+    Object.assign(registry, {
+      defaultModelRef: normalizeModelRef(config.defaultModelRef)
+    });
   }
   return registry;
 }
@@ -1041,7 +1061,7 @@ function studioModelsConfig(registry, agents) {
       models
     };
     if (provider.name !== void 0) config2.name = provider.name;
-    if (provider.defaultModel !== void 0) config2.defaultModel = provider.defaultModel;
+    if (provider.defaultModelId !== void 0) config2.defaultModelId = provider.defaultModelId;
     if (provider.metadata !== void 0) config2.metadata = provider.metadata;
     return config2;
   });
@@ -1053,7 +1073,7 @@ function studioModelsConfig(registry, agents) {
     providers,
     agents: agentsConfig
   };
-  if (registry.defaultModel !== void 0) config.default = registry.defaultModel;
+  if (registry.defaultModelRef !== void 0) config.defaultModelRef = registry.defaultModelRef;
   return config;
 }
 function registerModelRoutes(app, props) {
@@ -1067,8 +1087,8 @@ function registerModelRoutes(app, props) {
     const response = {
       providers
     };
-    if (props.registry.defaultModel !== void 0) {
-      response.defaultModel = props.registry.defaultModel;
+    if (props.registry.defaultModelRef !== void 0) {
+      response.defaultModelRef = props.registry.defaultModelRef;
     }
     return c.json(response);
   });
@@ -1101,7 +1121,7 @@ function resolveStudioModel(registry, input) {
   if (registry === void 0) {
     return { warnings: [] };
   }
-  const selectedRef = normalizeOptionalModelRef(input.request.model) ?? sessionModelRef(input.sessionMetadata) ?? registry.agentPolicies.get(input.agent.id)?.default ?? registry.defaultModel;
+  const selectedRef = normalizeOptionalModelRef(input.request.model) ?? sessionModelRef(input.sessionMetadata) ?? registry.agentPolicies.get(input.agent.id)?.defaultModelRef ?? registry.defaultModelRef;
   if (selectedRef === void 0) {
     return { warnings: [] };
   }
@@ -1113,7 +1133,7 @@ function resolveStudioModel(registry, input) {
   }
   let model = registry.modelCache.get(selectedRef);
   if (model === void 0) {
-    model = provider.createCompletionModel(modelId);
+    model = provider.createCompletionModel({ modelId });
     registry.modelCache.set(selectedRef, model);
   }
   const metadata = provider.staticModels.get(modelId);
@@ -1131,12 +1151,7 @@ function normalizeOptionalModelRef(ref) {
   return ref === void 0 ? void 0 : normalizeModelRef(ref);
 }
 function normalizeModelRef(ref) {
-  if (typeof ref === "string") {
-    const trimmed = ref.trim();
-    const parsed = parseModelRef(trimmed);
-    return `${parsed.providerId}:${parsed.modelId}`;
-  }
-  return `${normalizeProviderId(ref.provider)}:${normalizeModelId(ref.model)}`;
+  return `${normalizeProviderId(ref.providerId)}:${normalizeModelId(ref.modelId)}`;
 }
 function parseModelRef(ref) {
   const index = ref.indexOf(":");
@@ -1179,12 +1194,12 @@ async function agentModelsCatalog(registry, agent) {
       return [];
     }
   });
-  const defaultModel = policy?.default ?? registry.defaultModel;
+  const defaultModelRef = policy?.defaultModelRef ?? registry.defaultModelRef;
   const summary = {
     agentId: agent.id,
     models: [...models, ...exactPolicyModels]
   };
-  if (defaultModel !== void 0) summary.defaultModel = defaultModel;
+  if (defaultModelRef !== void 0) summary.defaultModelRef = defaultModelRef;
   if (warnings.length > 0) summary.warnings = warnings;
   return summary;
 }
@@ -1222,7 +1237,7 @@ async function providerCatalog(provider) {
     models: [...models.values()].sort((left, right) => left.ref.localeCompare(right.ref))
   };
   if (provider.name !== void 0) catalog.name = provider.name;
-  if (provider.defaultModel !== void 0) catalog.defaultModel = provider.defaultModel;
+  if (provider.defaultModelId !== void 0) catalog.defaultModelId = provider.defaultModelId;
   if (provider.metadata !== void 0) catalog.metadata = provider.metadata;
   if (warning !== void 0) catalog.warning = warning;
   return catalog;
@@ -1256,19 +1271,33 @@ function normalizeAgentPolicies(policies) {
   return new Map(
     Object.entries(policies).map(([agentId, policy]) => {
       const normalized = {};
-      if (policy.default !== void 0) normalized.default = normalizeModelRef(policy.default);
+      if (policy.defaultModelRef !== void 0) {
+        normalized.defaultModelRef = normalizeModelRef(policy.defaultModelRef);
+      }
       if (policy.allowed !== void 0) {
-        normalized.allowed = policy.allowed.map(
-          (entry) => typeof entry === "string" && entry.trim().endsWith(":*") ? `${normalizeProviderId(entry.trim().slice(0, -2))}:*` : normalizeModelRef(entry)
-        );
+        normalized.allowed = policy.allowed.map((entry) => {
+          if (typeof entry === "string") {
+            return normalizeWildcardModelRef(entry);
+          }
+          return normalizeModelRef(entry);
+        });
       }
       return [agentId.trim(), normalized];
     })
   );
 }
+function normalizeWildcardModelRef(ref) {
+  const normalized = ref.trim();
+  if (!normalized.endsWith(":*")) {
+    throw new ModelSelectionError(`Invalid wildcard model reference: ${ref}`);
+  }
+  return `${normalizeProviderId(normalized.slice(0, -2))}:*`;
+}
 function publicPolicy(policy) {
   const config = {};
-  if (policy.default !== void 0) config.default = policy.default;
+  if (policy.defaultModelRef !== void 0) {
+    config.defaultModelRef = policy.defaultModelRef;
+  }
   if (policy.allowed !== void 0) config.allowed = policy.allowed;
   return config;
 }
@@ -1299,15 +1328,13 @@ function modelWarnings(ref, model, request) {
 function requestModalities(request) {
   const modalities = /* @__PURE__ */ new Set(["text"]);
   for (const message of requestMessages(request)) {
-    if (typeof message === "string") {
-      continue;
-    }
     if (message.role === "user" || message.role === "assistant") {
+      if (typeof message.content === "string") continue;
       for (const content of message.content) {
         if (content.type === "image") {
           modalities.add("image");
         }
-        if (content.type === "document") {
+        if (content.type === "file") {
           modalities.add("document");
         }
       }
@@ -1316,7 +1343,7 @@ function requestModalities(request) {
   return modalities;
 }
 function requestMessages(request) {
-  return [...request.history ?? [], request.message];
+  return request.type === "messages" ? request.messages : [];
 }
 function normalizeProviderId(id) {
   const trimmed = id.trim();
@@ -1334,7 +1361,7 @@ function normalizeModelId(id) {
 }
 
 // src/runtime/streams.ts
-import { createEventStream } from "@anvia/server";
+import { createClientStreamResponse, createEventStreamResponse } from "@anvia/server";
 var studioJsonlHeaders = {
   "cache-control": "no-cache, no-transform",
   connection: "keep-alive",
@@ -1343,7 +1370,15 @@ var studioJsonlHeaders = {
   "x-accel-buffering": "no"
 };
 function streamStudioJsonl(events) {
-  return createEventStream(withStudioStreamErrors(events), {
+  return createEventStreamResponse({
+    events: withStudioStreamErrors(events),
+    format: "jsonl",
+    headers: studioJsonlHeaders
+  });
+}
+function streamStudioClient(options) {
+  return createClientStreamResponse({
+    events: options.events,
     format: "jsonl",
     headers: studioJsonlHeaders
   });
@@ -1362,8 +1397,9 @@ function withStudioStreamErrors(events) {
             const next = await iterator.next();
             if (next.done === true) {
               done = true;
+              return next;
             }
-            return next;
+            return { done: false, value: serializeStreamError(next.value) };
           } catch (error) {
             done = true;
             return {
@@ -1381,6 +1417,12 @@ function withStudioStreamErrors(events) {
     }
   };
 }
+function serializeStreamError(event) {
+  if (typeof event !== "object" || event === null || !("type" in event) || event.type !== "error" || !("error" in event)) {
+    return event;
+  }
+  return { ...event, error: serializeError(event.error) };
+}
 function studioStreamError(error) {
   return {
     type: "error",
@@ -1589,6 +1631,16 @@ function isEventType(value) {
   return value === "session_log" || value === "pipeline_log" || value === "trace";
 }
 
+// src/runtime/runs.ts
+import {
+  customAgentEventsToClientStream
+} from "@anvia/client";
+import { parseAgentInteractionResponse } from "@anvia/core/agent";
+import {
+  isJsonValue as isJsonValue2,
+  parseMessages
+} from "@anvia/core/completion";
+
 // src/runtime/transcript.ts
 function renumberTranscript(entries) {
   return entries.map((entry, entryId) => ({ ...entry, entryId }));
@@ -1602,7 +1654,8 @@ function transcriptFromMessages(messages) {
     if (message.role === "user") {
       const attachments = attachmentsFromMessage(message);
       let textEntryAdded = false;
-      for (const content of message.content) {
+      const contents2 = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+      for (const content of contents2) {
         if (content.type === "text") {
           const entry = {
             entryId: transcript.length,
@@ -1616,32 +1669,36 @@ 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: "tool_result",
-          callId: content.callId ?? content.id,
-          result: content.content.map(
-            (item) => "text" in item ? item.text : `[image:${item.mediaType ?? "image/png"}]`
-          ).join("\n"),
-          structuredResult: content.content
-        });
+          toolName: content.toolName,
+          callId: content.callId ?? content.toolCallId,
+          result: toolResultText(content.output)
+        };
+        if (content.output.type === "content") entry.structuredResult = content.output.value;
+        transcript.push(entry);
       }
       continue;
     }
-    for (const content of message.content) {
+    const contents = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    for (const content of contents) {
       if (content.type === "text") {
         appendAssistantTranscriptText(transcript, content.text);
       } else if (content.type === "reasoning") {
@@ -1652,13 +1709,13 @@ function transcriptFromMessages(messages) {
         };
         if (content.id !== void 0) entry.reasoningId = content.id;
         transcript.push(entry);
-      } else if (content.type === "tool_call") {
+      } else if (content.type === "tool-call") {
         transcript.push({
           entryId: transcript.length,
           kind: "tool",
-          toolName: content.function.name,
-          callId: content.callId ?? content.id,
-          args: formatJson(content.function.arguments)
+          toolName: content.toolName,
+          callId: content.callId ?? content.toolCallId,
+          args: formatJson(content.input)
         });
       }
     }
@@ -1669,28 +1726,37 @@ function attachmentsFromMessage(message) {
   if (message.role !== "user" && message.role !== "assistant") {
     return [];
   }
+  if (typeof message.content === "string") return [];
   return message.content.flatMap((content) => {
     if (content.type === "image") {
       const attachment = { kind: "image" };
-      if (content.source.type === "base64") {
-        attachment.data = content.source.data;
-        attachment.mediaType = content.source.mediaType;
+      if (content.image.type === "data") {
+        attachment.data = content.image.data;
+        if (content.mediaType !== void 0) attachment.mediaType = content.mediaType;
       } else {
-        attachment.url = content.source.url;
+        attachment.url = content.image.url;
       }
       return [attachment];
     }
-    if (content.type === "document") {
+    if (content.type === "file") {
       const attachment = { kind: "document" };
-      if (content.source.filename !== void 0) attachment.name = content.source.filename;
-      if (content.source.mediaType !== void 0) attachment.mediaType = content.source.mediaType;
-      if (content.source.type === "base64") attachment.data = content.source.data;
-      if (content.source.type === "url") attachment.url = content.source.url;
+      if (content.filename !== void 0) attachment.name = content.filename;
+      attachment.mediaType = content.mediaType;
+      if (content.data.type === "data") attachment.data = content.data.data;
+      if (content.data.type === "url") attachment.url = content.data.url;
       return [attachment];
     }
     return [];
   });
 }
+function toolResultText(output) {
+  if (output.type === "text" || output.type === "error-text") return output.value;
+  if (output.type === "json" || output.type === "error-json") return formatJson(output.value);
+  if (output.type === "execution-denied") return output.reason ?? "Execution denied";
+  return output.value.map(
+    (part) => part.type === "text" ? part.text : `[file:${part.mediaType}${part.filename === void 0 ? "" : `:${part.filename}`}]`
+  ).join("\n");
+}
 function appendAssistantTranscriptText(transcript, text) {
   const last = transcript.at(-1);
   if (last?.kind === "message" && last.role === "assistant") {
@@ -1738,48 +1804,43 @@ 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({
+      events: withAgentRunCancellation(events, options.onCancel),
+      runId: options.runId,
+      mapCustomEvent: studioEventToClientEvent
+    })
+  });
 }
-function streamAgentRunEvents(_c, events, options = {}) {
-  return streamStudioJsonl(withAgentRunCancellation(events, options.onCancel));
+function studioEventToClientEvent(event, context) {
+  if (event.type === "session_log" && isJsonValue2(event.log)) {
+    return {
+      type: "data",
+      runId: context.runId,
+      name: "studio.session_log",
+      data: event.log,
+      transient: true
+    };
+  }
+  if (event.type === "pipeline_log" && isJsonValue2(event.log)) {
+    return {
+      type: "data",
+      runId: context.runId,
+      name: "studio.pipeline_log",
+      data: event.log,
+      transient: true
+    };
+  }
+  if (event.type === "pipeline_final" && isJsonValue2(event.output)) {
+    return {
+      type: "data",
+      runId: context.runId,
+      name: "studio.pipeline_final",
+      data: event.output
+    };
+  }
+  return void 0;
 }
 function withAgentRunCancellation(events, onCancel) {
   const iterator = events[Symbol.asyncIterator]();
@@ -1889,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,
@@ -1899,10 +1960,10 @@ function createPersistedStreamingSessionTranscript(props) {
         };
         if (event.type === "error") saveInput.error = serializeError(event.error);
         await saveTranscript(saveInput);
-        const generatedMessages = event.type === "final" ? event.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({
-            context: { sessionId: props.session.id },
+            scope: { sessionId: props.session.id },
             runId: props.runId,
             turn: 1,
             messages: generatedMessages
@@ -2004,9 +2065,9 @@ function acceptTranscriptStreamEvent(transcript, event) {
     transcript.push({
       entryId: transcript.length,
       kind: "tool",
-      toolName: event.toolCall.function.name,
-      callId: event.toolCall.callId ?? event.toolCall.id,
-      args: formatJson(event.toolCall.function.arguments)
+      toolName: event.toolCall.toolName,
+      callId: event.toolCall.callId ?? event.toolCall.toolCallId,
+      args: formatJson(event.toolCall.input)
     });
   }
   if (event.type === "tool_result") {
@@ -2047,86 +2108,72 @@ function acceptTranscriptStreamEvent(transcript, event) {
     }
     appendChildAgentTranscriptEvent(matched, event);
   }
-  if (event.type === "tool_approval_request") {
+  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) {
-      matched.approval = {
-        id: event.approval.id,
-        status: event.approval.status,
-        requestedAt: event.approval.requestedAt
-      };
-    }
-  }
-  if (event.type === "tool_approval_result") {
-    const matched = findTranscriptToolEntry(
-      transcript,
-      event.approval.toolName,
-      approvalCallId(event.approval)
-    );
-    if (matched !== void 0) {
+    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.trace?.traceId !== void 0) {
-    assignTranscriptTraceId(transcript, event.trace.traceId);
+  if (event.type === "final" && event.result.trace?.traceId !== void 0) {
+    assignTranscriptTraceId(transcript, event.result.trace.traceId);
   }
   if (event.type === "error") {
     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) {
@@ -2187,9 +2234,9 @@ function childAgentTranscriptEvent(event) {
     const entry = {
       kind: "tool",
       agentId: event.agentId,
-      toolName: child.toolCall.function.name,
-      callId: child.toolCall.callId ?? child.toolCall.id,
-      args: formatJson(child.toolCall.function.arguments)
+      toolName: child.toolCall.toolName,
+      callId: child.toolCall.callId ?? child.toolCall.toolCallId,
+      args: formatJson(child.toolCall.input)
     };
     if (event.agentName !== void 0) entry.agentName = event.agentName;
     return entry;
@@ -2326,17 +2373,18 @@ function extractMessageText(message) {
   if (message.role === "system") {
     return message.content;
   }
+  if (typeof message.content === "string") {
+    return message.content;
+  }
   return message.content.flatMap((item) => {
     if (item.type === "text" || item.type === "reasoning") {
       return [item.text];
     }
-    if (item.type === "tool_call") {
-      return [`${item.function.name}(${formatJson(item.function.arguments)})`];
+    if (item.type === "tool-call") {
+      return [`${item.toolName}(${formatJson(item.input)})`];
     }
-    if (item.type === "tool_result") {
-      return item.content.map(
-        (result) => "text" in result ? result.text : `[image:${result.mediaType ?? "image/png"}]`
-      );
+    if (item.type === "tool-result") {
+      return [toolResultOutputText(item.output)];
     }
     return [];
   }).join("\n");
@@ -2345,23 +2393,26 @@ function optionalTranscriptAttachments(message) {
   if (typeof message === "string" || message.role !== "user") {
     return {};
   }
+  if (typeof message.content === "string") {
+    return {};
+  }
   const attachments = message.content.flatMap((content) => {
     if (content.type === "image") {
       const attachment = { kind: "image" };
-      if (content.source.type === "base64") {
-        attachment.data = content.source.data;
-        attachment.mediaType = content.source.mediaType;
+      if (content.image.type === "data") {
+        attachment.data = content.image.data;
+        if (content.mediaType !== void 0) attachment.mediaType = content.mediaType;
       } else {
-        attachment.url = content.source.url;
+        attachment.url = content.image.url;
       }
       return [attachment];
     }
-    if (content.type === "document") {
+    if (content.type === "file") {
       const attachment = { kind: "document" };
-      if (content.source.filename !== void 0) attachment.name = content.source.filename;
-      if (content.source.mediaType !== void 0) attachment.mediaType = content.source.mediaType;
-      if (content.source.type === "base64") attachment.data = content.source.data;
-      if (content.source.type === "url") attachment.url = content.source.url;
+      if (content.filename !== void 0) attachment.name = content.filename;
+      attachment.mediaType = content.mediaType;
+      if (content.data.type === "data") attachment.data = content.data.data;
+      if (content.data.type === "url") attachment.url = content.data.url;
       return [attachment];
     }
     return [];
@@ -2378,32 +2429,63 @@ async function parseRunRequest(c) {
   if (!isObject(body)) {
     return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
   }
-  const request = "message" in body ? parseLegacyRunRequestBody(c, body) : parseUiRunRequestBody(c, body);
+  if ("message" in body || "history" in body) {
+    return {
+      error: errorResponse(
+        c,
+        400,
+        "bad_request",
+        "Legacy message/history requests are not supported; use messages"
+      )
+    };
+  }
+  const request = parseRunRequestBody(c, body);
   if ("error" in request) {
     return request;
   }
   return parseRunRequestOptions(c, body, request);
 }
-function parseLegacyRunRequestBody(c, body) {
-  if (!isMessageInput(body.message)) {
+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", "Request body requires a string or Message")
+      error: errorResponse(
+        c,
+        400,
+        "bad_request",
+        'type must be "messages" or "interaction_response"'
+      )
     };
   }
-  const request = {
-    message: typeof body.message === "string" ? body.message : body.message
-  };
-  if ("history" in body) {
-    if (!Array.isArray(body.history) || !body.history.every(isMessage)) {
-      return { error: errorResponse(c, 400, "bad_request", "history must be a Message array") };
-    }
-    request.history = body.history;
-  }
-  return request;
-}
-function parseUiRunRequestBody(c, body) {
-  const messages = body.messages;
-  if (!Array.isArray(messages) || !messages.every(isMessage)) {
+  let messages;
+  try {
+    messages = parseMessages(body.messages);
+  } catch {
     return {
       error: errorResponse(c, 400, "bad_request", "messages must be a non-empty Message array")
     };
@@ -2419,19 +2501,21 @@ function parseUiRunRequestBody(c, body) {
       error: errorResponse(c, 400, "bad_request", "messages must be a non-empty Message array")
     };
   }
-  const history = messages.slice(0, -1);
-  const request = { message };
-  if (history.length > 0) request.history = history;
-  return request;
+  if (message.role !== "user") {
+    return {
+      error: errorResponse(c, 400, "bad_request", "The final message must be user-authored")
+    };
+  }
+  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") };
     }
-    if (request.history !== void 0) {
+    if (request.messages.length !== 1 || request.messages[0]?.role !== "user") {
       return {
-        error: errorResponse(c, 400, "bad_request", "sessionId cannot be combined with history")
+        error: errorResponse(c, 400, "bad_request", "sessionId requires exactly one user message")
       };
     }
     request.sessionId = body.sessionId;
@@ -2442,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")
@@ -2450,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")
@@ -2458,13 +2542,11 @@ function parseRunRequestOptions(c, body, request) {
     }
     request.toolConcurrency = body.toolConcurrency;
   }
-  if ("model" in body) {
-    if (typeof body.model === "string") {
-      request.model = body.model;
-    } else if (isObject(body.model) && typeof body.model.provider === "string" && typeof body.model.model === "string") {
+  if (request.type === "messages" && "model" in body) {
+    if (isObject(body.model) && typeof body.model.providerId === "string" && typeof body.model.modelId === "string") {
       request.model = {
-        provider: body.model.provider,
-        model: body.model.model
+        providerId: body.model.providerId,
+        modelId: body.model.modelId
       };
     } else {
       return {
@@ -2472,7 +2554,7 @@ function parseRunRequestOptions(c, body, request) {
           c,
           400,
           "bad_request",
-          "model must be a provider:model string or { provider, model } object"
+          "model must be a { providerId, modelId } object"
         )
       };
     }
@@ -2493,6 +2575,14 @@ function parseRunRequestOptions(c, body, request) {
   }
   return request;
 }
+function toolResultOutputText(output) {
+  if (output.type === "text" || output.type === "error-text") return output.value;
+  if (output.type === "json" || output.type === "error-json") return formatJson(output.value);
+  if (output.type === "execution-denied") return output.reason ?? "Execution denied";
+  return output.value.map(
+    (part) => part.type === "text" ? part.text : `[file:${part.mediaType}${part.filename === void 0 ? "" : `:${part.filename}`}]`
+  ).join("\n");
+}
 
 // src/runtime/session-logs.ts
 async function appendSessionLog(store, input) {
@@ -2627,6 +2717,25 @@ function memorySavedLog(props) {
     metadata
   };
 }
+function memoryCompactedLog(props) {
+  const metadata = {
+    originalMessageCount: props.originalMessageCount,
+    compactedMessageCount: props.compactedMessageCount,
+    retainedMessageCount: props.retainedMessageCount,
+    attempts: props.attempts
+  };
+  const usage = usageSummary(props.usage);
+  if (usage !== void 0) metadata.usage = usage;
+  return {
+    sessionId: props.sessionId,
+    runId: props.runId,
+    level: "info",
+    category: "memory",
+    event: "memory.compacted",
+    message: "Session memory compacted",
+    metadata
+  };
+}
 function runFailedLog(sessionId, runId, error, startedAt) {
   return {
     sessionId,
@@ -2643,6 +2752,9 @@ function runFailedLog(sessionId, runId, error, startedAt) {
 }
 function logsFromStreamEvent(props) {
   const { event, sessionId, runId } = props;
+  if (event.type === "memory_compaction") {
+    return [memoryCompactedLog({ sessionId, runId, ...event })];
+  }
   if (event.type === "turn_start") {
     return [
       {
@@ -2668,12 +2780,12 @@ function logsFromStreamEvent(props) {
         level: "info",
         category: "tool",
         event: "tool.called",
-        message: `Tool ${event.toolCall.function.name} called`,
+        message: `Tool ${event.toolCall.toolName} called`,
         metadata: {
           turn: event.turn,
-          toolName: event.toolCall.function.name,
-          callId: event.toolCall.callId ?? event.toolCall.id,
-          argumentBytes: byteLength2(formatUnknown(event.toolCall.function.arguments))
+          toolName: event.toolCall.toolName,
+          callId: event.toolCall.callId ?? event.toolCall.toolCallId,
+          argumentBytes: byteLength2(formatUnknown(event.toolCall.input))
         }
       }
     ];
@@ -2722,102 +2834,79 @@ function logsFromStreamEvent(props) {
     ];
   }
   if (event.type === "final") {
-    return [
-      runCompletedLog({
-        sessionId,
-        runId,
-        durationMs: Date.now() - props.startedAt,
-        usage: event.usage,
-        output: event.output,
-        messageCount: event.messages.length
-      }),
-      memorySavedLog({ sessionId, runId, messageCount: event.messages.length })
-    ];
-  }
-  if (event.type === "error") {
-    return [runFailedLog(sessionId, runId, event.error, props.startedAt)];
-  }
-  if (event.type === "tool_approval_request") {
-    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 result = event.result;
+    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 === "tool_question_result") {
-    const cancelled = event.question.status === "cancelled";
+  if (event.type === "error") {
+    return [runFailedLog(sessionId, runId, event.error, props.startedAt)];
+  }
+  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
       }
     ];
@@ -2843,16 +2932,16 @@ function childAgentLog(event, sessionId, runId) {
         level: "debug",
         category: "tool",
         event: "child_tool.called",
-        message: `Child agent ${event.agentName ?? event.agentId} called ${child.toolCall.function.name}`,
+        message: `Child agent ${event.agentName ?? event.agentId} called ${child.toolCall.toolName}`,
         metadata: {
           parentToolName: event.toolName,
           agentId: event.agentId,
           hasAgentName: event.agentName !== void 0,
           turn: event.turn,
           childTurn: child.turn,
-          toolName: child.toolCall.function.name,
-          callId: child.toolCall.callId ?? child.toolCall.id,
-          argumentBytes: byteLength2(formatUnknown(child.toolCall.function.arguments))
+          toolName: child.toolCall.toolName,
+          callId: child.toolCall.callId ?? child.toolCall.toolCallId,
+          argumentBytes: byteLength2(formatUnknown(child.toolCall.input))
         }
       }
     ];
@@ -2903,14 +2992,16 @@ function childAgentLog(event, sessionId, runId) {
     ];
   }
   if (child.type === "final") {
+    const result = child.result;
     const metadata = {
       parentToolName: event.toolName,
       agentId: event.agentId,
       hasAgentName: event.agentName !== void 0,
-      outputBytes: byteLength2(child.output),
-      messageCount: child.messages.length
+      outputBytes: byteLength2(result.text),
+      messageCount: result.messages.length,
+      status: result.status
     };
-    const usage = usageSummary(child.usage);
+    const usage = usageSummary(result.usage);
     if (usage !== void 0) metadata.usage = usage;
     return [
       {
@@ -3010,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;
@@ -3036,12 +3177,12 @@ async function prepareAgentRun(c, props) {
     store: props.stores.sessions
   });
   const memoryMetadata = runMemoryMetadata(agentId, body, selectedModel, runId);
-  const promptMessage = normalizePromptMessage(body.message);
+  const promptMessage = body.messages.at(-1);
   const sessionStore = props.stores.sessions;
   const shouldPersistSessionMessages = session !== void 0 && sessionStore !== void 0 && !usesStoreAsAgentMemory(runAgent, sessionStore);
   if (shouldPersistSessionMessages) {
     await sessionStore.append({
-      context: { sessionId: session.id, metadata: memoryMetadata },
+      scope: { sessionId: session.id, metadata: memoryMetadata },
       runId,
       turn: 1,
       messages: [promptMessage]
@@ -3061,10 +3202,13 @@ async function prepareAgentRun(c, props) {
     body,
     memoryMetadata,
     execution,
-    options: createRunOptions(body, agentId, session),
+    failureMessages: void 0,
+    memoryCompactionLogged: false,
+    options: createRunOptions(body, agentId, session, c.req.raw.signal),
     runAgent,
     runId,
     runStartedAt,
+    generatedMessagesStartIndex: 1,
     selectedModel,
     session,
     sessionStore,
@@ -3106,7 +3250,7 @@ async function recordRunReceived(props) {
     sessionId: props.session.id,
     runId: props.runId,
     agentId: props.agentId,
-    message: props.body.message,
+    message: props.body.messages.at(-1),
     stream: props.body.stream === true,
     hasTrace: props.body.trace !== void 0
   };
@@ -3154,23 +3298,33 @@ function runMemoryMetadata(agentId, body, selectedModel, runId) {
   return metadata;
 }
 function createRunExecution(props) {
-  if (props.session !== void 0 && props.runAgent.memory !== void 0) {
-    const session = props.runAgent.session(props.session.id, { metadata: props.memoryMetadata });
+  const session = props.session;
+  if (session !== void 0 && props.runAgent.memory !== void 0) {
     return {
-      generate: (options) => session.generate(props.body.message, options),
-      stream: (options) => session.stream(props.body.message, options)
+      generate: (options) => props.runAgent.generate({
+        prompt: props.promptMessage,
+        session: { sessionId: session.id, metadata: props.memoryMetadata },
+        ...options
+      }),
+      stream: (options) => props.runAgent.stream({
+        prompt: props.promptMessage,
+        session: { sessionId: session.id, metadata: props.memoryMetadata },
+        ...options
+      })
     };
   }
-  const input = props.session !== void 0 ? [...props.session.messages, props.promptMessage] : props.body.history !== void 0 ? [...props.body.history, props.promptMessage] : props.body.message;
+  const transcript = session !== void 0 ? [...session.messages, props.promptMessage] : props.body.messages;
   return {
-    generate: (options) => props.runAgent.generate(input, options),
-    stream: (options) => props.runAgent.stream(input, options)
+    generate: (options) => props.runAgent.generate({ messages: transcript, ...options }),
+    stream: (options) => props.runAgent.stream({ messages: transcript, ...options })
   };
 }
-function createRunOptions(body, agentId, session) {
-  const options = { retries: {} };
-  if (body.maxTurns !== void 0) options.maxTurns = body.maxTurns;
-  if (body.toolConcurrency !== void 0) options.toolConcurrency = body.toolConcurrency;
+function createRunOptions(body, agentId, session, abortSignal) {
+  const options = { abortSignal };
+  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) {
@@ -3179,34 +3333,11 @@ function createRunOptions(body, agentId, session) {
   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;
@@ -3221,17 +3352,17 @@ function handleStreamingAgentRun(c, run, props) {
       }),
       store: run.sessionStore,
       session: run.session,
-      message: run.body.message,
+      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());
@@ -3250,59 +3381,57 @@ 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
+  const internalOptions = {
+    onFailure: ({ messages }) => {
+      run.failureMessages = structuredClone(messages);
+    },
+    runId: run.runId
   };
-  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);
-  return withInternalAgentRunOptions({ ...run.options }, { hook: effectiveHook, runId: run.runId });
+  if (run.session !== void 0 && run.sessionStore !== void 0) {
+    const sessionId = run.session.id;
+    const sessionStore = run.sessionStore;
+    internalOptions.onMemoryCompaction = async (compaction) => {
+      await appendSessionLog(
+        sessionStore,
+        memoryCompactedLog({
+          sessionId,
+          runId: run.runId,
+          ...compaction
+        })
+      );
+      run.memoryCompactionLogged = true;
+    };
+  }
+  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) {
@@ -3310,10 +3439,10 @@ 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({
-        context: { sessionId: run.session.id, metadata: run.memoryMetadata },
+        scope: { sessionId: run.session.id, metadata: run.memoryMetadata },
         runId: run.runId,
         turn: 1,
         messages: generatedMessages
@@ -3326,21 +3455,85 @@ async function completeBufferedSessionRun(run, response) {
   await run.sessionStore.saveSessionRunTranscript({
     id: run.session.id,
     runId: run.runId,
-    ...optionalTitle(run.body.message),
+    ...optionalTitle(run.body.messages.at(-1)),
     transcript,
-    status: "success"
+    status: response.status === "suspended" ? "suspended" : "success"
   });
+  if (response.memoryCompaction !== void 0 && !run.memoryCompactionLogged) {
+    await appendSessionLog(
+      run.sessionStore,
+      memoryCompactedLog({
+        sessionId: run.session.id,
+        runId: run.runId,
+        ...response.memoryCompaction
+      })
+    );
+    run.memoryCompactionLogged = true;
+  }
   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,
       usage: response.usage,
-      output: response.output,
+      output: response.text,
       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({
@@ -3354,17 +3547,14 @@ async function failBufferedSessionRun(run, error) {
   if (run.session === void 0 || run.sessionStore === void 0) {
     return;
   }
-  const messages = await run.sessionStore.load({
-    sessionId: run.session.id,
-    metadata: run.memoryMetadata
-  });
   const durationMs2 = Date.now() - run.runStartedAt;
-  const transcript = transcriptFromMessages(messages.slice(run.session.messageCount));
+  const messages = run.failureMessages ?? [run.body.messages.at(-1)];
+  const transcript = transcriptFromMessages([...messages]);
   assignTranscriptRunDuration(transcript, durationMs2);
   await run.sessionStore.saveSessionRunTranscript({
     id: run.session.id,
     runId: run.runId,
-    ...optionalTitle(run.body.message),
+    ...optionalTitle(run.body.messages.at(-1)),
     transcript,
     status: "error",
     error: serializeError(error)
@@ -3374,254 +3564,13 @@ async function failBufferedSessionRun(run, error) {
     runFailedLog(run.session.id, run.runId, error, run.runStartedAt)
   );
 }
-function normalizePromptMessage(message) {
-  return typeof message === "string" ? Message.user(message) : message;
-}
 function usesStoreAsAgentMemory(agent, store) {
   const memoryStore = agent.memory?.store;
   return memoryStore !== void 0 && rawObservedStore(memoryStore) === rawObservedStore(store);
 }
 
-// src/runtime/approvals.ts
-import { getAgentApprovalRequestDetails } 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 === "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/config.ts
+import { isQuestionTool } from "@anvia/core/tool";
 
 // src/runtime/eval-config.ts
 var CASE_PREVIEW_LIMIT = 5;
@@ -3703,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"));
@@ -3763,7 +3747,7 @@ async function agentKnowledgeConfig(agent) {
 async function knowledgeSources(agent) {
   const toolIndexes = getAgentToolState(agent.agent).toolIndexes;
   const staticContext = staticContextDocuments(agent.agent);
-  const indexedContext = contextIndexes(agent.agent);
+  const indexedContext = vectorContexts(agent.agent);
   const sources = [
     {
       sourceId: staticSourceId(),
@@ -3775,20 +3759,20 @@ async function knowledgeSources(agent) {
     }
   ];
   const dynamicContextSources = await Promise.all(
-    indexedContext.map(async (contextIndex, index) => {
-      const inspect = inspectFn(contextIndex.index);
-      const count = await inspectableCount(inspect, contextIndex.filter);
+    indexedContext.map(async (vectorContext, index) => {
+      const inspect = inspectFn(vectorContext.store);
+      const count = await inspectableCount(inspect, vectorContext.filter);
       const source = {
         sourceId: dynamicContextSourceId(index),
         kind: "dynamic_context",
         label: `Dynamic context ${index + 1}`,
         count: 1,
         registrationIndex: index,
-        topK: contextIndex.topK,
+        topK: vectorContext.topK,
         inspectable: inspect !== void 0
       };
-      if (contextIndex.threshold !== void 0) {
-        source.threshold = contextIndex.threshold;
+      if (vectorContext.minScore !== void 0) {
+        source.minScore = vectorContext.minScore;
       }
       if (count !== void 0) source.itemCount = count;
       return source;
@@ -3807,8 +3791,8 @@ async function knowledgeSources(agent) {
         topK: toolIndex.topK,
         inspectable: inspect !== void 0
       };
-      if (toolIndex.threshold !== void 0) {
-        source.threshold = toolIndex.threshold;
+      if (toolIndex.minScore !== void 0) {
+        source.minScore = toolIndex.minScore;
       }
       if (count !== void 0) source.itemCount = count;
       return source;
@@ -3827,20 +3811,20 @@ async function knowledgeItemsPage(agent, sourceId, request) {
   if (sourceId === staticSourceId()) {
     return staticKnowledgeItemsPage(agent, request);
   }
-  const dynamicContextIndex = dynamicSourceIndex(sourceId, "dynamic_context");
-  if (dynamicContextIndex !== void 0) {
-    const contextIndex = contextIndexes(agent.agent)[dynamicContextIndex];
-    if (contextIndex === void 0) {
+  const vectorContextIndex = dynamicSourceIndex(sourceId, "dynamic_context");
+  if (vectorContextIndex !== void 0) {
+    const vectorContext = vectorContexts(agent.agent)[vectorContextIndex];
+    if (vectorContext === void 0) {
       return void 0;
     }
-    const inspect = inspectFn(contextIndex.index);
+    const inspect = inspectFn(vectorContext.store);
     if (inspect === void 0) {
       return nonInspectablePage(agent.id, sourceId, "dynamic_context");
     }
     const page = await inspect({
       limit: request.limit,
       cursor: request.cursor,
-      filter: contextIndex.filter
+      filter: vectorContext.filter
     });
     const result = {
       agentId: agent.id,
@@ -3881,12 +3865,12 @@ async function knowledgeItemsPage(agent, sourceId, request) {
   }
   return void 0;
 }
-function inspectFn(index) {
-  if (!isRecord3(index) || typeof index.inspect !== "function") {
+function inspectFn(store) {
+  if (!isRecord3(store) || typeof store.inspect !== "function") {
     return void 0;
   }
-  const inspect = index.inspect;
-  return (request) => inspect.call(index, request);
+  const inspect = store.inspect;
+  return (request) => inspect.call(store, request);
 }
 function staticKnowledgeItemsPage(agent, request) {
   const staticContext = staticContextDocuments(agent.agent);
@@ -4102,7 +4086,7 @@ function isRecord3(value) {
 
 // src/runtime/tool-metadata.ts
 import { getAgentToolState as getAgentToolState2 } from "@anvia/core/internal/agent";
-var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
+import { isMcpTool } from "@anvia/core/mcp";
 function agentToolItems(agent) {
   const state = getAgentToolState2(agent.agent);
   const items = state.staticTools.map((tool) => ({ tool, source: "static" }));
@@ -4135,15 +4119,10 @@ function toolRequiresApproval(tool) {
   return approval !== void 0 && approval !== false;
 }
 function mcpServerName(tool) {
-  const metadata = tool[MCP_TOOL_METADATA_KEY];
-  if (typeof metadata !== "object" || metadata === null) {
-    return void 0;
-  }
-  const serverName = metadata.serverName;
-  return typeof serverName === "string" && serverName.length > 0 ? serverName : void 0;
+  return isMcpTool(tool) ? tool.mcp.serverName : void 0;
 }
-function agentHasMcpTools(agent) {
-  return agentToolItems(agent).some(({ tool }) => mcpServerName(tool) !== void 0);
+function agentHasMcpServers(agent) {
+  return agent.agent.mcpServers.length > 0;
 }
 
 // src/runtime/config.ts
@@ -4165,7 +4144,7 @@ function agentConfig(agent) {
 function agentRuntimeSummary(agent) {
   const tools = agentToolItems(agent);
   const staticContext = staticContextDocuments(agent.agent);
-  const indexedContext = contextIndexes(agent.agent);
+  const indexedContext = vectorContexts(agent.agent);
   const name = agent.name ?? agent.agent.name;
   const description = agent.description ?? agent.agent.description;
   const summary = {
@@ -4178,7 +4157,7 @@ function agentRuntimeSummary(agent) {
     mcpToolCount: tools.filter((item) => mcpServerName(item.tool) !== void 0).length,
     staticContextCount: staticContext.length,
     dynamicContextCount: indexedContext.length,
-    observerCount: agent.agent.observers.length,
+    observerCount: Object.keys(agent.agent.observability?.observers ?? {}).length,
     hasMemory: agent.agent.memory !== void 0,
     hasLifecycle: agent.agent.lifecycle !== void 0,
     hasOutputSchema: agent.agent.outputSchema !== void 0
@@ -4250,14 +4229,16 @@ function capabilityConfig(_options, agents, pipelines, stores, sandboxCount = 0)
   if (agents.some((agent) => agent.agent.tools.length > 0)) {
     capabilities.tools = { enabled: true };
   }
-  if (agents.some(agentHasMcpTools)) {
+  if (agents.some(agentHasMcpServers)) {
     capabilities.mcps = { enabled: true };
   }
   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 };
@@ -4339,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) => {
@@ -4354,43 +4376,29 @@ function registerMcpRoutes(app, props) {
   });
 }
 async function agentMcpMetadata(agent) {
-  const servers = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  for (const { tool, source } of agentToolItems(agent)) {
-    const serverName = mcpServerName(tool);
-    if (serverName === void 0) {
-      continue;
-    }
-    const definition = await tool.definition("");
-    const key = `${serverName}:${source}:${definition.name}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    const tools = servers.get(serverName) ?? [];
-    tools.push({
-      name: definition.name,
-      description: definition.description,
-      parameters: definition.parameters,
-      source,
-      approval: approvalMetadata(tool)
-    });
-    servers.set(serverName, tools);
-  }
-  return [...servers.entries()].map(([name, tools]) => {
-    const sortedTools = tools.sort((left, right) => {
-      if (left.source !== right.source) {
-        return left.source === "static" ? -1 : 1;
-      }
-      return left.name.localeCompare(right.name);
-    });
-    return {
-      agentId: agent.id,
-      name,
-      toolCount: sortedTools.length,
-      tools: sortedTools
-    };
-  }).sort((left, right) => left.name.localeCompare(right.name));
+  return Promise.all(
+    agent.agent.mcpServers.map(async (server) => {
+      const tools = await Promise.all(
+        server.tools.map(async (tool) => {
+          const definition = await tool.definition("");
+          return {
+            name: definition.name,
+            description: definition.description,
+            parameters: definition.parameters,
+            source: "static",
+            approval: approvalMetadata(tool)
+          };
+        })
+      );
+      const sortedTools = tools.sort((left, right) => left.name.localeCompare(right.name));
+      return {
+        agentId: agent.id,
+        name: server.name,
+        toolCount: sortedTools.length,
+        tools: sortedTools
+      };
+    })
+  ).then((servers) => servers.sort((left, right) => left.name.localeCompare(right.name)));
 }
 
 // src/runtime/memory.ts
@@ -4612,7 +4620,7 @@ function agentMemorySource(ref, label, agentId, storeKindValue, inspector) {
       ).slice(0, options.limit);
     },
     async getConversation(conversationRef) {
-      const conversation = await inspector.getConversation(conversationRef);
+      const conversation = await inspector.getConversation({ ref: conversationRef });
       return conversation === void 0 ? void 0 : inspectorConversationDetail(conversation, summary.agentIds);
     }
   };
@@ -4835,12 +4843,12 @@ function pipelineRunFailedLog(pipelineId, runId, error, startedAt) {
     }
   };
 }
-function pipelineStageLog(pipelineId, runId, event) {
+function pipelineStageLog(event, studioPipelineId = event.pipelineId) {
   const category = stageCategory(event.node);
   if (event.type === "stage_started") {
     return {
-      pipelineId,
-      runId,
+      pipelineId: studioPipelineId,
+      runId: event.runId,
       level: "debug",
       category,
       event: `${event.node.kind}.started`,
@@ -4850,8 +4858,8 @@ function pipelineStageLog(pipelineId, runId, event) {
   }
   if (event.type === "stage_completed") {
     return {
-      pipelineId,
-      runId,
+      pipelineId: studioPipelineId,
+      runId: event.runId,
       level: "debug",
       category,
       event: `${event.node.kind}.completed`,
@@ -4863,8 +4871,8 @@ function pipelineStageLog(pipelineId, runId, event) {
     };
   }
   return {
-    pipelineId,
-    runId,
+    pipelineId: studioPipelineId,
+    runId: event.runId,
     level: "error",
     category,
     event: `${event.node.kind}.failed`,
@@ -4891,6 +4899,7 @@ function stageCategory(node) {
 function nodeMetadata(node) {
   const metadata = {
     nodeId: node.id,
+    nodePath: [...node.path],
     kind: node.kind,
     label: node.label
   };
@@ -5052,17 +5061,24 @@ async function executePipelineRun(c, props, pipeline, body) {
     if (body.metadata !== void 0) streamOptions.metadata = body.metadata;
     if (props.logStore !== void 0) streamOptions.logStore = props.logStore;
     if (props.runStore !== void 0) streamOptions.runStore = props.runStore;
+    streamOptions.abortSignal = c.req.raw.signal;
     return streamPipelineRun(c, streamOptions);
   }
   try {
     await appendPipelineLog(props.logStore, pipelineRunStartedLog(pipeline, runId));
-    const output = await pipeline.pipeline.run(body.input, {
+    const result = await pipeline.pipeline.run({
+      input: body.input,
+      runId,
+      metadata: body.metadata,
+      abortSignal: c.req.raw.signal,
       observer: {
         async onEvent(event) {
-          await appendPipelineLog(props.logStore, pipelineStageLog(pipeline.id, runId, event));
+          await appendPipelineLog(props.logStore, pipelineStageLog(event, pipeline.id));
         }
-      }
+      },
+      failOnObserverError: true
     });
+    const output = result.output;
     const jsonOutput = toJsonValue(output);
     const endedAt = Date.now();
     const successRecord = {
@@ -5127,19 +5143,24 @@ function streamPipelineRun(_c, props) {
 async function* pipelineRunEvents(props) {
   yield* emitPipelineLog(props.logStore, pipelineRunStartedLog(props.pipeline, props.runId));
   const events = new AsyncEventQueue();
-  const run = props.pipeline.pipeline.run(props.input, {
+  const run = props.pipeline.pipeline.run({
+    input: props.input,
+    runId: props.runId,
+    metadata: props.metadata,
+    abortSignal: props.abortSignal,
     observer: {
       async onEvent(event) {
         const log = await appendPipelineLog(
           props.logStore,
-          pipelineStageLog(props.pipeline.id, props.runId, event)
+          pipelineStageLog(event, props.pipeline.id)
         );
         if (log !== void 0) {
           events.push({ type: "pipeline_log", log });
         }
       }
-    }
-  }).then(async (output) => {
+    },
+    failOnObserverError: true
+  }).then(async ({ output }) => {
     const jsonOutput = toJsonValue(output);
     const endedAt = Date.now();
     const successRecord = {
@@ -5292,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") };
+  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.questionId !== "string" || answer.questionId.trim().length === 0) {
-      return { error: errorResponse(c, 400, "bad_request", "questionId must be a string") };
-    }
-    if (typeof answer.answer !== "string" || answer.answer.trim().length === 0) {
-      return { error: errorResponse(c, 400, "bad_request", "answer must be a string") };
+    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 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 publicQuestion(question) {
-  const { emit, resolve: resolve2, ...rest } = question;
-  void emit;
-  void resolve2;
-  return rest;
+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;
@@ -5576,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) {
@@ -5629,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);
@@ -5654,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) {
@@ -5667,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");
@@ -5680,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"
         }
@@ -5709,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);
@@ -5726,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);
@@ -5743,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({
@@ -5774,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.`);
+  }
+  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 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.`);
+    }
   }
-  return isSandboxSession(metadata.session) ? metadata.session : void 0;
 }
-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 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 supportsPorts(session) {
-  return Array.isArray(session.publishedPorts);
+function supportsFiles(inspector) {
+  return typeof inspector.listFiles === "function" && typeof inspector.readFile === "function";
 }
-function supportsProcesses(session) {
-  return typeof session.listProcesses === "function" && typeof session.readProcessLogs === "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");
@@ -5798,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;
@@ -5824,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;
@@ -5833,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 {
@@ -5849,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
     };
@@ -5870,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,
@@ -5882,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) {
@@ -5919,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(
@@ -5942,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,
@@ -5976,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";
 }
@@ -5985,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
@@ -6143,6 +6229,16 @@ function createInMemoryStudioStore() {
 }
 var InMemoryStudioStore = class {
   kind = "memory";
+  compaction = {
+    snapshot: ({ scope }) => {
+      const messages = this.sessions.get(scope.sessionId)?.messages ?? [];
+      return Promise.resolve({
+        revision: memoryRevision(messages),
+        messages: cloneMessages(messages)
+      });
+    },
+    replacePrefix: (options) => this.replaceCompactionPrefix(options)
+  };
   sessions = /* @__PURE__ */ new Map();
   traces = /* @__PURE__ */ new Map();
   pipelineLogs = /* @__PURE__ */ new Map();
@@ -6184,20 +6280,20 @@ var InMemoryStudioStore = class {
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     return materializeSession(session);
   }
-  load(context) {
-    return Promise.resolve(this.sessions.get(context.sessionId)?.messages ?? []);
+  load({ scope }) {
+    return Promise.resolve(cloneMessages(this.sessions.get(scope.sessionId)?.messages ?? []));
   }
   append(input) {
-    const session = this.sessions.get(input.context.sessionId);
+    const session = this.sessions.get(input.scope.sessionId);
     if (session !== void 0) {
-      session.messages.push(...input.messages);
+      session.messages.push(...cloneMessages(input.messages));
       session.messageCount = session.messages.length;
       session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     return Promise.resolve();
   }
-  clear(context) {
-    const session = this.sessions.get(context.sessionId);
+  clear({ scope }) {
+    const session = this.sessions.get(scope.sessionId);
     if (session !== void 0) {
       session.messages = [];
       session.runs = [];
@@ -6208,13 +6304,26 @@ var InMemoryStudioStore = class {
   }
   async recordError(input) {
     await this.saveSessionRunTranscript({
-      id: input.context.sessionId,
-      runId: studioRunId(input.context) ?? input.runId,
+      id: input.scope.sessionId,
+      runId: studioRunId(input.scope) ?? input.runId,
       transcript: transcriptFromMessages(input.messages),
       status: "error",
       error: serializeJsonError(input.error)
     });
   }
+  replaceCompactionPrefix(input) {
+    if (!Number.isSafeInteger(input.messageCount) || input.messageCount < 1) {
+      throw new RangeError("messageCount must be a positive integer.");
+    }
+    const session = this.sessions.get(input.scope.sessionId);
+    if (session === void 0 || memoryRevision(session.messages) !== input.revision || input.messageCount > session.messages.length) {
+      return Promise.resolve({ status: "conflict" });
+    }
+    session.messages.splice(0, input.messageCount, structuredClone(input.replacement));
+    session.messageCount = session.messages.length;
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return Promise.resolve({ status: "committed" });
+  }
   saveSessionRunTranscript(input) {
     const session = this.sessions.get(input.id);
     if (session === void 0) {
@@ -6340,18 +6449,24 @@ function sessionSummary(session) {
 function materializeSession(session) {
   return {
     ...sessionSummary(session),
-    messages: [...session.messages],
+    messages: cloneMessages(session.messages),
     transcript: renumberTranscript(session.runs.flatMap((run) => run.transcript))
   };
 }
+function cloneMessages(messages) {
+  return structuredClone([...messages]);
+}
 function traceAgentId(trace) {
   const nestedMetadata = trace.metadata?.metadata;
   return isJsonObject(nestedMetadata) && typeof nestedMetadata.agentId === "string" ? nestedMetadata.agentId : void 0;
 }
-function studioRunId(context) {
-  const value = context.metadata?.studioRunId;
+function studioRunId(scope) {
+  const value = scope.metadata?.studioRunId;
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function memoryRevision(messages) {
+  return JSON.stringify(messages);
+}
 function serializeJsonError(error) {
   if (error instanceof Error) {
     return {
@@ -6687,6 +6802,7 @@ var Studio = class {
   options;
   studio;
   server;
+  websocketServer;
   sigintHandler;
   constructor(targets = [], options = {}) {
     this.options = studioOptionsFromTargets(targets, options);
@@ -6711,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;
@@ -6758,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) {
@@ -6836,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) {
@@ -6877,11 +7016,11 @@ function uniqueAgentId(baseId, ids) {
 function agentMetadata(agent) {
   const metadata = {
     staticContextCount: staticContextDocuments(agent).length,
-    dynamicContextCount: contextIndexes(agent).length,
+    dynamicContextCount: vectorContexts(agent).length,
     dynamicToolCount: getAgentToolState3(agent).toolIndexes.length,
     hasLifecycle: agent.lifecycle !== void 0,
     hasOutputSchema: agent.outputSchema !== void 0,
-    observerCount: agent.observers.length,
+    observerCount: Object.keys(agent.observability?.observers ?? {}).length,
     approvalToolCount: agent.tools.filter(toolRequiresApproval).length
   };
   if (agent.defaultMaxTurns !== void 0) metadata.defaultMaxTurns = agent.defaultMaxTurns;
@@ -6898,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;
@@ -6951,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,
@@ -6972,8 +7109,7 @@ function createStudioApp(options) {
     agentMap,
     stores,
     modelRegistry,
-    approvalRuntime,
-    questionRuntime
+    continuationRegistry
   });
   if (memorySources.size > 0 || stores.sessions !== void 0) {
     registerMemoryRoutes(app, {
@@ -7005,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 });
@@ -7012,30 +7150,37 @@ function createStudioApp(options) {
   return studio;
 }
 function withStudioTraceObserver(studioAgent, traceStore) {
-  if (traceStore === void 0 || hasStudioTraceObserver(studioAgent.agent)) {
-    return studioAgent;
+  if (traceStore === void 0) return studioAgent;
+  const existing = studioAgent.agent.observability;
+  const studioObserver = existing?.observers.studio;
+  if (studioObserver !== void 0 && !(studioObserver instanceof StudioTraceObserver)) {
+    throw new TypeError('Studio reserves the observer name "studio" for local trace persistence.');
+  }
+  for (const [name, observer] of Object.entries(existing?.observers ?? {})) {
+    if (observer instanceof StudioTraceObserver && name !== "studio") {
+      throw new TypeError('StudioTraceObserver must be registered with the name "studio".');
+    }
   }
   return {
     ...studioAgent,
     agent: cloneAgent(studioAgent.agent, {
-      observers: [
-        ...studioAgent.agent.observers,
-        { observer: new StudioTraceObserver({ store: traceStore }) }
-      ]
+      observability: {
+        observers: {
+          ...existing?.observers ?? {},
+          studio: studioObserver ?? new StudioTraceObserver({ store: traceStore })
+        },
+        primaryTrace: "studio",
+        errorPolicy: existing?.errorPolicy ?? "ignore"
+      }
     })
   };
 }
-function hasStudioTraceObserver(agent) {
-  return agent.observers.some(
-    (registration) => registration.observer instanceof StudioTraceObserver
-  );
-}
 
 // src/storage/sqlite-store.ts
 import { mkdirSync } from "fs";
 import { createRequire } from "module";
 import { dirname, resolve } from "path";
-import { isJsonValue as isJsonValue2 } from "@anvia/core/completion";
+import { isJsonValue as isJsonValue3 } from "@anvia/core/completion";
 var DatabaseSync;
 function createSqliteSessionStore(options = {}) {
   return new SqliteSessionStore(options.path ?? ":memory:");
@@ -7046,6 +7191,13 @@ var SqliteSessionStore = class {
   }
   path;
   kind = "sqlite";
+  compaction = {
+    snapshot: ({ scope }) => {
+      const messages = this.listSessionMessages(scope.sessionId);
+      return Promise.resolve({ revision: memoryRevision2(messages), messages });
+    },
+    replacePrefix: (options) => this.replaceCompactionPrefix(options)
+  };
   db;
   listSessions(options) {
     const db = this.database();
@@ -7117,8 +7269,8 @@ var SqliteSessionStore = class {
     }
     return this.getSession(id);
   }
-  load(context) {
-    const session = this.getSession(context.sessionId);
+  load({ scope }) {
+    const session = this.getSession(scope.sessionId);
     return Promise.resolve(session?.messages ?? []);
   }
   append(input) {
@@ -7129,20 +7281,20 @@ var SqliteSessionStore = class {
         `SELECT id, agent_id, title, metadata_json, created_at, updated_at
            FROM anvia_studio_sessions
            WHERE id = $id`
-      ).get({ $id: input.context.sessionId });
+      ).get({ $id: input.scope.sessionId });
       if (row === void 0) {
         db.exec("ROLLBACK");
         return Promise.resolve();
       }
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const nextIndex = this.nextMessageIndex(input.context.sessionId);
-      this.insertMessages(input.context.sessionId, input.messages, nextIndex, updatedAt);
+      const nextIndex = this.nextMessageIndex(input.scope.sessionId);
+      this.insertMessages(input.scope.sessionId, input.messages, nextIndex, updatedAt);
       db.prepare(
         `UPDATE anvia_studio_sessions
          SET updated_at = $updatedAt
          WHERE id = $id`
       ).run({
-        $id: input.context.sessionId,
+        $id: input.scope.sessionId,
         $updatedAt: updatedAt
       });
       db.exec("COMMIT");
@@ -7154,7 +7306,7 @@ var SqliteSessionStore = class {
       throw error;
     }
   }
-  clear(context) {
+  clear({ scope }) {
     const db = this.database();
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     try {
@@ -7164,14 +7316,14 @@ var SqliteSessionStore = class {
          SET updated_at = $updatedAt
          WHERE id = $id`
       ).run({
-        $id: context.sessionId,
+        $id: scope.sessionId,
         $updatedAt: updatedAt
       });
       db.prepare("DELETE FROM anvia_studio_session_messages WHERE session_id = $id").run({
-        $id: context.sessionId
+        $id: scope.sessionId
       });
       db.prepare("DELETE FROM anvia_studio_session_runs WHERE session_id = $id").run({
-        $id: context.sessionId
+        $id: scope.sessionId
       });
       db.exec("COMMIT");
       return Promise.resolve();
@@ -7183,17 +7335,51 @@ var SqliteSessionStore = class {
     }
   }
   async recordError(input) {
-    const runId = studioRunId2(input.context) ?? input.runId;
-    const existing = this.getSessionRun(input.context.sessionId, runId);
+    const runId = studioRunId2(input.scope) ?? input.runId;
+    const existing = this.getSessionRun(input.scope.sessionId, runId);
     const transcript = existing === void 0 || parseJsonArray(existing.transcript_json).length === 0 ? transcriptFromMessages(input.messages) : parseJsonArray(existing.transcript_json);
     await this.saveSessionRunTranscript({
-      id: input.context.sessionId,
+      id: input.scope.sessionId,
       runId,
       transcript,
       status: "error",
       error: serializeJsonError2(input.error)
     });
   }
+  replaceCompactionPrefix(input) {
+    if (!Number.isSafeInteger(input.messageCount) || input.messageCount < 1) {
+      throw new RangeError("messageCount must be a positive integer.");
+    }
+    const db = this.database();
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      const messages = this.listSessionMessages(input.scope.sessionId);
+      if (memoryRevision2(messages) !== input.revision || input.messageCount > messages.length || this.getSessionRow(input.scope.sessionId) === void 0) {
+        db.exec("ROLLBACK");
+        return Promise.resolve({ status: "conflict" });
+      }
+      db.prepare("DELETE FROM anvia_studio_session_messages WHERE session_id = $id").run({
+        $id: input.scope.sessionId
+      });
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.insertMessages(
+        input.scope.sessionId,
+        [input.replacement, ...messages.slice(input.messageCount)],
+        0,
+        updatedAt
+      );
+      db.prepare(
+        `UPDATE anvia_studio_sessions
+         SET updated_at = $updatedAt
+         WHERE id = $id`
+      ).run({ $id: input.scope.sessionId, $updatedAt: updatedAt });
+      db.exec("COMMIT");
+      return Promise.resolve({ status: "committed" });
+    } catch (error) {
+      if (db.isTransaction) db.exec("ROLLBACK");
+      throw error;
+    }
+  }
   saveSessionRunTranscript(input) {
     const db = this.database();
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -7889,7 +8075,7 @@ var SqliteSessionStore = class {
     );
     messages.forEach((message, messageOffset) => {
       const messageIndex = startIndex + messageOffset;
-      if (message.metadata !== void 0 && !isJsonValue2(message.metadata)) {
+      if (message.metadata !== void 0 && !isJsonValue3(message.metadata)) {
         throw new TypeError("Studio message metadata must be a strict JSON value.");
       }
       insertMessage.run({
@@ -7990,6 +8176,9 @@ function messageParts(message) {
   if (message.role === "system") {
     return [{ type: "text", value: { type: "text", text: message.content } }];
   }
+  if (typeof message.content === "string") {
+    return [{ type: "text", value: { type: "text", text: message.content } }];
+  }
   return message.content.map((content) => ({
     type: content.type,
     value: content
@@ -7998,40 +8187,40 @@ function messageParts(message) {
 function messageFromRows(row, partRows) {
   const parts = partRows.map((partRow) => JSON.parse(partRow.part_json));
   const metadata = parseJsonValue(row.metadata_json);
-  if (metadata !== void 0 && !isJsonValue2(metadata)) {
-    throw new TypeError("Stored Studio message metadata is not a strict JSON value.");
+  if (metadata !== void 0 && (!isJsonValue3(metadata) || typeof metadata !== "object" || metadata === null || Array.isArray(metadata))) {
+    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)
     };
-    if (metadata !== void 0) message.metadata = metadata;
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   if (row.role === "user") {
-    const message = {
+    let message = {
       role: "user",
       content: parts
     };
-    if (metadata !== void 0) message.metadata = metadata;
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   if (row.role === "assistant") {
-    const message = {
+    let message = {
       role: "assistant",
       content: parts
     };
-    if (row.message_id !== null) message.id = row.message_id;
-    if (metadata !== void 0) message.metadata = metadata;
+    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
     };
-    if (metadata !== void 0) message.metadata = metadata;
+    if (metadata !== void 0) message = { ...message, metadata };
     return message;
   }
   throw new Error(`Unsupported stored message role: ${row.role}`);
@@ -8116,10 +8305,13 @@ function parseJsonValue(value) {
   }
   return JSON.parse(value);
 }
-function studioRunId2(context) {
-  const value = context.metadata?.studioRunId;
+function studioRunId2(scope) {
+  const value = scope.metadata?.studioRunId;
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function memoryRevision2(messages) {
+  return JSON.stringify(messages);
+}
 function serializeJsonError2(error) {
   if (error instanceof Error) {
     return {