@mastra/server 0.0.0-commonjs-20250414101718

package/dist/chunk-YANVFOYA.js

@@ -0,0 +1,120 @@
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+
+// src/server/handlers/network.ts
+var network_exports = {};
+__export(network_exports, {
+  generateHandler: () => generateHandler,
+  getNetworkByIdHandler: () => getNetworkByIdHandler,
+  getNetworksHandler: () => getNetworksHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getNetworksHandler({ mastra }) {
+  try {
+    const networks = mastra.getNetworks();
+    const serializedNetworks = networks.map((network) => {
+      const routingAgent = network.getRoutingAgent();
+      const agents = network.getAgents();
+      return {
+        id: network.formatAgentId(routingAgent.name),
+        name: routingAgent.name,
+        instructions: routingAgent.instructions,
+        agents: agents.map((agent) => ({
+          name: agent.name,
+          provider: agent.llm?.getProvider(),
+          modelId: agent.llm?.getModelId()
+        })),
+        routingModel: {
+          provider: routingAgent.llm?.getProvider(),
+          modelId: routingAgent.llm?.getModelId()
+        }
+      };
+    });
+    return serializedNetworks;
+  } catch (error) {
+    return handleError(error, "Error getting networks");
+  }
+}
+async function getNetworkByIdHandler({ mastra, networkId }) {
+  try {
+    const networks = mastra.getNetworks();
+    const network = networks.find((network2) => {
+      const routingAgent2 = network2.getRoutingAgent();
+      return network2.formatAgentId(routingAgent2.name) === networkId;
+    });
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    const routingAgent = network.getRoutingAgent();
+    const agents = network.getAgents();
+    const serializedNetwork = {
+      id: network.formatAgentId(routingAgent.name),
+      name: routingAgent.name,
+      instructions: routingAgent.instructions,
+      agents: agents.map((agent) => ({
+        name: agent.name,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      })),
+      routingModel: {
+        provider: routingAgent.llm?.getProvider(),
+        modelId: routingAgent.llm?.getModelId()
+      }
+    };
+    return serializedNetwork;
+  } catch (error) {
+    return handleError(error, "Error getting network by ID");
+  }
+}
+async function generateHandler({
+  mastra,
+  container,
+  networkId,
+  body
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    validateBody({ messages: body.messages });
+    const { messages, ...rest } = body;
+    const result = await network.generate(messages, { ...rest, container });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body,
+  container
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    validateBody({ messages: body.messages });
+    const { messages, output, ...rest } = body;
+    const streamResult = await network.stream(messages, {
+      output,
+      ...rest,
+      container
+    });
+    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming from network");
+  }
+}
+
+export { generateHandler, getNetworkByIdHandler, getNetworksHandler, network_exports, streamGenerateHandler };

package/dist/chunk-YNSGUC2O.js

@@ -0,0 +1,116 @@
+import { stringify, esm_default } from './chunk-VK6FX47H.js';
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { isVercelTool } from '@mastra/core/tools';
+
+// src/server/handlers/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  executeAgentToolHandler: () => executeAgentToolHandler,
+  executeToolHandler: () => executeToolHandler,
+  getToolByIdHandler: () => getToolByIdHandler,
+  getToolsHandler: () => getToolsHandler
+});
+async function getToolsHandler({ tools }) {
+  try {
+    if (!tools) {
+      return {};
+    }
+    const serializedTools = Object.entries(tools).reduce(
+      (acc, [id, _tool]) => {
+        const tool = _tool;
+        acc[id] = {
+          ...tool,
+          inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+        };
+        return acc;
+      },
+      {}
+    );
+    return serializedTools;
+  } catch (error) {
+    return handleError(error, "Error getting tools");
+  }
+}
+async function getToolByIdHandler({ tools, toolId }) {
+  try {
+    const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new HTTPException(404, { message: "Tool not found" });
+    }
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+    };
+    return serializedTool;
+  } catch (error) {
+    return handleError(error, "Error getting tool");
+  }
+}
+function executeToolHandler(tools) {
+  return async ({
+    mastra,
+    runId,
+    toolId,
+    data
+  }) => {
+    try {
+      if (!toolId) {
+        throw new HTTPException(400, { message: "Tool ID is required" });
+      }
+      const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+      if (!tool) {
+        throw new HTTPException(404, { message: "Tool not found" });
+      }
+      if (!tool?.execute) {
+        throw new HTTPException(400, { message: "Tool is not executable" });
+      }
+      validateBody({ data });
+      if (isVercelTool(tool)) {
+        const result2 = await tool.execute(data);
+        return result2;
+      }
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId
+      });
+      return result;
+    } catch (error) {
+      return handleError(error, "Error executing tool");
+    }
+  };
+}
+async function executeAgentToolHandler({
+  mastra,
+  agentId,
+  toolId,
+  data
+}) {
+  try {
+    const agent = agentId ? mastra.getAgent(agentId) : null;
+    if (!agent) {
+      throw new HTTPException(404, { message: "Tool not found" });
+    }
+    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new HTTPException(404, { message: "Tool not found" });
+    }
+    if (!tool?.execute) {
+      throw new HTTPException(400, { message: "Tool is not executable" });
+    }
+    const result = await tool.execute({
+      context: data,
+      mastra,
+      runId: agentId
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error executing tool");
+  }
+}
+
+export { executeAgentToolHandler, executeToolHandler, getToolByIdHandler, getToolsHandler, tools_exports };

package/dist/chunk-Z46X3YCB.cjs

@@ -0,0 +1,164 @@
+'use strict';
+
+var chunkQH6XWSXP_cjs = require('./chunk-QH6XWSXP.cjs');
+var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/agents.ts
+var agents_exports = {};
+chunkFV45V6WC_cjs.__export(agents_exports, {
+  generateHandler: () => generateHandler,
+  getAgentByIdHandler: () => getAgentByIdHandler,
+  getAgentsHandler: () => getAgentsHandler,
+  getEvalsByAgentIdHandler: () => getEvalsByAgentIdHandler,
+  getLiveEvalsByAgentIdHandler: () => getLiveEvalsByAgentIdHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getAgentsHandler({ mastra }) {
+  try {
+    const agents = mastra.getAgents();
+    const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
+      const agent = _agent;
+      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc2, [key, tool]) => {
+        const _tool = tool;
+        acc2[key] = {
+          ..._tool,
+          inputSchema: _tool.inputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(_tool.inputSchema)) : void 0,
+          outputSchema: _tool.outputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(_tool.outputSchema)) : void 0
+        };
+        return acc2;
+      }, {});
+      acc[_id] = {
+        name: agent.name,
+        instructions: agent.instructions,
+        tools: serializedAgentTools,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      };
+      return acc;
+    }, {});
+    return serializedAgents;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
+      const _tool = tool;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(_tool.inputSchema)) : void 0,
+        outputSchema: _tool.outputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(_tool.outputSchema)) : void 0
+      };
+      return acc;
+    }, {});
+    return {
+      name: agent.name,
+      instructions: agent.instructions,
+      tools: serializedAgentTools,
+      provider: agent.llm?.getProvider(),
+      modelId: agent.llm?.getModelId()
+    };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.__getEvalsByAgentName?.(agent.name, "test") || [];
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.__getEvalsByAgentName?.(agent.name, "live") || [];
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler({
+  mastra,
+  container,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    chunkQN4KF3BH_cjs.validateBody({ messages });
+    const result = await agent.generate(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      container
+    });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  container,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    chunkQN4KF3BH_cjs.validateBody({ messages });
+    const streamResult = await agent.stream(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      container
+    });
+    const streamResponse = rest.output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    throw new chunkFV45V6WC_cjs.HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });
+  }
+}
+
+exports.agents_exports = agents_exports;
+exports.generateHandler = generateHandler;
+exports.getAgentByIdHandler = getAgentByIdHandler;
+exports.getAgentsHandler = getAgentsHandler;
+exports.getEvalsByAgentIdHandler = getEvalsByAgentIdHandler;
+exports.getLiveEvalsByAgentIdHandler = getLiveEvalsByAgentIdHandler;
+exports.streamGenerateHandler = streamGenerateHandler;

package/dist/chunk-ZLBRQFDD.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/error.ts
+function handleError(error, defaultMessage) {
+  const apiError = error;
+  throw new chunkFV45V6WC_cjs.HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage
+  });
+}
+
+exports.handleError = handleError;

package/dist/index.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/index.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+

package/dist/server/handlers/agents.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var chunkZ46X3YCB_cjs = require('../../chunk-Z46X3YCB.cjs');
+
+
+
+Object.defineProperty(exports, "generateHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.generateHandler; }
+});
+Object.defineProperty(exports, "getAgentByIdHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.getAgentByIdHandler; }
+});
+Object.defineProperty(exports, "getAgentsHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.getAgentsHandler; }
+});
+Object.defineProperty(exports, "getEvalsByAgentIdHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.getEvalsByAgentIdHandler; }
+});
+Object.defineProperty(exports, "getLiveEvalsByAgentIdHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.getLiveEvalsByAgentIdHandler; }
+});
+Object.defineProperty(exports, "streamGenerateHandler", {
+  enumerable: true,
+  get: function () { return chunkZ46X3YCB_cjs.streamGenerateHandler; }
+});

package/dist/server/handlers/agents.d.cts

@@ -0,0 +1,6 @@
+export { getAgentsHandler } from '../../_tsup-dts-rollup.cjs';
+export { getAgentByIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { getEvalsByAgentIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { getLiveEvalsByAgentIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { generateHandler } from '../../_tsup-dts-rollup.cjs';
+export { streamGenerateHandler } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/agents.d.ts

@@ -0,0 +1,6 @@
+export { getAgentsHandler } from '../../_tsup-dts-rollup.js';
+export { getAgentByIdHandler } from '../../_tsup-dts-rollup.js';
+export { getEvalsByAgentIdHandler } from '../../_tsup-dts-rollup.js';
+export { getLiveEvalsByAgentIdHandler } from '../../_tsup-dts-rollup.js';
+export { generateHandler } from '../../_tsup-dts-rollup.js';
+export { streamGenerateHandler } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/agents.js

@@ -0,0 +1 @@
+export { generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler } from '../../chunk-67WTHYAV.js';

package/dist/server/handlers/error.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkZLBRQFDD_cjs = require('../../chunk-ZLBRQFDD.cjs');
+
+
+
+Object.defineProperty(exports, "handleError", {
+  enumerable: true,
+  get: function () { return chunkZLBRQFDD_cjs.handleError; }
+});

package/dist/server/handlers/error.d.cts

@@ -0,0 +1 @@
+export { handleError } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/error.d.ts

@@ -0,0 +1 @@
+export { handleError } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/error.js

@@ -0,0 +1 @@
+export { handleError } from '../../chunk-3AHQ5RGN.js';

package/dist/server/handlers/logs.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkSKBVVI24_cjs = require('../../chunk-SKBVVI24.cjs');
+
+
+
+Object.defineProperty(exports, "getLogTransports", {
+  enumerable: true,
+  get: function () { return chunkSKBVVI24_cjs.getLogTransports; }
+});
+Object.defineProperty(exports, "getLogsByRunIdHandler", {
+  enumerable: true,
+  get: function () { return chunkSKBVVI24_cjs.getLogsByRunIdHandler; }
+});
+Object.defineProperty(exports, "getLogsHandler", {
+  enumerable: true,
+  get: function () { return chunkSKBVVI24_cjs.getLogsHandler; }
+});

package/dist/server/handlers/logs.d.cts

@@ -0,0 +1,3 @@
+export { getLogsHandler } from '../../_tsup-dts-rollup.cjs';
+export { getLogsByRunIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { getLogTransports } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/logs.d.ts

@@ -0,0 +1,3 @@
+export { getLogsHandler } from '../../_tsup-dts-rollup.js';
+export { getLogsByRunIdHandler } from '../../_tsup-dts-rollup.js';
+export { getLogTransports } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/logs.js

@@ -0,0 +1 @@
+export { getLogTransports, getLogsByRunIdHandler, getLogsHandler } from '../../chunk-3EJZQ6TQ.js';

package/dist/server/handlers/memory.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var chunk2FJURXCL_cjs = require('../../chunk-2FJURXCL.cjs');
+
+
+
+Object.defineProperty(exports, "createThreadHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.createThreadHandler; }
+});
+Object.defineProperty(exports, "deleteThreadHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.deleteThreadHandler; }
+});
+Object.defineProperty(exports, "getMemoryStatusHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.getMemoryStatusHandler; }
+});
+Object.defineProperty(exports, "getMessagesHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.getMessagesHandler; }
+});
+Object.defineProperty(exports, "getThreadByIdHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.getThreadByIdHandler; }
+});
+Object.defineProperty(exports, "getThreadsHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.getThreadsHandler; }
+});
+Object.defineProperty(exports, "saveMessagesHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.saveMessagesHandler; }
+});
+Object.defineProperty(exports, "updateThreadHandler", {
+  enumerable: true,
+  get: function () { return chunk2FJURXCL_cjs.updateThreadHandler; }
+});

package/dist/server/handlers/memory.d.cts

@@ -0,0 +1,8 @@
+export { getMemoryStatusHandler } from '../../_tsup-dts-rollup.cjs';
+export { getThreadsHandler } from '../../_tsup-dts-rollup.cjs';
+export { getThreadByIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { saveMessagesHandler } from '../../_tsup-dts-rollup.cjs';
+export { createThreadHandler } from '../../_tsup-dts-rollup.cjs';
+export { updateThreadHandler } from '../../_tsup-dts-rollup.cjs';
+export { deleteThreadHandler } from '../../_tsup-dts-rollup.cjs';
+export { getMessagesHandler } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/memory.d.ts

@@ -0,0 +1,8 @@
+export { getMemoryStatusHandler } from '../../_tsup-dts-rollup.js';
+export { getThreadsHandler } from '../../_tsup-dts-rollup.js';
+export { getThreadByIdHandler } from '../../_tsup-dts-rollup.js';
+export { saveMessagesHandler } from '../../_tsup-dts-rollup.js';
+export { createThreadHandler } from '../../_tsup-dts-rollup.js';
+export { updateThreadHandler } from '../../_tsup-dts-rollup.js';
+export { deleteThreadHandler } from '../../_tsup-dts-rollup.js';
+export { getMessagesHandler } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/memory.js

@@ -0,0 +1 @@
+export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, saveMessagesHandler, updateThreadHandler } from '../../chunk-RBQASTUP.js';

package/dist/server/handlers/network.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunkJLDXUWK7_cjs = require('../../chunk-JLDXUWK7.cjs');
+
+
+
+Object.defineProperty(exports, "generateHandler", {
+  enumerable: true,
+  get: function () { return chunkJLDXUWK7_cjs.generateHandler; }
+});
+Object.defineProperty(exports, "getNetworkByIdHandler", {
+  enumerable: true,
+  get: function () { return chunkJLDXUWK7_cjs.getNetworkByIdHandler; }
+});
+Object.defineProperty(exports, "getNetworksHandler", {
+  enumerable: true,
+  get: function () { return chunkJLDXUWK7_cjs.getNetworksHandler; }
+});
+Object.defineProperty(exports, "streamGenerateHandler", {
+  enumerable: true,
+  get: function () { return chunkJLDXUWK7_cjs.streamGenerateHandler; }
+});

package/dist/server/handlers/network.d.cts

@@ -0,0 +1,4 @@
+export { getNetworksHandler } from '../../_tsup-dts-rollup.cjs';
+export { getNetworkByIdHandler } from '../../_tsup-dts-rollup.cjs';
+export { generateHandler_alias_1 as generateHandler } from '../../_tsup-dts-rollup.cjs';
+export { streamGenerateHandler_alias_1 as streamGenerateHandler } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/network.d.ts

@@ -0,0 +1,4 @@
+export { getNetworksHandler } from '../../_tsup-dts-rollup.js';
+export { getNetworkByIdHandler } from '../../_tsup-dts-rollup.js';
+export { generateHandler_alias_1 as generateHandler } from '../../_tsup-dts-rollup.js';
+export { streamGenerateHandler_alias_1 as streamGenerateHandler } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/network.js

@@ -0,0 +1 @@
+export { generateHandler, getNetworkByIdHandler, getNetworksHandler, streamGenerateHandler } from '../../chunk-YANVFOYA.js';

package/dist/server/handlers/telemetry.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunkCWSDZEZG_cjs = require('../../chunk-CWSDZEZG.cjs');
+
+
+
+Object.defineProperty(exports, "getTelemetryHandler", {
+  enumerable: true,
+  get: function () { return chunkCWSDZEZG_cjs.getTelemetryHandler; }
+});
+Object.defineProperty(exports, "storeTelemetryHandler", {
+  enumerable: true,
+  get: function () { return chunkCWSDZEZG_cjs.storeTelemetryHandler; }
+});

package/dist/server/handlers/telemetry.d.cts

@@ -0,0 +1,2 @@
+export { getTelemetryHandler } from '../../_tsup-dts-rollup.cjs';
+export { storeTelemetryHandler } from '../../_tsup-dts-rollup.cjs';

package/dist/server/handlers/telemetry.d.ts

@@ -0,0 +1,2 @@
+export { getTelemetryHandler } from '../../_tsup-dts-rollup.js';
+export { storeTelemetryHandler } from '../../_tsup-dts-rollup.js';

package/dist/server/handlers/telemetry.js

@@ -0,0 +1 @@
+export { getTelemetryHandler, storeTelemetryHandler } from '../../chunk-DVPP5S6I.js';