coder-eval 0.8.2__py3-none-any.whl

coder_eval/cli/run_helpers.py

@@ -0,0 +1,137 @@
+"""Helper functions for the run command."""
+
+import random
+from pathlib import Path
+
+import typer
+
+from ..config import settings
+from ..models import RunSummary
+from ..path_utils import TASK_LOG_FILENAME, generate_run_id
+from .console import console
+
+
+# Resolve tasks/ relative to project root — this is a repo-only feature.
+# When running from a wheel install, users must provide explicit task file paths.
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+DEFAULT_TASKS_DIR = _PROJECT_ROOT / "tasks"
+
+
+def discover_default_tasks() -> list[Path]:
+    """Recursively find all .yaml task files under the default tasks/ directory.
+
+    This feature requires a source checkout — the tasks/ directory is not
+    shipped in the wheel. When running from an installed package, provide
+    explicit task file paths instead.
+
+    Returns:
+        Sorted list of task file paths.
+
+    Raises:
+        typer.Exit: If the tasks/ directory doesn't exist or contains no YAML files.
+    """
+    if not DEFAULT_TASKS_DIR.is_dir():
+        console.print(f"[red]Default tasks directory not found: {DEFAULT_TASKS_DIR}[/red]")
+        console.print(
+            "[yellow]Hint: Zero-argument task discovery requires a source checkout. "
+            + "Provide explicit task file paths instead: coder-eval run task1.yaml task2.yaml[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    task_files = list(DEFAULT_TASKS_DIR.rglob("*.yaml"))
+    if not task_files:
+        console.print(f"[red]No .yaml files found in {DEFAULT_TASKS_DIR}[/red]")
+        raise typer.Exit(1)
+
+    random.shuffle(task_files)
+    console.print(f"[dim]Discovered {len(task_files)} task(s) from {DEFAULT_TASKS_DIR}[/dim]")
+    return task_files
+
+
+def prepare_run_directory(run_dir: Path | None) -> Path:
+    """Create and prepare the run directory.
+
+    Args:
+        run_dir: Custom run directory path, or None to auto-generate
+
+    Returns:
+        Path to the prepared run directory
+    """
+    if run_dir is None:
+        run_id = generate_run_id()
+        run_dir = settings.runs_dir / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    console.print(f"[bold]Run directory:[/bold] {run_dir}\n")
+    return run_dir
+
+
+def expand_task_files(task_files: list[Path]) -> list[Path]:
+    """Expand glob patterns and collect all task files.
+
+    Args:
+        task_files: List of task file paths or glob patterns
+
+    Returns:
+        List of resolved task file paths
+
+    Raises:
+        typer.Exit: If no task files are found
+    """
+    all_task_files = []
+    for pattern in task_files:
+        if pattern.is_file():
+            all_task_files.append(pattern)
+        else:
+            # Try as glob pattern (supports ** for recursive matching)
+            if pattern.is_absolute():
+                all_task_files.extend(Path(pattern.anchor).glob(str(pattern.relative_to(pattern.anchor))))
+            else:
+                all_task_files.extend(Path().glob(str(pattern)))
+
+    if not all_task_files:
+        console.print("[red]No task files found![/red]")
+        raise typer.Exit(1)
+
+    random.shuffle(all_task_files)
+    return all_task_files
+
+
+def print_execution_mode(task_count: int, max_parallel: int) -> None:
+    """Print execution mode information.
+
+    Args:
+        task_count: Number of tasks to execute
+        max_parallel: Maximum parallel tasks
+    """
+    console.print(f"\n[bold]Running {task_count} task(s)[/bold]")
+    if max_parallel > 1:
+        console.print(f"[dim]Max parallel tasks: {max_parallel}[/dim]\n")
+    else:
+        console.print("[dim]Mode: Sequential[/dim]\n")
+
+
+def print_execution_summary(run_dir: Path, summary: RunSummary) -> None:
+    """Print execution summary with results and log file locations.
+
+    Args:
+        run_dir: Path to the run directory
+        summary: Run execution summary
+    """
+    console.print(f"\n[bold green]Run complete:[/bold green] {run_dir}")
+    console.print(f"[bold]Results:[/bold] {summary.tasks_succeeded}/{summary.tasks_run} succeeded")
+    console.print(f"[dim]View report: open {run_dir / 'experiment.md'}[/dim]")
+    console.print(f"[dim]View report: uv run coder-eval report {run_dir}[/dim]")
+
+    # Print log file locations
+    console.print("\n[bold]Log Files:[/bold]")
+    run_log_path = run_dir / "experiment.log"
+    if run_log_path.exists():
+        console.print(f"  Experiment log: {run_log_path}")
+
+    # Print task logs (find all task.log files under variant directories)
+    for task_log in sorted(run_dir.glob(f"**/{TASK_LOG_FILENAME}")):
+        # Dataset fan-out task_ids contain slashes, so render the full
+        # relative path rather than indexing fixed parent segments.
+        rel = task_log.parent.relative_to(run_dir).as_posix()
+        console.print(f"  Task log ({rel}): {task_log}")

coder_eval/cli/run_task_internal_command.py

@@ -0,0 +1,210 @@
+"""Internal CLI subcommand executed inside the Docker container.
+
+Not part of the public CLI surface -- the host's :class:`DockerRunner`
+invokes it via ``docker run``. It loads the staged task + context from
+``/work/input``, runs one full evaluation cycle in-process (driver=tempdir),
+and writes ``task.json`` + ``task.html`` to ``/work/output``.
+
+The container always exits 0 once ``task.json`` is written, even if the
+task itself failed -- criterion failures are signaled via the final_status
+field, not the container exit code. Setup failures (missing input,
+malformed YAML) exit non-zero before producing task.json so the host can
+distinguish them from task-level failures.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+from pathlib import Path
+
+import typer
+
+from coder_eval.config import settings
+from coder_eval.isolation.docker_runner import (
+    HEARTBEAT_FILENAME,
+    HEARTBEAT_STALE_SECONDS,
+)
+from coder_eval.logging_config import setup_logging
+from coder_eval.models import (
+    CONTAINER_INPUT_DIR,
+    CONTAINER_OUTPUT_DIR,
+    CONTAINER_TASK_DIR,
+    ConfigLineageEntry,
+    PreservationMode,
+)
+from coder_eval.orchestration.task_loader import load_task
+
+
+logger = logging.getLogger(__name__)
+
+
+def heartbeat_is_alive(current: str, last_counter: str, current_mtime: float, last_mtime: float) -> bool:
+    """True when the heartbeat shows a fresh signal of life.
+
+    Counter advance OR mtime advance counts as alive. The mtime arm covers the empty-counter
+    startup race (host touch + delayed first write → both reads ""; mtime advanced); the counter
+    arm covers bind-mount mtime latency (macOS gRPC-FUSE/VirtioFS) where mtime lags the write.
+    """
+    return bool(current and current != last_counter) or current_mtime > last_mtime
+
+
+def run_task_internal_command(
+    input_dir: Path = typer.Option(  # noqa: B008
+        Path(CONTAINER_INPUT_DIR),
+        "--input",
+        help="Directory containing task.yaml and context.json (bind-mounted by host).",
+    ),
+    output_dir: Path = typer.Option(  # noqa: B008
+        Path(CONTAINER_OUTPUT_DIR),
+        "--output",
+        help="Directory to write task.json/task.html into (bind-mounted by host).",
+    ),
+    task_dir: Path = typer.Option(  # noqa: B008
+        Path(CONTAINER_TASK_DIR),
+        "--task-dir",
+        help="Original task directory mount (used to resolve relative template paths).",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Enable verbose (DEBUG level) logging",
+    ),
+) -> None:
+    """Run a single staged task inside the container."""
+    # Use the same logging path as the host CLI so LOG_LEVEL from the
+    # forwarded env is honoured. Without this, root stays at INFO and the
+    # DEBUG-level task_log_handler attached by Orchestrator never sees the
+    # agent's per-tool-call DEBUG records.
+    log_level = "DEBUG" if verbose else settings.log_level
+    setup_logging(level=log_level)
+
+    # Start the host-heartbeat watchdog: if the host process dies
+    # ungracefully (SIGKILL, Claude-Code Escape, crash) before it can
+    # `docker kill` us, the heartbeat file in output_dir goes stale and
+    # we self-exit -- otherwise the container would keep burning LLM
+    # budget orphaned. Daemon thread so it doesn't block normal shutdown.
+    import os as _os
+    import threading
+    import time
+
+    def _watch_host_heartbeat() -> None:
+        heartbeat = output_dir / HEARTBEAT_FILENAME
+        # Grace period for the host to write the first counter value.
+        time.sleep(HEARTBEAT_STALE_SECONDS)
+        last_counter = ""
+        last_mtime = 0.0
+        last_change = time.monotonic()
+        while True:
+            try:
+                current = heartbeat.read_text(encoding="utf-8")
+            except (FileNotFoundError, OSError):
+                current = ""
+            try:
+                current_mtime = heartbeat.stat().st_mtime
+            except (FileNotFoundError, OSError):
+                current_mtime = 0.0
+            now = time.monotonic()
+            if heartbeat_is_alive(current, last_counter, current_mtime, last_mtime):
+                last_counter = current
+                last_mtime = current_mtime
+                last_change = now
+            if now - last_change > HEARTBEAT_STALE_SECONDS:
+                logger.error(
+                    "Host heartbeat stale (>%ss); exiting to reap orphan container.",
+                    HEARTBEAT_STALE_SECONDS,
+                )
+                # os._exit skips atexit and IO flushing, so the error line
+                # above would routinely be lost -- making a genuine
+                # stale-heartbeat suicide indistinguishable from an external
+                # SIGKILL in the archived logs. Flush best-effort first;
+                # never let a flush failure stop the exit.
+                import sys as _sys
+
+                for _handler in logging.getLogger().handlers:
+                    with contextlib.suppress(Exception):
+                        _handler.flush()
+                with contextlib.suppress(Exception):
+                    _sys.stdout.flush()
+                with contextlib.suppress(Exception):
+                    _sys.stderr.flush()
+                _os._exit(137)
+            time.sleep(HEARTBEAT_STALE_SECONDS / 4)
+
+    threading.Thread(target=_watch_host_heartbeat, daemon=True).start()
+
+    task_yaml = input_dir / "task.yaml"
+    context_json = input_dir / "context.json"
+    if not task_yaml.exists():
+        typer.echo(f"FATAL: missing {task_yaml}", err=True)
+        raise typer.Exit(2)
+    if not context_json.exists():
+        typer.echo(f"FATAL: missing {context_json}", err=True)
+        raise typer.Exit(2)
+
+    context = json.loads(context_json.read_text(encoding="utf-8"))
+    variant_id: str = context["variant_id"]
+    replicate_index: int = context.get("replicate_index", 0)
+    # The host resolves the driver-derived default before dispatch; the container
+    # obeys it verbatim. This command only ever runs inside the docker driver, so
+    # a missing key falls back to the docker default (DIRECT_WRITE) — a deliberate
+    # default, not version back-compat.
+    preservation_mode = PreservationMode(context.get("preservation_mode", PreservationMode.DIRECT_WRITE.value))
+    # Docker WORKDIR alignment: the host resolves the concrete WORKDIR
+    # (config value / "auto" -> `docker inspect` / fallback) and forwards it here.
+    # Absent -> None -> standard run_dir/artifacts workspace.
+    workspace_dir_raw = context.get("workspace_dir")
+    workspace_dir = Path(workspace_dir_raw) if workspace_dir_raw else None
+    config_lineage = {k: ConfigLineageEntry.model_validate(v) for k, v in (context.get("config_lineage") or {}).items()}
+    # Prefer the host's raw source_yaml so task.json's audit trail matches
+    # the in-process driver. Fall back to the staged (post-override) YAML
+    # for older host versions that didn't forward it.
+    host_source_yaml: str | None = context.get("source_yaml")
+
+    # Load the post-override spec from the staged YAML. We then point
+    # `task_file` at a path *under the symmetric task_dir mount* so the
+    # Orchestrator's `task_file.parent` reasoning -- specifically the
+    # `TASK_DIR` env exposed to `run_command` criteria -- resolves to the
+    # original host task directory rather than `/work/input/`.
+    task, source_yaml = load_task(task_yaml)
+    if host_source_yaml is not None:
+        source_yaml = host_source_yaml
+    # The path below is never re-read; it only seeds Orchestrator's TASK_DIR.
+    runtime_task_file = task_dir / "task.yaml" if task_dir.is_dir() else task_yaml
+
+    # Force driver back to tempdir for the actual in-container run.
+    # We're already inside the container; another nested docker would be
+    # both wrong and impossible (no docker CLI in image).
+    if task.sandbox.driver == "docker":
+        task = task.model_copy(update={"sandbox": task.sandbox.model_copy(update={"driver": "tempdir"})})
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Late import: orchestrator pulls in heavy deps (anthropic SDK etc.)
+    # that we don't want to load just to print --help.
+    from coder_eval.orchestrator import Orchestrator
+
+    orchestrator = Orchestrator(
+        task=task,
+        run_dir=output_dir,
+        preservation_mode=preservation_mode,
+        task_file=runtime_task_file,
+        variant_id=variant_id,
+        source_yaml=source_yaml,
+        config_lineage=config_lineage,
+        replicate_index=replicate_index,
+        workspace_dir=workspace_dir,
+    )
+
+    # Install the stdout-NDJSON stream callback so per-tool-call events
+    # reach the host. Late import keeps the streaming module out of the
+    # default --help path.
+    from coder_eval.streaming.wire import StdoutNDJsonCallback
+
+    orchestrator.stream_callback = StdoutNDJsonCallback()
+
+    asyncio.run(orchestrator.run())
+    # Orchestrator.run() writes task.json to run_dir (== output_dir). Done.

coder_eval/cli/utils.py

@@ -0,0 +1,37 @@
+"""Shared utility functions for CLI commands."""
+
+import shutil
+
+from ..config import settings
+from .console import console
+
+
+def check_tools() -> None:
+    """Check that required tools are available."""
+    console.print("[bold]Checking required tools...[/bold]")
+
+    tools = {
+        "claude": "Claude Code CLI",
+        "uv": "UV package manager",
+    }
+
+    all_found = True
+    for cmd, name in tools.items():
+        if shutil.which(cmd):
+            console.print(f"  [green]✓[/green] {name} ({cmd})")
+        else:
+            console.print(f"  [red]✗[/red] {name} ({cmd}) not found")
+            all_found = False
+
+    if not all_found:
+        console.print("[yellow]Warning: Some tools are missing[/yellow]")
+
+
+def check_api_keys() -> None:
+    """Check that API keys are configured."""
+    console.print("\n[bold]Checking API keys...[/bold]")
+
+    if settings.anthropic_api_key:
+        console.print("  [green]✓[/green] ANTHROPIC_API_KEY is set")
+    else:
+        console.print("  [yellow]⚠[/yellow] ANTHROPIC_API_KEY not set")

coder_eval/config.py

@@ -0,0 +1,212 @@
+"""Configuration management using pydantic-settings."""
+
+# by-design model-hub ↔ config type-level cycle; runtime imports are lazy per CE017
+# pyright: reportImportCycles=false
+
+import base64
+import os
+from pathlib import Path
+from typing import Any
+
+from dotenv import dotenv_values, load_dotenv
+from pydantic import AliasChoices, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from coder_eval.models import AgentKind, ApiBackend
+
+
+# Application Insights connection string baked into the application so a fresh
+# install reports usage telemetry to the shared coder-eval resource with no
+# configuration. An explicitly-set connection string (env or .env, via any of the
+# field's aliases below) takes precedence — pydantic-settings always prefers an
+# env value over a field default.
+#
+# This is an INGESTION-ONLY connection string (InstrumentationKey + IngestionEndpoint):
+# it can only WRITE telemetry to the resource, never read/query/manage it — the same
+# class of value embedded in every distributed telemetry client (VS Code, Azure CLI,
+# gh, the UiPath CLI). Approved by security for embedding. It is base64-wrapped ONLY
+# to avoid tripping naive secret scanners / push-protection and to mark it as an
+# intentional, reviewed default — NOT for secrecy (base64 is trivially reversible).
+# Residual risk is telemetry spoofing / ingestion-cost abuse, bounded by the resource
+# being dedicated to coder-eval usage telemetry.
+_DEFAULT_TELEMETRY_CONNECTION_STRING = base64.b64decode(
+    "SW5zdHJ1bWVudGF0aW9uS2V5PTgxZDBkOGI1LTg1ZjktNDMxNS1iYjJlLTg4ODg0Y2ZkYTVhNztJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3R1czItMi5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdHVzMi5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MDRjN2U3ZjItYjg0OC00ZjhlLTkxNzMtZjI3NmE1YTAwMzk0"
+).decode("utf-8")
+
+
+# Load .env file with override so .env values always win over shell environment
+load_dotenv(override=True)
+
+# For certain keys, we want .env values to take precedence over shell environment
+# because the shell may have outdated/different credentials
+env_values = dotenv_values(".env")
+for key in [
+    "ANTHROPIC_API_KEY",
+]:
+    value = env_values.get(key)
+    if value:
+        os.environ[key] = value
+
+
+# Removed layer-5 `.env` knobs → their `-D` override paths. pydantic-settings
+# silently ignores unknown env vars, so without an explicit guard a stale knob
+# would silently stop having any effect — fail loud with a migration hint instead.
+_REMOVED_DEFAULT_KNOBS = {
+    "DEFAULT_AGENT_MODEL": "agent.model",
+    "DEFAULT_PERMISSION_MODE": "agent.permission_mode",
+    "DEFAULT_MAX_TURNS": "run_limits.max_turns",
+}
+
+
+def _reject_removed_default_knobs() -> None:
+    """Fail loud on stale removed DEFAULT_* env knobs (see _REMOVED_DEFAULT_KNOBS).
+
+    An os.environ-only check suffices: load_dotenv(override=True) at module
+    import folds the .env file into os.environ before Settings is constructed
+    (if that load_dotenv were ever removed, this guard would silently narrow to
+    shell-env-only).
+
+    Called from Settings.__init__ BEFORE pydantic validation so the plain
+    ValueError propagates as-is — a pydantic ValidationError would echo the
+    full input dict (including API keys) into the error message.
+    """
+    stale = [name for name in _REMOVED_DEFAULT_KNOBS if os.environ.get(name)]
+    if stale:
+        hints = " ".join(
+            f"{name} was removed — set the baseline in experiments/default.yaml"
+            + f" ({_REMOVED_DEFAULT_KNOBS[name]}) or override per-run with -D {_REMOVED_DEFAULT_KNOBS[name]}=…"
+            + (" / --model." if name == "DEFAULT_AGENT_MODEL" else ".")
+            for name in stale
+        )
+        raise ValueError(f"{hints} Remove the variable(s) from your .env / shell environment.")
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        _reject_removed_default_knobs()
+        super().__init__(*args, **kwargs)
+
+    # API Keys (for Claude Code agent only)
+    anthropic_api_key: str | None = None
+
+    # Paths
+    runs_dir: Path = Path("runs")  # Base directory for timestamped runs
+
+    # API Backend routing
+    api_backend: ApiBackend = ApiBackend.DIRECT
+
+    # AWS Bedrock settings (used when api_backend == "bedrock")
+    aws_bearer_token_bedrock: str | None = None
+    aws_region: str | None = None
+    bedrock_model: str | None = None  # Cross-region model ID
+    bedrock_small_model: str | None = None  # Cross-region small model ID
+
+    # Codex settings (CodexAgent). CODEX_MODEL is the fallback model/deployment
+    # used when a task doesn't pin agent.model; CODEX_BASE_URL routes to a custom
+    # OpenAI-/responses-compatible endpoint (incl. Azure OpenAI). For Azure also
+    # set CODEX_API_VERSION (the required ``api-version`` query param) and use the
+    # deployment name as the model. CODEX_BASE_URL / CODEX_API_VERSION /
+    # CODEX_API_KEY are read directly via os.getenv in the agent, not mirrored here.
+    codex_model: str | None = None
+
+    # Antigravity settings (AntigravityAgent — Google's Gemini coding harness).
+    # GEMINI_API_KEY authenticates the local harness (read from .env here so the
+    # export loop below re-publishes it to os.environ, where the google-antigravity
+    # SDK looks for it). ANTIGRAVITY_MODEL is the fallback Gemini model used when a
+    # task doesn't pin agent.model.
+    gemini_api_key: str | None = None
+    antigravity_model: str | None = None
+
+    # Logging
+    log_level: str = "INFO"  # Default log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    log_to_file: bool = False  # Whether to enable file logging
+
+    # Usage telemetry (OpenTelemetry → Azure Application Insights customEvents).
+    # On by default via the baked-in connection string; see coder_eval/telemetry.py.
+    # telemetry_enabled (TELEMETRY_ENABLED) is the single canonical disable gate.
+    telemetry_enabled: bool = True
+    # Defaults to the embedded coder-eval resource; any set value (env or .env, via
+    # the aliases below) overrides it — pydantic-settings prefers env over default.
+    telemetry_connection_string: str | None = Field(
+        default=_DEFAULT_TELEMETRY_CONNECTION_STRING,
+        validation_alias=AliasChoices(
+            "telemetry_connection_string",
+            "applicationinsights_connection_string",
+            "uipath_ai_connection_string",
+        ),
+    )
+    # Caller-settable origin stamp (TELEMETRY_SOURCE), emitted as the `Source`
+    # dimension on every event. Lets downstream pipelines tag themselves (e.g.
+    # `nightly-vm` / `skill-eval`) so internal runs are distinguishable from
+    # anonymous local ones — `IsCI` alone can't, and the framework's own CI is
+    # muted. Defaults to "coder-eval" for a plain local install.
+    telemetry_source: str = "coder-eval"
+
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", case_sensitive=False, extra="ignore")
+
+    def _validate_bedrock_settings(self) -> None:
+        """Validate that required AWS Bedrock settings are present.
+
+        Raises:
+            ValueError: If required Bedrock settings are missing
+        """
+        missing = []
+        if not self.aws_bearer_token_bedrock:
+            missing.append("AWS_BEARER_TOKEN_BEDROCK")
+        if not self.aws_region:
+            missing.append("AWS_REGION")
+        # BEDROCK_MODEL is the route-level model source. Without it, an
+        # invocation that doesn't override via --model / task.agent.model
+        # would send model=None to the SDK and Bedrock would return an
+        # opaque 400. Fail fast at startup with a clear error.
+        if not self.bedrock_model:
+            missing.append("BEDROCK_MODEL")
+        if missing:
+            raise ValueError(
+                f"Bedrock routing is enabled but missing required settings: {', '.join(missing)}."
+                + " Please set them in your .env file."
+            )
+
+    def validate_api_keys(self, agent_type: str) -> None:
+        """Validate that required API keys are present.
+
+        Args:
+            agent_type: The type of agent being used
+
+        Raises:
+            ValueError: If required API key is missing
+        """
+        # The no-op agent (agent: {type: none}) makes no model API call, so it
+        # needs no credentials — not even the backend (Bedrock) settings.
+        if agent_type == AgentKind.NONE.value:
+            return
+
+        if self.api_backend == ApiBackend.BEDROCK:
+            self._validate_bedrock_settings()
+
+        # Claude Code agent can use either:
+        # 1. ANTHROPIC_API_KEY environment variable
+        # 2. Cached CLI authentication from 'claude-code login' (subscription account)
+        # We don't validate the API key here because the SDK handles auth and fails clearly if missing.
+        if agent_type == AgentKind.CLAUDE_CODE.value:
+            return
+
+
+# Global settings instance
+settings = Settings()
+
+# Export settings to environment variables for external libraries (the Anthropic SDK,
+# boto3/Bedrock) that use os.getenv() instead of reading from the Settings object.
+# Only export non-None values and convert non-string types to strings.
+for key, value in settings.model_dump().items():
+    if value is not None:
+        env_key = key.upper()
+        # Convert Path objects and other types to strings
+        if isinstance(value, Path):
+            os.environ[env_key] = str(value)
+        elif isinstance(value, bool):
+            os.environ[env_key] = str(value).lower()
+        else:
+            os.environ[env_key] = str(value)