@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/.docs/reference/agents/generateLegacy.md

@@ -0,0 +1,225 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.generateLegacy() (Legacy)
+
+> **Warning:** **Deprecated**: This method is deprecated and only works with legacy model adapters. For current model adapters, use [`.generate()`](https://mastra.ai/reference/agents/generate) instead.
+
+The `.generateLegacy()` method is the legacy version of the agent generation API, used with legacy model adapters to produce text or structured responses. This method accepts messages and optional generation options.
+
+## Usage example
+
+```typescript
+await agent.generateLegacy('message for agent')
+```
+
+## Processor retry support
+
+`generateLegacy()` doesn't run error processors or `maxProcessorRetries`. It uses the legacy AI SDK generation path instead.
+
+Scorer judges with legacy model adapters call `generateLegacy()`. They don't receive the coordinated `StreamErrorRetryProcessor` budget available to scorer judges that use Mastra’s current generation API. Use a current model adapter when you need error-processor retries. The legacy `maxRetries` option remains separate and defaults to `2`.
+
+## Parameters
+
+**messages** (`string | string[] | CoreMessage[] | AiMessageType[] | UIMessageWithMetadata[]`): The messages to send to the agent. Can be a single string, array of strings, or structured message objects with multimodal content (text, images, etc.).
+
+**options** (`AgentGenerateOptions`): Optional configuration for the generation process.
+
+**options.abortSignal** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated.
+
+**options.context** (`CoreMessage[]`): Additional context messages to provide to the agent.
+
+**options.structuredOutput** (`StructuredOutputOptions<S extends ZodTypeAny = ZodTypeAny>`): Enables structured output generation with better developer experience. Automatically creates and uses a StructuredOutputProcessor internally.
+
+**options.structuredOutput.schema** (`z.ZodSchema<S>`): Zod schema to validate the output against.
+
+**options.structuredOutput.model** (`MastraLanguageModel`): Model to use for the internal structuring agent.
+
+**options.structuredOutput.errorStrategy** (`'strict' | 'warn' | 'fallback'`): Strategy when parsing or validation fails. Defaults to 'strict'.
+
+**options.structuredOutput.fallbackValue** (`<S extends ZodTypeAny>`): Fallback value when errorStrategy is 'fallback'.
+
+**options.structuredOutput.instructions** (`string`): Custom instructions for the structuring agent.
+
+**options.outputProcessors** (`Processor[]`): Overrides the output processors set on the agent. Output processors that can modify or validate messages from the agent before they are returned to the user. Must implement either (or both) of the processOutputResult and processOutputStream functions.
+
+**options.inputProcessors** (`Processor[]`): Overrides the input processors set on the agent. Input processors that can modify or validate messages before they are processed by the agent. Must implement the processInput function.
+
+**options.experimental\_output** (`Zod schema | JsonSchema7`): Note, the preferred route is to use the structuredOutput property. Enables structured output generation alongside text generation and tool calls. The model will generate responses that conform to the provided schema.
+
+**options.instructions** (`string`): Custom instructions that override the agent's default instructions for this specific generation. Useful for dynamically modifying agent behavior without creating a new agent instance.
+
+**options.output** (`Zod schema | JsonSchema7`): Defines the expected structure of the output. Can be a JSON Schema object or a Zod schema.
+
+**options.memory** (`object`): Configuration for memory. This is the preferred way to manage memory.
+
+**options.memory.thread** (`string | { id: string; metadata?: Record<string, any>, title?: string }`): The conversation thread, as a string ID or an object with an id and optional metadata.
+
+**options.memory.resource** (`string`): Identifier for the user or resource associated with the thread.
+
+**options.memory.options** (`MemoryConfig`): Configuration for memory behavior, like message history and semantic recall. See MemoryConfig below.
+
+**options.maxSteps** (`number`): Maximum number of execution steps allowed.
+
+**options.maxRetries** (`number`): Maximum number of retries. Set to 0 to disable retries.
+
+**options.onStepFinish** (`GenerateTextOnStepFinishCallback<any> | never`): Callback function called after each execution step. Receives step details as a JSON string. Unavailable for structured output
+
+**options.runId** (`string`): Unique ID for this generation run. Useful for tracking and debugging purposes.
+
+**options.telemetry** (`TelemetrySettings`): Settings for telemetry collection during generation.
+
+**options.telemetry.isEnabled** (`boolean`): Enable or disable telemetry. Disabled by default while experimental.
+
+**options.telemetry.recordInputs** (`boolean`): Enable or disable input recording. Enabled by default. You might want to disable input recording to avoid recording sensitive information.
+
+**options.telemetry.recordOutputs** (`boolean`): Enable or disable output recording. Enabled by default. You might want to disable output recording to avoid recording sensitive information.
+
+**options.telemetry.functionId** (`string`): Identifier for this function. Used to group telemetry data by function.
+
+**options.temperature** (`number`): Controls randomness in the model's output. Higher values (e.g., 0.8) make the output more random, lower values (e.g., 0.2) make it more focused and deterministic.
+
+**options.toolChoice** (`'auto' | 'none' | 'required' | { type: 'tool'; toolName: string }`): Controls how the agent uses tools during generation.
+
+**options.toolChoice.'auto'** (`string`): Let the model decide whether to use tools (default).
+
+**options.toolChoice.'none'** (`string`): Do not use any tools.
+
+**options.toolChoice.'required'** (`string`): Require the model to use at least one tool.
+
+**options.toolChoice.{ type: 'tool'; toolName: string }** (`object`): Require the model to use a specific tool by name.
+
+**options.toolsets** (`ToolsetsInput`): Additional toolsets to make available to the agent during generation.
+
+**options.clientTools** (`ToolsInput`): Tools that are executed on the 'client' side of the request. These tools do not have execute functions in the definition.
+
+**options.hooks** (`ToolHooks`): Per-execution hooks that run before and after tool calls. Overrides matching agent-level hooks for this execution. beforeToolCall can return { proceed: false, output } to skip the tool call.
+
+**options.savePerStep** (`boolean`): Save messages incrementally after each generation step completes (default: false). Disabled internally when observational memory is enabled.
+
+**options.providerOptions** (`Record<string, Record<string, JSONValue>>`): Additional provider-specific options that are passed through to the underlying LLM provider. The structure is { providerName: { optionKey: value } }. Since Mastra extends AI SDK, see the AI SDK documentation for complete provider options.
+
+**options.providerOptions.openai** (`Record<string, JSONValue>`): OpenAI-specific options. Example: { reasoningEffort: 'high' }
+
+**options.providerOptions.anthropic** (`Record<string, JSONValue>`): Anthropic-specific options. Example: { maxTokens: 1000 }
+
+**options.providerOptions.google** (`Record<string, JSONValue>`): Google-specific options. Example: { safetySettings: \[...] }
+
+**options.providerOptions.\[providerName]** (`Record<string, JSONValue>`): Other provider-specific options. The key is the provider name and the value is a record of provider-specific options.
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+**options.maxTokens** (`number`): Maximum number of tokens to generate.
+
+**options.topP** (`number`): Nucleus sampling. This is a number between 0 and 1. It is recommended to set either temperature or topP, but not both.
+
+**options.topK** (`number`): Only sample from the top K options for each subsequent token. Used to remove 'long tail' low probability responses.
+
+**options.presencePenalty** (`number`): Presence penalty setting. It affects the likelihood of the model to repeat information that is already in the prompt. A number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+
+**options.frequencyPenalty** (`number`): Frequency penalty setting. It affects the likelihood of the model to repeatedly use the same words or phrases. A number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+
+**options.stopSequences** (`string[]`): Stop sequences. If set, the model will stop generating text when one of the stop sequences is generated.
+
+**options.seed** (`number`): The seed (integer) to use for random sampling. If set and supported by the model, calls will generate deterministic results.
+
+**options.headers** (`Record<string, string | undefined>`): Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+## Returns
+
+**text** (`string`): The generated text response. Present when output is 'text' (no schema provided).
+
+**object** (`object`): The generated structured response. Present when a schema is provided via output, structuredOutput, or experimental\_output.
+
+**toolCalls** (`Array<ToolCall>`): The tool calls made during the generation process. Present in both text and object modes.
+
+**toolCalls.toolName** (`string`): The name of the tool invoked.
+
+**toolCalls.args** (`any`): The arguments passed to the tool.
+
+## Migration to new API
+
+> **Info:** The new `.generate()` method offers enhanced capabilities including AI SDK v5+ compatibility, better structured output handling, and improved streaming support. See the [migration guide](https://mastra.ai/guides/migrations/vnext-to-standard-apis) for detailed migration instructions.
+
+### Quick Migration Example
+
+#### Before (Legacy)
+
+```typescript
+const result = await agent.generateLegacy('message', {
+  temperature: 0.7,
+  maxSteps: 3,
+})
+```
+
+#### After (New API)
+
+```typescript
+const result = await agent.generate('message', {
+  modelSettings: {
+    temperature: 0.7,
+  },
+  maxSteps: 3,
+})
+```
+
+## Extended usage example
+
+```typescript
+import { z } from 'zod'
+import { ModerationProcessor, TokenLimiterProcessor } from '@mastra/core/processors'
+
+await agent.generateLegacy(
+  [
+    { role: 'user', content: 'message for agent' },
+    {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text: 'message for agent',
+        },
+        {
+          type: 'image',
+          imageUrl: 'https://example.com/image.jpg',
+          mimeType: 'image/jpeg',
+        },
+      ],
+    },
+  ],
+  {
+    temperature: 0.7,
+    maxSteps: 3,
+    memory: {
+      thread: 'user-123',
+      resource: 'test-app',
+    },
+    toolChoice: 'auto',
+    providerOptions: {
+      openai: {
+        reasoningEffort: 'high',
+      },
+    },
+    // Structured output with better DX
+    structuredOutput: {
+      schema: z.object({
+        sentiment: z.enum(['positive', 'negative', 'neutral']),
+        confidence: z.number(),
+      }),
+      model: 'openai/gpt-5.6-sol',
+      errorStrategy: 'warn',
+    },
+    // Output processors for response validation
+    outputProcessors: [
+      new ModerationProcessor({ model: 'openai/gpt-5-mini' }),
+      new TokenLimiterProcessor({ maxTokens: 1000 }),
+    ],
+  },
+)
+```
+
+## Related
+
+- [Migration Guide](https://mastra.ai/guides/migrations/vnext-to-standard-apis)
+- [New .generate() method](https://mastra.ai/reference/agents/generate)
+- [Generating responses](https://mastra.ai/docs/agents/overview)
+- [Streaming responses](https://mastra.ai/docs/agents/overview)

package/.docs/reference/agents/getDefaultGenerateOptions.md

@@ -0,0 +1,36 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getDefaultGenerateOptionsLegacy()
+
+> **Warning:** **Deprecated**: This method is deprecated and only works with V1 models. For V2 models, use the new [`.getDefaultOptions()`](https://mastra.ai/reference/agents/getDefaultOptions) method instead.
+
+Agents can be configured with default generation options for controlling model behavior, output formatting and tool and workflow calls. The `.getDefaultGenerateOptionsLegacy()` method retrieves these defaults, resolving them if they're functions. These options apply to all `generateLegacy()` calls unless overridden and are useful for inspecting an agent’s unknown defaults.
+
+## Usage example
+
+```typescript
+await agent.getDefaultGenerateOptionsLegacy()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**defaultOptions** (`AgentGenerateOptions | Promise<AgentGenerateOptions>`): The default generation options configured for the agent, either as a direct object or a promise that resolves to the options.
+
+## Extended usage example
+
+```typescript
+await agent.getDefaultGenerateOptionsLegacy({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Agent generation](https://mastra.ai/docs/agents/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getDefaultOptions.md

@@ -0,0 +1,34 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getDefaultOptions()
+
+Agents can be configured with default options for memory usage and output format. Iteration steps can also be configured. The `.getDefaultOptions()` method returns these defaults, resolving them if they're functions. These options apply to all `stream()` and `generate()` calls unless overridden and are useful for inspecting an agent’s unknown defaults.
+
+## Usage example
+
+```typescript
+await agent.getDefaultOptions()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**defaultOptions** (`AgentExecutionOptions<Output> | Promise<AgentExecutionOptions<Output>>`): The default streaming options configured for the agent, either as a direct object or a promise that resolves to the options.
+
+## Extended usage example
+
+```typescript
+await agent.getDefaultOptions({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Streaming with agents](https://mastra.ai/guides/concepts/streaming)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getDefaultStreamOptions.md

@@ -0,0 +1,36 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getDefaultStreamOptionsLegacy()
+
+> **Warning:** **Deprecated**: This method is deprecated and only works with V1 models. For V2 models, use the new [`.getDefaultOptions()`](https://mastra.ai/reference/agents/getDefaultOptions) method instead.
+
+Agents can be configured with default streaming options for memory usage and output format. Iteration steps can also be configured. The `.getDefaultStreamOptionsLegacy()` method returns these defaults, resolving them if they're functions. These options apply to all `streamLegacy()` calls unless overridden and are useful for inspecting an agent’s unknown defaults.
+
+## Usage example
+
+```typescript
+await agent.getDefaultStreamOptionsLegacy()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**defaultOptions** (`AgentStreamOptions | Promise<AgentStreamOptions>`): The default vNext streaming options configured for the agent, either as a direct object or a promise that resolves to the options.
+
+## Extended usage example
+
+```typescript
+await agent.getDefaultStreamOptionsLegacy({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Streaming with agents](https://mastra.ai/guides/concepts/streaming)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getDescription.md

@@ -0,0 +1,23 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getDescription()
+
+The `.getDescription()` method retrieves the description configured for an agent. This method returns a string description that describes the agent's purpose and capabilities.
+
+## Usage example
+
+```typescript
+agent.getDescription()
+```
+
+## Parameters
+
+This method takes no parameters.
+
+## Returns
+
+**description** (`string`): The description of the agent, or an empty string if no description was configured.
+
+## Related
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)

package/.docs/reference/agents/getInstructions.md

@@ -0,0 +1,34 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getInstructions()
+
+The `.getInstructions()` method retrieves the instructions configured for an agent, resolving them if they're a function. These instructions guide the agent's behavior and define its capabilities and constraints.
+
+## Usage example
+
+```typescript
+await agent.getInstructions()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**instructions** (`SystemMessage | Promise<SystemMessage>`): The instructions configured for the agent. SystemMessage can be: string | string\[] | CoreSystemMessage | CoreSystemMessage\[] | SystemModelMessage | SystemModelMessage\[]. Returns either directly or as a promise that resolves to the instructions.
+
+## Extended usage example
+
+```typescript
+await agent.getInstructions({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getLLM.md

@@ -0,0 +1,43 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getLLM()
+
+The `.getLLM()` method retrieves the language model instance configured for an agent, resolving it if it's a function. You can also pass a request-scoped `model` override without mutating the agent's configured model.
+
+## Usage example
+
+```typescript
+await agent.getLLM()
+```
+
+```typescript
+await agent.getLLM({
+  model: 'openai/gpt-5.6-sol',
+})
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext; model?: MastraModelConfig | DynamicArgument<MastraModelConfig> }`): Optional configuration object containing request context and an optional request-scoped model override. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+**options.model** (`MastraModelConfig | DynamicArgument<MastraModelConfig>`): Optional request-scoped model override. The agent's configured model is not mutated.
+
+## Returns
+
+**llm** (`MastraLLMV1 | Promise<MastraLLMV1>`): The language model instance configured for the agent, either as a direct instance or a promise that resolves to the LLM.
+
+## Extended usage example
+
+```typescript
+await agent.getLLM({
+  requestContext: new RequestContext(),
+  model: 'openai/gpt-5.6-sol',
+})
+```
+
+## Related
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getMemory.md

@@ -0,0 +1,34 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getMemory()
+
+The `.getMemory()` method retrieves the memory system associated with an agent. This method is used to access the agent's memory capabilities for storing and retrieving information across conversations.
+
+## Usage example
+
+```typescript
+await agent.getMemory()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**memory** (`Promise<MastraMemory | undefined>`): A promise that resolves to the memory system configured for the agent, or undefined if no memory system is configured.
+
+## Extended usage example
+
+```typescript
+await agent.getMemory({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Memory](https://mastra.ai/docs/memory/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getMetadata.md

@@ -0,0 +1,63 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getMetadata()
+
+The `.getMetadata()` method retrieves the metadata configured for an agent, resolving it if it's a function. Use metadata to classify agents in clients without encoding that data in the agent ID or name.
+
+## Usage example
+
+```typescript
+await agent.getMetadata()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context passed to dynamic metadata functions. Ignored when metadata is static.
+
+## Returns
+
+**metadata** (`Record<string, unknown> | Promise<Record<string, unknown>>`): The metadata configured for the agent, or undefined if no metadata was configured. Returns either directly or as a promise that resolves to the metadata when defined as a function.
+
+## Extended usage example
+
+Static metadata:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support Agent',
+  instructions: 'You help customers with support requests.',
+  model: 'openai/gpt-5.6-sol',
+  metadata: { type: 'support' },
+})
+
+const metadata = supportAgent.getMetadata()
+```
+
+Dynamic metadata resolved from the request context:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support Agent',
+  instructions: 'You help customers with support requests.',
+  model: 'openai/gpt-5.6-sol',
+  metadata: ({ requestContext }) => ({
+    type: 'support',
+    tenant: requestContext.get('tenant'),
+  }),
+})
+
+const metadata = await supportAgent.getMetadata({ requestContext })
+```
+
+## Related
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getModel.md

@@ -0,0 +1,34 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getModel()
+
+The `.getModel()` method retrieves the language model configured for an agent, resolving it if it's a function. This method is used to access the underlying model that powers the agent's capabilities.
+
+## Usage example
+
+```typescript
+await agent.getModel()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing request context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Request Context for dependency injection and contextual information.
+
+## Returns
+
+**model** (`MastraLanguageModel | Promise<MastraLanguageModel>`): The language model configured for the agent, either as a direct instance or a promise that resolves to the model.
+
+## Extended usage example
+
+```typescript
+await agent.getModel({
+  requestContext: new RequestContext(),
+})
+```
+
+## Related
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)
+- [Request Context](https://mastra.ai/docs/server/request-context)

package/.docs/reference/agents/getSkill.md

@@ -0,0 +1,60 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# `.getSkill()`
+
+Retrieves a specific skill by name from the agent's configured skills (both agent-level and workspace skills).
+
+## Usage example
+
+```typescript
+import { agent } from '../mastra/agents'
+
+const skill = await agent.getSkill('code-review')
+
+if (skill) {
+  console.log(skill.name) // "code-review"
+  console.log(skill.description) // "Use when reviewing code changes."
+  console.log(skill.instructions) // Full markdown instructions
+}
+```
+
+## Parameters
+
+**skillName** (`string`): The name of the skill to retrieve.
+
+**options** (`object`): Options for skill resolution.
+
+**options.requestContext** (`RequestContext`): Request context passed to dynamic skill resolvers.
+
+## Return value
+
+Returns `Promise<Skill | null>`.
+
+Returns the `Skill` object if found, or `null` if no skill with that name exists.
+
+```typescript
+interface Skill {
+  name: string
+  description: string
+  instructions: string
+  path: string
+  source: { type: string; projectPath: string }
+  references: string[]
+  scripts: string[]
+  assets: string[]
+  license?: string
+  compatibility?: string[]
+  'user-invocable'?: boolean
+  metadata?: Record<string, unknown>
+}
+```
+
+## Merging behavior
+
+When both agent-level skills and workspace skills are configured, `.getSkill()` searches the merged set. Agent-level skills take precedence on name conflicts.
+
+## Related
+
+- [Agent skills](https://mastra.ai/docs/agents/skills)
+- [`.listSkills()` reference](https://mastra.ai/reference/agents/listSkills)
+- [`createSkill()` reference](https://mastra.ai/reference/agents/createSkill)

package/.docs/reference/agents/getTools.md

@@ -0,0 +1,29 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Agent.getTools()
+
+The `.getTools()` method retrieves the tools configured for an agent, resolving them if they're a function. These tools extend the agent's capabilities, allowing it to perform specific actions or access external systems.
+
+## Usage example
+
+```typescript
+await agent.getTools()
+```
+
+## Parameters
+
+**options** (`{ requestContext?: RequestContext }`): Optional configuration object containing runtime context. (Default: `{}`)
+
+**options.requestContext** (`RequestContext`): Runtime context for dependency injection and contextual information.
+
+## Returns
+
+**tools** (`TTools | Promise<TTools>`): The tools configured for the agent, either as a direct object or a promise that resolves to the tools.
+
+## Extended usage example
+
+```typescript
+await agent.getTools({
+  requestContext: new RequestContext(),
+})
+```