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

package/.docs/raw/agents/using-tools.mdx

@@ -1,95 +0,0 @@
----
-title: "Using Tools | Agents | Mastra Docs"
-description: Learn how to create tools and add them to agents to extend capabilities beyond text generation.
----
-
-# Using Tools
-
-Agents use tools to call APIs, query databases, or run custom functions from your codebase. [Tools](../tools-mcp/overview.mdx) give agents capabilities beyond language generation by providing structured access to data and performing clearly defined operations. You can also load tools from remote [MCP servers](../tools-mcp/mcp-overview.mdx) to expand an agent’s capabilities.
-
-## When to use tools
-
-Use tools when an agent needs additional context or information from remote resources, or when it needs to run code that performs a specific operation. This includes tasks a model can't reliably handle on its own, such as fetching live data or returning consistent, well defined outputs.
-
-## Creating a tool
-
-This example shows how to create a tool that fetches weather data from an API. When the agent calls the tool, it provides the required input as defined by the tool’s `inputSchema`. The tool accesses this data through its `context` argument, which in this example includes the `location` used in the weather API query.
-
-```typescript {14,16} filename="src/mastra/tools/weather-tool.ts" showLineNumbers copy
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-export const weatherTool = createTool({
-  id: "weather-tool",
-  description: "Fetches weather for a location",
-  inputSchema: z.object({
-    location: z.string()
-  }),
-  outputSchema: z.object({
-    weather: z.string()
-  }),
-  execute: async ({ context }) => {
-    const { location } = context;
-
-    const response = await fetch(`https://wttr.in/${location}?format=3`);
-    const weather = await response.text();
-
-    return { weather };
-  }
-});
-```
-
-## Adding tools to an agent
-
-To make a tool available to an agent, add it to the `tools` option and reference it by name in the agent’s instructions.
-
-```typescript {9,11} filename="src/mastra/agents/weather-agent.ts" showLineNumbers copy
-import { openai } from "@ai-sdk/openai";
-import { Agent } from "@mastra/core/agent";
-import { weatherTool } from "../tools/weather-tool";
-
-export const weatherAgent = new Agent({
-  name: "weather-agent",
-  instructions: `
-      You are a helpful weather assistant.
-      Use the weatherTool to fetch current weather data.`,
-  model: openai("gpt-4o-mini"),
-  tools: { weatherTool }
-});
-```
-
-## Calling an agent
-
-The agent uses the tool’s `inputSchema` to infer what data the tool expects. In this case, it extracts `London` as the `location` from the message and makes it available to the tool’s context.
-
-```typescript {5} filename="src/test-tool.ts" showLineNumbers copy
-import { mastra } from "./mastra";
-
-const agent = mastra.getAgent("weatherAgent");
-
-const result = await agent.generate("What's the weather in London?");
-```
-
-## Using multiple tools
-
-An agent can use multiple tools to handle more complex tasks by delegating specific parts to individual tools. The agent decides which tools to use based on the user’s message, the agent’s instructions, and the tool descriptions and schemas.
-
-When multiple tools are available, the agent may choose to use one, several, or none, depending on what’s needed to answer the query.
-
-```typescript {6} filename="src/mastra/agents/weather-agent.ts" showLineNumbers copy
-import { weatherTool } from "../tools/weather-tool";
-import { activitiesTool } from "../tools/activities-tool";
-
-export const weatherAgent = new Agent({
-  // ..
-  tools: { weatherTool, activitiesTool }
-});
-```
-
-
-## Related
-
-- [Tools Overview](../tools-mcp/overview.mdx)
-- [Agent Memory](./agent-memory.mdx)
-- [Runtime Context](../server-db/runtime-context.mdx)
-- [Calling Agents](../../examples/agents/calling-agents.mdx)

package/.docs/raw/auth/auth0.mdx

@@ -1,235 +0,0 @@
----
-title: "MastraAuthAuth0 Class"
-description: "Documentation for the MastraAuthAuth0 class, which authenticates Mastra applications using Auth0 authentication."
----
-
-import { Tabs, Tab } from "@/components/tabs";
-
-# MastraAuthAuth0 Class
-
-The `MastraAuthAuth0` class provides authentication for Mastra using Auth0. It verifies incoming requests using Auth0-issued JWT tokens and integrates with the Mastra server using the `experimental_auth` option.
-
-## Prerequisites
-
-This example uses Auth0 authentication. Make sure to:
-
-1. Create an Auth0 account at [auth0.com](https://auth0.com/)
-2. Set up an Application in your Auth0 Dashboard
-3. Configure an API in your Auth0 Dashboard with an identifier (audience)
-4. Configure your application's allowed callback URLs, web origins, and logout URLs
-
-```env filename=".env" copy
-AUTH0_DOMAIN=your-tenant.auth0.com
-AUTH0_AUDIENCE=your-api-identifier
-```
-
-> **Note:** You can find your domain in the Auth0 Dashboard under Applications > Settings. The audience is the identifier of your API configured in Auth0 Dashboard > APIs.
-
-> For detailed setup instructions, refer to the [Auth0 quickstarts](https://auth0.com/docs/quickstarts) for your specific platform.
-
-## Installation
-
-Before you can use the `MastraAuthAuth0` class you have to install the `@mastra/auth-auth0` package.
-
-```bash copy
-npm install @mastra/auth-auth0@latest
-```
-
-## Usage examples
-
-### Basic usage with environment variables
-
-```typescript {2,7} filename="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core/mastra";
-import { MastraAuthAuth0 } from '@mastra/auth-auth0';
-
-export const mastra = new Mastra({
-  // ..
-  server: {
-    experimental_auth: new MastraAuthAuth0(),
-  },
-});
-```
-
-### Custom configuration
-
-```typescript {2,7-10} filename="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core/mastra";
-import { MastraAuthAuth0 } from '@mastra/auth-auth0';
-
-export const mastra = new Mastra({
-  // ..
-  server: {
-    experimental_auth: new MastraAuthAuth0({
-      domain: process.env.AUTH0_DOMAIN,
-      audience: process.env.AUTH0_AUDIENCE
-    }),
-  },
-});
-```
-
-## Configuration
-
-### User Authorization
-
-By default, `MastraAuthAuth0` allows all authenticated users who have valid Auth0 tokens for the specified audience. The token verification ensures that:
-
-1. The token is properly signed by Auth0
-2. The token is not expired
-3. The token audience matches your configured audience
-4. The token issuer matches your Auth0 domain
-
-To customize user authorization, provide a custom `authorizeUser` function:
-
-```typescript filename="src/mastra/auth.ts" showLineNumbers copy
-import { MastraAuthAuth0 } from '@mastra/auth-auth0';
-
-const auth0Provider = new MastraAuthAuth0({
-  authorizeUser: async (user) => {
-    // Custom authorization logic
-    return user.email?.endsWith('@yourcompany.com') || false;
-  }
-});
-```
-
-> See the [MastraAuthAuth0](/reference/auth/auth0.mdx) API reference for all available configuration options.
-
-## Client-side setup
-
-When using Auth0 auth, you'll need to set up the Auth0 React SDK, authenticate users, and retrieve their access tokens to pass to your Mastra requests.
-
-### Setting up Auth0 React SDK
-
-First, install and configure the Auth0 React SDK in your application:
-
-```bash copy
-npm install @auth0/auth0-react
-```
-
-```typescript filename="src/auth0-provider.tsx" showLineNumbers copy
-import React from 'react';
-import { Auth0Provider } from '@auth0/auth0-react';
-
-const Auth0ProviderWithHistory = ({ children }) => {
-  return (
-    <Auth0Provider
-      domain={process.env.REACT_APP_AUTH0_DOMAIN}
-      clientId={process.env.REACT_APP_AUTH0_CLIENT_ID}
-      authorizationParams={{
-        redirect_uri: window.location.origin,
-        audience: process.env.REACT_APP_AUTH0_AUDIENCE,
-        scope: "read:current_user update:current_user_metadata"
-      }}
-    >
-      {children}
-    </Auth0Provider>
-  );
-};
-
-export default Auth0ProviderWithHistory;
-```
-
-### Retrieving access tokens
-
-Use the Auth0 React SDK to authenticate users and retrieve their access tokens:
-
-```typescript filename="lib/auth.ts" showLineNumbers copy
-import { useAuth0 } from '@auth0/auth0-react';
-
-export const useAuth0Token = () => {
-  const { getAccessTokenSilently } = useAuth0();
-
-  const getAccessToken = async () => {
-    const token = await getAccessTokenSilently();
-    return token;
-  };
-
-  return { getAccessToken };
-};
-```
-
-> Refer to the [Auth0 React SDK documentation](https://auth0.com/docs/libraries/auth0-react) for more authentication methods and configuration options.
-
-## Configuring `MastraClient`
-
-When `experimental_auth` is enabled, all requests made with `MastraClient` must include a valid Auth0 access token in the `Authorization` header:
-
-```typescript filename="lib/mastra/mastra-client.ts" showLineNumbers copy
-import { MastraClient } from "@mastra/client-js";
-
-export const createMastraClient = (accessToken: string) => {
-  return new MastraClient({
-    baseUrl: "https://<mastra-api-url>",
-    headers: {
-      Authorization: `Bearer ${accessToken}`
-    }
-  });
-};
-```
-
-> **Note:** The access token must be prefixed with `Bearer` in the Authorization header.
-
-> See [Mastra Client SDK](/docs/server-db/mastra-client.mdx) for more configuration options.
-
-### Making authenticated requests
-
-Once `MastraClient` is configured with the Auth0 access token, you can send authenticated requests:
-
-<Tabs items={["React Component", "curl"]}>
-  <Tab>
-    ```tsx filename="src/components/mastra-api-test.tsx" showLineNumbers copy
-    import React, { useState } from 'react';
-    import { useAuth0 } from '@auth0/auth0-react';
-    import { MastraClient } from '@mastra/client-js';
-
-    export const MastraApiTest = () => {
-      const { getAccessTokenSilently } = useAuth0();
-      const [result, setResult] = useState(null);
-
-      const callMastraApi = async () => {
-        const token = await getAccessTokenSilently();
-
-        const mastra = new MastraClient({
-          baseUrl: "http://localhost:4111",
-          headers: {
-            Authorization: `Bearer ${token}`
-          }
-        });
-
-        const weatherAgent = mastra.getAgent("weatherAgent");
-        const response = await weatherAgent.generate({
-          messages: "What's the weather like in New York"
-        });
-
-        setResult(response.text);
-      };
-
-      return (
-        <div>
-          <button onClick={callMastraApi}>
-            Test Mastra API
-          </button>
-
-          {result && (
-            <div className="result">
-              <h6>Result:</h6>
-              <pre>{result}</pre>
-            </div>
-          )}
-        </div>
-      );
-    };
-    ```
-  </Tab>
-  <Tab>
-    ```bash copy
-    curl -X POST http://localhost:4111/api/agents/weatherAgent/generate \
-      -H "Content-Type: application/json" \
-      -H "Authorization: Bearer <your-auth0-access-token>" \
-      -d '{
-        "messages": "Weather in London"
-      }'
-    ```
-  </Tab>
-</Tabs>
-

package/.docs/raw/auth/clerk.mdx

@@ -1,142 +0,0 @@
----
-title: "MastraAuthClerk Class"
-description: "Documentation for the MastraAuthClerk class, which authenticates Mastra applications using Clerk authentication."
----
-
-import { Tabs, Tab } from "@/components/tabs";
-
-# MastraAuthClerk Class
-
-The `MastraAuthClerk` class provides authentication for Mastra using Clerk. It verifies incoming requests using Clerk's authentication system and integrates with the Mastra server using the `experimental_auth` option.
-
-## Prerequisites
-
-This example uses Clerk authentication. Make sure to add your Clerk credentials to your `.env` file and ensure your Clerk project is properly configured.
-
-```env filename=".env" copy
-CLERK_PUBLISHABLE_KEY=pk_test_...
-CLERK_SECRET_KEY=sk_test_...
-CLERK_JWKS_URI=https://your-clerk-domain.clerk.accounts.dev/.well-known/jwks.json
-```
-
-> **Note:** You can find these keys in your Clerk Dashboard under "API Keys".
-
-## Installation
-
-Before you can use the `MastraAuthClerk` class you have to install the `@mastra/auth-clerk` package.
-
-```bash copy
-npm install @mastra/auth-clerk@latest
-```
-
-## Usage example
-
-```typescript {2,7-11} filename="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core/mastra";
-import { MastraAuthClerk } from '@mastra/auth-clerk';
-
-export const mastra = new Mastra({
-  // ..
-  server: {
-    experimental_auth: new MastraAuthClerk({
-      publishableKey: process.env.CLERK_PUBLISHABLE_KEY,
-      secretKey: process.env.CLERK_SECRET_KEY,
-      jwksUri: process.env.CLERK_JWKS_URI
-    }),
-  },
-});
-```
-
-> **Note:** The default `authorizeUser` method allows all authenticated users. To customize user authorization, provide a custom `authorizeUser` function when constructing the provider.
-
-> See the [MastraAuthClerk](/reference/auth/clerk.mdx) API reference for all available configuration options.
-
-## Client-side setup
-
-When using Clerk auth, you'll need to retrieve the access token from Clerk on the client side and pass it to your Mastra requests.
-
-### Retrieving the access token
-
-Use the Clerk React hooks to authenticate users and retrieve their access token:
-
-```typescript filename="lib/auth.ts" showLineNumbers copy
-import { useAuth } from "@clerk/nextjs";
-
-export const useClerkAuth = () => {
-  const { getToken } = useAuth();
-  
-  const getAccessToken = async () => {
-    const token = await getToken();
-    return token;
-  };
-  
-  return { getAccessToken };
-};
-```
-
-> Refer to the [Clerk documentation](https://clerk.com/docs) for more information.
-
-## Configuring `MastraClient`
-
-When `experimental_auth` is enabled, all requests made with `MastraClient` must include a valid Clerk access token in the `Authorization` header:
-
-```typescript {6} filename="lib/mastra/mastra-client.ts" showLineNumbers copy
-import { MastraClient } from "@mastra/client-js";
-
-export const mastraClient = new MastraClient({
-  baseUrl: "https://<mastra-api-url>",
-  headers: {
-    Authorization: `Bearer ${accessToken}`
-  }
-});
-```
-
-> **Note:** The access token must be prefixed with `Bearer` in the Authorization header.
-> See [Mastra Client SDK](/docs/server-db/mastra-client.mdx) for more configuration options.
-
-### Making authenticated requests
-
-Once `MastraClient` is configured with the Clerk access token, you can send authenticated requests:
-
-<Tabs items={["MastraClient", "curl"]}>
-  <Tab>
-    ```tsx filename="src/components/test-agent.tsx" showLineNumbers copy
-    "use client";
-
-    import { useAuth } from "@clerk/nextjs";
-    import { MastraClient } from "@mastra/client-js";
-
-    export const TestAgent = () => {
-      const { getToken } = useAuth();
-
-      async function handleClick() {
-        const token = await getToken();
-
-        const client = new MastraClient({
-          baseUrl: "http://localhost:4111",
-          headers: token ? { Authorization: `Bearer ${token}` } : undefined,
-        });
-
-        const weatherAgent = client.getAgent("weatherAgent");
-        const response = await weatherAgent.generate({
-          messages: "What's the weather like in New York",
-        });
-
-        console.log({ response });
-      }
-
-      return <button onClick={handleClick}>Test Agent</button>;
-    };
-    ```
-  </Tab>
-  <Tab>
-    ```bash copy
-    curl -X POST http://localhost:4111/api/agents/weatherAgent/generate \
-      -H "Content-Type: application/json" \
-      -H "Authorization: Bearer <your-clerk-access-token>" \
-      -d '{
-        "messages": "Weather in London"
-      }'
-    ```
-  </Tab>
-</Tabs>