@mastra/server 0.0.1-alpha.0

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-FV45V6WC.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/http-exception.ts
+var HTTPException = class extends Error {
+  res;
+  status;
+  /**
+   * Creates an instance of `HTTPException`.
+   * @param status - HTTP status code for the exception. Defaults to 500.
+   * @param options - Additional options for the exception.
+   */
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  /**
+   * Returns the response object associated with the exception.
+   * If a response object is not provided, a new response is created with the error message and status code.
+   * @returns The response object.
+   */
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
+  }
+};
+
+exports.HTTPException = HTTPException;
+exports.__export = __export;

package/dist/chunk-L7XE5QTW.js

@@ -0,0 +1,16 @@
+import { HTTPException } from './chunk-TRDNDNGQ.js';
+
+// src/server/handlers/utils.ts
+function validateBody(body) {
+  const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
+    if (!value) {
+      acc[key] = `Argument "${key}" is required`;
+    }
+    return acc;
+  }, {});
+  if (Object.keys(errorResponse).length > 0) {
+    throw new HTTPException(400, { message: Object.values(errorResponse)[0] });
+  }
+}
+
+export { validateBody };

package/dist/chunk-M56ECCHK.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/vector.ts
+var vector_exports = {};
+chunkFV45V6WC_cjs.__export(vector_exports, {
+  createIndex: () => createIndex,
+  deleteIndex: () => deleteIndex,
+  describeIndex: () => describeIndex,
+  listIndexes: () => listIndexes,
+  queryVectors: () => queryVectors,
+  upsertVectors: () => upsertVectors
+});
+function getVector(mastra, vectorName) {
+  if (!vectorName) {
+    throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Vector name is required" });
+  }
+  const vector = mastra.getVector(vectorName);
+  if (!vector) {
+    throw new chunkFV45V6WC_cjs.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 chunkFV45V6WC_cjs.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 chunkZLBRQFDD_cjs.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 chunkFV45V6WC_cjs.HTTPException(400, {
+        message: "Invalid request index, indexName and positive dimension number are required."
+      });
+    }
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new chunkFV45V6WC_cjs.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 chunkZLBRQFDD_cjs.handleError(error, "Error creating index");
+  }
+}
+async function queryVectors({
+  mastra,
+  vectorName,
+  query
+}) {
+  try {
+    if (!query?.indexName || !query?.queryVector || !Array.isArray(query.queryVector)) {
+      throw new chunkFV45V6WC_cjs.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 chunkZLBRQFDD_cjs.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 chunkZLBRQFDD_cjs.handleError(error, "Error listing indexes");
+  }
+}
+async function describeIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new chunkFV45V6WC_cjs.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 chunkZLBRQFDD_cjs.handleError(error, "Error describing index");
+  }
+}
+async function deleteIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(mastra, vectorName);
+    await vector.deleteIndex(indexName);
+    return { success: true };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error deleting index");
+  }
+}
+
+exports.createIndex = createIndex;
+exports.deleteIndex = deleteIndex;
+exports.describeIndex = describeIndex;
+exports.listIndexes = listIndexes;
+exports.queryVectors = queryVectors;
+exports.upsertVectors = upsertVectors;
+exports.vector_exports = vector_exports;