@mastra/mcp-docs-server 1.1.35-alpha.6 → 1.1.35

package/.docs/docs/observability/tracing/exporters/{default.md → mastra-storage.md}

@@ -1,6 +1,8 @@
-# Default exporter
+# Mastra Storage exporter
 
-The `DefaultExporter` persists traces to your configured storage backend, making them accessible through Studio. It's automatically enabled when using the default observability configuration and requires no external services.
+The `MastraStorageExporter` persists traces to your configured storage backend, making them accessible through Studio. It requires no external services.
+
+> **Note:** `MastraStorageExporter` was previously called `DefaultExporter`. The original `DefaultExporter` class is still exported from `@mastra/observability` for backward compatibility, but it is deprecated. New code should use `MastraStorageExporter`.
 
 > **Production Observability:** Observability data can quickly overwhelm general-purpose databases in production. For high-traffic applications, route the observability storage domain to [ClickHouse](https://mastra.ai/reference/storage/clickhouse) through [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](#production-recommendations) for details.
 
@@ -15,7 +17,7 @@ The `DefaultExporter` persists traces to your configured storage backend, making
 
 ```typescript
 import { Mastra } from '@mastra/core'
-import { Observability, DefaultExporter } from '@mastra/observability'
+import { Observability, MastraStorageExporter } from '@mastra/observability'
 import { LibSQLStore } from '@mastra/libsql'
 
 export const mastra = new Mastra({
@@ -27,7 +29,7 @@ export const mastra = new Mastra({
     configs: {
       local: {
         serviceName: 'my-service',
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -36,14 +38,14 @@ export const mastra = new Mastra({
 
 ### Recommended Configuration
 
-Include DefaultExporter in your observability configuration:
+Include MastraStorageExporter in your observability configuration:
 
 ```typescript
 import { Mastra } from '@mastra/core'
 import {
   Observability,
-  DefaultExporter,
-  CloudExporter,
+  MastraStorageExporter,
+  MastraPlatformExporter,
   SensitiveDataFilter,
 } from '@mastra/observability'
 import { LibSQLStore } from '@mastra/libsql'
@@ -58,8 +60,8 @@ export const mastra = new Mastra({
       default: {
         serviceName: 'mastra',
         exporters: [
-          new DefaultExporter(), // Persists traces to storage for Studio
-          new CloudExporter(), // Sends observability data to hosted Mastra Studio (requires MASTRA_CLOUD_ACCESS_TOKEN)
+          new MastraStorageExporter(), // Persists observability events to Mastra Storage
+          new MastraPlatformExporter(), // Sends observability events to Mastra Platform (requires MASTRA_CLOUD_ACCESS_TOKEN)
         ],
         spanOutputProcessors: [new SensitiveDataFilter()],
       },
@@ -79,7 +81,7 @@ Access your traces through Studio:
 
 ## Tracing strategies
 
-DefaultExporter automatically selects the optimal tracing strategy based on your storage provider. You can also override this selection if needed.
+MastraStorageExporter automatically selects the optimal tracing strategy based on your storage provider. You can also override this selection if needed.
 
 ### Available Strategies
 
@@ -92,7 +94,7 @@ DefaultExporter automatically selects the optimal tracing strategy based on your
 ### Strategy Configuration
 
 ```typescript
-new DefaultExporter({
+new MastraStorageExporter({
   strategy: 'auto', // Default - let storage provider decide
   // or explicitly set:
   // strategy: 'realtime' | 'batch-with-updates' | 'insert-only'
@@ -108,7 +110,7 @@ new DefaultExporter({
 
 Different storage providers support different tracing strategies. Some providers support observability for production workloads, while others are intended primarily for local development.
 
-If you set the strategy to `'auto'`, the `DefaultExporter` automatically selects the optimal strategy for the storage provider. If you set the strategy to a mode that the storage provider doesn't support, you will get an error message.
+If you set the strategy to `'auto'`, the `MastraStorageExporter` automatically selects the optimal strategy for the storage provider. If you set an explicit strategy that the storage provider doesn't support, the exporter logs a warning and falls back to the provider's preferred strategy.
 
 ### Providers with Observability Support
 
@@ -167,33 +169,68 @@ For both batch strategies (`batch-with-updates` and `insert-only`), traces are f
 
 ### Error handling
 
-The DefaultExporter includes robust error handling for production use:
+The MastraStorageExporter includes robust error handling for production use:
 
 - **Retry Logic**: Exponential backoff (500ms, 1s, 2s, 4s)
 - **Transient Failures**: Automatic retry with backoff
 - **Persistent Failures**: Drop batch after 4 failed attempts
 - **Buffer Overflow**: Prevent memory issues during storage outages
 
-### Configuration Examples
+## Dropped observability events
+
+`DefaultExporter` emits structured drop events when it cannot persist observability data. Register an exporter or bridge with `onDroppedEvent` to forward these drops to alerting or monitoring.
+
+There are two drop reasons:
+
+- `unsupported-storage`: The storage provider does not implement the signal type.
+- `retry-exhausted`: The exporter retried a batch up to `maxRetries` times and then dropped it.
+
+The following example demonstrates forwarding drop details to a monitoring endpoint:
+
+```typescript
+import { BaseExporter } from '@mastra/observability'
+import type { ObservabilityDropEvent, TracingEvent } from '@mastra/core/observability'
+
+class DropAlertExporter extends BaseExporter {
+  name = 'drop-alerts'
+
+  async onDroppedEvent(event: ObservabilityDropEvent) {
+    await fetch('https://monitoring.example.com/observability-drops', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        count: event.count,
+        signal: event.signal,
+        reason: event.reason,
+        exporterName: event.exporterName,
+      }),
+    })
+  }
+
+  protected async _exportTracingEvent(_event: TracingEvent) {}
+}
+```
+
+## Configuration examples
 
 ```typescript
 // Zero config - recommended for most users
-new DefaultExporter()
+new MastraStorageExporter()
 
 // Development override
-new DefaultExporter({
+new MastraStorageExporter({
   strategy: 'realtime', // Immediate visibility for debugging
 })
 
 // High-throughput production
-new DefaultExporter({
+new MastraStorageExporter({
   maxBatchSize: 2000, // Larger batches
   maxBatchWaitMs: 10000, // Wait longer to fill batches
   maxBufferSize: 50000, // Handle longer outages
 })
 
 // Low-latency production
-new DefaultExporter({
+new MastraStorageExporter({
   maxBatchSize: 100, // Smaller batches
   maxBatchWaitMs: 1000, // Flush quickly
 })
@@ -202,6 +239,6 @@ new DefaultExporter({
 ## Related
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview)
-- [CloudExporter](https://mastra.ai/docs/observability/tracing/exporters/cloud)
+- [MastraPlatformExporter](https://mastra.ai/docs/observability/tracing/exporters/mastra-platform)
 - [Composite Storage](https://mastra.ai/reference/storage/composite): Combine multiple storage providers
 - [Storage Configuration](https://mastra.ai/docs/memory/storage)

package/.docs/docs/observability/tracing/exporters/otel.md

@@ -1,6 +1,6 @@
 # OpenTelemetry exporter
 
-The OpenTelemetry (OTEL) exporter sends your traces to any OTEL-compatible observability platform using standardized [OpenTelemetry Semantic Conventions for GenAI](https://opentelemetry.io/docs/specs/semconv/gen-ai/). This ensures broad compatibility with platforms like Datadog, New Relic, SigNoz, MLflow, Dash0, Traceloop, Laminar, and more.
+The OpenTelemetry (OTEL) exporter sends your traces and logs to any OTEL-compatible observability platform using standardized [OpenTelemetry Semantic Conventions for GenAI](https://opentelemetry.io/docs/specs/semconv/gen-ai/). This ensures broad compatibility with platforms like Datadog, New Relic, SigNoz, MLflow, Dash0, Traceloop, Laminar, and more.
 
 > **Looking for bidirectional OTEL integration?:** If you have existing OpenTelemetry instrumentation and want Mastra traces to inherit context from active OTEL spans, see the [OpenTelemetry Bridge](https://mastra.ai/docs/observability/tracing/bridges/otel) instead.
 
@@ -389,6 +389,77 @@ new OtelExporter({
 })
 ```
 
+## Signals
+
+The exporter sends two OpenTelemetry signals:
+
+- Traces: Mastra spans, exported via `BatchSpanProcessor`.
+- Logs: Mastra log events, exported via `BatchLogRecordProcessor`. Logs that carry `traceId` and `spanId` are correlated with traces using both the OTEL log record's native trace context and `mastra.traceId` / `mastra.spanId` attributes, so backends like Datadog, Grafana, and Honeycomb can join logs to traces automatically.
+
+Both signals are enabled by default and share the same provider configuration. The log endpoint is derived from the trace endpoint by replacing the `/v1/traces` suffix with `/v1/logs`.
+
+To disable a signal, set the `signals` option:
+
+```typescript
+new OtelExporter({
+  provider: {
+    /* ... */
+  },
+  signals: {
+    traces: true, // default
+    logs: false, // disable log export
+  },
+})
+```
+
+Log export requires installing the matching OTLP log exporter package for your protocol:
+
+**npm**:
+
+```bash
+# HTTP/JSON
+npm install @opentelemetry/exporter-logs-otlp-http
+# HTTP/Protobuf
+npm install @opentelemetry/exporter-logs-otlp-proto
+# gRPC
+npm install @opentelemetry/exporter-logs-otlp-grpc @grpc/grpc-js
+```
+
+**pnpm**:
+
+```bash
+# HTTP/JSON
+pnpm add @opentelemetry/exporter-logs-otlp-http
+# HTTP/Protobuf
+pnpm add @opentelemetry/exporter-logs-otlp-proto
+# gRPC
+pnpm add @opentelemetry/exporter-logs-otlp-grpc @grpc/grpc-js
+```
+
+**Yarn**:
+
+```bash
+# HTTP/JSON
+yarn add @opentelemetry/exporter-logs-otlp-http
+# HTTP/Protobuf
+yarn add @opentelemetry/exporter-logs-otlp-proto
+# gRPC
+yarn add @opentelemetry/exporter-logs-otlp-grpc @grpc/grpc-js
+```
+
+**Bun**:
+
+```bash
+# HTTP/JSON
+bun add @opentelemetry/exporter-logs-otlp-http
+# HTTP/Protobuf
+bun add @opentelemetry/exporter-logs-otlp-proto
+# gRPC
+bun add @opentelemetry/exporter-logs-otlp-grpc @grpc/grpc-js
+```
+
+If the matching log exporter package is not installed, log export is silently disabled and traces continue to work.
+
 ## Configuration options
 
 ### Complete Configuration
@@ -400,9 +471,15 @@ new OtelExporter({
     // Use one of: dash0, signoz, newrelic, traceloop, laminar, custom
   },
 
+  // Per-signal toggles. Both default to true.
+  signals: {
+    traces: true,
+    logs: true,
+  },
+
   // Export configuration
   timeout: 30000, // Export timeout in milliseconds
-  batchSize: 100, // Number of spans per batch
+  batchSize: 100, // Number of spans/logs per batch
 
   // Debug options
   logLevel: 'info', // 'debug' | 'info' | 'warn' | 'error'

package/.docs/docs/observability/tracing/overview.md

@@ -18,10 +18,11 @@ Traces are created by:
 
 ```ts
 import { Mastra } from '@mastra/core'
+import { LibSQLStore } from '@mastra/libsql'
 import {
   Observability,
-  DefaultExporter,
-  CloudExporter,
+  MastraStorageExporter,
+  MastraPlatformExporter,
   SensitiveDataFilter,
 } from '@mastra/observability'
 
@@ -31,8 +32,8 @@ export const mastra = new Mastra({
       default: {
         serviceName: 'mastra',
         exporters: [
-          new DefaultExporter(), // Persists traces to storage for Studio
-          new CloudExporter(), // Sends observability data to hosted Mastra Studio (if MASTRA_CLOUD_ACCESS_TOKEN is set)
+          new MastraStorageExporter(), // Persists observability events to Mastra Storage
+          new MastraPlatformExporter(), // Sends observability events to Mastra Platform (if MASTRA_CLOUD_ACCESS_TOKEN is set)
         ],
         spanOutputProcessors: [
           new SensitiveDataFilter(), // Redacts sensitive data like passwords, tokens, keys
@@ -55,8 +56,8 @@ This configuration includes:
 
 - **Exporters**:
 
-  - `DefaultExporter` - Persists traces to your configured storage for Studio
-  - `CloudExporter` - Sends observability data to hosted Mastra Studio (requires `MASTRA_CLOUD_ACCESS_TOKEN`)
+  - `MastraStorageExporter` - Persists observability events to Mastra Storage
+  - `MastraPlatformExporter` - Sends observability events to Mastra Platform (requires `MASTRA_CLOUD_ACCESS_TOKEN`)
 
 - **Span Output Processors**: `SensitiveDataFilter` - Redacts sensitive fields
 
@@ -68,8 +69,8 @@ Exporters determine where your trace data is sent and how it's stored. They inte
 
 Mastra provides two built-in exporters:
 
-- **[Default](https://mastra.ai/docs/observability/tracing/exporters/default)** - Persists traces to local storage for viewing in Studio
-- **[Cloud](https://mastra.ai/docs/observability/tracing/exporters/cloud)** - Sends observability data to hosted Mastra Studio for production monitoring and collaboration
+- **[Mastra Storage](https://mastra.ai/docs/observability/tracing/exporters/mastra-storage)** - Persists observability events to Mastra Storage for viewing in Studio
+- **[Mastra Platform](https://mastra.ai/docs/observability/tracing/exporters/mastra-platform)** - Sends observability events to Mastra Platform for production monitoring and collaboration
 
 ### External Exporters
 
@@ -172,7 +173,7 @@ export const mastra = new Mastra({
           type: 'ratio',
           probability: 0.1,
         },
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -212,7 +213,7 @@ export const mastra = new Mastra({
       debug: {
         serviceName: 'debug-service',
         sampling: { type: 'always' },
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
     configSelector: (context, availableTracers) => {
@@ -249,7 +250,7 @@ export const mastra = new Mastra({
       development: {
         serviceName: 'my-service-dev',
         sampling: { type: 'always' },
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
       staging: {
         serviceName: 'my-service-staging',
@@ -259,7 +260,7 @@ export const mastra = new Mastra({
       production: {
         serviceName: 'my-service-prod',
         sampling: { type: 'ratio', probability: 0.01 },
-        exporters: [cloudExporter, langfuseExporter],
+        exporters: [mastraObserveExporter, langfuseExporter],
       },
     },
     configSelector: (context, availableTracers) => {
@@ -274,13 +275,13 @@ export const mastra = new Mastra({
 
 #### Maintaining Studio access
 
-When adding external exporters, include `DefaultExporter` and `CloudExporter` to maintain access to Studio:
+When adding external exporters, include `MastraStorageExporter` and `MastraPlatformExporter` to maintain access to Studio:
 
 ```ts
 import {
   Observability,
-  DefaultExporter,
-  CloudExporter,
+  MastraStorageExporter,
+  MastraPlatformExporter,
   SensitiveDataFilter,
 } from '@mastra/observability'
 import { ArizeExporter } from '@mastra/arize'
@@ -292,11 +293,11 @@ export const mastra = new Mastra({
         serviceName: 'my-service',
         exporters: [
           new ArizeExporter({
-            endpoint: process.env.PHOENIX_ENDPOINT,
+            endpoint: process.env.PHOENIX_COLLECTOR_ENDPOINT,
             apiKey: process.env.PHOENIX_API_KEY,
           }),
-          new DefaultExporter(), // Keep Studio access
-          new CloudExporter(), // Keep Cloud access
+          new MastraStorageExporter(), // Keep Studio access
+          new MastraPlatformExporter(), // Keep Cloud access
         ],
         spanOutputProcessors: [new SensitiveDataFilter()],
       },
@@ -308,8 +309,8 @@ export const mastra = new Mastra({
 This configuration sends traces to all three destinations simultaneously:
 
 - **Arize Phoenix/AX** for external observability
-- **DefaultExporter** for Studio
-- **CloudExporter** for hosted Studio dashboard
+- **MastraStorageExporter** for Studio
+- **MastraPlatformExporter** for hosted Studio dashboard
 
 > **Info:** Remember: A single trace can be sent to multiple exporters. You don't need separate configs for each exporter unless you want different sampling rates or processors.
 
@@ -352,7 +353,7 @@ export const mastra = new Mastra({
     configs: {
       default: {
         serviceName: 'my-service',
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -378,7 +379,7 @@ export const mastra = new Mastra({
       default: {
         serviceName: 'my-service',
         requestContextKeys: ['userId', 'environment', 'tenantId'],
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -429,7 +430,7 @@ export const mastra = new Mastra({
     configs: {
       default: {
         requestContextKeys: ['user.id', 'session.data.experimentId'],
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -667,7 +668,7 @@ export const mastra = new Mastra({
     configs: {
       development: {
         spanOutputProcessors: [new LowercaseInputProcessor(), new SensitiveDataFilter()],
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -694,7 +695,7 @@ The following example demonstrates how to combine both options in a single confi
 ```ts
 import { Mastra } from '@mastra/core'
 import { SpanType } from '@mastra/core/observability'
-import { Observability, DefaultExporter } from '@mastra/observability'
+import { Observability, MastraStorageExporter } from '@mastra/observability'
 import { LangfuseExporter } from '@mastra/langfuse'
 
 export const mastra = new Mastra({
@@ -702,7 +703,7 @@ export const mastra = new Mastra({
     configs: {
       default: {
         serviceName: 'my-app',
-        exporters: [new DefaultExporter(), new LangfuseExporter()],
+        exporters: [new MastraStorageExporter(), new LangfuseExporter()],
         excludeSpanTypes: [SpanType.MODEL_CHUNK, SpanType.MODEL_STEP],
         spanFilter: span => {
           if (span.type === SpanType.TOOL_CALL && span.attributes?.success) {
@@ -880,7 +881,7 @@ export const mastra = new Mastra({
           maxArrayLength: 100, // Maximum number of items in arrays (default: 50)
           maxObjectKeys: 75, // Maximum number of keys in objects (default: 50)
         },
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),
@@ -1161,8 +1162,8 @@ Mastra automatically creates spans for:
 
 ### Exporters
 
-- [DefaultExporter](https://mastra.ai/reference/observability/tracing/exporters/default-exporter): Storage persistence
-- [CloudExporter](https://mastra.ai/reference/observability/tracing/exporters/cloud-exporter): Mastra platform integration
+- [MastraStorageExporter](https://mastra.ai/reference/observability/tracing/exporters/mastra-storage-exporter): Storage persistence
+- [MastraPlatformExporter](https://mastra.ai/reference/observability/tracing/exporters/mastra-platform-exporter): Mastra platform integration
 - [ConsoleExporter](https://mastra.ai/reference/observability/tracing/exporters/console-exporter): Debug output
 - [Arize](https://mastra.ai/reference/observability/tracing/exporters/arize): Arize Phoenix and Arize AX integration
 - [Braintrust](https://mastra.ai/reference/observability/tracing/exporters/braintrust): Braintrust integration

package/.docs/docs/observability/tracing/processors/sensitive-data-filter.md

@@ -9,8 +9,8 @@ The Sensitive Data Filter is included in the recommended observability configura
 ```ts
 import {
   Observability,
-  DefaultExporter,
-  CloudExporter,
+  MastraStorageExporter,
+  MastraPlatformExporter,
   SensitiveDataFilter,
 } from '@mastra/observability'
 
@@ -19,7 +19,7 @@ export const mastra = new Mastra({
     configs: {
       default: {
         serviceName: 'mastra',
-        exporters: [new DefaultExporter(), new CloudExporter()],
+        exporters: [new MastraStorageExporter(), new MastraPlatformExporter()],
         spanOutputProcessors: [
           new SensitiveDataFilter(), // Redacts sensitive fields before export
         ],
@@ -70,14 +70,14 @@ When a sensitive field is detected, its value is replaced with `[REDACTED]` by d
 You can customize which fields are redacted and how redaction displays:
 
 ```ts
-import { SensitiveDataFilter, DefaultExporter, Observability } from '@mastra/observability'
+import { SensitiveDataFilter, MastraStorageExporter, Observability } from '@mastra/observability'
 
 export const mastra = new Mastra({
   observability: new Observability({
     configs: {
       production: {
         serviceName: 'my-service',
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
         spanOutputProcessors: [
           new SensitiveDataFilter({
             // Add custom sensitive fields
@@ -226,7 +226,7 @@ export const mastra = new Mastra({
       debug: {
         serviceName: 'debug-service',
         spanOutputProcessors: [], // No processors, including no SensitiveDataFilter
-        exporters: [new DefaultExporter()],
+        exporters: [new MastraStorageExporter()],
       },
     },
   }),

package/.docs/docs/server/mastra-server.md

@@ -4,17 +4,15 @@ Mastra runs as an HTTP server that exposes your agents, workflows, and other fun
 
 > **Info:** This page covers the [`server`](https://mastra.ai/reference/configuration) configuration options passed to the `Mastra` constructor. For running Mastra with your own HTTP server (Hono, Express, etc.), visit [Server Adapters](https://mastra.ai/docs/server/server-adapters).
 
-## Server architecture
-
-Mastra uses [Hono](https://hono.dev) as its underlying HTTP server framework. When you build a Mastra application using `mastra build`, it generates a Hono-based HTTP server in the `.mastra` directory.
-
-The server provides:
+## Server features
 
-- API endpoints for all registered agents and workflows
-- Custom API routes and middleware
-- Authentication across providers
-- Request context for dynamic configuration
-- Stream data redaction for secure responses
+- **[Middleware](https://mastra.ai/docs/server/middleware)**: Intercept requests for authentication, logging, CORS, or injecting request-specific context.
+- **[Custom API Routes](https://mastra.ai/docs/server/custom-api-routes)**: Extend the server with your own HTTP endpoints that have access to the Mastra instance.
+- **[Request Context](https://mastra.ai/docs/server/request-context)**: Pass request-specific values to agents, tools, and workflows based on runtime conditions.
+- **[Server Adapters](https://mastra.ai/docs/server/server-adapters)**: Run Mastra with Express, Hono, or your own HTTP server instead of the generated server.
+- **[Custom Adapters](https://mastra.ai/docs/server/custom-adapters)**: Build adapters for frameworks not officially supported.
+- **[Mastra Client SDK](https://mastra.ai/docs/server/mastra-client)**: Type-safe client for calling agents, workflows, and tools from browser or server environments.
+- **[Authentication](https://mastra.ai/docs/server/auth)**: Secure endpoints with JWT, Clerk, Supabase, Firebase, Auth0, or WorkOS.
 
 ## Configuration
 
@@ -33,15 +31,21 @@ export const mastra = new Mastra({
 
 > **Info:** Visit the [configuration reference](https://mastra.ai/reference/configuration) for a full list of available server options.
 
-## Server features
+## Deploy your server
 
-- **[Middleware](https://mastra.ai/docs/server/middleware)**: Intercept requests for authentication, logging, CORS, or injecting request-specific context.
-- **[Custom API Routes](https://mastra.ai/docs/server/custom-api-routes)**: Extend the server with your own HTTP endpoints that have access to the Mastra instance.
-- **[Request Context](https://mastra.ai/docs/server/request-context)**: Pass request-specific values to agents, tools, and workflows based on runtime conditions.
-- **[Server Adapters](https://mastra.ai/docs/server/server-adapters)**: Run Mastra with Express, Hono, or your own HTTP server instead of the generated server.
-- **[Custom Adapters](https://mastra.ai/docs/server/custom-adapters)**: Build adapters for frameworks not officially supported.
-- **[Mastra Client SDK](https://mastra.ai/docs/server/mastra-client)**: Type-safe client for calling agents, workflows, and tools from browser or server environments.
-- **[Authentication](https://mastra.ai/docs/server/auth)**: Secure endpoints with JWT, Clerk, Supabase, Firebase, Auth0, or WorkOS.
+Mastra servers can be deployed to any Node.js-compatible environment. Deploy it to production using the [Mastra platform](https://mastra.ai/docs/mastra-platform/overview) or your own infastructure. Visit the [deployment docs](https://mastra.ai/docs/deployment/overview) to learn how.
+
+## Server architecture
+
+Mastra uses [Hono](https://hono.dev) as its underlying HTTP server framework. When you build a Mastra application using `mastra build`, it generates a Hono-based HTTP server in the `.mastra` directory.
+
+The server provides:
+
+- API endpoints for all registered agents and workflows
+- Custom API routes and middleware
+- Authentication across providers
+- Request context for dynamic configuration
+- Stream data redaction for secure responses
 
 ## REST API
 
@@ -88,4 +92,11 @@ Mastra requires `module` and `moduleResolution` settings compatible with modern
   },
   "include": ["src/**/*"]
 }
-```
+```
+
+## Next steps
+
+- Add [middleware](https://mastra.ai/docs/server/middleware)
+- Create [custom API routes](https://mastra.ai/docs/server/custom-api-routes)
+- Add [authentication](https://mastra.ai/docs/server/auth)
+- [Deploy](https://mastra.ai/docs/deployment/overview) your server to production

package/.docs/docs/studio/observability.md

@@ -65,8 +65,8 @@ import { DuckDBStore } from '@mastra/duckdb'
 import { MastraCompositeStore } from '@mastra/core/storage'
 import {
   Observability,
-  DefaultExporter,
-  CloudExporter,
+  MastraStorageExporter,
+  MastraPlatformExporter,
   SensitiveDataFilter,
 } from '@mastra/observability'
 
@@ -86,8 +86,8 @@ export const mastra = new Mastra({
       default: {
         serviceName: 'mastra',
         exporters: [
-          new DefaultExporter(), // Persists traces to storage for Mastra Studio
-          new CloudExporter(), // Sends observability data to hosted Mastra Studio (if MASTRA_CLOUD_ACCESS_TOKEN is set)
+          new MastraStorageExporter(), // Persists observability events to Mastra Storage
+          new MastraPlatformExporter(), // Sends observability events to Mastra Platform (if MASTRA_CLOUD_ACCESS_TOKEN is set)
         ],
         spanOutputProcessors: [
           new SensitiveDataFilter(), // Redacts sensitive data like passwords, tokens, keys

package/.docs/docs/studio/overview.md

@@ -39,6 +39,10 @@ Once the server is running, you can:
 
 While Studio is running, you can edit your [agents](https://mastra.ai/docs/agents/overview), [workflows](https://mastra.ai/docs/workflows/overview), and other parts of your Mastra application in real time.
 
+## Deploy Studio
+
+When you're ready to share Studio with your team, you can deploy it to production using the [Mastra platform](https://mastra.ai/docs/mastra-platform/overview) or your own infrastructure. Visit the [deployment docs](https://mastra.ai/docs/studio/deployment) to learn how.
+
 ## Primitives
 
 ### Agents
@@ -47,6 +51,8 @@ Chat with your agent directly, dynamically switch [models](https://mastra.ai/mod
 
 When you interact with your agent, you can follow each step of its reasoning, view tool call outputs, and [observe](#observability) traces and logs to see how responses are generated. You can also attach [scorers](#scorers) to measure and compare response quality over time.
 
+While an agent response is streaming, you can send a follow-up message in the same thread. Studio shows the message as pending until the stream confirms it, then continues the response below that follow-up. Other Studio tabs that have the same thread open can observe the active stream.
+
 Use [Editor](https://mastra.ai/docs/editor/overview) to let non-technical team members iterate on agents, version every change, and run experiments without redeploying.
 
 ### Workflows