Agent

export const Agent = z.object({
  description: z.string(),
  id: z.nanoid({ length: 6 }).regex(/^[A-Za-z0-9]+$/),
  name: z.string(),
})

export type Agent = z.infer<typeof Agent>

type ConfigAgent = {
  color?: string
  description?: string
  disabled?: boolean
  hidden?: boolean
  mode?: "all" | "primary" | "subagent"
  model?:
    | string
    | { readonly providerID: string; readonly model: string; readonly variant?: string | undefined }
  permissions?: readonly {
    readonly action: string
    readonly resource: string
    readonly effect: "allow" | "ask" | "deny"
  }[]
  request?: {
    readonly headers?: { readonly [x: string]: string } | undefined
    readonly body?: { readonly [x: string]: Json } | undefined
  }
  steps?: number
  system?: string
}

type AgentDefinition = {
  autoCompactWindow?: number
  background?: boolean
  criticalSystemReminder_EXPERIMENTAL?: string
  description: string
  disallowedTools?: string[]
  effort?: number | "high" | "low" | "max" | "medium" | "xhigh"
  initialPrompt?: string
  maxTurns?: number
  mcpServers?: AgentMcpServerSpec[]
  memory?: "local" | "project" | "user"
  model?: string
  observer?: string
  observerMessage?: string
  omitClaudeMd?: boolean
  permissionMode?: PermissionMode
  prompt: string
  skills?: string[]
  tools?: string[]
}

type subagent = {
  autoCompactWindow?
  background?
  color?
  description
  disallowedTools?
  effort?
  experimental?
  hooks?
  initialPrompt?
  isolation?
  maxTurns?
  mcpServers?
  memory?
  model?
  name
  omitClaudeMd?
  permissionMode?
  skills?
  tools?
}

declare class Agent {
  initialState: unknown
  maxConcurrentAgentTools: number
  observability?: Observability
  onAgentToolFinish: (_run: AgentToolRunInfo, _result: AgentToolLifecycleResult) => Promise<void>
  onAgentToolStart: (_run: AgentToolRunInfo) => Promise<void>
  onAlarm: () => void
  onBeforeSubAgent: (
    _request: Request,
    _child: { className: string; name: string },
  ) => Promise<void | Request | Response>
  onClose: (
    _connection: Connection,
    _code: number,
    _reason: string,
    _wasClean: boolean,
  ) => void | Promise<void>
  onConnect: (_connection: Connection, _context: ConnectionContext) => void | Promise<void>
  onError: {
    (connection: Connection, error: unknown): void | Promise<void>
    (error: unknown): void | Promise<void>
  }
  onFiberRecovered: (_ctx: FiberRecoveryContext) => Promise<void | FiberRecoveryResult>
  onJob: (
    context: LifecycleJobContext,
  ) => void | Promise<void | LifecycleJobOutcome> | LifecycleJobOutcome
  onMessage: (_connection: Connection, _message: WSMessage) => void | Promise<void>
  onProgress: (_run: AgentToolRunInfo, _progress: AgentToolProgressSnapshot) => Promise<void>
  onRequest: (_request: Request) => Promise<Response> | Response
  onStart: (_props?: object | undefined) => void | Promise<void>
  onStateChanged: (_state: unknown, _source: "server" | Connection) => void
  onStateUpdate: (_state: unknown, _source: "server" | Connection) => void
  onWorkflowCallback: (callback: WorkflowCallback<DefaultProgress>) => Promise<void>
  onWorkflowComplete: (workflowName: string, workflowId: string, result?: unknown) => Promise<void>
  onWorkflowError: (workflowName: string, workflowId: string, error: string) => Promise<void>
  onWorkflowEvent: (workflowName: string, workflowId: string, event: unknown) => Promise<void>
  onWorkflowProgress: (workflowName: string, workflowId: string, progress: unknown) => Promise<void>
  static options: AgentStaticOptions
  taskDefinitions?: TaskHandlers
}

type AgentConfig = {
  agents?: DynamicArgument<Record<string, SubAgent<string, unknown>>, unknown>
  backgroundTasks?: AgentBackgroundConfig
  browser?: MastraBrowser
  channels?: AgentChannels | ChannelConfig
  defaultGenerateOptionsLegacy?: DynamicArgument<
    AgentGenerateOptions<undefined, undefined>,
    unknown
  >
  defaultNetworkOptions?: DynamicArgument<NetworkOptions, unknown>
  defaultOptions?: DynamicArgument<AgentExecutionOptions<undefined>, unknown>
  defaultStreamOptionsLegacy?: DynamicArgument<AgentStreamOptions<undefined, undefined>, unknown>
  description?: string
  durable?: AgentDurableOption
  editor?: AgentEditorConfig
  errorProcessorDefaults?: boolean
  errorProcessors?: DynamicArgument<ErrorProcessorOrWorkflow[], unknown>
  goal?: GoalConfig
  hooks?: ToolHooks<unknown, unknown, unknown, Record<string, unknown>>
  id: string
  inputProcessors?: DynamicArgument<InputProcessorOrWorkflow[], unknown>
  instructions: DynamicArgument<SystemMessage, unknown>
  mastra?: Mastra<
    Record<string, Agent<any, ToolsInput, undefined, any, AgentEditorConfig | undefined>>,
    Record<string, AnyWorkflow>,
    Record<string, MastraVector<any>>,
    Record<string, MastraTTS>,
    IMastraLogger,
    Record<string, MCPServerBase<any>>,
    Record<string, MastraScorer<any, any, any, any>>,
    Record<string, ToolAction<any, any, any, any, any, any, unknown>>,
    Record<string, Processor<any, unknown>>,
    Record<string, MastraMemory>,
    Record<string, ChannelProvider>,
    Record<string, Classifier<any>>,
    Record<string, Knowledge>
  >
  maxProcessorRetries?: number
  maxRetries?: number
  memory?: DynamicArgument<MastraMemory, unknown>
  metadata?: DynamicArgument<Record<string, unknown>, unknown>
  model: DynamicArgument<ModelWithRetries[] | MastraModelConfig, unknown>
  name: string
  notifications?: AgentNotificationConfig
  options?: AgentCreateOptions
  outputProcessors?: DynamicArgument<OutputProcessorOrWorkflow[], unknown>
  pubsub?: PubSub
  rawConfig?: Record<string, unknown>
  requestContextSchema?: PublicSchema<unknown>
  scopes?: DynamicArgument<string[], unknown>
  scorers?: DynamicArgument<MastraScorers, unknown>
  signals?: SignalProvider<string>[]
  skills?: AgentSkillsInput<unknown>
  skillsFormat?: SkillFormat
  tools?: DynamicArgument<ToolsInput, unknown>
  transform?: ToolPayloadTransformPolicy
  voice?: DynamicArgument<
    MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap, unknown>,
    unknown
  >
  workflows?: DynamicArgument<
    Record<string, Workflow<any, any, any, any, any, any, any, any>>,
    unknown
  >
  workspace?: DynamicArgument<AnyWorkspace | undefined, unknown>
}

type AgentOptions = {
  handoffDescription?: string
  handoffOutputTypeWarningEnabled?: boolean
  handoffs?: (Agent<any, any> | Handoff<any, "text">)[]
  inputGuardrails?: InputGuardrail[]
  instructions?:
    | string
    | ((runContext: RunContext<unknown>, agent: Agent<unknown, "text">) => string | Promise<string>)
  mcpConfig?: {
    convertSchemasToStrict?: boolean | undefined
    errorFunction?: MCPToolErrorFunction | null | undefined
    includeServerInToolNames?: boolean | undefined
  }
  mcpServers?: MCPServer[]
  model?: string | Model
  modelSettings?: ModelSettings
  name: string
  outputGuardrails?: OutputGuardrail<"text", unknown>[]
  outputType?: "text"
  prompt?:
    | Prompt
    | ((runContext: RunContext<unknown>, agent: Agent<unknown, "text">) => Promise<Prompt> | Prompt)
  resetToolChoice?: boolean
  tools?: Tool<unknown>[]
  toolUseBehavior?: ToolUseBehavior
}

type agent = {
  description: string
  developer_instructions: string
  name: string
}

type ToolLoopAgentSettings = {
  activeTools?: ActiveTools<{}>
  allowSystemInMessages?: boolean
  callOptionsSchema?: FlexibleSchema<never>
  experimental_download?: DownloadFunction
  experimental_onStart?: GenerateTextOnStartCallback<{}, Context, never>
  experimental_onStepStart?: GenerateTextOnStepStartCallback<{}, NoInfer<Context>, never>
  experimental_refineToolInput?: ToolInputRefinement<{}>
  experimental_repairToolCall?: ToolCallRepairFunction<{}>
  experimental_telemetry?: TelemetryOptions<Context, {}>
  experimental_toolApprovalSecret?: string | Uint8Array<ArrayBufferLike>
  experimental_toolCallers?: Experimental_ToolCallers<{}>
  frequencyPenalty?: number
  headers?: Record<string, string | undefined>
  id?: string
  include?: GenerateTextInclude & StreamTextInclude
  instructions?: Instructions
  maxOutputTokens?: number
  maxRetries?: number
  model: LanguageModel
  onEnd?: GenerateTextOnEndCallback<{}, NoInfer<Context>>
  onFinish?: GenerateTextOnEndCallback<{}, NoInfer<Context>>
  onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<{}>
  onLanguageModelCallStart?: OnLanguageModelCallStartCallback
  onStart?: GenerateTextOnStartCallback<{}, Context, never>
  onStepEnd?: GenerateTextOnStepEndCallback<{}, NoInfer<Context>>
  onStepFinish?: GenerateTextOnStepFinishCallback<{}, NoInfer<Context>>
  onStepStart?: GenerateTextOnStepStartCallback<{}, NoInfer<Context>, never>
  onToolExecutionEnd?: OnToolExecutionEndCallback<{}>
  onToolExecutionStart?: OnToolExecutionStartCallback<{}>
  output?: undefined
  prepareCall?: (
    options: Omit<
      AgentCallParameters<never, {}, NoInfer<Context>>,
      | "abortSignal"
      | "experimental_onStart"
      | "experimental_onStepStart"
      | "onEnd"
      | "onFinish"
      | "onStart"
      | "onStepEnd"
      | "onStepFinish"
      | "onStepStart"
      | "onToolExecutionEnd"
      | "onToolExecutionStart"
      | "timeout"
    > &
      Pick<
        ToolLoopAgentSettings<never, {}, Context, never>,
        | "_internal"
        | "activeTools"
        | "allowSystemInMessages"
        | "experimental_download"
        | "experimental_refineToolInput"
        | "experimental_repairToolCall"
        | "experimental_telemetry"
        | "experimental_toolApprovalSecret"
        | "experimental_toolCallers"
        | "frequencyPenalty"
        | "headers"
        | "include"
        | "instructions"
        | "maxOutputTokens"
        | "maxRetries"
        | "model"
        | "prepareStep"
        | "presencePenalty"
        | "providerOptions"
        | "reasoning"
        | "repairToolCall"
        | "runtimeContext"
        | "seed"
        | "stopSequences"
        | "stopWhen"
        | "telemetry"
        | "temperature"
        | "toolApproval"
        | "toolCallConcurrency"
        | "toolChoice"
        | "toolOrder"
        | "tools"
        | "topK"
        | "topP"
      > & { toolsContext: Normalize<RequiredToolSetContext<{}> & OptionalToolSetContext<{}>> },
  ) => MaybePromiseLike<
    Pick<
      ToolLoopAgentSettings<never, {}, Context, never>,
      | "_internal"
      | "activeTools"
      | "allowSystemInMessages"
      | "experimental_download"
      | "experimental_refineToolInput"
      | "experimental_repairToolCall"
      | "experimental_telemetry"
      | "experimental_toolApprovalSecret"
      | "experimental_toolCallers"
      | "frequencyPenalty"
      | "headers"
      | "include"
      | "instructions"
      | "maxOutputTokens"
      | "maxRetries"
      | "model"
      | "prepareStep"
      | "presencePenalty"
      | "providerOptions"
      | "reasoning"
      | "repairToolCall"
      | "runtimeContext"
      | "seed"
      | "stopSequences"
      | "stopWhen"
      | "telemetry"
      | "temperature"
      | "toolApproval"
      | "toolCallConcurrency"
      | "toolChoice"
      | "toolOrder"
      | "tools"
      | "topK"
      | "topP"
    > &
      Omit<Prompt, "system"> & {
        toolsContext: Normalize<RequiredToolSetContext<{}> & OptionalToolSetContext<{}>>
      }
  >
  prepareStep?: PrepareStepFunction<{}, Context>
  presencePenalty?: number
  providerOptions?: SharedV4ProviderOptions
  reasoning?: "high" | "low" | "max" | "medium" | "minimal" | "none" | "provider-default" | "xhigh"
  repairToolCall?: ToolCallRepairFunction<{}>
  runtimeContext?: Context
  seed?: number
  stopSequences?: string[]
  stopWhen?: Arrayable<StopCondition<{}, Context>>
  telemetry?: TelemetryOptions<Context, {}>
  temperature?: number
  timeout?: TimeoutConfiguration<{}>
  toolApproval?: ToolApprovalConfiguration<{}, Context>
  toolCallConcurrency?: number
  toolChoice?: ToolChoice<{}>
  toolOrder?: ToolOrder<{}>
  tools?: {}
  toolsContext?: undefined
  topK?: number
  topP?: number
}

type AgentDefinition = {
  build?: AgentBuildDefinition
  compaction?: PublicAgentCompactionDefinition
  defaultTools?: boolean
  description?: string
  experimental?: AgentExperimentalDefinition
  limits?: AgentLimitsDefinition
  model: PublicAgentDynamicModelDefinition | PublicAgentStaticModelDefinition
  modelContextWindowTokens?: number
  modelOptions?: AgentModelOptionsDefinition
  reasoning?: AgentReasoningDefinition
  tool?: AgentToolExposure
}