Mastra

import { class Composio<TProvider extends BaseComposioProvider<unknown, unknown, unknown> = OpenAIProvider>
This is the core class for Composio.
It is used to initialize the Composio SDK and provide a global configuration.Composio } from "@composio/core";
import { class MastraProviderMastraProvider } from "@composio/mastra";
import { class Agent<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>
The Agent class is the foundation for creating AI agents in Mastra. It provides methods for generating responses,
streaming interactions, managing memory, and handling voice capabilities.
@example```typescript
import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

const agent = new Agent({
  id: 'my-agent',
  name: 'My Agent',
  instructions: 'You are a helpful assistant',
  model: 'openai/gpt-5',
  tools: {
    calculator: calculatorTool,
  },
  memory: new Memory(),
});
```Agent } from "@mastra/core/agent";
import { const openai: OpenAIProvider
Default OpenAI provider instance.openai } from "@ai-sdk/openai";

const const composio: Composio<MastraProvider>composio = new new Composio<MastraProvider>(config?: ComposioConfig<MastraProvider> | undefined): Composio<MastraProvider>
Creates a new instance of the Composio SDK.

The constructor initializes the SDK with the provided configuration options,
sets up the API client, and initializes all core models (tools, toolkits, etc.).
@paramconfig - Configuration options for the Composio SDK@paramconfig.apiKey - The API key for authenticating with the Composio API@paramconfig.baseURL - The base URL for the Composio API (defaults to production URL)@paramconfig.allowTracking - Whether to allow anonymous usage analytics@paramconfig.provider - The provider to use for this Composio instance (defaults to OpenAIProvider)@example```typescript
// Initialize with default configuration
const composio = new Composio();

// Initialize with custom API key and base URL
const composio = new Composio({
  apiKey: 'your-api-key',
  baseURL: 'https://api.composio.dev'
});

// Initialize with custom provider
const composio = new Composio({
  apiKey: 'your-api-key',
  provider: new CustomProvider()
});
```Composio({
  provider?: MastraProvider | undefined
The tool provider to use for this Composio instance.
@examplenew OpenAIProvider()provider: new 
new MastraProvider({ strict }?: {
    strict?: boolean;
}): MastraProvider
Creates a new instance of the MastraProvider.

This provider enables integration with the Mastra AI SDK,
allowing Composio tools to be used with Mastra AI applications.
@paramparam0@paramparam0.strict - Whether to use strict mode for tool execution@returnsA new instance of the MastraProvider@example```typescript
import { Composio } from '@composio/core';
import { MastraProvider } from '@composio/mastra';

const composio = new Composio({
  apiKey: 'your-composio-api-key',
  provider: new MastraProvider(),
});
```MastraProvider(),
});

const const userId: "john doe"userId = "john doe";

const const tools: MastraToolCollectiontools = await const composio: Composio<MastraProvider>composio.Composio<MastraProvider>.tools: Tools<unknown, unknown, MastraProvider>
List, retrieve, and execute toolstools.Tools<unknown, unknown, MastraProvider>.get<MastraProvider>(userId: string, filters: ToolListParams, options?: AgenticToolOptions | undefined): Promise<MastraToolCollection> (+1 overload)
Get a list of tools from Composio based on filters.
This method fetches the tools from the Composio API and wraps them using the provider.
@paramuserId - The user id to get the tools for@paramfilters - The filters to apply when fetching tools@paramoptions - Optional provider options including modifiers@returnsThe wrapped tools collection@example```typescript
// Get tools from the GitHub toolkit
const tools = await composio.tools.get('default', {
  toolkits: ['github'],
  limit: 10
});

// Get tools with search
const searchTools = await composio.tools.get('default', {
  search: 'user',
  limit: 10
});

// Get a specific tool by slug
const hackerNewsUserTool = await composio.tools.get('default', 'HACKERNEWS_GET_USER');

// Get a tool with schema modifications
const tool = await composio.tools.get('default', 'GITHUB_GET_REPOS', {
  modifySchema: (toolSlug, toolkitSlug, schema) => {
    // Customize the tool schema
    return {...schema, description: 'Custom description'};
  }
});
```get(
  const userId: "john doe"userId,
  {
    toolkits: [string]toolkits: ["SUPABASE"],
  }
);

const const agent: Agent<"supabase-agent", MastraToolCollection>agent = new new Agent<"supabase-agent", MastraToolCollection>(config: AgentConfig<"supabase-agent", MastraToolCollection>): Agent<"supabase-agent", MastraToolCollection>
Creates a new Agent instance with the specified configuration.
@example```typescript
import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

const agent = new Agent({
  id: 'weatherAgent',
  name: 'Weather Agent',
  instructions: 'You help users with weather information',
  model: 'openai/gpt-5',
  tools: { getWeather },
  memory: new Memory(),
  maxRetries: 2,
});
```Agent({
  AgentConfig<"supabase-agent", MastraToolCollection>.id: "supabase-agent"
Identifier for the agent.id: "supabase-agent",
  AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>.name: string
Unique identifier for the agent.name: "Supabase Agent",
  AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>.instructions: DynamicAgentInstructions
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.instructions: "You think therefore you are.",
  AgentConfig<"supabase-agent", MastraToolCollection>.model: MastraModelConfig | DynamicModel | ModelWithRetries[]
The language model used by the agent. Can be provided statically or resolved at runtime.model: function openai(modelId: OpenAIResponsesModelId): LanguageModelV3
Default OpenAI provider instance.openai("gpt-4.1"),
  AgentConfig<"supabase-agent", MastraToolCollection>.tools?: DynamicArgument<MastraToolCollection> | undefined
Tools that the agent can access. Can be provided statically or resolved dynamically.tools: const tools: MastraToolCollectiontools,
});

const { const text: stringtext } = await const agent: Agent<"supabase-agent", MastraToolCollection>agent.
Agent<"supabase-agent", MastraToolCollection>.generate<undefined>(messages: MessageListInput, options?: AgentExecutionOptions<undefined> | undefined): Promise<{
    traceId: string | undefined;
    runId: string;
    suspendPayload: any;
    scoringData?: {
        input: Omit<ScorerRunInputForAgent, "runId">;
        output: ScorerRunOutputForAgent;
    } | undefined;
    text: string;
    usage: LanguageModelUsage;
    ... 15 more ...;
    tripwire: StepTripwireData | undefined;
}>generate([
  { role: "user"role: "user", content: stringcontent: "Tell me about my Supabase project" },
]);

var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log("\n🤖 Agent Response:\n");
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log(const text: stringtext);

import { class MCPClientMCPClient } from "@mastra/mcp";
import { const openai: OpenAIProvider
Default OpenAI provider instance.openai } from "@ai-sdk/openai";
import { class Agent<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>
The Agent class is the foundation for creating AI agents in Mastra. It provides methods for generating responses,
streaming interactions, managing memory, and handling voice capabilities.
@example```typescript
import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

const agent = new Agent({
  id: 'my-agent',
  name: 'My Agent',
  instructions: 'You are a helpful assistant',
  model: 'openai/gpt-5',
  tools: {
    calculator: calculatorTool,
  },
  memory: new Memory(),
});
```Agent } from "@mastra/core/agent";
import { class Composio<TProvider extends BaseComposioProvider<unknown, unknown, unknown> = OpenAIProvider>
This is the core class for Composio.
It is used to initialize the Composio SDK and provide a global configuration.Composio } from "@composio/core";

// Initialize Composio
const const composio: Composio<OpenAIProvider>composio = new new Composio<OpenAIProvider>(config?: ComposioConfig<OpenAIProvider> | undefined): Composio<OpenAIProvider>
Creates a new instance of the Composio SDK.

The constructor initializes the SDK with the provided configuration options,
sets up the API client, and initializes all core models (tools, toolkits, etc.).
@paramconfig - Configuration options for the Composio SDK@paramconfig.apiKey - The API key for authenticating with the Composio API@paramconfig.baseURL - The base URL for the Composio API (defaults to production URL)@paramconfig.allowTracking - Whether to allow anonymous usage analytics@paramconfig.provider - The provider to use for this Composio instance (defaults to OpenAIProvider)@example```typescript
// Initialize with default configuration
const composio = new Composio();

// Initialize with custom API key and base URL
const composio = new Composio({
  apiKey: 'your-api-key',
  baseURL: 'https://api.composio.dev'
});

// Initialize with custom provider
const composio = new Composio({
  apiKey: 'your-api-key',
  provider: new CustomProvider()
});
```Composio();

// Create MCP server with GitHub, Linear, and Notion tools
const const server: MCPConfigCreateResponseserver = await const composio: Composio<OpenAIProvider>composio.Composio<OpenAIProvider>.mcp: MCP
Model Context Protocol server managementmcp.
MCP.create(name: string, mcpConfig: {
    toolkits: (string | {
        toolkit?: string | undefined;
        authConfigId?: string | undefined;
    })[];
    allowedTools?: string[] | undefined;
    manuallyManageConnections?: boolean | undefined;
}): Promise<MCPConfigCreateResponse>
Create a new MCP configuration.
@paramparams - Parameters for creating the MCP configuration@paramparams.authConfig - Array of auth configurations with id and allowed tools@paramparams.options - Configuration options@paramparams.options.name - Unique name for the MCP configuration@paramparams.options.manuallyManageConnections - Whether to use chat-based authentication or manually connect accounts@returnsCreated server details with instance getter@example```typescript
const server = await composio.mcpConfig.create("personal-mcp-server", {
  toolkits: ["github", "slack"],
  allowedTools: ["GMAIL_FETCH_EMAILS", "SLACK_SEND_MESSAGE"],
  manuallyManageConnections: false
 }
});

const server = await composio.mcpConfig.create("personal-mcp-server", {
  toolkits: [{ toolkit: "gmail", authConfigId: "ac_243434343" }],
  allowedTools: ["GMAIL_FETCH_EMAILS"],
  manuallyManageConnections: false
 }
});
```create(
  "dev-automation-server",
  {
    
toolkits: (string | {
    toolkit?: string | undefined;
    authConfigId?: string | undefined;
})[]toolkits: [
      { toolkit?: string | undefinedtoolkit: "github", authConfigId?: string | undefinedauthConfigId: "ac_github_id" },
      { toolkit?: string | undefinedtoolkit: "linear", authConfigId?: string | undefinedauthConfigId: "ac_linear_id" },
      { toolkit?: string | undefinedtoolkit: "notion", authConfigId?: string | undefinedauthConfigId: "ac_notion_id" }
    ],
    allowedTools?: string[] | undefinedallowedTools: [
      "GITHUB_LIST_ISSUES", "GITHUB_CREATE_ISSUE",
      "LINEAR_CREATE_ISSUE", "LINEAR_UPDATE_ISSUE",
      "NOTION_CREATE_PAGE", "NOTION_UPDATE_PAGE"
    ]
  }
);

// Generate MCP instance for user
const 
const instance: {
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}instance = await const server: MCPConfigCreateResponseserver.
MCPConfigCreateResponse.generate: (userId: string) => Promise<{
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}>
Creates an instance for a user of the specific MCP Server/COnfig
@paramuserId@returnsgenerate("user@example.com");

// Create MCP client with Composio server
export const const mcpClient: MCPClientmcpClient = new new MCPClient(args: MCPClientOptions): MCPClientMCPClient({
  MCPClientOptions.id?: string | undefinedid: "composio-mcp-client",
  MCPClientOptions.servers: Record<string, MastraMCPServerDefinition>servers: {
    
composio: {
    url: URL;
}composio: { url: URLurl: new var URL: new (url: string | URL, base?: string | URL) => URL
The **`URL`** interface is used to parse, construct, normalize, and encode URL.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/URL)URL(
const instance: {
    name: string;
    type: "streamable_http";
    id: string;
    userId: string;
    allowedTools: string[];
    url: string;
    authConfigs: string[];
}instance.url: stringurl) },
  }
});

// Create a development workflow agent
export const const devAgent: Agent<"dev-assistant", Record<string, any>>devAgent = new new Agent<"dev-assistant", Record<string, any>>(config: AgentConfig<"dev-assistant", Record<string, any>>): Agent<"dev-assistant", Record<string, any>>
Creates a new Agent instance with the specified configuration.
@example```typescript
import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

const agent = new Agent({
  id: 'weatherAgent',
  name: 'Weather Agent',
  instructions: 'You help users with weather information',
  model: 'openai/gpt-5',
  tools: { getWeather },
  memory: new Memory(),
  maxRetries: 2,
});
```Agent({
  AgentConfig<"dev-assistant", Record<string, any>>.id: "dev-assistant"
Identifier for the agent.id: "dev-assistant",
  AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>.name: string
Unique identifier for the agent.name: "Dev Assistant",
  AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>.description?: string | undefined
Description of the agent's purpose and capabilities.description: "AI assistant for development workflow automation",
  AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput>.instructions: DynamicAgentInstructions
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.instructions: "Help manage GitHub repos, Linear issues, and Notion documentation.",
  AgentConfig<"dev-assistant", Record<string, any>>.model: MastraModelConfig | DynamicModel | ModelWithRetries[]
The language model used by the agent. Can be provided statically or resolved at runtime.model: function openai(modelId: OpenAIResponsesModelId): LanguageModelV3
Default OpenAI provider instance.openai("gpt-4-turbo"),
  AgentConfig<"dev-assistant", Record<string, any>>.tools?: DynamicArgument<Record<string, any>> | undefined
Tools that the agent can access. Can be provided statically or resolved dynamically.tools: await const mcpClient: MCPClientmcpClient.MCPClient.getTools(): Promise<Record<string, any>>getTools()
});

// Example: Automate development workflow
(async () => {
  const 
const response: {
    traceId: string | undefined;
    runId: string;
    suspendPayload: any;
    scoringData?: {
        input: Omit<ScorerRunInputForAgent, "runId">;
        output: ScorerRunOutputForAgent;
    } | undefined;
    text: string;
    usage: LanguageModelUsage;
    steps: LLMStepResult<undefined>[];
    finishReason: string | undefined;
    warnings: LanguageModelV2CallWarning[];
    ... 12 more ...;
    tripwire: StepTripwireData | undefined;
}response = await const devAgent: Agent<"dev-assistant", Record<string, any>>devAgent.
Agent<"dev-assistant", Record<string, any>>.generate<undefined>(messages: MessageListInput, options?: AgentExecutionOptions<undefined> | undefined): Promise<{
    traceId: string | undefined;
    runId: string;
    suspendPayload: any;
    scoringData?: {
        input: Omit<ScorerRunInputForAgent, "runId">;
        output: ScorerRunOutputForAgent;
    } | undefined;
    text: string;
    usage: LanguageModelUsage;
    ... 15 more ...;
    tripwire: StepTripwireData | undefined;
}>generate(
    "Review open GitHub issues, create Linear tasks for bugs labeled 'priority', and update the Notion roadmap page"
  );
  var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log(
const response: {
    traceId: string | undefined;
    runId: string;
    suspendPayload: any;
    scoringData?: {
        input: Omit<ScorerRunInputForAgent, "runId">;
        output: ScorerRunOutputForAgent;
    } | undefined;
    text: string;
    usage: LanguageModelUsage;
    steps: LLMStepResult<undefined>[];
    finishReason: string | undefined;
    warnings: LanguageModelV2CallWarning[];
    ... 12 more ...;
    tripwire: StepTripwireData | undefined;
}response.text: stringtext);
})();