@mastra/core 1.6.0 → 1.7.0-alpha.0

package/dist/docs/references/docs-workspace-skills.md

@@ -1,126 +0,0 @@
-# Workspace Skills
-
-**Added in:** `@mastra/core@1.1.0`
-
-Skills are reusable instructions that teach agents how to perform specific tasks. They follow the [Agent Skills specification](https://agentskills.io) - an open standard for packaging agent capabilities.
-
-A skill is a folder containing:
-
-- `SKILL.md`: Instructions and metadata for the agent
-- `references/`: Supporting documentation (optional)
-- `scripts/`: Executable scripts (optional)
-- `assets/`: Images and other files (optional)
-
-```plaintext
-/skills
-  /code-review
-    SKILL.md
-    /references
-      style-guide.md
-      pr-checklist.md
-    /scripts
-      lint.ts
-```
-
-When skills are configured on a workspace, agents can discover and activate them during conversations.
-
-## SKILL.md format
-
-Follow the official [skill specification](https://agentskills.io/specification) when creating your skill. Here is an example `SKILL.md` for a code review skill:
-
-```markdown
----
-name: code-review
-description: Reviews code for quality, style, and potential issues
-version: 1.0.0
-tags:
-  - development
-  - review
----
-
-# Code Review
-
-You are a code reviewer. When reviewing code:
-
-1. Check for bugs and edge cases
-2. Verify the code follows the style guide in references/style-guide.md
-3. Suggest improvements for readability
-4. Run the linter using scripts/lint.ts
-
-## What to look out for
-
-- Unused variables and imports
-- Missing error handling
-- Security vulnerabilities
-- Performance issues
-```
-
-## Configuring skills
-
-Enable skill discovery by setting the `skills` option on your workspace:
-
-```typescript
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  skills: ['/skills'],
-});
-```
-
-The `skills` directory is relative to your `basePath`. You can specify multiple skill directories:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  skills: [
-    '/skills',      // Project skills
-    '/team-skills', // Shared team skills
-  ],
-});
-```
-
-## Dynamic skills
-
-For dynamic skill paths based on context, pass a function:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  skills: (context) => {
-    const paths = ['/skills'];
-    if (context.user?.role === 'developer') {
-      paths.push('/dev-skills');
-    }
-    return paths;
-  },
-});
-```
-
-## How agents use skills
-
-When an agent activates a skill, the skill's instructions are added to the conversation context. The agent can then follow those instructions and access the skill's references and scripts.
-
-Under the hood this involves:
-
-1. Lists available skills in the system message
-2. Allows agents to activate skills during conversation
-3. Provides access to skill references and scripts
-
-## Skill search
-
-If BM25 or vector search is enabled on the workspace, skills are automatically indexed. Agents can search across skill content to find relevant instructions.
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  skills: ['/skills'],
-  bm25: true,
-});
-```
-
-## Related
-
-- [Agent skills specification](https://agentskills.io)
-- [Workspace overview](https://mastra.ai/docs/workspace/overview)
-- [Search and indexing](https://mastra.ai/docs/workspace/search)

package/dist/docs/references/guides-agent-frameworks-ai-sdk.md

@@ -1,140 +0,0 @@
-# AI SDK
-
-If you're already using the [Vercel AI SDK](https://sdk.vercel.ai) directly and want to add Mastra capabilities like [processors](https://mastra.ai/docs/agents/processors) or [memory](https://mastra.ai/docs/memory/memory-processors) without switching to the full Mastra agent API, [`withMastra()`](https://mastra.ai/reference/ai-sdk/with-mastra) lets you wrap any AI SDK model with these features. This is useful when you want to keep your existing AI SDK code but add input/output processing, conversation persistence, or content filtering.
-
-> **Tip:** If you want to use Mastra together with AI SDK UI (e.g. `useChat()`), visit the [AI SDK UI guide](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
-
-## Installation
-
-Install `@mastra/ai-sdk` to begin using the `withMastra()` function.
-
-**npm**:
-
-```bash
-npm install @mastra/ai-sdk@latest
-```
-
-**pnpm**:
-
-```bash
-pnpm add @mastra/ai-sdk@latest
-```
-
-**Yarn**:
-
-```bash
-yarn add @mastra/ai-sdk@latest
-```
-
-**Bun**:
-
-```bash
-bun add @mastra/ai-sdk@latest
-```
-
-## Examples
-
-### With Processors
-
-Processors let you transform messages before they're sent to the model (`processInput`) and after responses are received (`processOutputResult`). This example creates a logging processor that logs message counts at each stage, then wraps an OpenAI model with it.
-
-```typescript
-import { openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
-import { withMastra } from '@mastra/ai-sdk';
-import type { Processor } from '@mastra/core/processors';
-
-const loggingProcessor: Processor<'logger'> = {
-  id: 'logger',
-  async processInput({ messages }) {
-    console.log('Input:', messages.length, 'messages');
-    return messages;
-  },
-  async processOutputResult({ messages }) {
-    console.log('Output:', messages.length, 'messages');
-    return messages;
-  },
-};
-
-const model = withMastra(openai('gpt-4o'), {
-  inputProcessors: [loggingProcessor],
-  outputProcessors: [loggingProcessor],
-});
-
-const { text } = await generateText({
-  model,
-  prompt: 'What is 2 + 2?',
-});
-```
-
-### With Memory
-
-Memory automatically loads previous messages from storage before the LLM call and saves new messages after. This example configures a libSQL storage backend to persist conversation history, loading the last 10 messages for context.
-
-```typescript
-import { openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
-import { withMastra } from '@mastra/ai-sdk';
-import { LibSQLStore } from '@mastra/libsql';
-
-const storage = new LibSQLStore({
-  id: 'my-app',
-  url: 'file:./data.db',
-});
-await storage.init();
-
-const memoryStorage = await storage.getStore('memory');
-
-const model = withMastra(openai('gpt-4o'), {
-  memory: {
-    storage: memoryStorage!,
-    threadId: 'user-thread-123',
-    resourceId: 'user-123',
-    lastMessages: 10,
-  },
-});
-
-const { text } = await generateText({
-  model,
-  prompt: 'What did we talk about earlier?',
-});
-```
-
-### With Processors & Memory
-
-You can combine processors and memory together. Input processors run after memory loads historical messages, and output processors run before memory saves the response.
-
-```typescript
-import { openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
-import { withMastra } from '@mastra/ai-sdk';
-import { LibSQLStore } from '@mastra/libsql';
-
-const storage = new LibSQLStore({ id: 'my-app', url: 'file:./data.db' });
-await storage.init();
-
-const memoryStorage = await storage.getStore('memory');
-
-const model = withMastra(openai('gpt-4o'), {
-  inputProcessors: [myGuardProcessor],
-  outputProcessors: [myLoggingProcessor],
-  memory: {
-    storage: memoryStorage!,
-    threadId: 'thread-123',
-    resourceId: 'user-123',
-    lastMessages: 10,
-  },
-});
-
-const { text } = await generateText({
-  model,
-  prompt: 'Hello!',
-});
-```
-
-## Related
-
-- [`withMastra()`](https://mastra.ai/reference/ai-sdk/with-mastra) - API reference for `withMastra()`
-- [Processors](https://mastra.ai/docs/agents/processors) - Learn about input and output processors
-- [Memory](https://mastra.ai/docs/memory/overview) - Overview of Mastra's memory system
-- [AI SDK UI](https://mastra.ai/guides/build-your-ui/ai-sdk-ui) - Using AI SDK UI hooks with Mastra agents, workflows, and networks

package/dist/docs/references/reference-agents-agent.md

@@ -1,142 +0,0 @@
-# Agent Class
-
-The `Agent` class is the foundation for creating AI agents in Mastra. It provides methods for generating responses, streaming interactions, and handling voice capabilities.
-
-## Usage examples
-
-### Basic string instructions
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-
-// String instructions
-export const agent = new Agent({
-  id: "test-agent",
-  name: "Test Agent",
-  instructions: "You are a helpful assistant that provides concise answers.",
-  model: "openai/gpt-5.1",
-});
-
-// System message object
-export const agent2 = new Agent({
-  id: "test-agent-2",
-  name: "Test Agent 2",
-  instructions: {
-    role: "system",
-    content: "You are an expert programmer",
-  },
-  model: "openai/gpt-5.1",
-});
-
-// Array of system messages
-export const agent3 = new Agent({
-  id: "test-agent-3",
-  name: "Test Agent 3",
-  instructions: [
-    { role: "system", content: "You are a helpful assistant" },
-    { role: "system", content: "You have expertise in TypeScript" },
-  ],
-  model: "openai/gpt-5.1",
-});
-```
-
-### Single CoreSystemMessage
-
-Use CoreSystemMessage format to access additional properties like `providerOptions` for provider-specific configurations:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-
-export const agent = new Agent({
-  id: "core-message-agent",
-  name: "Core Message Agent",
-  instructions: {
-    role: "system",
-    content:
-      "You are a helpful assistant specialized in technical documentation.",
-    providerOptions: {
-      openai: {
-        reasoningEffort: "low",
-      },
-    },
-  },
-  model: "openai/gpt-5.1",
-});
-```
-
-### Multiple CoreSystemMessages
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-
-// This could be customizable based on the user
-const preferredTone = {
-  role: "system",
-  content: "Always maintain a professional and empathetic tone.",
-};
-
-export const agent = new Agent({
-  id: "multi-message-agent",
-  name: "Multi Message Agent",
-  instructions: [
-    { role: "system", content: "You are a customer service representative." },
-    preferredTone,
-    {
-      role: "system",
-      content: "Escalate complex issues to human agents when needed.",
-      providerOptions: {
-        anthropic: { cacheControl: { type: "ephemeral" } },
-      },
-    },
-  ],
-  model: "anthropic/claude-sonnet-4-20250514",
-});
-```
-
-## Constructor parameters
-
-**id?:** (`string`): Unique identifier for the agent. Defaults to \`name\` if not provided.
-
-**name:** (`string`): Display name for the agent. Used as the identifier if \`id\` is not provided.
-
-**description?:** (`string`): Optional description of the agent's purpose and capabilities.
-
-**instructions:** (`SystemMessage | ({ requestContext: RequestContext }) => SystemMessage | Promise<SystemMessage>`): Instructions that guide the agent's behavior. Can be a string, array of strings, system message object, array of system messages, or a function that returns any of these types dynamically. SystemMessage types: string | string\[] | CoreSystemMessage | CoreSystemMessage\[] | SystemModelMessage | SystemModelMessage\[]
-
-**model:** (`MastraLanguageModel | ({ requestContext: RequestContext }) => MastraLanguageModel | Promise<MastraLanguageModel>`): The language model used by the agent. Can be provided statically or resolved at runtime.
-
-**agents?:** (`Record<string, Agent> | ({ requestContext: RequestContext }) => Record<string, Agent> | Promise<Record<string, Agent>>`): Sub-Agents that the agent can access. Can be provided statically or resolved dynamically.
-
-**tools?:** (`ToolsInput | ({ requestContext: RequestContext }) => ToolsInput | Promise<ToolsInput>`): Tools that the agent can access. Can be provided statically or resolved dynamically.
-
-**workflows?:** (`Record<string, Workflow> | ({ requestContext: RequestContext }) => Record<string, Workflow> | Promise<Record<string, Workflow>>`): Workflows that the agent can execute. Can be static or dynamically resolved.
-
-**defaultOptions?:** (`AgentExecutionOptions | ({ requestContext: RequestContext }) => AgentExecutionOptions | Promise<AgentExecutionOptions>`): Default options used when calling \`stream()\` and \`generate()\`.
-
-**defaultGenerateOptionsLegacy?:** (`AgentGenerateOptions | ({ requestContext: RequestContext }) => AgentGenerateOptions | Promise<AgentGenerateOptions>`): Default options used when calling \`generateLegacy()\`.
-
-**defaultStreamOptionsLegacy?:** (`AgentStreamOptions | ({ requestContext: RequestContext }) => AgentStreamOptions | Promise<AgentStreamOptions>`): Default options used when calling \`streamLegacy()\`.
-
-**mastra?:** (`Mastra`): Reference to the Mastra runtime instance (injected automatically).
-
-**scorers?:** (`MastraScorers | ({ requestContext: RequestContext }) => MastraScorers | Promise<MastraScorers>`): Scoring configuration for runtime evaluation and telemetry. Can be static or dynamically provided.
-
-**memory?:** (`MastraMemory | ({ requestContext: RequestContext }) => MastraMemory | Promise<MastraMemory>`): Memory module used for storing and retrieving stateful context.
-
-**voice?:** (`CompositeVoice`): Voice settings for speech input and output.
-
-**inputProcessors?:** (`(Processor | ProcessorWorkflow)[] | ({ requestContext: RequestContext }) => (Processor | ProcessorWorkflow)[] | Promise<(Processor | ProcessorWorkflow)[]>`): Input processors that can modify or validate messages before they are processed by the agent. Can be individual Processor objects or workflows created with \`createWorkflow()\` using ProcessorStepSchema.
-
-**outputProcessors?:** (`(Processor | ProcessorWorkflow)[] | ({ requestContext: RequestContext }) => (Processor | ProcessorWorkflow)[] | Promise<(Processor | ProcessorWorkflow)[]>`): Output processors that can modify or validate messages from the agent before they are sent to the client. Can be individual Processor objects or workflows.
-
-**maxProcessorRetries?:** (`number`): Maximum number of times a processor can request retrying the LLM step.
-
-**requestContextSchema?:** (`z.ZodType<any>`): Zod schema for validating request context values. When provided, the context is validated at the start of generate() or stream(), throwing a MastraError if validation fails.
-
-## Returns
-
-**agent:** (`Agent<TAgentId, TTools>`): A new Agent instance with the specified configuration.
-
-## Related
-
-- [Agents overview](https://mastra.ai/docs/agents/overview)

package/dist/docs/references/reference-agents-generate.md

@@ -1,174 +0,0 @@
-# Agent.generate()
-
-The `.generate()` method enables non-streaming response generation from an agent with enhanced capabilities. It accepts messages and optional generation options.
-
-## Usage example
-
-```typescript
-// Basic usage
-const result = await agent.generate("message for agent");
-
-// With model settings (e.g., limiting output tokens)
-const limitedResult = await agent.generate("Write a short poem about coding", {
-  modelSettings: {
-    maxOutputTokens: 50,
-    temperature: 0.7,
-  },
-});
-
-// With structured output
-const structuredResult = await agent.generate("Extract the user's name and age", {
-  structuredOutput: {
-    schema: z.object({
-      name: z.string(),
-      age: z.number(),
-    }),
-  },
-});
-
-// With memory for conversation persistence
-const memoryResult = await agent.generate("Remember my favorite color is blue", {
-  memory: {
-    thread: "user-123-thread",
-    resource: "user-123",
-  },
-});
-
-// Accessing response headers
-const result = await agent.generate("Hello!");
-const remainingRequests = result.response?.headers?.["anthropic-ratelimit-requests-remaining"];
-const remainingTokens = result.response?.headers?.["x-ratelimit-remaining-tokens"];
-console.log(`Remaining requests: ${remainingRequests}, Remaining tokens: ${remainingTokens}`);
-```
-
-> **Info:** **Model Compatibility**: This method requires AI SDK v5+ models. If you're using AI SDK v4 models, use the [`.generateLegacy()`](https://mastra.ai/reference/agents/generateLegacy) method instead. The framework automatically detects your model version and will throw an error if there's a mismatch.
-
-## 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.
-
-**options?:** (`AgentExecutionOptions<Output, Format>`): Optional configuration for the generation process.
-
-### Options
-
-**maxSteps?:** (`number`): Maximum number of steps to run during execution.
-
-**stopWhen?:** (`LoopOptions['stopWhen']`): Conditions for stopping execution (e.g., step count, token limit).
-
-**scorers?:** (`MastraScorers | Record<string, { scorer: MastraScorer['name']; sampling?: ScoringSamplingConfig }>`): scorer:stringName of the scorer to use.sampling?:ScoringSamplingConfigSampling configuration for the scorer.type:'none' | 'ratio'Type of sampling strategy. Use 'none' to disable sampling or 'ratio' for percentage-based sampling.rate?:numberSampling rate (0-1). Required when type is 'ratio'.
-
-**returnScorerData?:** (`boolean`): Whether to return detailed scoring data in the response.
-
-**onChunk?:** (`(chunk: ChunkType) => Promise<void> | void`): Callback function called for each chunk during generation.
-
-**onError?:** (`({ error }: { error: Error | string }) => Promise<void> | void`): Callback function called when an error occurs during generation.
-
-**onAbort?:** (`(event: any) => Promise<void> | void`): Callback function called when the generation is aborted.
-
-**activeTools?:** (`Array<keyof ToolSet> | undefined`): Array of tool names that should be active during execution. If undefined, all available tools are active.
-
-**abortSignal?:** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated.
-
-**prepareStep?:** (`PrepareStepFunction`): Callback function called before each step of multi-step execution.
-
-**requireToolApproval?:** (`boolean`): When true, all tool calls require explicit approval before execution. The generate() method will return with \`finishReason: 'suspended'\` and include a \`suspendPayload\` with tool call details (\`toolCallId\`, \`toolName\`, \`args\`). Use \`approveToolCallGenerate()\` or \`declineToolCallGenerate()\` to proceed. See \[Agent Approval]\(/docs/agents/agent-approval#tool-approval-with-generate) for details.
-
-**autoResumeSuspendedTools?:** (`boolean`): When true, automatically resumes suspended tools when the user sends a new message on the same thread. The agent extracts \`resumeData\` from the user's message based on the tool's \`resumeSchema\`. Requires memory to be configured.
-
-**toolCallConcurrency?:** (`number`): Maximum number of tool calls to execute concurrently. Defaults to 1 when approval may be required, otherwise 10.
-
-**context?:** (`ModelMessage[]`): Additional context messages to provide to the agent.
-
-**structuredOutput?:** (`StructuredOutputOptions<S extends ZodTypeAny = ZodTypeAny>`): schema:z.ZodSchema\<S>Zod schema defining the expected output structure.model?:MastraLanguageModelLanguage model to use for structured output generation. If provided, enables the agent to respond in multi step with tool calls, text, and structured outputerrorStrategy?:'strict' | 'warn' | 'fallback'Strategy for handling schema validation errors. 'strict' throws errors, 'warn' logs warnings, 'fallback' uses fallback values.fallbackValue?:\<S extends ZodTypeAny>Fallback value to use when schema validation fails and errorStrategy is 'fallback'.instructions?:stringAdditional instructions for the structured output model.jsonPromptInjection?:booleanInjects system prompt into the main agent instructing it to return structured output, useful for when a model does not natively support structured outputs.logger?:IMastraLoggerOptional logger instance for structured logging during output generation.providerOptions?:ProviderOptionsProvider-specific options passed to the internal structuring agent. Use this to control model behavior like reasoning effort for thinking models (e.g., \`{ openai: { reasoningEffort: 'low' } }\`).
-
-**outputProcessors?:** (`OutputProcessorOrWorkflow[]`): Output processors to use for this execution (overrides agent's default).
-
-**maxProcessorRetries?:** (`number`): Maximum number of times processors can trigger a retry for this generation. Overrides agent's default maxProcessorRetries.
-
-**inputProcessors?:** (`InputProcessorOrWorkflow[]`): Input processors to use for this execution (overrides agent's default).
-
-**instructions?:** (`string | string[] | CoreSystemMessage | SystemModelMessage | CoreSystemMessage[] | SystemModelMessage[]`): Custom instructions that override the agent's default instructions for this execution. Can be a single string, message object, or array of either.
-
-**system?:** (`string | string[] | CoreSystemMessage | SystemModelMessage | CoreSystemMessage[] | SystemModelMessage[]`): Custom system message(s) to include in the prompt. Can be a single string, message object, or array of either. System messages provide additional context or behavior instructions that supplement the agent's main instructions.
-
-**output?:** (`Zod schema | JsonSchema7`): \*\*Deprecated.\*\* Use structuredOutput without a model to achieve the same thing. Defines the expected structure of the output. Can be a JSON Schema object or a Zod schema.
-
-**memory?:** (`object`): thread:string | { id: string; metadata?: Record\<string, any>, title?: string }Thread identifier for conversation continuity. Can be a string ID or an object with ID and optional metadata/title.resource:stringResource identifier for organizing conversations by user, session, or context.options?:MemoryConfigAdditional memory configuration options including lastMessages, readOnly, semanticRecall, and workingMemory.
-
-**onFinish?:** (`LoopConfig['onFinish']`): Callback fired when generation completes.
-
-**onStepFinish?:** (`LoopConfig['onStepFinish']`): Callback fired after each generation step.
-
-**telemetry?:** (`TelemetrySettings`): isEnabled?:booleanWhether telemetry collection is enabled.recordInputs?:booleanWhether to record input data in telemetry.recordOutputs?:booleanWhether to record output data in telemetry.functionId?:stringIdentifier for the function being executed.
-
-**modelSettings?:** (`CallSettings`): temperature?:numberControls randomness in generation (0-2). Higher values make output more random.maxOutputTokens?:numberMaximum number of tokens to generate in the response. Note: Use maxOutputTokens (not maxTokens) as per AI SDK v5 convention.maxRetries?:numberMaximum number of retry attempts for failed requests.topP?:numberNucleus sampling parameter (0-1). Controls diversity of generated text.topK?:numberTop-k sampling parameter. Limits vocabulary to k most likely tokens.presencePenalty?:numberPenalty for token presence (-2 to 2). Reduces repetition.frequencyPenalty?:numberPenalty for token frequency (-2 to 2). Reduces repetition of frequent tokens.stopSequences?:string\[]Stop sequences. If set, the model will stop generating text when one of the stop sequences is generated.
-
-**toolChoice?:** (`'auto' | 'none' | 'required' | { type: 'tool'; toolName: string }`): 'auto':stringLet the model decide when to use tools (default).'none':stringDisable tool usage entirely.'required':stringForce the model to use at least one tool.{ type: 'tool'; toolName: string }:objectForce the model to use a specific tool.
-
-**toolsets?:** (`ToolsetsInput`): Additional tool sets that can be used for this execution.
-
-**clientTools?:** (`ToolsInput`): Client-side tools available during execution.
-
-**savePerStep?:** (`boolean`): Save messages incrementally after each generation step completes (default: false).
-
-**providerOptions?:** (`Record<string, Record<string, JSONValue>>`): openai?:Record\<string, JSONValue>OpenAI-specific options like reasoningEffort, responseFormat, etc.anthropic?:Record\<string, JSONValue>Anthropic-specific options like maxTokens, etc.google?:Record\<string, JSONValue>Google-specific options.\[providerName]?:Record\<string, JSONValue>Any provider-specific options.
-
-**runId?:** (`string`): Unique identifier for this execution run.
-
-**requestContext?:** (`RequestContext`): Request Context containing dynamic configuration and state.
-
-**tracingContext?:** (`TracingContext`): currentSpan?:SpanCurrent span for creating child spans and adding metadata. Use this to create custom child spans or update span attributes during execution.
-
-**tracingOptions?:** (`TracingOptions`): metadata?:Record\<string, any>Metadata to add to the root trace span. Useful for adding custom attributes like user IDs, session IDs, or feature flags.requestContextKeys?:string\[]Additional RequestContext keys to extract as metadata for this trace. Supports dot notation for nested values (e.g., 'user.id').traceId?:stringTrace ID to use for this execution (1-32 hexadecimal characters). If provided, this trace will be part of the specified trace.parentSpanId?:stringParent span ID to use for this execution (1-16 hexadecimal characters). If provided, the root span will be created as a child of this span.tags?:string\[]Tags to apply to this trace. String labels for categorizing and filtering traces.
-
-**includeRawChunks?:** (`boolean`): Whether to include raw chunks in the stream output. Not available on all model providers.
-
-## Returns
-
-**result:** (`Awaited<ReturnType<MastraModelOutput<Output>['getFullOutput']>>`): Returns the full output of the generation process including text, object (if structured output), tool calls, tool results, usage statistics, and step information.
-
-**text:** (`string`): The generated text response from the agent.
-
-**object?:** (`Output | undefined`): The structured output object if structuredOutput was provided, validated against the schema.
-
-**toolCalls:** (`ToolCall[]`): Array of tool calls made during generation.
-
-**toolResults:** (`ToolResult[]`): Array of results from tool executions.
-
-**usage:** (`TokenUsage`): Token usage statistics for the generation.
-
-**steps:** (`Step[]`): Array of execution steps, useful for debugging multi-step generations.
-
-**finishReason:** (`string`): The reason generation finished. Values include 'stop' (normal completion), 'tool-calls' (ended with tool calls), 'suspended' (waiting for tool approval), or 'error' (error occurred).
-
-**response:** (`object`): id?:stringResponse ID from the model provider.timestamp?:DateTimestamp when the response was generated.modelId?:stringModel identifier used for this response.headers?:Record\<string, string>HTTP response headers from the model provider. Contains rate limit information (e.g., \`anthropic-ratelimit-requests-remaining\`, \`x-ratelimit-remaining-tokens\`) and other provider-specific metadata.messages?:ResponseMessage\[]Response messages in model format.uiMessages?:UIMessage\[]Response messages in UI format, includes any metadata added by output processors.
-
-**request?:** (`object`): body?:unknownThe request body sent to the model provider.
-
-**warnings?:** (`LanguageModelWarning[]`): Any warnings from the model provider during generation.
-
-**providerMetadata?:** (`Record<string, unknown>`): Provider-specific metadata returned with the response.
-
-**reasoning?:** (`ReasoningChunk[]`): Reasoning details from models that support reasoning (e.g., OpenAI o1 series).
-
-**reasoningText?:** (`string`): Combined reasoning text from reasoning models.
-
-**sources?:** (`SourceChunk[]`): Sources referenced by the model during generation.
-
-**files?:** (`FileChunk[]`): Files generated by the model.
-
-**suspendPayload?:** (`object`): toolCallId:stringUnique identifier for the pending tool call.toolName:stringName of the tool that requires approval.args:Record\<string, any>Arguments that will be passed to the tool.
-
-**runId?:** (`string`): Unique identifier for this execution run. Required when calling \`approveToolCallGenerate()\` or \`declineToolCallGenerate()\` to resume a suspended execution.
-
-**traceId?:** (`string`): The trace ID associated with this execution when Tracing is enabled. Use this to correlate logs and debug execution flow.
-
-**messages:** (`MastraDBMessage[]`): All messages from this execution including input, memory history, and response.
-
-**rememberedMessages:** (`MastraDBMessage[]`): Only messages loaded from memory (conversation history).
-
-**error?:** (`Error`): Error object if the generation failed.
-
-**tripwire?:** (`StepTripwireData`): Tripwire data if content was blocked by a processor.
-
-**scoringData?:** (`object`): Scoring data for evals when \`returnScorerData\` is enabled.