Mastra server.build config for swaggerUI, openAPIDocs, apiReqLogs

.changeset/soft-ants-slide.md

@@ -0,0 +1,11 @@
+---
+'@mastra/deployer-cloudflare': patch
+'@mastra/deployer-netlify': patch
+'@mastra/deployer': patch
+'@mastra/deployer-vercel': patch
+'@mastra/core': patch
+'mastra': patch
+'create-mastra': patch
+---
+
+Disable swaggerUI, playground for production builds, mastra instance server build config to enable swaggerUI, apiReqLogs, openAPI documentation for prod builds

deployers/cloudflare/src/index.ts

@@ -1,6 +1,5 @@
 import { writeFile } from 'fs/promises';
 import { join } from 'path';
-
 import { Deployer, createChildProcessLogger } from '@mastra/deployer';
 import type { analyzeBundle } from '@mastra/deployer/analyze';
 import virtual from '@rollup/plugin-virtual';
@@ -80,16 +79,63 @@ export class CloudflareDeployer extends Deployer {
 
   private getEntry(): string {
     return `
-import '#polyfills';
-import { mastra } from '#mastra';
-import { createHonoServer } from '#server';
-
-export default {
-  fetch: async (request, env, context) => {
-    const app = await createHonoServer(mastra)
-    return app.fetch(request, env, context);
-  }
-}
+    import '#polyfills';
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
+
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
+
+    if (mastra.getStorage()) {
+      // start storage init in the background
+      mastra.getStorage().init();
+    }
+
+    registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+      const storage = mastra.getStorage();
+      if (storage) {
+        // Check for required fields
+        const logger = mastra?.getLogger();
+        const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+        if (!areFieldsValid) return;
+
+        await storage.insert({
+          tableName: TABLE_EVALS,
+          record: {
+            input: traceObject.input,
+            output: traceObject.output,
+            result: JSON.stringify(traceObject.result || {}),
+            agent_name: traceObject.agentName,
+            metric_name: traceObject.metricName,
+            instructions: traceObject.instructions,
+            test_info: null,
+            global_run_id: traceObject.globalRunId,
+            run_id: traceObject.runId,
+            created_at: new Date().toISOString(),
+          },
+        });
+      }
+    });
+
+    export default {
+      fetch: async (request, env, context) => {
+        const app = await createHonoServer(mastra)
+        return app.fetch(request, env, context);
+      }
+    }
 `;
   }
   async prepare(outputDirectory: string): Promise<void> {

deployers/netlify/src/index.ts

@@ -1,10 +1,8 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-
 import { Deployer } from '@mastra/deployer';
 import { DepsService } from '@mastra/deployer/services';
 import { execa } from 'execa';
-
 import { getOrCreateSite } from './helpers.js';
 
 export class NetlifyDeployer extends Deployer {
@@ -100,13 +98,60 @@ to = "/.netlify/functions/api/:splat"
 
   private getEntry(): string {
     return `
-import { handle } from 'hono/netlify'
-import { mastra } from '#mastra';
-import { createHonoServer } from '#server';
+    import { handle } from 'hono/netlify'
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
+
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
+
+    if (mastra.getStorage()) {
+      // start storage init in the background
+      mastra.getStorage().init();
+    }
+
+    registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+      const storage = mastra.getStorage();
+      if (storage) {
+        // Check for required fields
+        const logger = mastra?.getLogger();
+        const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+        if (!areFieldsValid) return;
+
+        await storage.insert({
+          tableName: TABLE_EVALS,
+          record: {
+            input: traceObject.input,
+            output: traceObject.output,
+            result: JSON.stringify(traceObject.result || {}),
+            agent_name: traceObject.agentName,
+            metric_name: traceObject.metricName,
+            instructions: traceObject.instructions,
+            test_info: null,
+            global_run_id: traceObject.globalRunId,
+            run_id: traceObject.runId,
+            created_at: new Date().toISOString(),
+          },
+        });
+      }
+    });
 
-const app = await createHonoServer(mastra);
+    const app = await createHonoServer(mastra);
 
-export default handle(app)
+    export default handle(app)
 `;
   }
 }

deployers/vercel/src/index.ts

@@ -2,7 +2,6 @@ import * as child_process from 'child_process';
 import { readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import process from 'process';
-
 import { Deployer } from '@mastra/deployer';
 
 interface EnvVar {
@@ -139,6 +138,53 @@ export class VercelDeployer extends Deployer {
 import { handle } from 'hono/vercel'
 import { mastra } from '#mastra';
 import { createHonoServer } from '#server';
+import { evaluate } from '@mastra/core/eval';
+import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+import { TABLE_EVALS } from '@mastra/core/storage';
+import { checkEvalStorageFields } from '@mastra/core/utils';
+
+registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+  evaluate({
+    agentName,
+    input,
+    metric,
+    output,
+    runId,
+    globalRunId: runId,
+    instructions,
+  });
+});
+
+if (mastra.getStorage()) {
+  // start storage init in the background
+  mastra.getStorage().init();
+}
+
+registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+  const storage = mastra.getStorage();
+  if (storage) {
+    // Check for required fields
+    const logger = mastra?.getLogger();
+    const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+    if (!areFieldsValid) return;
+
+    await storage.insert({
+      tableName: TABLE_EVALS,
+      record: {
+        input: traceObject.input,
+        output: traceObject.output,
+        result: JSON.stringify(traceObject.result || {}),
+        agent_name: traceObject.agentName,
+        metric_name: traceObject.metricName,
+        instructions: traceObject.instructions,
+        test_info: null,
+        global_run_id: traceObject.globalRunId,
+        run_id: traceObject.runId,
+        created_at: new Date().toISOString(),
+      },
+    });
+  }
+});
 
 const app = await createHonoServer(mastra);
 

docs/src/components/github-star-count.tsx

@@ -1,4 +1,3 @@
-
 import React from "react";
 
 function formatToK(number: number) {

docs/src/content/en/docs/local-dev/mastra-dev.mdx

@@ -82,6 +82,40 @@ You can then leverage the [Mastra Client](/docs/deployment/client) SDK to intera
 
 `mastra dev` provides an OpenAPI spec at http://localhost:4111/openapi.json
 
+To enable OpenAPI documentation in your Mastra instance, add the following configuration:
+
+```typescript
+import { Mastra } from "@mastra/core";
+
+export const mastra = new Mastra({
+  server: {
+    build: {
+      openAPIDocs: true,  // Enable OpenAPI documentation
+      // ... other build config options
+    }
+  }
+});
+```
+
+## Swagger UI
+
+Swagger UI provides an interactive interface for testing your API endpoints at `mastra dev` provides an OpenAPI spec at http://localhost:4111/swagger-ui. 
+To enable Swagger UI in your Mastra instance, add the following configuration:
+
+```typescript
+import { Mastra } from "@mastra/core";
+
+export const mastra = new Mastra({
+  server: {
+    build: {
+      openAPIDocs: true,  // Enable OpenAPI documentation
+      swaggerUI: true,  // Enable Swagger UI
+      // ... other build config options
+    }
+  }
+});
+```
+
 ## Local Dev Architecture
 
 The local development server is designed to run without any external dependencies or containerization. This is achieved through:

packages/cli/src/commands/build/BuildBundler.ts

@@ -1,9 +1,5 @@
 import { FileService } from '@mastra/deployer/build';
 import { Bundler } from '@mastra/deployer/bundler';
-import * as fsExtra from 'fs-extra';
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 
 export class BuildBundler extends Bundler {
   constructor() {
@@ -29,13 +25,64 @@ export class BuildBundler extends Bundler {
     await super.prepare(outputDirectory);
   }
 
-  bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void> {
+  async bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void> {
     return this._bundle(this.getEntry(), entryFile, outputDirectory, toolsPaths);
   }
 
   protected getEntry(): string {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    return readFileSync(join(__dirname, 'templates', 'dev.entry.js'), 'utf8');
+    return `
+    // @ts-ignore
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
+    import { mastra } from '#mastra';
+    import { createNodeServer } from '#server';
+    // @ts-ignore
+    await createNodeServer(mastra);
+
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
+
+    if (mastra.getStorage()) {
+      // start storage init in the background
+      mastra.getStorage().init();
+    }
+
+    registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+      const storage = mastra.getStorage();
+      if (storage) {
+        // Check for required fields
+        const logger = mastra?.getLogger();
+        const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+        if (!areFieldsValid) return;
+
+        await storage.insert({
+          tableName: TABLE_EVALS,
+          record: {
+            input: traceObject.input,
+            output: traceObject.output,
+            result: JSON.stringify(traceObject.result || {}),
+            agent_name: traceObject.agentName,
+            metric_name: traceObject.metricName,
+            instructions: traceObject.instructions,
+            test_info: null,
+            global_run_id: traceObject.globalRunId,
+            run_id: traceObject.runId,
+            created_at: new Date().toISOString(),
+          },
+        });
+      }
+    });
+    `;
   }
 }

packages/cli/src/index.ts

@@ -169,7 +169,10 @@ program
       command: 'mastra build',
       args,
       execution: async () => {
-        await build({ dir: args.dir, tools: args.tools ? args.tools.split(',') : [] });
+        await build({
+          dir: args.dir,
+          tools: args.tools ? args.tools.split(',') : [],
+        });
       },
       origin,
     });

packages/cli/src/templates/dev.entry.js

@@ -7,7 +7,7 @@ import { checkEvalStorageFields } from '@mastra/core/utils';
 import { mastra } from '#mastra';
 import { createNodeServer } from '#server';
 // @ts-ignore
-await createNodeServer(mastra, { playground: true, swaggerUI: true });
+await createNodeServer(mastra, { playground: true, isDev: true });
 
 registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
   evaluate({