empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/workflows/step_config.py

@@ -1,234 +0,0 @@
-"""Workflow Step Configuration for Multi-Model Pipelines
-
-Provides declarative step configuration that integrates with:
-- empathy_os.models.registry for model lookup
-- empathy_os.models.tasks for task-type routing
-- empathy_os.models.fallback for resilience policies
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from dataclasses import dataclass, field
-from typing import Any
-
-from empathy_os.models import (
-    FallbackPolicy,
-    ModelTier,
-    RetryPolicy,
-    get_tier_for_task,
-    normalize_task_type,
-)
-
-
-@dataclass
-class WorkflowStepConfig:
-    """Configuration for a single workflow step.
-
-    Combines declarative routing configuration with optional overrides
-    for provider, tier, and resilience policies.
-
-    Example:
-        >>> step = WorkflowStepConfig(
-        ...     name="triage",
-        ...     task_type="classify",
-        ...     tier_hint="cheap",
-        ...     timeout_seconds=30,
-        ... )
-        >>> step.effective_tier
-        'cheap'
-
-        >>> step2 = WorkflowStepConfig(
-        ...     name="analysis",
-        ...     task_type="fix_bug",
-        ...     # tier_hint not specified, uses task_type routing
-        ... )
-        >>> step2.effective_tier
-        'capable'
-
-    """
-
-    # Required fields
-    name: str
-    task_type: str  # Canonical task type (e.g., "summarize", "fix_bug", "coordinate")
-
-    # Optional routing hints (override task-based routing)
-    tier_hint: str | None = None  # "cheap" | "capable" | "premium"
-    provider_hint: str | None = None  # "anthropic" | "openai" | "ollama"
-
-    # Optional resilience configuration
-    fallback_policy: FallbackPolicy | None = None
-    retry_policy: RetryPolicy | None = None
-
-    # Optional execution constraints
-    timeout_seconds: int | None = None
-    max_tokens: int | None = None
-
-    # Optional metadata
-    description: str = ""
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        """Normalize task_type on creation."""
-        self.task_type = normalize_task_type(self.task_type)
-
-    @property
-    def effective_tier(self) -> str:
-        """Get the effective tier for this step.
-
-        Priority:
-        1. tier_hint if specified
-        2. Tier derived from task_type routing
-
-        Returns:
-            Tier name ("cheap", "capable", or "premium")
-
-        """
-        if self.tier_hint:
-            return self.tier_hint
-
-        tier = get_tier_for_task(self.task_type)
-        return tier.value
-
-    @property
-    def effective_tier_enum(self) -> ModelTier:
-        """Get effective tier as ModelTier enum."""
-        return ModelTier(self.effective_tier)
-
-    def with_overrides(
-        self,
-        tier_hint: str | None = None,
-        provider_hint: str | None = None,
-        fallback_policy: FallbackPolicy | None = None,
-        retry_policy: RetryPolicy | None = None,
-        timeout_seconds: int | None = None,
-    ) -> "WorkflowStepConfig":
-        """Create a new step config with overrides applied.
-
-        Useful for runtime customization without mutating the original.
-
-        Returns:
-            New WorkflowStepConfig with overrides applied
-
-        """
-        return WorkflowStepConfig(
-            name=self.name,
-            task_type=self.task_type,
-            tier_hint=tier_hint if tier_hint is not None else self.tier_hint,
-            provider_hint=provider_hint if provider_hint is not None else self.provider_hint,
-            fallback_policy=(
-                fallback_policy if fallback_policy is not None else self.fallback_policy
-            ),
-            retry_policy=retry_policy if retry_policy is not None else self.retry_policy,
-            timeout_seconds=(
-                timeout_seconds if timeout_seconds is not None else self.timeout_seconds
-            ),
-            max_tokens=self.max_tokens,
-            description=self.description,
-            metadata=self.metadata.copy(),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for serialization."""
-        return {
-            "name": self.name,
-            "task_type": self.task_type,
-            "tier_hint": self.tier_hint,
-            "provider_hint": self.provider_hint,
-            "effective_tier": self.effective_tier,
-            "timeout_seconds": self.timeout_seconds,
-            "max_tokens": self.max_tokens,
-            "description": self.description,
-            "metadata": self.metadata,
-            "has_fallback_policy": self.fallback_policy is not None,
-            "has_retry_policy": self.retry_policy is not None,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "WorkflowStepConfig":
-        """Create from dictionary.
-
-        Note: fallback_policy and retry_policy are not restored from dict
-        (they should be configured programmatically).
-        """
-        return cls(
-            name=data["name"],
-            task_type=data["task_type"],
-            tier_hint=data.get("tier_hint"),
-            provider_hint=data.get("provider_hint"),
-            timeout_seconds=data.get("timeout_seconds"),
-            max_tokens=data.get("max_tokens"),
-            description=data.get("description", ""),
-            metadata=data.get("metadata", {}),
-        )
-
-
-def validate_step_config(step: WorkflowStepConfig) -> list[str]:
-    """Validate a step configuration.
-
-    Returns:
-        List of validation error messages (empty if valid)
-
-    """
-    errors = []
-
-    if not step.name:
-        errors.append("Step name is required")
-
-    if not step.task_type:
-        errors.append("Step task_type is required")
-
-    if step.tier_hint and step.tier_hint not in ("cheap", "capable", "premium"):
-        errors.append(f"Invalid tier_hint: {step.tier_hint}")
-
-    if step.provider_hint and step.provider_hint not in (
-        "anthropic",
-        "openai",
-        "google",
-        "ollama",
-        "hybrid",
-    ):
-        errors.append(f"Invalid provider_hint: {step.provider_hint}")
-
-    if step.timeout_seconds is not None and step.timeout_seconds <= 0:
-        errors.append(f"timeout_seconds must be positive: {step.timeout_seconds}")
-
-    if step.max_tokens is not None and step.max_tokens <= 0:
-        errors.append(f"max_tokens must be positive: {step.max_tokens}")
-
-    return errors
-
-
-def steps_from_tier_map(
-    stages: list[str],
-    tier_map: dict[str, str],
-    task_type_default: str = "generate_code",
-) -> list[WorkflowStepConfig]:
-    """Convert legacy stages/tier_map to WorkflowStepConfig list.
-
-    Useful for migrating existing workflows.
-
-    Args:
-        stages: List of stage names
-        tier_map: Mapping of stage name to tier
-        task_type_default: Default task type if not inferrable
-
-    Returns:
-        List of WorkflowStepConfig
-
-    """
-    steps = []
-    for stage_name in stages:
-        tier = tier_map.get(stage_name, "capable")
-        # Handle both string and enum tier values
-        if hasattr(tier, "value"):
-            tier = tier.value
-
-        steps.append(
-            WorkflowStepConfig(
-                name=stage_name,
-                task_type=task_type_default,
-                tier_hint=tier,
-            ),
-        )
-    return steps

empathy_os/workflows/telemetry_mixin.py

@@ -1,269 +0,0 @@
-"""Telemetry Mixin for Workflow LLM Call Tracking
-
-Extracted from BaseWorkflow to improve maintainability and reusability.
-Provides telemetry tracking for LLM calls and workflow executions.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from __future__ import annotations
-
-import logging
-import uuid
-from datetime import datetime
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from empathy_os.models import (
-        TelemetryBackend,
-    )
-
-logger = logging.getLogger(__name__)
-
-# Try to import UsageTracker
-try:
-    from empathy_os.telemetry import UsageTracker
-
-    TELEMETRY_AVAILABLE = True
-except ImportError:
-    TELEMETRY_AVAILABLE = False
-    UsageTracker = None  # type: ignore
-
-
-class TelemetryMixin:
-    """Mixin that provides telemetry tracking for workflow LLM calls.
-
-    This mixin extracts telemetry logic from BaseWorkflow to improve
-    maintainability and enable reuse in other contexts.
-
-    Attributes:
-        _telemetry_backend: Backend for storing telemetry records
-        _telemetry_tracker: UsageTracker singleton for tracking
-        _enable_telemetry: Whether telemetry is enabled
-        _run_id: Current workflow run ID for correlation
-
-    Usage:
-        class MyWorkflow(TelemetryMixin, BaseWorkflow):
-            pass
-
-        # TelemetryMixin methods are now available
-        workflow._track_telemetry(...)
-        workflow._emit_call_telemetry(...)
-        workflow._emit_workflow_telemetry(...)
-    """
-
-    # Instance variables (set by __init__ or subclass)
-    _telemetry_backend: TelemetryBackend | None = None
-    _telemetry_tracker: UsageTracker | None = None
-    _enable_telemetry: bool = True
-    _run_id: str | None = None
-
-    # These must be provided by the class using this mixin
-    name: str = "unknown"
-    _provider_str: str = "unknown"
-
-    def _init_telemetry(self, telemetry_backend: TelemetryBackend | None = None) -> None:
-        """Initialize telemetry tracking.
-
-        Call this from __init__ to set up telemetry.
-
-        Args:
-            telemetry_backend: Optional backend for storing telemetry records.
-                             Defaults to TelemetryStore (JSONL file backend).
-        """
-        from empathy_os.models import get_telemetry_store
-
-        self._telemetry_backend = telemetry_backend or get_telemetry_store()
-        self._telemetry_tracker = None
-        self._enable_telemetry = True
-
-        if TELEMETRY_AVAILABLE and UsageTracker is not None:
-            try:
-                self._telemetry_tracker = UsageTracker.get_instance()
-            except (OSError, PermissionError) as e:
-                # File system errors - log but disable telemetry
-                logger.debug(f"Failed to initialize telemetry tracker (file system error): {e}")
-                self._enable_telemetry = False
-            except (AttributeError, TypeError, ValueError) as e:
-                # Configuration or initialization errors
-                logger.debug(f"Failed to initialize telemetry tracker (config error): {e}")
-                self._enable_telemetry = False
-
-    def _track_telemetry(
-        self,
-        stage: str,
-        tier: Any,  # ModelTier
-        model: str,
-        cost: float,
-        tokens: dict[str, int],
-        cache_hit: bool,
-        cache_type: str | None,
-        duration_ms: int,
-    ) -> None:
-        """Track telemetry for an LLM call.
-
-        Args:
-            stage: Stage name
-            tier: Model tier used (ModelTier enum)
-            model: Model ID used
-            cost: Cost in USD
-            tokens: Dictionary with "input" and "output" token counts
-            cache_hit: Whether this was a cache hit
-            cache_type: Cache type if cache hit
-            duration_ms: Duration in milliseconds
-        """
-        if not self._enable_telemetry or self._telemetry_tracker is None:
-            return
-
-        try:
-            provider_str = getattr(self, "_provider_str", "unknown")
-            self._telemetry_tracker.track_llm_call(
-                workflow=self.name,
-                stage=stage,
-                tier=tier.value.upper() if hasattr(tier, "value") else str(tier).upper(),
-                model=model,
-                provider=provider_str,
-                cost=cost,
-                tokens=tokens,
-                cache_hit=cache_hit,
-                cache_type=cache_type,
-                duration_ms=duration_ms,
-            )
-        except (AttributeError, TypeError, ValueError) as e:
-            # INTENTIONAL: Telemetry tracking failures should never crash workflows
-            logger.debug(f"Failed to track telemetry (config/data error): {e}")
-        except (OSError, PermissionError) as e:
-            # File system errors - log but never crash workflow
-            logger.debug(f"Failed to track telemetry (file system error): {e}")
-
-    def _emit_call_telemetry(
-        self,
-        step_name: str,
-        task_type: str,
-        tier: str,
-        model_id: str,
-        input_tokens: int,
-        output_tokens: int,
-        cost: float,
-        latency_ms: int,
-        success: bool = True,
-        error_message: str | None = None,
-        fallback_used: bool = False,
-    ) -> None:
-        """Emit an LLMCallRecord to the telemetry backend.
-
-        Args:
-            step_name: Name of the workflow step
-            task_type: Task type used for routing
-            tier: Model tier used
-            model_id: Model ID used
-            input_tokens: Input token count
-            output_tokens: Output token count
-            cost: Estimated cost
-            latency_ms: Latency in milliseconds
-            success: Whether the call succeeded
-            error_message: Error message if failed
-            fallback_used: Whether fallback was used
-        """
-        from empathy_os.models import LLMCallRecord
-
-        record = LLMCallRecord(
-            call_id=str(uuid.uuid4()),
-            timestamp=datetime.now().isoformat(),
-            workflow_name=self.name,
-            step_name=step_name,
-            task_type=task_type,
-            provider=getattr(self, "_provider_str", "unknown"),
-            tier=tier,
-            model_id=model_id,
-            input_tokens=input_tokens,
-            output_tokens=output_tokens,
-            estimated_cost=cost,
-            latency_ms=latency_ms,
-            success=success,
-            error_message=error_message,
-            fallback_used=fallback_used,
-            metadata={"run_id": self._run_id},
-        )
-        try:
-            if self._telemetry_backend is not None:
-                self._telemetry_backend.log_call(record)
-        except (AttributeError, ValueError, TypeError):
-            # Telemetry backend errors - log but don't crash workflow
-            logger.debug("Failed to log call telemetry (backend error)")
-        except OSError:
-            # File system errors - log but don't crash workflow
-            logger.debug("Failed to log call telemetry (file system error)")
-        except Exception:  # noqa: BLE001
-            # INTENTIONAL: Telemetry is optional diagnostics - never crash workflow
-            logger.debug("Unexpected error logging call telemetry")
-
-    def _emit_workflow_telemetry(self, result: Any) -> None:
-        """Emit a WorkflowRunRecord to the telemetry backend.
-
-        Args:
-            result: The WorkflowResult to record
-        """
-        from empathy_os.models import WorkflowRunRecord, WorkflowStageRecord
-
-        # Build stage records
-        stages = [
-            WorkflowStageRecord(
-                stage_name=s.name,
-                tier=s.tier.value if hasattr(s.tier, "value") else str(s.tier),
-                model_id=(
-                    self.get_model_for_tier(s.tier)
-                    if hasattr(self, "get_model_for_tier")
-                    else "unknown"
-                ),
-                input_tokens=s.input_tokens,
-                output_tokens=s.output_tokens,
-                cost=s.cost,
-                latency_ms=s.duration_ms,
-                success=not s.skipped and result.error is None,
-                skipped=s.skipped,
-                skip_reason=s.skip_reason,
-            )
-            for s in result.stages
-        ]
-
-        record = WorkflowRunRecord(
-            run_id=self._run_id or str(uuid.uuid4()),
-            workflow_name=self.name,
-            started_at=result.started_at.isoformat(),
-            completed_at=result.completed_at.isoformat(),
-            stages=stages,
-            total_input_tokens=sum(s.input_tokens for s in result.stages if not s.skipped),
-            total_output_tokens=sum(s.output_tokens for s in result.stages if not s.skipped),
-            total_cost=result.cost_report.total_cost,
-            baseline_cost=result.cost_report.baseline_cost,
-            savings=result.cost_report.savings,
-            savings_percent=result.cost_report.savings_percent,
-            total_duration_ms=result.total_duration_ms,
-            success=result.success,
-            error=result.error,
-            providers_used=[getattr(self, "_provider_str", "unknown")],
-            tiers_used=list(result.cost_report.by_tier.keys()),
-        )
-        try:
-            if self._telemetry_backend is not None:
-                self._telemetry_backend.log_workflow(record)
-        except (AttributeError, ValueError, TypeError):
-            # Telemetry backend errors - log but don't crash workflow
-            logger.debug("Failed to log workflow telemetry (backend error)")
-        except OSError:
-            # File system errors - log but don't crash workflow
-            logger.debug("Failed to log workflow telemetry (file system error)")
-        except Exception:  # noqa: BLE001
-            # INTENTIONAL: Telemetry is optional diagnostics - never crash workflow
-            logger.debug("Unexpected error logging workflow telemetry")
-
-    def _generate_run_id(self) -> str:
-        """Generate a new run ID for telemetry correlation.
-
-        Returns:
-            A new UUID string for the run
-        """
-        self._run_id = str(uuid.uuid4())
-        return self._run_id

empathy_os/workflows/test5.py

@@ -1,125 +0,0 @@
-"""scan code for bugs or opportunities to improve the code and generate a detailed report.
-
-Stages:
-1. analyze - Analyze
-2. process - Process
-3. test - Test
-4. report - Report
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import logging
-from typing import Any
-
-from empathy_os.workflows.base import BaseWorkflow, ModelTier
-
-logger = logging.getLogger(__name__)
-
-
-class Test5Workflow(BaseWorkflow):
-    """scan code for bugs or opportunities to improve the code and generate a detailed report.
-
-
-    Usage:
-        workflow = Test5Workflow()
-        result = await workflow.execute(
-            # Add parameters here
-        )
-    """
-
-    name = "test5"
-    description = (
-        "scan code for bugs or opportunities to improve the code and generate a detailed report."
-    )
-    stages = ["analyze", "fix"]
-    tier_map = {
-        "analyze": ModelTier.CAPABLE,
-        "fix": ModelTier.CAPABLE,
-    }
-
-    def __init__(
-        self,
-        **kwargs: Any,
-    ):
-        """Initialize test5 workflow.
-
-        Args:
-            **kwargs: Additional arguments passed to BaseWorkflow
-
-        """
-        super().__init__(**kwargs)
-        self._crew: Any = None
-        self._crew_available = False
-
-    async def _initialize_crew(self) -> None:
-        """Initialize the Refactoring Crew."""
-        if self._crew is not None:
-            return
-
-        try:
-            from empathy_llm_toolkit.agent_factory.crews.refactoring import RefactoringCrew
-
-            self._crew = RefactoringCrew()
-            self._crew_available = True
-            logger.info("RefactoringCrew initialized successfully")
-        except ImportError as e:
-            logger.warning(f"RefactoringCrew not available: {e}")
-            self._crew_available = False
-
-    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Execute RefactoringCrew for the given stage."""
-        await self._initialize_crew()
-
-        if not self._crew_available:
-            return {"error": "Crew not available"}, 0, 0
-
-        try:
-            if stage_name == "analyze":
-                # Use RefactoringCrew's analyze method
-                result = await self._crew.analyze(
-                    code=input_data.get("code", ""), file_path=input_data.get("path", ".")
-                )
-
-                return (
-                    {
-                        "findings": [
-                            {
-                                "title": f.title,
-                                "description": f.description,
-                                "category": f.category.value,
-                                "severity": f.severity.value,
-                                "file": f.file_path,
-                                "lines": f"{f.start_line}-{f.end_line}",
-                            }
-                            for f in result.findings
-                        ],
-                        "summary": f"Found {len(result.findings)} refactoring opportunities",
-                    },
-                    0,
-                    0,
-                )
-
-            elif stage_name == "fix":
-                # Apply refactorings (placeholder for now)
-                return (
-                    {
-                        "status": "Refactoring recommendations ready",
-                        "message": "Review findings from analyze stage to apply fixes",
-                    },
-                    0,
-                    0,
-                )
-
-            else:
-                return {"error": f"Unknown stage: {stage_name}"}, 0, 0
-
-        except Exception as e:
-            logger.error(f"Crew execution failed: {e}")
-            return {"error": str(e)}, 0, 0