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

empathy_llm_toolkit/state.py

@@ -1,246 +0,0 @@
-"""Collaboration State Management
-
-Tracks AI-human collaboration over time to enable Level 3+ empathy.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-
-class PatternType(Enum):
-    """Types of patterns that can be detected"""
-
-    SEQUENTIAL = "sequential"  # User always does X then Y
-    TEMPORAL = "temporal"  # User does X at specific time
-    CONDITIONAL = "conditional"  # When Z happens, user does X
-    PREFERENCE = "preference"  # User prefers format/style X
-
-
-@dataclass
-class UserPattern:
-    """A detected pattern in user behavior.
-
-    Enables Level 3 (Proactive) empathy.
-    """
-
-    pattern_type: PatternType
-    trigger: str  # What triggers this pattern
-    action: str  # What user typically does
-    confidence: float  # 0.0 to 1.0
-    occurrences: int  # How many times observed
-    last_seen: datetime
-    context: dict[str, Any] = field(default_factory=dict)
-
-    def should_act(self, trust_level: float) -> bool:
-        """Determine if we should act proactively on this pattern.
-
-        Requires both high confidence and sufficient trust.
-        """
-        return self.confidence > 0.7 and trust_level > 0.6
-
-
-@dataclass
-class Interaction:
-    """Single interaction in conversation history"""
-
-    timestamp: datetime
-    role: str  # "user" or "assistant"
-    content: str
-    empathy_level: int  # Which level was used
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class CollaborationState:
-    """Tracks AI-human collaboration state over time.
-
-    This is the foundation for Level 2+ empathy:
-    - Level 2: Uses conversation history for context
-    - Level 3: Detects patterns, builds trust
-    - Level 4: Analyzes trajectory
-    - Level 5: Contributes to shared pattern library
-    """
-
-    user_id: str
-    session_start: datetime = field(default_factory=datetime.now)
-
-    # Conversation tracking
-    interactions: list[Interaction] = field(default_factory=list)
-
-    # Pattern detection (Level 3)
-    detected_patterns: list[UserPattern] = field(default_factory=list)
-
-    # Trust building
-    trust_level: float = 0.5  # 0.0 to 1.0, starts neutral
-    successful_actions: int = 0
-    failed_actions: int = 0
-    trust_trajectory: list[float] = field(default_factory=list)
-
-    # Empathy level progression
-    current_level: int = 1  # Start at Level 1
-    level_history: list[int] = field(default_factory=list)
-
-    # User preferences learned over time
-    preferences: dict[str, Any] = field(default_factory=dict)
-
-    # Context that persists across interactions
-    shared_context: dict[str, Any] = field(default_factory=dict)
-
-    @property
-    def success_rate(self) -> float:
-        """Calculate success rate from successful and failed actions."""
-        total = self.successful_actions + self.failed_actions
-        if total == 0:
-            return 1.0  # Default to 100% if no actions yet
-        return self.successful_actions / total
-
-    def add_interaction(
-        self,
-        role: str,
-        content: str,
-        empathy_level: int,
-        metadata: dict | None = None,
-    ):
-        """Add interaction to history"""
-        self.interactions.append(
-            Interaction(
-                timestamp=datetime.now(),
-                role=role,
-                content=content,
-                empathy_level=empathy_level,
-                metadata=metadata or {},
-            ),
-        )
-
-        # Track level history
-        if role == "assistant":
-            self.level_history.append(empathy_level)
-
-    def update_trust(self, outcome: str, magnitude: float = 1.0):
-        """Update trust level based on action outcome.
-
-        Args:
-            outcome: "success" or "failure"
-            magnitude: How much to adjust (0.0 to 1.0)
-
-        """
-        if outcome == "success":
-            adjustment = 0.05 * magnitude
-            self.trust_level = min(1.0, self.trust_level + adjustment)
-            self.successful_actions += 1
-        elif outcome == "failure":
-            adjustment = 0.10 * magnitude  # Trust erodes faster
-            self.trust_level = max(0.0, self.trust_level - adjustment)
-            self.failed_actions += 1
-
-        # Track trajectory
-        self.trust_trajectory.append(self.trust_level)
-
-    def add_pattern(self, pattern: UserPattern):
-        """Add or update a detected pattern"""
-        # Check if pattern already exists
-        for existing in self.detected_patterns:
-            if (
-                existing.pattern_type == pattern.pattern_type
-                and existing.trigger == pattern.trigger
-            ):
-                # Update existing
-                existing.occurrences = pattern.occurrences
-                existing.confidence = pattern.confidence
-                existing.last_seen = pattern.last_seen
-                return
-
-        # Add new pattern
-        self.detected_patterns.append(pattern)
-
-    def find_matching_pattern(self, trigger_text: str) -> UserPattern | None:
-        """Find pattern that matches current input.
-
-        Returns pattern with highest confidence if found.
-        """
-        matches = [
-            p
-            for p in self.detected_patterns
-            if p.trigger.lower() in trigger_text.lower() and p.should_act(self.trust_level)
-        ]
-
-        if matches:
-            # Return highest confidence match
-            return max(matches, key=lambda p: p.confidence)
-
-        return None
-
-    def get_conversation_history(
-        self,
-        max_turns: int = 10,
-        include_metadata: bool = False,
-    ) -> list[dict[str, Any]]:
-        """Get recent conversation history in LLM format.
-
-        Args:
-            max_turns: Maximum number of turns to include
-            include_metadata: Whether to include interaction metadata
-
-        Returns:
-            List of {"role": "user/assistant", "content": "..."}
-
-        """
-        recent = self.interactions[-max_turns:] if max_turns else self.interactions
-
-        if include_metadata:
-            return [{"role": i.role, "content": i.content, "metadata": i.metadata} for i in recent]
-        return [{"role": i.role, "content": i.content} for i in recent]
-
-    def should_progress_to_level(self, level: int) -> bool:
-        """Determine if system should progress to higher empathy level.
-
-        Progression criteria:
-        - Level 2: Immediate (guided questions always helpful)
-        - Level 3: Trust > 0.6, patterns detected
-        - Level 4: Trust > 0.7, sufficient history
-        - Level 5: Trust > 0.8, cross-domain patterns available
-        """
-        if level <= 2:
-            return True  # Level 2 always appropriate
-
-        if level == 3:
-            return self.trust_level > 0.6 and len(self.detected_patterns) > 0
-
-        if level == 4:
-            return (
-                self.trust_level > 0.7
-                and len(self.interactions) > 10
-                and len(self.detected_patterns) > 2
-            )
-
-        if level == 5:
-            return self.trust_level > 0.8
-
-        return False
-
-    def get_statistics(self) -> dict[str, Any]:
-        """Get collaboration statistics"""
-        total_interactions = len(self.interactions)
-        success_rate = (
-            self.successful_actions / (self.successful_actions + self.failed_actions)
-            if (self.successful_actions + self.failed_actions) > 0
-            else 0.0
-        )
-
-        return {
-            "user_id": self.user_id,
-            "session_duration": (datetime.now() - self.session_start).total_seconds(),
-            "total_interactions": total_interactions,
-            "trust_level": self.trust_level,
-            "success_rate": success_rate,
-            "patterns_detected": len(self.detected_patterns),
-            "current_level": self.current_level,
-            "average_level": (
-                sum(self.level_history) / len(self.level_history) if self.level_history else 1
-            ),
-        }

empathy_llm_toolkit/utils/__init__.py

@@ -1,5 +0,0 @@
-"""Utility modules for empathy_llm_toolkit."""
-
-from .tokens import count_message_tokens, count_tokens, estimate_cost
-
-__all__ = ["count_tokens", "count_message_tokens", "estimate_cost"]

empathy_llm_toolkit/utils/tokens.py

@@ -1,349 +0,0 @@
-"""Token counting utilities using Anthropic's tokenizer.
-
-Provides accurate token counting for billing-accurate cost tracking.
-Replaces rough estimates (4 chars per token) with Anthropic's official counter.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import functools
-import logging
-import os
-from dataclasses import dataclass
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# Lazy import to avoid requiring dependencies if not used
-_client = None
-_tiktoken_encoding = None
-
-# Try to import tiktoken for fast local estimation
-try:
-    import tiktoken
-
-    TIKTOKEN_AVAILABLE = True
-except ImportError:
-    TIKTOKEN_AVAILABLE = False
-    logger.debug("tiktoken not available - will use API or heuristic fallback")
-
-
-@dataclass
-class TokenCount:
-    """Token count result with metadata."""
-
-    tokens: int
-    method: str  # "anthropic_api", "tiktoken", "heuristic"
-    model: str | None = None
-
-
-def _get_client():
-    """Get or create Anthropic client for token counting."""
-    global _client
-    if _client is None:
-        try:
-            from anthropic import Anthropic
-
-            api_key = os.getenv("ANTHROPIC_API_KEY")
-            if not api_key:
-                raise ValueError(
-                    "ANTHROPIC_API_KEY environment variable required for API token counting"
-                )
-            _client = Anthropic(api_key=api_key)
-        except ImportError as e:
-            raise ImportError(
-                "anthropic package required for token counting. Install with: pip install anthropic"
-            ) from e
-    return _client
-
-
-@functools.lru_cache(maxsize=4)
-def _get_tiktoken_encoding(model: str) -> Any:
-    """Get tiktoken encoding for Claude models (cached)."""
-    if not TIKTOKEN_AVAILABLE:
-        return None
-    try:
-        # Claude uses cl100k_base encoding (similar to GPT-4)
-        return tiktoken.get_encoding("cl100k_base")
-    except Exception as e:
-        logger.warning(f"Failed to get tiktoken encoding: {e}")
-        return None
-
-
-def _count_tokens_tiktoken(text: str, model: str) -> int:
-    """Count tokens using tiktoken (fast local estimation)."""
-    if not text:
-        return 0
-
-    encoding = _get_tiktoken_encoding(model)
-    if not encoding:
-        return 0
-
-    try:
-        return len(encoding.encode(text))
-    except Exception as e:
-        logger.warning(f"tiktoken encoding failed: {e}")
-        return 0
-
-
-def _count_tokens_heuristic(text: str) -> int:
-    """Fallback heuristic token counting (~4 chars per token)."""
-    if not text:
-        return 0
-    return max(1, len(text) // 4)
-
-
-def count_tokens(text: str, model: str = "claude-sonnet-4-5-20250929", use_api: bool = False) -> int:
-    """Count tokens using best available method.
-
-    By default, uses tiktoken for fast local estimation (~98% accurate).
-    Set use_api=True for exact count via Anthropic API (requires network call).
-
-    Args:
-        text: Text to tokenize
-        model: Model ID (different models may have different tokenizers)
-        use_api: Whether to use Anthropic API for exact count (slower, requires API key)
-
-    Returns:
-        Token count
-
-    Example:
-        >>> count_tokens("Hello, world!")
-        4
-        >>> count_tokens("def hello():\\n    print('hi')", use_api=True)
-        8
-
-    Raises:
-        ImportError: If anthropic package not installed (when use_api=True)
-        ValueError: If API key missing (when use_api=True)
-
-    """
-    if not text:
-        return 0
-
-    # Use API if explicitly requested
-    if use_api:
-        try:
-            client = _get_client()
-            # FIXED: Use correct API method - client.messages.count_tokens()
-            result = client.messages.count_tokens(
-                model=model,
-                messages=[{"role": "user", "content": text}],
-            )
-            return int(result.input_tokens)
-        except Exception as e:
-            logger.warning(f"API token counting failed, using fallback: {e}")
-            # Continue to fallback methods
-
-    # Try tiktoken first (fast and accurate)
-    if TIKTOKEN_AVAILABLE:
-        tokens = _count_tokens_tiktoken(text, model)
-        if tokens > 0:
-            return tokens
-
-    # Fallback to heuristic
-    return _count_tokens_heuristic(text)
-
-
-def count_message_tokens(
-    messages: list[dict[str, str]],
-    system_prompt: str | None = None,
-    model: str = "claude-sonnet-4-5-20250929",
-    use_api: bool = False,
-) -> dict[str, int]:
-    """Count tokens in a conversation.
-
-    By default uses tiktoken for fast estimation. Set use_api=True for exact count.
-
-    Args:
-        messages: List of message dicts with "role" and "content"
-        system_prompt: Optional system prompt
-        model: Model ID
-        use_api: Whether to use Anthropic API for exact count
-
-    Returns:
-        Dict with token counts by component:
-        - "system": System prompt tokens
-        - "messages": Message tokens
-        - "total": Sum of all tokens
-
-    Example:
-        >>> messages = [{"role": "user", "content": "Hello!"}]
-        >>> count_message_tokens(messages, system_prompt="You are helpful")
-        {"system": 4, "messages": 6, "total": 10}
-
-    """
-    if not messages:
-        if system_prompt:
-            tokens = count_tokens(system_prompt, model, use_api)
-            return {"system": tokens, "messages": 0, "total": tokens}
-        return {"system": 0, "messages": 0, "total": 0}
-
-    # Use Anthropic API for exact count if requested
-    if use_api:
-        try:
-            client = _get_client()
-            kwargs: dict[str, Any] = {"model": model, "messages": messages}
-            if system_prompt:
-                kwargs["system"] = system_prompt
-
-            result = client.messages.count_tokens(**kwargs)
-            # API returns total input tokens, estimate breakdown
-            total_tokens = result.input_tokens
-
-            # Estimate system vs message breakdown
-            if system_prompt:
-                system_tokens = count_tokens(system_prompt, model, use_api=False)
-                message_tokens = max(0, total_tokens - system_tokens)
-            else:
-                system_tokens = 0
-                message_tokens = total_tokens
-
-            return {
-                "system": system_tokens,
-                "messages": message_tokens,
-                "total": total_tokens,
-            }
-        except Exception as e:
-            logger.warning(f"API token counting failed, using fallback: {e}")
-            # Continue to fallback method
-
-    # Fallback: count each component separately
-    counts: dict[str, int] = {}
-
-    # Count system prompt
-    if system_prompt:
-        counts["system"] = count_tokens(system_prompt, model, use_api=False)
-    else:
-        counts["system"] = 0
-
-    # Count messages with overhead
-    message_tokens = 0
-    for message in messages:
-        content = message.get("content", "")
-        message_tokens += count_tokens(content, model, use_api=False)
-        message_tokens += 4  # Overhead for role markers
-
-    counts["messages"] = message_tokens
-    counts["total"] = counts["system"] + message_tokens
-
-    return counts
-
-
-def estimate_cost(input_tokens: int, output_tokens: int, model: str = "claude-sonnet-4-5") -> float:
-    """Estimate cost in USD based on token counts.
-
-    Args:
-        input_tokens: Input token count
-        output_tokens: Output token count
-        model: Model ID (used to look up pricing)
-
-    Returns:
-        Estimated cost in USD
-
-    Example:
-        >>> estimate_cost(1000, 500, "claude-sonnet-4-5")
-        0.0105  # $3/M input + $15/M output
-
-    Raises:
-        ValueError: If model is unknown
-
-    """
-    # Import here to avoid circular dependency
-    try:
-        from empathy_os.models.registry import get_pricing_for_model
-
-        pricing = get_pricing_for_model(model)
-        if not pricing:
-            raise ValueError(f"Unknown model: {model}")
-
-        input_cost = (input_tokens / 1_000_000) * pricing["input"]
-        output_cost = (output_tokens / 1_000_000) * pricing["output"]
-
-        return input_cost + output_cost
-    except ImportError:
-        # Fallback if registry not available
-        # Use default Sonnet 4.5 pricing
-        input_cost = (input_tokens / 1_000_000) * 3.00
-        output_cost = (output_tokens / 1_000_000) * 15.00
-        return input_cost + output_cost
-
-
-def calculate_cost_with_cache(
-    input_tokens: int,
-    output_tokens: int,
-    cache_creation_tokens: int,
-    cache_read_tokens: int,
-    model: str = "claude-sonnet-4-5",
-) -> dict[str, Any]:
-    """Calculate cost including Anthropic prompt caching.
-
-    Anthropic prompt caching pricing:
-    - Cache writes: 25% markup over standard input pricing
-    - Cache reads: 90% discount from standard input pricing
-
-    Args:
-        input_tokens: Regular input tokens (not cached)
-        output_tokens: Output tokens
-        cache_creation_tokens: Tokens written to cache
-        cache_read_tokens: Tokens read from cache
-        model: Model ID
-
-    Returns:
-        Dict with cost breakdown:
-        - "base_cost": Cost without cache
-        - "cache_write_cost": Cost for cache writes (25% markup)
-        - "cache_read_cost": Cost for cache reads (90% discount)
-        - "total_cost": Sum of all costs
-        - "savings": Amount saved by cache reads
-
-    Example:
-        >>> calculate_cost_with_cache(1000, 500, 5000, 10000, "claude-sonnet-4-5")
-        {
-            "base_cost": 0.0105,
-            "cache_write_cost": 0.01875,  # 5000 tokens * $3.75/M
-            "cache_read_cost": 0.003,     # 10000 tokens * $0.30/M
-            "total_cost": 0.03225,
-            "savings": 0.027,             # Saved vs. no cache
-        }
-
-    """
-    # Get pricing for model
-    try:
-        from empathy_os.models.registry import get_pricing_for_model
-
-        pricing = get_pricing_for_model(model)
-        if not pricing:
-            raise ValueError(f"Unknown model: {model}")
-
-        input_price_per_million = pricing["input"]
-        output_price_per_million = pricing["output"]
-    except (ImportError, ValueError):
-        # Fallback to default Sonnet 4.5 pricing
-        input_price_per_million = 3.00
-        output_price_per_million = 15.00
-
-    # Base cost (non-cached tokens)
-    base_cost = (input_tokens / 1_000_000) * input_price_per_million
-    base_cost += (output_tokens / 1_000_000) * output_price_per_million
-
-    # Cache write cost (25% markup)
-    cache_write_price = input_price_per_million * 1.25
-    cache_write_cost = (cache_creation_tokens / 1_000_000) * cache_write_price
-
-    # Cache read cost (90% discount = 10% of input price)
-    cache_read_price = input_price_per_million * 0.1
-    cache_read_cost = (cache_read_tokens / 1_000_000) * cache_read_price
-
-    # Calculate what we would have paid without cache
-    full_price_for_cached = (cache_read_tokens / 1_000_000) * input_price_per_million
-    savings = full_price_for_cached - cache_read_cost
-
-    return {
-        "base_cost": round(base_cost, 6),
-        "cache_write_cost": round(cache_write_cost, 6),
-        "cache_read_cost": round(cache_read_cost, 6),
-        "total_cost": round(base_cost + cache_write_cost + cache_read_cost, 6),
-        "savings": round(savings, 6),
-    }

empathy_os/adaptive/__init__.py

@@ -1,13 +0,0 @@
-"""Adaptive prompting system for dynamic model and compression selection.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from empathy_os.adaptive.task_complexity import (
-    ComplexityScore,
-    TaskComplexity,
-    TaskComplexityScorer,
-)
-
-__all__ = ["TaskComplexity", "ComplexityScore", "TaskComplexityScorer"]