@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/reference/client-js/agents.mdx

@@ -1,220 +0,0 @@
----
-title: Mastra Client Agents API
-description: Learn how to interact with Mastra AI agents, including generating responses, streaming interactions, and managing agent tools using the client-js SDK.
----
-
-# Agents API
-
-The Agents API provides methods to interact with Mastra AI agents, including generating responses, streaming interactions, and managing agent tools.
-
-## Getting All Agents
-
-Retrieve a list of all available agents:
-
-```typescript
-const agents = await mastraClient.getAgents();
-```
-
-## Working with a Specific Agent
-
-Get an instance of a specific agent:
-
-```typescript
-const agent = mastraClient.getAgent("agent-id");
-```
-
-## Agent Methods
-
-### Get Agent Details
-
-Retrieve detailed information about an agent:
-
-```typescript
-const details = await agent.details();
-```
-
-### Generate Response
-
-Generate a response from the agent:
-
-```typescript
-const response = await agent.generate({
-  messages: [
-    {
-      role: "user",
-      content: "Hello, how are you?",
-    },
-  ],
-  threadId: "thread-1", // Optional: Thread ID for conversation context
-  resourceId: "resource-1", // Optional: Resource ID
-  output: {}, // Optional: Output configuration
-});
-```
-
-### Stream Response
-
-Stream responses from the agent for real-time interactions:
-
-```typescript
-const response = await agent.stream({
-  messages: [
-    {
-      role: "user",
-      content: "Tell me a story",
-    },
-  ],
-});
-
-// Process data stream with the processDataStream util
-response.processDataStream({
-  onChunk: async(chunk) => {
-    console.log(chunk);
-  },
-});
-
-
-// You can also read from response body directly
-const reader = response.body.getReader();
-while (true) {
-  const { done, value } = await reader.read();
-  if (done) break;
-  console.log(new TextDecoder().decode(value));
-}
-```
-
-### Client tools
-
-Client-side tools allow you to execute custom functions on the client side when the agent requests them.
-
-#### Basic Usage
-
-```typescript
-import { createTool } from '@mastra/client-js';
-import { z } from 'zod';
-
-const colorChangeTool = createTool({
-  id: 'changeColor',
-  description: 'Changes the background color',
-  inputSchema: z.object({
-    color: z.string(),
-  }),
-  execute: async ({ context }) => {
-    document.body.style.backgroundColor = context.color;
-    return { success: true };
-  }
-})
-
-
-// Use with generate
-const response = await agent.generate({
-  messages: 'Change the background to blue',
-  clientTools: {colorChangeTool},
-});
-
-// Use with stream
-const response = await agent.stream({
-  messages: 'Change the background to green',
-  clientTools: {colorChangeTool},
-});
-
-response.processDataStream({
-  onChunk: async (chunk) => {
-    if (chunk.type === 'text-delta') {
-      console.log(chunk.payload.text);
-    } else if (chunk.type === 'tool-call') {
-      console.log(`calling tool ${chunk.payload.toolName} with args ${JSON.stringify(chunk.payload.args, null, 2)}`);
-    }
-  },
-});
-```
-
-### Get Agent Tool
-
-Retrieve information about a specific tool available to the agent:
-
-```typescript
-const tool = await agent.getTool("tool-id");
-```
-
-### Get Agent Evaluations
-
-Get evaluation results for the agent:
-
-```typescript
-// Get CI evaluations
-const evals = await agent.evals();
-
-// Get live evaluations
-const liveEvals = await agent.liveEvals();
-```
-
-
-### Stream
-
-
-Stream responses using the enhanced API with improved method signatures. This method provides enhanced capabilities and format flexibility, with support for Mastra's native format.
-
-```typescript
-const response = await agent.stream(
-  "Tell me a story",
-  {
-    threadId: "thread-1",
-    clientTools: { colorChangeTool },
-  }
-);
-
-// Process the stream
-response.processDataStream({
-  onChunk: async (chunk) => {
-    if (chunk.type === 'text-delta') {
-      console.log(chunk.payload.text);
-    }
-  },
-});
-```
-
-#### AI SDK compatible format
-
-To stream AI SDK-formatted parts on the client from an `agent.stream(...)` response, wrap `response.processDataStream` into a `ReadableStream<ChunkType>` and use `toAISdkFormat`:
-
-```typescript filename="client-ai-sdk-transform.ts" copy
-import { createUIMessageStream } from 'ai';
-import { toAISdkFormat } from '@mastra/ai-sdk';
-import type { ChunkType, MastraModelOutput } from '@mastra/core/stream';
-
-const response = await agent.stream({ messages: 'Tell me a story' });
-
-const chunkStream: ReadableStream<ChunkType> = new ReadableStream<ChunkType>({
-  start(controller) {
-    response.processDataStream({
-      onChunk: async (chunk) => controller.enqueue(chunk as ChunkType),
-    }).finally(() => controller.close());
-  },
-});
-
-const uiMessageStream = createUIMessageStream({
-  execute: async ({ writer }) => {
-    for await (const part of toAISdkFormat(chunkStream as unknown as MastraModelOutput, { from: 'agent' })) {
-      writer.write(part);
-    }
-  },
-});
-
-for await (const part of uiMessageStream) {
-  console.log(part);
-}
-```
-
-### Generate
-
-Generate a response using the enhanced API with improved method signatures and AI SDK v5 compatibility:
-
-```typescript
-const response = await agent.generate(
-  "Hello, how are you?",
-  {
-    threadId: "thread-1",
-    resourceId: "resource-1",
-  }
-);
-```

package/.docs/raw/reference/client-js/error-handling.mdx

@@ -1,23 +0,0 @@
----
-title: Mastra Client Error Handling
-description: Learn about the built-in retry mechanism and error handling capabilities in the Mastra client-js SDK.
----
-
-# Error Handling
-
-The Mastra Client SDK includes built-in retry mechanism and error handling capabilities.
-
-## Error Handling
-
-All API methods can throw errors that you can catch and handle:
-
-```typescript
-try {
-  const agent = mastraClient.getAgent("agent-id");
-  const response = await agent.generate({
-    messages: [{ role: "user", content: "Hello" }],
-  });
-} catch (error) {
-  console.error("An error occurred:", error.message);
-}
-```

package/.docs/raw/reference/client-js/logs.mdx

@@ -1,29 +0,0 @@
----
-title: Mastra Client Logs API
-description: Learn how to access and query system logs and debugging information in Mastra using the client-js SDK.
----
-
-# Logs API
-
-The Logs API provides methods to access and query system logs and debugging information in Mastra.
-
-## Getting Logs
-
-Retrieve system logs with optional filtering:
-
-```typescript
-const logs = await mastraClient.getLogs({
-  transportId: "transport-1",
-});
-```
-
-## Getting Logs for a Specific Run
-
-Retrieve logs for a specific execution run:
-
-```typescript
-const runLogs = await mastraClient.getLogForRun({
-  runId: "run-1",
-  transportId: "transport-1",
-});
-```

package/.docs/raw/reference/client-js/mastra-client.mdx

@@ -1,157 +0,0 @@
----
-title: MastraClient
-description: Learn how to interact with Mastra using the client-js SDK.
----
-
-# Mastra Client SDK
-
-The Mastra Client SDK provides a simple and type-safe interface for interacting with your [Mastra Server](/docs/deployment/server-deployment.mdx) from your client environment.
-
-## Usage example
-
-```typescript filename="lib/mastra/mastra-client.ts" showLineNumbers copy
-import { MastraClient } from "@mastra/client-js";
-
-export const mastraClient = new MastraClient({
-  baseUrl: "http://localhost:4111/",
-});
-```
-
-## Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "baseUrl",
-      type: "string",
-      description: "The base URL for the Mastra API. All requests will be sent relative to this URL.",
-      isOptional: false,
-    },
-    {
-      name: "retries",
-      type: "number",
-      description: "The number of times a request will be retried on failure before throwing an error.",
-      isOptional: true,
-      defaultValue: "3",
-    },
-    {
-      name: "backoffMs",
-      type: "number",
-      description: "The initial delay in milliseconds before retrying a failed request. This value is doubled with each retry (exponential backoff).",
-      isOptional: true,
-      defaultValue: "300",
-    },
-    {
-      name: "maxBackoffMs",
-      type: "number",
-      description: "The maximum backoff time in milliseconds. Prevents retries from waiting too long between attempts.",
-      isOptional: true,
-      defaultValue: "5000",
-    },
-    {
-      name: "headers",
-      type: "Record<string, string>",
-      description: "An object containing custom HTTP headers to include with every request.",
-      isOptional: true,
-    },
-    {
-      name: "credentials",
-      type: '"omit" | "same-origin" | "include"',
-      description: "Credentials mode for requests. See https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials for more info.",
-      isOptional: true,
-    },
-  ]}
-/>
-
-## Methods
-
-<PropertiesTable
-  content={[
-    {
-      name: "getAgents()",
-      type: "Promise<Record<string, GetAgentResponse>>",
-      description: "Returns all available agent instances.",
-    },
-    {
-      name: "getAgent(agentId)",
-      type: "Agent",
-      description: "Retrieves a specific agent instance by ID.",
-    },
-    {
-      name: "getMemoryThreads(params)",
-      type: "Promise<StorageThreadType[]>",
-      description: "Retrieves memory threads for the specified resource and agent. Requires a `resourceId` and an `agentId`.",
-    },
-    {
-      name: "createMemoryThread(params)",
-      type: "Promise<MemoryThread>",
-      description: "Creates a new memory thread with the given parameters.",
-    },
-    {
-      name: "getMemoryThread(threadId)",
-      type: "Promise<MemoryThread>",
-      description: "Fetches a specific memory thread by ID.",
-    },
-    {
-      name: "saveMessageToMemory(params)",
-      type: "Promise<void>",
-      description: "Saves one or more messages to the memory system.",
-    },
-    {
-      name: "getMemoryStatus()",
-      type: "Promise<MemoryStatus>",
-      description: "Returns the current status of the memory system.",
-    },
-    {
-      name: "getTools()",
-      type: "Record<string, Tool>",
-      description: "Returns all available tools.",
-    },
-    {
-      name: "getTool(toolId)",
-      type: "Tool",
-      description: "Retrieves a specific tool instance by ID.",
-    },
-    {
-      name: "getWorkflows()",
-      type: "Record<string, Workflow>",
-      description: "Returns all available workflow instances.",
-    },
-    {
-      name: "getWorkflow(workflowId)",
-      type: "Workflow",
-      description: "Retrieves a specific workflow instance by ID.",
-    },
-    {
-      name: "getVector(vectorName)",
-      type: "MastraVector",
-      description: "Returns a vector store instance by name.",
-    },
-    {
-      name: "getLogs(params)",
-      type: "Promise<LogEntry[]>",
-      description: "Fetches system logs matching the provided filters.",
-    },
-    {
-      name: "getLog(params)",
-      type: "Promise<LogEntry>",
-      description: "Retrieves a specific log entry by ID or filter.",
-    },
-    {
-      name: "getLogTransports()",
-      type: "string[]",
-      description: "Returns the list of configured log transport types.",
-    },
-    {
-      name: "getAITrace(traceId)",
-      type: "Promise<AITraceRecord>",
-      description: "Retrieves a specific AI trace by ID, including all its spans and details.",
-    },
-    {
-      name: "getAITraces(params)",
-      type: "Promise<GetAITracesResponse>",
-      description: "Retrieves paginated list of AI trace root spans with optional filtering. Use getAITrace() to get complete traces with all spans.",
-    },
-  ]}
-/>
-

package/.docs/raw/reference/client-js/memory.mdx

@@ -1,130 +0,0 @@
----
-title: Mastra Client Memory API
-description: Learn how to manage conversation threads and message history in Mastra using the client-js SDK.
----
-
-# Memory API
-
-The Memory API provides methods to manage conversation threads and message history in Mastra.
-
-### Get All Threads
-
-Retrieve all memory threads for a specific resource:
-
-```typescript
-const threads = await mastraClient.getMemoryThreads({
-  resourceId: "resource-1",
-  agentId: "agent-1",
-});
-```
-
-### Create a New Thread
-
-Create a new memory thread:
-
-```typescript
-const thread = await mastraClient.createMemoryThread({
-  title: "New Conversation",
-  metadata: { category: "support" },
-  resourceId: "resource-1",
-  agentId: "agent-1",
-});
-```
-
-### Working with a Specific Thread
-
-Get an instance of a specific memory thread:
-
-```typescript
-const thread = mastraClient.getMemoryThread("thread-id", "agent-id");
-```
-
-## Thread Methods
-
-### Get Thread Details
-
-Retrieve details about a specific thread:
-
-```typescript
-const details = await thread.get();
-```
-
-### Update Thread
-
-Update thread properties:
-
-```typescript
-const updated = await thread.update({
-  title: "Updated Title",
-  metadata: { status: "resolved" },
-  resourceId: "resource-1",
-});
-```
-
-### Delete Thread
-
-Delete a thread and its messages:
-
-```typescript
-await thread.delete();
-```
-
-## Message Operations
-
-### Save Messages
-
-Save messages to memory:
-
-```typescript
-const savedMessages = await mastraClient.saveMessageToMemory({
-  messages: [
-    {
-      role: "user",
-      content: "Hello!",
-      id: "1",
-      threadId: "thread-1",
-      createdAt: new Date(),
-      type: "text",
-    },
-  ],
-  agentId: "agent-1",
-});
-```
-
-### Retrieve Thread Messages
-
-Get messages associated with a memory thread:
-
-```typescript
-// Get all messages in the thread
-const { messages } = await thread.getMessages();
-
-// Limit the number of messages retrieved
-const { messages } = await thread.getMessages({ limit: 10 });
-```
-
-### Delete a Message
-
-Delete a specific message from a thread:
-
-```typescript
-const result = await thread.deleteMessage("message-id");
-// Returns: { success: true, message: "Message deleted successfully" }
-```
-
-### Delete Multiple Messages
-
-Delete multiple messages from a thread in a single operation:
-
-```typescript
-const result = await thread.deleteMessages(["message-1", "message-2", "message-3"]);
-// Returns: { success: true, message: "3 messages deleted successfully" }
-```
-
-### Get Memory Status
-
-Check the status of the memory system:
-
-```typescript
-const status = await mastraClient.getMemoryStatus("agent-id");
-```

package/.docs/raw/reference/client-js/observability.mdx

@@ -1,76 +0,0 @@
----
-title: Mastra Client Observability API
-description: Learn how to retrieve AI traces, monitor application performance, and score traces using the client-js SDK.
----
-
-# Observability API
-
-The Observability API provides methods to retrieve AI traces, monitor your application's performance, and score traces for evaluation. This helps you understand how your AI agents and workflows are performing.
-
-## Getting a Specific AI Trace
-
-Retrieve a specific AI trace by its ID, including all its spans and details:
-
-```typescript
-const trace = await mastraClient.getAITrace("trace-id-123");
-```
-
-## Getting AI Traces with Filtering
-
-Retrieve a paginated list of AI trace root spans with optional filtering:
-
-```typescript
-const traces = await mastraClient.getAITraces({
-  pagination: {
-    page: 1,
-    perPage: 20,
-    dateRange: {
-      start: new Date('2024-01-01'),
-      end: new Date('2024-01-31')
-    }
-  },
-  filters: {
-    name: "weather-agent", // Filter by trace name
-    spanType: "agent", // Filter by span type
-    entityId: "weather-agent-id", // Filter by entity ID
-    entityType: "agent" // Filter by entity type
-  }
-});
-
-console.log(`Found ${traces.spans.length} root spans`);
-console.log(`Total pages: ${traces.pagination.totalPages}`);
-
-// To get the complete trace with all spans, use getAITrace
-const completeTrace = await mastraClient.getAITrace(traces.spans[0].traceId);
-```
-
-## Scoring Traces
-
-Score specific traces using registered scorers for evaluation:
-
-```typescript
-const result = await mastraClient.score({
-  scorerName: "answer-relevancy",
-  targets: [
-    { traceId: "trace-1", spanId: "span-1" }, // Score specific span
-    { traceId: "trace-2" }, // Score specific span which defaults to the parent span
-  ]
-});
-```
-
-## Getting Scores by Span
-
-Retrieve scores for a specific span within a trace:
-
-```typescript
-const scores = await mastraClient.getScoresBySpan({
-  traceId: "trace-123",
-  spanId: "span-456",
-  page: 1,
-  perPage: 20
-});
-```
-## Related
-
-- [Agents API](./agents) - Learn about agent interactions that generate traces
-- [Workflows API](./workflows) - Understand workflow execution monitoring  

package/.docs/raw/reference/client-js/telemetry.mdx

@@ -1,25 +0,0 @@
----
-title: Mastra Client Telemetry API
-description: Learn how to retrieve and analyze traces from your Mastra application for monitoring and debugging using the client-js SDK.
----
-
-# Telemetry API
-
-The Telemetry API provides methods to retrieve and analyze traces from your Mastra application. This helps you monitor and debug your application's behavior and performance.
-
-## Getting Traces
-
-Retrieve traces with optional filtering and pagination:
-
-```typescript
-const telemetry = await mastraClient.getTelemetry({
-  name: "trace-name", // Optional: Filter by trace name
-  scope: "scope-name", // Optional: Filter by scope
-  page: 1, // Optional: Page number for pagination
-  perPage: 10, // Optional: Number of items per page
-  attribute: {
-    // Optional: Filter by custom attributes
-    key: "value",
-  },
-});
-```

package/.docs/raw/reference/client-js/tools.mdx

@@ -1,49 +0,0 @@
----
-title: Mastra Client Tools API
-description: Learn how to interact with and execute tools available in the Mastra platform using the client-js SDK.
----
-
-# Tools API
-
-The Tools API provides methods to interact with and execute tools available in the Mastra platform.
-
-## Getting All Tools
-
-Retrieve a list of all available tools:
-
-```typescript
-const tools = await mastraClient.getTools();
-```
-
-## Working with a Specific Tool
-
-Get an instance of a specific tool:
-
-```typescript
-const tool = mastraClient.getTool("tool-id");
-```
-
-## Tool Methods
-
-### Get Tool Details
-
-Retrieve detailed information about a tool:
-
-```typescript
-const details = await tool.details();
-```
-
-### Execute Tool
-
-Execute a tool with specific arguments:
-
-```typescript
-const result = await tool.execute({
-  args: {
-    param1: "value1",
-    param2: "value2",
-  },
-  threadId: "thread-1", // Optional: Thread context
-  resourceId: "resource-1", // Optional: Resource identifier
-});
-```