Struct StandardDefinition 

pub struct StandardDefinition {

    pub name: String,
    pub description: String,
    pub version: Option<String>,
    pub instructions: String,
    pub mcp_servers: Option<Vec<McpDefinition>>,
    pub model_settings: Option<ModelSettings>,
    pub analysis_model_settings: Option<ModelSettings>,
    pub history_size: Option<usize>,
    pub strategy: Option<AgentStrategy>,
    pub icon_url: Option<String>,
    pub max_iterations: Option<usize>,
    pub skills_description: Vec<AgentSkill>,
    pub available_skills: Vec<AvailableSkill>,
    pub sub_agents: Vec<String>,
    pub tool_format: ToolCallFormat,
    pub tool_delivery_mode: ToolDeliveryMode,
    pub tools: Option<ToolsConfig>,
    pub partials: HashMap<String, String>,
    pub reflection: Option<ReflectionConfig>,
    pub enable_todos: Option<bool>,
    pub browser_config: Option<BrowserAgentConfig>,
    pub include_shell: Option<bool>,
    pub context_size: Option<u32>,
    pub append_default_instructions: Option<bool>,
    pub include_scratchpad: Option<bool>,
    pub hooks: Vec<String>,
    pub user_message_overrides: Option<UserMessageOverrides>,
    pub compaction_enabled: bool,
    pub remote: bool,
    pub runtime: Vec<RuntimeMode>,
}

Agent definition - complete configuration for an agent

Fields

name: String

The name of the agent.

description: String

A brief description of the agent’s purpose.

version: Option<String>

The version of the agent.

instructions: String

Instructions for the agent - serves as an introduction defining what the agent is and does.

mcp_servers: Option<Vec<McpDefinition>>

A list of MCP server definitions associated with the agent.

model_settings: Option<ModelSettings>

Settings related to the model used by the agent. When None, the agent inherits model settings from the orchestrator context defaults.

analysis_model_settings: Option<ModelSettings>

Optional lower-level model settings for lightweight analysis helpers

history_size: Option<usize>

The size of the history to maintain for the agent.

strategy: Option<AgentStrategy>

The new strategy configuration for the agent.

icon_url: Option<String>

A2A-specific fields

max_iterations: Option<usize>

skills_description: Vec<AgentSkill>

A2A agent card skills metadata (describes capabilities for agent-to-agent protocol)

available_skills: Vec<AvailableSkill>

Skills available for on-demand loading by this agent

sub_agents: Vec<String>

List of sub-agents that this agent can transfer control to

tool_format: ToolCallFormat

Tool calling configuration

tool_delivery_mode: ToolDeliveryMode

How tools are delivered to the LLM (all upfront vs on-demand search)

tools: Option<ToolsConfig>

Tools configuration for this agent

partials: HashMap<String, String>

Custom handlebars partials (name -> template path) for use in custom prompts

reflection: Option<ReflectionConfig>

Reflection configuration for post-execution analysis using a subagent

enable_todos: Option<bool>

Whether to enable TODO management functionality

browser_config: Option<BrowserAgentConfig>

Browser configuration for this agent (enables shared Chromium automation)

include_shell: Option<bool>

Whether to include shell/code execution tools (start_shell, execute_shell, stop_shell)

context_size: Option<u32>

Context size override for this agent (overrides model_settings.context_size)

append_default_instructions: Option<bool>

Strategy for prompt construction (append default template vs fully custom)

include_scratchpad: Option<bool>

Whether to include the built-in scratchpad/history in prompts (default: true)

hooks: Vec<String>

Optional hook names to attach to this agent

user_message_overrides: Option<UserMessageOverrides>

Custom user message construction (dynamic prompting)

compaction_enabled: bool

Whether context compaction is enabled for this agent (default: true)

remote: bool

DEPRECATED: prefer runtime = ["cli"] instead.

When true, this is treated as runtime = [Cli] — the agent needs a CLI-style local environment (filesystem, shell exec). In a Cloud runtime the orchestrator forks the call into a sandbox via BackgroundRunner. Kept for backwards compatibility with existing agent definitions and the --remote CLI flag / DefinitionOverrides.remote.

runtime: Vec<RuntimeMode>

Runtime constraint for this agent. Like Docker’s platforms field:

• empty / omitted → runs in any runtime (default).
• ["cli"] → only runs when ExecutorContext.runtime_mode == Cli, OR via a BackgroundRunner providing Cli (e.g. SandboxLauncher spawning distri-cli inside a browsr container).
• ["cli", "cloud"] → runs in either Cli or Cloud, but not Browser.

When the current runtime doesn’t match any allowed value and no compatible runner exists, the orchestrator fails fast at request entry.

Accepts both scalar (runtime = "cli") and array (runtime = ["cli"]) syntax in TOML/JSON for ergonomics.

Implementations

impl StandardDefinition

pub fn allowed_runtimes(&self) -> Vec<RuntimeMode>

The set of runtimes this agent is allowed to run in, with the deprecated remote: true flag merged in (treated as [Cli] when runtime is empty).

Empty result = no constraint = runs anywhere.

pub fn is_runnable_in( &self, current: &RuntimeMode, runner_provides: Option<&RuntimeMode>, ) -> bool

Whether this agent can execute given the caller’s current runtime, optionally with a BackgroundRunner providing an alternative runtime via remote dispatch.

Returns true when:

• the agent has no runtime constraint, OR
• the current runtime matches one of the allowed runtimes, OR
• a runner is available whose provided_runtime matches one of the allowed runtimes.

pub fn should_use_browser(&self) -> bool

Check if browser should be initialized automatically in orchestrator (default: false)

pub fn browser_settings(&self) -> Option<&BrowserAgentConfig>

Returns browser config if defined

pub fn browser_runtime_config(&self) -> Option<BrowsrClientConfig>

Returns the runtime Chromium driver configuration if enabled

pub fn should_persist_browser_session(&self) -> bool

Should browser session state be serialized after tool runs

pub fn is_reflection_enabled(&self) -> bool

Check if reflection is enabled (default: false)

pub fn reflection_config(&self) -> Option<&ReflectionConfig>

Get the reflection configuration, if any

pub fn is_todos_enabled(&self) -> bool

Check if TODO management functionality is enabled (default: false)

pub fn should_include_shell(&self) -> bool

Check if shell/code execution tools should be included (default: false)

pub fn model_settings(&self) -> Option<&ModelSettings>

Get model settings if configured.

pub fn model_settings_mut(&mut self) -> Option<&mut ModelSettings>

Get a mutable reference to model settings, if present.

pub fn get_effective_context_size(&self) -> u32

Get the effective context size (agent-level override or model settings)

pub fn analysis_model_settings_config(&self) -> Option<&ModelSettings>

Model settings to use for lightweight browser analysis helpers (e.g., observe_summary commands)

pub fn include_scratchpad(&self) -> bool

Whether to include the persistent scratchpad/history in prompts

pub fn apply_overrides(&mut self, overrides: DefinitionOverrides)

Apply definition overrides to this agent definition

impl StandardDefinition

pub fn validate(&self) -> Result<()>

pub fn validate_reflection_agent(agent_def: &StandardDefinition) -> Result<()>

Validate that a reflection agent definition has the “reflect” tool configured. This is called at registration time when we have access to the full agent config.

Trait Implementations

impl Clone for StandardDefinition

fn clone(&self) -> StandardDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StandardDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for StandardDefinition

fn default() -> StandardDefinition

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StandardDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StandardDefinition> for LlmDefinition

fn from(definition: StandardDefinition) -> Self

Converts to this type from the input type.

impl JsonSchema for StandardDefinition

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for StandardDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.