@mastra/server 0.0.0-default-storage-virtual-file-20250410035748

package/dist/chunk-4JINXASC.js

@@ -0,0 +1,120 @@
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+
+// src/server/handlers/vector.ts
+var vector_exports = {};
+__export(vector_exports, {
+  createIndex: () => createIndex,
+  deleteIndex: () => deleteIndex,
+  describeIndex: () => describeIndex,
+  listIndexes: () => listIndexes,
+  queryVectors: () => queryVectors,
+  upsertVectors: () => upsertVectors
+});
+function getVector(mastra, vectorName) {
+  if (!vectorName) {
+    throw new HTTPException(400, { message: "Vector name is required" });
+  }
+  const vector = mastra.getVector(vectorName);
+  if (!vector) {
+    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+}
+async function upsertVectors({ mastra, vectorName, index }) {
+  try {
+    if (!index?.indexName || !index?.vectors || !Array.isArray(index.vectors)) {
+      throw new HTTPException(400, { message: "Invalid request index. indexName and vectors array are required." });
+    }
+    const vector = getVector(mastra, vectorName);
+    const result = await vector.upsert(index);
+    return { ids: result };
+  } catch (error) {
+    return handleError(error, "Error upserting vectors");
+  }
+}
+async function createIndex({
+  mastra,
+  vectorName,
+  index
+}) {
+  try {
+    const { indexName, dimension, metric } = index;
+    if (!indexName || typeof dimension !== "number" || dimension <= 0) {
+      throw new HTTPException(400, {
+        message: "Invalid request index, indexName and positive dimension number are required."
+      });
+    }
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
+    }
+    const vector = getVector(mastra, vectorName);
+    await vector.createIndex({ indexName, dimension, metric });
+    return { success: true };
+  } catch (error) {
+    return handleError(error, "Error creating index");
+  }
+}
+async function queryVectors({
+  mastra,
+  vectorName,
+  query
+}) {
+  try {
+    if (!query?.indexName || !query?.queryVector || !Array.isArray(query.queryVector)) {
+      throw new HTTPException(400, { message: "Invalid request query. indexName and queryVector array are required." });
+    }
+    const vector = getVector(mastra, vectorName);
+    const results = await vector.query(query);
+    return results;
+  } catch (error) {
+    return handleError(error, "Error querying vectors");
+  }
+}
+async function listIndexes({ mastra, vectorName }) {
+  try {
+    const vector = getVector(mastra, vectorName);
+    const indexes = await vector.listIndexes();
+    return indexes.filter(Boolean);
+  } catch (error) {
+    return handleError(error, "Error listing indexes");
+  }
+}
+async function describeIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(mastra, vectorName);
+    const stats = await vector.describeIndex(indexName);
+    return {
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase()
+    };
+  } catch (error) {
+    return handleError(error, "Error describing index");
+  }
+}
+async function deleteIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(mastra, vectorName);
+    await vector.deleteIndex(indexName);
+    return { success: true };
+  } catch (error) {
+    return handleError(error, "Error deleting index");
+  }
+}
+
+export { createIndex, deleteIndex, describeIndex, listIndexes, queryVectors, upsertVectors, vector_exports };

package/dist/chunk-5JOF627H.cjs

@@ -0,0 +1,123 @@
+'use strict';
+
+var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/network.ts
+var network_exports = {};
+chunkFV45V6WC_cjs.__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 chunkZLBRQFDD_cjs.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 chunkFV45V6WC_cjs.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 chunkZLBRQFDD_cjs.handleError(error, "Error getting network by ID");
+  }
+}
+async function generateHandler({
+  mastra,
+  networkId,
+  body
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Network not found" });
+    }
+    chunkQN4KF3BH_cjs.validateBody({ messages: body.messages });
+    const { messages, ...rest } = body;
+    const result = await network.generate(messages, rest);
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Network not found" });
+    }
+    chunkQN4KF3BH_cjs.validateBody({ messages: body.messages });
+    const { messages, output, ...rest } = body;
+    const streamResult = await network.stream(messages, {
+      output,
+      ...rest
+    });
+    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 chunkZLBRQFDD_cjs.handleError(error, "Error streaming from network");
+  }
+}
+
+exports.generateHandler = generateHandler;
+exports.getNetworkByIdHandler = getNetworkByIdHandler;
+exports.getNetworksHandler = getNetworksHandler;
+exports.network_exports = network_exports;
+exports.streamGenerateHandler = streamGenerateHandler;

package/dist/chunk-A7DF4ETD.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var stream = require('stream');
+
+// src/server/handlers/voice.ts
+var voice_exports = {};
+chunkFV45V6WC_cjs.__export(voice_exports, {
+  generateSpeechHandler: () => generateSpeechHandler,
+  getSpeakersHandler: () => getSpeakersHandler,
+  transcribeSpeechHandler: () => transcribeSpeechHandler
+});
+async function getSpeakersHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const speakers = await agent.voice.getSpeakers();
+    return speakers;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting speakers");
+  }
+}
+async function generateSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    chunkQN4KF3BH_cjs.validateBody({
+      text: void 0,
+      speakerId: void 0,
+      ...body
+    });
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = await agent.voice.speak(body.text, { speaker: body.speakerId });
+    if (!audioStream) {
+      throw new chunkFV45V6WC_cjs.HTTPException(500, { message: "Failed to generate speech" });
+    }
+    const chunks = [];
+    for await (const chunk of audioStream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const audioData = Buffer.concat(chunks);
+    return { audioData };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error generating speech");
+  }
+}
+async function transcribeSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    if (!body?.audioData) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Audio data is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = new stream.Readable();
+    audioStream.push(body.audioData);
+    audioStream.push(null);
+    const text = await agent.voice.listen(audioStream, body.options);
+    return { text };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error transcribing speech");
+  }
+}
+
+exports.generateSpeechHandler = generateSpeechHandler;
+exports.getSpeakersHandler = getSpeakersHandler;
+exports.transcribeSpeechHandler = transcribeSpeechHandler;
+exports.voice_exports = voice_exports;

package/dist/chunk-BMA2ORRT.js

@@ -0,0 +1,152 @@
+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';
+
+// src/server/handlers/agents.ts
+var agents_exports = {};
+__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 ? stringify(esm_default(_tool.inputSchema)) : void 0,
+          outputSchema: _tool.outputSchema ? stringify(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 handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new 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 ? stringify(esm_default(_tool.inputSchema)) : void 0,
+        outputSchema: _tool.outputSchema ? stringify(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 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 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 handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    validateBody({ messages });
+    const result = await agent.generate(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    validateBody({ messages });
+    const streamResult = await agent.stream(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId
+    });
+    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 HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });
+  }
+}
+
+export { agents_exports, generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler };

package/dist/chunk-CWSDZEZG.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/telemetry.ts
+var telemetry_exports = {};
+chunkFV45V6WC_cjs.__export(telemetry_exports, {
+  getTelemetryHandler: () => getTelemetryHandler,
+  storeTelemetryHandler: () => storeTelemetryHandler
+});
+async function getTelemetryHandler({ mastra, body }) {
+  try {
+    const telemetry = mastra.getTelemetry();
+    const storage = mastra.getStorage();
+    if (!telemetry) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Telemetry is not initialized" });
+    }
+    if (!storage) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Storage is not initialized" });
+    }
+    if (!body) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { name, scope, page, perPage, attribute } = body;
+    const attributes = attribute ? Object.fromEntries(
+      (Array.isArray(attribute) ? attribute : [attribute]).map((attr) => {
+        const [key, value] = attr.split(":");
+        return [key, value];
+      })
+    ) : void 0;
+    const traces = await storage.__getTraces({
+      name,
+      scope,
+      page: Number(page ?? 0),
+      perPage: Number(perPage ?? 100),
+      attributes
+    });
+    return traces;
+  } catch (error2) {
+    return chunkZLBRQFDD_cjs.handleError(error2, "Error getting telemetry");
+  }
+}
+async function storeTelemetryHandler({ mastra, body }) {
+  try {
+    const storage = mastra.getStorage();
+    const logger = mastra.getLogger();
+    if (!storage) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Storage is not initialized" });
+    }
+    const now = /* @__PURE__ */ new Date();
+    const items = body?.resourceSpans?.[0]?.scopeSpans;
+    logger.debug("[Telemetry Handler] Received spans:", {
+      totalSpans: items?.reduce((acc, scope) => acc + scope.spans.length, 0) || 0,
+      timestamp: now.toISOString()
+    });
+    if (!items?.length) {
+      return {
+        status: "success",
+        message: "No spans to process",
+        traceCount: 0
+      };
+    }
+    const allSpans = items.reduce((acc, scopedSpans) => {
+      const { scope, spans } = scopedSpans;
+      for (const span of spans) {
+        const {
+          spanId,
+          parentSpanId,
+          traceId,
+          name,
+          kind,
+          attributes,
+          status,
+          events,
+          links,
+          startTimeUnixNano,
+          endTimeUnixNano,
+          ...rest
+        } = span;
+        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
+        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
+        acc.push({
+          id: spanId,
+          parentSpanId,
+          traceId,
+          name,
+          scope: scope.name,
+          kind,
+          status: JSON.stringify(status),
+          events: JSON.stringify(events),
+          links: JSON.stringify(links),
+          attributes: JSON.stringify(
+            attributes.reduce((acc2, attr) => {
+              const valueKey = Object.keys(attr.value)[0];
+              if (valueKey) {
+                acc2[attr.key] = attr.value[valueKey];
+              }
+              return acc2;
+            }, {})
+          ),
+          startTime,
+          endTime,
+          other: JSON.stringify(rest),
+          createdAt: now
+        });
+      }
+      return acc;
+    }, []);
+    return storage.__batchTraceInsert({
+      records: allSpans
+    }).then(() => {
+      return {
+        status: "success",
+        message: "Traces received and processed successfully",
+        traceCount: body.resourceSpans?.length || 0
+      };
+    }).catch(() => {
+      return {
+        status: "error",
+        message: "Failed to process traces",
+        // @ts-ignore
+        error: error.message
+      };
+    });
+  } catch (error2) {
+    console.error("Error processing traces:", error2);
+    return {
+      status: "error",
+      message: "Failed to process traces",
+      // @ts-ignore
+      error: error2.message
+    };
+  }
+}
+
+exports.getTelemetryHandler = getTelemetryHandler;
+exports.storeTelemetryHandler = storeTelemetryHandler;
+exports.telemetry_exports = telemetry_exports;