@mastra/deployer 0.0.1-alpha.25 → 0.0.1-alpha.27

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/deployer
 
+## 0.0.1-alpha.27
+
+### Patch Changes
+
+- 73d112c: Core and deployer fixes
+- ac8c61a: Mastra server vector operations
+- Updated dependencies [73d112c]
+  - @mastra/core@0.1.27-alpha.82
+
+## 0.0.1-alpha.26
+
+### Patch Changes
+
+- Updated dependencies [9fb3039]
+  - @mastra/core@0.1.27-alpha.81
+
 ## 0.0.1-alpha.25
 
 ### Patch Changes

package/dist/index.js

@@ -318,7 +318,7 @@ async function bundle(entry, {
   const { start } = buildWorkflow.createRun();
   buildWorkflow.__setLogger(noopLogger);
   try {
-    await start({
+    const result = await start({
       triggerData: {
         buildName,
         entry,
@@ -327,8 +327,16 @@ async function bundle(entry, {
         devMode
       }
     });
+    Object.entries(result.results).forEach(([stepName, stepResult]) => {
+      if (stepResult.status !== "success") {
+        logger.error(`${stepName}:`, stepResult);
+        throw new Error(`Step ${stepName} failed`);
+      }
+    });
   } catch (error) {
-    logger.error("Failed to build:", { error });
+    if (error instanceof Error) {
+      logger.error(error.message, { stack: error.stack, message: error.message, name: error.name });
+    }
     process.exit(1);
   }
 }
@@ -632,9 +640,21 @@ var Deployer = class extends MastraBase {
     const dirPath = dir || path2.join(this.projectPath, "src/mastra");
     this.writePackageJson();
     this.writeServerFile();
-    await this.install();
-    await this.build({ dir: dirPath, useBanner });
-    await this.buildServer({ playground, swaggerUI });
+    try {
+      await this.install();
+    } catch (error) {
+      this.logger.error("Failed to install dependencies", { error });
+    }
+    try {
+      await this.build({ dir: dirPath, useBanner });
+    } catch (error) {
+      this.logger.error("Failed to build", { error });
+    }
+    try {
+      await this.buildServer({ playground, swaggerUI });
+    } catch (error) {
+      this.logger.error("Failed to build server", { error });
+    }
   }
 };
 

package/dist/server/index.js

@@ -1,4 +1,4 @@
-// ../../node_modules/.pnpm/@hono+node-server@1.13.7_hono@4.6.17/node_modules/@hono/node-server/dist/index.mjs
+// ../../node_modules/.pnpm/@hono+node-server@1.13.7_hono@4.6.19/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
@@ -443,7 +443,7 @@ var serve = (options, listeningListener) => {
   return server;
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/filepath.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/filepath.js
 var getFilePath = (options) => {
   let filename = options.filename;
   const defaultDocument = options.defaultDocument || "index.html";
@@ -475,7 +475,7 @@ var getFilePathWithoutDefaultDocument = (options) => {
   return path;
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/mime.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/mime.js
 var getMimeType = (filename, mimes = baseMimes) => {
   const regexp = /\.([a-zA-Z0-9]+?)$/;
   const match = filename.match(regexp);
@@ -547,7 +547,7 @@ var _baseMimes = {
 };
 var baseMimes = _baseMimes;
 
-// ../../node_modules/.pnpm/@hono+node-server@1.13.7_hono@4.6.17/node_modules/@hono/node-server/dist/serve-static.mjs
+// ../../node_modules/.pnpm/@hono+node-server@1.13.7_hono@4.6.19/node_modules/@hono/node-server/dist/serve-static.mjs
 import { createReadStream, lstatSync } from "fs";
 var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
 var ENCODINGS = {
@@ -670,7 +670,7 @@ var serveStatic = (options = { root: "" }) => {
   };
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/html.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/html.js
 var HtmlEscapedCallbackPhase = {
   Stringify: 1,
   BeforeStream: 2,
@@ -786,7 +786,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/helper/html/index.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/helper/html/index.js
 var html = (strings, ...values) => {
   const buffer = [""];
   for (let i2 = 0, len = strings.length - 1; i2 < len; i2++) {
@@ -823,7 +823,7 @@ var html = (strings, ...values) => {
   return buffer.length === 1 ? "callbacks" in buffer ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks))) : raw(buffer[0]) : stringBufferToString(buffer, buffer.callbacks);
 };
 
-// ../../node_modules/.pnpm/@hono+swagger-ui@0.5.0_hono@4.6.17/node_modules/@hono/swagger-ui/dist/index.js
+// ../../node_modules/.pnpm/@hono+swagger-ui@0.5.0_hono@4.6.19/node_modules/@hono/swagger-ui/dist/index.js
 var RENDER_TYPE = {
   STRING_ARRAY: "string_array",
   STRING: "string",
@@ -940,7 +940,7 @@ var middleware = (options) => async (c2) => {
   );
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/body.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/body.js
 var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
   const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
@@ -1005,7 +1005,7 @@ var handleParsingNestedValues = (form, key, value) => {
   });
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/url.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/url.js
 var splitPath = (path) => {
   const paths = path.split("/");
   if (paths[0] === "") {
@@ -1219,7 +1219,7 @@ var getQueryParams = (url, key) => {
 };
 var decodeURIComponent_ = decodeURIComponent;
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/request.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/request.js
 var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
   raw;
@@ -1327,7 +1327,7 @@ var HonoRequest = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/context.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/context.js
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setHeaders = (headers, map = {}) => {
   for (const key of Object.keys(map)) {
@@ -1576,7 +1576,7 @@ var Context = class {
   };
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/compose.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/compose.js
 var compose = (middleware2, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
@@ -1625,7 +1625,7 @@ var compose = (middleware2, onError, onNotFound) => {
   };
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router.js
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
 var METHODS = ["get", "post", "put", "delete", "options", "patch"];
@@ -1633,10 +1633,10 @@ var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is
 var UnsupportedPathError = class extends Error {
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/constants.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/constants.js
 var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/hono-base.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/hono-base.js
 var notFoundHandler = (c2) => {
   return c2.text("404 Not Found", 404);
 };
@@ -1861,7 +1861,7 @@ var Hono = class {
   };
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/reg-exp-router/node.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/reg-exp-router/node.js
 var LABEL_REG_EXP_STR = "[^/]+";
 var ONLY_WILDCARD_REG_EXP_STR = ".*";
 var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
@@ -1966,7 +1966,7 @@ var Node = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/reg-exp-router/trie.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/reg-exp-router/trie.js
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
@@ -2022,7 +2022,7 @@ var Trie = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/reg-exp-router/router.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/reg-exp-router/router.js
 var emptyParam = [];
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
@@ -2218,7 +2218,7 @@ var RegExpRouter = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/smart-router/router.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/smart-router/router.js
 var SmartRouter = class {
   name = "SmartRouter";
   #routers = [];
@@ -2273,7 +2273,7 @@ var SmartRouter = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/trie-router/node.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/trie-router/node.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
 var Node2 = class {
   #methods;
@@ -2420,7 +2420,7 @@ var Node2 = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/router/trie-router/router.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/router/trie-router/router.js
 var TrieRouter = class {
   name = "TrieRouter";
   #node;
@@ -2442,7 +2442,7 @@ var TrieRouter = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/hono.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/hono.js
 var Hono2 = class extends Hono {
   constructor(options = {}) {
     super(options);
@@ -2452,7 +2452,7 @@ var Hono2 = class extends Hono {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/http-exception.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/http-exception.js
 var HTTPException = class extends Error {
   res;
   status;
@@ -2475,10 +2475,10 @@ var HTTPException = class extends Error {
   }
 };
 
-// ../../node_modules/.pnpm/hono-openapi@0.4.3_hono@4.6.17_openapi-types@12.1.3_zod@3.24.1/node_modules/hono-openapi/utils.js
+// ../../node_modules/.pnpm/hono-openapi@0.4.3_hono@4.6.19_openapi-types@12.1.3_zod@3.24.1/node_modules/hono-openapi/utils.js
 var e = Symbol("openapi");
 
-// ../../node_modules/.pnpm/hono-openapi@0.4.3_hono@4.6.17_openapi-types@12.1.3_zod@3.24.1/node_modules/hono-openapi/index.js
+// ../../node_modules/.pnpm/hono-openapi@0.4.3_hono@4.6.19_openapi-types@12.1.3_zod@3.24.1/node_modules/hono-openapi/index.js
 function n(n2) {
   const { validateResponse: s2, ...o2 } = n2;
   return Object.assign(async (t, o3) => {
@@ -2577,7 +2577,7 @@ import { join } from "path";
 import { pathToFileURL } from "url";
 import { readFile as readFile2 } from "fs/promises";
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/middleware/cors/index.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/middleware/cors/index.js
 var cors = (options) => {
   const defaults = {
     origin: "*",
@@ -2654,14 +2654,14 @@ var cors = (options) => {
   };
 };
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/utils/color.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/utils/color.js
 function getColorEnabled() {
   const { process: process2, Deno } = globalThis;
   const isNoColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : process2 !== void 0 ? "NO_COLOR" in process2?.env : false;
   return !isNoColor;
 }
 
-// ../../node_modules/.pnpm/hono@4.6.17/node_modules/hono/dist/middleware/logger/index.js
+// ../../node_modules/.pnpm/hono@4.6.19/node_modules/hono/dist/middleware/logger/index.js
 var humanize = (times) => {
   const [delimiter, separator] = [",", "."];
   const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
@@ -9097,6 +9097,104 @@ async function executeAgentToolHandler(c2) {
   }
 }
 
+// src/server/handlers/vector.ts
+var getVector = (c2, vectorName) => {
+  const vector = c2.get("mastra").getVector(vectorName);
+  if (!vector) {
+    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+};
+async function upsertVectors(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, vectors, metadata, ids } = await c2.req.json();
+    if (!indexName || !vectors || !Array.isArray(vectors)) {
+      throw new HTTPException(400, { message: "Invalid request body. indexName and vectors array are required." });
+    }
+    const vector = getVector(c2, vectorName);
+    const result = await vector.upsert(indexName, vectors, metadata, ids);
+    return c2.json({ ids: result });
+  } catch (error) {
+    return handleError(error, "Error upserting vectors");
+  }
+}
+async function createIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, dimension, metric } = await c2.req.json();
+    if (!indexName || typeof dimension !== "number" || dimension <= 0) {
+      throw new HTTPException(400, {
+        message: "Invalid request body. 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(c2, vectorName);
+    await vector.createIndex(indexName, dimension, metric);
+    return c2.json({ success: true });
+  } catch (error) {
+    return handleError(error, "Error creating index");
+  }
+}
+async function queryVectors(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = await c2.req.json();
+    if (!indexName || !queryVector || !Array.isArray(queryVector)) {
+      throw new HTTPException(400, { message: "Invalid request body. indexName and queryVector array are required." });
+    }
+    const vector = getVector(c2, vectorName);
+    const results = await vector.query(indexName, queryVector, topK, filter, includeVector);
+    return c2.json({ results });
+  } catch (error) {
+    return handleError(error, "Error querying vectors");
+  }
+}
+async function listIndexes(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const vector = getVector(c2, vectorName);
+    const indexes = await vector.listIndexes();
+    return c2.json({ indexes: indexes.filter(Boolean) });
+  } catch (error) {
+    return handleError(error, "Error listing indexes");
+  }
+}
+async function describeIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const indexName = c2.req.param("indexName");
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(c2, vectorName);
+    const stats = await vector.describeIndex(indexName);
+    return c2.json({
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase()
+    });
+  } catch (error) {
+    return handleError(error, "Error describing index");
+  }
+}
+async function deleteIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const indexName = c2.req.param("indexName");
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(c2, vectorName);
+    await vector.deleteIndex(indexName);
+    return c2.json({ success: true });
+  } catch (error) {
+    return handleError(error, "Error deleting index");
+  }
+}
+
 // src/server/handlers/workflows.ts
 async function getWorkflowsHandler(c2) {
   try {
@@ -9963,6 +10061,213 @@ async function createHonoServer(mastra, options = {}) {
     }),
     executeToolHandler(tools)
   );
+  app.post(
+    "/api/vector/:vectorName/upsert",
+    n({
+      description: "Upsert vectors into an index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                vectors: {
+                  type: "array",
+                  items: {
+                    type: "array",
+                    items: { type: "number" }
+                  }
+                },
+                metadata: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                ids: {
+                  type: "array",
+                  items: { type: "string" }
+                }
+              },
+              required: ["indexName", "vectors"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Vectors upserted successfully"
+        }
+      }
+    }),
+    upsertVectors
+  );
+  app.post(
+    "/api/vector/:vectorName/create-index",
+    n({
+      description: "Create a new vector index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                dimension: { type: "number" },
+                metric: {
+                  type: "string",
+                  enum: ["cosine", "euclidean", "dotproduct"]
+                }
+              },
+              required: ["indexName", "dimension"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Index created successfully"
+        }
+      }
+    }),
+    createIndex
+  );
+  app.post(
+    "/api/vector/:vectorName/query",
+    n({
+      description: "Query vectors from an index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                queryVector: {
+                  type: "array",
+                  items: { type: "number" }
+                },
+                topK: { type: "number" },
+                filter: { type: "object" },
+                includeVector: { type: "boolean" }
+              },
+              required: ["indexName", "queryVector"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Query results"
+        }
+      }
+    }),
+    queryVectors
+  );
+  app.get(
+    "/api/vector/:vectorName/indexes",
+    n({
+      description: "List all indexes for a vector store",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of indexes"
+        }
+      }
+    }),
+    listIndexes
+  );
+  app.get(
+    "/api/vector/:vectorName/indexes/:indexName",
+    n({
+      description: "Get details about a specific index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "indexName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Index details"
+        }
+      }
+    }),
+    describeIndex
+  );
+  app.delete(
+    "/api/vector/:vectorName/indexes/:indexName",
+    n({
+      description: "Delete a specific index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "indexName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Index deleted successfully"
+        }
+      }
+    }),
+    deleteIndex
+  );
   app.get(
     "/openapi.json",
     r(app, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/deployer",
-  "version": "0.0.1-alpha.25",
+  "version": "0.0.1-alpha.27",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -25,7 +25,7 @@
     "esbuild": "^0.24.2",
     "fs-extra": "^11.2.0",
     "zod": "^3.24.1",
-    "@mastra/core": "0.1.27-alpha.80"
+    "@mastra/core": "0.1.27-alpha.82"
   },
   "devDependencies": {
     "@hono/node-server": "^1.13.7",

package/src/build/bundle.ts

@@ -227,7 +227,7 @@ export async function bundle(
   buildWorkflow.__setLogger(noopLogger as unknown as Logger);
 
   try {
-    await start({
+    const result = await start({
       triggerData: {
         buildName,
         entry,
@@ -236,8 +236,17 @@ export async function bundle(
         devMode,
       },
     });
+
+    Object.entries(result.results).forEach(([stepName, stepResult]) => {
+      if ((stepResult as any).status !== 'success') {
+        logger.error(`${stepName}:`, stepResult);
+        throw new Error(`Step ${stepName} failed`);
+      }
+    });
   } catch (error) {
-    logger.error('Failed to build:', { error });
+    if (error instanceof Error) {
+      logger.error(error.message, { stack: error.stack, message: error.message, name: error.name });
+    }
     process.exit(1);
   }
 }

package/src/deploy/base.ts

@@ -180,8 +180,22 @@ export class Deployer extends MastraBase {
     const dirPath = dir || path.join(this.projectPath, 'src/mastra');
     this.writePackageJson();
     this.writeServerFile();
-    await this.install();
-    await this.build({ dir: dirPath, useBanner });
-    await this.buildServer({ playground, swaggerUI });
+    try {
+      await this.install();
+    } catch (error) {
+      this.logger.error('Failed to install dependencies', { error });
+    }
+
+    try {
+      await this.build({ dir: dirPath, useBanner });
+    } catch (error) {
+      this.logger.error('Failed to build', { error });
+    }
+
+    try {
+      await this.buildServer({ playground, swaggerUI });
+    } catch (error) {
+      this.logger.error('Failed to build server', { error });
+    }
   }
 }

package/src/server/handlers/vector.ts

@@ -0,0 +1,149 @@
+import type { MastraVector, QueryResult, IndexStats } from '@mastra/core';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+
+interface UpsertRequest {
+  indexName: string;
+  vectors: number[][];
+  metadata?: Record<string, any>[];
+  ids?: string[];
+}
+
+interface CreateIndexRequest {
+  indexName: string;
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+
+interface QueryRequest {
+  indexName: string;
+  queryVector: number[];
+  topK?: number;
+  filter?: Record<string, any>;
+  includeVector?: boolean;
+}
+
+export const getVector = (c: Context, vectorName: string): MastraVector => {
+  const vector = c.get('mastra').getVector(vectorName);
+  if (!vector) {
+    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+};
+
+// Upsert vectors
+export async function upsertVectors(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, vectors, metadata, ids } = await c.req.json<UpsertRequest>();
+
+    if (!indexName || !vectors || !Array.isArray(vectors)) {
+      throw new HTTPException(400, { message: 'Invalid request body. indexName and vectors array are required.' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const result = await vector.upsert(indexName, vectors, metadata, ids);
+    return c.json({ ids: result });
+  } catch (error) {
+    return handleError(error, 'Error upserting vectors');
+  }
+}
+
+// Create index
+export async function createIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, dimension, metric } = await c.req.json<CreateIndexRequest>();
+
+    if (!indexName || typeof dimension !== 'number' || dimension <= 0) {
+      throw new HTTPException(400, {
+        message: 'Invalid request body. 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(c, vectorName);
+    await vector.createIndex(indexName, dimension, metric);
+    return c.json({ success: true });
+  } catch (error) {
+    return handleError(error, 'Error creating index');
+  }
+}
+
+// Query vectors
+export async function queryVectors(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = await c.req.json<QueryRequest>();
+
+    if (!indexName || !queryVector || !Array.isArray(queryVector)) {
+      throw new HTTPException(400, { message: 'Invalid request body. indexName and queryVector array are required.' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const results: QueryResult[] = await vector.query(indexName, queryVector, topK, filter, includeVector);
+    return c.json({ results });
+  } catch (error) {
+    return handleError(error, 'Error querying vectors');
+  }
+}
+
+// List indexes
+export async function listIndexes(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const vector = getVector(c, vectorName);
+
+    const indexes = await vector.listIndexes();
+    return c.json({ indexes: indexes.filter(Boolean) });
+  } catch (error) {
+    return handleError(error, 'Error listing indexes');
+  }
+}
+
+// Describe index
+export async function describeIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const indexName = c.req.param('indexName');
+
+    if (!indexName) {
+      throw new HTTPException(400, { message: 'Index name is required' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const stats: IndexStats = await vector.describeIndex(indexName);
+
+    return c.json({
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase(),
+    });
+  } catch (error) {
+    return handleError(error, 'Error describing index');
+  }
+}
+
+// Delete index
+export async function deleteIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const indexName = c.req.param('indexName');
+
+    if (!indexName) {
+      throw new HTTPException(400, { message: 'Index name is required' });
+    }
+
+    const vector = getVector(c, vectorName);
+    await vector.deleteIndex(indexName);
+    return c.json({ success: true });
+  } catch (error) {
+    return handleError(error, 'Error deleting index');
+  }
+}

package/src/server/index.ts

@@ -41,6 +41,14 @@ import {
   getToolResultHandler,
   getToolsHandler,
 } from './handlers/tools.js';
+import {
+  upsertVectors,
+  createIndex,
+  queryVectors,
+  listIndexes,
+  describeIndex,
+  deleteIndex,
+} from './handlers/vector.js';
 import { executeWorkflowHandler, getWorkflowByIdHandler, getWorkflowsHandler } from './handlers/workflows.js';
 import { html } from './welcome.js';
 
@@ -806,6 +814,220 @@ export async function createHonoServer(
     executeToolHandler(tools),
   );
 
+  // Vector routes
+  app.post(
+    '/api/vector/:vectorName/upsert',
+    describeRoute({
+      description: 'Upsert vectors into an index',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                indexName: { type: 'string' },
+                vectors: {
+                  type: 'array',
+                  items: {
+                    type: 'array',
+                    items: { type: 'number' },
+                  },
+                },
+                metadata: {
+                  type: 'array',
+                  items: { type: 'object' },
+                },
+                ids: {
+                  type: 'array',
+                  items: { type: 'string' },
+                },
+              },
+              required: ['indexName', 'vectors'],
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Vectors upserted successfully',
+        },
+      },
+    }),
+    upsertVectors,
+  );
+
+  app.post(
+    '/api/vector/:vectorName/create-index',
+    describeRoute({
+      description: 'Create a new vector index',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                indexName: { type: 'string' },
+                dimension: { type: 'number' },
+                metric: {
+                  type: 'string',
+                  enum: ['cosine', 'euclidean', 'dotproduct'],
+                },
+              },
+              required: ['indexName', 'dimension'],
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Index created successfully',
+        },
+      },
+    }),
+    createIndex,
+  );
+
+  app.post(
+    '/api/vector/:vectorName/query',
+    describeRoute({
+      description: 'Query vectors from an index',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                indexName: { type: 'string' },
+                queryVector: {
+                  type: 'array',
+                  items: { type: 'number' },
+                },
+                topK: { type: 'number' },
+                filter: { type: 'object' },
+                includeVector: { type: 'boolean' },
+              },
+              required: ['indexName', 'queryVector'],
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Query results',
+        },
+      },
+    }),
+    queryVectors,
+  );
+
+  app.get(
+    '/api/vector/:vectorName/indexes',
+    describeRoute({
+      description: 'List all indexes for a vector store',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      responses: {
+        200: {
+          description: 'List of indexes',
+        },
+      },
+    }),
+    listIndexes,
+  );
+
+  app.get(
+    '/api/vector/:vectorName/indexes/:indexName',
+    describeRoute({
+      description: 'Get details about a specific index',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+        {
+          name: 'indexName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      responses: {
+        200: {
+          description: 'Index details',
+        },
+      },
+    }),
+    describeIndex,
+  );
+
+  app.delete(
+    '/api/vector/:vectorName/indexes/:indexName',
+    describeRoute({
+      description: 'Delete a specific index',
+      tags: ['vector'],
+      parameters: [
+        {
+          name: 'vectorName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+        {
+          name: 'indexName',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        },
+      ],
+      responses: {
+        200: {
+          description: 'Index deleted successfully',
+        },
+      },
+    }),
+    deleteIndex,
+  );
+
   app.get(
     '/openapi.json',
     openAPISpecs(app, {

package/src/server/openapi.json

@@ -27,6 +27,24 @@
         "parameters": [{ "name": "agentId", "in": "path", "required": true, "schema": { "type": "string" } }]
       }
     },
+    "/api/agents/{agentId}/evals/ci": {
+      "get": {
+        "responses": { "200": { "description": "List of evals" } },
+        "operationId": "getApiAgentsByAgentIdEvalsCi",
+        "description": "Get CI evals by agent ID",
+        "tags": ["agents"],
+        "parameters": [{ "name": "agentId", "in": "path", "required": true, "schema": { "type": "string" } }]
+      }
+    },
+    "/api/agents/{agentId}/evals/live": {
+      "get": {
+        "responses": { "200": { "description": "List of evals" } },
+        "operationId": "getApiAgentsByAgentIdEvalsLive",
+        "description": "Get live evals by agent ID",
+        "tags": ["agents"],
+        "parameters": [{ "name": "agentId", "in": "path", "required": true, "schema": { "type": "string" } }]
+      }
+    },
     "/api/agents/{agentId}/generate": {
       "post": {
         "responses": { "200": { "description": "Generated response" }, "404": { "description": "Agent not found" } },
@@ -253,21 +271,6 @@
         }
       }
     },
-    "/api/syncs/{syncId}/execute": {
-      "post": {
-        "responses": { "200": { "description": "Sync execution result" }, "404": { "description": "Sync not found" } },
-        "operationId": "postApiSyncsBySyncIdExecute",
-        "description": "Execute a sync",
-        "tags": ["syncs"],
-        "parameters": [{ "name": "syncId", "in": "path", "required": true, "schema": { "type": "string" } }],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": { "schema": { "type": "object", "properties": { "input": { "type": "object" } } } }
-          }
-        }
-      }
-    },
     "/api/logs": {
       "get": {
         "responses": { "200": { "description": "List of all logs" } },
@@ -341,6 +344,115 @@
           }
         }
       }
+    },
+    "/api/vector/{vectorName}/upsert": {
+      "post": {
+        "responses": { "200": { "description": "Vectors upserted successfully" } },
+        "operationId": "postApiVectorByVectorNameUpsert",
+        "description": "Upsert vectors into an index",
+        "tags": ["vector"],
+        "parameters": [{ "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "indexName": { "type": "string" },
+                  "vectors": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } },
+                  "metadata": { "type": "array", "items": { "type": "object" } },
+                  "ids": { "type": "array", "items": { "type": "string" } }
+                },
+                "required": ["indexName", "vectors"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/vector/{vectorName}/create-index": {
+      "post": {
+        "responses": { "200": { "description": "Index created successfully" } },
+        "operationId": "postApiVectorByVectorNameCreate-index",
+        "description": "Create a new vector index",
+        "tags": ["vector"],
+        "parameters": [{ "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "indexName": { "type": "string" },
+                  "dimension": { "type": "number" },
+                  "metric": { "type": "string", "enum": ["cosine", "euclidean", "dotproduct"] }
+                },
+                "required": ["indexName", "dimension"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/vector/{vectorName}/query": {
+      "post": {
+        "responses": { "200": { "description": "Query results" } },
+        "operationId": "postApiVectorByVectorNameQuery",
+        "description": "Query vectors from an index",
+        "tags": ["vector"],
+        "parameters": [{ "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "indexName": { "type": "string" },
+                  "queryVector": { "type": "array", "items": { "type": "number" } },
+                  "topK": { "type": "number" },
+                  "filter": { "type": "object" },
+                  "includeVector": { "type": "boolean" }
+                },
+                "required": ["indexName", "queryVector"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/vector/{vectorName}/indexes": {
+      "get": {
+        "responses": { "200": { "description": "List of indexes" } },
+        "operationId": "getApiVectorByVectorNameIndexes",
+        "description": "List all indexes for a vector store",
+        "tags": ["vector"],
+        "parameters": [{ "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } }]
+      }
+    },
+    "/api/vector/{vectorName}/indexes/{indexName}": {
+      "get": {
+        "responses": { "200": { "description": "Index details" } },
+        "operationId": "getApiVectorByVectorNameIndexesByIndexName",
+        "description": "Get details about a specific index",
+        "tags": ["vector"],
+        "parameters": [
+          { "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } },
+          { "name": "indexName", "in": "path", "required": true, "schema": { "type": "string" } }
+        ]
+      },
+      "delete": {
+        "responses": { "200": { "description": "Index deleted successfully" } },
+        "operationId": "deleteApiVectorByVectorNameIndexesByIndexName",
+        "description": "Delete a specific index",
+        "tags": ["vector"],
+        "parameters": [
+          { "name": "vectorName", "in": "path", "required": true, "schema": { "type": "string" } },
+          { "name": "indexName", "in": "path", "required": true, "schema": { "type": "string" } }
+        ]
+      }
     }
   },
   "components": { "schemas": {} }