class AppServerConfig(OpenHandsModel):
    persistence_dir: Path = Field(default_factory=get_default_persistence_dir)
    file_store: FileStore = Field(default_factory=_get_default_file_store)
    web_url: str | None = Field(
        default_factory=get_default_web_url,
        description='The URL where OpenHands is running',
    )
    permitted_cors_origins: list[str] = Field(
        default_factory=get_default_permitted_cors_origins,
        description='Additional permitted CORS origins...',
    )
    openhands_provider_base_url: str | None = Field(
        default_factory=get_openhands_provider_base_url,
    )
    tavily_api_key: str | None = Field(
        default_factory=get_default_tavily_api_key,
    )
    # Dependency Injection Injectors
    llm_model: LLMModelServiceInjector | None = None
    event: EventServiceInjector | None = None
    event_callback: EventCallbackServiceInjector | None = None
    sandbox: SandboxServiceInjector | None = None
    sandbox_spec: SandboxSpecServiceInjector | None = None
    app_conversation_info: AppConversationInfoServiceInjector | None = None
    app_conversation_start_task: AppConversationStartTaskServiceInjector | None = None
    app_conversation: AppConversationServiceInjector | None = None
    pending_message: PendingMessageServiceInjector | None = None
    user: UserContextInjector | None = None
    jwt: JwtServiceInjector | None = None
    httpx: HttpxClientInjector = Field(default_factory=HttpxClientInjector)
    db_session: DbSessionInjector = Field(
        default_factory=lambda: DbSessionInjector(
            persistence_dir=get_default_persistence_dir()
        )
    )
    # Services
    lifespan: AppLifespanService | None = Field(default_factory=_get_default_lifespan)
    app_mode: AppMode = AppMode.OPENHANDS
    web_client: WebClientConfigInjector = Field(
        default_factory=DefaultWebClientConfigInjector
    )

def get_default_persistence_dir() -> Path:
    persistence_dir = os.getenv('OH_PERSISTENCE_DIR')
    # Legacy V0 fallback variable
    if persistence_dir is None:
        persistence_dir = os.getenv('FILE_STORE_PATH')
    if persistence_dir:
        result = Path(persistence_dir)
    else:
        result = Path.home() / '.openhands'
    result.mkdir(parents=True, exist_ok=True)
    return result

def config_from_env() -> AppServerConfig:
    # Import defaults...
    config: AppServerConfig = from_env(AppServerConfig, 'OH')

    if config.llm_model is None:
        llm_model_kwargs: dict = {}
        aws_region = os.getenv('AWS_REGION_NAME')
        aws_key = os.getenv('AWS_ACCESS_KEY_ID')
        aws_secret = os.getenv('AWS_SECRET_ACCESS_KEY')
        if aws_region and aws_key and aws_secret:
            llm_model_kwargs['aws_region_name'] = aws_region
            llm_model_kwargs['aws_access_key_id'] = SecretStr(aws_key)
            llm_model_kwargs['aws_secret_access_key'] = SecretStr(aws_secret)
        ollama_url = os.getenv('OLLAMA_BASE_URL')
        if ollama_url:
            llm_model_kwargs['ollama_base_url'] = ollama_url
        config.llm_model = DefaultLLMModelServiceInjector(**llm_model_kwargs)

    if config.event is None:
        provider = get_storage_provider()
        if provider == StorageProvider.AWS:
            config.event = AwsEventServiceInjector(bucket_name=bucket_name)
        elif provider == StorageProvider.GCP:
            config.event = GoogleCloudEventServiceInjector(bucket_name=bucket_name)
        else:
            config.event = FilesystemEventServiceInjector()
    # ... sandbox, conversation, user 等注入器依次装配
    return config

if config.sandbox is None:
    # Legacy fallback
    if os.getenv('RUNTIME') == 'remote':
        config.sandbox = RemoteSandboxServiceInjector(
            api_key=os.environ['SANDBOX_API_KEY'],
            api_url=os.environ['SANDBOX_REMOTE_RUNTIME_API_URL'],
        )
    elif os.getenv('RUNTIME') in ('local', 'process'):
        config.sandbox = ProcessSandboxServiceInjector()
    else:
        # Docker sandbox with legacy env var support
        docker_sandbox_kwargs: dict = {}
        if os.getenv('SANDBOX_HOST_PORT'):
            docker_sandbox_kwargs['host_port'] = int(os.environ['SANDBOX_HOST_PORT'])
        if os.getenv('SANDBOX_STARTUP_GRACE_SECONDS'):
            docker_sandbox_kwargs['startup_grace_seconds'] = int(
                os.environ['SANDBOX_STARTUP_GRACE_SECONDS']
            )
        # Parse SANDBOX_VOLUMES for --mount-cwd support
        sandbox_volumes = os.getenv('SANDBOX_VOLUMES')
        if sandbox_volumes:
            mounts = []
            for mount_spec in sandbox_volumes.split(','):
                parts = mount_spec.split(':')
                if len(parts) >= 2:
                    mounts.append(VolumeMount(
                        host_path=parts[0],
                        container_path=parts[1],
                        mode=parts[2] if len(parts) > 2 else 'rw',
                    ))
            if mounts:
                docker_sandbox_kwargs['mounts'] = mounts
        config.sandbox = DockerSandboxServiceInjector(**docker_sandbox_kwargs)

class ServerConfig(ServerConfigInterface):
    config_cls = os.environ.get('OPENHANDS_CONFIG_CLS', None)
    app_mode = AppMode.OPENHANDS
    posthog_client_key = 'phc_3ESMmY9SgqEAGBB6sMGK5ayYHkeUuknH2vP6FmWH9RA'
    github_client_id = os.environ.get('GITHUB_APP_CLIENT_ID', '')
    enable_billing = os.environ.get('ENABLE_BILLING', 'false') == 'true'
    hide_llm_settings = os.environ.get('HIDE_LLM_SETTINGS', 'false') == 'true'
    # Pluggable class names
    settings_store_class: str = (
        'openhands.app_server.settings.file_settings_store.FileSettingsStore'
    )
    secret_store_class: str = (
        'openhands.app_server.secrets.file_secrets_store.FileSecretsStore'
    )
    user_auth_class: str = (
        'openhands.app_server.user_auth.default_user_auth.DefaultUserAuth'
    )
    enable_v1: bool = os.getenv('ENABLE_V1') != '0'

    def verify_config(self):
        if self.config_cls:
            raise ValueError('Unexpected config path provided')

    def get_config(self):
        return {
            'APP_MODE': self.app_mode,
            'GITHUB_CLIENT_ID': self.github_client_id,
            'FEATURE_FLAGS': {
                'ENABLE_BILLING': self.enable_billing,
                'HIDE_LLM_SETTINGS': self.hide_llm_settings,
            },
        }

def load_server_config() -> ServerConfig:
    config_cls = os.environ.get('OPENHANDS_CONFIG_CLS', None)
    server_config_cls = get_impl(ServerConfig, config_cls)
    server_config: ServerConfig = server_config_cls()
    server_config.verify_config()
    return server_config

class SettingsStore(ABC):
    @abstractmethod
    async def load(
        self,
        *,
        resolve_agent_profile: bool = False,
        override_agent_profile_id: str | None = None,
    ) -> Settings | None:
        """Load session init data.
        resolve_agent_profile=True opts into the effective launch view.
        """

    @abstractmethod
    async def store(self, settings: Settings) -> None:
        """Store session init data."""

    @classmethod
    @abstractmethod
    async def get_instance(cls, user_id: str | None) -> SettingsStore:
        """Get a store for the user represented by the token."""

    @abstractmethod
    async def get_org_marketplaces(self, user_id: str | None) -> list[dict]:
        """Get organization-level marketplaces."""

@dataclass
class FileSettingsStore(SettingsStore):
    file_store: FileStore
    path: str = 'settings.json'

    async def load(self, *, resolve_agent_profile=False, ...) -> Settings | None:
        try:
            json_str = await call_sync_from_async(self.file_store.read, self.path)
            kwargs = json.loads(json_str)
            # Migrate legacy agent_settings.llm to llm_profiles
            if 'llm_profiles' not in kwargs:
                legacy_llm = (kwargs.get('agent_settings') or {}).get('llm')
                if isinstance(legacy_llm, dict) and legacy_llm.get('model'):
                    kwargs['llm_profiles'] = {
                        'profiles': {'Default': legacy_llm},
                        'active': 'Default',
                    }
            settings = Settings(**kwargs)
            settings.v1_enabled = True
            return settings
        except FileNotFoundError:
            return None

    async def store(self, settings: Settings) -> None:
        json_str = settings.model_dump_json(
            context={'expose_secrets': True, 'persist_settings': True}
        )
        await call_sync_from_async(self.file_store.write, self.path, json_str)

# Create router with /api/v1/settings prefix
router = APIRouter(
    prefix='/settings',
    tags=['Settings'],
    dependencies=get_dependencies(),
)

    existing_settings = await settings_store.load()
    settings = existing_settings.model_copy() if existing_settings else Settings()
    settings.update(payload)

_user_profile_locks: defaultdict[str, asyncio.Lock] = defaultdict(asyncio.Lock)

def _profile_lock_key(user_id: str | None) -> str:
    return user_id or '<anonymous>'

[core]
  # workspace_base, cache_dir, debug, runtime, jwt_secret, ...
  runtime = "docker"
  max_iterations = 500
  max_budget_per_task = 0.0
  max_concurrent_conversations = 3

[agent]
  # Tool enable/disable flags
  enable_browsing = true
  enable_cmd = true
  enable_jupyter = true
  enable_history_truncation = true

[sandbox]
  # Container image, GPU, volumes, timeouts
  base_container_image = "nikolaik/python-nodejs:..."
  enable_gpu = false
  close_delay = 300

[security]
  confirmation_mode = false
  security_analyzer = "llm"

[condenser]
  type = "noop"
  # Options: noop, observation_masking, recent, llm, amortized, llm_attention

[kubernetes]
  # K8s namespace, PVC, resource limits, tolerations
  namespace = "default"
  pvc_storage_size = "2Gi"

[mcp]
  # SSE/SHTTP/Stdio MCP server configuration