@mastra/server 1.33.0-alpha.1 → 1.33.0-alpha.13

package/dist/{chunk-MI3PFFAR.js → chunk-SYAGB4OG.js}

@@ -1,15 +1,15 @@
 import { getAgentSkillResponseSchema, skillDisambiguationQuerySchema } from './chunk-ZHULRNJG.js';
-import { listAgentsResponseSchema, serializedAgentSchema, agentVersionQuerySchema, agentIdPathParams, generateResponseSchema, agentExecutionBodySchema, agentExecutionLegacyBodySchema, streamResponseSchema, providersResponseSchema, streamUntilIdleBodySchema, observeAgentResponseSchema, observeAgentBodySchema, toolCallResponseSchema, approveToolCallBodySchema, declineToolCallBodySchema, resumeStreamBodySchema, approveNetworkToolCallBodySchema, declineNetworkToolCallBodySchema, modelManagementResponseSchema, updateAgentModelBodySchema, reorderAgentModelListBodySchema, updateAgentModelInModelListBodySchema, modelConfigIdPathParams, enhanceInstructionsResponseSchema, enhanceInstructionsBodySchema, agentSkillPathParams } from './chunk-43CWQ4M3.js';
-import { stringify, toSlug } from './chunk-X2LYM3QK.js';
-import { sanitizeBody, validateBody, getEffectiveResourceId, getEffectiveThreadId, enforceThreadAccess, validateThreadOwnership, validateRunOwnership } from './chunk-UOC4K3RU.js';
+import { listAgentsResponseSchema, serializedAgentSchema, agentVersionQuerySchema, agentIdPathParams, generateResponseSchema, agentExecutionBodySchema, agentExecutionLegacyBodySchema, streamResponseSchema, providersResponseSchema, sendAgentSignalBodySchema, subscribeAgentThreadBodySchema, streamUntilIdleBodySchema, observeAgentResponseSchema, observeAgentBodySchema, toolCallResponseSchema, approveToolCallBodySchema, declineToolCallBodySchema, resumeStreamBodySchema, resumeStreamUntilIdleBodySchema, approveNetworkToolCallBodySchema, declineNetworkToolCallBodySchema, modelManagementResponseSchema, updateAgentModelBodySchema, reorderAgentModelListBodySchema, updateAgentModelInModelListBodySchema, modelConfigIdPathParams, enhanceInstructionsResponseSchema, enhanceInstructionsBodySchema, agentSkillPathParams } from './chunk-EQUOHUYY.js';
+import { stringify, toSlug } from './chunk-DYHG4LMH.js';
+import { sanitizeBody, validateBody, getEffectiveResourceId, getEffectiveThreadId, enforceThreadAccess, validateThreadOwnership, validateRunOwnership } from './chunk-JOUPK2UV.js';
 import { MastraFGAPermissions } from './chunk-6KDKASVR.js';
-import { WORKSPACE_TOOLS, resolveToolConfig } from './chunk-OJRAH5VV.js';
+import { WORKSPACE_TOOLS, resolveToolConfig, MASTRA_IS_STUDIO_KEY, isReservedRequestContextKey } from './chunk-YARY4I5U.js';
 import { createStoredAgentResponseSchema } from './chunk-AIRSK4QU.js';
-import { createRoute, standardSchemaToJSONSchema, toStandardSchema5 } from './chunk-KDUX3YN3.js';
+import { createRoute, standardSchemaToJSONSchema, toStandardSchema5 } from './chunk-SW5NAE22.js';
 import { handleError } from './chunk-P23KBWKB.js';
 import { HTTPException } from './chunk-6QWQZI4Q.js';
 import { __export } from './chunk-PR4QN5HX.js';
-import { isDurableAgentLike, Agent } from '@mastra/core/agent';
+import { Agent, isDurableAgentLike } from '@mastra/core/agent';
 import { AGENT_STREAM_TOPIC } from '@mastra/core/agent/durable';
 import { MASTRA_VERSIONS_KEY, mergeVersionOverrides } from '@mastra/core/di';
 import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
@@ -39,6 +39,8 @@ __export(agents_exports, {
   REORDER_AGENT_MODEL_LIST_ROUTE: () => REORDER_AGENT_MODEL_LIST_ROUTE,
   RESET_AGENT_MODEL_ROUTE: () => RESET_AGENT_MODEL_ROUTE,
   RESUME_STREAM_ROUTE: () => RESUME_STREAM_ROUTE,
+  RESUME_STREAM_UNTIL_IDLE_ROUTE: () => RESUME_STREAM_UNTIL_IDLE_ROUTE,
+  SEND_AGENT_SIGNAL_ROUTE: () => SEND_AGENT_SIGNAL_ROUTE,
   STREAM_GENERATE_LEGACY_ROUTE: () => STREAM_GENERATE_LEGACY_ROUTE,
   STREAM_GENERATE_ROUTE: () => STREAM_GENERATE_ROUTE,
   STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE: () => STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE,
@@ -47,6 +49,7 @@ __export(agents_exports, {
   STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE: () => STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE,
   STREAM_UNTIL_IDLE_GENERATE_ROUTE: () => STREAM_UNTIL_IDLE_GENERATE_ROUTE,
   STREAM_VNEXT_DEPRECATED_ROUTE: () => STREAM_VNEXT_DEPRECATED_ROUTE,
+  SUBSCRIBE_AGENT_THREAD_ROUTE: () => SUBSCRIBE_AGENT_THREAD_ROUTE,
   UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE: () => UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE,
   UPDATE_AGENT_MODEL_ROUTE: () => UPDATE_AGENT_MODEL_ROUTE,
   extractVersionOptions: () => extractVersionOptions,
@@ -67,6 +70,20 @@ function stashVersionOverrides(ctx, versions) {
     ctx.set(MASTRA_VERSIONS_KEY, merged);
   }
 }
+function getIsStudioFromContext(requestContext) {
+  return requestContext.get(MASTRA_IS_STUDIO_KEY) === true;
+}
+function mergeBodyRequestContext(serverRequestContext, bodyRequestContext) {
+  if (!bodyRequestContext || typeof bodyRequestContext !== "object") {
+    return;
+  }
+  for (const [key, value] of Object.entries(bodyRequestContext)) {
+    if (isReservedRequestContextKey(key)) continue;
+    if (serverRequestContext.get(key) === void 0) {
+      serverRequestContext.set(key, value);
+    }
+  }
+}
 function isProviderConnected(providerId, customProviders) {
   const cleanId = providerId.includes(".") ? providerId.split(".")[0] : providerId;
   let provider = PROVIDER_REGISTRY[cleanId];
@@ -271,10 +288,8 @@ async function getSerializedAgentDefinition({
       const agents = await agent.listAgents({ requestContext });
       serializedAgentAgents = Object.entries(agents || {}).reduce(
         (acc, [key, agent2]) => {
-          return {
-            ...acc,
-            [key]: { id: agent2.id, name: agent2.name }
-          };
+          acc[key] = { id: agent2.id, name: agent2.name ?? key };
+          return acc;
         },
         {}
       );
@@ -452,8 +467,9 @@ async function getAgentFromSystem({
       for (const [_, ag] of Object.entries(agents)) {
         try {
           const subAgents = await ag.listAgents();
-          if (subAgents[agentId]) {
-            agent = subAgents[agentId];
+          const subAgent = subAgents[agentId];
+          if (subAgent instanceof Agent) {
+            agent = subAgent;
             break;
           }
         } catch (error) {
@@ -527,14 +543,24 @@ async function formatAgent({
       logger.error("Error getting workflows for agent", { agentName: agent.name, error });
     }
   }
-  let proxyRequestContext = requestContext;
-  const instructions = await agent.getInstructions({ requestContext: proxyRequestContext });
+  const instructionsRequestContext = isStudio ? new Proxy(requestContext, {
+    get(target, prop) {
+      if (prop === "get") {
+        return function(key) {
+          const value = target.get(key);
+          return value ?? `<${key}>`;
+        };
+      }
+      return Reflect.get(target, prop);
+    }
+  }) : requestContext;
+  const instructions = await agent.getInstructions({ requestContext: instructionsRequestContext });
   const llm = await agent.getLLM({ requestContext });
   const defaultGenerateOptionsLegacy = await agent.getDefaultGenerateOptionsLegacy({
-    requestContext: proxyRequestContext
+    requestContext
   });
-  const defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext: proxyRequestContext });
-  const defaultOptions = await agent.getDefaultOptions({ requestContext: proxyRequestContext });
+  const defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext });
+  const defaultOptions = await agent.getDefaultOptions({ requestContext });
   const model = llm?.getModel();
   const models = await agent.getModelList(requestContext);
   const modelList = models?.map((md) => ({
@@ -545,7 +571,7 @@ async function formatAgent({
       modelVersion: md.model.specificationVersion
     }
   }));
-  const serializedAgentAgents = await getSerializedAgentDefinition({ agent, requestContext: proxyRequestContext });
+  const serializedAgentAgents = await getSerializedAgentDefinition({ agent, requestContext });
   let serializedInputProcessors = [];
   let serializedOutputProcessors = [];
   try {
@@ -557,12 +583,12 @@ async function formatAgent({
   } catch (error) {
     mastra.getLogger().error("Error getting configured processors for agent", { agentName: agent.name, error });
   }
-  const serializedSkills = await getSerializedSkillsFromAgent(agent, proxyRequestContext);
-  const workspaceTools = await getWorkspaceToolsFromAgent(agent, proxyRequestContext);
+  const serializedSkills = await getSerializedSkillsFromAgent(agent, requestContext);
+  const workspaceTools = await getWorkspaceToolsFromAgent(agent, requestContext);
   const browserTools = getBrowserToolsFromAgent(agent, createBrowserToolsErrorLogger(mastra.getLogger(), agent.id));
   let workspaceId;
   try {
-    const workspace = await agent.getWorkspace({ requestContext: proxyRequestContext });
+    const workspace = await agent.getWorkspace({ requestContext });
     workspaceId = workspace?.id;
   } catch {
   }
@@ -715,7 +741,7 @@ var GET_AGENT_BY_ID_ROUTE = createRoute({
     try {
       const versionOptions = versionId ? { versionId } : status ? { status } : void 0;
       const agent = await getAgentFromSystem({ mastra, agentId, versionOptions, requestContext });
-      const isStudio = false;
+      const isStudio = getIsStudioFromContext(requestContext);
       const result = await formatAgent({
         mastra,
         agent,
@@ -795,13 +821,7 @@ var GENERATE_AGENT_ROUTE = createRoute({
         ),
         requestContext: serverRequestContext
       });
-      if (bodyRequestContext && typeof bodyRequestContext === "object") {
-        for (const [key, value] of Object.entries(bodyRequestContext)) {
-          if (serverRequestContext.get(key) === void 0) {
-            serverRequestContext.set(key, value);
-          }
-        }
-      }
+      mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
       stashVersionOverrides(serverRequestContext, versions);
       let authorizedMemoryOption = memoryOption;
       if (memoryOption) {
@@ -1053,13 +1073,7 @@ var STREAM_GENERATE_ROUTE = createRoute({
         ),
         requestContext: serverRequestContext
       });
-      if (bodyRequestContext && typeof bodyRequestContext === "object") {
-        for (const [key, value] of Object.entries(bodyRequestContext)) {
-          if (serverRequestContext.get(key) === void 0) {
-            serverRequestContext.set(key, value);
-          }
-        }
-      }
+      mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
       stashVersionOverrides(serverRequestContext, versions);
       let authorizedMemoryOption = memoryOption;
       if (memoryOption) {
@@ -1102,6 +1116,153 @@ var STREAM_GENERATE_ROUTE = createRoute({
     }
   }
 });
+var sendAgentSignalResponseSchema = z.object({
+  accepted: z.literal(true),
+  runId: z.string()
+});
+var SEND_AGENT_SIGNAL_ROUTE = createRoute({
+  method: "POST",
+  path: "/agents/:agentId/signals",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: sendAgentSignalBodySchema,
+  responseSchema: sendAgentSignalResponseSchema,
+  summary: "Send agent signal",
+  description: "Sends a signal to an active agent run or starts a memory thread run when the thread is idle",
+  tags: ["Agents", "Streaming"],
+  requiresAuth: true,
+  requiresPermission: "agents:execute",
+  handler: async ({
+    mastra,
+    agentId,
+    requestContext: serverRequestContext,
+    signal,
+    runId,
+    resourceId,
+    threadId,
+    ifActive,
+    ifIdle
+  }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId, requestContext: serverRequestContext });
+      const effectiveResourceId = getEffectiveResourceId(serverRequestContext, resourceId);
+      const effectiveThreadId = getEffectiveThreadId(serverRequestContext, threadId);
+      const ifIdleWithContext = {
+        ifIdle: {
+          ...ifIdle ?? {},
+          streamOptions: { ...ifIdle?.streamOptions ?? {}, requestContext: serverRequestContext }
+        }
+      };
+      if (effectiveThreadId && effectiveResourceId) {
+        const memory = await agent.getMemory({ requestContext: serverRequestContext });
+        if (memory) {
+          const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+          await validateThreadOwnership(thread, effectiveResourceId);
+        }
+      }
+      if (typeof agent.sendSignal !== "function") {
+        throw new HTTPException(501, { message: "agent signals are not supported by this Mastra core version" });
+      }
+      const agentSignal = signal;
+      if (runId) {
+        const result2 = await agent.sendSignal(agentSignal, {
+          runId,
+          ...effectiveResourceId ? { resourceId: effectiveResourceId } : {},
+          ...effectiveThreadId ? { threadId: effectiveThreadId } : {},
+          ...ifActive ? { ifActive } : {}
+        });
+        return { accepted: result2.accepted, runId: result2.runId, signal: result2.signal };
+      }
+      if (!effectiveResourceId || !effectiveThreadId) {
+        throw new HTTPException(400, { message: "resourceId and threadId are required when runId is not provided" });
+      }
+      const result = await agent.sendSignal(agentSignal, {
+        resourceId: effectiveResourceId,
+        threadId: effectiveThreadId,
+        ...ifActive ? { ifActive } : {},
+        ...ifIdleWithContext
+      });
+      return { accepted: result.accepted, runId: result.runId, signal: result.signal };
+    } catch (error) {
+      return handleError(error, "error sending agent signal");
+    }
+  }
+});
+var SUBSCRIBE_AGENT_THREAD_ROUTE = createRoute({
+  method: "POST",
+  path: "/agents/:agentId/threads/subscribe",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: subscribeAgentThreadBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Subscribe to agent thread runs",
+  description: "Subscribes to future and active stream runs for a memory thread",
+  tags: ["Agents", "Streaming"],
+  requiresAuth: true,
+  requiresPermission: "agents:execute",
+  handler: async ({ mastra, agentId, resourceId, threadId, abortSignal, requestContext: serverRequestContext }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId, requestContext: serverRequestContext });
+      if (typeof agent.subscribeToThread !== "function") {
+        throw new HTTPException(501, {
+          message: "agent thread subscriptions are not supported by this Mastra core version"
+        });
+      }
+      const effectiveResourceId = getEffectiveResourceId(serverRequestContext, resourceId);
+      const effectiveThreadId = getEffectiveThreadId(serverRequestContext, threadId);
+      if (!effectiveThreadId) {
+        throw new HTTPException(400, { message: "threadId is required" });
+      }
+      if (effectiveResourceId) {
+        const memory = await agent.getMemory({ requestContext: serverRequestContext });
+        if (memory) {
+          const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+          await validateThreadOwnership(thread, effectiveResourceId);
+        }
+      }
+      const subscription = await agent.subscribeToThread({
+        resourceId: effectiveResourceId,
+        threadId: effectiveThreadId
+      });
+      let cleanedUp = false;
+      const cleanup = (closeController) => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        subscription.abort();
+        subscription.unsubscribe();
+        if (closeController) {
+          try {
+            closeController.close();
+          } catch {
+          }
+        }
+      };
+      return new ReadableStream({
+        async start(controller) {
+          const abortCleanup = () => cleanup(controller);
+          abortSignal?.addEventListener("abort", abortCleanup, { once: true });
+          try {
+            for await (const part of subscription.stream) {
+              controller.enqueue(part);
+            }
+            cleanup(controller);
+          } catch (error) {
+            cleanup();
+            controller.error(error);
+          } finally {
+            abortSignal?.removeEventListener("abort", abortCleanup);
+          }
+        },
+        cancel() {
+          cleanup();
+        }
+      });
+    } catch (error) {
+      return handleError(error, "error subscribing to agent thread");
+    }
+  }
+});
 var STREAM_UNTIL_IDLE_GENERATE_ROUTE = createRoute({
   method: "POST",
   path: "/agents/:agentId/stream-until-idle",
@@ -1129,13 +1290,7 @@ var STREAM_UNTIL_IDLE_GENERATE_ROUTE = createRoute({
         ),
         requestContext: serverRequestContext
       });
-      if (bodyRequestContext && typeof bodyRequestContext === "object") {
-        for (const [key, value] of Object.entries(bodyRequestContext)) {
-          if (serverRequestContext.get(key) === void 0) {
-            serverRequestContext.set(key, value);
-          }
-        }
-      }
+      mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
       let authorizedMemoryOption = memoryOption;
       if (memoryOption) {
         const clientThreadId = typeof memoryOption.thread === "string" ? memoryOption.thread : memoryOption.thread?.id;
@@ -1356,6 +1511,90 @@ var RESUME_STREAM_ROUTE = createRoute({
   tags: ["Agents"],
   requiresAuth: true,
   requiresPermission: MastraFGAPermissions.AGENTS_EXECUTE,
+  handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+    try {
+      if (!params.runId) {
+        throw new HTTPException(400, { message: "Run id is required" });
+      }
+      sanitizeBody(params, ["tools"]);
+      const {
+        resumeData,
+        runId,
+        toolCallId,
+        memory: memoryOption,
+        requestContext: bodyRequestContext,
+        versions,
+        ...rest
+      } = params;
+      const agent = await getAgentFromSystem({
+        mastra,
+        agentId,
+        versionOptions: extractVersionOptions(
+          serverRequestContext,
+          bodyRequestContext
+        )
+      });
+      mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+      stashVersionOverrides(serverRequestContext, versions);
+      let authorizedMemoryOption = memoryOption;
+      const clientThreadId = typeof memoryOption?.thread === "string" ? memoryOption.thread : memoryOption?.thread?.id;
+      const effectiveResourceId = getEffectiveResourceId(serverRequestContext, memoryOption?.resource);
+      const effectiveThreadId = getEffectiveThreadId(serverRequestContext, clientThreadId);
+      if (effectiveThreadId) {
+        const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+        if (memoryInstance) {
+          const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+          if (thread) {
+            await enforceThreadAccess({
+              mastra,
+              requestContext: serverRequestContext,
+              threadId: effectiveThreadId,
+              thread,
+              effectiveResourceId,
+              permission: MastraFGAPermissions.MEMORY_WRITE
+            });
+          }
+        }
+      }
+      if (memoryOption || effectiveResourceId || effectiveThreadId) {
+        authorizedMemoryOption = {
+          ...memoryOption,
+          ...effectiveResourceId ? { resource: effectiveResourceId } : {},
+          ...effectiveThreadId ? { thread: effectiveThreadId } : {}
+        };
+      }
+      const workflowsStore = await mastra.getStorage()?.getStore("workflows");
+      const workflowRun = await workflowsStore?.getWorkflowRunById({ workflowName: "agentic-loop", runId });
+      await validateRunOwnership(workflowRun, getEffectiveResourceId(serverRequestContext, void 0));
+      const { structuredOutput, ...restOptions } = rest;
+      const options = {
+        runId,
+        toolCallId,
+        ...restOptions,
+        requestContext: serverRequestContext,
+        memory: authorizedMemoryOption,
+        abortSignal
+      };
+      const streamResult = structuredOutput ? await agent.resumeStream(resumeData, { ...options, structuredOutput }) : await agent.resumeStream(resumeData, options);
+      return streamResult.fullStream;
+    } catch (error) {
+      return handleError(error, "error resuming agent stream");
+    }
+  }
+});
+var RESUME_STREAM_UNTIL_IDLE_ROUTE = createRoute({
+  method: "POST",
+  path: "/agents/:agentId/resume-stream-until-idle",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: resumeStreamUntilIdleBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Resume agent stream until idle",
+  description: "Resumes a suspended agent stream until idle with custom resume data, also listens for background task completions and streams them in real-time",
+  tags: ["Agents"],
+  requiresAuth: true,
+  requiresPermission: "agents:execute",
   handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
     try {
       if (!params.runId) {
@@ -1426,7 +1665,7 @@ var RESUME_STREAM_ROUTE = createRoute({
         memory: authorizedMemoryOption,
         abortSignal
       };
-      const streamResult = structuredOutput ? await agent.resumeStream(resumeData, { ...options, structuredOutput }) : await agent.resumeStream(resumeData, options);
+      const streamResult = structuredOutput ? await agent.resumeStreamUntilIdle(resumeData, { ...options, structuredOutput }) : await agent.resumeStreamUntilIdle(resumeData, options);
       return streamResult.fullStream;
     } catch (error) {
       return handleError(error, "error resuming agent stream");
@@ -1910,6 +2149,6 @@ var GET_AGENT_SKILL_ROUTE = createRoute({
   }
 });
 
-export { APPROVE_NETWORK_TOOL_CALL_ROUTE, APPROVE_TOOL_CALL_GENERATE_ROUTE, APPROVE_TOOL_CALL_ROUTE, CLONE_AGENT_ROUTE, DECLINE_NETWORK_TOOL_CALL_ROUTE, DECLINE_TOOL_CALL_GENERATE_ROUTE, DECLINE_TOOL_CALL_ROUTE, ENHANCE_INSTRUCTIONS_ROUTE, GENERATE_AGENT_ROUTE, GENERATE_AGENT_VNEXT_ROUTE, GENERATE_LEGACY_ROUTE, GET_AGENT_BY_ID_ROUTE, GET_AGENT_SKILL_ROUTE, GET_PROVIDERS_ROUTE, LIST_AGENTS_ROUTE, OBSERVE_AGENT_STREAM_ROUTE, REORDER_AGENT_MODEL_LIST_ROUTE, RESET_AGENT_MODEL_ROUTE, RESUME_STREAM_ROUTE, STREAM_GENERATE_LEGACY_ROUTE, STREAM_GENERATE_ROUTE, STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE, STREAM_NETWORK_ROUTE, STREAM_UI_MESSAGE_DEPRECATED_ROUTE, STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE, STREAM_UNTIL_IDLE_GENERATE_ROUTE, STREAM_VNEXT_DEPRECATED_ROUTE, UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE, UPDATE_AGENT_MODEL_ROUTE, agents_exports, extractVersionOptions, getAgentFromSystem, getBrowserToolsFromAgent, getSerializedAgentTools, getSerializedProcessors, getSerializedSkillsFromAgent, getWorkspaceToolsFromAgent, isProviderConnected };
-//# sourceMappingURL=chunk-MI3PFFAR.js.map
-//# sourceMappingURL=chunk-MI3PFFAR.js.map
+export { APPROVE_NETWORK_TOOL_CALL_ROUTE, APPROVE_TOOL_CALL_GENERATE_ROUTE, APPROVE_TOOL_CALL_ROUTE, CLONE_AGENT_ROUTE, DECLINE_NETWORK_TOOL_CALL_ROUTE, DECLINE_TOOL_CALL_GENERATE_ROUTE, DECLINE_TOOL_CALL_ROUTE, ENHANCE_INSTRUCTIONS_ROUTE, GENERATE_AGENT_ROUTE, GENERATE_AGENT_VNEXT_ROUTE, GENERATE_LEGACY_ROUTE, GET_AGENT_BY_ID_ROUTE, GET_AGENT_SKILL_ROUTE, GET_PROVIDERS_ROUTE, LIST_AGENTS_ROUTE, OBSERVE_AGENT_STREAM_ROUTE, REORDER_AGENT_MODEL_LIST_ROUTE, RESET_AGENT_MODEL_ROUTE, RESUME_STREAM_ROUTE, RESUME_STREAM_UNTIL_IDLE_ROUTE, SEND_AGENT_SIGNAL_ROUTE, STREAM_GENERATE_LEGACY_ROUTE, STREAM_GENERATE_ROUTE, STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE, STREAM_NETWORK_ROUTE, STREAM_UI_MESSAGE_DEPRECATED_ROUTE, STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE, STREAM_UNTIL_IDLE_GENERATE_ROUTE, STREAM_VNEXT_DEPRECATED_ROUTE, SUBSCRIBE_AGENT_THREAD_ROUTE, UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE, UPDATE_AGENT_MODEL_ROUTE, agents_exports, extractVersionOptions, getAgentFromSystem, getBrowserToolsFromAgent, getSerializedAgentTools, getSerializedProcessors, getSerializedSkillsFromAgent, getWorkspaceToolsFromAgent, isProviderConnected };
+//# sourceMappingURL=chunk-SYAGB4OG.js.map
+//# sourceMappingURL=chunk-SYAGB4OG.js.map