empathy-framework 4.8.0__py3-none-any.whl → 4.9.0__py3-none-any.whl

empathy_os/workflow_commands.py

@@ -137,7 +137,7 @@ def morning_workflow(
     print("-" * 40)
 
     total_bugs = len(patterns.get("debugging", []))
-    resolved_bugs = len([p for p in patterns.get("debugging", []) if p.get("status") == "resolved"])
+    resolved_bugs = sum(1 for p in patterns.get("debugging", []) if p.get("status") == "resolved")
     security_decisions = len(patterns.get("security", []))
 
     print(f"  Bug patterns:        {total_bugs} ({resolved_bugs} resolved)")
@@ -207,14 +207,14 @@ def morning_workflow(
         checks_passed += 1
         print("  Lint:     OK")
     else:
-        issues = len([line for line in output.split("\n") if line.strip()])
+        issues = sum(1 for line in output.split("\n") if line.strip())
         print(f"  Lint:     {issues} issues")
 
     # Check for uncommitted changes
     checks_total += 1
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
-        changes = len([line for line in output.split("\n") if line.strip()])
+        changes = sum(1 for line in output.split("\n") if line.strip())
         if changes == 0:
             checks_passed += 1
             print("  Git:      Clean")
@@ -312,7 +312,7 @@ def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
     if not success or not output.strip():
         print("   PASS - No obvious hardcoded secrets")
     else:
-        lines = len([line for line in output.split("\n") if line.strip()])
+        lines = sum(1 for line in output.split("\n") if line.strip())
         issues.append(f"Secrets: {lines} potential hardcoded secrets")
         print(f"   WARN - {lines} potential hardcoded values found")
 
@@ -322,7 +322,7 @@ def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
     if not output.strip():
         print("   PASS - No sensitive files tracked")
     else:
-        files = len([line for line in output.split("\n") if line.strip()])
+        files = sum(1 for line in output.split("\n") if line.strip())
         issues.append(f"Files: {files} sensitive files in git")
         print(f"   WARN - {files} sensitive files tracked in git")
 
@@ -427,10 +427,10 @@ def ship_workflow(
     print("4. Checking git status...")
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
-        staged = len(
-            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))],
+        staged = sum(
+            1 for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))
         )
-        unstaged = len([line for line in output.split("\n") if line.startswith((" M", " D", "??"))])
+        unstaged = sum(1 for line in output.split("\n") if line.startswith((" M", " D", "??")))
         if staged > 0:
             print(f"   INFO - {staged} staged, {unstaged} unstaged")
         elif unstaged > 0:
@@ -523,7 +523,7 @@ def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bo
         print(f"   Fixed {fixed} issues")
     else:
         # Some issues couldn't be auto-fixed
-        unfixable = len([line for line in output.split("\n") if "error" in line.lower()])
+        unfixable = sum(1 for line in output.split("\n") if "error" in line.lower())
         print(f"   {unfixable} issues require manual fix")
         if verbose:
             print(output)

empathy_os/workflows/__init__.py

@@ -80,11 +80,9 @@ from .base import (
     get_workflow_stats,
 )
 
-# Builder pattern for workflow construction
-from .builder import WorkflowBuilder, workflow_builder
-
 # Config is small and frequently needed
 from .config import DEFAULT_MODELS, ModelConfig, WorkflowConfig, create_example_config, get_model
+from .step_config import WorkflowStepConfig, steps_from_tier_map, validate_step_config
 
 # Routing strategies (small, frequently needed for builder pattern)
 from .routing import (
@@ -94,7 +92,9 @@ from .routing import (
     RoutingContext,
     TierRoutingStrategy,
 )
-from .step_config import WorkflowStepConfig, steps_from_tier_map, validate_step_config
+
+# Builder pattern for workflow construction
+from .builder import WorkflowBuilder, workflow_builder
 
 # Lazy import mapping for workflow classes
 _LAZY_WORKFLOW_IMPORTS: dict[str, tuple[str, str]] = {

empathy_os/workflows/base.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 
 import json
 import logging
-import sys
 import time
 import uuid
 from abc import ABC, abstractmethod
@@ -58,12 +57,7 @@ from empathy_os.models import ModelTier as UnifiedModelTier
 from .caching import CachedResponse, CachingMixin
 
 # Import progress tracking
-from .progress import (
-    RICH_AVAILABLE,
-    ProgressCallback,
-    ProgressTracker,
-    RichProgressReporter,
-)
+from .progress import ProgressCallback, ProgressTracker
 from .telemetry_mixin import TelemetryMixin
 
 # Import telemetry tracking
@@ -550,7 +544,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         enable_tier_tracking: bool = True,
         enable_tier_fallback: bool = False,
         routing_strategy: TierRoutingStrategy | None = None,
-        enable_rich_progress: bool = False,
     ):
         """Initialize workflow with optional cost tracker, provider, and config.
 
@@ -576,11 +569,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
                      When provided, overrides static tier_map for stage tier decisions.
                      Strategies: CostOptimizedRouting, PerformanceOptimizedRouting,
                      BalancedRouting, HybridRouting.
-            enable_rich_progress: Whether to enable Rich-based live progress display
-                     (default False). When enabled and output is a TTY, shows live
-                     progress bars with spinners. Default is False because most users
-                     run workflows from IDEs (VSCode, etc.) where TTY is not available.
-                     The console reporter works reliably in all environments.
 
         """
         from .config import WorkflowConfig
@@ -591,8 +579,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         # Progress tracking
         self._progress_callback = progress_callback
         self._progress_tracker: ProgressTracker | None = None
-        self._enable_rich_progress = enable_rich_progress
-        self._rich_reporter: RichProgressReporter | None = None
 
         # New: LLMExecutor support
         self._executor = executor
@@ -1069,39 +1055,15 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         current_data = kwargs
         error = None
 
-        # Initialize progress tracker
-        # Always show progress by default (IDE-friendly console output)
-        # Rich live display only when explicitly enabled AND in TTY
-        from .progress import ConsoleProgressReporter
-
-        self._progress_tracker = ProgressTracker(
-            workflow_name=self.name,
-            workflow_id=self._run_id,
-            stage_names=self.stages,
-        )
-
-        # Add user's callback if provided
+        # Initialize progress tracker if callback provided
         if self._progress_callback:
+            self._progress_tracker = ProgressTracker(
+                workflow_name=self.name,
+                workflow_id=self._run_id,
+                stage_names=self.stages,
+            )
             self._progress_tracker.add_callback(self._progress_callback)
-
-        # Rich progress: only when explicitly enabled AND in a TTY
-        if self._enable_rich_progress and RICH_AVAILABLE and sys.stdout.isatty():
-            try:
-                self._rich_reporter = RichProgressReporter(self.name, self.stages)
-                self._progress_tracker.add_callback(self._rich_reporter.report)
-                self._rich_reporter.start()
-            except Exception as e:
-                # Fall back to console reporter
-                logger.debug(f"Rich progress unavailable: {e}")
-                self._rich_reporter = None
-                console_reporter = ConsoleProgressReporter(verbose=False)
-                self._progress_tracker.add_callback(console_reporter.report)
-        else:
-            # Default: use console reporter (works in IDEs, terminals, everywhere)
-            console_reporter = ConsoleProgressReporter(verbose=False)
-            self._progress_tracker.add_callback(console_reporter.report)
-
-        self._progress_tracker.start_workflow()
+            self._progress_tracker.start_workflow()
 
         try:
             # Tier fallback mode: try CHEAP → CAPABLE → PREMIUM with validation
@@ -1431,14 +1393,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         if self._progress_tracker and error is None:
             self._progress_tracker.complete_workflow()
 
-        # Stop Rich progress display if active
-        if self._rich_reporter:
-            try:
-                self._rich_reporter.stop()
-            except Exception:
-                pass  # Best effort cleanup
-            self._rich_reporter = None
-
         # Save to workflow history for dashboard
         try:
             _save_workflow_run(self.name, provider_str, result)

empathy_os/workflows/bug_predict.py

@@ -695,7 +695,7 @@ class BugPredictionWorkflow(BaseWorkflow):
             {
                 "correlations": correlations,
                 "correlation_count": len(correlations),
-                "high_confidence_count": len([c for c in correlations if c["confidence"] > 0.6]),
+                "high_confidence_count": sum(1 for c in correlations if c["confidence"] > 0.6),
                 **input_data,
             },
             input_tokens,
@@ -759,7 +759,7 @@ class BugPredictionWorkflow(BaseWorkflow):
             {
                 "predictions": predictions[:20],  # Top 20 risky files
                 "overall_risk_score": round(self._risk_score, 2),
-                "high_risk_files": len([p for p in predictions if float(p["risk_score"]) > 0.7]),
+                "high_risk_files": sum(1 for p in predictions if float(p["risk_score"]) > 0.7),
                 **input_data,
             },
             input_tokens,

empathy_os/workflows/history.py

@@ -459,6 +459,10 @@ class WorkflowHistoryStore:
         Returns:
             Number of runs deleted
         """
+        cutoff = datetime.now().replace(
+            hour=0, minute=0, second=0, microsecond=0
+        ).isoformat()
+
         cursor = self.conn.cursor()
 
         # Get run IDs to delete
@@ -476,14 +480,12 @@ class WorkflowHistoryStore:
             return 0
 
         # Delete stages for these runs
-        # Security Note: f-string builds placeholder list only ("?, ?, ?")
-        # Actual data (run_ids) passed as parameters - SQL injection safe
         placeholders = ",".join("?" * len(run_ids))
         cursor.execute(
             f"DELETE FROM workflow_stages WHERE run_id IN ({placeholders})", run_ids
         )
 
-        # Delete runs (same safe parameterization pattern)
+        # Delete runs
         cursor.execute(
             f"DELETE FROM workflow_runs WHERE run_id IN ({placeholders})", run_ids
         )

empathy_os/workflows/perf_audit.py

@@ -269,10 +269,10 @@ class PerformanceAuditWorkflow(BaseWorkflow):
         # Analyze each file
         analysis: list[dict] = []
         for file_path, file_findings in by_file.items():
-            # Calculate file complexity score
-            high_count = len([f for f in file_findings if f["impact"] == "high"])
-            medium_count = len([f for f in file_findings if f["impact"] == "medium"])
-            low_count = len([f for f in file_findings if f["impact"] == "low"])
+            # Calculate file complexity score (generator expressions for memory efficiency)
+            high_count = sum(1 for f in file_findings if f["impact"] == "high")
+            medium_count = sum(1 for f in file_findings if f["impact"] == "medium")
+            low_count = sum(1 for f in file_findings if f["impact"] == "low")
 
             complexity_score = high_count * 10 + medium_count * 5 + low_count * 1
 

empathy_os/workflows/progress.py

@@ -11,35 +11,12 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
-import sys
-import uuid
-from collections.abc import Callable, Coroutine, Generator
-from contextlib import contextmanager
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from typing import Any, Protocol
 
-logger = logging.getLogger(__name__)
-
-# Rich imports with fallback
-try:
-    from rich.console import Console, Group
-    from rich.live import Live
-    from rich.panel import Panel
-    from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn
-    from rich.table import Table
-    from rich.text import Text
-
-    RICH_AVAILABLE = True
-except ImportError:
-    RICH_AVAILABLE = False
-    Console = None  # type: ignore
-    Live = None  # type: ignore
-    Panel = None  # type: ignore
-    Progress = None  # type: ignore
-
 
 class ProgressStatus(Enum):
     """Status of a workflow or stage."""
@@ -384,9 +361,9 @@ class ProgressTracker:
         for callback in self._callbacks:
             try:
                 callback(update)
-            except Exception:  # noqa: BLE001
-                # INTENTIONAL: Callbacks are optional - never fail workflow on callback error
-                logger.warning("Progress callback error", exc_info=True)
+            except Exception as e:
+                # Log but don't fail on callback errors
+                print(f"Progress callback error: {e}")
 
         # Call async callbacks
         for async_callback in self._async_callbacks:
@@ -410,111 +387,39 @@ class ProgressReporter(Protocol):
 
 
 class ConsoleProgressReporter:
-    """Console-based progress reporter optimized for IDE environments.
+    """Simple console-based progress reporter for CLI usage."""
 
-    Provides clear, readable progress output that works reliably in:
-    - VSCode integrated terminal
-    - VSCode output panel
-    - IDE debug consoles
-    - Standard terminals
-
-    Uses Unicode symbols that render correctly in most environments.
-    """
-
-    def __init__(self, verbose: bool = False, show_tokens: bool = False):
-        """Initialize console progress reporter.
-
-        Args:
-            verbose: Show additional details (fallback info, errors)
-            show_tokens: Include token counts in output
-        """
+    def __init__(self, verbose: bool = False):
         self.verbose = verbose
-        self.show_tokens = show_tokens
-        self._start_time: datetime | None = None
-        self._stage_times: dict[str, int] = {}
 
     def report(self, update: ProgressUpdate) -> None:
-        """Print progress to console.
-
-        Args:
-            update: Progress update from the tracker
-        """
-        # Track start time for elapsed calculation
-        if self._start_time is None:
-            self._start_time = datetime.now()
-
-        percent = f"{update.percent_complete:3.0f}%"
+        """Print progress to console."""
+        percent = f"{update.percent_complete:.0f}%"
         cost = f"${update.cost_so_far:.4f}"
-
-        # Status icons that work in most environments
         status_icon = {
             ProgressStatus.PENDING: "○",
-            ProgressStatus.RUNNING: "►",
-            ProgressStatus.COMPLETED: "✓",
+            ProgressStatus.RUNNING: "◐",
+            ProgressStatus.COMPLETED: "●",
             ProgressStatus.FAILED: "✗",
-            ProgressStatus.SKIPPED: "–",
-            ProgressStatus.FALLBACK: "↻",
+            ProgressStatus.SKIPPED: "◌",
+            ProgressStatus.FALLBACK: "↩",
             ProgressStatus.RETRYING: "↻",
         }.get(update.status, "?")
 
         # Get current tier from running stage
         tier_info = ""
-        model_info = ""
         if update.current_stage and update.stages:
             for stage in update.stages:
-                if stage.name == update.current_stage:
-                    if stage.status == ProgressStatus.RUNNING:
-                        tier_info = f" [{stage.tier.upper()}]"
-                        if stage.model:
-                            model_info = f" ({stage.model})"
-                    # Track stage duration
-                    if stage.duration_ms > 0:
-                        self._stage_times[stage.name] = stage.duration_ms
+                if stage.name == update.current_stage and stage.status == ProgressStatus.RUNNING:
+                    tier_info = f" [{stage.tier.upper()}]"
                     break
 
-        # Build output line
-        elapsed = ""
-        if self._start_time:
-            elapsed_sec = (datetime.now() - self._start_time).total_seconds()
-            if elapsed_sec >= 1:
-                elapsed = f" [{elapsed_sec:.1f}s]"
-
-        tokens_str = ""
-        if self.show_tokens and update.tokens_so_far > 0:
-            tokens_str = f" | {update.tokens_so_far:,} tokens"
-
-        # Format: [100%] ✓ Completed optimize [PREMIUM] ($0.0279) [12.3s]
-        output = f"[{percent}] {status_icon} {update.message}{tier_info} ({cost}{tokens_str}){elapsed}"
-        print(output)
-
-        # Verbose output
-        if self.verbose:
-            if update.fallback_info:
-                print(f"         ↳ Fallback: {update.fallback_info}")
-            if update.error:
-                print(f"         ↳ Error: {update.error}")
-
-        # Print summary only on final workflow completion (not stage completion)
-        if update.status == ProgressStatus.COMPLETED and "workflow" in update.message.lower():
-            self._print_summary(update)
-
-    def _print_summary(self, update: ProgressUpdate) -> None:
-        """Print workflow completion summary."""
-        if not self._stage_times:
-            return
-
-        print("")
-        print("─" * 50)
-        print("Stage Summary:")
-        for stage in update.stages:
-            if stage.status == ProgressStatus.COMPLETED:
-                duration_ms = stage.duration_ms or self._stage_times.get(stage.name, 0)
-                duration_str = f"{duration_ms}ms" if duration_ms < 1000 else f"{duration_ms/1000:.1f}s"
-                cost_str = f"${stage.cost:.4f}" if stage.cost > 0 else "—"
-                print(f"  {stage.name}: {duration_str} | {cost_str}")
-            elif stage.status == ProgressStatus.SKIPPED:
-                print(f"  {stage.name}: skipped")
-        print("─" * 50)
+        print(f"[{percent}] {status_icon} {update.message}{tier_info} ({cost})")
+
+        if self.verbose and update.fallback_info:
+            print(f"       Fallback: {update.fallback_info}")
+        if self.verbose and update.error:
+            print(f"       Error: {update.error}")
 
     async def report_async(self, update: ProgressUpdate) -> None:
         """Async version just calls sync."""
@@ -558,6 +463,8 @@ def create_progress_tracker(
         Configured ProgressTracker instance
 
     """
+    import uuid
+
     tracker = ProgressTracker(
         workflow_name=workflow_name,
         workflow_id=uuid.uuid4().hex[:12],
@@ -568,212 +475,3 @@ def create_progress_tracker(
         tracker.add_callback(reporter.report)
 
     return tracker
-
-
-class RichProgressReporter:
-    """Rich-based live progress display with spinner, progress bar, and metrics.
-
-    Provides real-time visual feedback during workflow execution:
-    - Progress bar showing stage completion (1/3, 2/3, etc.)
-    - Spinner during active LLM API calls
-    - Real-time cost and token display
-    - In-place updates (no terminal scrolling)
-
-    Requires Rich library. Falls back gracefully if unavailable.
-    """
-
-    def __init__(self, workflow_name: str, stage_names: list[str]) -> None:
-        """Initialize the Rich progress reporter.
-
-        Args:
-            workflow_name: Name of the workflow for display
-            stage_names: List of stage names for progress tracking
-        """
-        if not RICH_AVAILABLE:
-            raise RuntimeError("Rich library required for RichProgressReporter")
-
-        self.workflow_name = workflow_name
-        self.stage_names = stage_names
-        self.console = Console()
-        self._live: Live | None = None
-        self._progress: Progress | None = None
-        self._task_id: TaskID | None = None
-        self._current_stage = ""
-        self._cost = 0.0
-        self._tokens = 0
-        self._status = ProgressStatus.PENDING
-
-    def start(self) -> None:
-        """Start the live progress display."""
-        if not RICH_AVAILABLE or Progress is None or Live is None:
-            return
-
-        self._progress = Progress(
-            SpinnerColumn(),
-            TextColumn("[bold blue]{task.description}"),
-            BarColumn(bar_width=30),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            TextColumn("({task.completed}/{task.total})"),
-            console=self.console,
-            transient=False,
-        )
-
-        self._task_id = self._progress.add_task(
-            self.workflow_name,
-            total=len(self.stage_names),
-        )
-
-        self._live = Live(
-            self._create_display(),
-            console=self.console,
-            refresh_per_second=4,
-            transient=False,
-        )
-        self._live.start()
-
-    def stop(self) -> None:
-        """Stop the live progress display."""
-        if self._live:
-            self._live.stop()
-            self._live = None
-
-    def report(self, update: ProgressUpdate) -> None:
-        """Handle a progress update.
-
-        Args:
-            update: Progress update from the tracker
-        """
-        self._current_stage = update.current_stage
-        self._cost = update.cost_so_far
-        self._tokens = update.tokens_so_far
-        self._status = update.status
-
-        # Update progress bar
-        if self._progress is not None and self._task_id is not None:
-            completed = sum(
-                1 for s in update.stages if s.status == ProgressStatus.COMPLETED
-            )
-            self._progress.update(
-                self._task_id,
-                completed=completed,
-                description=f"{self.workflow_name}: {update.current_stage}",
-            )
-
-        # Refresh display
-        if self._live:
-            self._live.update(self._create_display())
-
-    async def report_async(self, update: ProgressUpdate) -> None:
-        """Async version of report."""
-        self.report(update)
-
-    def _create_display(self) -> Panel:
-        """Create the Rich display panel.
-
-        Returns:
-            Rich Panel containing progress information
-        """
-        if not RICH_AVAILABLE or Panel is None or Table is None:
-            raise RuntimeError("Rich not available")
-
-        # Build metrics table
-        metrics = Table(show_header=False, box=None, padding=(0, 2))
-        metrics.add_column("Label", style="dim")
-        metrics.add_column("Value", style="bold")
-
-        metrics.add_row("Cost:", f"${self._cost:.4f}")
-        metrics.add_row("Tokens:", f"{self._tokens:,}")
-        metrics.add_row("Stage:", self._current_stage or "Starting...")
-
-        # Status indicator
-        status_style = {
-            ProgressStatus.PENDING: "dim",
-            ProgressStatus.RUNNING: "blue",
-            ProgressStatus.COMPLETED: "green",
-            ProgressStatus.FAILED: "red",
-            ProgressStatus.FALLBACK: "yellow",
-            ProgressStatus.RETRYING: "yellow",
-        }.get(self._status, "white")
-
-        status_text = Text(self._status.value.upper(), style=status_style)
-
-        # Combine into panel
-        if self._progress is not None:
-            content = Group(self._progress, metrics)
-        else:
-            content = metrics
-
-        return Panel(
-            content,
-            title=f"[bold]{self.workflow_name}[/bold]",
-            subtitle=status_text,
-            border_style=status_style,
-        )
-
-    def __enter__(self) -> RichProgressReporter:
-        """Context manager entry."""
-        self.start()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Context manager exit."""
-        self.stop()
-
-
-@contextmanager
-def live_progress(
-    workflow_name: str,
-    stage_names: list[str],
-    console: Console | None = None,
-) -> Generator[tuple[ProgressTracker, RichProgressReporter | None], None, None]:
-    """Context manager for live progress display during workflow execution.
-
-    Provides a ProgressTracker with optional Rich-based live display.
-    Falls back gracefully when Rich is unavailable or output is not a TTY.
-
-    Args:
-        workflow_name: Name of the workflow
-        stage_names: List of stage names in order
-        console: Optional Rich Console (creates new one if not provided)
-
-    Yields:
-        Tuple of (ProgressTracker, RichProgressReporter or None)
-
-    Example:
-        with live_progress("Code Review", ["analyze", "review", "summarize"]) as (tracker, _):
-            tracker.start_workflow()
-            for stage in stages:
-                tracker.start_stage(stage)
-                # ... do work ...
-                tracker.complete_stage(stage, cost=0.01, tokens_in=100, tokens_out=50)
-            tracker.complete_workflow()
-    """
-    tracker = ProgressTracker(
-        workflow_name=workflow_name,
-        workflow_id=uuid.uuid4().hex[:12],
-        stage_names=stage_names,
-    )
-
-    reporter: RichProgressReporter | None = None
-
-    # Use Rich if available and output is a TTY
-    if RICH_AVAILABLE and sys.stdout.isatty():
-        try:
-            reporter = RichProgressReporter(workflow_name, stage_names)
-            tracker.add_callback(reporter.report)
-            reporter.start()
-        except Exception:  # noqa: BLE001
-            # INTENTIONAL: Rich display is optional - fall back to console output
-            reporter = None
-            simple_reporter = ConsoleProgressReporter(verbose=False)
-            tracker.add_callback(simple_reporter.report)
-    else:
-        # No Rich or not a TTY - use simple console reporter
-        simple_reporter = ConsoleProgressReporter(verbose=False)
-        tracker.add_callback(simple_reporter.report)
-
-    try:
-        yield tracker, reporter
-    finally:
-        if reporter:
-            reporter.stop()

empathy_os/workflows/routing.py

@@ -136,12 +136,7 @@ class BalancedRouting(TierRoutingStrategy):
 
         Args:
             total_budget: Total budget in USD for this workflow execution
-
-        Raises:
-            ValueError: If total_budget is not positive
         """
-        if total_budget <= 0:
-            raise ValueError("total_budget must be positive")
         self.total_budget = total_budget
 
     def route(self, context: RoutingContext) -> ModelTier: