@anvia/studio 0.8.1 → 1.0.0-rc.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/runtime/studio.ts
-import { Agent as Agent2 } from "@anvia/core/internal/agent";
+import { Agent, getAgentToolState as getAgentToolState3 } from "@anvia/core/internal/agent";
 import { Pipeline } from "@anvia/core/pipeline";
 import { serve } from "@hono/node-server";
 import { Hono as HonoApp } from "hono";
@@ -200,6 +200,7 @@ var StudioRunTraceObserver = class {
     const metadata = traceMetadata(this.props.args, result.messages);
     const trace = {
       id: this.props.id,
+      runId: this.props.args.runId,
       sessionId,
       status,
       trace: this.trace,
@@ -427,6 +428,7 @@ function traceObservation(props) {
 }
 function traceMetadata(args, messages) {
   return compactJsonObject({
+    runId: args.runId,
     agentName: args.agentName,
     agentDescription: args.agentDescription,
     maxTurns: args.maxTurns,
@@ -874,70 +876,30 @@ function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
+// src/runtime/agent-context.ts
+import { isContextIndex } from "@anvia/core/agent";
+function staticContextDocuments(agent) {
+  return agent.context.filter((input) => !isContextIndex(input));
+}
+function contextIndexes(agent) {
+  return agent.context.filter(isContextIndex);
+}
+
 // src/runtime/agent-runs.ts
 import { Message } from "@anvia/core/completion";
+import { withInternalAgentRunOptions } from "@anvia/core/internal/agent";
 
 // src/runtime/agent-utils.ts
 import {
-  createHook
-} from "@anvia/core/hooks";
-import { Agent } from "@anvia/core/internal/agent";
+  createResolvedAgent,
+  getResolvedAgentOptions
+} from "@anvia/core/internal/agent";
 function cloneAgent(agent, overrides = {}) {
-  return new Agent({
-    id: agent.id,
-    name: agent.name,
-    description: agent.description,
-    model: agent.model,
-    instructions: agent.instructions,
-    staticContext: agent.staticContext,
-    temperature: agent.temperature,
-    maxTokens: agent.maxTokens,
-    additionalParams: agent.additionalParams,
-    toolSet: agent.toolSet,
-    toolChoice: agent.toolChoice,
-    defaultMaxTurns: agent.defaultMaxTurns,
-    hook: agent.hook,
-    outputSchema: agent.outputSchema,
-    observers: agent.observers,
-    approvals: agent.approvals,
-    dynamicContexts: agent.dynamicContexts,
-    dynamicTools: agent.dynamicTools,
-    middlewares: agent.middlewares,
-    memory: agent.memory,
-    eventStore: agent.eventStore,
+  return createResolvedAgent({
+    ...getResolvedAgentOptions(agent),
     ...overrides
   });
 }
-function composeHooks(first, second) {
-  if (first === void 0) {
-    return second;
-  }
-  if (second === void 0) {
-    return first;
-  }
-  return createHook({
-    async onCompletionCall(args) {
-      const firstAction = await first.onCompletionCall?.(args);
-      return firstAction?.type === "terminate" ? firstAction : await second.onCompletionCall?.(args) ?? void 0;
-    },
-    async onCompletionResponse(args) {
-      const firstAction = await first.onCompletionResponse?.(args);
-      return firstAction?.type === "terminate" ? firstAction : await second.onCompletionResponse?.(args) ?? void 0;
-    },
-    async onToolCall(args) {
-      const firstAction = await first.onToolCall?.(args);
-      if (firstAction?.type === "skip" || firstAction?.type === "terminate" || firstAction?.type === "approval_request") {
-        return firstAction;
-      }
-      const secondAction = await second.onToolCall?.(args);
-      return secondAction ?? firstAction ?? void 0;
-    },
-    async onToolResult(args) {
-      const firstAction = await first.onToolResult?.(args);
-      return firstAction?.type === "terminate" ? firstAction : await second.onToolResult?.(args) ?? void 0;
-    }
-  });
-}
 
 // src/runtime/errors.ts
 function serializeError(error) {
@@ -1435,6 +1397,7 @@ function traceSummary(trace) {
     startedAt: trace.startedAt,
     observationCount: trace.observations.length
   };
+  if (trace.runId !== void 0) summary.runId = trace.runId;
   if (trace.name !== void 0) summary.name = trace.name;
   if (trace.endedAt !== void 0) summary.endedAt = trace.endedAt;
   if (trace.durationMs !== void 0) summary.durationMs = trace.durationMs;
@@ -3084,7 +3047,7 @@ async function prepareAgentRun(c, props) {
       messages: [promptMessage]
     });
   }
-  const request = createRunRequest({
+  const execution = createRunExecution({
     agentId,
     body,
     memoryMetadata,
@@ -3097,7 +3060,8 @@ async function prepareAgentRun(c, props) {
     agent,
     body,
     memoryMetadata,
-    request,
+    execution,
+    options: createRunOptions(body, agentId, session),
     runAgent,
     runId,
     runStartedAt,
@@ -3189,23 +3153,30 @@ function runMemoryMetadata(agentId, body, selectedModel, runId) {
   metadata.studioRunId = runId;
   return metadata;
 }
-function createRunRequest(props) {
-  const request = props.session !== void 0 ? props.runAgent.memory === void 0 ? props.runAgent.prompt([...props.session.messages, props.promptMessage]) : props.runAgent.session(props.session.id, { metadata: props.memoryMetadata }).prompt(props.body.message) : props.runAgent.prompt(
-    props.body.history !== void 0 ? [...props.body.history, props.promptMessage] : props.body.message
-  );
-  request.withCompletionRetries();
-  if (props.body.maxTurns !== void 0) {
-    request.maxTurns(props.body.maxTurns);
-  }
-  if (props.body.toolConcurrency !== void 0) {
-    request.withToolConcurrency(props.body.toolConcurrency);
+function createRunExecution(props) {
+  if (props.session !== void 0 && props.runAgent.memory !== void 0) {
+    const session = props.runAgent.session(props.session.id, { metadata: props.memoryMetadata });
+    return {
+      generate: (options) => session.generate(props.body.message, options),
+      stream: (options) => session.stream(props.body.message, options)
+    };
   }
-  if (props.body.trace !== void 0) {
-    request.withTrace(traceForRun(props.body.trace, props.agentId, props.session));
-  } else if (props.session !== void 0) {
-    request.withTrace(traceForRun(void 0, props.agentId, props.session));
+  const input = props.session !== void 0 ? [...props.session.messages, props.promptMessage] : props.body.history !== void 0 ? [...props.body.history, props.promptMessage] : props.body.message;
+  return {
+    generate: (options) => props.runAgent.generate(input, options),
+    stream: (options) => props.runAgent.stream(input, 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;
+  if (body.trace !== void 0) {
+    options.trace = traceForRun(body.trace, agentId, session);
+  } else if (session !== void 0) {
+    options.trace = traceForRun(void 0, agentId, session);
   }
-  return request;
+  return options;
 }
 function handleStreamingAgentRun(c, run, props) {
   const runtimeEvents = new AsyncEventQueue();
@@ -3216,7 +3187,6 @@ function handleStreamingAgentRun(c, run, props) {
   };
   if (run.session !== void 0) approvalContext.sessionId = run.session.id;
   if (run.body.metadata !== void 0) approvalContext.metadata = run.body.metadata;
-  run.request.approvals(props.approvalRuntime.createApprovals(approvalContext));
   const questionContext = {
     runId: run.runId,
     agentId: run.agentId,
@@ -3224,14 +3194,20 @@ function handleStreamingAgentRun(c, run, props) {
   };
   if (run.session !== void 0) questionContext.sessionId = run.session.id;
   if (run.body.metadata !== void 0) questionContext.metadata = run.body.metadata;
-  const effectiveHook = composeHooks(
-    run.runAgent.hook,
-    props.questionRuntime.createHook(questionContext)
+  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
   );
-  if (effectiveHook !== void 0) {
-    run.request.withHook(effectiveHook);
-  }
-  const runStream = mergeRunAndApprovalEvents(run.request.stream(), runtimeEvents);
   let stream = runStream;
   let persistedRun;
   if (run.session !== void 0 && run.sessionStore !== void 0) {
@@ -3274,8 +3250,14 @@ function handleStreamingAgentRun(c, run, props) {
 }
 async function handleBufferedAgentRun(c, run, props) {
   try {
-    await startBufferedSessionRun(run, props);
-    const response = await run.request.send();
+    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);
   } catch (error) {
@@ -3294,19 +3276,33 @@ async function startBufferedSessionRun(run, props) {
   };
   if (run.session !== void 0) questionContext.sessionId = run.session.id;
   if (run.body.metadata !== void 0) questionContext.metadata = run.body.metadata;
-  const effectiveHook = composeHooks(
-    run.runAgent.hook,
-    props.questionRuntime.createHook(questionContext)
-  );
-  const approvalContext = {
+  const effectiveHook = props.questionRuntime.createHook(questionContext);
+  return withInternalAgentRunOptions({ ...run.options }, { hook: effectiveHook, runId: run.runId });
+}
+function createApprovalContext(run, emit) {
+  const context = {
     runId: run.runId,
     agentId: run.agentId
   };
-  if (run.session !== void 0) approvalContext.sessionId = run.session.id;
-  if (run.body.metadata !== void 0) approvalContext.metadata = run.body.metadata;
-  run.request.approvals(props.approvalRuntime.createApprovals(approvalContext));
-  if (effectiveHook !== void 0) {
-    run.request.withHook(effectiveHook);
+  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;
+    }
+    if (pending === void 0) return;
+    const decision = await approvalRuntime.request(context, pending.approval);
+    stream = agent.resume(pending, decision);
   }
 }
 async function completeBufferedSessionRun(run, response) {
@@ -3386,6 +3382,9 @@ function usesStoreAsAgentMemory(agent, store) {
   return memoryStore !== void 0 && rawObservedStore(memoryStore) === rawObservedStore(store);
 }
 
+// src/runtime/approvals.ts
+import { getAgentApprovalRequestDetails } from "@anvia/core/internal/agent";
+
 // src/runtime/query.ts
 function optionalQueryString(value) {
   const trimmed = value?.trim();
@@ -3491,22 +3490,11 @@ function createApprovalRuntime() {
   const approvals = /* @__PURE__ */ new Map();
   return {
     approvals,
-    createApprovals(context) {
-      return {
-        async handler(request) {
-          const approvalRequest = {
-            toolName: request.toolName,
-            internalCallId: request.internalCallId,
-            args: request.rawArgs
-          };
-          if (request.toolCallId !== void 0) approvalRequest.toolCallId = request.toolCallId;
-          if (request.reason !== void 0) approvalRequest.reason = request.reason;
-          if (request.rejectMessage !== void 0) {
-            approvalRequest.rejectMessage = request.rejectMessage;
-          }
-          const decision = await requestApproval(approvals, context, approvalRequest);
-          return approvalDecision(decision.approved, decision.reason);
-        }
+    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) {
@@ -3567,14 +3555,15 @@ function createApprovalRuntime() {
   };
 }
 async function requestApproval(approvals, context, request) {
-  const id = globalThis.crypto.randomUUID();
+  const id = request.id;
+  const details = getAgentApprovalRequestDetails(request);
   const approval = {
     id,
     runId: context.runId,
     agentId: context.agentId,
     toolName: request.toolName,
-    internalCallId: request.internalCallId,
-    args: request.args,
+    internalCallId: details?.internalCallId ?? request.id,
+    args: details?.rawArgs ?? JSON.stringify(request.input) ?? "null",
     status: "pending",
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
     resolve: () => {
@@ -3583,7 +3572,7 @@ async function requestApproval(approvals, context, request) {
   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 (request.rejectMessage !== void 0) approval.rejectMessage = request.rejectMessage;
+  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) => {
@@ -3594,7 +3583,7 @@ async function requestApproval(approvals, context, request) {
         }
         return;
       }
-      const reason = decision2.approved ? decision2.reason : decision2.reason ?? request.rejectMessage ?? "Rejected in Anvia Studio.";
+      const reason = decision2.approved ? decision2.reason : decision2.reason ?? details?.rejectMessage ?? "Rejected in Anvia Studio.";
       const resolved = resolveApproval(
         current,
         decision2.approved ? "approved" : "rejected",
@@ -3712,242 +3701,8 @@ function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-// src/runtime/tool-metadata.ts
-import { ToolSet } from "@anvia/core/tool";
-var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
-function agentToolItems(agent) {
-  return [
-    ...agent.agent.toolSet.values().map((tool) => ({ tool, source: "static" })),
-    ...agent.agent.dynamicTools.flatMap((registration) => {
-      const maybeToolSet = registration.index.toolSet;
-      if (!(maybeToolSet instanceof ToolSet)) {
-        return [];
-      }
-      return maybeToolSet.values().map((tool) => ({ tool, source: "dynamic" }));
-    })
-  ];
-}
-function approvalMetadata(tool) {
-  const approval = tool.approval;
-  if (approval === void 0 || typeof approval !== "object" || approval === null) {
-    return { required: false };
-  }
-  const policy = approval;
-  const metadata = { required: true };
-  if (typeof policy.reason === "string") metadata.reason = policy.reason;
-  if (typeof policy.rejectMessage === "string") metadata.rejectMessage = policy.rejectMessage;
-  return metadata;
-}
-function mcpServerName(tool) {
-  const metadata = tool[MCP_TOOL_METADATA_KEY];
-  if (typeof metadata !== "object" || metadata === null) {
-    return void 0;
-  }
-  const serverName = metadata.serverName;
-  return typeof serverName === "string" && serverName.length > 0 ? serverName : void 0;
-}
-function agentHasMcpTools(agent) {
-  return agentToolItems(agent).some(({ tool }) => mcpServerName(tool) !== void 0);
-}
-
-// src/runtime/config.ts
-function runnerId(options) {
-  return options.id ?? "anvia-studio";
-}
-function agentConfig(agent) {
-  const name = agent.name ?? agent.agent.name;
-  const description = agent.description ?? agent.agent.description;
-  const config = {
-    id: agent.id,
-    quickPrompts: agent.quickPrompts ?? []
-  };
-  if (name !== void 0) config.name = name;
-  if (description !== void 0) config.description = description;
-  if (agent.metadata !== void 0) config.metadata = agent.metadata;
-  return config;
-}
-function agentRuntimeSummary(agent) {
-  const tools = agentToolItems(agent);
-  const name = agent.name ?? agent.agent.name;
-  const description = agent.description ?? agent.agent.description;
-  const summary = {
-    id: agent.id,
-    model: toJsonValue2(agent.agent.model),
-    toolCount: tools.length,
-    staticToolCount: tools.filter((item) => item.source === "static").length,
-    dynamicToolCount: tools.filter((item) => item.source === "dynamic").length,
-    approvalToolCount: tools.filter((item) => item.tool.approval !== void 0).length,
-    mcpToolCount: tools.filter((item) => mcpServerName(item.tool) !== void 0).length,
-    staticContextCount: agent.agent.staticContext.length,
-    dynamicContextCount: agent.agent.dynamicContexts.length,
-    observerCount: agent.agent.observers.length,
-    hasMemory: agent.agent.memory !== void 0,
-    hasHook: agent.agent.hook !== void 0,
-    hasOutputSchema: agent.agent.outputSchema !== void 0
-  };
-  if (name !== void 0) summary.name = name;
-  if (description !== void 0) summary.description = description;
-  if (agent.agent.defaultMaxTurns !== void 0) {
-    summary.defaultMaxTurns = agent.agent.defaultMaxTurns;
-  }
-  if (agent.metadata !== void 0) summary.metadata = agent.metadata;
-  return summary;
-}
-function pipelineConfig(pipeline) {
-  const graph = pipeline.pipeline.graph();
-  const stageNodes = graph.nodes.filter((node) => node.kind !== "input" && node.kind !== "output");
-  const config = {
-    id: pipeline.id,
-    stageCount: stageNodes.length,
-    edgeCount: graph.edges.length,
-    hasParallelStages: graph.nodes.some((node) => node.kind === "parallel"),
-    agentCount: graph.nodes.filter((node) => node.kind === "agent").length,
-    extractorCount: graph.nodes.filter((node) => node.kind === "extractor").length
-  };
-  if (pipeline.name !== void 0) config.name = pipeline.name;
-  if (pipeline.description !== void 0) config.description = pipeline.description;
-  if (pipeline.metadata !== void 0) config.metadata = pipeline.metadata;
-  return config;
-}
-function buildConfig(options, agents, pipelines, stores, sandboxCount = 0) {
-  const models = options.models === void 0 ? void 0 : studioModelsConfig(createStudioModelRegistry(options.models), agents);
-  const config = {
-    id: runnerId(options),
-    agents: agents.map(agentConfig),
-    pipelines: pipelines.map(pipelineConfig),
-    evals: options.evals.map(evalConfig),
-    chat: {
-      quickPrompts: Object.fromEntries(agents.map((agent) => [agent.id, agent.quickPrompts ?? []]))
-    },
-    capabilities: capabilityConfig(options, agents, pipelines, stores, sandboxCount),
-    unsupportedCapabilities: unsupportedCapabilities(stores)
-  };
-  if (options.name !== void 0) config.name = options.name;
-  if (options.description !== void 0) config.description = options.description;
-  if (options.version !== void 0) config.version = options.version;
-  if (models !== void 0) config.models = models;
-  return config;
-}
-function capabilityConfig(_options, agents, pipelines, stores, sandboxCount = 0) {
-  const capabilities = {
-    agents: { enabled: true },
-    observability: { enabled: true },
-    status: { enabled: true }
-  };
-  if (stores.sessions !== void 0) {
-    capabilities.sessions = { enabled: true };
-  }
-  if (stores.sessions !== void 0 || agents.some((agent) => agent.agent.memory !== void 0)) {
-    capabilities.memory = { enabled: true };
-  }
-  if (stores.traces !== void 0) {
-    capabilities.traces = { enabled: true };
-  }
-  if (pipelines.length > 0) {
-    capabilities.pipelines = { enabled: true };
-  }
-  if (_options.evals.length > 0) {
-    capabilities.evals = { enabled: true };
-  }
-  if (agents.some(
-    (agent) => agent.agent.toolSet.values().length > 0 || agent.agent.dynamicTools.length > 0
-  )) {
-    capabilities.tools = { enabled: true };
-  }
-  if (agents.some(agentHasMcpTools)) {
-    capabilities.mcps = { enabled: true };
-  }
-  if (sandboxCount > 0) {
-    capabilities.sandboxes = { enabled: true };
-  }
-  if (agents.some(
-    (agent) => agent.agent.hook !== void 0 || agent.agent.toolSet.values().some((tool) => tool.approval)
-  )) {
-    capabilities.approvals = { enabled: true };
-  }
-  if (agents.some(
-    (agent) => agent.agent.staticContext.length > 0 || agent.agent.dynamicContexts.length > 0 || agent.agent.dynamicTools.length > 0
-  )) {
-    capabilities.knowledge = { enabled: true };
-  }
-  return capabilities;
-}
-function unsupportedCapabilities(stores) {
-  const capabilities = [];
-  if (stores.sessions === void 0) capabilities.push("sessions");
-  if (stores.traces === void 0) capabilities.push("traces");
-  return capabilities;
-}
-function toJsonValue2(value) {
-  return serializeUnknown(value);
-}
-
-// src/runtime/evals.ts
-import { runEvalSuite } from "@anvia/core/evals";
-function registerEvalRoutes(app, props) {
-  app.get(
-    "/evals",
-    (c) => c.json({
-      evals: props.evals.map(evalConfig)
-    })
-  );
-  app.get("/evals/:evalId", (c) => {
-    const suite = props.evalMap.get(c.req.param("evalId"));
-    if (suite === void 0) {
-      return errorResponse(c, 404, "not_found", "Eval suite not found");
-    }
-    return c.json(evalConfig(suite));
-  });
-  app.post("/evals/:evalId/runs", async (c) => {
-    const suite = props.evalMap.get(c.req.param("evalId"));
-    if (suite === void 0) {
-      return errorResponse(c, 404, "not_found", "Eval suite not found");
-    }
-    const body = await parseEvalRunRequest(c);
-    if ("error" in body) {
-      return body.error;
-    }
-    const runId = globalThis.crypto.randomUUID();
-    const startedAt = Date.now();
-    const runOptions = { ...suite };
-    if (body.concurrency !== void 0) runOptions.concurrency = body.concurrency;
-    const result = await runEvalSuite(runOptions);
-    const endedAt = Date.now();
-    const jsonResult = toJsonValue(result);
-    const response = {
-      runId,
-      suiteId: suite.id ?? suite.name,
-      startedAt: new Date(startedAt).toISOString(),
-      endedAt: new Date(endedAt).toISOString(),
-      durationMs: endedAt - startedAt,
-      result: isJsonObject(jsonResult) ? jsonResult : { value: jsonResult }
-    };
-    return c.json(response);
-  });
-}
-async function parseEvalRunRequest(c) {
-  let body = {};
-  try {
-    body = await c.req.json();
-  } catch {
-    body = {};
-  }
-  if (!isObject(body)) {
-    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
-  }
-  const request = {};
-  if ("concurrency" in body) {
-    if (!isPositiveInteger(body.concurrency)) {
-      return {
-        error: errorResponse(c, 400, "bad_request", "concurrency must be a positive integer")
-      };
-    }
-    request.concurrency = body.concurrency;
-  }
-  return request;
-}
-
 // src/runtime/knowledge.ts
+import { getAgentToolState } from "@anvia/core/internal/agent";
 function registerKnowledgeRoutes(app, props) {
   app.get("/knowledge", async (c) => {
     const limit = parseLimit(c.req.query("limit"));
@@ -3984,12 +3739,17 @@ function registerKnowledgeRoutes(app, props) {
     return c.json(page);
   });
 }
+function agentHasKnowledge(agent) {
+  const toolIndexes = getAgentToolState(agent.agent).toolIndexes;
+  return agent.agent.context.length > 0 || toolIndexes.length > 0;
+}
 async function agentKnowledgeConfig(agent) {
   const agentName = agent.name ?? agent.agent.name;
+  const staticContext = staticContextDocuments(agent.agent);
   const config = {
     agentId: agent.id,
     sources: await knowledgeSources(agent),
-    staticContext: agent.agent.staticContext.map((document) => {
+    staticContext: staticContext.map((document) => {
       const item = { id: document.id, text: document.text };
       if (document.additionalProps !== void 0) {
         item.additionalProps = jsonObjectFromRecord(document.additionalProps);
@@ -4001,51 +3761,54 @@ async function agentKnowledgeConfig(agent) {
   return config;
 }
 async function knowledgeSources(agent) {
+  const toolIndexes = getAgentToolState(agent.agent).toolIndexes;
+  const staticContext = staticContextDocuments(agent.agent);
+  const indexedContext = contextIndexes(agent.agent);
   const sources = [
     {
       sourceId: staticSourceId(),
       kind: "static_context",
       label: "Static context",
-      count: agent.agent.staticContext.length,
+      count: staticContext.length,
       inspectable: true,
-      itemCount: agent.agent.staticContext.length
+      itemCount: staticContext.length
     }
   ];
   const dynamicContextSources = await Promise.all(
-    agent.agent.dynamicContexts.map(async (registration, index) => {
-      const inspect = inspectFn(registration.index);
-      const count = await inspectableCount(inspect, registration.options.filter);
+    indexedContext.map(async (contextIndex, index) => {
+      const inspect = inspectFn(contextIndex.index);
+      const count = await inspectableCount(inspect, contextIndex.filter);
       const source = {
         sourceId: dynamicContextSourceId(index),
         kind: "dynamic_context",
         label: `Dynamic context ${index + 1}`,
         count: 1,
         registrationIndex: index,
-        topK: registration.options.topK,
+        topK: contextIndex.topK,
         inspectable: inspect !== void 0
       };
-      if (registration.options.threshold !== void 0) {
-        source.threshold = registration.options.threshold;
+      if (contextIndex.threshold !== void 0) {
+        source.threshold = contextIndex.threshold;
       }
       if (count !== void 0) source.itemCount = count;
       return source;
     })
   );
   const dynamicToolSources = await Promise.all(
-    agent.agent.dynamicTools.map(async (registration, index) => {
-      const inspect = inspectFn(registration.index);
-      const count = await inspectableCount(inspect, registration.options.filter);
+    toolIndexes.map(async (toolIndex, index) => {
+      const inspect = inspectFn(toolIndex);
+      const count = await inspectableCount(inspect, toolIndex.filter);
       const source = {
         sourceId: dynamicToolsSourceId(index),
         kind: "dynamic_tools",
         label: `Dynamic tools ${index + 1}`,
         count: 1,
         registrationIndex: index,
-        topK: registration.options.topK,
+        topK: toolIndex.topK,
         inspectable: inspect !== void 0
       };
-      if (registration.options.threshold !== void 0) {
-        source.threshold = registration.options.threshold;
+      if (toolIndex.threshold !== void 0) {
+        source.threshold = toolIndex.threshold;
       }
       if (count !== void 0) source.itemCount = count;
       return source;
@@ -4066,18 +3829,18 @@ async function knowledgeItemsPage(agent, sourceId, request) {
   }
   const dynamicContextIndex = dynamicSourceIndex(sourceId, "dynamic_context");
   if (dynamicContextIndex !== void 0) {
-    const registration = agent.agent.dynamicContexts[dynamicContextIndex];
-    if (registration === void 0) {
+    const contextIndex = contextIndexes(agent.agent)[dynamicContextIndex];
+    if (contextIndex === void 0) {
       return void 0;
     }
-    const inspect = inspectFn(registration.index);
+    const inspect = inspectFn(contextIndex.index);
     if (inspect === void 0) {
       return nonInspectablePage(agent.id, sourceId, "dynamic_context");
     }
     const page = await inspect({
       limit: request.limit,
       cursor: request.cursor,
-      filter: registration.options.filter
+      filter: contextIndex.filter
     });
     const result = {
       agentId: agent.id,
@@ -4092,18 +3855,18 @@ async function knowledgeItemsPage(agent, sourceId, request) {
   }
   const dynamicToolsIndex = dynamicSourceIndex(sourceId, "dynamic_tools");
   if (dynamicToolsIndex !== void 0) {
-    const registration = agent.agent.dynamicTools[dynamicToolsIndex];
-    if (registration === void 0) {
+    const toolIndex = getAgentToolState(agent.agent).toolIndexes[dynamicToolsIndex];
+    if (toolIndex === void 0) {
       return void 0;
     }
-    const inspect = inspectFn(registration.index);
+    const inspect = inspectFn(toolIndex);
     if (inspect === void 0) {
       return nonInspectablePage(agent.id, sourceId, "dynamic_tools");
     }
     const page = await inspect({
       limit: request.limit,
       cursor: request.cursor,
-      filter: registration.options.filter
+      filter: toolIndex.filter
     });
     const result = {
       agentId: agent.id,
@@ -4126,8 +3889,9 @@ function inspectFn(index) {
   return (request) => inspect.call(index, request);
 }
 function staticKnowledgeItemsPage(agent, request) {
+  const staticContext = staticContextDocuments(agent.agent);
   const start = Math.max(0, Math.trunc(Number(request.cursor ?? "0")));
-  const page = agent.agent.staticContext.slice(start, start + request.limit);
+  const page = staticContext.slice(start, start + request.limit);
   const nextOffset = start + page.length;
   const result = {
     agentId: agent.id,
@@ -4145,9 +3909,9 @@ function staticKnowledgeItemsPage(agent, request) {
       }
       return item;
     }),
-    totalCount: agent.agent.staticContext.length
+    totalCount: staticContext.length
   };
-  if (nextOffset < agent.agent.staticContext.length) result.nextCursor = String(nextOffset);
+  if (nextOffset < staticContext.length) result.nextCursor = String(nextOffset);
   return result;
 }
 function nonInspectablePage(agentId, sourceId, kind) {
@@ -4336,6 +4100,245 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(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");
+function agentToolItems(agent) {
+  const state = getAgentToolState2(agent.agent);
+  const items = state.staticTools.map((tool) => ({ tool, source: "static" }));
+  const names = new Set(items.map(({ tool }) => tool.name));
+  for (const index of state.toolIndexes) {
+    for (const tool of index.tools) {
+      if (!names.has(tool.name)) {
+        names.add(tool.name);
+        items.push({ tool, source: "dynamic" });
+      }
+    }
+  }
+  return items;
+}
+function approvalMetadata(tool) {
+  const approval = tool.requiresApproval;
+  if (approval === void 0 || approval === false) {
+    return { required: false };
+  }
+  if (typeof approval !== "object" || approval === null) {
+    return { required: true };
+  }
+  const policy = approval;
+  const metadata = { required: true };
+  if (typeof policy.reason === "string") metadata.reason = policy.reason;
+  return metadata;
+}
+function toolRequiresApproval(tool) {
+  const approval = tool.requiresApproval;
+  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;
+}
+function agentHasMcpTools(agent) {
+  return agentToolItems(agent).some(({ tool }) => mcpServerName(tool) !== void 0);
+}
+
+// src/runtime/config.ts
+function runnerId(options) {
+  return options.id ?? "anvia-studio";
+}
+function agentConfig(agent) {
+  const name = agent.name ?? agent.agent.name;
+  const description = agent.description ?? agent.agent.description;
+  const config = {
+    id: agent.id,
+    quickPrompts: agent.quickPrompts ?? []
+  };
+  if (name !== void 0) config.name = name;
+  if (description !== void 0) config.description = description;
+  if (agent.metadata !== void 0) config.metadata = agent.metadata;
+  return config;
+}
+function agentRuntimeSummary(agent) {
+  const tools = agentToolItems(agent);
+  const staticContext = staticContextDocuments(agent.agent);
+  const indexedContext = contextIndexes(agent.agent);
+  const name = agent.name ?? agent.agent.name;
+  const description = agent.description ?? agent.agent.description;
+  const summary = {
+    id: agent.id,
+    model: toJsonValue2(agent.agent.model),
+    toolCount: tools.length,
+    staticToolCount: tools.filter((item) => item.source === "static").length,
+    dynamicToolCount: tools.filter((item) => item.source === "dynamic").length,
+    approvalToolCount: tools.filter((item) => toolRequiresApproval(item.tool)).length,
+    mcpToolCount: tools.filter((item) => mcpServerName(item.tool) !== void 0).length,
+    staticContextCount: staticContext.length,
+    dynamicContextCount: indexedContext.length,
+    observerCount: agent.agent.observers.length,
+    hasMemory: agent.agent.memory !== void 0,
+    hasLifecycle: agent.agent.lifecycle !== void 0,
+    hasOutputSchema: agent.agent.outputSchema !== void 0
+  };
+  if (name !== void 0) summary.name = name;
+  if (description !== void 0) summary.description = description;
+  if (agent.agent.defaultMaxTurns !== void 0) {
+    summary.defaultMaxTurns = agent.agent.defaultMaxTurns;
+  }
+  if (agent.metadata !== void 0) summary.metadata = agent.metadata;
+  return summary;
+}
+function pipelineConfig(pipeline) {
+  const graph = pipeline.pipeline.graph();
+  const stageNodes = graph.nodes.filter((node) => node.kind !== "input" && node.kind !== "output");
+  const config = {
+    id: pipeline.id,
+    stageCount: stageNodes.length,
+    edgeCount: graph.edges.length,
+    hasParallelStages: graph.nodes.some((node) => node.kind === "parallel"),
+    agentCount: graph.nodes.filter((node) => node.kind === "agent").length,
+    extractorCount: graph.nodes.filter((node) => node.kind === "extractor").length
+  };
+  if (pipeline.name !== void 0) config.name = pipeline.name;
+  if (pipeline.description !== void 0) config.description = pipeline.description;
+  if (pipeline.metadata !== void 0) config.metadata = pipeline.metadata;
+  return config;
+}
+function buildConfig(options, agents, pipelines, stores, sandboxCount = 0) {
+  const models = options.models === void 0 ? void 0 : studioModelsConfig(createStudioModelRegistry(options.models), agents);
+  const config = {
+    id: runnerId(options),
+    agents: agents.map(agentConfig),
+    pipelines: pipelines.map(pipelineConfig),
+    evals: options.evals.map(evalConfig),
+    chat: {
+      quickPrompts: Object.fromEntries(agents.map((agent) => [agent.id, agent.quickPrompts ?? []]))
+    },
+    capabilities: capabilityConfig(options, agents, pipelines, stores, sandboxCount),
+    unsupportedCapabilities: unsupportedCapabilities(stores)
+  };
+  if (options.name !== void 0) config.name = options.name;
+  if (options.description !== void 0) config.description = options.description;
+  if (options.version !== void 0) config.version = options.version;
+  if (models !== void 0) config.models = models;
+  return config;
+}
+function capabilityConfig(_options, agents, pipelines, stores, sandboxCount = 0) {
+  const capabilities = {
+    agents: { enabled: true },
+    observability: { enabled: true },
+    status: { enabled: true }
+  };
+  if (stores.sessions !== void 0) {
+    capabilities.sessions = { enabled: true };
+  }
+  if (stores.sessions !== void 0 || agents.some((agent) => agent.agent.memory !== void 0)) {
+    capabilities.memory = { enabled: true };
+  }
+  if (stores.traces !== void 0) {
+    capabilities.traces = { enabled: true };
+  }
+  if (pipelines.length > 0) {
+    capabilities.pipelines = { enabled: true };
+  }
+  if (_options.evals.length > 0) {
+    capabilities.evals = { enabled: true };
+  }
+  if (agents.some((agent) => agent.agent.tools.length > 0)) {
+    capabilities.tools = { enabled: true };
+  }
+  if (agents.some(agentHasMcpTools)) {
+    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(agentHasKnowledge)) {
+    capabilities.knowledge = { enabled: true };
+  }
+  return capabilities;
+}
+function unsupportedCapabilities(stores) {
+  const capabilities = [];
+  if (stores.sessions === void 0) capabilities.push("sessions");
+  if (stores.traces === void 0) capabilities.push("traces");
+  return capabilities;
+}
+function toJsonValue2(value) {
+  return serializeUnknown(value);
+}
+
+// src/runtime/evals.ts
+import { runEvalSuite } from "@anvia/core/evals";
+function registerEvalRoutes(app, props) {
+  app.get(
+    "/evals",
+    (c) => c.json({
+      evals: props.evals.map(evalConfig)
+    })
+  );
+  app.get("/evals/:evalId", (c) => {
+    const suite = props.evalMap.get(c.req.param("evalId"));
+    if (suite === void 0) {
+      return errorResponse(c, 404, "not_found", "Eval suite not found");
+    }
+    return c.json(evalConfig(suite));
+  });
+  app.post("/evals/:evalId/runs", async (c) => {
+    const suite = props.evalMap.get(c.req.param("evalId"));
+    if (suite === void 0) {
+      return errorResponse(c, 404, "not_found", "Eval suite not found");
+    }
+    const body = await parseEvalRunRequest(c);
+    if ("error" in body) {
+      return body.error;
+    }
+    const runId = globalThis.crypto.randomUUID();
+    const startedAt = Date.now();
+    const runOptions = { ...suite };
+    if (body.concurrency !== void 0) runOptions.concurrency = body.concurrency;
+    const result = await runEvalSuite(runOptions);
+    const endedAt = Date.now();
+    const jsonResult = toJsonValue(result);
+    const response = {
+      runId,
+      suiteId: suite.id ?? suite.name,
+      startedAt: new Date(startedAt).toISOString(),
+      endedAt: new Date(endedAt).toISOString(),
+      durationMs: endedAt - startedAt,
+      result: isJsonObject(jsonResult) ? jsonResult : { value: jsonResult }
+    };
+    return c.json(response);
+  });
+}
+async function parseEvalRunRequest(c) {
+  let body = {};
+  try {
+    body = await c.req.json();
+  } catch {
+    body = {};
+  }
+  if (!isObject(body)) {
+    return { error: errorResponse(c, 400, "bad_request", "Request body must be an object") };
+  }
+  const request = {};
+  if ("concurrency" in body) {
+    if (!isPositiveInteger(body.concurrency)) {
+      return {
+        error: errorResponse(c, 400, "bad_request", "concurrency must be a positive integer")
+      };
+    }
+    request.concurrency = body.concurrency;
+  }
+  return request;
+}
+
 // src/runtime/mcps.ts
 function registerMcpRoutes(app, props) {
   app.get("/agents/:agentId/mcps", async (c) => {
@@ -5290,7 +5293,7 @@ function parsePipelineLogAfter(value) {
 }
 
 // src/runtime/questions.ts
-import { createHook as createHook2 } from "@anvia/core/hooks";
+import { createHook } from "@anvia/core/internal/agent";
 import { parseToolArgs } from "@anvia/core/tool";
 function registerQuestionRoutes(app, questions) {
   app.get("/questions", (c) => {
@@ -5383,7 +5386,7 @@ function createQuestionRuntime() {
   return {
     questions,
     createHook(context) {
-      return createHook2({
+      return createHook({
         async onToolCall({ toolName, toolCallId, internalCallId, args, tool: control }) {
           if (toolName !== "ask_question") {
             return control.run();
@@ -6820,7 +6823,7 @@ function waitForShutdown(signal) {
   });
 }
 function studioOptionsFromTargets(targets, options) {
-  const agents = targets.filter((target) => target instanceof Agent2);
+  const agents = targets.filter((target) => target instanceof Agent);
   const pipelines = targets.filter(
     // biome-ignore lint/suspicious/noExplicitAny: Studio accepts heterogeneous user pipelines.
     (target) => target instanceof Pipeline
@@ -6873,13 +6876,13 @@ function uniqueAgentId(baseId, ids) {
 }
 function agentMetadata(agent) {
   const metadata = {
-    staticContextCount: agent.staticContext.length,
-    dynamicContextCount: agent.dynamicContexts.length,
-    dynamicToolCount: agent.dynamicTools.length,
+    staticContextCount: staticContextDocuments(agent).length,
+    dynamicContextCount: contextIndexes(agent).length,
+    dynamicToolCount: getAgentToolState3(agent).toolIndexes.length,
+    hasLifecycle: agent.lifecycle !== void 0,
     hasOutputSchema: agent.outputSchema !== void 0,
-    hasHook: agent.hook !== void 0,
     observerCount: agent.observers.length,
-    approvalToolCount: agent.toolSet.values().filter((tool) => tool.approval !== void 0).length
+    approvalToolCount: agent.tools.filter(toolRequiresApproval).length
   };
   if (agent.defaultMaxTurns !== void 0) metadata.defaultMaxTurns = agent.defaultMaxTurns;
   return metadata;
@@ -8100,6 +8103,7 @@ function toTraceSummary(row) {
   if (error !== void 0) summary.error = error;
   if (usage !== void 0) summary.usage = usage;
   if (metadata !== void 0) summary.metadata = metadata;
+  if (typeof metadata?.runId === "string") summary.runId = metadata.runId;
   return summary;
 }
 function parseJsonArray(value) {