@mastra/server 0.0.0-support-d1-client-20250701191943 → 0.0.0-suspendRuntimeContextTypeFix-20250930142630

package/dist/chunk-SXENNNR7.cjs

@@ -0,0 +1,625 @@
+'use strict';
+
+var chunkTVSIG4JE_cjs = require('./chunk-TVSIG4JE.cjs');
+var chunk743UIDHI_cjs = require('./chunk-743UIDHI.cjs');
+var chunkAK2FXLLB_cjs = require('./chunk-AK2FXLLB.cjs');
+var chunkP7RBMCBE_cjs = require('./chunk-P7RBMCBE.cjs');
+var chunkHZJRQ5L3_cjs = require('./chunk-HZJRQ5L3.cjs');
+var chunkIGFMAZZ5_cjs = require('./chunk-IGFMAZZ5.cjs');
+var chunkHJQKWRKQ_cjs = require('./chunk-HJQKWRKQ.cjs');
+var chunk5DP5XZH6_cjs = require('./chunk-5DP5XZH6.cjs');
+var chunkG4PUALCE_cjs = require('./chunk-G4PUALCE.cjs');
+var chunkFALVL2VV_cjs = require('./chunk-FALVL2VV.cjs');
+var chunkPPYGWINI_cjs = require('./chunk-PPYGWINI.cjs');
+var chunkGU4EWMZB_cjs = require('./chunk-GU4EWMZB.cjs');
+var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
+var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.cjs');
+var chunkEMMSS5I5_cjs = require('./chunk-EMMSS5I5.cjs');
+var runtimeContext = require('@mastra/core/runtime-context');
+var zodToJson = require('@mastra/core/utils/zod-to-json');
+
+// src/server/handlers/agents.ts
+var agents_exports = {};
+chunkEMMSS5I5_cjs.__export(agents_exports, {
+  generateHandler: () => generateHandler,
+  generateLegacyHandler: () => generateLegacyHandler,
+  generateVNextHandler: () => generateVNextHandler,
+  getAgentByIdHandler: () => getAgentByIdHandler,
+  getAgentsHandler: () => getAgentsHandler,
+  getEvalsByAgentIdHandler: () => getEvalsByAgentIdHandler,
+  getLiveEvalsByAgentIdHandler: () => getLiveEvalsByAgentIdHandler,
+  getSerializedAgentTools: () => getSerializedAgentTools,
+  reorderAgentModelListHandler: () => reorderAgentModelListHandler,
+  streamGenerateHandler: () => streamGenerateHandler,
+  streamGenerateLegacyHandler: () => streamGenerateLegacyHandler,
+  streamNetworkHandler: () => streamNetworkHandler,
+  streamVNextGenerateHandler: () => streamVNextGenerateHandler,
+  streamVNextUIMessageHandler: () => streamVNextUIMessageHandler,
+  updateAgentModelHandler: () => updateAgentModelHandler,
+  updateAgentModelInModelListHandler: () => updateAgentModelInModelListHandler
+});
+async function getSerializedAgentTools(tools) {
+  return Object.entries(tools || {}).reduce((acc, [key, tool]) => {
+    const _tool = tool;
+    const toolId = _tool.id ?? `tool-${key}`;
+    let inputSchemaForReturn = void 0;
+    if (_tool.inputSchema) {
+      if (_tool.inputSchema?.jsonSchema) {
+        inputSchemaForReturn = chunkGU4EWMZB_cjs.stringify(_tool.inputSchema.jsonSchema);
+      } else {
+        inputSchemaForReturn = chunkGU4EWMZB_cjs.stringify(zodToJson.zodToJsonSchema(_tool.inputSchema));
+      }
+    }
+    let outputSchemaForReturn = void 0;
+    if (_tool.outputSchema) {
+      if (_tool.outputSchema?.jsonSchema) {
+        outputSchemaForReturn = chunkGU4EWMZB_cjs.stringify(_tool.outputSchema.jsonSchema);
+      } else {
+        outputSchemaForReturn = chunkGU4EWMZB_cjs.stringify(zodToJson.zodToJsonSchema(_tool.outputSchema));
+      }
+    }
+    acc[key] = {
+      ..._tool,
+      id: toolId,
+      inputSchema: inputSchemaForReturn,
+      outputSchema: outputSchemaForReturn
+    };
+    return acc;
+  }, {});
+}
+async function getSerializedAgentDefinition({
+  agent,
+  runtimeContext
+}) {
+  let serializedAgentAgents = {};
+  if ("listAgents" in agent) {
+    const agents = await agent.listAgents({ runtimeContext });
+    serializedAgentAgents = Object.entries(agents || {}).reduce((acc, [key, agent2]) => {
+      return {
+        ...acc,
+        [key]: { id: agent2.id, name: agent2.name }
+      };
+    }, {});
+  }
+  return serializedAgentAgents;
+}
+async function formatAgentList({
+  id,
+  mastra,
+  agent,
+  runtimeContext
+}) {
+  const instructions = await agent.getInstructions({ runtimeContext });
+  const tools = await agent.getTools({ runtimeContext });
+  const llm = await agent.getLLM({ runtimeContext });
+  const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext });
+  const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext });
+  const serializedAgentTools = await getSerializedAgentTools(tools);
+  let serializedAgentWorkflows = {};
+  if ("getWorkflows" in agent) {
+    const logger = mastra.getLogger();
+    try {
+      const workflows = await agent.getWorkflows({ runtimeContext });
+      serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+        return {
+          ...acc,
+          [key]: {
+            name: workflow.name
+          }
+        };
+      }, {});
+    } catch (error) {
+      logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+    }
+  }
+  const serializedAgentAgents = await getSerializedAgentDefinition({ agent, runtimeContext });
+  const model = llm?.getModel();
+  const models = await agent.getModelList(runtimeContext);
+  const modelList = models?.map((md) => ({
+    ...md,
+    model: {
+      modelId: md.model.modelId,
+      provider: md.model.provider,
+      modelVersion: md.model.specificationVersion
+    }
+  }));
+  return {
+    id,
+    name: agent.name,
+    instructions,
+    agents: serializedAgentAgents,
+    tools: serializedAgentTools,
+    workflows: serializedAgentWorkflows,
+    provider: llm?.getProvider(),
+    modelId: llm?.getModelId(),
+    modelVersion: model?.specificationVersion,
+    defaultGenerateOptions,
+    defaultStreamOptions,
+    modelList
+  };
+}
+async function getAgentsHandler({ mastra, runtimeContext }) {
+  try {
+    const agents = mastra.getAgents();
+    const serializedAgentsMap = await Promise.all(
+      Object.entries(agents).map(async ([id, agent]) => {
+        return formatAgentList({ id, mastra, agent, runtimeContext });
+      })
+    );
+    const serializedAgents = serializedAgentsMap.reduce((acc, { id, ...rest }) => {
+      acc[id] = rest;
+      return acc;
+    }, {});
+    return serializedAgents;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting agents");
+  }
+}
+async function formatAgent({
+  mastra,
+  agent,
+  runtimeContext,
+  isPlayground
+}) {
+  const tools = await agent.getTools({ runtimeContext });
+  const serializedAgentTools = await getSerializedAgentTools(tools);
+  let serializedAgentWorkflows = {};
+  if ("getWorkflows" in agent) {
+    const logger = mastra.getLogger();
+    try {
+      const workflows = await agent.getWorkflows({ runtimeContext });
+      serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+        return {
+          ...acc,
+          [key]: {
+            name: workflow.name,
+            steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
+              return {
+                ...acc2,
+                [key2]: {
+                  id: step.id,
+                  description: step.description
+                }
+              };
+            }, {})
+          }
+        };
+      }, {});
+    } catch (error) {
+      logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+    }
+    let proxyRuntimeContext = runtimeContext;
+    if (isPlayground) {
+      proxyRuntimeContext = new Proxy(runtimeContext, {
+        get(target, prop) {
+          if (prop === "get") {
+            return function(key) {
+              const value = target.get(key);
+              return value ?? `<${key}>`;
+            };
+          }
+          return Reflect.get(target, prop);
+        }
+      });
+    }
+    const instructions = await agent.getInstructions({ runtimeContext: proxyRuntimeContext });
+    const llm = await agent.getLLM({ runtimeContext });
+    const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext: proxyRuntimeContext });
+    const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext: proxyRuntimeContext });
+    const model = llm?.getModel();
+    const models = await agent.getModelList(runtimeContext);
+    const modelList = models?.map((md) => ({
+      ...md,
+      model: {
+        modelId: md.model.modelId,
+        provider: md.model.provider,
+        modelVersion: md.model.specificationVersion
+      }
+    }));
+    const serializedAgentAgents = await getSerializedAgentDefinition({ agent, runtimeContext: proxyRuntimeContext });
+    return {
+      name: agent.name,
+      instructions,
+      tools: serializedAgentTools,
+      agents: serializedAgentAgents,
+      workflows: serializedAgentWorkflows,
+      provider: llm?.getProvider(),
+      modelId: llm?.getModelId(),
+      modelVersion: model?.specificationVersion,
+      modelList,
+      defaultGenerateOptions,
+      defaultStreamOptions
+    };
+  }
+}
+async function getAgentByIdHandler({
+  mastra,
+  runtimeContext,
+  agentId,
+  isPlayground = false
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    return formatAgent({ mastra, agent, runtimeContext, isPlayground });
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "test") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "live") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting live evals");
+  }
+}
+function generateHandler({
+  mastra,
+  ...args
+}) {
+  const logger = mastra.getLogger();
+  logger?.warn(
+    "Deprecation NOTICE:\nGenerate method will switch to use generateVNext implementation September 30th, 2025. Please use generateLegacyHandler if you don't want to upgrade just yet."
+  );
+  return generateLegacyHandler({ mastra, ...args });
+}
+async function generateLegacyHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    chunkG4PUALCE_cjs.sanitizeBody(body, ["tools"]);
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const result = await agent.generate(messages, {
+      ...rest,
+      abortSignal,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      runtimeContext: finalRuntimeContext
+    });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error generating from agent");
+  }
+}
+async function generateVNextHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    chunkG4PUALCE_cjs.sanitizeBody(body, ["tools"]);
+    const { messages, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const result = await agent.generateVNext(messages, {
+      ...rest,
+      runtimeContext: finalRuntimeContext,
+      format: rest.format || "mastra",
+      abortSignal
+    });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  ...args
+}) {
+  const logger = mastra.getLogger();
+  logger?.warn(
+    "Deprecation NOTICE:\n Stream method will switch to use streamVNext implementation September 30th, 2025. Please use streamGenerateLegacyHandler if you don't want to upgrade just yet."
+  );
+  return streamGenerateLegacyHandler({ mastra, ...args });
+}
+async function streamGenerateLegacyHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const streamResult = await agent.stream(messages, {
+      ...rest,
+      abortSignal,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      runtimeContext: finalRuntimeContext
+    });
+    const streamResponse = rest.output ? streamResult.toTextStreamResponse({
+      headers: {
+        "Transfer-Encoding": "chunked"
+      }
+    }) : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      },
+      headers: {
+        "Transfer-Encoding": "chunked"
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error streaming agent response");
+  }
+}
+function streamVNextGenerateHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    chunkG4PUALCE_cjs.sanitizeBody(body, ["tools"]);
+    const { messages, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const streamResult = agent.streamVNext(messages, {
+      ...rest,
+      runtimeContext: finalRuntimeContext,
+      abortSignal,
+      format: body.format ?? "mastra"
+    });
+    return streamResult;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error streaming agent response");
+  }
+}
+function streamNetworkHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body
+  // abortSignal,
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    chunkG4PUALCE_cjs.sanitizeBody(body, ["tools"]);
+    const { messages, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const streamResult = agent.network(messages, {
+      ...rest,
+      memory: {
+        thread: rest.thread ?? "",
+        resource: rest.resourceId ?? ""
+      },
+      runtimeContext: finalRuntimeContext
+    });
+    return streamResult;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error streaming agent loop response");
+  }
+}
+async function streamVNextUIMessageHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    chunkG4PUALCE_cjs.sanitizeBody(body, ["tools"]);
+    const { messages, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkG4PUALCE_cjs.validateBody({ messages });
+    const streamResult = await agent.streamVNext(messages, {
+      ...rest,
+      runtimeContext: finalRuntimeContext,
+      abortSignal,
+      format: "aisdk"
+    });
+    return streamResult.toUIMessageStreamResponse();
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error streaming agent response");
+  }
+}
+async function updateAgentModelHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const agentModel = await agent.getModel();
+    const modelVersion = agentModel.specificationVersion;
+    const { modelId, provider } = body;
+    const providerMap = {
+      v1: {
+        openai: chunkPPYGWINI_cjs.openai(modelId),
+        anthropic: chunkIGFMAZZ5_cjs.anthropic(modelId),
+        groq: chunkHJQKWRKQ_cjs.groq(modelId),
+        xai: chunk5DP5XZH6_cjs.xai(modelId),
+        google: chunkTVSIG4JE_cjs.google(modelId)
+      },
+      v2: {
+        openai: chunkFALVL2VV_cjs.openai(modelId),
+        anthropic: chunk743UIDHI_cjs.anthropic(modelId),
+        groq: chunkAK2FXLLB_cjs.groq(modelId),
+        xai: chunkP7RBMCBE_cjs.xai(modelId),
+        google: chunkHZJRQ5L3_cjs.google(modelId)
+      }
+    };
+    const modelVersionKey = modelVersion === "v2" ? "v2" : "v1";
+    const model = providerMap[modelVersionKey][provider];
+    agent.__updateModel({ model });
+    return { message: "Agent model updated" };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error updating agent model");
+  }
+}
+async function reorderAgentModelListHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const modelList = await agent.getModelList();
+    if (!modelList || modelList.length === 0) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Agent model list is not found or empty" });
+    }
+    agent.reorderModels(body.reorderedModelIds);
+    return { message: "Model list reordered" };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error reordering model list");
+  }
+}
+async function updateAgentModelInModelListHandler({
+  mastra,
+  agentId,
+  modelConfigId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { model: bodyModel, maxRetries, enabled } = body;
+    if (!modelConfigId) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Model id is required" });
+    }
+    const modelList = await agent.getModelList();
+    if (!modelList || modelList.length === 0) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Agent model list is not found or empty" });
+    }
+    const modelToUpdate = modelList.find((m) => m.id === modelConfigId);
+    if (!modelToUpdate) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Model to update is not found in agent model list" });
+    }
+    let model;
+    if (bodyModel) {
+      const { modelId, provider } = bodyModel;
+      const providerMap = {
+        openai: chunkFALVL2VV_cjs.openai(modelId),
+        anthropic: chunk743UIDHI_cjs.anthropic(modelId),
+        groq: chunkAK2FXLLB_cjs.groq(modelId),
+        xai: chunkP7RBMCBE_cjs.xai(modelId),
+        google: chunkHZJRQ5L3_cjs.google(modelId)
+      };
+      model = providerMap[provider];
+    }
+    agent.updateModelInModelList({ id: modelConfigId, model, maxRetries, enabled });
+    return { message: "Model list updated" };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "error updating model list");
+  }
+}
+
+exports.agents_exports = agents_exports;
+exports.generateHandler = generateHandler;
+exports.generateLegacyHandler = generateLegacyHandler;
+exports.generateVNextHandler = generateVNextHandler;
+exports.getAgentByIdHandler = getAgentByIdHandler;
+exports.getAgentsHandler = getAgentsHandler;
+exports.getEvalsByAgentIdHandler = getEvalsByAgentIdHandler;
+exports.getLiveEvalsByAgentIdHandler = getLiveEvalsByAgentIdHandler;
+exports.getSerializedAgentTools = getSerializedAgentTools;
+exports.reorderAgentModelListHandler = reorderAgentModelListHandler;
+exports.streamGenerateHandler = streamGenerateHandler;
+exports.streamGenerateLegacyHandler = streamGenerateLegacyHandler;
+exports.streamNetworkHandler = streamNetworkHandler;
+exports.streamVNextGenerateHandler = streamVNextGenerateHandler;
+exports.streamVNextUIMessageHandler = streamVNextUIMessageHandler;
+exports.updateAgentModelHandler = updateAgentModelHandler;
+exports.updateAgentModelInModelListHandler = updateAgentModelInModelListHandler;
+//# sourceMappingURL=chunk-SXENNNR7.cjs.map
+//# sourceMappingURL=chunk-SXENNNR7.cjs.map