Config¶

Bases: BaseModel

Capability and family/generation metadata for a single model.

Enriched from litellm at discovery and persisted on :class:~synthorg.config.provider_schema.ProviderModelConfig so the matcher can select on real capability data offline.

Attributes:

Config:

• frozen: True
• extra: forbid
• allow_inf_nan: False

Fields:

• supports_tools (bool)
• tool_calls_verified (bool | None)
• supports_vision (bool)
• supports_reasoning (bool)
• supports_embeddings (bool)
• max_output_tokens (int | None)
• parameter_count (int | None)
• cost_tier (int | None)
• family (NotBlankStr | None)
• generation (float | None)
• release_date (date | None)
• metadata_source (MetadataSource)

tool_calls_verified = None

max_output_tokens = None

parameter_count = None

cost_tier = None

family = None

generation = None

release_date = None

metadata_source = 'unknown'

Bases: BaseModel

Per-model launch parameters for local providers.

Config:

• frozen: True
• allow_inf_nan: False
• extra: forbid

Fields:

• num_ctx (int | None)
• num_gpu_layers (int | None)
• num_threads (int | None)
• num_batch (int | None)
• repeat_penalty (float | None)

repeat_penalty = None

Bases: BaseModel

Configuration for an LLM provider.

Config:

• frozen: True
• allow_inf_nan: False
• extra: forbid

Fields:

• driver (NotBlankStr)
• litellm_provider (NotBlankStr | None)
• family (NotBlankStr | None)
• auth_type (AuthType)
• connection_name (NotBlankStr | None)
• subscription_token (NotBlankStr | None)
• tos_accepted_at (AwareDatetime | None)
• base_url (NotBlankStr | None)
• keep_alive (NotBlankStr | None)
• vram_guard (OllamaVramGuardConfig)
• oauth_token_url (NotBlankStr | None)
• oauth_client_id (NotBlankStr | None)
• oauth_client_secret (NotBlankStr | None)
• oauth_scope (NotBlankStr | None)
• custom_header_name (NotBlankStr | None)
• custom_header_value (NotBlankStr | None)
• models (tuple[ProviderModelConfig, ...])
• retry (RetryConfig)
• rate_limiter (RateLimiterConfig)
• subscription (SubscriptionConfig)
• degradation (DegradationConfig)
• defaults (ProviderModelDefaults)
• preset_name (NotBlankStr | None)

Validators:

• _validate_auth_fields
• _validate_unique_model_identifiers

driver = 'litellm'

litellm_provider = None

family = None

auth_type = AuthType.API_KEY

connection_name = None

subscription_token = None

tos_accepted_at = None

base_url = None

keep_alive = None

vram_guard

oauth_token_url = None

oauth_client_id = None

oauth_client_secret = None

oauth_scope = None

custom_header_name = None

custom_header_value = None

models = ()

retry

rate_limiter

subscription

degradation

defaults

preset_name = None

Bases: BaseModel

Configuration for a single LLM model within a provider.

Config:

• frozen: True
• allow_inf_nan: False
• extra: forbid

Fields:

• id (NotBlankStr)
• alias (NotBlankStr | None)
• cost_per_1k_input (float)
• cost_per_1k_output (float)
• max_context (int)
• estimated_latency_ms (int | None)
• local_params (LocalModelParams | None)
• metadata (ModelMetadata)
• stale (ModelStaleness | None)

id

alias = None

cost_per_1k_input = 0.0

cost_per_1k_output = 0.0

max_context = 200000

estimated_latency_ms = None

local_params = None

metadata

stale = None

Bases: BaseModel

Root company configuration -- the top-level validation target.

Aggregates all sub-configurations into a single frozen model that represents a fully validated company setup.

Attributes:

Config:

• frozen: True
• allow_inf_nan: False
• extra: forbid

Fields:

• company_name (NotBlankStr)
• company_type (CompanyType)
• departments (tuple[Department, ...])
• agents (tuple[AgentConfig, ...])
• custom_roles (tuple[CustomRole, ...])
• config (CompanyConfig)
• budget (BudgetConfig)
• communication (CommunicationConfig)
• providers (dict[str, ProviderConfig])
• routing (RoutingConfig)
• stakes_routing (StakesRoutingConfig)
• logging (LogConfig | None)
• audit_chain (AuditChainConfig)
• graceful_shutdown (GracefulShutdownConfig)
• workflow_handoffs (tuple[WorkflowHandoff, ...])
• escalation_paths (tuple[EscalationPath, ...])
• coordination_metrics (CoordinationMetricsConfig)
• task_assignment (TaskAssignmentConfig)
• memory (CompanyMemoryConfig)
• persistence (PersistenceConfig)
• cost_tiers (CostTiersConfig)
• org_memory (OrgMemoryConfig)
• api (ApiConfig)
• sandboxing (SandboxingConfig)
• mcp (MCPConfig)
• security (SecurityConfig)
• trust (TrustConfig)
• promotion (PromotionConfig)
• performance (PerformanceConfig)
• training (TrainingConfig)
• task_engine (TaskEngineConfig)
• recovery (EngineRecoveryConfig)
• queue (QueueConfig)
• coordination (CoordinationSectionConfig)
• evolution (EvolutionConfig)
• compaction (CompactionConfig)
• stagnation (StagnationDetectionConfig)
• strategy (StrategyConfig)
• knowledge (KnowledgeConfig)
• git_clone (GitCloneNetworkPolicy)
• backup (BackupConfig)
• workflow (WorkflowConfig)
• notifications (NotificationConfig)
• integrations (IntegrationsConfig)
• a2a (A2AConfig)
• ontology (OntologyConfig)
• telemetry (TelemetryConfig)
• web (WebToolsConfig | None)
• database (DatabaseConfig | None)
• terminal (TerminalConfig | None)
• design_tools (DesignToolsConfig | None)
• communication_tools (CommunicationToolsConfig | None)
• analytics_tools (AnalyticsToolsConfig | None)
• tool_disclosure (ToolDisclosureConfig)
• posture (PostureConfig)

Validators:

• _validate_unique_agent_names
• _validate_unique_department_names
• _validate_milestone_clean_history_windows
• _validate_queue_requires_distributed_bus
• _validate_routing_references
• _validate_degradation_fallback_providers

company_name

company_type = CompanyType.CUSTOM

departments = ()

agents = ()

custom_roles = ()

config

budget

communication

providers

routing

stakes_routing

logging = None

audit_chain

graceful_shutdown

workflow_handoffs = ()

escalation_paths = ()

coordination_metrics

task_assignment

memory

persistence

cost_tiers

org_memory

api

sandboxing

mcp

security

trust

promotion

performance

training

task_engine

recovery

queue

coordination

compaction

stagnation

strategy

knowledge

git_clone

backup

workflow

notifications

integrations

a2a

ontology

telemetry

web = None

database = None

terminal = None

design_tools = None

communication_tools = None

analytics_tools = None

tool_disclosure

Source location for a configuration error.

Attributes:

Bases: DomainError

Base exception for configuration errors.

Attributes:

44
45
46
47
48
49
50
51

def __init__(
    self,
    message: str,
    locations: tuple[ConfigLocation, ...] = (),
) -> None:
    self.message = message
    self.locations = locations
    super().__init__(message)

__str__()

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

@override
def __str__(self) -> str:
    """Format error message with source locations.

    Returns:
        The message alone when there are no locations, otherwise the
        message followed by one indented line per source location.
    """
    if not self.locations:
        return self.message
    parts = [self.message]
    for loc in self.locations:
        loc_parts: list[str] = []
        if loc.key_path:
            loc_parts.append(f"  {loc.key_path}")
        if loc.file_path:
            if loc.line is not None and loc.column is not None:
                line_info = f" at line {loc.line}, column {loc.column}"
            elif loc.line is not None:
                line_info = f" at line {loc.line}"
            else:
                line_info = ""
            loc_parts.append(f"    in {loc.file_path}{line_info}")
        parts.extend(loc_parts)
    return "\n".join(parts)

Bases: ConfigError

Raised when a configuration file does not exist.

44
45
46
47
48
49
50
51

def __init__(
    self,
    message: str,
    locations: tuple[ConfigLocation, ...] = (),
) -> None:
    self.message = message
    self.locations = locations
    super().__init__(message)

Bases: ConfigError

Raised when YAML parsing fails.

44
45
46
47
48
49
50
51

def __init__(
    self,
    message: str,
    locations: tuple[ConfigLocation, ...] = (),
) -> None:
    self.message = message
    self.locations = locations
    super().__init__(message)

Bases: ConfigError

Raised when Pydantic validation fails.

Attributes:

113
114
115
116
117
118
119
120

def __init__(
    self,
    message: str,
    locations: tuple[ConfigLocation, ...] = (),
    field_errors: tuple[tuple[str, str], ...] = (),
) -> None:
    super().__init__(message, locations)
    self.field_errors = field_errors

__str__()

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

@override
def __str__(self) -> str:
    """Format validation error with per-field details.

    Returns:
        The base location-formatted message when there are no field
        errors, otherwise a header line plus one indented line per
        ``(key_path, message)`` field error.
    """
    if not self.field_errors:
        return super().__str__()
    parts = [f"{self.message} ({len(self.field_errors)} errors):"]
    loc_by_key: dict[str, ConfigLocation] = {
        loc.key_path: loc for loc in self.locations if loc.key_path
    }
    for key_path, msg in self.field_errors:
        parts.append(f"  {key_path}: {msg}")
        loc = loc_by_key.get(key_path)
        if loc and loc.file_path:
            if loc.line is not None and loc.column is not None:
                line_info = f" at line {loc.line}, column {loc.column}"
            elif loc.line is not None:
                line_info = f" at line {loc.line}"
            else:
                line_info = ""
            parts.append(f"    in {loc.file_path}{line_info}")
    return "\n".join(parts)