Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

200 KB
Raw Blame
"""Unit tests for core/config.py configuration functions."""

import logging
import os
import subprocess
import sys
import tempfile
from pathlib import Path
from tempfile import gettempdir

import pytest

import xagent.config as config
from xagent.config import (
    AGENT_RUNTIME,
    APP_BASE_URL,
    BACKGROUND_JOB_MAX_RETRIES,
    BACKGROUND_JOB_STALE_SECONDS,
    BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS,
    BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS,
    BROWSER_CUA_DRIVER_COMMAND,
    BROWSER_CUA_DRIVER_MAX_ELEMENTS,
    BROWSER_CUA_DRIVER_SOCKET,
    BROWSER_CUA_DRIVER_TIMEOUT_SECONDS,
    CELERY_BROKER_URL,
    CELERY_ENABLED,
    CELERY_RESULT_BACKEND,
    CORS_ORIGINS,
    DATABASE_URL,
    DB_MAX_OVERFLOW,
    DB_POOL_SIZE,
    DB_POOL_TIMEOUT_SECONDS,
    DEEPDOC_XINFERENCE_API_KEY,
    DEEPDOC_XINFERENCE_MODEL_UID,
    DEEPDOC_XINFERENCE_PASSWORD,
    DEEPDOC_XINFERENCE_TIMEOUT_SECONDS,
    DEEPDOC_XINFERENCE_URL,
    DEEPDOC_XINFERENCE_USERNAME,
    EXTERNAL_MEDIA_URL_TTL_SECONDS,
    EXTERNAL_SKILLS_LIBRARY_DIRS,
    EXTERNAL_UPLOAD_DIRS,
    FILE_DELIVERY_ACCEL_REDIRECT_ENABLED,
    FILE_DELIVERY_ACCEL_REDIRECT_PREFIX,
    FILE_DELIVERY_REDIRECT_ENABLED,
    FILE_DELIVERY_SIGNED_URL_TTL_SECONDS,
    FILE_MATERIALIZE_DIR,
    FILE_STORAGE_OPTIONS,
    FILE_STORAGE_STARTUP_SYNC_ENABLED,
    FILE_STORAGE_URI,
    FILE_STREAM_TICKET_TTL_SECONDS,
    FORM_ANSWER_CONTINUATION_ENABLED,
    FRONTEND_DIST_DIR,
    GMAIL_PUBSUB_PROJECT_ID,
    GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT,
    GMAIL_PUBSUB_SUBSCRIPTION_PREFIX,
    GMAIL_PUBSUB_TOPIC_PREFIX,
    GMAIL_REGISTRATION_TIMEOUT_SECONDS,
    HOT_PATH_CACHE_ENABLED,
    HOT_PATH_CACHE_TTL_SECONDS,
    HOT_PATH_TASK_CACHE_TTL_SECONDS,
    KB_COLLECTIONS_TIMEOUT_SECONDS,
    KB_MIGRATION_DEFER_BUDGET_SECONDS,
    KB_MIGRATION_DEFER_DELAY_SECONDS,
    KB_MILVUS_CLEANUP_ENABLED,
    KB_MILVUS_CLEANUP_INTERVAL_SECONDS,
    KB_SEARCH_TIMEOUT_SECONDS,
    LANCEDB_PATH,
    MAX_TRACE_PAYLOAD_BYTES,
    MAX_UPLOAD_SIZE,
    MCP_OAUTH_ALLOW_PRIVATE_HOSTS,
    MCP_OAUTH_PROXY_URL,
    MCP_TOOL_INIT_TIMEOUT_SECONDS,
    NATIVE_BROWSER_APP_NAME,
    NATIVE_BROWSER_ENABLED,
    OPENROUTER_OFFICIAL_PROVIDERS_ONLY,
    PASSWORD_RESET_EXPIRE_MINUTES,
    PREVIEW_TMP_DIR,
    PUBLIC_API_BASE_URL,
    REDIS_URL,
    S2S_API_BASE_URL,
    SANDBOX_CPUS,
    SANDBOX_ENV,
    SANDBOX_HOST_PROJECT_ROOT,
    SANDBOX_HOST_STORAGE_ROOT,
    SANDBOX_IDLE_TTL,
    SANDBOX_IMAGE,
    SANDBOX_MAX_CONTAINERS,
    SANDBOX_MEMORY,
    SANDBOX_NAMESPACE,
    SANDBOX_NETWORK,
    SANDBOX_SWEEP_INTERVAL,
    SANDBOX_TOOL_RUNNER,
    SANDBOX_VOLUMES,
    SANDBOX_WORKSPACE_MOUNT_MODE,
    SANDBOX_WORKSPACE_VOLUME,
    SANDBOX_WORKSPACE_VOLUME_ROOT,
    SLACK_APP_TOKEN,
    SLACK_CLIENT_ID,
    SLACK_CLIENT_SECRET,
    SLACK_REDIRECT_URI,
    SMTP_FROM_EMAIL,
    SMTP_FROM_NAME,
    SMTP_HOST,
    SMTP_PASSWORD,
    SMTP_PORT,
    SMTP_USE_SSL,
    SMTP_USE_TLS,
    SMTP_USERNAME,
    STORAGE_ROOT,
    TASK_LEASE_RECOVERY_BATCH_SIZE,
    TASK_LEASE_RECOVERY_INTERVAL_SECONDS,
    TASK_LEASE_TTL_SECONDS,
    TASK_RUNTIME_HOOK_MAX_WORKERS,
    TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS,
    TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS,
    TRIGGER_DISPATCHER_BATCH_SIZE,
    TRIGGER_DISPATCHER_ENABLED,
    TRIGGER_DISPATCHER_INTERVAL_SECONDS,
    TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS,
    TRUSTED_EGRESS_PROXY,
    UPLOADED_FILE_RECOVERY_BATCH_SIZE,
    UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS,
    UPLOADED_FILE_RECOVERY_STALE_SECONDS,
    UPLOADS_DIR,
    WEB_CRAWL_TLS_IMPERSONATE,
    WEB_DIR,
    WEB_SEARCH_PROVIDER,
    WEB_SEARCH_PROVIDERS,
    XROUTER_EXCLUDED_MODELS,
    ExternalUploadsDirConfigurationError,
    format_file_size,
    get_agent_pattern_for_execution_mode,
    get_agent_runtime,
    get_app_base_url,
    get_background_job_max_retries,
    get_background_job_stale_seconds,
    get_background_job_sweep_interval_seconds,
    get_background_job_visibility_timeout_seconds,
    get_brave_search_country,
    get_brave_search_endpoint,
    get_browser_cua_driver_command,
    get_browser_cua_driver_max_elements,
    get_browser_cua_driver_socket,
    get_browser_cua_driver_timeout_seconds,
    get_celery_broker_url,
    get_celery_enabled,
    get_celery_result_backend,
    get_cors_origins,
    get_database_url,
    get_db_max_overflow,
    get_db_pool_size,
    get_db_pool_timeout_seconds,
    get_deepdoc_xinference_api_key,
    get_deepdoc_xinference_model_uid,
    get_deepdoc_xinference_password,
    get_deepdoc_xinference_timeout_seconds,
    get_deepdoc_xinference_url,
    get_deepdoc_xinference_username,
    get_default_sqlite_db_path,
    get_default_task_execution_mode,
    get_external_skills_dirs,
    get_external_upload_dirs,
    get_file_delivery_accel_redirect_enabled,
    get_file_delivery_accel_redirect_prefix,
    get_file_delivery_redirect_enabled,
    get_file_delivery_signed_url_ttl_seconds,
    get_file_materialize_dir,
    get_file_storage_options,
    get_file_storage_startup_sync_enabled,
    get_file_storage_uri,
    get_file_stream_ticket_ttl_seconds,
    get_form_answer_continuation_enabled,
    get_frontend_dist_dir,
    get_gmail_pubsub_project_id,
    get_gmail_pubsub_push_service_account,
    get_gmail_pubsub_subscription_prefix,
    get_gmail_pubsub_topic_prefix,
    get_gmail_registration_timeout_seconds,
    get_hot_path_cache_enabled,
    get_hot_path_cache_ttl_seconds,
    get_hot_path_task_cache_ttl_seconds,
    get_kb_collections_timeout_seconds,
    get_kb_migration_defer_budget_seconds,
    get_kb_migration_defer_delay_seconds,
    get_kb_milvus_cleanup_enabled,
    get_kb_milvus_cleanup_interval_seconds,
    get_kb_search_timeout_seconds,
    get_lancedb_path,
    get_max_trace_payload_bytes,
    get_max_upload_size_bytes,
    get_mcp_oauth_allow_private_hosts,
    get_mcp_oauth_proxy_url,
    get_mcp_tool_init_timeout_seconds,
    get_native_browser_app_name,
    get_native_browser_enabled,
    get_openrouter_official_providers_only,
    get_password_reset_expire_minutes,
    get_preview_tmp_dir,
    get_public_api_base_url,
    get_redis_url,
    get_s2s_api_base_url,
    get_sandbox_cpus,
    get_sandbox_env,
    get_sandbox_host_project_root,
    get_sandbox_host_storage_root,
    get_sandbox_idle_ttl,
    get_sandbox_image,
    get_sandbox_max_containers,
    get_sandbox_memory,
    get_sandbox_namespace,
    get_sandbox_network,
    get_sandbox_sweep_interval,
    get_sandbox_volumes,
    get_sandbox_workspace_mount_mode,
    get_sandbox_workspace_volume,
    get_sandbox_workspace_volume_root,
    get_slack_app_token,
    get_slack_client_id,
    get_slack_client_secret,
    get_slack_oauth_redirect_uri,
    get_smtp_from_email,
    get_smtp_from_name,
    get_smtp_host,
    get_smtp_password,
    get_smtp_port,
    get_smtp_use_ssl,
    get_smtp_use_tls,
    get_smtp_username,
    get_storage_root,
    get_task_lease_recovery_batch_size,
    get_task_lease_recovery_interval_seconds,
    get_task_runtime_hook_max_workers,
    get_task_runtime_hook_queue_timeout_seconds,
    get_temp_file_cleanup_shutdown_timeout_seconds,
    get_trigger_dispatcher_batch_size,
    get_trigger_dispatcher_enabled,
    get_trigger_dispatcher_interval_seconds,
    get_trigger_dispatcher_startup_jitter_seconds,
    get_trusted_egress_proxy_enabled,
    get_uploaded_file_recovery_batch_size,
    get_uploaded_file_recovery_interval_seconds,
    get_uploaded_file_recovery_stale_seconds,
    get_uploads_dir,
    get_web_crawl_tls_impersonate,
    get_web_dir,
    get_web_search_provider,
    get_xrouter_excluded_models,
    in_sandbox_tool_runner,
    validate_sandbox_namespace,
    validate_sandbox_network,
)


@pytest.mark.parametrize("value", ["0", "-1", "garbage"])
def test_artifact_validation_byte_budget_invalid(monkeypatch, value):
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
    with pytest.raises(ValueError):
        config.get_artifact_validation_max_bytes()


@pytest.mark.parametrize("value", ["0", "-1", "nan", "inf", "garbage"])
def test_artifact_validation_timeout_invalid(monkeypatch, value):
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", value)
    with pytest.raises(ValueError):
        config.get_artifact_validation_timeout_seconds()


def test_artifact_validation_defaults_and_overrides(monkeypatch):
    monkeypatch.delenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", raising=False)
    monkeypatch.delenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", raising=False)
    assert config.get_artifact_validation_max_bytes() == 32 * 1024 * 1024
    assert config.get_artifact_validation_timeout_seconds() == 8
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", "")
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", "")
    assert config.get_artifact_validation_max_bytes() == 32 * 1024 * 1024
    assert config.get_artifact_validation_timeout_seconds() == 8
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", "1024")
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", "0.5")
    assert config.get_artifact_validation_max_bytes() == 1024
    assert config.get_artifact_validation_timeout_seconds() == 0.5


@pytest.mark.parametrize(
    "value,expected",
    [("32M", 32 * 1024**2), ("1.5MB", 1572864), ("512K", 524288), ("1024", 1024)],
)
def test_artifact_validation_and_upload_share_size_parser(monkeypatch, value, expected):
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
    monkeypatch.setenv("XAGENT_MAX_UPLOAD_SIZE", value)
    assert config.get_artifact_validation_max_bytes() == expected
    assert config.get_max_upload_size_bytes() == expected


@pytest.mark.parametrize("value", ["inf", "infM", "nan", "nanM", "-1M"])
def test_artifact_validation_size_rejects_invalid_and_nonfinite(monkeypatch, value):
    monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
    with pytest.raises(ValueError):
        config.get_artifact_validation_max_bytes()


@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_google_scope_config(monkeypatch, value):
    flag = "XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED"
    if value is None:
        monkeypatch.delenv(flag, raising=False)
    else:
        monkeypatch.setenv(flag, value)

    assert flag == config.GOOGLE_RESTRICTED_SCOPES_ENABLED
    assert config.get_google_restricted_scopes() is (value in {"true", "1", "ON"})


@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_google_shared_oauth_grants_config(monkeypatch, value):
    flag = "XAGENT_GOOGLE_SHARED_OAUTH_GRANTS_ENABLED"
    if value is None:
        monkeypatch.delenv(flag, raising=False)
    else:
        monkeypatch.setenv(flag, value)

    assert flag == config.GOOGLE_SHARED_OAUTH_GRANTS_ENABLED
    assert config.get_google_shared_oauth_grants_enabled() is (
        value in {"true", "1", "ON"}
    )


@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_zoom_meeting_write_config(monkeypatch, value):
    flag = "XAGENT_ZOOM_MEETING_WRITE_ENABLED"
    if value is None:
        monkeypatch.delenv(flag, raising=False)
    else:
        monkeypatch.setenv(flag, value)

    assert flag == config.ZOOM_MEETING_WRITE_ENABLED
    assert config.get_zoom_meeting_write_enabled() is (value in {"true", "1", "ON"})


class TestEnvironmentVariableConstants:
    """Test environment variable constant names."""

    def test_upload_dir_constant(self):
        assert UPLOADS_DIR == "XAGENT_UPLOADS_DIR"

    def test_web_dir_constant(self):
        assert WEB_DIR == "XAGENT_WEB_DIR"

    def test_frontend_dist_dir_constant(self):
        assert FRONTEND_DIST_DIR == "XAGENT_FRONTEND_DIST_DIR"

    def test_external_upload_dirs_constant(self):
        assert EXTERNAL_UPLOAD_DIRS == "XAGENT_EXTERNAL_UPLOAD_DIRS"

    def test_external_skills_dirs_constant(self):
        assert EXTERNAL_SKILLS_LIBRARY_DIRS == "XAGENT_EXTERNAL_SKILLS_LIBRARY_DIRS"

    def test_agent_runtime_constant(self):
        assert AGENT_RUNTIME == "XAGENT_AGENT_RUNTIME"

    def test_storage_root_constant(self):
        assert STORAGE_ROOT == "XAGENT_STORAGE_ROOT"

    def test_local_browser_constants(self):
        assert NATIVE_BROWSER_ENABLED == "XAGENT_NATIVE_BROWSER_ENABLED"
        assert NATIVE_BROWSER_APP_NAME == "XAGENT_NATIVE_BROWSER_APP_NAME"
        assert BROWSER_CUA_DRIVER_COMMAND == "XAGENT_BROWSER_CUA_DRIVER_COMMAND"
        assert BROWSER_CUA_DRIVER_SOCKET == "XAGENT_BROWSER_CUA_DRIVER_SOCKET"
        assert (
            BROWSER_CUA_DRIVER_TIMEOUT_SECONDS
            == "XAGENT_BROWSER_CUA_DRIVER_TIMEOUT_SECONDS"
        )
        assert (
            BROWSER_CUA_DRIVER_MAX_ELEMENTS == "XAGENT_BROWSER_CUA_DRIVER_MAX_ELEMENTS"
        )

    def test_sandbox_image_constant(self):
        assert SANDBOX_IMAGE == "SANDBOX_IMAGE"

    def test_sandbox_host_project_root_constant(self):
        assert SANDBOX_HOST_PROJECT_ROOT == "XAGENT_SANDBOX_HOST_PROJECT_ROOT"

    def test_sandbox_namespace_constant(self):
        assert SANDBOX_NAMESPACE == "XAGENT_SANDBOX_NAMESPACE"

    def test_sandbox_network_constant(self):
        assert SANDBOX_NETWORK == "XAGENT_SANDBOX_NETWORK"

    def test_sandbox_host_storage_root_constant(self):
        assert SANDBOX_HOST_STORAGE_ROOT == "XAGENT_SANDBOX_HOST_STORAGE_ROOT"

    def test_sandbox_tool_runner_constant(self):
        assert SANDBOX_TOOL_RUNNER == "XAGENT_SANDBOX_TOOL_RUNNER"

    def test_in_sandbox_tool_runner_defaults_to_false(self):
        assert in_sandbox_tool_runner() is False

    def test_in_sandbox_tool_runner_reads_the_env_at_process_start(self, monkeypatch):
        for value, expected in (
            ("1", True),
            ("true", True),
            ("yes", True),
            ("on", True),
            ("0", False),
            ("false", False),
            ("no", False),
            ("off", False),
            ("", False),
        ):
            monkeypatch.setenv(SANDBOX_TOOL_RUNNER, value)
            assert config._get_bool_env(SANDBOX_TOOL_RUNNER, False) is expected

    def test_in_sandbox_tool_runner_ignores_later_env_mutation(self, monkeypatch):
        """Agent-authored code runs late; it must not flip the whole process."""
        monkeypatch.setenv(SANDBOX_TOOL_RUNNER, "1")
        assert in_sandbox_tool_runner() is False

    def test_in_sandbox_tool_runner_does_read_the_env_at_import(self):
        """The other tests patch the snapshot, so pin that it is populated."""
        probe = "import xagent.config as c; print(c.in_sandbox_tool_runner())"
        env = {**os.environ, SANDBOX_TOOL_RUNNER: "1"}
        proc = subprocess.run(
            [sys.executable, "-c", probe],
            capture_output=True,
            text=True,
            env=env,
            check=True,
        )
        assert proc.stdout.strip() == "True"

    def test_lancedb_path_constant(self):
        assert LANCEDB_PATH == "LANCEDB_PATH"

    def test_database_url_constant(self):
        assert DATABASE_URL == "DATABASE_URL"

    def test_task_lease_recovery_constants(self):
        assert (
            TASK_LEASE_RECOVERY_INTERVAL_SECONDS
            == "XAGENT_TASK_LEASE_RECOVERY_INTERVAL_SECONDS"
        )
        assert TASK_LEASE_RECOVERY_BATCH_SIZE == "XAGENT_TASK_LEASE_RECOVERY_BATCH_SIZE"

    def test_uploaded_file_recovery_constants(self):
        assert (
            UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS
            == "XAGENT_UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS"
        )
        assert (
            UPLOADED_FILE_RECOVERY_STALE_SECONDS
            == "XAGENT_UPLOADED_FILE_RECOVERY_STALE_SECONDS"
        )
        assert (
            UPLOADED_FILE_RECOVERY_BATCH_SIZE
            == "XAGENT_UPLOADED_FILE_RECOVERY_BATCH_SIZE"
        )

    def test_max_upload_size_constant(self):
        assert MAX_UPLOAD_SIZE == "XAGENT_MAX_UPLOAD_SIZE"

    def test_web_search_provider_constant(self):
        assert WEB_SEARCH_PROVIDER == "XAGENT_WEB_SEARCH_PROVIDER"

    def test_web_crawl_tls_impersonate_constant(self):
        assert WEB_CRAWL_TLS_IMPERSONATE == "XAGENT_WEB_CRAWL_TLS_IMPERSONATE"

    def test_openrouter_official_providers_only_constant(self):
        assert (
            OPENROUTER_OFFICIAL_PROVIDERS_ONLY
            == "XAGENT_OPENROUTER_OFFICIAL_PROVIDERS_ONLY"
        )

    def test_xrouter_excluded_models_constant(self):
        assert XROUTER_EXCLUDED_MODELS == "XAGENT_XROUTER_EXCLUDED_MODELS"

    def test_mcp_oauth_allow_private_hosts_constant(self):
        assert MCP_OAUTH_ALLOW_PRIVATE_HOSTS == "XAGENT_MCP_OAUTH_ALLOW_PRIVATE_HOSTS"

    def test_mcp_oauth_proxy_url_constant(self):
        assert MCP_OAUTH_PROXY_URL == "XAGENT_MCP_OAUTH_PROXY_URL"

    def test_file_storage_uri_constant(self):
        assert FILE_STORAGE_URI == "XAGENT_FILE_STORAGE_URI"

    def test_file_storage_options_constant(self):
        assert FILE_STORAGE_OPTIONS == "XAGENT_FILE_STORAGE_OPTIONS"

    def test_file_materialize_dir_constant(self):
        assert FILE_MATERIALIZE_DIR == "XAGENT_FILE_MATERIALIZE_DIR"

    def test_preview_tmp_dir_constant(self):
        assert PREVIEW_TMP_DIR == "XAGENT_PREVIEW_TMP_DIR"

    def test_file_storage_startup_sync_enabled_constant(self):
        assert (
            FILE_STORAGE_STARTUP_SYNC_ENABLED
            == "XAGENT_FILE_STORAGE_STARTUP_SYNC_ENABLED"
        )

    def test_file_delivery_accel_redirect_constants(self):
        assert (
            FILE_DELIVERY_ACCEL_REDIRECT_ENABLED
            == "XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_ENABLED"
        )
        assert (
            FILE_DELIVERY_ACCEL_REDIRECT_PREFIX
            == "XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_PREFIX"
        )

    def test_redis_url_constant(self):
        assert REDIS_URL == "XAGENT_REDIS_URL"

    def test_hot_path_cache_constants(self):
        assert HOT_PATH_CACHE_ENABLED == "XAGENT_HOT_PATH_CACHE_ENABLED"
        assert HOT_PATH_CACHE_TTL_SECONDS == "XAGENT_HOT_PATH_CACHE_TTL_SECONDS"
        assert (
            HOT_PATH_TASK_CACHE_TTL_SECONDS == "XAGENT_HOT_PATH_TASK_CACHE_TTL_SECONDS"
        )

    def test_celery_background_job_constants(self):
        assert CELERY_ENABLED == "XAGENT_CELERY_ENABLED"
        assert CELERY_BROKER_URL == "XAGENT_CELERY_BROKER_URL"
        assert CELERY_RESULT_BACKEND == "XAGENT_CELERY_RESULT_BACKEND"
        assert (
            BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS
            == "XAGENT_BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS"
        )
        assert BACKGROUND_JOB_MAX_RETRIES == "XAGENT_BACKGROUND_JOB_MAX_RETRIES"
        assert BACKGROUND_JOB_STALE_SECONDS == "XAGENT_BACKGROUND_JOB_STALE_SECONDS"
        assert (
            BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS
            == "XAGENT_BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS"
        )
        assert (
            KB_MIGRATION_DEFER_DELAY_SECONDS
            == "XAGENT_KB_MIGRATION_DEFER_DELAY_SECONDS"
        )
        assert (
            KB_MIGRATION_DEFER_BUDGET_SECONDS
            == "XAGENT_KB_MIGRATION_DEFER_BUDGET_SECONDS"
        )
        assert TRIGGER_DISPATCHER_ENABLED == "XAGENT_TRIGGER_DISPATCHER_ENABLED"
        assert (
            TRIGGER_DISPATCHER_INTERVAL_SECONDS
            == "XAGENT_TRIGGER_DISPATCHER_INTERVAL_SECONDS"
        )
        assert TRIGGER_DISPATCHER_BATCH_SIZE == "XAGENT_TRIGGER_DISPATCHER_BATCH_SIZE"

    def test_auth_email_config_constants(self):
        assert PASSWORD_RESET_EXPIRE_MINUTES == "XAGENT_PASSWORD_RESET_EXPIRE_MINUTES"
        assert APP_BASE_URL == "XAGENT_APP_BASE_URL"
        assert SMTP_HOST == "XAGENT_SMTP_HOST"
        assert SMTP_PORT == "XAGENT_SMTP_PORT"
        assert SMTP_USERNAME == "XAGENT_SMTP_USERNAME"
        assert SMTP_PASSWORD == "XAGENT_SMTP_PASSWORD"
        assert SMTP_USE_TLS == "XAGENT_SMTP_USE_TLS"
        assert SMTP_USE_SSL == "XAGENT_SMTP_USE_SSL"
        assert SMTP_FROM_EMAIL == "XAGENT_SMTP_FROM_EMAIL"
        assert SMTP_FROM_NAME == "XAGENT_SMTP_FROM_NAME"

    def test_slack_oauth_config_constants(self):
        assert SLACK_CLIENT_ID == "XAGENT_SLACK_CLIENT_ID"
        assert SLACK_CLIENT_SECRET == "XAGENT_SLACK_CLIENT_SECRET"
        assert SLACK_APP_TOKEN == "XAGENT_SLACK_APP_TOKEN"
        assert SLACK_REDIRECT_URI == "XAGENT_SLACK_REDIRECT_URI"


class TestAuthEmailConfig:
    def test_password_reset_expire_minutes_defaults_to_30(self, monkeypatch):
        monkeypatch.delenv(PASSWORD_RESET_EXPIRE_MINUTES, raising=False)
        assert get_password_reset_expire_minutes() == 30

    @pytest.mark.parametrize("value", ["abc", "0", "-5"])
    def test_password_reset_expire_minutes_invalid_values_fall_back(
        self, monkeypatch, value
    ):
        monkeypatch.setenv(PASSWORD_RESET_EXPIRE_MINUTES, value)
        assert get_password_reset_expire_minutes() == 30

    def test_app_base_url_returns_none_when_unset_or_blank(self, monkeypatch):
        monkeypatch.delenv(APP_BASE_URL, raising=False)
        assert get_app_base_url() is None

        monkeypatch.setenv(APP_BASE_URL, "   ")
        assert get_app_base_url() is None

    def test_app_base_url_strips_and_removes_trailing_slash(self, monkeypatch):
        monkeypatch.setenv(APP_BASE_URL, " https://app.example.com/base/ ")
        assert get_app_base_url() == "https://app.example.com/base"

    def test_slack_oauth_config_defaults_to_unconfigured(self, monkeypatch):
        for env_name in (
            SLACK_CLIENT_ID,
            SLACK_CLIENT_SECRET,
            SLACK_APP_TOKEN,
            SLACK_REDIRECT_URI,
            PUBLIC_API_BASE_URL,
        ):
            monkeypatch.delenv(env_name, raising=False)

        assert get_slack_client_id() is None
        assert get_slack_client_secret() is None
        assert get_slack_app_token() is None
        assert get_slack_oauth_redirect_uri() is None

    def test_cors_origins_default_to_frontend_url(self, monkeypatch):
        monkeypatch.delenv(CORS_ORIGINS, raising=False)
        monkeypatch.setenv("XAGENT_FRONTEND_URL", " https://app.example.com/ ")
        assert get_cors_origins() == ["https://app.example.com"]

    def test_cors_origins_parse_explicit_list(self, monkeypatch):
        monkeypatch.setenv(
            CORS_ORIGINS,
            " https://app.example.com/ , https://admin.example.com ",
        )
        assert get_cors_origins() == [
            "https://app.example.com",
            "https://admin.example.com",
        ]

    def test_cors_origins_treat_blank_as_unset(self, monkeypatch):
        monkeypatch.setenv(CORS_ORIGINS, "")
        monkeypatch.setenv("XAGENT_FRONTEND_URL", "https://app.example.com")
        assert get_cors_origins() == ["https://app.example.com"]

    def test_cors_origins_reject_wildcard_with_credentials(self, monkeypatch):
        monkeypatch.setenv(CORS_ORIGINS, "*")
        with pytest.raises(ValueError, match=r"cannot contain '\*'"):
            get_cors_origins()

    def test_slack_oauth_config_uses_explicit_values(self, monkeypatch):
        monkeypatch.setenv(SLACK_CLIENT_ID, " client-id ")
        monkeypatch.setenv(SLACK_CLIENT_SECRET, " client-secret ")
        monkeypatch.setenv(SLACK_APP_TOKEN, " xapp-test ")
        monkeypatch.setenv(
            SLACK_REDIRECT_URI,
            " https://api.example.com/api/channels/slack/oauth/callback/ ",
        )

        assert get_slack_client_id() == "client-id"
        assert get_slack_client_secret() == "client-secret"
        assert get_slack_app_token() == "xapp-test"
        assert (
            get_slack_oauth_redirect_uri()
            == "https://api.example.com/api/channels/slack/oauth/callback"
        )

    def test_slack_redirect_uri_falls_back_to_public_api_base(self, monkeypatch):
        monkeypatch.delenv(SLACK_REDIRECT_URI, raising=False)
        monkeypatch.setenv(PUBLIC_API_BASE_URL, " https://api.example.com/ ")

        assert (
            get_slack_oauth_redirect_uri()
            == "https://api.example.com/api/channels/slack/oauth/callback"
        )

    def test_smtp_host_and_credentials_strip_expected_values(self, monkeypatch):
        monkeypatch.setenv(SMTP_HOST, " smtp.example.com ")
        monkeypatch.setenv(SMTP_USERNAME, " user ")
        monkeypatch.setenv(SMTP_PASSWORD, "secret ")
        monkeypatch.setenv(SMTP_FROM_EMAIL, " [email protected] ")

        assert get_smtp_host() == "smtp.example.com"
        assert get_smtp_username() == "user"
        assert get_smtp_password() == "secret "
        assert get_smtp_from_email() == "[email protected]"

    def test_smtp_port_defaults_and_invalid_values_fall_back(self, monkeypatch):
        monkeypatch.delenv(SMTP_PORT, raising=False)
        assert get_smtp_port() == 587

        monkeypatch.setenv(SMTP_PORT, "abc")
        assert get_smtp_port() == 587

        monkeypatch.setenv(SMTP_PORT, "0")
        assert get_smtp_port() == 587

    @pytest.mark.parametrize(
        "env_var,getter,default,true_value,false_value",
        [
            (SMTP_USE_TLS, get_smtp_use_tls, True, "true", "false"),
            (SMTP_USE_SSL, get_smtp_use_ssl, False, "yes", "off"),
        ],
    )
    def test_smtp_bool_settings(
        self, monkeypatch, env_var, getter, default, true_value, false_value
    ):
        monkeypatch.delenv(env_var, raising=False)
        assert getter() is default

        monkeypatch.setenv(env_var, true_value)
        assert getter() is True

        monkeypatch.setenv(env_var, false_value)
        assert getter() is False

    def test_smtp_from_name_uses_default_and_trimmed_override(self, monkeypatch):
        monkeypatch.delenv(SMTP_FROM_NAME, raising=False)
        assert get_smtp_from_name("Xagent") == "Xagent"

        monkeypatch.setenv(SMTP_FROM_NAME, " Support Team ")
        assert get_smtp_from_name("Xagent") == "Support Team"


class TestOpenRouterConfig:
    def test_official_providers_only_defaults_false(self, monkeypatch):
        monkeypatch.delenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, raising=False)
        assert get_openrouter_official_providers_only() is False

    @pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
    def test_official_providers_only_true_values(self, monkeypatch, value):
        monkeypatch.setenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, value)
        assert get_openrouter_official_providers_only() is True

    @pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
    def test_official_providers_only_false_values(self, monkeypatch, value):
        monkeypatch.setenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, value)
        assert get_openrouter_official_providers_only() is False

    def test_xrouter_excluded_models_defaults_empty(self, monkeypatch):
        monkeypatch.delenv(XROUTER_EXCLUDED_MODELS, raising=False)
        assert get_xrouter_excluded_models() == ()

    def test_xrouter_excluded_models_parses_and_deduplicates(self, monkeypatch):
        monkeypatch.setenv(
            XROUTER_EXCLUDED_MODELS,
            " z-ai/glm-5.3-flash, openai/gpt-5.6-luna, z-ai/glm-5.3-flash,, ",
        )

        assert get_xrouter_excluded_models() == (
            "z-ai/glm-5.3-flash",
            "openai/gpt-5.6-luna",
        )


class TestFormAnswerContinuationConfig:
    @pytest.mark.parametrize(
        ("value", "expected"),
        [
            pytest.param(None, True, id="unset-is-on"),
            pytest.param("true", True, id="true"),
            pytest.param(" TRUE ", True, id="true-padded-uppercase"),
            pytest.param("1", True, id="one"),
            pytest.param("false", False, id="false"),
            pytest.param("0", False, id="zero"),
            pytest.param("", False, id="empty-is-off"),
        ],
    )
    def test_env_table(self, monkeypatch, value, expected):
        if value is None:
            monkeypatch.delenv(FORM_ANSWER_CONTINUATION_ENABLED, raising=False)
        else:
            monkeypatch.setenv(FORM_ANSWER_CONTINUATION_ENABLED, value)
        assert get_form_answer_continuation_enabled() is expected

    def test_env_var_name_constant(self):
        assert (
            FORM_ANSWER_CONTINUATION_ENABLED
            == "XAGENT_FORM_ANSWER_CONTINUATION_ENABLED"
        )


class TestMCPOAuthConfig:
    def test_allow_private_hosts_defaults_false(self, monkeypatch):
        monkeypatch.delenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, raising=False)
        assert get_mcp_oauth_allow_private_hosts() is False

    @pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
    def test_allow_private_hosts_true_values(self, monkeypatch, value):
        monkeypatch.setenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, value)
        assert get_mcp_oauth_allow_private_hosts() is True

    @pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
    def test_allow_private_hosts_false_values(self, monkeypatch, value):
        monkeypatch.setenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, value)
        assert get_mcp_oauth_allow_private_hosts() is False

    def test_proxy_url_returns_none_when_unset_or_blank(self, monkeypatch):
        monkeypatch.delenv(MCP_OAUTH_PROXY_URL, raising=False)
        assert get_mcp_oauth_proxy_url() is None

        monkeypatch.setenv(MCP_OAUTH_PROXY_URL, "   ")
        assert get_mcp_oauth_proxy_url() is None

    def test_proxy_url_accepts_absolute_http_proxy(self, monkeypatch):
        monkeypatch.setenv(MCP_OAUTH_PROXY_URL, " http://proxy.example.com:8080 ")
        assert get_mcp_oauth_proxy_url() == "http://proxy.example.com:8080"

    @pytest.mark.parametrize("value", ["proxy.example.com:8080", "socks5://proxy:1080"])
    def test_proxy_url_rejects_unsupported_values(self, monkeypatch, value):
        monkeypatch.setenv(MCP_OAUTH_PROXY_URL, value)
        with pytest.raises(ValueError, match="XAGENT_MCP_OAUTH_PROXY_URL"):
            get_mcp_oauth_proxy_url()

    def test_hubspot_credentials_are_trimmed(self, monkeypatch):
        monkeypatch.setenv(config.HUBSPOT_MCP_CLIENT_ID, " client-id ")
        monkeypatch.setenv(config.HUBSPOT_MCP_CLIENT_SECRET, " client-secret ")

        assert config.get_hubspot_mcp_client_id() == "client-id"
        assert config.get_hubspot_mcp_client_secret() == "client-secret"

    def test_hubspot_credentials_default_none(self, monkeypatch):
        monkeypatch.delenv(config.HUBSPOT_MCP_CLIENT_ID, raising=False)
        monkeypatch.delenv(config.HUBSPOT_MCP_CLIENT_SECRET, raising=False)

        assert config.get_hubspot_mcp_client_id() is None
        assert config.get_hubspot_mcp_client_secret() is None


class TestTrustedEgressProxyConfig:
    def test_trusted_egress_proxy_constant(self):
        assert TRUSTED_EGRESS_PROXY == "XAGENT_TRUSTED_EGRESS_PROXY"

    def test_trusted_egress_proxy_defaults_false(self, monkeypatch):
        monkeypatch.delenv(TRUSTED_EGRESS_PROXY, raising=False)
        assert get_trusted_egress_proxy_enabled() is False

    @pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
    def test_trusted_egress_proxy_true_values(self, monkeypatch, value):
        monkeypatch.setenv(TRUSTED_EGRESS_PROXY, value)
        assert get_trusted_egress_proxy_enabled() is True

    @pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
    def test_trusted_egress_proxy_false_values(self, monkeypatch, value):
        monkeypatch.setenv(TRUSTED_EGRESS_PROXY, value)
        assert get_trusted_egress_proxy_enabled() is False


class TestHotPathCacheConfig:
    def test_redis_url_empty_is_none(self, monkeypatch):
        monkeypatch.delenv(REDIS_URL, raising=False)
        assert get_redis_url() is None
        monkeypatch.setenv(REDIS_URL, "  ")
        assert get_redis_url() is None

    def test_redis_url_strips_value(self, monkeypatch):
        monkeypatch.setenv(REDIS_URL, " redis://localhost:6379/0 ")
        assert get_redis_url() == "redis://localhost:6379/0"

    def test_hot_path_cache_enabled_defaults_true(self, monkeypatch):
        monkeypatch.delenv(HOT_PATH_CACHE_ENABLED, raising=False)
        assert get_hot_path_cache_enabled() is True

    def test_hot_path_cache_enabled_false(self, monkeypatch):
        monkeypatch.setenv(HOT_PATH_CACHE_ENABLED, "false")
        assert get_hot_path_cache_enabled() is False

    def test_hot_path_ttls(self, monkeypatch):
        monkeypatch.delenv(HOT_PATH_CACHE_TTL_SECONDS, raising=False)
        monkeypatch.delenv(HOT_PATH_TASK_CACHE_TTL_SECONDS, raising=False)
        assert get_hot_path_cache_ttl_seconds() == 30
        assert get_hot_path_task_cache_ttl_seconds() == 30

        monkeypatch.setenv(HOT_PATH_CACHE_TTL_SECONDS, "45")
        monkeypatch.setenv(HOT_PATH_TASK_CACHE_TTL_SECONDS, "3")
        assert get_hot_path_cache_ttl_seconds() == 45
        assert get_hot_path_task_cache_ttl_seconds() == 3


class TestCeleryBackgroundJobConfig:
    def test_celery_disabled_by_default(self, monkeypatch):
        monkeypatch.delenv(CELERY_ENABLED, raising=False)
        assert get_celery_enabled() is False

    def test_celery_enabled_true_values(self, monkeypatch):
        monkeypatch.setenv(CELERY_ENABLED, "yes")
        assert get_celery_enabled() is True

    def test_celery_broker_explicit(self, monkeypatch):
        monkeypatch.setenv(CELERY_BROKER_URL, " redis://localhost:6379/7 ")
        monkeypatch.setenv(REDIS_URL, "redis://localhost:6379/0")
        assert get_celery_broker_url() == "redis://localhost:6379/7"

    def test_celery_broker_derives_from_redis_url_db1(self, monkeypatch):
        monkeypatch.delenv(CELERY_BROKER_URL, raising=False)
        monkeypatch.setenv(REDIS_URL, "redis://localhost:6379/0")
        assert get_celery_broker_url() == "redis://localhost:6379/1"

    def test_celery_broker_none_without_redis(self, monkeypatch):
        monkeypatch.delenv(CELERY_BROKER_URL, raising=False)
        monkeypatch.delenv(REDIS_URL, raising=False)
        assert get_celery_broker_url() is None

    def test_celery_result_backend_optional(self, monkeypatch):
        monkeypatch.delenv(CELERY_RESULT_BACKEND, raising=False)
        assert get_celery_result_backend() is None
        monkeypatch.setenv(CELERY_RESULT_BACKEND, " redis://localhost:6379/2 ")
        assert get_celery_result_backend() == "redis://localhost:6379/2"

    def test_background_job_tuning_defaults(self, monkeypatch):
        monkeypatch.delenv(BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS, raising=False)
        monkeypatch.delenv(BACKGROUND_JOB_MAX_RETRIES, raising=False)
        monkeypatch.delenv(BACKGROUND_JOB_STALE_SECONDS, raising=False)
        monkeypatch.delenv(BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS, raising=False)
        assert get_background_job_visibility_timeout_seconds() == 3600
        assert get_background_job_max_retries() == 3
        assert get_background_job_stale_seconds() == 7200
        assert get_background_job_sweep_interval_seconds() == 300

    def test_kb_migration_defer_defaults(self, monkeypatch):
        monkeypatch.delenv(KB_MIGRATION_DEFER_DELAY_SECONDS, raising=False)
        monkeypatch.delenv(KB_MIGRATION_DEFER_BUDGET_SECONDS, raising=False)
        assert get_kb_migration_defer_delay_seconds() == 15
        assert get_kb_migration_defer_budget_seconds() == 600

    def test_kb_migration_defer_env_overrides(self, monkeypatch):
        monkeypatch.setenv(KB_MIGRATION_DEFER_DELAY_SECONDS, "20")
        monkeypatch.setenv(KB_MIGRATION_DEFER_BUDGET_SECONDS, "1200")
        assert get_kb_migration_defer_delay_seconds() == 20
        assert get_kb_migration_defer_budget_seconds() == 1200

    def test_kb_milvus_cleanup_interval_default(self, monkeypatch):
        monkeypatch.delenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, raising=False)
        assert get_kb_milvus_cleanup_interval_seconds() == 3600

    def test_kb_milvus_cleanup_interval_env_override(self, monkeypatch):
        monkeypatch.setenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, "600")
        assert get_kb_milvus_cleanup_interval_seconds() == 600

    def test_kb_milvus_cleanup_interval_below_minimum_falls_back_to_default(
        self, monkeypatch
    ):
        monkeypatch.setenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, "299")
        assert get_kb_milvus_cleanup_interval_seconds() == 3600

    def test_kb_milvus_cleanup_enabled_defaults_to_true(self, monkeypatch):
        monkeypatch.delenv(KB_MILVUS_CLEANUP_ENABLED, raising=False)
        assert get_kb_milvus_cleanup_enabled() is True

    @pytest.mark.parametrize("value", ["false", "0", "no", "off", "FALSE", " false "])
    def test_kb_milvus_cleanup_enabled_false_values(self, monkeypatch, value):
        monkeypatch.setenv(KB_MILVUS_CLEANUP_ENABLED, value)
        assert get_kb_milvus_cleanup_enabled() is False

    def test_kb_milvus_cleanup_enabled_true_value(self, monkeypatch):
        monkeypatch.setenv(KB_MILVUS_CLEANUP_ENABLED, "true")
        assert get_kb_milvus_cleanup_enabled() is True

    def test_trigger_dispatcher_tuning(self, monkeypatch):
        monkeypatch.delenv(TRIGGER_DISPATCHER_ENABLED, raising=False)
        monkeypatch.delenv(TRIGGER_DISPATCHER_INTERVAL_SECONDS, raising=False)
        monkeypatch.delenv(TRIGGER_DISPATCHER_BATCH_SIZE, raising=False)
        monkeypatch.delenv(TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS, raising=False)
        assert get_trigger_dispatcher_enabled() is True
        assert get_trigger_dispatcher_interval_seconds() == 5
        assert get_trigger_dispatcher_batch_size() == 20
        assert get_trigger_dispatcher_startup_jitter_seconds() == 30

        monkeypatch.setenv(TRIGGER_DISPATCHER_ENABLED, "false")
        monkeypatch.setenv(TRIGGER_DISPATCHER_INTERVAL_SECONDS, "9")
        monkeypatch.setenv(TRIGGER_DISPATCHER_BATCH_SIZE, "3")
        monkeypatch.setenv(TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS, "0")
        assert get_trigger_dispatcher_enabled() is False
        assert get_trigger_dispatcher_interval_seconds() == 9
        assert get_trigger_dispatcher_batch_size() == 3
        assert get_trigger_dispatcher_startup_jitter_seconds() == 0

    def test_task_lease_recovery_tuning(self, monkeypatch):
        monkeypatch.setenv(TASK_LEASE_TTL_SECONDS, "60")
        monkeypatch.delenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, raising=False)
        monkeypatch.delenv(TASK_LEASE_RECOVERY_BATCH_SIZE, raising=False)
        assert get_task_lease_recovery_interval_seconds() == 20
        assert get_task_lease_recovery_batch_size() == 100

        monkeypatch.setenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, "7")
        monkeypatch.setenv(TASK_LEASE_RECOVERY_BATCH_SIZE, "3")
        assert get_task_lease_recovery_interval_seconds() == 7
        assert get_task_lease_recovery_batch_size() == 3

        monkeypatch.setenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, "")
        monkeypatch.setenv(TASK_LEASE_RECOVERY_BATCH_SIZE, "0")
        assert get_task_lease_recovery_interval_seconds() == 20
        assert get_task_lease_recovery_batch_size() == 100

    def test_uploaded_file_recovery_tuning(self, monkeypatch):
        monkeypatch.delenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, raising=False)
        monkeypatch.delenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, raising=False)
        monkeypatch.delenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, raising=False)
        assert get_uploaded_file_recovery_interval_seconds() == 60
        assert get_uploaded_file_recovery_stale_seconds() == 300
        assert get_uploaded_file_recovery_batch_size() == 100

        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, "7")
        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, "45")
        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, "3")
        assert get_uploaded_file_recovery_interval_seconds() == 7
        assert get_uploaded_file_recovery_stale_seconds() == 45
        assert get_uploaded_file_recovery_batch_size() == 3

        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, "")
        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, "0")
        monkeypatch.setenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, "-1")
        assert get_uploaded_file_recovery_interval_seconds() == 60
        assert get_uploaded_file_recovery_stale_seconds() == 300
        assert get_uploaded_file_recovery_batch_size() == 100

    def test_temp_file_cleanup_shutdown_timeout_tuning(self, monkeypatch):
        assert (
            TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS
            == "XAGENT_TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS"
        )

        monkeypatch.delenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, raising=False)
        assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10

        monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "45")
        assert get_temp_file_cleanup_shutdown_timeout_seconds() == 45

        # Invalid / non-positive values fall back to the default.
        monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "0")
        assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10

        monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "abc")
        assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10

        monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "-5")
        assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10


class TestGetWebSearchProvider:
    """Test get_web_search_provider() function."""

    def test_default_web_search_provider(self, monkeypatch):
        monkeypatch.delenv(WEB_SEARCH_PROVIDER, raising=False)
        assert get_web_search_provider() == "auto"

    def test_normalizes_web_search_provider(self, monkeypatch):
        monkeypatch.setenv(WEB_SEARCH_PROVIDER, " Google ")
        assert get_web_search_provider() == "google"

    def test_brave_web_search_provider(self, monkeypatch):
        monkeypatch.setenv(WEB_SEARCH_PROVIDER, "Brave")
        assert get_web_search_provider() == "brave"

    def test_empty_web_search_provider_means_auto(self, monkeypatch):
        monkeypatch.setenv(WEB_SEARCH_PROVIDER, "  ")
        assert get_web_search_provider() == "auto"

    def test_invalid_web_search_provider_fails_closed(self, monkeypatch, caplog):
        monkeypatch.setenv(WEB_SEARCH_PROVIDER, "bing")
        with caplog.at_level("ERROR"):
            provider = get_web_search_provider()
        assert provider not in WEB_SEARCH_PROVIDERS
        assert provider != "auto"
        assert WEB_SEARCH_PROVIDER in caplog.text


class TestGetBraveSearchCountry:
    def test_values(self, monkeypatch):
        monkeypatch.delenv("XAGENT_BRAVE_SEARCH_COUNTRY", raising=False)
        assert get_brave_search_country() is None
        monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", " Au ")
        assert get_brave_search_country() == "au"
        monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", "")
        assert get_brave_search_country() is None

    def test_invalid_value_ignored(self, monkeypatch):
        monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", "AUS")
        assert get_brave_search_country() is None


class TestGetBraveSearchEndpoint:
    def test_default_and_values(self, monkeypatch):
        monkeypatch.delenv("XAGENT_BRAVE_SEARCH_ENDPOINT", raising=False)
        assert get_brave_search_endpoint() == "web"
        monkeypatch.setenv("XAGENT_BRAVE_SEARCH_ENDPOINT", " LLM_Context ")
        assert get_brave_search_endpoint() == "llm_context"

    def test_unknown_value_uses_web_and_warns(self, monkeypatch, caplog):
        monkeypatch.setenv("XAGENT_BRAVE_SEARCH_ENDPOINT", "bogus")
        with caplog.at_level("WARNING"):
            assert get_brave_search_endpoint() == "web"
        assert "XAGENT_BRAVE_SEARCH_ENDPOINT" in caplog.text


class TestGetWebCrawlTlsImpersonate:
    """Test get_web_crawl_tls_impersonate() function."""

    def test_default_web_crawl_tls_impersonate(self, monkeypatch):
        monkeypatch.delenv(WEB_CRAWL_TLS_IMPERSONATE, raising=False)
        assert get_web_crawl_tls_impersonate() is None

    @pytest.mark.parametrize("value", ["", "   ", "none", "None", "NULL"])
    def test_empty_like_web_crawl_tls_impersonate(self, monkeypatch, value):
        monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, value)
        assert get_web_crawl_tls_impersonate() is None

    def test_auto_web_crawl_tls_impersonate(self, monkeypatch):
        monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, " auto ")
        assert get_web_crawl_tls_impersonate() == "auto"

    def test_specific_web_crawl_tls_impersonate(self, monkeypatch):
        monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, "safari17_0")
        assert get_web_crawl_tls_impersonate() == "safari17_0"


class TestGetMaxUploadSizeBytes:
    """Test get_max_upload_size_bytes() function."""

    def test_default_max_upload_size(self, monkeypatch):
        monkeypatch.delenv(MAX_UPLOAD_SIZE, raising=False)
        assert get_max_upload_size_bytes() == 100 * 1024 * 1024

    def test_numeric_max_upload_size(self, monkeypatch):
        monkeypatch.setenv(MAX_UPLOAD_SIZE, "2048")
        assert get_max_upload_size_bytes() == 2048

    def test_numeric_float_max_upload_size(self, monkeypatch):
        monkeypatch.setenv(MAX_UPLOAD_SIZE, "1.5")
        assert get_max_upload_size_bytes() == 1

    def test_rejects_non_positive_max_upload_size(self, monkeypatch):
        monkeypatch.setenv(MAX_UPLOAD_SIZE, "0")
        with pytest.raises(ValueError, match="positive"):
            get_max_upload_size_bytes()

        monkeypatch.setenv(MAX_UPLOAD_SIZE, "-1")
        with pytest.raises(ValueError, match="positive"):
            get_max_upload_size_bytes()

    def test_human_readable_max_upload_size(self, monkeypatch):
        monkeypatch.setenv(MAX_UPLOAD_SIZE, "150M")
        assert get_max_upload_size_bytes() == 150 * 1024 * 1024

    def test_invalid_max_upload_size_raises(self, monkeypatch):
        monkeypatch.setenv(MAX_UPLOAD_SIZE, "banana")
        with pytest.raises(ValueError, match="XAGENT_MAX_UPLOAD_SIZE"):
            get_max_upload_size_bytes()


class TestFormatFileSize:
    def test_formats_kilobytes(self):
        assert format_file_size(512 * 1024) == "512KB"

    def test_formats_fractional_megabytes(self):
        assert format_file_size(1572864) == "1.5MB"

    def test_promotes_boundary_values_to_next_unit(self):
        assert format_file_size(1048575) == "1MB"


class TestFileStorageConfig:
    def test_default_file_storage_uri_uses_storage_root(self, monkeypatch):
        monkeypatch.delenv(FILE_STORAGE_URI, raising=False)
        monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")

        assert get_file_storage_uri() == "file:///custom/storage/files"

    def test_default_file_storage_uri_resolves_relative_storage_root(
        self, monkeypatch, tmp_path
    ):
        monkeypatch.delenv(FILE_STORAGE_URI, raising=False)
        monkeypatch.chdir(tmp_path)
        monkeypatch.setenv(STORAGE_ROOT, ".xagent")

        assert get_file_storage_uri() == (tmp_path / ".xagent" / "files").as_uri()

    def test_file_storage_uri_with_env_var(self, monkeypatch):
        monkeypatch.setenv(FILE_STORAGE_URI, "s3://bucket/prefix")

        assert get_file_storage_uri() == "s3://bucket/prefix"

    def test_file_storage_options_default_to_empty_dict(self, monkeypatch):
        monkeypatch.delenv(FILE_STORAGE_OPTIONS, raising=False)

        assert get_file_storage_options() == {}

    def test_file_storage_options_parse_json_object(self, monkeypatch):
        monkeypatch.setenv(
            FILE_STORAGE_OPTIONS,
            '{"endpoint_url":"https://s3.example.com","region_name":"us-east-1"}',
        )

        assert get_file_storage_options() == {
            "endpoint_url": "https://s3.example.com",
            "region_name": "us-east-1",
        }

    def test_file_storage_options_reject_non_object_json(self, monkeypatch):
        monkeypatch.setenv(FILE_STORAGE_OPTIONS, '["not", "an", "object"]')

        with pytest.raises(ValueError, match="XAGENT_FILE_STORAGE_OPTIONS"):
            get_file_storage_options()

    def test_file_materialize_dir_default(self, monkeypatch):
        monkeypatch.delenv(FILE_MATERIALIZE_DIR, raising=False)

        assert get_file_materialize_dir() == Path(gettempdir()) / "xagent-materialized"

    def test_file_materialize_dir_with_env_var(self, monkeypatch):
        monkeypatch.setenv(FILE_MATERIALIZE_DIR, "/custom/materialized")

        assert get_file_materialize_dir() == Path("/custom/materialized")

    def test_preview_tmp_dir_default(self, monkeypatch):
        monkeypatch.delenv(PREVIEW_TMP_DIR, raising=False)

        assert get_preview_tmp_dir() == Path(gettempdir()) / "xagent-preview"

    def test_preview_tmp_dir_with_env_var(self, monkeypatch):
        monkeypatch.setenv(PREVIEW_TMP_DIR, "/custom/preview-tmp")

        assert get_preview_tmp_dir() == Path("/custom/preview-tmp")

    def test_file_storage_startup_sync_enabled_defaults_true(self, monkeypatch):
        monkeypatch.delenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, raising=False)

        assert get_file_storage_startup_sync_enabled() is True

    @pytest.mark.parametrize(
        "value,expected",
        [
            ("true", True),
            ("1", True),
            ("yes", True),
            ("on", True),
            ("false", False),
            ("0", False),
            ("no", False),
            ("off", False),
        ],
    )
    def test_file_storage_startup_sync_enabled_parses_bool(
        self, monkeypatch, value, expected
    ):
        monkeypatch.setenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, value)

        assert get_file_storage_startup_sync_enabled() is expected

    def test_file_storage_startup_sync_enabled_rejects_invalid(self, monkeypatch):
        monkeypatch.setenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, "maybe")

        with pytest.raises(
            ValueError, match="XAGENT_FILE_STORAGE_STARTUP_SYNC_ENABLED"
        ):
            get_file_storage_startup_sync_enabled()

    def test_file_delivery_redirect_enabled_defaults_false(self, monkeypatch):
        monkeypatch.delenv(FILE_DELIVERY_REDIRECT_ENABLED, raising=False)

        assert get_file_delivery_redirect_enabled() is False

    @pytest.mark.parametrize(
        "value,expected",
        [
            ("true", True),
            ("1", True),
            ("yes", True),
            ("on", True),
            ("false", False),
            ("0", False),
            ("no", False),
            ("off", False),
        ],
    )
    def test_file_delivery_redirect_enabled_parses_bool(
        self, monkeypatch, value, expected
    ):
        monkeypatch.setenv(FILE_DELIVERY_REDIRECT_ENABLED, value)

        assert get_file_delivery_redirect_enabled() is expected

    def test_file_delivery_redirect_enabled_rejects_invalid(self, monkeypatch):
        monkeypatch.setenv(FILE_DELIVERY_REDIRECT_ENABLED, "maybe")

        with pytest.raises(ValueError, match="XAGENT_FILE_DELIVERY_REDIRECT_ENABLED"):
            get_file_delivery_redirect_enabled()

    def test_file_delivery_signed_url_ttl_defaults_to_300(self, monkeypatch):
        monkeypatch.delenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, raising=False)

        assert get_file_delivery_signed_url_ttl_seconds() == 300

    def test_file_delivery_signed_url_ttl_with_env_var(self, monkeypatch):
        monkeypatch.setenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, "60")

        assert get_file_delivery_signed_url_ttl_seconds() == 60

    @pytest.mark.parametrize("value", ["0", "-1", "abc"])
    def test_file_delivery_signed_url_ttl_rejects_invalid(self, monkeypatch, value):
        monkeypatch.setenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, value)

        with pytest.raises(
            ValueError, match="XAGENT_FILE_DELIVERY_SIGNED_URL_TTL_SECONDS"
        ):
            get_file_delivery_signed_url_ttl_seconds()

    def test_file_stream_ticket_ttl_defaults_to_600(self, monkeypatch):
        monkeypatch.delenv(FILE_STREAM_TICKET_TTL_SECONDS, raising=False)

        assert get_file_stream_ticket_ttl_seconds() == 600

    def test_file_stream_ticket_ttl_with_env_var(self, monkeypatch):
        monkeypatch.setenv(FILE_STREAM_TICKET_TTL_SECONDS, "120")

        assert get_file_stream_ticket_ttl_seconds() == 120

    @pytest.mark.parametrize("value", ["0", "-1", "abc"])
    def test_file_stream_ticket_ttl_rejects_invalid(self, monkeypatch, value):
        monkeypatch.setenv(FILE_STREAM_TICKET_TTL_SECONDS, value)

        with pytest.raises(ValueError, match="XAGENT_FILE_STREAM_TICKET_TTL_SECONDS"):
            get_file_stream_ticket_ttl_seconds()

    def test_external_media_url_ttl_defaults_to_600(self, monkeypatch):
        monkeypatch.delenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, raising=False)

        assert config.get_external_media_url_ttl_seconds() == 600

    def test_external_media_url_ttl_with_env_var(self, monkeypatch):
        monkeypatch.setenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, "900")

        assert config.get_external_media_url_ttl_seconds() == 900

    @pytest.mark.parametrize("value", ["0", "59", "3601", "abc"])
    def test_external_media_url_ttl_rejects_invalid(self, monkeypatch, value):
        monkeypatch.setenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, value)

        with pytest.raises(ValueError, match="XAGENT_EXTERNAL_MEDIA_URL_TTL_SECONDS"):
            config.get_external_media_url_ttl_seconds()

    def test_file_delivery_accel_redirect_enabled_defaults_false(self, monkeypatch):
        monkeypatch.delenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, raising=False)

        assert get_file_delivery_accel_redirect_enabled() is False

    @pytest.mark.parametrize(
        "value,expected",
        [
            ("true", True),
            ("1", True),
            ("yes", True),
            ("on", True),
            ("false", False),
            ("0", False),
            ("no", False),
            ("off", False),
        ],
    )
    def test_file_delivery_accel_redirect_enabled_parses_bool(
        self, monkeypatch, value, expected
    ):
        monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, value)

        assert get_file_delivery_accel_redirect_enabled() is expected

    def test_file_delivery_accel_redirect_enabled_rejects_invalid(self, monkeypatch):
        monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, "maybe")

        with pytest.raises(
            ValueError, match="XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_ENABLED"
        ):
            get_file_delivery_accel_redirect_enabled()

    def test_file_delivery_accel_redirect_prefix_defaults_to_internal_uri(
        self, monkeypatch
    ):
        monkeypatch.delenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, raising=False)

        assert get_file_delivery_accel_redirect_prefix() == "/_xagent_internal_files/"

    def test_file_delivery_accel_redirect_prefix_normalizes_trailing_slash(
        self, monkeypatch
    ):
        monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, "/private-files")

        assert get_file_delivery_accel_redirect_prefix() == "/private-files/"

    def test_file_delivery_accel_redirect_prefix_requires_absolute_uri(
        self, monkeypatch
    ):
        monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, "private-files")

        with pytest.raises(
            ValueError, match="XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_PREFIX"
        ):
            get_file_delivery_accel_redirect_prefix()


class TestGetUploadsDir:
    """Test get_uploads_dir() function."""

    def test_default_uploads_dir(self, monkeypatch):
        """Test default uploads directory path."""
        monkeypatch.delenv(UPLOADS_DIR, raising=False)
        monkeypatch.delenv(WEB_DIR, raising=False)
        result = get_uploads_dir()
        # Default is src/xagent/web/uploads
        assert result.name == "uploads"
        assert result.parent.name == "web"

    def test_uploads_dir_with_env_var(self, monkeypatch):
        """Test uploads directory with environment variable."""
        monkeypatch.setenv(UPLOADS_DIR, "/tmp/test_uploads")
        result = get_uploads_dir()
        assert result == Path("/tmp/test_uploads")

    def test_uploads_dir_env_overrides_web_dir(self, monkeypatch):
        """Test that UPLOADS_DIR env var overrides computed default."""
        monkeypatch.setenv(WEB_DIR, "/custom/web")
        monkeypatch.setenv(UPLOADS_DIR, "/custom/uploads")
        result = get_uploads_dir()
        assert result == Path("/custom/uploads")


class TestGetWebDir:
    """Test get_web_dir() function."""

    def test_default_web_dir(self, monkeypatch):
        """Test default web directory path."""
        monkeypatch.delenv(WEB_DIR, raising=False)
        result = get_web_dir()
        assert result.name == "web"

    def test_web_dir_with_env_var(self, monkeypatch):
        """Test web directory with environment variable."""
        monkeypatch.setenv(WEB_DIR, "/custom/web")
        result = get_web_dir()
        assert result == Path("/custom/web")


@pytest.mark.parametrize(
    "value, expected",
    [
        (None, ""),
        ("", ""),
        (" auto ", "auto"),
        (" https://preview.example.test/path ", "https://preview.example.test/path"),
    ],
)
def test_get_html_preview_origin(monkeypatch, value, expected):
    monkeypatch.delenv(config.HTML_PREVIEW_ORIGIN, raising=False)
    if value is not None:
        monkeypatch.setenv(config.HTML_PREVIEW_ORIGIN, value)
    assert config.get_html_preview_origin() == expected


class TestGetFrontendDistDir:
    """Test get_frontend_dist_dir() function."""

    def test_default_frontend_dist_dir(self, monkeypatch):
        """Defaults to WEB_DIR/frontend_dist."""
        monkeypatch.delenv(FRONTEND_DIST_DIR, raising=False)
        monkeypatch.delenv(WEB_DIR, raising=False)
        result = get_frontend_dist_dir()
        assert result.name == "frontend_dist"
        assert result.parent.name == "web"

    def test_frontend_dist_dir_with_env_var(self, monkeypatch):
        """Environment variable overrides the default."""
        monkeypatch.setenv(FRONTEND_DIST_DIR, "/custom/dist")
        result = get_frontend_dist_dir()
        assert result == Path("/custom/dist")

    def test_frontend_dist_dir_follows_web_dir_default(self, monkeypatch):
        """Default is computed under the configured WEB_DIR."""
        monkeypatch.delenv(FRONTEND_DIST_DIR, raising=False)
        monkeypatch.setenv(WEB_DIR, "/custom/web")
        result = get_frontend_dist_dir()
        assert result == Path("/custom/web/frontend_dist")


class TestGetAgentRuntime:
    """Test get_agent_runtime() function."""

    def test_default_agent_runtime(self, monkeypatch):
        monkeypatch.delenv(AGENT_RUNTIME, raising=False)
        assert get_agent_runtime() == "v1"

    def test_agent_runtime_v2(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, "v2")
        assert get_agent_runtime() == "v2"

    def test_agent_runtime_normalizes_case_and_spaces(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, " V2 ")
        assert get_agent_runtime() == "v2"

    def test_invalid_agent_runtime_falls_back_to_v1(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, "unknown")
        assert get_agent_runtime() == "v1"


class TestGetAgentPatternForExecutionMode:
    """Test get_agent_pattern_for_execution_mode() function."""

    def test_known_execution_modes(self):
        assert get_agent_pattern_for_execution_mode("flash") == "single_call"
        assert get_agent_pattern_for_execution_mode("balanced") == "react"
        assert get_agent_pattern_for_execution_mode("think") == "dag_plan_execute"
        assert get_agent_pattern_for_execution_mode("auto") == "auto"

    def test_normalizes_mode(self):
        assert get_agent_pattern_for_execution_mode(" AUTO ") == "auto"

    def test_unknown_mode_falls_back_to_react(self):
        assert get_agent_pattern_for_execution_mode("unknown") == "react"
        assert get_agent_pattern_for_execution_mode(None) == "react"


class TestGetDefaultTaskExecutionMode:
    """Test default task execution mode selection."""

    def test_default_standalone_defaults_to_auto(self, monkeypatch):
        monkeypatch.delenv(AGENT_RUNTIME, raising=False)
        assert get_default_task_execution_mode() == "auto"

    def test_v1_standalone_defaults_to_think(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, "v1")
        assert get_default_task_execution_mode() == "think"

    def test_v2_standalone_defaults_to_auto(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, "v2")
        assert get_default_task_execution_mode() == "auto"

    def test_agent_tasks_default_to_balanced_in_v2(self, monkeypatch):
        monkeypatch.setenv(AGENT_RUNTIME, "v2")
        assert get_default_task_execution_mode(agent_id=123) == "balanced"

    def test_explicit_runtime_can_be_passed(self):
        assert get_default_task_execution_mode(agent_runtime="v2") == "auto"


class TestGetExternalUploadDirs:
    """Test get_external_upload_dirs() function."""

    def test_no_env_var_returns_empty_list(self, monkeypatch):
        """Test that missing env var returns empty list."""
        monkeypatch.delenv(EXTERNAL_UPLOAD_DIRS, raising=False)
        result = get_external_upload_dirs()
        assert result == []

    def test_empty_env_var_returns_empty_list(self, monkeypatch):
        """Test that empty env var returns empty list."""
        monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, "")
        result = get_external_upload_dirs()
        assert result == []

    def test_nonexistent_dirs_are_filtered(self, monkeypatch):
        """Test that nonexistent directories are not included."""
        monkeypatch.setenv(
            EXTERNAL_UPLOAD_DIRS, "/nonexistent/path1,/nonexistent/path2"
        )
        result = get_external_upload_dirs()
        assert result == []

    def test_existing_dirs_are_included(self, monkeypatch):
        """Test that existing directories are included."""
        with tempfile.TemporaryDirectory() as tmpdir:
            dir1 = Path(tmpdir) / "uploads1"
            dir2 = Path(tmpdir) / "uploads2"
            dir1.mkdir()
            dir2.mkdir()

            monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, f"{dir1},{dir2}")
            result = get_external_upload_dirs()
            assert len(result) == 2
            assert dir1 in result
            assert dir2 in result

    def test_expands_environment_tilde_and_preserves_symlink_spelling(
        self, tmp_path, monkeypatch
    ):
        physical = tmp_path / "physical" / "uploads"
        physical.mkdir(parents=True)
        alias = tmp_path / "alias"
        alias.symlink_to(physical, target_is_directory=True)
        monkeypatch.setenv("HOME", str(tmp_path))
        monkeypatch.setenv("EXTERNAL_NAME", "alias")
        monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, "~/$EXTERNAL_NAME")

        assert get_external_upload_dirs() == [alias]

    def test_rejects_symlink_followed_by_dotdot(self, tmp_path, monkeypatch):
        base = tmp_path / "base"
        outside = tmp_path / "outside" / "nested"
        base.mkdir()
        outside.mkdir(parents=True)
        (base / "link").symlink_to(outside, target_is_directory=True)
        monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, str(base / "link" / ".."))

        with pytest.raises(ExternalUploadsDirConfigurationError, match="two different"):
            get_external_upload_dirs()

    def test_relative_dir_is_pinned_to_first_working_directory(
        self, tmp_path, monkeypatch
    ):
        first_cwd = tmp_path / "first"
        second_cwd = tmp_path / "second"
        external = first_cwd / "relative-external"
        external.mkdir(parents=True)
        second_cwd.mkdir()
        relative_spelling = "relative-external"
        monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, relative_spelling)

        monkeypatch.chdir(first_cwd)
        assert get_external_upload_dirs() == [external]

        monkeypatch.chdir(second_cwd)
        assert get_external_upload_dirs() == [external]


class TestGetExternalSkillsDirs:
    """Test get_external_skills_dirs() function."""

    def test_no_env_var_returns_empty_list(self, monkeypatch):
        """Test that missing env var returns empty list."""
        monkeypatch.delenv(EXTERNAL_SKILLS_LIBRARY_DIRS, raising=False)
        result = get_external_skills_dirs()
        assert result == []

    def test_tilde_expansion(self, monkeypatch):
        """Test that tilde (~) is expanded to home directory."""
        monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "~/skills")
        result = get_external_skills_dirs()
        assert len(result) == 1
        assert result[0] == Path.home() / "skills"

    def test_env_var_expansion(self, monkeypatch):
        """Test that environment variables in paths are expanded."""
        monkeypatch.setenv("CUSTOM_SKILLS_DIR", "/opt/skills")
        monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "$CUSTOM_SKILLS_DIR")
        result = get_external_skills_dirs()
        assert len(result) == 1
        assert result[0] == Path("/opt/skills")

    def test_url_like_paths_are_skipped(self, monkeypatch):
        """Test that URL-like paths are skipped with warning."""
        monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "https://example.com/skills")
        result = get_external_skills_dirs()
        assert result == []


class TestGetStorageRoot:
    """Test get_storage_root() function."""

    def test_default_storage_root(self, monkeypatch):
        """Test default storage root path."""
        monkeypatch.delenv(STORAGE_ROOT, raising=False)
        result = get_storage_root()
        assert result == Path.home() / ".xagent"

    def test_storage_root_with_env_var(self, monkeypatch):
        """Test storage root with environment variable."""
        monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")
        result = get_storage_root()
        assert result == Path("/custom/storage")

    def test_storage_root_expands_tilde(self, monkeypatch, tmp_path):
        """A ~-prefixed env value resolves to the home directory."""
        monkeypatch.setenv("HOME", str(tmp_path))
        monkeypatch.setenv(STORAGE_ROOT, "~/custom-root")
        result = get_storage_root()
        assert result == tmp_path / "custom-root"


class TestGetSandboxImage:
    """Test get_sandbox_image() function."""

    def test_default_sandbox_image(self, monkeypatch):
        """Test default sandbox image name."""
        monkeypatch.delenv(SANDBOX_IMAGE, raising=False)
        result = get_sandbox_image()
        assert result == "xprobe/xagent-sandbox:latest"

    def test_sandbox_image_with_env_var(self, monkeypatch):
        """Test sandbox image with environment variable."""
        monkeypatch.setenv(SANDBOX_IMAGE, "custom/sandbox:v1.0")
        result = get_sandbox_image()
        assert result == "custom/sandbox:v1.0"


class TestGetLancedbPath:
    """Test get_lancedb_path() function."""

    def test_default_lancedb_path(self, monkeypatch):
        """Test default LanceDB path (relative to storage root)."""
        monkeypatch.delenv(LANCEDB_PATH, raising=False)
        monkeypatch.delenv(STORAGE_ROOT, raising=False)
        result = get_lancedb_path()
        assert result == Path.home() / ".xagent" / "data" / "lancedb"

    def test_lancedb_path_with_env_var(self, monkeypatch):
        """Test LanceDB path with environment variable."""
        monkeypatch.setenv(LANCEDB_PATH, "/custom/lancedb")
        result = get_lancedb_path()
        assert result == Path("/custom/lancedb")


class TestGoogleDriveDownloadTimeout:
    """Test the Google Drive LRO timeout configuration."""

    def test_constant_name(self):
        assert (
            config.GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS
            == "XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS"
        )

    def test_default(self, monkeypatch):
        monkeypatch.delenv(
            "XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", raising=False
        )
        assert config.get_google_drive_download_timeout_seconds() == 600

    def test_environment_override(self, monkeypatch):
        monkeypatch.setenv("XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", "120")
        assert config.get_google_drive_download_timeout_seconds() == 120

    @pytest.mark.parametrize("value", ["0", "-1", "not-a-number"])
    def test_invalid_value_uses_default(self, monkeypatch, value):
        monkeypatch.setenv("XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", value)
        assert config.get_google_drive_download_timeout_seconds() == 600


class TestGetKbCollectionsTimeoutSeconds:
    """Test get_kb_collections_timeout_seconds() function."""

    def test_env_var_constant(self):
        assert KB_COLLECTIONS_TIMEOUT_SECONDS == "XAGENT_KB_COLLECTIONS_TIMEOUT_SECONDS"

    def test_default(self, monkeypatch):
        monkeypatch.delenv(KB_COLLECTIONS_TIMEOUT_SECONDS, raising=False)
        assert get_kb_collections_timeout_seconds() == 30

    def test_env_override(self, monkeypatch):
        monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "90")
        assert get_kb_collections_timeout_seconds() == 90

    def test_invalid_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "not-a-number")
        assert get_kb_collections_timeout_seconds() == 30

    def test_non_positive_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "0")
        assert get_kb_collections_timeout_seconds() == 30


class TestGetKbSearchTimeoutSeconds:
    """Test get_kb_search_timeout_seconds() function."""

    def test_env_var_constant(self):
        assert KB_SEARCH_TIMEOUT_SECONDS == "XAGENT_KB_SEARCH_TIMEOUT_SECONDS"

    def test_default(self, monkeypatch):
        monkeypatch.delenv(KB_SEARCH_TIMEOUT_SECONDS, raising=False)
        assert get_kb_search_timeout_seconds() == 60

    def test_env_override(self, monkeypatch):
        monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "5")
        assert get_kb_search_timeout_seconds() == 5

    def test_invalid_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "not-a-number")
        assert get_kb_search_timeout_seconds() == 60

    def test_non_positive_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "0")
        assert get_kb_search_timeout_seconds() == 60


class TestDeepDocRemoteParsingConfig:
    """Test the remote DeepDoc parsing (Xinference) configuration getters."""

    def test_env_var_constants(self):
        assert DEEPDOC_XINFERENCE_URL == "XAGENT_DEEPDOC_XINFERENCE_URL"
        assert DEEPDOC_XINFERENCE_API_KEY == "XAGENT_DEEPDOC_XINFERENCE_API_KEY"
        assert (
            DEEPDOC_XINFERENCE_TIMEOUT_SECONDS
            == "XAGENT_DEEPDOC_XINFERENCE_TIMEOUT_SECONDS"
        )
        assert DEEPDOC_XINFERENCE_MODEL_UID == "XAGENT_DEEPDOC_XINFERENCE_MODEL_UID"
        assert DEEPDOC_XINFERENCE_USERNAME == "XAGENT_DEEPDOC_XINFERENCE_USERNAME"
        assert DEEPDOC_XINFERENCE_PASSWORD == "XAGENT_DEEPDOC_XINFERENCE_PASSWORD"

    def test_url_unset_defaults_to_local_mode(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_URL, raising=False)
        assert get_deepdoc_xinference_url() is None

    def test_url_blank_defaults_to_local_mode(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, "   ")
        assert get_deepdoc_xinference_url() is None

    def test_url_strips_whitespace_and_trailing_slash(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, " http://gpu-host:9997/ ")
        assert get_deepdoc_xinference_url() == "http://gpu-host:9997"

    @pytest.mark.parametrize(
        "value",
        [
            "gpu-host:9997",
            "ftp://gpu-host:9997",
            "https:///missing-host",
            "http://gpu-host:9997?model=deepdoc",
            "http://gpu-host:9997#deepdoc",
            "http://gpu-host:9997/v1/deepdoc?model=deepdoc",
        ],
    )
    def test_url_rejects_invalid_values(self, monkeypatch, value):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, value)

        with pytest.raises(ValueError, match="XAGENT_DEEPDOC_XINFERENCE_URL"):
            get_deepdoc_xinference_url()

    def test_api_key_dedicated_var_wins(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_API_KEY, " deepdoc-key ")
        monkeypatch.setenv("XINFERENCE_API_KEY", "shared-key")
        assert get_deepdoc_xinference_api_key() == "deepdoc-key"

    def test_api_key_falls_back_to_shared_xinference_key(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_API_KEY, raising=False)
        monkeypatch.setenv("XINFERENCE_API_KEY", " shared-key ")
        assert get_deepdoc_xinference_api_key() == "shared-key"

    def test_api_key_blank_dedicated_var_falls_back(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_API_KEY, "  ")
        monkeypatch.setenv("XINFERENCE_API_KEY", "shared-key")
        assert get_deepdoc_xinference_api_key() == "shared-key"

    def test_api_key_unset_means_no_auth(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_API_KEY, raising=False)
        monkeypatch.delenv("XINFERENCE_API_KEY", raising=False)
        assert get_deepdoc_xinference_api_key() is None

    def test_timeout_default(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, raising=False)
        assert get_deepdoc_xinference_timeout_seconds() == 1800

    def test_timeout_env_override(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, "600")
        assert get_deepdoc_xinference_timeout_seconds() == 600

    @pytest.mark.parametrize("value", ["not-a-number", "", "0", "-1"])
    def test_timeout_invalid_or_non_positive_falls_back(self, monkeypatch, value):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, value)
        assert get_deepdoc_xinference_timeout_seconds() == 1800

    def test_model_uid_defaults_to_the_family_name(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_MODEL_UID, raising=False)
        assert get_deepdoc_xinference_model_uid() == "DeepDoc"

    def test_model_uid_env_override_is_trimmed(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_MODEL_UID, "  deepdoc-gpu-1  ")
        assert get_deepdoc_xinference_model_uid() == "deepdoc-gpu-1"

    @pytest.mark.parametrize("value", ["", "   "])
    def test_model_uid_blank_falls_back_to_the_default(self, monkeypatch, value):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_MODEL_UID, value)
        assert get_deepdoc_xinference_model_uid() == "DeepDoc"

    def test_username_unset_means_no_token_exchange(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_USERNAME, raising=False)
        assert get_deepdoc_xinference_username() is None

    def test_username_is_trimmed(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_USERNAME, "  admin  ")
        assert get_deepdoc_xinference_username() == "admin"

    @pytest.mark.parametrize("value", ["", "   "])
    def test_username_blank_means_no_token_exchange(self, monkeypatch, value):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_USERNAME, value)
        assert get_deepdoc_xinference_username() is None

    def test_password_unset_means_no_token_exchange(self, monkeypatch):
        monkeypatch.delenv(DEEPDOC_XINFERENCE_PASSWORD, raising=False)
        assert get_deepdoc_xinference_password() is None

    def test_password_blank_means_no_token_exchange(self, monkeypatch):
        monkeypatch.setenv(DEEPDOC_XINFERENCE_PASSWORD, "")
        assert get_deepdoc_xinference_password() is None

    def test_password_preserves_surrounding_whitespace(self, monkeypatch):
        """Whitespace can be significant in a secret, so it is not stripped."""
        monkeypatch.setenv(DEEPDOC_XINFERENCE_PASSWORD, "  pa ss  ")
        assert get_deepdoc_xinference_password() == "  pa ss  "


class TestGetDefaultSqliteDbPath:
    """Test get_default_sqlite_db_path() function."""

    def test_default_sqlite_db_path(self, monkeypatch):
        """Test default SQLite database path."""
        monkeypatch.delenv(STORAGE_ROOT, raising=False)
        result = get_default_sqlite_db_path()
        assert result == str(Path.home() / ".xagent" / "xagent.db")

    def test_sqlite_db_path_respects_storage_root(self, monkeypatch):
        """Test that SQLite path respects STORAGE_ROOT env var."""
        monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")
        result = get_default_sqlite_db_path()
        assert result == "/custom/storage/xagent.db"


class TestGetDatabaseUrl:
    """Test get_database_url() function."""

    def test_default_database_url(self, monkeypatch):
        """Test default database URL (SQLite)."""
        monkeypatch.delenv(DATABASE_URL, raising=False)
        monkeypatch.delenv(STORAGE_ROOT, raising=False)
        result = get_database_url()
        assert result.startswith("sqlite:///")
        assert result.endswith("xagent.db")

    def test_database_url_with_env_var(self, monkeypatch):
        """Test database URL with environment variable."""
        monkeypatch.setenv(DATABASE_URL, "postgresql://user:pass@localhost/db")
        result = get_database_url()
        assert result == "postgresql://user:pass@localhost/db"


class TestDbPoolConfig:
    """Test DB pool sizing getters."""

    def test_defaults(self, monkeypatch):
        monkeypatch.delenv(DB_POOL_SIZE, raising=False)
        monkeypatch.delenv(DB_MAX_OVERFLOW, raising=False)
        monkeypatch.delenv(DB_POOL_TIMEOUT_SECONDS, raising=False)
        assert get_db_pool_size() == 10
        assert get_db_max_overflow() == 20
        assert get_db_pool_timeout_seconds() == 30

    def test_env_overrides(self, monkeypatch):
        monkeypatch.setenv(DB_POOL_SIZE, "25")
        monkeypatch.setenv(DB_MAX_OVERFLOW, "0")
        monkeypatch.setenv(DB_POOL_TIMEOUT_SECONDS, "5")
        assert get_db_pool_size() == 25
        assert get_db_max_overflow() == 0
        assert get_db_pool_timeout_seconds() == 5

    def test_invalid_values_fall_back(self, monkeypatch):
        monkeypatch.setenv(DB_POOL_SIZE, "abc")
        monkeypatch.setenv(DB_MAX_OVERFLOW, "-1")
        monkeypatch.setenv(DB_POOL_TIMEOUT_SECONDS, "0")
        assert get_db_pool_size() == 10
        assert get_db_max_overflow() == 20
        assert get_db_pool_timeout_seconds() == 30


class TestMcpToolInitTimeout:
    """Test get_mcp_tool_init_timeout_seconds() function."""

    def test_default(self, monkeypatch):
        monkeypatch.delenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, raising=False)
        assert get_mcp_tool_init_timeout_seconds() == 60

    def test_env_override(self, monkeypatch):
        monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "120")
        assert get_mcp_tool_init_timeout_seconds() == 120

    def test_zero_disables(self, monkeypatch):
        monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "0")
        assert get_mcp_tool_init_timeout_seconds() == 0

    def test_invalid_falls_back(self, monkeypatch):
        monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "not-a-number")
        assert get_mcp_tool_init_timeout_seconds() == 60


class TestGetSandboxCpus:
    """Test get_sandbox_cpus() function."""

    def test_no_env_var_returns_none(self, monkeypatch):
        """Test that missing env var returns None."""
        monkeypatch.delenv(SANDBOX_CPUS, raising=False)
        result = get_sandbox_cpus()
        assert result is None

    def test_valid_cpu_count(self, monkeypatch):
        """Test valid CPU count from env var."""
        monkeypatch.setenv(SANDBOX_CPUS, "4")
        result = get_sandbox_cpus()
        assert result == 4

    def test_invalid_cpu_count_returns_none(self, monkeypatch):
        """Test that invalid CPU count returns None."""
        monkeypatch.setenv(SANDBOX_CPUS, "invalid")
        result = get_sandbox_cpus()
        assert result is None


class TestGetSandboxMemory:
    """Test get_sandbox_memory() function."""

    def test_no_env_var_returns_none(self, monkeypatch):
        """Test that missing env var returns None."""
        monkeypatch.delenv(SANDBOX_MEMORY, raising=False)
        result = get_sandbox_memory()
        assert result is None

    def test_valid_memory_value(self, monkeypatch):
        """Test valid memory value from env var."""
        monkeypatch.setenv(SANDBOX_MEMORY, "2048")
        result = get_sandbox_memory()
        assert result == 2048

    def test_invalid_memory_value_returns_none(self, monkeypatch):
        """Test that invalid memory value returns None."""
        monkeypatch.setenv(SANDBOX_MEMORY, "invalid")
        result = get_sandbox_memory()
        assert result is None


class TestGetSandboxPidsLimit:
    def test_default_and_override(self, monkeypatch):
        from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit

        monkeypatch.delenv(SANDBOX_PIDS_LIMIT, raising=False)
        assert get_sandbox_pids_limit() == 1024
        monkeypatch.setenv(SANDBOX_PIDS_LIMIT, "2048")
        assert get_sandbox_pids_limit() == 2048

    @pytest.mark.parametrize("value", ["invalid", "-1", "63"])
    def test_invalid_or_too_small_value_uses_default(self, monkeypatch, value):
        from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit

        monkeypatch.setenv(SANDBOX_PIDS_LIMIT, value)
        assert get_sandbox_pids_limit() == 1024

    def test_zero_disables_limit(self, monkeypatch):
        from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit

        monkeypatch.setenv(SANDBOX_PIDS_LIMIT, "0")
        assert get_sandbox_pids_limit() is None


class TestGetSandboxEnv:
    """Test get_sandbox_env() function."""

    def test_no_env_var_returns_empty_dict(self, monkeypatch):
        """Test that missing env var returns empty dict."""
        monkeypatch.delenv(SANDBOX_ENV, raising=False)
        result = get_sandbox_env()
        assert result == {}

    def test_empty_env_var_returns_empty_dict(self, monkeypatch):
        """Test that empty env var returns empty dict."""
        monkeypatch.setenv(SANDBOX_ENV, "")
        result = get_sandbox_env()
        assert result == {}

    def test_valid_env_config(self, monkeypatch):
        """Test valid environment variable configuration."""
        monkeypatch.setenv(SANDBOX_ENV, "KEY1=value1;KEY2=value2")
        result = get_sandbox_env()
        assert result == {"KEY1": "value1", "KEY2": "value2"}

    def test_env_config_with_spaces(self, monkeypatch):
        """Test that spaces around keys/values are trimmed."""
        monkeypatch.setenv(SANDBOX_ENV, " KEY1 = value1 ; KEY2 = value2 ")
        result = get_sandbox_env()
        assert result == {"KEY1": "value1", "KEY2": "value2"}


class TestGetSandboxVolumes:
    """Test get_sandbox_volumes() function."""

    def test_no_env_var_returns_empty_list(self, monkeypatch):
        """Test that missing env var returns empty list."""
        monkeypatch.delenv(SANDBOX_VOLUMES, raising=False)
        result = get_sandbox_volumes()
        assert result == []

    def test_empty_env_var_returns_empty_list(self, monkeypatch):
        """Test that empty env var returns empty list."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "")
        result = get_sandbox_volumes()
        assert result == []

    def test_valid_volume_config(self, monkeypatch):
        """Test valid volume configuration."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:ro")
        result = get_sandbox_volumes()
        assert len(result) == 1
        assert result[0] == ("/host", "/container", "ro")

    def test_volume_with_explicit_mode(self, monkeypatch):
        """Test volume configuration with explicit mode."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:rw")
        result = get_sandbox_volumes()
        assert result[0][2] == "rw"

    def test_volume_defaults_to_readonly(self, monkeypatch):
        """Test that volume defaults to readonly mode."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container")
        result = get_sandbox_volumes()
        assert result[0][2] == "ro"

    def test_invalid_mode_defaults_to_readonly(self, monkeypatch):
        """Test that invalid mode defaults to readonly."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:invalid")
        result = get_sandbox_volumes()
        assert result[0][2] == "ro"

    def test_tilde_expansion_in_volume_src(self, monkeypatch):
        """Test that tilde is expanded in volume source path."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "~/data:/container:ro")
        result = get_sandbox_volumes()
        assert result[0][0] == str(Path.home() / "data")

    def test_multiple_volumes(self, monkeypatch):
        """Test multiple volume configurations."""
        monkeypatch.setenv(
            SANDBOX_VOLUMES, "/host1:/container1:ro;/host2:/container2:rw"
        )
        result = get_sandbox_volumes()
        assert len(result) == 2
        assert result[0] == ("/host1", "/container1", "ro")
        assert result[1] == ("/host2", "/container2", "rw")

    def test_host_side_sources_preserve_absolute_paths(self, monkeypatch):
        """Docker sibling volume sources are already host paths."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "/host/data:/container:rw")
        result = get_sandbox_volumes(host_side_sources=True)
        assert result == [("/host/data", "/container", "rw")]

    def test_host_side_sources_reject_relative_paths(self, monkeypatch):
        """Docker sibling mode should not absolutize relative paths in backend."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "relative/path:/container:ro")
        result = get_sandbox_volumes(host_side_sources=True)
        assert result == []

    def test_host_side_sources_reject_tilde_paths(self, monkeypatch):
        """Docker sibling mode should not expand backend-container home paths."""
        monkeypatch.setenv(SANDBOX_VOLUMES, "~/data:/container:ro")
        result = get_sandbox_volumes(host_side_sources=True)
        assert result == []


class TestGetSandboxHostProjectRoot:
    """Test get_sandbox_host_project_root() function."""

    def test_no_env_var_returns_none(self, monkeypatch):
        """Test that missing env var returns None."""
        monkeypatch.delenv(SANDBOX_HOST_PROJECT_ROOT, raising=False)
        result = get_sandbox_host_project_root()
        assert result is None

    def test_project_root_with_env_var(self, monkeypatch):
        """Test project root with environment variable."""
        monkeypatch.setenv(SANDBOX_HOST_PROJECT_ROOT, "/host/xagent")
        result = get_sandbox_host_project_root()
        assert result == Path("/host/xagent")

    def test_project_root_expands_env_vars_without_user_or_abspath(self, monkeypatch):
        """Host paths should not be resolved against the backend container."""
        monkeypatch.setenv("HOST_PROJECT_ROOT", "/host/xagent")
        monkeypatch.setenv(SANDBOX_HOST_PROJECT_ROOT, "$HOST_PROJECT_ROOT/../xagent")
        result = get_sandbox_host_project_root()
        assert result == Path("/host/xagent/../xagent")


class TestGetSandboxHostStorageRoot:
    """Test get_sandbox_host_storage_root() function."""

    def test_no_env_var_returns_none(self, monkeypatch):
        """Test that missing env var returns None."""
        monkeypatch.delenv(SANDBOX_HOST_STORAGE_ROOT, raising=False)
        result = get_sandbox_host_storage_root()
        assert result is None

    def test_storage_root_with_env_var(self, monkeypatch):
        """Test storage root with environment variable."""
        monkeypatch.setenv(SANDBOX_HOST_STORAGE_ROOT, "/host/.xagent")
        result = get_sandbox_host_storage_root()
        assert result == Path("/host/.xagent")

    def test_storage_root_expands_env_vars_without_user_or_abspath(self, monkeypatch):
        """Host paths should not be resolved against the backend container."""
        monkeypatch.setenv("HOST_STORAGE_ROOT", "/host/.xagent")
        monkeypatch.setenv(SANDBOX_HOST_STORAGE_ROOT, "$HOST_STORAGE_ROOT/../.xagent")
        result = get_sandbox_host_storage_root()
        assert result == Path("/host/.xagent/../.xagent")


class TestGetSandboxNamespace:
    """Test get_sandbox_namespace() function."""

    def test_no_env_var_returns_none(self, monkeypatch):
        """Test that a missing namespace returns None."""
        monkeypatch.delenv(SANDBOX_NAMESPACE, raising=False)
        result = get_sandbox_namespace()
        assert result is None

    def test_blank_env_var_returns_none(self, monkeypatch):
        """Test that a blank namespace returns None."""
        monkeypatch.setenv(SANDBOX_NAMESPACE, "   ")
        result = get_sandbox_namespace()
        assert result is None

    def test_valid_namespace(self, monkeypatch):
        """Test that a Compose-project-name-shaped namespace is accepted."""
        monkeypatch.setenv(SANDBOX_NAMESPACE, "my-project-1")
        result = get_sandbox_namespace()
        assert result == "my-project-1"

    @pytest.mark.parametrize(
        "value",
        [
            "Upper-Case",
            "-leading-dash",
            "has space",
            ":",
            "a::b",
            "a/b",
            "a.b",
            "café",
        ],
    )
    def test_invalid_namespace_raises(self, monkeypatch, value):
        """Test that malformed namespaces raise instead of silently degrading."""
        monkeypatch.setenv(SANDBOX_NAMESPACE, value)
        with pytest.raises(ValueError, match="Invalid sandbox namespace"):
            get_sandbox_namespace()

    def test_validation_helper_rejects_empty_namespace(self):
        """Direct callers must not bypass the getter's blank-to-None policy."""
        with pytest.raises(ValueError, match="Invalid sandbox namespace"):
            validate_sandbox_namespace("")

    def test_long_namespace_accepted_like_compose(self, monkeypatch):
        """Compose accepts arbitrary-length project names; so must we.

        Container identities hash the full namespace, label values preserve
        it, and snapshot repository names use a bounded sanitized token plus
        a digest, so backend identifiers do not impose a namespace length cap.
        """
        monkeypatch.setenv(SANDBOX_NAMESPACE, "a" * 100)
        assert get_sandbox_namespace() == "a" * 100


class TestGetSandboxNetwork:
    def test_missing_or_blank_returns_none(self, monkeypatch):
        monkeypatch.delenv(SANDBOX_NETWORK, raising=False)
        assert get_sandbox_network() is None
        monkeypatch.setenv(SANDBOX_NETWORK, "  ")
        assert get_sandbox_network() is None

    def test_dedicated_network_name_is_accepted(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_NETWORK, "stage_sandbox-egress.v1")
        assert get_sandbox_network() == "stage_sandbox-egress.v1"

    @pytest.mark.parametrize(
        "value",
        ["bridge", "host", "none", "default", "has space", "/bad", "a" * 256],
    )
    def test_builtin_or_malformed_network_is_rejected(self, monkeypatch, value):
        monkeypatch.setenv(SANDBOX_NETWORK, value)
        with pytest.raises(ValueError, match="Invalid sandbox network"):
            get_sandbox_network()

    def test_direct_validation_is_fail_closed(self):
        with pytest.raises(ValueError, match="Invalid sandbox network"):
            validate_sandbox_network("")


class TestSandboxWorkspaceMountConfig:
    def test_mount_mode_defaults_to_bind(self, monkeypatch):
        monkeypatch.delenv(SANDBOX_WORKSPACE_MOUNT_MODE, raising=False)
        assert get_sandbox_workspace_mount_mode() == "bind"

    def test_volume_subpath_mode_and_settings(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_WORKSPACE_MOUNT_MODE, "volume_subpath")
        monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME, "xagent-stage-workspaces")
        monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME_ROOT, "/root/.xagent/uploads")
        assert get_sandbox_workspace_mount_mode() == "volume_subpath"
        assert get_sandbox_workspace_volume() == "xagent-stage-workspaces"
        assert get_sandbox_workspace_volume_root() == Path("/root/.xagent/uploads")

    @pytest.mark.parametrize("value", ["", "volume", "host", "named-volume"])
    def test_invalid_mount_mode_is_rejected(self, monkeypatch, value):
        monkeypatch.setenv(SANDBOX_WORKSPACE_MOUNT_MODE, value)
        if value == "":
            assert get_sandbox_workspace_mount_mode() == "bind"
        else:
            with pytest.raises(ValueError, match=SANDBOX_WORKSPACE_MOUNT_MODE):
                get_sandbox_workspace_mount_mode()

    @pytest.mark.parametrize("value", ["/host/path", "bad volume", "a"])
    def test_invalid_volume_name_is_rejected(self, monkeypatch, value):
        monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME, value)
        with pytest.raises(ValueError, match="Docker volume name"):
            get_sandbox_workspace_volume()

    def test_relative_volume_root_is_rejected(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME_ROOT, "uploads")
        with pytest.raises(ValueError, match="absolute path"):
            get_sandbox_workspace_volume_root()


class TestGetMaxTracePayloadBytes:
    """Test get_max_trace_payload_bytes() function."""

    def test_default(self, monkeypatch):
        monkeypatch.delenv(MAX_TRACE_PAYLOAD_BYTES, raising=False)
        assert get_max_trace_payload_bytes() == 50_000

    def test_env_override(self, monkeypatch):
        monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "1234")
        assert get_max_trace_payload_bytes() == 1234

    def test_zero_passes_through(self, monkeypatch):
        """Zero disables truncation (handled by truncate_for_trace)."""
        monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "0")
        assert get_max_trace_payload_bytes() == 0

    def test_invalid_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "not-a-number")
        assert get_max_trace_payload_bytes() == 50_000

    def test_negative_falls_back_to_default(self, monkeypatch):
        monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "-100")
        assert get_max_trace_payload_bytes() == 50_000


class TestToolConcurrencyConfig:
    """Config for in-turn tool concurrency (design §7)."""

    def test_parallel_enabled_default_is_false(self, monkeypatch):
        from xagent.config import get_tool_parallel_enabled

        monkeypatch.delenv("XAGENT_TOOL_PARALLEL_ENABLED", raising=False)
        assert get_tool_parallel_enabled() is False

    def test_parallel_enabled_env_override(self, monkeypatch):
        from xagent.config import get_tool_parallel_enabled

        monkeypatch.setenv("XAGENT_TOOL_PARALLEL_ENABLED", "true")
        assert get_tool_parallel_enabled() is True
        monkeypatch.setenv("XAGENT_TOOL_PARALLEL_ENABLED", "0")
        assert get_tool_parallel_enabled() is False

    def test_max_concurrency_default_is_three(self, monkeypatch):
        from xagent.config import get_tool_max_concurrency

        monkeypatch.delenv("XAGENT_TOOL_MAX_CONCURRENCY", raising=False)
        assert get_tool_max_concurrency() == 3

    def test_max_concurrency_env_override(self, monkeypatch):
        from xagent.config import get_tool_max_concurrency

        monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "8")
        assert get_tool_max_concurrency() == 8

    def test_max_concurrency_invalid_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_tool_max_concurrency

        monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "not-a-number")
        assert get_tool_max_concurrency() == 3
        monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "0")
        assert get_tool_max_concurrency() == 3


class TestTaskRuntimeHookConfig:
    def test_defaults(self, monkeypatch):
        monkeypatch.delenv(TASK_RUNTIME_HOOK_MAX_WORKERS, raising=False)
        monkeypatch.delenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, raising=False)

        assert get_task_runtime_hook_max_workers() == 8
        assert get_task_runtime_hook_queue_timeout_seconds() == 30

    def test_env_overrides(self, monkeypatch):
        monkeypatch.setenv(TASK_RUNTIME_HOOK_MAX_WORKERS, "12")
        monkeypatch.setenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, "45")

        assert get_task_runtime_hook_max_workers() == 12
        assert get_task_runtime_hook_queue_timeout_seconds() == 45

    def test_invalid_values_fall_back(self, monkeypatch):
        monkeypatch.setenv(TASK_RUNTIME_HOOK_MAX_WORKERS, "0")
        monkeypatch.setenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, "invalid")

        assert get_task_runtime_hook_max_workers() == 8
        assert get_task_runtime_hook_queue_timeout_seconds() == 30


class TestLocalBrowserConfig:
    def test_defaults(self, monkeypatch):
        for name in (
            NATIVE_BROWSER_ENABLED,
            NATIVE_BROWSER_APP_NAME,
            BROWSER_CUA_DRIVER_COMMAND,
            BROWSER_CUA_DRIVER_SOCKET,
            BROWSER_CUA_DRIVER_TIMEOUT_SECONDS,
            BROWSER_CUA_DRIVER_MAX_ELEMENTS,
        ):
            monkeypatch.delenv(name, raising=False)

        assert get_native_browser_enabled() is False
        assert get_native_browser_app_name() == "Google Chrome"
        assert get_browser_cua_driver_command() == "cua-driver"
        assert get_browser_cua_driver_socket() is None
        assert get_browser_cua_driver_timeout_seconds() == 30
        assert get_browser_cua_driver_max_elements() == 2_000

    def test_env_overrides(self, monkeypatch):
        monkeypatch.setenv(NATIVE_BROWSER_ENABLED, "true")
        monkeypatch.setenv(NATIVE_BROWSER_APP_NAME, "Chromium")
        monkeypatch.setenv(BROWSER_CUA_DRIVER_COMMAND, "/opt/bin/cua-driver")
        monkeypatch.setenv(BROWSER_CUA_DRIVER_SOCKET, "/tmp/cua.sock")
        monkeypatch.setenv(BROWSER_CUA_DRIVER_TIMEOUT_SECONDS, "12.5")
        monkeypatch.setenv(BROWSER_CUA_DRIVER_MAX_ELEMENTS, "250")

        assert get_native_browser_enabled() is True
        assert get_native_browser_app_name() == "Chromium"
        assert get_browser_cua_driver_command() == "/opt/bin/cua-driver"
        assert get_browser_cua_driver_socket() == "/tmp/cua.sock"
        assert get_browser_cua_driver_timeout_seconds() == 12.5
        assert get_browser_cua_driver_max_elements() == 250

    def test_invalid_values_fall_back(self, monkeypatch):
        monkeypatch.setenv(BROWSER_CUA_DRIVER_TIMEOUT_SECONDS, "0")
        monkeypatch.setenv(BROWSER_CUA_DRIVER_MAX_ELEMENTS, "invalid")

        assert get_browser_cua_driver_timeout_seconds() == 30
        assert get_browser_cua_driver_max_elements() == 2_000

    def test_rejects_non_browser_native_application(self, monkeypatch):
        monkeypatch.setenv(NATIVE_BROWSER_APP_NAME, "Terminal")

        with pytest.raises(ValueError, match="must name a supported browser"):
            get_native_browser_app_name()


class TestBrowserToolDefaultLocaleConfig:
    """Fallback locale/timezone for browser_use (Playwright) sessions."""

    def test_defaults(self, monkeypatch):
        monkeypatch.delenv(config.BROWSER_TOOL_DEFAULT_LOCALE, raising=False)
        monkeypatch.delenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, raising=False)

        assert config.get_browser_tool_default_locale() == "en-US"
        assert config.get_browser_tool_default_timezone() is None

    def test_env_overrides(self, monkeypatch):
        monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_LOCALE, "ja-JP")
        monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, "Asia/Tokyo")

        assert config.get_browser_tool_default_locale() == "ja-JP"
        assert config.get_browser_tool_default_timezone() == "Asia/Tokyo"

    def test_blank_values_fall_back(self, monkeypatch):
        monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_LOCALE, "   ")
        monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, "")

        assert config.get_browser_tool_default_locale() == "en-US"
        assert config.get_browser_tool_default_timezone() is None


class TestBrowserSandboxConfig:
    def test_defaults_to_sandboxed(self, monkeypatch):
        monkeypatch.delenv(config.BROWSER_ALLOW_UNSANDBOXED, raising=False)
        assert config.get_browser_allow_unsandboxed() is False

    def test_env_override(self, monkeypatch):
        monkeypatch.setenv(config.BROWSER_ALLOW_UNSANDBOXED, "true")
        assert config.get_browser_allow_unsandboxed() is True


class TestBrowserRunAsConfig:
    def test_unset_returns_none(self, monkeypatch):
        monkeypatch.delenv(config.BROWSER_RUN_AS_UID, raising=False)
        monkeypatch.delenv(config.BROWSER_RUN_AS_GID, raising=False)

        assert config.get_browser_run_as() is None

    @pytest.mark.parametrize(("uid", "gid"), [("", ""), ("   ", "\t")])
    def test_blank_values_return_none(self, monkeypatch, uid, gid):
        monkeypatch.setenv(config.BROWSER_RUN_AS_UID, uid)
        monkeypatch.setenv(config.BROWSER_RUN_AS_GID, gid)

        assert config.get_browser_run_as() is None

    @pytest.mark.parametrize(("uid", "gid"), [("", "1000"), ("1000", "   ")])
    def test_one_blank_value_requires_both(self, monkeypatch, uid, gid):
        monkeypatch.setenv(config.BROWSER_RUN_AS_UID, uid)
        monkeypatch.setenv(config.BROWSER_RUN_AS_GID, gid)

        with pytest.raises(ValueError, match="must be set together"):
            config.get_browser_run_as()

    def test_both_set_returns_tuple(self, monkeypatch):
        monkeypatch.setenv(config.BROWSER_RUN_AS_UID, "1000")
        monkeypatch.setenv(config.BROWSER_RUN_AS_GID, "1001")

        assert config.get_browser_run_as() == (1000, 1001)

    @pytest.mark.parametrize(
        ("uid", "gid"),
        [
            ("1000", None),
            (None, "1000"),
            ("not-a-number", "1000"),
            ("1000", "not-a-number"),
            ("0", "1000"),
            ("1000", "0"),
            ("-1", "1000"),
            ("1000", "-2"),
            ("4294967295", "1000"),
        ],
    )
    def test_invalid_settings_raise(self, monkeypatch, uid, gid):
        for name, value in (
            (config.BROWSER_RUN_AS_UID, uid),
            (config.BROWSER_RUN_AS_GID, gid),
        ):
            if value is None:
                monkeypatch.delenv(name, raising=False)
            else:
                monkeypatch.setenv(name, value)

        with pytest.raises(ValueError):
            config.get_browser_run_as()


class TestCheckpointStorageConfig:
    """Config for checkpoint trace-event storage encoding and retention."""

    def test_encoding_v2_default_is_true(self, monkeypatch):
        from xagent.config import get_checkpoint_encoding_v2_enabled

        monkeypatch.delenv("XAGENT_CHECKPOINT_ENCODING_V2", raising=False)
        assert get_checkpoint_encoding_v2_enabled() is True

    def test_encoding_v2_env_override(self, monkeypatch):
        from xagent.config import get_checkpoint_encoding_v2_enabled

        monkeypatch.setenv("XAGENT_CHECKPOINT_ENCODING_V2", "false")
        assert get_checkpoint_encoding_v2_enabled() is False
        monkeypatch.setenv("XAGENT_CHECKPOINT_ENCODING_V2", "1")
        assert get_checkpoint_encoding_v2_enabled() is True

    def test_history_limit_default_is_eight(self, monkeypatch):
        from xagent.config import get_checkpoint_history_limit

        monkeypatch.delenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", raising=False)
        assert get_checkpoint_history_limit() == 8

    def test_history_limit_env_override_and_zero_disables(self, monkeypatch):
        from xagent.config import get_checkpoint_history_limit

        monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "20")
        assert get_checkpoint_history_limit() == 20
        monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "0")
        assert get_checkpoint_history_limit() == 0

    def test_history_limit_invalid_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_checkpoint_history_limit

        monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "not-a-number")
        assert get_checkpoint_history_limit() == 8
        monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "-1")
        assert get_checkpoint_history_limit() == 8


class TestSandboxConcurrencyConfig:
    """Config for sandbox worker concurrency."""

    def test_sandbox_max_concurrency_default_is_three(self, monkeypatch):
        from xagent.config import get_sandbox_max_concurrency

        monkeypatch.delenv("XAGENT_SANDBOX_MAX_CONCURRENCY", raising=False)
        assert get_sandbox_max_concurrency() == 3

    def test_sandbox_max_concurrency_env_override(self, monkeypatch):
        from xagent.config import get_sandbox_max_concurrency

        monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "5")
        assert get_sandbox_max_concurrency() == 5

    def test_sandbox_max_concurrency_invalid_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_sandbox_max_concurrency

        monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "not-a-number")
        assert get_sandbox_max_concurrency() == 3
        monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "0")
        assert get_sandbox_max_concurrency() == 3


class TestTriggerRateLimitConfig:
    """Config for trigger callback and CRUD rate limits."""

    def test_callback_rate_limit_default(self, monkeypatch):
        from xagent.config import get_trigger_callback_rate_limit

        monkeypatch.delenv("XAGENT_TRIGGER_CALLBACK_RATE_LIMIT", raising=False)
        assert get_trigger_callback_rate_limit() == "120/minute"

    def test_callback_rate_limit_env_override(self, monkeypatch):
        from xagent.config import get_trigger_callback_rate_limit

        monkeypatch.setenv("XAGENT_TRIGGER_CALLBACK_RATE_LIMIT", "10/second")
        assert get_trigger_callback_rate_limit() == "10/second"

    def test_crud_rate_limit_default(self, monkeypatch):
        from xagent.config import get_trigger_crud_rate_limit

        monkeypatch.delenv("XAGENT_TRIGGER_CRUD_RATE_LIMIT", raising=False)
        assert get_trigger_crud_rate_limit() == "60/minute"

    def test_crud_rate_limit_env_override(self, monkeypatch):
        from xagent.config import get_trigger_crud_rate_limit

        monkeypatch.setenv("XAGENT_TRIGGER_CRUD_RATE_LIMIT", "5/minute")
        assert get_trigger_crud_rate_limit() == "5/minute"


class TestShareRateLimitConfig:
    """Config for public share-channel rate limits and run quotas (#973)."""

    _CASES = [
        ("get_share_auth_rate_limit", "XAGENT_SHARE_AUTH_RATE_LIMIT", "60/minute"),
        (
            "get_share_auth_ip_rate_limit",
            "XAGENT_SHARE_AUTH_IP_RATE_LIMIT",
            "300/minute",
        ),
        (
            "get_share_task_create_rate_limit",
            "XAGENT_SHARE_TASK_CREATE_RATE_LIMIT",
            "30/minute",
        ),
        (
            "get_share_task_create_token_rate_limit",
            "XAGENT_SHARE_TASK_CREATE_TOKEN_RATE_LIMIT",
            "120/minute",
        ),
        (
            "get_share_ws_turn_rate_limit",
            "XAGENT_SHARE_WS_TURN_RATE_LIMIT",
            "60/minute",
        ),
        (
            "get_share_ws_connect_ip_rate_limit",
            "XAGENT_SHARE_WS_CONNECT_IP_RATE_LIMIT",
            "120/minute",
        ),
        ("get_share_upload_rate_limit", "XAGENT_SHARE_UPLOAD_RATE_LIMIT", "60/minute"),
        (
            "get_widget_upload_rate_limit",
            "XAGENT_WIDGET_UPLOAD_RATE_LIMIT",
            "240/minute",
        ),
        (
            "get_widget_upload_ip_rate_limit",
            "XAGENT_WIDGET_UPLOAD_IP_RATE_LIMIT",
            "60/minute",
        ),
        ("get_share_run_quota", "XAGENT_SHARE_RUN_QUOTA", "500/day"),
        ("get_share_run_guest_quota", "XAGENT_SHARE_RUN_GUEST_QUOTA", "60/hour"),
        (
            "get_widget_ws_connect_ip_rate_limit",
            "XAGENT_WIDGET_WS_CONNECT_IP_RATE_LIMIT",
            "120/minute",
        ),
        (
            "get_widget_ws_turn_ip_rate_limit",
            "XAGENT_WIDGET_WS_TURN_IP_RATE_LIMIT",
            "60/minute",
        ),
        (
            "get_widget_ws_turn_rate_limit",
            "XAGENT_WIDGET_WS_TURN_RATE_LIMIT",
            "240/minute",
        ),
        (
            "get_widget_auth_rate_limit",
            "XAGENT_WIDGET_AUTH_RATE_LIMIT",
            "1200/minute",
        ),
        (
            "get_widget_auth_ip_rate_limit",
            "XAGENT_WIDGET_AUTH_IP_RATE_LIMIT",
            "300/minute",
        ),
        (
            "get_widget_task_create_rate_limit",
            "XAGENT_WIDGET_TASK_CREATE_RATE_LIMIT",
            "240/minute",
        ),
        (
            "get_widget_task_create_ip_rate_limit",
            "XAGENT_WIDGET_TASK_CREATE_IP_RATE_LIMIT",
            "60/minute",
        ),
        ("get_widget_run_quota", "XAGENT_WIDGET_RUN_QUOTA", "500/day"),
        ("get_widget_run_ip_quota", "XAGENT_WIDGET_RUN_IP_QUOTA", "120/hour"),
    ]

    @pytest.mark.parametrize("func_name,env_var,default", _CASES)
    def test_default(self, monkeypatch, func_name, env_var, default):
        import xagent.config as config

        monkeypatch.delenv(env_var, raising=False)
        assert getattr(config, func_name)() == default

    @pytest.mark.parametrize("func_name,env_var,default", _CASES)
    def test_env_override(self, monkeypatch, func_name, env_var, default):
        import xagent.config as config

        monkeypatch.setenv(env_var, "7/second")
        assert getattr(config, func_name)() == "7/second"

    @pytest.mark.parametrize("func_name,env_var,default", _CASES)
    def test_blank_env_falls_back_to_default(
        self, monkeypatch, func_name, env_var, default
    ):
        import xagent.config as config

        monkeypatch.setenv(env_var, "   ")
        assert getattr(config, func_name)() == default


class TestOrphanUploadGcConfig:
    """Config for task-less public-upload orphan GC (#973)."""

    def test_ttl_default(self, monkeypatch):
        from xagent.config import get_taskless_upload_ttl_seconds

        monkeypatch.delenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", raising=False)
        assert get_taskless_upload_ttl_seconds() == 48 * 60 * 60

    def test_ttl_env_override(self, monkeypatch):
        from xagent.config import get_taskless_upload_ttl_seconds

        monkeypatch.setenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", "86400")
        assert get_taskless_upload_ttl_seconds() == 86400

    def test_ttl_below_minimum_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_taskless_upload_ttl_seconds

        # Below the 1h floor -> default (guards against reaping mid-first-turn).
        monkeypatch.setenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", "5")
        assert get_taskless_upload_ttl_seconds() == 48 * 60 * 60

    def test_sweep_interval_default(self, monkeypatch):
        from xagent.config import get_orphan_upload_sweep_interval_seconds

        monkeypatch.delenv("XAGENT_ORPHAN_UPLOAD_SWEEP_INTERVAL_SECONDS", raising=False)
        assert get_orphan_upload_sweep_interval_seconds() == 3600

    def test_sweep_interval_env_override(self, monkeypatch):
        from xagent.config import get_orphan_upload_sweep_interval_seconds

        monkeypatch.setenv("XAGENT_ORPHAN_UPLOAD_SWEEP_INTERVAL_SECONDS", "900")
        assert get_orphan_upload_sweep_interval_seconds() == 900


class TestComposioReconcileConfig:
    """How often unbound Composio accounts are cleaned up (#3548)."""

    def test_off_unless_set(self, monkeypatch):
        from xagent.config import get_composio_reconcile_interval_seconds

        monkeypatch.delenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", raising=False)
        assert get_composio_reconcile_interval_seconds() is None
        monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", " ")
        assert get_composio_reconcile_interval_seconds() is None

    def test_a_set_interval_has_a_floor(self, monkeypatch):
        from xagent.config import get_composio_reconcile_interval_seconds

        monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", "900")
        assert get_composio_reconcile_interval_seconds() == 900
        for invalid in ("5", "hourly"):
            monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", invalid)
            assert get_composio_reconcile_interval_seconds() is None


class TestComposioMissingAccountConfig:
    """How often grants whose Composio account is gone are cleared."""

    def test_on_by_default(self, monkeypatch):
        from xagent.config import get_composio_missing_account_interval_seconds

        monkeypatch.delenv(
            "XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", raising=False
        )
        assert get_composio_missing_account_interval_seconds() == 3600
        monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", " ")
        assert get_composio_missing_account_interval_seconds() == 3600

    def test_zero_turns_it_off(self, monkeypatch):
        from xagent.config import get_composio_missing_account_interval_seconds

        monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", "0")
        assert get_composio_missing_account_interval_seconds() == 0

    def test_a_set_interval_has_a_floor(self, monkeypatch):
        from xagent.config import get_composio_missing_account_interval_seconds

        monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", "900")
        assert get_composio_missing_account_interval_seconds() == 900
        for invalid in ("5", "hourly", "-1"):
            monkeypatch.setenv(
                "XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", invalid
            )
            assert get_composio_missing_account_interval_seconds() == 3600


class TestTaskCleanupRetryConfig:
    """Config for retrying the external cleanup a task deletion owes (#2587)."""

    def test_retry_interval_default(self, monkeypatch):
        from xagent.config import get_task_cleanup_retry_interval_seconds

        monkeypatch.delenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", raising=False)
        assert get_task_cleanup_retry_interval_seconds() == 300

    def test_retry_interval_env_override(self, monkeypatch):
        from xagent.config import get_task_cleanup_retry_interval_seconds

        monkeypatch.setenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", "120")
        assert get_task_cleanup_retry_interval_seconds() == 120

    def test_retry_interval_below_minimum_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_task_cleanup_retry_interval_seconds

        monkeypatch.setenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", "1")
        assert get_task_cleanup_retry_interval_seconds() == 300

    def test_max_attempts_default(self, monkeypatch):
        from xagent.config import get_task_cleanup_max_attempts

        monkeypatch.delenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", raising=False)
        assert get_task_cleanup_max_attempts() == 8

    def test_max_attempts_env_override(self, monkeypatch):
        from xagent.config import get_task_cleanup_max_attempts

        monkeypatch.setenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", "3")
        assert get_task_cleanup_max_attempts() == 3

    def test_max_attempts_zero_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_task_cleanup_max_attempts

        monkeypatch.setenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", "0")
        assert get_task_cleanup_max_attempts() == 8


class TestLlmRetryBudgetConfig:
    """#2605: the two bounds that attempt counting cannot express."""

    def test_deadline_default(self, monkeypatch):
        from xagent.config import get_llm_retry_deadline_seconds

        monkeypatch.delenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", raising=False)
        assert get_llm_retry_deadline_seconds() == 300.0

    def test_deadline_env_override(self, monkeypatch):
        from xagent.config import get_llm_retry_deadline_seconds

        monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", "45.5")
        assert get_llm_retry_deadline_seconds() == 45.5

    @pytest.mark.parametrize(
        "value", ["", "   ", "not-a-number", "0", "-5", "nan", "inf"]
    )
    def test_deadline_rejects_unusable_values(self, monkeypatch, value):
        """An unbounded loop is the bug; never let bad config reintroduce it."""
        from xagent.config import get_llm_retry_deadline_seconds

        monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", value)
        assert get_llm_retry_deadline_seconds() == 300.0

    def test_capacity_attempts_default(self, monkeypatch):
        from xagent.config import get_llm_capacity_max_attempts

        monkeypatch.delenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", raising=False)
        assert get_llm_capacity_max_attempts() == 2

    def test_capacity_attempts_env_override(self, monkeypatch):
        from xagent.config import get_llm_capacity_max_attempts

        monkeypatch.setenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", "1")
        assert get_llm_capacity_max_attempts() == 1

    @pytest.mark.parametrize("value", ["", "1.5", "not-a-number", "0", "-3"])
    def test_capacity_attempts_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_llm_capacity_max_attempts

        monkeypatch.setenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", value)
        assert get_llm_capacity_max_attempts() == 2

    def test_auto_primary_attempts_default(self, monkeypatch):
        from xagent.config import get_auto_primary_max_attempts

        monkeypatch.delenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", raising=False)
        assert get_auto_primary_max_attempts() == 2

    def test_auto_primary_attempts_env_override(self, monkeypatch):
        from xagent.config import get_auto_primary_max_attempts

        monkeypatch.setenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", "3")
        assert get_auto_primary_max_attempts() == 3

    @pytest.mark.parametrize("value", ["", "1.5", "not-a-number", "0", "-3"])
    def test_auto_primary_attempts_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_auto_primary_max_attempts

        monkeypatch.setenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", value)
        assert get_auto_primary_max_attempts() == 2

    def test_auto_candidate_cooldown_default(self, monkeypatch):
        from xagent.config import get_auto_candidate_cooldown_seconds

        monkeypatch.delenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", raising=False)
        assert get_auto_candidate_cooldown_seconds() == 300.0

    def test_auto_candidate_cooldown_env_override(self, monkeypatch):
        from xagent.config import get_auto_candidate_cooldown_seconds

        monkeypatch.setenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", "45.5")
        assert get_auto_candidate_cooldown_seconds() == 45.5

    @pytest.mark.parametrize("value", ["", "not-a-number", "0", "-3", "nan", "inf"])
    def test_auto_candidate_cooldown_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_auto_candidate_cooldown_seconds

        monkeypatch.setenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", value)
        assert get_auto_candidate_cooldown_seconds() == 300.0


class TestConnectorProbeUsersConfig:
    def test_connector_probe_users_unset(self, monkeypatch):
        from xagent.config import get_connector_probe_users

        monkeypatch.delenv("XAGENT_CONNECTOR_PROBE_USERS", raising=False)
        result = get_connector_probe_users()
        assert result == frozenset()
        assert isinstance(result, frozenset)

    def test_connector_probe_users_parses_and_strips(self, monkeypatch):
        from xagent.config import get_connector_probe_users

        monkeypatch.setenv(
            "XAGENT_CONNECTOR_PROBE_USERS", " [email protected] , ops,,  "
        )
        assert get_connector_probe_users() == {"[email protected]", "ops"}

    def test_connector_probe_users_blank(self, monkeypatch):
        from xagent.config import get_connector_probe_users

        monkeypatch.setenv("XAGENT_CONNECTOR_PROBE_USERS", "  ,  ")
        assert get_connector_probe_users() == frozenset()


class TestConnectorSmokeWriteAppsConfig:
    """#3564: the connectors whose smoke V2 write checks may run."""

    def test_unset_runs_no_write_check(self, monkeypatch):
        from xagent.config import get_connector_smoke_write_apps

        monkeypatch.delenv("XAGENT_CONNECTOR_SMOKE_WRITE_APPS", raising=False)
        result = get_connector_smoke_write_apps()
        assert result == frozenset()
        assert isinstance(result, frozenset)

    def test_parses_and_strips_app_ids(self, monkeypatch):
        from xagent.config import get_connector_smoke_write_apps

        monkeypatch.setenv(
            "XAGENT_CONNECTOR_SMOKE_WRITE_APPS", " jira , google-drive,,  "
        )
        assert get_connector_smoke_write_apps() == {"jira", "google-drive"}

    def test_blank_runs_no_write_check(self, monkeypatch):
        from xagent.config import get_connector_smoke_write_apps

        monkeypatch.setenv("XAGENT_CONNECTOR_SMOKE_WRITE_APPS", "  ,  ")
        assert get_connector_smoke_write_apps() == frozenset()


class TestLlmStreamProgressConfig:
    """#2785: knobs for aborting an OpenAI-compatible LLM stream that stops
    making progress."""

    def test_empty_delta_limit_default(self, monkeypatch):
        from xagent.config import get_llm_stream_empty_delta_limit

        monkeypatch.delenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", raising=False)
        assert get_llm_stream_empty_delta_limit() == 200

    def test_empty_delta_limit_env_override(self, monkeypatch):
        from xagent.config import get_llm_stream_empty_delta_limit

        monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", "50")
        assert get_llm_stream_empty_delta_limit() == 50

    def test_empty_delta_limit_zero_disables(self, monkeypatch):
        """0 is a valid, explicit way to disable the check."""
        from xagent.config import get_llm_stream_empty_delta_limit

        monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", "0")
        assert get_llm_stream_empty_delta_limit() == 0

    @pytest.mark.parametrize("value", ["abc", "-5"])
    def test_empty_delta_limit_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_llm_stream_empty_delta_limit

        monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", value)
        assert get_llm_stream_empty_delta_limit() == 200

    def test_degenerate_window_default(self, monkeypatch):
        from xagent.config import get_llm_stream_degenerate_window

        monkeypatch.delenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", raising=False)
        assert get_llm_stream_degenerate_window() == 256

    def test_degenerate_window_env_override(self, monkeypatch):
        from xagent.config import get_llm_stream_degenerate_window

        monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", "128")
        assert get_llm_stream_degenerate_window() == 128

    def test_degenerate_window_zero_disables(self, monkeypatch):
        """0 is a valid, explicit way to disable the check."""
        from xagent.config import get_llm_stream_degenerate_window

        monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", "0")
        assert get_llm_stream_degenerate_window() == 0

    @pytest.mark.parametrize("value", ["abc", "-5"])
    def test_degenerate_window_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_llm_stream_degenerate_window

        monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", value)
        assert get_llm_stream_degenerate_window() == 256

    def test_degenerate_max_period_default(self, monkeypatch):
        from xagent.config import get_llm_stream_degenerate_max_period

        monkeypatch.delenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", raising=False)
        assert get_llm_stream_degenerate_max_period() == 64

    def test_degenerate_max_period_env_override(self, monkeypatch):
        from xagent.config import get_llm_stream_degenerate_max_period

        monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", "32")
        assert get_llm_stream_degenerate_max_period() == 32

    @pytest.mark.parametrize("value", ["abc", "-5", "0"])
    def test_degenerate_max_period_rejects_unusable_values(self, monkeypatch, value):
        """Unlike the window/limit knobs, 0 is below the minimum of 1 here."""
        from xagent.config import get_llm_stream_degenerate_max_period

        monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", value)
        assert get_llm_stream_degenerate_max_period() == 64

    def test_no_payload_abort_models_unset(self, monkeypatch):
        from xagent.config import get_llm_stream_no_payload_abort_models

        monkeypatch.delenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", raising=False)
        result = get_llm_stream_no_payload_abort_models()
        assert result == frozenset()
        assert isinstance(result, frozenset)

    def test_no_payload_abort_models_parses_and_strips(self, monkeypatch):
        from xagent.config import get_llm_stream_no_payload_abort_models

        monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", " a , b,,c ")
        result = get_llm_stream_no_payload_abort_models()
        assert result == {"a", "b", "c"}
        assert isinstance(result, frozenset)

    def test_no_payload_abort_models_blank(self, monkeypatch):
        from xagent.config import get_llm_stream_no_payload_abort_models

        monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", "   ")
        result = get_llm_stream_no_payload_abort_models()
        assert result == frozenset()
        assert isinstance(result, frozenset)

    def test_no_payload_timeout_invalid_value_logs_the_real_default(
        self, monkeypatch, caplog
    ):
        import logging

        from xagent.config import get_llm_stream_no_payload_timeout_seconds

        monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", "abc")
        with caplog.at_level(logging.WARNING, logger="xagent.config"):
            assert get_llm_stream_no_payload_timeout_seconds() == 30.0
        assert any("falling back to 30.0" in r.getMessage() for r in caplog.records)

    def test_retry_deadline_invalid_value_logs_the_real_default(
        self, monkeypatch, caplog
    ):
        import logging

        from xagent.config import get_llm_retry_deadline_seconds

        monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", "abc")
        with caplog.at_level(logging.WARNING, logger="xagent.config"):
            assert get_llm_retry_deadline_seconds() == 300.0
        assert any("falling back to 300.0" in r.getMessage() for r in caplog.records)

    def test_no_payload_timeout_default(self, monkeypatch):
        from xagent.config import get_llm_stream_no_payload_timeout_seconds

        monkeypatch.delenv(
            "XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", raising=False
        )
        assert get_llm_stream_no_payload_timeout_seconds() == 30.0

    def test_no_payload_timeout_env_override(self, monkeypatch):
        from xagent.config import get_llm_stream_no_payload_timeout_seconds

        monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", "15.5")
        assert get_llm_stream_no_payload_timeout_seconds() == 15.5

    @pytest.mark.parametrize("value", ["0", "nan", "abc"])
    def test_no_payload_timeout_rejects_unusable_values(self, monkeypatch, value):
        from xagent.config import get_llm_stream_no_payload_timeout_seconds

        monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", value)
        assert get_llm_stream_no_payload_timeout_seconds() == 30.0


class TestWorkforcePreviewRunReapConfig:
    """PR #1060 review: get_workforce_preview_run_stale_seconds() had no
    test, unlike its sibling TTL config functions above."""

    def test_default(self, monkeypatch):
        from xagent.config import get_workforce_preview_run_stale_seconds

        monkeypatch.delenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", raising=False)
        assert get_workforce_preview_run_stale_seconds() == 7200

    def test_env_override(self, monkeypatch):
        from xagent.config import get_workforce_preview_run_stale_seconds

        monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "3600")
        assert get_workforce_preview_run_stale_seconds() == 3600

    def test_below_minimum_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_workforce_preview_run_stale_seconds

        # Below the 300s floor -> default (guards against reaping a preview
        # run that is still genuinely in progress).
        monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "5")
        assert get_workforce_preview_run_stale_seconds() == 7200

    def test_invalid_value_falls_back_to_default(self, monkeypatch):
        from xagent.config import get_workforce_preview_run_stale_seconds

        monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "not-a-number")
        assert get_workforce_preview_run_stale_seconds() == 7200


class TestGmailPubSubProvisioningConfig:
    """Config for per-mailbox Gmail Pub/Sub provisioning."""

    def test_constants(self):
        assert GMAIL_PUBSUB_PROJECT_ID == "XAGENT_GMAIL_PUBSUB_PROJECT_ID"
        assert GMAIL_PUBSUB_TOPIC_PREFIX == "XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX"
        assert (
            GMAIL_PUBSUB_SUBSCRIPTION_PREFIX
            == "XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX"
        )
        assert (
            GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT
            == "XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT"
        )
        assert (
            GMAIL_REGISTRATION_TIMEOUT_SECONDS
            == "XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS"
        )
        assert PUBLIC_API_BASE_URL == "XAGENT_PUBLIC_API_BASE_URL"
        assert S2S_API_BASE_URL == "XAGENT_S2S_API_BASE_URL"

    def test_defaults(self, monkeypatch):
        monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_PROJECT_ID", raising=False)
        monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX", raising=False)
        monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX", raising=False)
        monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT", raising=False)
        monkeypatch.delenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", raising=False)
        monkeypatch.delenv("XAGENT_PUBLIC_API_BASE_URL", raising=False)
        monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)

        assert get_gmail_pubsub_project_id() is None
        assert get_gmail_pubsub_topic_prefix() == "xagent-gmail"
        assert get_gmail_pubsub_subscription_prefix() == "xagent-gmail-push"
        assert get_gmail_pubsub_push_service_account() is None
        assert get_gmail_registration_timeout_seconds() == 10
        assert get_public_api_base_url() is None
        assert get_s2s_api_base_url() is None

    def test_env_overrides(self, monkeypatch):
        monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_PROJECT_ID", " demo ")
        monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX", " mail-topic ")
        monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX", " mail-sub ")
        monkeypatch.setenv(
            "XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT",
            " [email protected] ",
        )
        monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "3")
        monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", " https://api.example.com/ ")
        monkeypatch.setenv(
            "XAGENT_S2S_API_BASE_URL", " https://sg-origin.example.com/ "
        )

        assert get_gmail_pubsub_project_id() == "demo"
        assert get_gmail_pubsub_topic_prefix() == "mail-topic"
        assert get_gmail_pubsub_subscription_prefix() == "mail-sub"
        assert (
            get_gmail_pubsub_push_service_account()
            == "[email protected]"
        )
        assert get_gmail_registration_timeout_seconds() == 3
        assert get_public_api_base_url() == "https://api.example.com"
        assert get_s2s_api_base_url() == "https://sg-origin.example.com"

    def test_s2s_base_falls_back_to_public_api_base(self, monkeypatch):
        monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
        monkeypatch.setenv(
            "XAGENT_PUBLIC_API_BASE_URL", " https://api.example.com/base/ "
        )

        assert get_s2s_api_base_url() == "https://api.example.com/base"

    @pytest.mark.parametrize(
        "value",
        [
            "api.example.com",
            "ftp://api.example.com",
            "https:///missing-host",
        ],
    )
    def test_s2s_base_rejects_invalid_http_urls(self, monkeypatch, value) -> None:
        monkeypatch.setenv("XAGENT_S2S_API_BASE_URL", value)

        with pytest.raises(ValueError, match="XAGENT_S2S_API_BASE_URL"):
            get_s2s_api_base_url()

    @pytest.mark.parametrize(
        "value",
        [
            "https://api.example.com/base?region=sg",
            "https://api.example.com/base#callbacks",
        ],
    )
    def test_s2s_base_rejects_query_and_fragment(self, monkeypatch, value) -> None:
        monkeypatch.setenv("XAGENT_S2S_API_BASE_URL", value)

        with pytest.raises(ValueError, match="XAGENT_S2S_API_BASE_URL"):
            get_s2s_api_base_url()

    def test_s2s_base_validates_public_api_fallback(self, monkeypatch) -> None:
        monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
        monkeypatch.setenv(
            "XAGENT_PUBLIC_API_BASE_URL",
            "https://api.example.com?region=sg",
        )

        with pytest.raises(ValueError, match="XAGENT_PUBLIC_API_BASE_URL"):
            get_s2s_api_base_url()

    def test_gmail_callback_validates_legacy_fallback(self, monkeypatch) -> None:
        monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
        monkeypatch.setenv(
            "XAGENT_TRIGGER_CALLBACK_BASE_URL",
            "https://legacy-callback.example.com#gmail",
        )

        resolver = getattr(config, "get_gmail_callback_base_url", lambda: None)
        with pytest.raises(ValueError, match="XAGENT_TRIGGER_CALLBACK_BASE_URL"):
            resolver()

    def test_gmail_callback_preserves_legacy_base_url_fallback(self, monkeypatch):
        monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
        monkeypatch.setenv(
            "XAGENT_TRIGGER_CALLBACK_BASE_URL",
            " https://legacy-callback.example.com/ ",
        )
        monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.example.com")

        assert (
            getattr(config, "TRIGGER_CALLBACK_BASE_URL", None)
            == "XAGENT_TRIGGER_CALLBACK_BASE_URL"
        )
        resolver = getattr(config, "get_gmail_callback_base_url", lambda: None)
        assert resolver() == "https://legacy-callback.example.com"
        assert get_s2s_api_base_url() == "https://api.example.com"

    def test_invalid_timeout_uses_default(self, monkeypatch):
        monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "0")
        assert get_gmail_registration_timeout_seconds() == 10
        monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "not-a-number")
        assert get_gmail_registration_timeout_seconds() == 10

    def test_pubsub_transport_defaults_to_grpc(self, monkeypatch):
        from xagent.config import get_gmail_pubsub_transport

        monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", raising=False)
        assert get_gmail_pubsub_transport() == "grpc"
        monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", " REST ")
        assert get_gmail_pubsub_transport() == "rest"
        monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", "carrier-pigeon")
        assert get_gmail_pubsub_transport() == "grpc"


class TestTrustedProxyHopsConfig:
    """Config for proxy-aware remote IP derivation."""

    def test_default_is_zero(self, monkeypatch):
        from xagent.config import get_trusted_proxy_hops

        monkeypatch.delenv("XAGENT_TRUSTED_PROXY_HOPS", raising=False)
        assert get_trusted_proxy_hops() == 0

    def test_env_override(self, monkeypatch):
        from xagent.config import get_trusted_proxy_hops

        monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "2")
        assert get_trusted_proxy_hops() == 2

    def test_invalid_value_falls_back_to_zero(self, monkeypatch):
        from xagent.config import get_trusted_proxy_hops

        monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "not-a-number")
        assert get_trusted_proxy_hops() == 0
        monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "-1")
        assert get_trusted_proxy_hops() == 0


class TestTriggerCallbackIpRateLimitConfig:
    """Config for the IP-wide callback rate ceiling."""

    def test_default(self, monkeypatch):
        from xagent.config import get_trigger_callback_ip_rate_limit

        monkeypatch.delenv("XAGENT_TRIGGER_CALLBACK_IP_RATE_LIMIT", raising=False)
        assert get_trigger_callback_ip_rate_limit() == "600/minute"

    def test_env_override(self, monkeypatch):
        from xagent.config import get_trigger_callback_ip_rate_limit

        monkeypatch.setenv("XAGENT_TRIGGER_CALLBACK_IP_RATE_LIMIT", "50/second")
        assert get_trigger_callback_ip_rate_limit() == "50/second"


class TestGetSandboxIdleTtl:
    """Test get_sandbox_idle_ttl() function."""

    def test_no_env_var_disables_reclamation(self, monkeypatch):
        monkeypatch.delenv(SANDBOX_IDLE_TTL, raising=False)
        assert get_sandbox_idle_ttl() is None

    def test_blank_env_var_disables_reclamation(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "   ")
        assert get_sandbox_idle_ttl() is None

    def test_valid_ttl_seconds(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "86400")
        assert get_sandbox_idle_ttl() == 86400.0

    def test_fractional_ttl_seconds(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "0.5")
        assert get_sandbox_idle_ttl() == 0.5

    def test_invalid_ttl_disables_reclamation(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "invalid")
        assert get_sandbox_idle_ttl() is None

    def test_non_positive_ttl_disables_reclamation(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "0")
        assert get_sandbox_idle_ttl() is None
        monkeypatch.setenv(SANDBOX_IDLE_TTL, "-60")
        assert get_sandbox_idle_ttl() is None

    def test_non_finite_ttl_disables_reclamation(self, monkeypatch):
        for value in ("nan", "NaN", "inf", "-inf"):
            monkeypatch.setenv(SANDBOX_IDLE_TTL, value)
            assert get_sandbox_idle_ttl() is None


class TestGetSandboxSweepInterval:
    """Test get_sandbox_sweep_interval() function."""

    def test_no_env_var_returns_default(self, monkeypatch):
        monkeypatch.delenv(SANDBOX_SWEEP_INTERVAL, raising=False)
        assert get_sandbox_sweep_interval() == 60.0

    def test_valid_interval(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "5")
        assert get_sandbox_sweep_interval() == 5.0

    def test_invalid_interval_returns_default(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "invalid")
        assert get_sandbox_sweep_interval() == 60.0

    def test_non_positive_interval_returns_default(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "0")
        assert get_sandbox_sweep_interval() == 60.0

    def test_non_finite_interval_returns_default(self, monkeypatch):
        for value in ("nan", "inf", "-inf"):
            monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, value)
            assert get_sandbox_sweep_interval() == 60.0


class TestGetSandboxMaxContainers:
    """Test get_sandbox_max_containers() function."""

    def test_no_env_var_disables_cap(self, monkeypatch):
        monkeypatch.delenv(SANDBOX_MAX_CONTAINERS, raising=False)
        assert get_sandbox_max_containers() is None

    def test_valid_cap(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "20")
        assert get_sandbox_max_containers() == 20

    def test_invalid_cap_disables_cap(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "invalid")
        assert get_sandbox_max_containers() is None

    def test_non_positive_cap_disables_cap(self, monkeypatch):
        monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "0")
        assert get_sandbox_max_containers() is None
        monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "-5")
        assert get_sandbox_max_containers() is None


class TestCheckpointGateStallWarningConfig:
    """Config for reporting a long-held exclusive checkpoint section."""

    def test_defaults_to_30_seconds(self, monkeypatch):
        from xagent.config import (
            CHECKPOINT_GATE_STALL_WARNING_SECONDS,
            get_checkpoint_gate_stall_warning_seconds,
        )

        monkeypatch.delenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, raising=False)
        assert get_checkpoint_gate_stall_warning_seconds() == 30.0

    def test_env_override(self, monkeypatch):
        from xagent.config import (
            CHECKPOINT_GATE_STALL_WARNING_SECONDS,
            get_checkpoint_gate_stall_warning_seconds,
        )

        monkeypatch.setenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, "2.5")
        assert get_checkpoint_gate_stall_warning_seconds() == 2.5

    @pytest.mark.parametrize("value", ["abc", "0", "-1", "nan", "inf"])
    def test_invalid_values_fall_back(self, monkeypatch, value):
        from xagent.config import (
            CHECKPOINT_GATE_STALL_WARNING_SECONDS,
            get_checkpoint_gate_stall_warning_seconds,
        )

        monkeypatch.setenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, value)
        assert get_checkpoint_gate_stall_warning_seconds() == 30.0


class TestCompactThresholdConfig:
    """Config for context-compaction threshold derivation."""

    def test_ratio_defaults_to_075(self, monkeypatch):
        from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio

        monkeypatch.delenv(COMPACT_THRESHOLD_RATIO, raising=False)
        assert get_compact_threshold_ratio() == 0.75

    def test_ratio_env_override(self, monkeypatch):
        from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio

        monkeypatch.setenv(COMPACT_THRESHOLD_RATIO, "0.8")
        assert get_compact_threshold_ratio() == 0.8

    @pytest.mark.parametrize("value", ["abc", "0", "-0.5", "1.5", "0.0"])
    def test_ratio_invalid_or_out_of_range_falls_back(self, monkeypatch, value):
        from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio

        monkeypatch.setenv(COMPACT_THRESHOLD_RATIO, value)
        assert get_compact_threshold_ratio() == 0.75

    def test_default_defaults_to_32000(self, monkeypatch):
        from xagent.config import (
            COMPACT_THRESHOLD_DEFAULT,
            get_compact_threshold_default,
        )

        monkeypatch.delenv(COMPACT_THRESHOLD_DEFAULT, raising=False)
        assert get_compact_threshold_default() == 32000

    def test_default_env_override(self, monkeypatch):
        from xagent.config import (
            COMPACT_THRESHOLD_DEFAULT,
            get_compact_threshold_default,
        )

        monkeypatch.setenv(COMPACT_THRESHOLD_DEFAULT, "64000")
        assert get_compact_threshold_default() == 64000

    @pytest.mark.parametrize("value", ["abc", "0", "-1"])
    def test_default_invalid_or_non_positive_falls_back(self, monkeypatch, value):
        from xagent.config import (
            COMPACT_THRESHOLD_DEFAULT,
            get_compact_threshold_default,
        )

        monkeypatch.setenv(COMPACT_THRESHOLD_DEFAULT, value)
        assert get_compact_threshold_default() == 32000


class TestUrlUserinfoRejectionIsScopedToDeepDoc:
    """Only the DeepDoc URL rejects embedded credentials.

    The rejection guards a specific hazard: the remote client interpolates
    ``httpx.HTTPStatusError`` — which renders the URL unredacted — into an
    exception the caller logs. Putting the check inside the shared
    ``_normalized_http_env_url`` would also apply it to
    ``PUBLIC_API_BASE_URL``/``S2S_API_BASE_URL``, whose call sites do not catch
    ``ValueError`` and depend on ``or``-chained fallbacks, so a pre-existing
    (if ill-advised) config would start failing at runtime.
    """

    def test_deepdoc_url_rejects_credentials(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, "http://user:pw@gpu-host:9997")
        with pytest.raises(ValueError, match="credentials embedded"):
            get_deepdoc_xinference_url()

    def test_deepdoc_url_without_credentials_is_accepted(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, "http://gpu-host:9997/base")
        assert get_deepdoc_xinference_url() == "http://gpu-host:9997/base"

    def test_shared_helper_consumers_keep_working(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        """The other consumers of the shared helper must be unaffected."""
        monkeypatch.setenv(PUBLIC_API_BASE_URL, "http://user:[email protected]")
        monkeypatch.delenv(S2S_API_BASE_URL, raising=False)

        assert get_public_api_base_url() == "http://user:[email protected]"
        assert get_s2s_api_base_url() == "http://user:[email protected]"


def test_inline_file_delivery_budget(monkeypatch, caplog):
    monkeypatch.delenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, raising=False)
    assert config.get_inline_file_delivery_max_bytes() == 8 * 1024 * 1024
    for value in ("0", "1024"):
        monkeypatch.setenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, value)
        assert config.get_inline_file_delivery_max_bytes() == int(value)
    for value in ("-1", "invalid", ""):
        monkeypatch.setenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, value)
        caplog.clear()
        assert config.get_inline_file_delivery_max_bytes() == 0
        assert "Invalid XAGENT_INLINE_FILE_DELIVERY_MAX_BYTES" in caplog.text


_OTEL_ENV_VARS = (
    "XAGENT_RUNTIME_TELEMETRY_ENABLED",
    "XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
    "XAGENT_OTEL_EXPORT_INTERVAL_MILLISECONDS",
    "XAGENT_OTEL_SERVICE_NAME",
    "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
    "OTEL_EXPORTER_OTLP_ENDPOINT",
    "OTEL_METRIC_EXPORT_INTERVAL",
    "OTEL_SERVICE_NAME",
)


def _clear_otel_env(monkeypatch: pytest.MonkeyPatch) -> None:
    for env_var in _OTEL_ENV_VARS:
        monkeypatch.delenv(env_var, raising=False)


def test_runtime_telemetry_defaults_to_disabled(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    _clear_otel_env(monkeypatch)

    assert config.get_otel_metrics_endpoint() is None
    assert config.get_runtime_telemetry_enabled() is False
    assert config.get_otel_export_interval_milliseconds() == 10_000
    assert config.get_otel_service_name() == "xagent"


def test_xagent_otel_endpoint_enables_export_and_explicit_false_disables_it(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    _clear_otel_env(monkeypatch)
    monkeypatch.setenv(
        "XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
        " http://collector:4318/v1/metrics/ ",
    )

    assert config.get_otel_metrics_endpoint() == "http://collector:4318/v1/metrics"
    assert config.get_runtime_telemetry_enabled() is True

    monkeypatch.setenv("XAGENT_RUNTIME_TELEMETRY_ENABLED", "false")
    assert config.get_runtime_telemetry_enabled() is False


def test_standard_otel_fallbacks_and_xagent_precedence(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    _clear_otel_env(monkeypatch)
    monkeypatch.setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://standard:4318/")
    monkeypatch.setenv("OTEL_METRIC_EXPORT_INTERVAL", "30000")
    monkeypatch.setenv("OTEL_SERVICE_NAME", "standard-xagent")

    assert config.get_otel_metrics_endpoint() == "http://standard:4318/v1/metrics"
    assert config.get_otel_export_interval_milliseconds() == 30_000
    assert config.get_otel_service_name() == "standard-xagent"

    monkeypatch.setenv(
        "XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
        "http://xagent:4318/v1/metrics",
    )
    monkeypatch.setenv("XAGENT_OTEL_EXPORT_INTERVAL_MILLISECONDS", "5000")
    monkeypatch.setenv("XAGENT_OTEL_SERVICE_NAME", "xagent-override")
    assert config.get_otel_metrics_endpoint() == "http://xagent:4318/v1/metrics"
    assert config.get_otel_export_interval_milliseconds() == 5_000
    assert config.get_otel_service_name() == "xagent-override"


def test_toby_personal_stdio_is_disabled_by_default(monkeypatch):
    monkeypatch.delenv(config.TOBY_PERSONAL_STDIO_ENABLED, raising=False)

    assert config.get_toby_personal_stdio_enabled() is False


def test_trace_database_defaults_and_opt_in(monkeypatch):
    monkeypatch.delenv(config.ASYNC_TRACE_DB_ENABLED, raising=False)
    monkeypatch.delenv(config.TRACE_DB_MAX_INFLIGHT, raising=False)
    assert config.get_async_trace_db_enabled() is True
    assert config.get_trace_db_max_inflight() == 4
    monkeypatch.setenv(config.ASYNC_TRACE_DB_ENABLED, "true")
    monkeypatch.setenv(config.TRACE_DB_MAX_INFLIGHT, "8")
    assert config.get_async_trace_db_enabled() is True
    assert config.get_trace_db_max_inflight() == 8


@pytest.mark.parametrize("value", ["0", "-1", "invalid"])
def test_trace_database_invalid_admission_limit_falls_back(monkeypatch, value):
    monkeypatch.setenv(config.TRACE_DB_MAX_INFLIGHT, value)
    assert config.get_trace_db_max_inflight() == 4


def test_db_write_retry_defaults(monkeypatch):
    monkeypatch.delenv(config.DB_WRITE_RETRY_ATTEMPTS, raising=False)
    monkeypatch.delenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, raising=False)
    monkeypatch.delenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, raising=False)
    assert config.get_db_write_retry_attempts() == 3
    assert config.get_db_write_retry_base_delay_ms() == 50
    assert config.get_db_write_retry_max_delay_ms() == 1000


def test_db_write_retry_overrides(monkeypatch):
    monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, "5")
    monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, "10")
    monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, "250")
    assert config.get_db_write_retry_attempts() == 5
    assert config.get_db_write_retry_base_delay_ms() == 10
    assert config.get_db_write_retry_max_delay_ms() == 250


def test_db_write_retry_zero_delays_are_allowed(monkeypatch):
    monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, "0")
    monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, "0")
    assert config.get_db_write_retry_base_delay_ms() == 0
    assert config.get_db_write_retry_max_delay_ms() == 0


def test_db_write_retry_one_attempt_disables_retries(monkeypatch):
    monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, "1")
    assert config.get_db_write_retry_attempts() == 1


@pytest.mark.parametrize("value", ["0", "-1", "abc"])
def test_db_write_retry_invalid_attempts_fall_back(monkeypatch, value):
    monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, value)
    assert config.get_db_write_retry_attempts() == 3


@pytest.mark.parametrize("value", ["-1", "abc"])
def test_db_write_retry_invalid_delays_fall_back(monkeypatch, value):
    monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, value)
    monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, value)
    assert config.get_db_write_retry_base_delay_ms() == 50
    assert config.get_db_write_retry_max_delay_ms() == 1000


@pytest.mark.parametrize("value", ["1", "true", "YES", "on"])
def test_toby_personal_stdio_explicit_opt_in(monkeypatch, value):
    monkeypatch.setenv(config.TOBY_PERSONAL_STDIO_ENABLED, value)

    assert config.get_toby_personal_stdio_enabled() is True


@pytest.mark.parametrize(
    "value,expected",
    [
        (None, False),
        ("", False),
        ("0", False),
        ("off", False),
        ("1", True),
        ("True", True),
    ],
)
def test_standby_enabled_parses_boolean(monkeypatch, value, expected):
    if value is None:
        monkeypatch.delenv(config.STANDBY, raising=False)
    else:
        monkeypatch.setenv(config.STANDBY, value)
    assert config.get_standby_enabled() is expected


def test_standby_enabled_rejects_a_typo(monkeypatch):
    monkeypatch.setenv(config.STANDBY, "maybe")
    with pytest.raises(ValueError, match="XAGENT_STANDBY"):
        config.get_standby_enabled()


@pytest.mark.parametrize("value,expected", [("true", True), ("false", False)])
def test_shared_task_execution_explicit_setting_wins(monkeypatch, value, expected):
    monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
    monkeypatch.setenv(config.WORKER_COUNT, "4")
    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, value)
    assert config.get_shared_task_execution_enabled() is expected


@pytest.mark.parametrize("value", ["", " "])
@pytest.mark.parametrize(
    "role,worker_count",
    [("combined", "4"), ("web", None), ("worker", None)],
)
def test_blank_shared_task_execution_setting_uses_topology(
    monkeypatch, value, role, worker_count
):
    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, value)
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
    monkeypatch.delenv(config.WORKER_COUNT, raising=False)
    if worker_count is not None:
        monkeypatch.setenv(config.WORKER_COUNT, worker_count)

    assert config.get_shared_task_execution_enabled() is True


@pytest.mark.parametrize(
    "role,worker_count,expected",
    [
        ("combined", None, False),
        ("combined", "4", True),
        ("web", None, True),
        ("worker", None, True),
    ],
)
def test_shared_task_execution_default_follows_topology(
    monkeypatch, role, worker_count, expected
):
    monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
    monkeypatch.delenv(config.WORKER_COUNT, raising=False)
    if worker_count is not None:
        monkeypatch.setenv(config.WORKER_COUNT, worker_count)

    assert config.get_shared_task_execution_enabled() is expected


def test_default_task_execution_host_configuration_is_self_contained(monkeypatch):
    monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
    monkeypatch.delenv(config.TASK_EXECUTION_ROLE, raising=False)
    monkeypatch.delenv(config.WORKER_COUNT, raising=False)
    monkeypatch.delenv(config.REDIS_URL, raising=False)
    monkeypatch.delenv(config.ENCRYPTION_KEY, raising=False)

    assert config.get_shared_task_execution_enabled() is False
    assert config.get_task_execution_role() == "combined"
    assert config.get_channel_ingress_enabled() is False
    config.validate_task_execution_host_config()


@pytest.mark.parametrize("value", ["0", "-1", "invalid"])
def test_local_host_rejects_invalid_runtime_secret_ttl_at_startup(monkeypatch, value):
    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "false")
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, "combined")
    monkeypatch.setenv(config.TASK_RUNTIME_SECRETS_TTL_SECONDS, value)
    with pytest.raises(ValueError):
        config.validate_task_execution_host_config()


@pytest.mark.parametrize("value", ["", " ", "deployment/channel"])
def test_task_event_channel_prefix_rejects_invalid_namespace(monkeypatch, value):
    monkeypatch.setenv(config.TASK_EVENT_CHANNEL_PREFIX, value)
    with pytest.raises(ValueError, match="channel prefix"):
        config.get_task_event_channel_prefix()


def test_task_event_channel_prefix_default_and_override(monkeypatch):
    monkeypatch.delenv(config.TASK_EVENT_CHANNEL_PREFIX, raising=False)
    assert config.get_task_event_channel_prefix() == "xagent:task-events:v1"
    monkeypatch.setenv(config.TASK_EVENT_CHANNEL_PREFIX, "xagent:staging:v1")
    assert config.get_task_event_channel_prefix() == "xagent:staging:v1"


@pytest.mark.parametrize("key", [None, ""])
def test_task_runtime_secrets_reject_unconfigured_key(monkeypatch, key):
    monkeypatch.delenv(config.ENCRYPTION_KEY, raising=False)
    if key is not None:
        monkeypatch.setenv(config.ENCRYPTION_KEY, key)
    assert config.get_task_runtime_secrets_encryption_key() is None


def test_task_runtime_secrets_use_explicit_fallback_key(monkeypatch):
    monkeypatch.setenv(config.ENCRYPTION_KEY, config.DEV_FALLBACK_ENCRYPTION_KEY)

    assert (
        config.get_task_runtime_secrets_encryption_key()
        == config.DEV_FALLBACK_ENCRYPTION_KEY
    )


def test_task_runtime_secrets_use_explicit_key(monkeypatch):
    from cryptography.fernet import Fernet

    key = Fernet.generate_key().decode()
    monkeypatch.setenv(config.ENCRYPTION_KEY, key)
    assert config.get_task_runtime_secrets_encryption_key() == key


@pytest.mark.parametrize(
    "value,expected", [(None, 30), ("12", 12), ("0", 30), ("-1", 30), ("bad", 30)]
)
def test_task_reply_wait_timeout(value, expected, monkeypatch):
    from xagent.config import (
        get_input_review_timeout_seconds,
        get_task_reply_wait_timeout_seconds,
    )

    monkeypatch.delenv("XAGENT_TASK_REPLY_WAIT_TIMEOUT_SECONDS", raising=False)
    if value is not None:
        monkeypatch.setenv("XAGENT_TASK_REPLY_WAIT_TIMEOUT_SECONDS", value)
    assert get_task_reply_wait_timeout_seconds() == expected
    assert get_input_review_timeout_seconds() == pytest.approx(min(20, expected * 0.8))
    assert get_input_review_timeout_seconds() < expected


@pytest.mark.parametrize(
    "shared,role,override,expected",
    [
        (False, "combined", None, True),
        (True, "combined", None, False),
        (True, "web", "true", True),
        (True, "web", "false", False),
        (True, "worker", "true", False),
    ],
)
def test_designated_channel_ingress(monkeypatch, shared, role, override, expected):
    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, str(shared).lower())
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
    monkeypatch.delenv(config.CHANNEL_INGRESS_ENABLED, raising=False)
    if override is not None:
        monkeypatch.setenv(config.CHANNEL_INGRESS_ENABLED, override)
    assert config.get_channel_ingress_enabled() is expected


@pytest.mark.parametrize("role", ["combined", "web", "worker"])
def test_shared_host_configuration(monkeypatch, role):
    from cryptography.fernet import Fernet

    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "true")
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
    monkeypatch.setenv(config.REDIS_URL, "redis://localhost:6379/0")
    monkeypatch.setenv(config.ENCRYPTION_KEY, Fernet.generate_key().decode())
    config.validate_task_execution_host_config()
    monkeypatch.setenv(config.ENCRYPTION_KEY, config.DEV_FALLBACK_ENCRYPTION_KEY)
    config.validate_task_execution_host_config()
    monkeypatch.delenv(config.ENCRYPTION_KEY)
    with pytest.raises(ValueError, match="private common ENCRYPTION_KEY"):
        config.validate_task_execution_host_config()
    monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "false")
    if role == "combined":
        config.validate_task_execution_host_config()
    else:
        with pytest.raises(ValueError, match="requires"):
            config.validate_task_execution_host_config()


def test_unknown_task_execution_role_rejected(monkeypatch):
    monkeypatch.setenv(config.TASK_EXECUTION_ROLE, "other")
    with pytest.raises(ValueError, match="combined, web or worker"):
        config.validate_task_execution_host_config()


@pytest.mark.parametrize(
    "value,expected", [(None, None), ("", None), ("1", 1), ("4", 4)]
)
def test_worker_count_optional_positive_integer(monkeypatch, value, expected):
    monkeypatch.delenv(config.WORKER_COUNT, raising=False)
    if value is not None:
        monkeypatch.setenv(config.WORKER_COUNT, value)
    assert config.get_worker_count() == expected


@pytest.mark.parametrize("value", ["0", "-1", "1.5", "invalid"])
def test_worker_count_rejects_invalid_values(monkeypatch, value):
    monkeypatch.setenv(config.WORKER_COUNT, value)
    with pytest.raises(
        ValueError, match="XAGENT_WORKER_COUNT must be a positive integer"
    ):
        config.get_worker_count()


# ---------------------------------------------------------------------------
# Conversation data retention (#2563).
#
# Two properties run through these cases, and every test here is one of them:
# a period that cannot be read disables the leg it configures rather than
# falling back to a number of days, and a switch that cannot be read resolves
# to whichever side deletes nothing.
# ---------------------------------------------------------------------------


@pytest.fixture
def no_retention_env(monkeypatch):
    """Clear every retention variable, so no case inherits another's state.

    Driven from ``config.RETENTION_ENV_VARS`` rather than a list written here,
    so a setting added without a test cannot silently inherit whatever the
    surrounding suite left behind.
    """
    for name in config.RETENTION_ENV_VARS:
        monkeypatch.delenv(name, raising=False)
    return monkeypatch


def _warnings(caplog) -> list[str]:
    return [record.getMessage() for record in caplog.records]


@pytest.mark.parametrize(
    "value,expected",
    [
        (None, None),
        ("", None),
        ("   ", None),
        ("0", None),
        ("365", 365),
        ("1", 1),
        (str(config.MAX_RETENTION_DAYS), config.MAX_RETENTION_DAYS),
        # Every one of these is a mistake, and must disable rather than fall
        # back to some working number of days.
        ("-1", None),
        ("90d", None),
        ("ninety", None),
        ("9.5", None),
        # An operator pasting a date. Parses as an integer, and no date can
        # express it -- `now - timedelta(days=20260923)` raises OverflowError,
        # which a consumer would hit on every use.
        ("20260923", None),
        ("1000000000", None),
        (str(config.MAX_RETENTION_DAYS + 1), None),
    ],
)
def test_conversation_retention_days(no_retention_env, value, expected):
    if value is not None:
        no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
    assert config.get_conversation_retention_days() == expected


def test_an_accepted_period_can_always_be_expressed_as_a_date(no_retention_env):
    """The bound is only correct if everything under it actually works.

    Pinned against the arithmetic it protects rather than against a number
    written twice: ``retention_cutoff`` is what raises, so it decides whether
    ``MAX_RETENTION_DAYS`` is set right. This caught the first value written.
    """
    from datetime import datetime, timezone

    from xagent.web.services.task_retention import retention_cutoff

    no_retention_env.setenv(
        config.CONVERSATION_RETENTION_DAYS, str(config.MAX_RETENTION_DAYS)
    )
    parsed = config.get_conversation_retention_days()

    assert parsed == config.MAX_RETENTION_DAYS
    assert retention_cutoff(now=datetime.now(timezone.utc), days=parsed) is not None


@pytest.mark.parametrize(
    "raw,expected",
    [
        # Every spelling of zero inherits the conversation period, because "0"
        # means "same as the conversation period" and ``int`` is the authority
        # on what zero is. Comparing the raw string against "0" instead
        # disagreed with ``int`` about these, and silently disabled traces.
        ("0", 365),
        (" 0 ", 365),
        ("00", 365),
        ("-0", 365),
        # Absent, likewise inherits.
        ("", 365),
        ("   ", 365),
        ("90", 90),
        # Longer than the conversation period: accepted, and inert.
        ("3650", 3650),
        # Unusable: disables the leg being configured rather than inheriting.
        ("0.0", None),
        ("90d", None),
        ("-5", None),
        ("800000", None),
    ],
)
def test_trace_period_reads_every_spelling_the_way_int_does(
    no_retention_env, raw, expected
):
    no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "365")
    no_retention_env.setenv(config.TRACE_RETENTION_DAYS, raw)

    assert config.get_trace_retention_days() == expected


def test_trace_alone_expires_traces_while_conversations_are_kept(no_retention_env):
    """A supported shape, not an accident: traces are most of the bytes."""
    no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "90")

    assert config.get_trace_retention_days() == 90
    assert config.get_conversation_retention_days() is None


def test_an_unusable_conversation_period_does_not_reach_the_trace_leg(
    no_retention_env,
):
    """Each leg is disabled on its own; neither failure contaminates the other."""
    no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "90d")

    assert config.get_conversation_retention_days() is None
    assert config.get_trace_retention_days() is None

    no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "30")
    assert config.get_trace_retention_days() == 30


def test_both_periods_zero_disables_everything(no_retention_env):
    no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "0")
    no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "0")

    assert config.get_conversation_retention_days() is None
    assert config.get_trace_retention_days() is None


@pytest.mark.parametrize("value", ["-1", "90d", str(config.MAX_RETENTION_DAYS + 1)])
def test_an_unusable_period_warns(no_retention_env, caplog, value):
    no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        config.get_conversation_retention_days()

    assert any(config.CONVERSATION_RETENTION_DAYS in m for m in _warnings(caplog))


@pytest.mark.parametrize("value", ["0", "", "   ", "365"])
def test_a_usable_or_absent_period_does_not_warn(no_retention_env, caplog, value):
    """Zero and blank are documented spellings, not mistakes."""
    no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        config.get_conversation_retention_days()

    assert _warnings(caplog) == []


@pytest.mark.parametrize(
    "value,expected",
    [
        (None, False),
        ("true", True),
        ("TRUE", True),
        (" yes ", True),
        ("1", True),
        ("y", True),
        ("false", False),
        ("n", False),
        ("off", False),
        # Unrecognised: this is the setting an operator reaches for before a
        # first real run, so the failure direction is "reported, not deleted".
        ("enabled", True),
        ("maybe", True),
        # Blank is unset, not a typo: a compose file interpolating an unset
        # shell variable passes an empty string, which says nothing.
        ("", False),
        ("   ", False),
    ],
)
def test_dry_run_resolves_an_unrecognised_value_to_dry(
    no_retention_env, value, expected
):
    if value is not None:
        no_retention_env.setenv(config.RETENTION_DRY_RUN, value)
    assert config.get_retention_dry_run() is expected


@pytest.mark.parametrize(
    "value,expected",
    [
        (None, True),
        ("true", True),
        ("y", True),
        (" ON ", True),
        ("false", False),
        ("off", False),
        ("n", False),
        # Unrecognised resolves to "stopped": for a kill switch, refusing to
        # act is the side that cannot delete anything.
        ("enabled", False),
        ("t", False),
        # Blank is unset, so it must not read as a deliberate stop.
        ("", True),
        ("   ", True),
    ],
)
def test_kill_switch_resolves_an_unrecognised_value_to_stopped(
    no_retention_env, value, expected
):
    if value is not None:
        no_retention_env.setenv(config.RETENTION_ENABLED, value)
    assert config.get_retention_enabled() is expected


@pytest.mark.parametrize("name", [config.RETENTION_DRY_RUN, config.RETENTION_ENABLED])
def test_an_unrecognised_switch_warns(no_retention_env, caplog, name):
    """Unlike a period, there is no legitimate spelling a switch rejects."""
    no_retention_env.setenv(name, "enabled")
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        config.get_retention_dry_run()
        config.get_retention_enabled()

    assert any(name in message for message in _warnings(caplog))


@pytest.mark.parametrize("name", [config.RETENTION_DRY_RUN, config.RETENTION_ENABLED])
@pytest.mark.parametrize("value", ["", "   ", "true", "no"])
def test_a_readable_or_blank_switch_does_not_warn(
    no_retention_env, caplog, name, value
):
    no_retention_env.setenv(name, value)
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        config.get_retention_dry_run()
        config.get_retention_enabled()

    assert _warnings(caplog) == []


def test_blank_is_unset_for_every_setting(no_retention_env):
    """All four parsers must agree about what an empty value means.

    They did not at first: the periods read blank as unset while the switches
    read it as an unrecognised value and the batch size read it as invalid.
    The visible consequence was a compose file interpolating an unset shell
    variable turning into a deliberate stop, warning on every read.
    """
    for name in config.RETENTION_ENV_VARS:
        no_retention_env.setenv(name, "")

    assert config.get_conversation_retention_days() is None
    assert config.get_trace_retention_days() is None
    assert config.get_retention_enabled() is True
    assert config.get_retention_dry_run() is False
    assert config.get_retention_batch_size() == 100
    assert config.get_retention_sweep_interval_seconds() == 86400.0
    assert config.get_retention_batch_pause_seconds() == 5.0


@pytest.mark.parametrize(
    "value,expected", [(None, 100), ("250", 250), ("0", 100), ("nope", 100), ("", 100)]
)
def test_retention_batch_size(no_retention_env, value, expected):
    if value is not None:
        no_retention_env.setenv(config.RETENTION_BATCH_SIZE, value)
    assert config.get_retention_batch_size() == expected


@pytest.mark.parametrize(
    "value,expected",
    [(None, 86400.0), ("60", 60.0), ("0", 86400.0), ("-1", 86400.0), ("x", 86400.0)],
)
def test_retention_sweep_interval(no_retention_env, value, expected):
    if value is not None:
        no_retention_env.setenv(config.RETENTION_SWEEP_INTERVAL_SECONDS, value)
    assert config.get_retention_sweep_interval_seconds() == expected


@pytest.mark.parametrize(
    "value,expected", [(None, 5.0), ("0.5", 0.5), ("0", 5.0), ("nope", 5.0)]
)
def test_retention_batch_pause(no_retention_env, value, expected):
    if value is not None:
        no_retention_env.setenv(config.RETENTION_BATCH_PAUSE_SECONDS, value)
    assert config.get_retention_batch_pause_seconds() == expected


def test_no_module_assigns_a_retention_environment_variable():
    """Pins the claim the section comment makes about needing a restart.

    That claim holds only while nothing writes these names into the
    environment, and other code in this repository does write ``os.environ``
    (``worker_pool`` sets the execution role for the processes it spawns), so
    it has to be checked rather than assumed.

    The scan is a heuristic and says so: it covers assignment, ``update``,
    ``setdefault``, ``putenv`` and ``load_dotenv(override=True)``, spelled
    through either the literal name or the constant. A computed key would slip
    past it. It is worth having anyway -- every way this claim has actually
    been broken in review is on the list -- but it is a tripwire, not a proof.
    """
    import re
    from pathlib import Path as _Path

    source_root = _Path(config.__file__).parent
    names = "|".join(
        [re.escape(name) for name in config.RETENTION_ENV_VARS]
        + [
            re.escape(name.removeprefix("XAGENT_"))
            for name in config.RETENTION_ENV_VARS
        ]
    )
    quoted = rf"""["']?({names})["']?"""
    pattern = re.compile(
        "|".join(
            [
                rf"environ\[\s*{quoted}\s*\]\s*=",
                rf"environ\.setdefault\(\s*{quoted}",
                rf"putenv\(\s*{quoted}",
                rf"environ\.update\([^)]*{quoted}",
                r"load_dotenv\([^)]*override\s*=\s*True",
            ]
        )
    )

    offenders = sorted(
        str(path.relative_to(source_root))
        for path in source_root.rglob("*.py")
        if pattern.search(path.read_text(encoding="utf-8", errors="ignore"))
    )

    assert offenders == [], (
        "these modules can change a retention variable after start-up, which "
        f"breaks the documented 'takes a restart' guarantee: {offenders}"
    )


_AUTO_RESUME_INT_SETTINGS = [
    ("TASK_AUTO_RESUME_POLL_SECONDS", "get_task_auto_resume_poll_seconds", 5),
    ("TASK_AUTO_RESUME_MAX_PER_TICK", "get_task_auto_resume_max_per_tick", 20),
    ("TASK_AUTO_RESUME_MAX_INFLIGHT", "get_task_auto_resume_max_inflight", 50),
    ("TASK_AUTO_RESUME_WINDOW_SECONDS", "get_task_auto_resume_window_seconds", 86400),
    (
        "TASK_AUTO_RESUME_CHANNEL_WINDOW_SECONDS",
        "get_task_auto_resume_channel_window_seconds",
        1800,
    ),
    (
        "TASK_AUTO_RESUME_MAX_TOTAL_PER_RUN",
        "get_task_auto_resume_max_total_per_run",
        20,
    ),
    (
        "TASK_AUTO_RESUME_SHORT_INITIAL_BACKOFF_SECONDS",
        "get_task_auto_resume_short_initial_backoff_seconds",
        10,
    ),
    (
        "TASK_AUTO_RESUME_SHORT_MAX_NO_PROGRESS",
        "get_task_auto_resume_short_max_no_progress",
        3,
    ),
    (
        "TASK_AUTO_RESUME_LLM_INITIAL_BACKOFF_SECONDS",
        "get_task_auto_resume_llm_initial_backoff_seconds",
        60,
    ),
    (
        "TASK_AUTO_RESUME_LLM_MAX_BACKOFF_SECONDS",
        "get_task_auto_resume_llm_max_backoff_seconds",
        900,
    ),
    (
        "TASK_AUTO_RESUME_LLM_MAX_ELAPSED_SECONDS",
        "get_task_auto_resume_llm_max_elapsed_seconds",
        7200,
    ),
    (
        "TASK_AUTO_RESUME_MODEL_OUTPUT_MAX_NO_PROGRESS",
        "get_task_auto_resume_model_output_max_no_progress",
        2,
    ),
]

_AUTO_RESUME_BOOL_SETTINGS = [
    ("TASK_INFRA_FAILURE_PAUSE_ENABLED", "get_task_infra_failure_pause_enabled", True),
    ("TASK_AUTO_RESUME_ENABLED", "get_task_auto_resume_enabled", True),
]


class TestTaskAutoRecoveryConfig:
    @pytest.mark.parametrize("const,getter,default", _AUTO_RESUME_INT_SETTINGS)
    def test_int_setting_defaults_overrides_and_invalid(
        self, monkeypatch, caplog, const, getter, default
    ):
        env_var = getattr(config, const)
        assert env_var == f"XAGENT_{const}"
        read = getattr(config, getter)

        monkeypatch.delenv(env_var, raising=False)
        assert read() == default

        monkeypatch.setenv(env_var, "7")
        assert read() == 7

        for invalid in ("", "abc", "0", "-3", "1.5"):
            monkeypatch.setenv(env_var, invalid)
            caplog.clear()
            with caplog.at_level(logging.WARNING, logger="xagent.config"):
                assert read() == default
            assert env_var in caplog.text

    @pytest.mark.parametrize("const,getter,default", _AUTO_RESUME_BOOL_SETTINGS)
    def test_bool_setting_defaults_overrides_and_invalid(
        self, monkeypatch, caplog, const, getter, default
    ):
        env_var = getattr(config, const)
        assert env_var == f"XAGENT_{const}"
        read = getattr(config, getter)

        monkeypatch.delenv(config.TASK_AUTO_RESUME_ENABLED, raising=False)
        monkeypatch.delenv(env_var, raising=False)
        assert read() is default

        for falsy in ("false", "0", "no", "off", " FALSE "):
            monkeypatch.setenv(env_var, falsy)
            assert read() is False
        for truthy in ("true", "1", "yes", "on", "True"):
            monkeypatch.setenv(env_var, truthy)
            assert read() is True

        for blank in ("", "   "):
            monkeypatch.setenv(env_var, blank)
            caplog.clear()
            with caplog.at_level(logging.WARNING, logger="xagent.config"):
                assert read() is default
            assert env_var not in caplog.text

        for invalid in ("maybe", "2"):
            monkeypatch.setenv(env_var, invalid)
            caplog.clear()
            with caplog.at_level(logging.WARNING, logger="xagent.config"):
                assert read() is default
            assert env_var in caplog.text

    @pytest.mark.parametrize("auto_resume", [True, False])
    def test_infra_failure_pause_follows_auto_resume_unless_set(
        self, monkeypatch, auto_resume
    ):
        monkeypatch.setenv(config.TASK_AUTO_RESUME_ENABLED, str(auto_resume).lower())
        read = config.get_task_infra_failure_pause_enabled

        for unset in (None, "", "maybe"):
            if unset is None:
                monkeypatch.delenv(
                    config.TASK_INFRA_FAILURE_PAUSE_ENABLED, raising=False
                )
            else:
                monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, unset)
            assert read() is auto_resume

        monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, "true")
        assert read() is True
        monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, "false")
        assert read() is False

    def test_example_env_documents_every_setting(self):
        example = (Path(config.__file__).parents[2] / "example.env").read_text()
        names = [f"XAGENT_{const}" for const, *_ in _AUTO_RESUME_INT_SETTINGS]
        names += [f"XAGENT_{const}" for const, *_ in _AUTO_RESUME_BOOL_SETTINGS]
        for name in names:
            assert f"# {name}=" in example


@pytest.mark.parametrize(
    ("raw", "expected", "warns"),
    [
        (None, 80, False),
        ("7", 7, False),
        ("1", 1, False),
        (" 7 ", 7, False),
        ("100000", 100000, False),
        ("0", 80, True),
        ("-1", 80, True),
        ("abc", 80, True),
        ("", 80, True),
        ("7.5", 80, True),
    ],
)
def test_dispatcher_max_inflight_env_parsing(monkeypatch, caplog, raw, expected, warns):
    env_var = config.DISPATCHER_MAX_INFLIGHT_PER_PROCESS
    assert env_var == "XAGENT_DISPATCHER_MAX_INFLIGHT_PER_PROCESS"
    if raw is None:
        monkeypatch.delenv(env_var, raising=False)
    else:
        monkeypatch.setenv(env_var, raw)

    caplog.clear()
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        assert config.get_dispatcher_max_inflight_per_process() == expected

    warnings = [
        record
        for record in caplog.records
        if record.name == "xagent.config" and record.levelno == logging.WARNING
    ]
    assert len(warnings) == int(warns)
    assert all(env_var in record.getMessage() for record in warnings)


@pytest.mark.parametrize(
    ("raw", "expected", "warns"),
    [
        (None, 0, False),
        ("0", 0, False),
        ("4", 4, False),
        (" 4 ", 4, False),
        ("-1", 0, True),
        ("abc", 0, True),
        ("", 0, True),
        ("1.5", 0, True),
    ],
)
def test_dispatcher_interactive_reserve_env_parsing(
    monkeypatch, caplog, raw, expected, warns
):
    env_var = config.DISPATCHER_INTERACTIVE_RESERVE_PER_PROCESS
    assert env_var == "XAGENT_DISPATCHER_INTERACTIVE_RESERVE_PER_PROCESS"
    if raw is None:
        monkeypatch.delenv(env_var, raising=False)
    else:
        monkeypatch.setenv(env_var, raw)

    caplog.clear()
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        assert config.get_dispatcher_interactive_reserve_per_process() == expected

    warnings = [
        record
        for record in caplog.records
        if record.name == "xagent.config" and record.levelno == logging.WARNING
    ]
    assert len(warnings) == int(warns)
    assert all(env_var in record.getMessage() for record in warnings)


@pytest.mark.parametrize(
    ("const", "env_var", "getter"),
    [
        (
            "DISPATCHER_FAIR_SHARE",
            "XAGENT_DISPATCHER_FAIR_SHARE",
            "get_dispatcher_fair_share_enabled",
        ),
        (
            "DISPATCH_ACCEPT_REQUESTED_CLASS",
            "XAGENT_DISPATCH_ACCEPT_REQUESTED_CLASS",
            "get_dispatch_accept_requested_class_enabled",
        ),
    ],
)
@pytest.mark.parametrize(
    ("raw", "expected", "warns"),
    [
        (None, False, False),
        ("true", True, False),
        ("TRUE", True, False),
        ("True", True, False),
        ("1", True, False),
        ("yes", True, False),
        ("YES", True, False),
        ("on", True, False),
        ("On", True, False),
        ("false", False, False),
        ("FALSE", False, False),
        ("0", False, False),
        ("no", False, False),
        ("off", False, False),
        # A blank value states nothing, as when a compose file interpolates an
        # unset variable: unlike the numeric settings above, it does not warn.
        ("", False, False),
        ("   ", False, False),
        ("garbage", False, True),
    ],
)
def test_dispatch_switch_env_parsing(
    monkeypatch, caplog, const, env_var, getter, raw, expected, warns
):
    assert getattr(config, const) == env_var
    if raw is None:
        monkeypatch.delenv(env_var, raising=False)
    else:
        monkeypatch.setenv(env_var, raw)

    caplog.clear()
    with caplog.at_level(logging.WARNING, logger="xagent.config"):
        assert getattr(config, getter)() is expected

    warnings = [
        record
        for record in caplog.records
        if record.name == "xagent.config" and record.levelno == logging.WARNING
    ]
    assert len(warnings) == int(warns)
    assert all(env_var in record.getMessage() for record in warnings)


@pytest.mark.parametrize(
    "name,value",
    [
        ("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "-1"),
        ("XAGENT_EXECUTION_BUDGET_MAX_TOKENS", "0"),
        ("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "100"),
        ("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "no"),
    ],
)
def test_execution_budget_invalid_env_rejected(monkeypatch, name, value):
    from xagent.config import get_execution_budget_defaults

    monkeypatch.setenv(name, value)
    with pytest.raises(ValueError):
        get_execution_budget_defaults()


def test_execution_budget_env_defaults(monkeypatch):
    from xagent.config import get_execution_budget_defaults

    for key in ("DEFAULT_TOKENS", "MAX_TOKENS", "SOFT_PERCENT"):
        monkeypatch.delenv(f"XAGENT_EXECUTION_BUDGET_{key}", raising=False)
    assert get_execution_budget_defaults() == {
        "default_tokens": None,
        "max_tokens": None,
        "soft_limit_percent": 80,
    }
    monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "12345")
    monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "65")
    assert get_execution_budget_defaults()["default_tokens"] == 12345
    assert get_execution_budget_defaults()["soft_limit_percent"] == 65


def test_execution_budget_env_default_cannot_exceed_maximum(monkeypatch):
    from xagent.config import get_execution_budget_defaults

    monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "200")
    monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_MAX_TOKENS", "100")
    with pytest.raises(ValueError, match="must not exceed"):
        get_execution_budget_defaults()


_READ_BUDGET_GETTERS = [
    ("XAGENT_EXECUTION_EVENT_READ_ROW_BUDGETS", "get_execution_event_read_row_budgets"),
    (
        "XAGENT_EXECUTION_EVENT_READ_DURATION_BUDGETS_MS",
        "get_execution_event_read_duration_budgets_ms",
    ),
]


@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
@pytest.mark.parametrize("value", [None, "", "   ", " , "])
def test_execution_event_read_budgets_unset_or_empty_means_no_budget(
    monkeypatch, env_var, getter, value
):
    from xagent import config

    if value is None:
        monkeypatch.delenv(env_var, raising=False)
    else:
        monkeypatch.setenv(env_var, value)
    assert dict(getattr(config, getter)()) == {}


@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
def test_execution_event_read_budgets_parse_operations_and_default(
    monkeypatch, env_var, getter
):
    from xagent import config

    monkeypatch.setenv(env_var, "model=2000, reconnect = 20000 ,*=50000,")
    assert dict(getattr(config, getter)()) == {
        "model": 2000,
        "reconnect": 20000,
        "*": 50000,
    }
    monkeypatch.setenv(env_var, "Tool_Outcome=7")
    assert dict(getattr(config, getter)()) == {"tool_outcome": 7}
    monkeypatch.setenv(
        env_var, "model=1,display=2,reconnect=3,checkpoint=4,tool_outcome=5"
    )
    assert dict(getattr(config, getter)()) == {
        "model": 1,
        "display": 2,
        "reconnect": 3,
        "checkpoint": 4,
        "tool_outcome": 5,
    }


@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
@pytest.mark.parametrize(
    "value,message",
    [
        ("model=abc", "positive integer"),
        ("model=1.5", "positive integer"),
        ("model=", "positive integer"),
        ("model=-5", "positive integer"),
        ("model=0", "positive integer"),
        ("*=0", "positive integer"),
        ("model", "<operation>=<positive integer>"),
        ("=5", "unknown operation"),
        ("models=5", "unknown operation"),
        ("replay=5", "unknown operation"),
        ("model=1,model=2", "duplicate"),
    ],
)
def test_execution_event_read_budgets_invalid_values_raise(
    monkeypatch, env_var, getter, value, message
):
    from xagent import config

    monkeypatch.setenv(env_var, value)
    with pytest.raises(ValueError, match=message) as error:
        getattr(config, getter)()
    assert env_var in str(error.value)


@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
def test_execution_event_read_budgets_cache_by_raw_value_and_follow_env(
    monkeypatch, env_var, getter
):
    from xagent import config

    config._parse_execution_event_read_budgets.cache_clear()
    monkeypatch.setenv(env_var, "model=10")
    first = getattr(config, getter)()
    parses = config._parse_execution_event_read_budgets.cache_info()
    assert getattr(config, getter)() is first
    after = config._parse_execution_event_read_budgets.cache_info()
    assert (after.misses, after.hits) == (parses.misses, parses.hits + 1)

    monkeypatch.setenv(env_var, "model=20")
    assert dict(getattr(config, getter)()) == {"model": 20}
    monkeypatch.delenv(env_var)
    assert dict(getattr(config, getter)()) == {}
    # A cached result cannot be mutated by a caller.
    with pytest.raises(TypeError):
        first["model"] = 1  # type: ignore[index]


@pytest.mark.parametrize("value", [None, "", "   ", " development ", "DEVELOPMENT"])
def test_environment_defaults_and_normalizes_development(monkeypatch, value):
    monkeypatch.delenv("ENVIRONMENT", raising=False)
    if value is None:
        monkeypatch.delenv("XAGENT_ENVIRONMENT", raising=False)
    else:
        monkeypatch.setenv("XAGENT_ENVIRONMENT", value)

    assert config.get_environment() == "development"


def test_legacy_environment_alias_is_normalized(monkeypatch):
    monkeypatch.delenv("XAGENT_ENVIRONMENT", raising=False)
    monkeypatch.setenv("ENVIRONMENT", " Production ")

    assert config.get_environment() == "production"


def test_blank_environment_override_falls_back_to_legacy_alias(monkeypatch):
    monkeypatch.setenv("XAGENT_ENVIRONMENT", "  ")
    monkeypatch.setenv("ENVIRONMENT", " production ")
    assert config.get_environment() == "production"


@pytest.mark.parametrize("setting", ["XAGENT_SECRET_ENCRYPTION_KEY", "SECRET_KEY"])
@pytest.mark.parametrize("length,valid", [(31, False), (32, True)])
def test_tool_key_alias_and_boundary(monkeypatch, setting, length, valid):
    monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
    monkeypatch.setenv("XAGENT_SECRET_ENCRYPTION_KEY", "  ")
    monkeypatch.delenv("SECRET_KEY", raising=False)
    monkeypatch.setenv(setting, "s" * length)
    if valid:
        assert config.get_tool_credentials_encryption_key() == "s" * length
    else:
        with pytest.raises(RuntimeError, match=f"^{setting} must"):
            config.get_tool_credentials_encryption_key()


@pytest.mark.parametrize("setting", ["XAGENT_SECRET_ENCRYPTION_KEY", "SECRET_KEY"])
@pytest.mark.parametrize(
    "value",
    sorted(value for value in config.KNOWN_INSECURE_SECRETS if len(value) >= 32),
)
def test_tool_key_rejects_known_public_values_including_alias(
    monkeypatch, setting, value
):
    monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
    monkeypatch.delenv("XAGENT_SECRET_ENCRYPTION_KEY", raising=False)
    monkeypatch.delenv("SECRET_KEY", raising=False)
    monkeypatch.setenv(setting, "  " + value.upper() + "  ")
    with pytest.raises(
        RuntimeError, match=f"^{setting} must not use a public placeholder"
    ):
        config.get_tool_credentials_encryption_key()


@pytest.mark.parametrize(
    "key",
    [
        config.DEV_FALLBACK_ENCRYPTION_KEY,
        config.DEV_FALLBACK_ENCRYPTION_KEY.replace("_", "/"),
        config.DEV_FALLBACK_ENCRYPTION_KEY + "=",
        config.DEV_FALLBACK_ENCRYPTION_KEY[:10]
        + "\n"
        + config.DEV_FALLBACK_ENCRYPTION_KEY[10:],
    ],
)
def test_deployed_encryption_rejects_published_fernet_key(monkeypatch, key):
    monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
    monkeypatch.setenv("ENCRYPTION_KEY", key)
    with pytest.raises(
        RuntimeError, match="^ENCRYPTION_KEY must provide a private Fernet key$"
    ):
        config.validate_encryption_config()


@pytest.mark.parametrize(
    "setting,getter,default",
    [
        (
            "XAGENT_AUTH_RATE_LIMIT_WINDOW_SECONDS",
            config.get_auth_rate_limit_window_seconds,
            900,
        ),
        ("XAGENT_AUTH_LOGIN_IP_LIMIT", config.get_auth_login_ip_limit, 200),
        ("XAGENT_AUTH_LOGIN_ACCOUNT_LIMIT", config.get_auth_login_account_limit, 50),
        ("XAGENT_AUTH_LOGIN_PAIR_LIMIT", config.get_auth_login_pair_limit, 5),
        ("XAGENT_AUTH_RECOVERY_IP_LIMIT", config.get_auth_recovery_ip_limit, 200),
        ("XAGENT_AUTH_RECOVERY_EMAIL_LIMIT", config.get_auth_recovery_email_limit, 50),
        ("XAGENT_AUTH_RECOVERY_PAIR_LIMIT", config.get_auth_recovery_pair_limit, 5),
        ("XAGENT_EMAIL_CHANGE_TARGET_LIMIT", config.get_email_change_target_limit, 5),
        (
            "XAGENT_EMAIL_CONFIRMATION_EXPIRE_MINUTES",
            config.get_email_confirmation_expire_minutes,
            15,
        ),
        (
            "XAGENT_AUTH_RATE_LIMIT_MAX_LOCAL_KEYS",
            config.get_auth_rate_limit_max_local_keys,
            10000,
        ),
    ],
)
def test_auth_rate_budget_configuration(monkeypatch, setting, getter, default):
    monkeypatch.delenv(setting, raising=False)
    assert getter() == default
    monkeypatch.setenv(setting, "123")
    assert getter() == 123
    for invalid in ("", "0", "-1", "invalid"):
        monkeypatch.setenv(setting, invalid)
        assert getter() == default


@pytest.mark.parametrize(
    "kind,default", [("image", 64 * 1024 * 1024), ("video", 512 * 1024 * 1024)]
)
def test_media_download_size_defaults_and_overrides(monkeypatch, kind, default):
    variable = f"XAGENT_{kind.upper()}_DOWNLOAD_MAX_BYTES"
    monkeypatch.delenv(variable, raising=False)
    assert config.get_media_download_max_bytes(kind) == default
    monkeypatch.setenv(variable, "123")
    assert config.get_media_download_max_bytes(kind) == 123
    for blank in ("", "  ", "\t"):
        monkeypatch.setenv(variable, blank)
        assert config.get_media_download_max_bytes(kind) == default


@pytest.mark.parametrize("value", ["0", "-1", "invalid", "1.5"])
def test_media_download_size_rejects_invalid_limits(monkeypatch, value):
    monkeypatch.setenv("XAGENT_IMAGE_DOWNLOAD_MAX_BYTES", value)
    with pytest.raises(ValueError):
        config.get_media_download_max_bytes("image")


def test_sql_worker_url_and_token_configuration(monkeypatch):
    monkeypatch.setenv("XAGENT_SQL_WORKER_URL", " http://sql-worker:8090/ ")
    monkeypatch.setenv("XAGENT_SQL_WORKER_TOKEN", " worker-secret ")
    assert config.get_sql_worker_url() == "http://sql-worker:8090"
    assert config.get_sql_worker_token() == "worker-secret"


@pytest.mark.parametrize(
    "value",
    [
        "sql-worker:8090",
        "ftp://sql-worker",
        "http://sql-worker/path?token=secret",
        "http://user:password@sql-worker:8090",
    ],
)
def test_sql_worker_url_rejects_unsafe_values(monkeypatch, value):
    monkeypatch.setenv("XAGENT_SQL_WORKER_URL", value)
    with pytest.raises(ValueError, match="XAGENT_SQL_WORKER_URL"):
        config.get_sql_worker_url()


@pytest.mark.parametrize(
    "setting,getter,default",
    [
        (
            "XAGENT_SQL_WORKER_QUERY_TIMEOUT_SECONDS",
            config.get_sql_worker_query_timeout_seconds,
            30,
        ),
        ("XAGENT_SQL_WORKER_MAX_ROWS", config.get_sql_worker_max_rows, 10_000),
        (
            "XAGENT_SQL_WORKER_MAX_RESULT_BYTES",
            config.get_sql_worker_max_result_bytes,
            8 * 1024 * 1024,
        ),
        (
            "XAGENT_SQL_WORKER_MAX_QUERY_BYTES",
            config.get_sql_worker_max_query_bytes,
            1024 * 1024,
        ),
        (
            "XAGENT_SQL_WORKER_MAX_CONCURRENCY",
            config.get_sql_worker_max_concurrency,
            4,
        ),
    ],
)
def test_sql_worker_limits(monkeypatch, setting, getter, default):
    monkeypatch.delenv(setting, raising=False)
    assert getter() == default
    monkeypatch.setenv(setting, "7")
    assert getter() == 7


def test_sql_worker_host_and_port(monkeypatch):
    monkeypatch.delenv("XAGENT_SQL_WORKER_HOST", raising=False)
    monkeypatch.delenv("XAGENT_SQL_WORKER_PORT", raising=False)
    assert config.get_sql_worker_host() == "0.0.0.0"
    assert config.get_sql_worker_port() == 8090
    monkeypatch.setenv("XAGENT_SQL_WORKER_HOST", "127.0.0.1")
    monkeypatch.setenv("XAGENT_SQL_WORKER_PORT", "18090")
    assert config.get_sql_worker_host() == "127.0.0.1"
    assert config.get_sql_worker_port() == 18090
    monkeypatch.setenv("XAGENT_SQL_WORKER_PORT", "70000")
    with pytest.raises(ValueError, match="XAGENT_SQL_WORKER_PORT"):
        config.get_sql_worker_port()


def test_remote_json_download_size_default_and_override(monkeypatch):
    monkeypatch.delenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", raising=False)
    assert config.get_remote_json_download_max_bytes() == 10 * 1024 * 1024
    for value in ("", " "):
        monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
        assert config.get_remote_json_download_max_bytes() == 10 * 1024 * 1024
    for value, expected in (("123", 123), ("2K", 2048), ("1.5M", 1572864)):
        monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
        assert config.get_remote_json_download_max_bytes() == expected


@pytest.mark.parametrize("value", ["0", "-1", "invalid", "1.5", "nan", "inf"])
def test_remote_json_download_size_rejects_invalid_limits(monkeypatch, value):
    monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
    with pytest.raises(ValueError):
        config.get_remote_json_download_max_bytes()


def test_private_model_config_is_default_empty_and_environment_only(monkeypatch):
    assert config.get_model_private_endpoints() == []
    assert config.get_model_private_cidrs() == []
    monkeypatch.setenv("XAGENT_MODEL_PRIVATE_ENDPOINTS", " http://localhost:9997, ")
    monkeypatch.setenv("XAGENT_MODEL_PRIVATE_CIDRS", " 127.0.0.1/32,::1/128 ")
    assert config.get_model_private_endpoints() == ["http://localhost:9997"]
    assert config.get_model_private_cidrs() == ["127.0.0.1/32", "::1/128"]


class TestZendeskMarketplaceHeaders:
    """#3222: Zendesk Marketplace review checks these headers on API calls."""

    ENV_VARS = (
        "ZENDESK_MARKETPLACE_NAME",
        "ZENDESK_MARKETPLACE_ORGANIZATION_ID",
        "ZENDESK_MARKETPLACE_APP_ID",
    )

    @pytest.fixture(autouse=True)
    def _unset(self, monkeypatch):
        for name in self.ENV_VARS:
            monkeypatch.delenv(name, raising=False)

    def test_unconfigured_sends_no_headers(self, monkeypatch):
        assert config.get_zendesk_marketplace_headers() == {}
        for name in self.ENV_VARS:
            monkeypatch.setenv(name, "  ")
        assert config.get_zendesk_marketplace_headers() == {}

    def test_all_three_settings_map_to_their_headers(self, monkeypatch):
        monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", " Xagent for Zendesk ")
        monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")
        monkeypatch.setenv("ZENDESK_MARKETPLACE_APP_ID", "67890")

        assert config.get_zendesk_marketplace_headers() == {
            "X-Zendesk-Marketplace-Name": "Xagent for Zendesk",
            "X-Zendesk-Marketplace-Organization-Id": "12345",
            "X-Zendesk-Marketplace-App-Id": "67890",
        }

    def test_a_partial_configuration_sends_the_headers_that_are_set(self, monkeypatch):
        # The app ID is only assigned once the app is submitted, while review
        # already checks for the headers.
        monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", "Xagent")
        monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")

        assert config.get_zendesk_marketplace_headers() == {
            "X-Zendesk-Marketplace-Name": "Xagent",
            "X-Zendesk-Marketplace-Organization-Id": "12345",
        }

    @pytest.mark.parametrize(
        "value",
        [
            "Xagent\r\nX-Injected: 1",
            "Xagent\nfor Zendesk",
            "Xagent\tfor Zendesk",
            "Xagent für Zendesk",
            "x" * 257,
        ],
    )
    def test_an_invalid_value_is_ignored_with_a_warning(
        self, monkeypatch, caplog, value
    ):
        monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", value)
        monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")

        with caplog.at_level(logging.WARNING, logger="xagent.config"):
            headers = config.get_zendesk_marketplace_headers()

        assert headers == {"X-Zendesk-Marketplace-Organization-Id": "12345"}
        assert "ZENDESK_MARKETPLACE_NAME" in caplog.text
        # The rejected value itself is never echoed into the logs.
        assert value.strip() not in caplog.text

    def test_the_maximum_length_is_accepted(self, monkeypatch):
        monkeypatch.setenv("ZENDESK_MARKETPLACE_APP_ID", "1" * 256)

        assert config.get_zendesk_marketplace_headers() == {
            "X-Zendesk-Marketplace-App-Id": "1" * 256
        }


def test_python_executor_timeout_default_and_override(monkeypatch):
    monkeypatch.delenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", raising=False)
    assert config.get_python_executor_timeout_seconds() == 1200

    monkeypatch.setenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", "45")
    assert config.get_python_executor_timeout_seconds() == 45


@pytest.mark.parametrize("value", ["0", "-5", "soon"])
def test_python_executor_timeout_rejects_invalid_values(monkeypatch, value):
    monkeypatch.setenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", value)
    assert config.get_python_executor_timeout_seconds() == 1200


def test_public_site_configuration_is_opt_in(monkeypatch):
    from xagent.config import (
        get_dual_entry_oauth_enabled,
        get_primary_public_site_url,
        get_public_entries,
    )

    monkeypatch.delenv("XAGENT_PUBLIC_ENTRIES_JSON", raising=False)
    monkeypatch.delenv("XAGENT_PRIMARY_PUBLIC_SITE_URL", raising=False)
    monkeypatch.delenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", raising=False)
    monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://legacy.example")
    monkeypatch.setenv("XAGENT_REGION_COOKIE_DOMAIN", ".legacy.example")
    assert get_primary_public_site_url() == "https://legacy.example"
    # The unconfigured legacy entry never carries a hosting cookie domain.
    assert get_public_entries()[0].region_cookie_domain is None
    assert not get_dual_entry_oauth_enabled()


@pytest.mark.parametrize(
    "value, expected", [(None, False), ("true", True), ("false", False)]
)
def test_get_sandbox_enabled(monkeypatch, value, expected):
    from xagent.config import get_sandbox_enabled

    if value is None:
        monkeypatch.delenv("SANDBOX_ENABLED", raising=False)
    else:
        monkeypatch.setenv("SANDBOX_ENABLED", value)
    assert get_sandbox_enabled() is expected


def test_legacy_source_uploads_boundary_ignores_operator_overrides(monkeypatch):
    from xagent.config import get_legacy_source_uploads_dir

    expected = get_legacy_source_uploads_dir()
    monkeypatch.setenv("XAGENT_WEB_DIR", "/unrelated")
    monkeypatch.setenv("XAGENT_UPLOADS_DIR", "/")
    assert get_legacy_source_uploads_dir() == expected


def test_platform_git_roots_follow_relative_alternates_without_looping(
    tmp_path, monkeypatch
):
    from xagent.config import get_platform_source_roots

    checkout = tmp_path / "checkout"
    (checkout / "src" / "xagent").mkdir(parents=True)
    (checkout / "pyproject.toml").write_text('[project]\nname = "xagent-ai"\n')
    objects = checkout / ".git" / "objects"
    pool = tmp_path / "pool"
    for path in (objects, pool):
        (path / "info").mkdir(parents=True)
    (objects / "info" / "alternates").write_text(os.path.relpath(pool, objects) + "\n")
    (pool / "info" / "alternates").write_text(os.path.relpath(objects, pool) + "\n")
    monkeypatch.chdir(checkout)
    roots = get_platform_source_roots()
    assert (checkout / ".git").resolve() in roots
    assert objects.resolve() in roots
    assert pool.resolve() in roots


class TestComposioCallbackUrlConfig:
    """XAGENT_COMPOSIO_CALLBACK_URL: the one callback of every Composio connect."""

    def test_constant(self):
        assert config.COMPOSIO_CALLBACK_URL == "XAGENT_COMPOSIO_CALLBACK_URL"

    def test_unset_or_blank_keeps_the_meta_callback(self, monkeypatch):
        monkeypatch.delenv(config.COMPOSIO_CALLBACK_URL, raising=False)
        assert config.get_composio_callback_url() is None

        monkeypatch.setenv(config.COMPOSIO_CALLBACK_URL, "   ")
        assert config.get_composio_callback_url() is None

    def test_strips_whitespace_and_a_trailing_slash(self, monkeypatch):
        monkeypatch.setenv(
            config.COMPOSIO_CALLBACK_URL,
            " https://app.example.com/api/auth/composio/callback/ ",
        )
        assert (
            config.get_composio_callback_url()
            == "https://app.example.com/api/auth/composio/callback"
        )

    @pytest.mark.parametrize(
        "value",
        [
            "app.example.com/api/auth/composio/callback",
            "ftp://app.example.com/api/auth/composio/callback",
            "https://app.example.com/api/auth/composio/callback?x=1",
            "https://app.example.com/api/auth/composio/callback#x",
            "https://user:[email protected]/api/auth/composio/callback",
        ],
        ids=["no-scheme", "ftp", "query", "fragment", "credentials"],
    )
    def test_rejects_an_unusable_url(self, monkeypatch, value):
        monkeypatch.setenv(config.COMPOSIO_CALLBACK_URL, value)
        with pytest.raises(ValueError, match="XAGENT_COMPOSIO_CALLBACK_URL"):
            config.get_composio_callback_url()


@pytest.mark.parametrize(
    ("getter", "env", "lower"),
    [
        (
            config.get_execution_event_storage_entries,
            config.EXECUTION_EVENT_STORAGE_ENTRIES,
            True,
        ),
        (
            config.get_execution_event_storage_user_ids,
            config.EXECUTION_EVENT_STORAGE_USER_IDS,
            False,
        ),
    ],
)
def test_execution_event_storage_getters_raw_parsing(monkeypatch, getter, env, lower):
    monkeypatch.delenv(env, raising=False)
    assert getter() == []
    monkeypatch.setenv(env, "")
    assert getter() == []
    monkeypatch.setenv(env, "   ")
    assert getter() == []
    monkeypatch.setenv(env, " Sdk ,, A2A , sdk,")
    expected = ["sdk", "a2a", "sdk"] if lower else ["Sdk", "A2A", "sdk"]
    assert getter() == expected


def test_execution_event_storage_getters_do_not_validate(monkeypatch):
    monkeypatch.setenv(config.EXECUTION_EVENT_STORAGE_USER_IDS, "1, abc, -2")
    assert config.get_execution_event_storage_user_ids() == ["1", "abc", "-2"]