Upload folder using huggingface_hub

ankigen_core/agents/__init__.py

@@ -16,15 +16,13 @@ from .judges import (
     JudgeCoordinator,
 )
 from .enhancers import RevisionAgent, EnhancementAgent
-from .feature_flags import AgentFeatureFlags
-from .metrics import AgentMetrics
 from .config import AgentConfigManager
 
 __all__ = [
     "BaseAgentWrapper",
     "AgentConfig",
     "SubjectExpertAgent",
-    "PedagogicalAgent", 
+    "PedagogicalAgent",
     "ContentStructuringAgent",
     "GenerationCoordinator",
     "ContentAccuracyJudge",
@@ -35,7 +33,5 @@ __all__ = [
     "JudgeCoordinator",
     "RevisionAgent",
     "EnhancementAgent",
-    "AgentFeatureFlags",
-    "AgentMetrics",
     "AgentConfigManager",
-]
+]

ankigen_core/agents/base.py

@@ -1,30 +1,50 @@
 # Base agent wrapper and configuration classes
 
-from typing import Dict, Any, Optional, List, Type
+from typing import Dict, Any, Optional, List
 from dataclasses import dataclass
 from pydantic import BaseModel
 import asyncio
-import time
+import json
 from openai import AsyncOpenAI
-from agents import Agent, Runner
+from agents import Agent, Runner, ModelSettings
 
 from ankigen_core.logging import logger
-from ankigen_core.models import Card
+from .token_tracker import track_usage_from_agents_sdk
+
+
+def parse_agent_json_response(response: Any) -> Dict[str, Any]:
+    """Parse agent response, handling markdown code blocks if present"""
+    if isinstance(response, str):
+        # Strip markdown code blocks
+        response = response.strip()
+        if response.startswith("```json"):
+            response = response[7:]  # Remove ```json
+        if response.startswith("```"):
+            response = response[3:]  # Remove ```
+        if response.endswith("```"):
+            response = response[:-3]  # Remove trailing ```
+        response = response.strip()
+
+        return json.loads(response)
+    else:
+        return response
 
 
 @dataclass
 class AgentConfig:
     """Configuration for individual agents"""
+
     name: str
     instructions: str
-    model: str = "gpt-4o"
+    model: str = "gpt-4.1"
     temperature: float = 0.7
     max_tokens: Optional[int] = None
     timeout: float = 30.0
     retry_attempts: int = 3
     enable_tracing: bool = True
     custom_prompts: Optional[Dict[str, str]] = None
-    
+    output_type: Optional[type] = None  # For structured outputs
+
     def __post_init__(self):
         if self.custom_prompts is None:
             self.custom_prompts = {}
@@ -32,162 +52,154 @@ class AgentConfig:
 
 class BaseAgentWrapper:
     """Base wrapper for OpenAI Agents SDK integration"""
-    
+
     def __init__(self, config: AgentConfig, openai_client: AsyncOpenAI):
         self.config = config
         self.openai_client = openai_client
         self.agent = None
         self.runner = None
-        self._performance_metrics = {
-            "total_calls": 0,
-            "successful_calls": 0,
-            "average_response_time": 0.0,
-            "error_count": 0,
-        }
-        
+
     async def initialize(self):
-        """Initialize the OpenAI agent"""
+        """Initialize the OpenAI agent with structured output support"""
         try:
-            self.agent = Agent(
-                name=self.config.name,
-                instructions=self.config.instructions,
-                model=self.config.model,
-                temperature=self.config.temperature,
-            )
-            
-            # Initialize runner with the OpenAI client
-            self.runner = Runner(
-                agent=self.agent,
-                client=self.openai_client,
-            )
-            
-            logger.info(f"Initialized agent: {self.config.name}")
-            
+            # Create model settings with temperature
+            model_settings = ModelSettings(temperature=self.config.temperature)
+
+            # Use clean instructions without JSON formatting hacks
+            clean_instructions = self.config.instructions
+
+            # Create agent with structured output if output_type is provided
+            if self.config.output_type:
+                self.agent = Agent(
+                    name=self.config.name,
+                    instructions=clean_instructions,
+                    model=self.config.model,
+                    model_settings=model_settings,
+                    output_type=self.config.output_type,
+                )
+                logger.info(
+                    f"Initialized agent with structured output: {self.config.name} -> {self.config.output_type}"
+                )
+            else:
+                self.agent = Agent(
+                    name=self.config.name,
+                    instructions=clean_instructions,
+                    model=self.config.model,
+                    model_settings=model_settings,
+                )
+                logger.info(
+                    f"Initialized agent (no structured output): {self.config.name}"
+                )
+
         except Exception as e:
             logger.error(f"Failed to initialize agent {self.config.name}: {e}")
             raise
-    
-    async def execute(self, user_input: str, context: Dict[str, Any] = None) -> Any:
+
+    async def execute(
+        self, user_input: str, context: Optional[Dict[str, Any]] = None
+    ) -> tuple[Any, Dict[str, Any]]:
         """Execute the agent with user input and optional context"""
-        if not self.runner:
+        if not self.agent:
             await self.initialize()
-        
-        start_time = time.time()
-        self._performance_metrics["total_calls"] += 1
-        
+
         try:
-                         # Add context to the user input if provided
+            # Add context to the user input if provided
             enhanced_input = user_input
             if context is not None:
                 context_str = "\n".join([f"{k}: {v}" for k, v in context.items()])
                 enhanced_input = f"{user_input}\n\nContext:\n{context_str}"
-            
-            # Execute the agent
+
+            # Execute the agent using Runner.run()
+            if self.agent is None:
+                raise ValueError("Agent not initialized")
+
+            logger.info(f"🤖 EXECUTING AGENT: {self.config.name}")
+            logger.info(f"📝 INPUT: {enhanced_input[:200]}...")
+
             result = await asyncio.wait_for(
-                self._run_agent(enhanced_input),
-                timeout=self.config.timeout
+                Runner.run(
+                    starting_agent=self.agent,
+                    input=enhanced_input,
+                ),
+                timeout=self.config.timeout,
             )
-            
-            # Update metrics
-            response_time = time.time() - start_time
-            self._update_performance_metrics(response_time, success=True)
-            
-            logger.debug(f"Agent {self.config.name} executed successfully in {response_time:.2f}s")
-            return result
-            
+
+            logger.info(f"Agent {self.config.name} executed successfully")
+
+            # Extract usage information from raw_responses
+            total_usage = {
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "total_tokens": 0,
+                "requests": 0,
+            }
+
+            if hasattr(result, "raw_responses") and result.raw_responses:
+                for response in result.raw_responses:
+                    if hasattr(response, "usage") and response.usage:
+                        total_usage["input_tokens"] += response.usage.input_tokens
+                        total_usage["output_tokens"] += response.usage.output_tokens
+                        total_usage["total_tokens"] += response.usage.total_tokens
+                        total_usage["requests"] += response.usage.requests
+
+                # Track usage with the token tracker
+                track_usage_from_agents_sdk(total_usage, self.config.model)
+                logger.info(f"💰 AGENT USAGE: {total_usage}")
+
+            # Extract the final output from the result
+            if hasattr(result, "new_items") and result.new_items:
+                # Get the last message content
+                from agents.items import ItemHelpers
+
+                text_output = ItemHelpers.text_message_outputs(result.new_items)
+
+                # If we have structured output, the response should already be parsed
+                if self.config.output_type and self.config.output_type is not str:
+                    logger.info(
+                        f"✅ STRUCTURED OUTPUT: {type(text_output)} -> {self.config.output_type}"
+                    )
+                    # The agents SDK should return the structured object directly
+                    return text_output, total_usage
+                else:
+                    return text_output, total_usage
+            else:
+                return str(result), total_usage
+
         except asyncio.TimeoutError:
-            self._performance_metrics["error_count"] += 1
-            logger.error(f"Agent {self.config.name} timed out after {self.config.timeout}s")
+            logger.error(
+                f"Agent {self.config.name} timed out after {self.config.timeout}s"
+            )
             raise
         except Exception as e:
-            self._performance_metrics["error_count"] += 1
             logger.error(f"Agent {self.config.name} execution failed: {e}")
             raise
-    
-    async def _run_agent(self, input_text: str) -> Any:
-        """Run the agent with retry logic"""
-        last_exception = None
-        
-        for attempt in range(self.config.retry_attempts):
-            try:
-                # Create a new run
-                run = await self.runner.create_run(messages=[
-                    {"role": "user", "content": input_text}
-                ])
-                
-                # Wait for completion
-                while run.status in ["queued", "in_progress"]:
-                    await asyncio.sleep(0.1)
-                    run = await self.runner.get_run(run.id)
-                
-                if run.status == "completed":
-                    # Get the final message
-                    messages = await self.runner.get_messages(run.thread_id)
-                    if messages and messages[-1].role == "assistant":
-                        return messages[-1].content
-                    else:
-                        raise ValueError("No assistant response found")
-                else:
-                    raise ValueError(f"Run failed with status: {run.status}")
-                    
-            except Exception as e:
-                last_exception = e
-                if attempt < self.config.retry_attempts - 1:
-                    wait_time = 2 ** attempt
-                    logger.warning(f"Agent {self.config.name} attempt {attempt + 1} failed, retrying in {wait_time}s: {e}")
-                    await asyncio.sleep(wait_time)
-                else:
-                    logger.error(f"Agent {self.config.name} failed after {self.config.retry_attempts} attempts")
-        
-        raise last_exception
-    
-    def _update_performance_metrics(self, response_time: float, success: bool):
-        """Update performance metrics"""
-        if success:
-            self._performance_metrics["successful_calls"] += 1
-        
-        # Update average response time
-        total_successful = self._performance_metrics["successful_calls"]
-        if total_successful > 0:
-            current_avg = self._performance_metrics["average_response_time"]
-            self._performance_metrics["average_response_time"] = (
-                (current_avg * (total_successful - 1) + response_time) / total_successful
-            )
-    
-    def get_performance_metrics(self) -> Dict[str, Any]:
-        """Get performance metrics for this agent"""
-        return {
-            **self._performance_metrics,
-            "success_rate": (
-                self._performance_metrics["successful_calls"] / 
-                max(1, self._performance_metrics["total_calls"])
-            ),
-            "agent_name": self.config.name,
-        }
-    
-    async def handoff_to(self, target_agent: "BaseAgentWrapper", context: Dict[str, Any]) -> Any:
+
+    async def handoff_to(
+        self, target_agent: "BaseAgentWrapper", context: Dict[str, Any]
+    ) -> Any:
         """Hand off execution to another agent with context"""
-        logger.info(f"Handing off from {self.config.name} to {target_agent.config.name}")
-        
+        logger.info(
+            f"Handing off from {self.config.name} to {target_agent.config.name}"
+        )
+
         # Prepare handoff context
         handoff_context = {
             "from_agent": self.config.name,
             "handoff_reason": context.get("reason", "Standard workflow handoff"),
-            **context
+            **context,
         }
-        
+
         # Execute the target agent
         return await target_agent.execute(
-            context.get("user_input", "Continue processing"),
-            handoff_context
+            context.get("user_input", "Continue processing"), handoff_context
         )
 
 
 class AgentResponse(BaseModel):
     """Standard response format for agents"""
+
     success: bool
     data: Any
     agent_name: str
-    execution_time: float
     metadata: Dict[str, Any] = {}
-    errors: List[str] = []
+    errors: List[str] = []

ankigen_core/agents/config.py

@@ -1,11 +1,10 @@
 # Agent configuration management system
 
 import json
-import yaml
-import os
 from typing import Dict, Any, Optional, List
 from pathlib import Path
 from dataclasses import dataclass, asdict
+from jinja2 import Environment, FileSystemLoader
 
 from ankigen_core.logging import logger
 from .base import AgentConfig
@@ -14,14 +13,15 @@ from .base import AgentConfig
 @dataclass
 class AgentPromptTemplate:
     """Template for agent prompts with variables"""
+
     system_prompt: str
     user_prompt_template: str
     variables: Optional[Dict[str, str]] = None
-    
+
     def __post_init__(self):
         if self.variables is None:
             self.variables = {}
-    
+
     def render_system_prompt(self, **kwargs) -> str:
         """Render system prompt with provided variables"""
         try:
@@ -30,7 +30,7 @@ class AgentPromptTemplate:
         except KeyError as e:
             logger.error(f"Missing variable in system prompt template: {e}")
             return self.system_prompt
-    
+
     def render_user_prompt(self, **kwargs) -> str:
         """Render user prompt template with provided variables"""
         try:
@@ -42,98 +42,139 @@ class AgentPromptTemplate:
 
 
 class AgentConfigManager:
-    """Manages agent configurations from files and runtime updates"""
-    
-    def __init__(self, config_dir: Optional[str] = None):
-        self.config_dir = Path(config_dir) if config_dir else Path("config/agents")
+    """Manages agent configurations using Jinja templates and runtime updates"""
+
+    def __init__(
+        self,
+        model_overrides: Optional[Dict[str, str]] = None,
+        template_vars: Optional[Dict[str, Any]] = None,
+    ):
+        self.model_overrides = model_overrides or {}
+        self.template_vars = template_vars or {}
         self.configs: Dict[str, AgentConfig] = {}
         self.prompt_templates: Dict[str, AgentPromptTemplate] = {}
-        self._ensure_config_dir()
+
+        # Set up Jinja2 environment with templates directory
+        template_dir = Path(__file__).parent / "templates"
+        self.jinja_env = Environment(loader=FileSystemLoader(template_dir))
+        self._load_default_configs()
+
+    def update_models(self, model_overrides: Dict[str, str]):
+        """Update model selections and regenerate configs"""
+        self.model_overrides = model_overrides
+        self._load_default_configs()
+        logger.info(f"Updated model overrides: {model_overrides}")
+
+    def update_template_vars(self, template_vars: Dict[str, Any]):
+        """Update template variables and regenerate configs"""
+        self.template_vars = template_vars
         self._load_default_configs()
-    
-    def _ensure_config_dir(self):
-        """Ensure config directory exists"""
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Create default config files if they don't exist
-        defaults_dir = self.config_dir / "defaults"
-        defaults_dir.mkdir(exist_ok=True)
-        
-        if not (defaults_dir / "generators.yaml").exists():
-            self._create_default_generator_configs()
-        
-        if not (defaults_dir / "judges.yaml").exists():
-            self._create_default_judge_configs()
-        
-        if not (defaults_dir / "enhancers.yaml").exists():
-            self._create_default_enhancer_configs()
-    
+        logger.info(f"Updated template variables: {template_vars}")
+
     def _load_default_configs(self):
-        """Load all default configurations"""
+        """Load all default configurations from Jinja templates"""
+        try:
+            self._load_configs_from_template("generators.j2")
+            self._load_configs_from_template("judges.j2")
+            self._load_configs_from_template("enhancers.j2")
+            self._load_prompt_templates_from_template("prompts.j2")
+            logger.info(
+                f"Loaded {len(self.configs)} agent configurations from Jinja templates"
+            )
+        except Exception as e:
+            logger.error(f"Failed to load agent configurations from templates: {e}")
+
+    def _get_model_for_agent(self, agent_name: str, default_model: str) -> str:
+        """Get model for agent, using override if available"""
+        return self.model_overrides.get(agent_name, default_model)
+
+    def _load_configs_from_template(self, template_name: str):
+        """Load agent configurations from a Jinja template"""
         try:
-            self._load_configs_from_file("defaults/generators.yaml")
-            self._load_configs_from_file("defaults/judges.yaml")
-            self._load_configs_from_file("defaults/enhancers.yaml")
-            logger.info(f"Loaded {len(self.configs)} agent configurations")
+            template = self.jinja_env.get_template(template_name)
+
+            # Default models for each agent type
+            default_models = {
+                "subject_expert_model": "gpt-4.1",
+                "pedagogical_agent_model": "gpt-4.1-nano",
+                "content_structuring_model": "gpt-4.1-nano",
+                "generation_coordinator_model": "gpt-4.1",
+                "content_accuracy_judge_model": "gpt-4.1-nano",
+                "pedagogical_judge_model": "gpt-4.1-nano",
+                "clarity_judge_model": "gpt-4.1-nano",
+                "technical_judge_model": "gpt-4.1-nano",
+                "completeness_judge_model": "gpt-4.1-nano",
+                "judge_coordinator_model": "gpt-4.1",
+                "revision_agent_model": "gpt-4.1",
+                "enhancement_agent_model": "gpt-4.1",
+            }
+
+            # Simple mapping: agent_name -> agent_name_model
+            model_vars = {}
+            for agent_name, model in self.model_overrides.items():
+                model_vars[f"{agent_name}_model"] = model
+
+            # Merge all template variables with defaults
+            render_vars = {**default_models, **self.template_vars, **model_vars}
+
+            logger.info(f"Rendering template {template_name} with vars: {render_vars}")
+            rendered_json = template.render(**render_vars)
+            config_data = json.loads(rendered_json)
+
+            # Create AgentConfig objects from the rendered data
+            for agent_name, agent_data in config_data.items():
+                config = AgentConfig(
+                    name=agent_data.get("name", agent_name),
+                    instructions=agent_data.get("instructions", ""),
+                    model=agent_data.get("model", "gpt-4"),
+                    temperature=agent_data.get("temperature", 0.7),
+                    max_tokens=agent_data.get("max_tokens"),
+                    timeout=agent_data.get("timeout", 30.0),
+                    retry_attempts=agent_data.get("retry_attempts", 3),
+                    enable_tracing=agent_data.get("enable_tracing", True),
+                    custom_prompts=agent_data.get("custom_prompts", {}),
+                )
+                self.configs[agent_name] = config
+                logger.info(f"Loaded config for {agent_name}: model={config.model}")
+
         except Exception as e:
-            logger.error(f"Failed to load default agent configurations: {e}")
-    
-    def _load_configs_from_file(self, filename: str):
-        """Load configurations from a YAML/JSON file"""
-        file_path = self.config_dir / filename
-        
-        if not file_path.exists():
-            logger.warning(f"Agent config file not found: {file_path}")
-            return
-        
+            logger.error(f"Failed to load configs from template {template_name}: {e}")
+
+    def _load_prompt_templates_from_template(self, template_name: str):
+        """Load prompt templates from a Jinja template"""
         try:
-            with open(file_path, 'r') as f:
-                if filename.endswith('.yaml') or filename.endswith('.yml'):
-                    data = yaml.safe_load(f)
-                else:
-                    data = json.load(f)
-            
-            # Load agent configs
-            if 'agents' in data:
-                for agent_name, agent_data in data['agents'].items():
-                    config = AgentConfig(
-                        name=agent_name,
-                        instructions=agent_data.get('instructions', ''),
-                        model=agent_data.get('model', 'gpt-4o'),
-                        temperature=agent_data.get('temperature', 0.7),
-                        max_tokens=agent_data.get('max_tokens'),
-                        timeout=agent_data.get('timeout', 30.0),
-                        retry_attempts=agent_data.get('retry_attempts', 3),
-                        enable_tracing=agent_data.get('enable_tracing', True),
-                        custom_prompts=agent_data.get('custom_prompts', {})
-                    )
-                    self.configs[agent_name] = config
-            
-            # Load prompt templates
-            if 'prompt_templates' in data:
-                for template_name, template_data in data['prompt_templates'].items():
-                    template = AgentPromptTemplate(
-                        system_prompt=template_data.get('system_prompt', ''),
-                        user_prompt_template=template_data.get('user_prompt_template', ''),
-                        variables=template_data.get('variables', {})
-                    )
-                    self.prompt_templates[template_name] = template
-                    
+            template = self.jinja_env.get_template(template_name)
+
+            # Render with current template variables
+            rendered_json = template.render(**self.template_vars)
+            template_data = json.loads(rendered_json)
+
+            # Create AgentPromptTemplate objects
+            for template_name, template_info in template_data.items():
+                prompt_template = AgentPromptTemplate(
+                    system_prompt=template_info.get("system_prompt", ""),
+                    user_prompt_template=template_info.get("user_prompt_template", ""),
+                    variables=template_info.get("variables", {}),
+                )
+                self.prompt_templates[template_name] = prompt_template
+
         except Exception as e:
-            logger.error(f"Failed to load agent config from {file_path}: {e}")
-    
+            logger.error(
+                f"Failed to load prompt templates from template {template_name}: {e}"
+            )
+
     def get_agent_config(self, agent_name: str) -> Optional[AgentConfig]:
         """Get configuration for a specific agent"""
         return self.configs.get(agent_name)
-    
+
     def get_config(self, agent_name: str) -> Optional[AgentConfig]:
         """Alias for get_agent_config for compatibility"""
         return self.get_agent_config(agent_name)
-    
+
     def get_prompt_template(self, template_name: str) -> Optional[AgentPromptTemplate]:
         """Get a prompt template by name"""
         return self.prompt_templates.get(template_name)
-    
+
     def update_agent_config(self, agent_name: str, **kwargs):
         """Update an agent's configuration at runtime"""
         if agent_name in self.configs:
@@ -142,356 +183,114 @@ class AgentConfigManager:
                 if hasattr(config, key):
                     setattr(config, key, value)
                     logger.info(f"Updated {agent_name} config: {key} = {value}")
-    
-    def update_config(self, agent_name: str, updates: Dict[str, Any]) -> Optional[AgentConfig]:
+
+    def update_config(
+        self, agent_name: str, updates: Dict[str, Any]
+    ) -> Optional[AgentConfig]:
         """Update agent configuration with a dictionary of updates"""
         if agent_name not in self.configs:
             return None
-        
+
         config = self.configs[agent_name]
         for key, value in updates.items():
             if hasattr(config, key):
                 setattr(config, key, value)
-        
+
         return config
-    
+
     def list_configs(self) -> List[str]:
         """List all agent configuration names"""
         return list(self.configs.keys())
-    
+
     def list_prompt_templates(self) -> List[str]:
         """List all prompt template names"""
         return list(self.prompt_templates.keys())
-    
+
     def load_config_from_dict(self, config_dict: Dict[str, Any]):
         """Load configuration from a dictionary"""
         # Load agent configs
-        if 'agents' in config_dict:
-            for agent_name, agent_data in config_dict['agents'].items():
+        if "agents" in config_dict:
+            for agent_name, agent_data in config_dict["agents"].items():
                 config = AgentConfig(
                     name=agent_name,
-                    instructions=agent_data.get('instructions', ''),
-                    model=agent_data.get('model', 'gpt-4o'),
-                    temperature=agent_data.get('temperature', 0.7),
-                    max_tokens=agent_data.get('max_tokens'),
-                    timeout=agent_data.get('timeout', 30.0),
-                    retry_attempts=agent_data.get('retry_attempts', 3),
-                    enable_tracing=agent_data.get('enable_tracing', True),
-                    custom_prompts=agent_data.get('custom_prompts', {})
+                    instructions=agent_data.get("instructions", ""),
+                    model=agent_data.get("model", "gpt-4.1"),
+                    temperature=agent_data.get("temperature", 0.7),
+                    max_tokens=agent_data.get("max_tokens"),
+                    timeout=agent_data.get("timeout", 30.0),
+                    retry_attempts=agent_data.get("retry_attempts", 3),
+                    enable_tracing=agent_data.get("enable_tracing", True),
+                    custom_prompts=agent_data.get("custom_prompts", {}),
                 )
                 self.configs[agent_name] = config
-        
+
         # Load prompt templates
-        if 'prompt_templates' in config_dict:
-            for template_name, template_data in config_dict['prompt_templates'].items():
+        if "prompt_templates" in config_dict:
+            for template_name, template_data in config_dict["prompt_templates"].items():
                 template = AgentPromptTemplate(
-                    system_prompt=template_data.get('system_prompt', ''),
-                    user_prompt_template=template_data.get('user_prompt_template', ''),
-                    variables=template_data.get('variables', {})
+                    system_prompt=template_data.get("system_prompt", ""),
+                    user_prompt_template=template_data.get("user_prompt_template", ""),
+                    variables=template_data.get("variables", {}),
                 )
                 self.prompt_templates[template_name] = template
-    
+
     def _validate_config(self, config_data: Dict[str, Any]) -> bool:
         """Validate agent configuration data"""
         # Check required fields
-        if 'name' not in config_data or 'instructions' not in config_data:
+        if "name" not in config_data or "instructions" not in config_data:
             return False
-        
+
         # Check temperature range
-        temperature = config_data.get('temperature', 0.7)
+        temperature = config_data.get("temperature", 0.7)
         if not 0.0 <= temperature <= 2.0:
             return False
-        
+
         # Check timeout is positive
-        timeout = config_data.get('timeout', 30.0)
+        timeout = config_data.get("timeout", 30.0)
         if timeout <= 0:
             return False
-        
+
         return True
-    
+
     def save_config_to_file(self, filename: str, agents: List[str] = None):
         """Save current configurations to a file"""
-        file_path = self.config_dir / filename
-        
         # Prepare data structure
-        data = {
-            "agents": {},
-            "prompt_templates": {}
-        }
-        
+        data = {"agents": {}, "prompt_templates": {}}
+
         # Add agent configs
         agents_to_save = agents if agents else list(self.configs.keys())
         for agent_name in agents_to_save:
             if agent_name in self.configs:
                 config = self.configs[agent_name]
                 data["agents"][agent_name] = asdict(config)
-        
+
         # Add prompt templates
         for template_name, template in self.prompt_templates.items():
             data["prompt_templates"][template_name] = asdict(template)
-        
+
         try:
-            with open(file_path, 'w') as f:
-                if filename.endswith('.yaml') or filename.endswith('.yml'):
-                    yaml.dump(data, f, default_flow_style=False, indent=2)
-                else:
-                    json.dump(data, f, indent=2)
-            logger.info(f"Saved agent configurations to {file_path}")
+            with open(filename, "w") as f:
+                json.dump(data, f, indent=2)
+            logger.info(f"Saved agent configurations to {filename}")
         except Exception as e:
-            logger.error(f"Failed to save agent config to {file_path}: {e}")
-    
-    def _create_default_generator_configs(self):
-        """Create default configuration for generator agents"""
-        config = {
-            "agents": {
-                "subject_expert": {
-                    "instructions": """You are a world-class expert in {subject} with deep pedagogical knowledge. 
-Your role is to generate high-quality flashcards that demonstrate mastery of {subject} concepts.
-
-Key responsibilities:
-- Ensure technical accuracy and depth appropriate for the target level
-- Use domain-specific terminology correctly
-- Include practical applications and real-world examples
-- Connect concepts to prerequisite knowledge
-- Avoid oversimplification while maintaining clarity
-
-Generate cards that test understanding, not just memorization.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.7,
-                    "timeout": 45.0,
-                    "custom_prompts": {
-                        "math": "Focus on problem-solving strategies and mathematical reasoning",
-                        "science": "Emphasize experimental design and scientific method",
-                        "history": "Connect events to broader historical patterns and causation",
-                        "programming": "Include executable examples and best practices"
-                    }
-                },
-                "pedagogical": {
-                    "instructions": """You are an educational specialist focused on learning theory and instructional design.
-Your role is to ensure all flashcards follow educational best practices.
-
-Apply these frameworks:
-- Bloom's Taxonomy: Ensure questions target appropriate cognitive levels
-- Spaced Repetition: Design cards for optimal retention
-- Cognitive Load Theory: Avoid overwhelming learners
-- Active Learning: Encourage engagement and application
-
-Review cards for:
-- Clear learning objectives
-- Appropriate difficulty progression
-- Effective use of examples and analogies
-- Prerequisite knowledge alignment""",
-                    "model": "gpt-4o",
-                    "temperature": 0.6,
-                    "timeout": 30.0
-                },
-                "content_structuring": {
-                    "instructions": """You are a content organization specialist focused on consistency and structure.
-Your role is to format and organize flashcard content for optimal learning.
-
-Ensure all cards have:
-- Consistent formatting and style
-- Proper metadata and tagging
-- Clear, unambiguous questions
-- Complete, well-structured answers
-- Appropriate examples and explanations
-- Relevant categorization and difficulty levels
-
-Maintain high standards for readability and accessibility.""",
-                    "model": "gpt-4o-mini",
-                    "temperature": 0.5,
-                    "timeout": 25.0
-                },
-                "generation_coordinator": {
-                    "instructions": """You are the generation workflow coordinator. 
-Your role is to orchestrate the card generation process and manage handoffs between specialized agents.
-
-Responsibilities:
-- Route requests to appropriate specialist agents
-- Coordinate parallel generation tasks
-- Manage workflow state and progress
-- Handle errors and fallback strategies
-- Optimize generation pipelines
-
-Make decisions based on content type, user preferences, and system load.""",
-                    "model": "gpt-4o-mini",
-                    "temperature": 0.3,
-                    "timeout": 20.0
-                }
-            },
-            "prompt_templates": {
-                "subject_generation": {
-                    "system_prompt": "You are an expert in {subject}. Generate {num_cards} flashcards covering key concepts.",
-                    "user_prompt_template": "Topic: {topic}\nDifficulty: {difficulty}\nPrerequisites: {prerequisites}\n\nGenerate cards that help learners master this topic.",
-                    "variables": {
-                        "subject": "general",
-                        "num_cards": "5",
-                        "difficulty": "intermediate",
-                        "prerequisites": "none"
-                    }
-                }
-            }
-        }
-        
-        with open(self.config_dir / "defaults" / "generators.yaml", 'w') as f:
-            yaml.dump(config, f, default_flow_style=False, indent=2)
-    
-    def _create_default_judge_configs(self):
-        """Create default configuration for judge agents"""
-        config = {
-            "agents": {
-                "content_accuracy_judge": {
-                    "instructions": """You are a fact-checking and accuracy specialist.
-Your role is to verify the correctness and accuracy of flashcard content.
-
-Evaluate cards for:
-- Factual accuracy and up-to-date information
-- Proper use of terminology and definitions
-- Absence of misconceptions or errors
-- Appropriate level of detail for the target audience
-- Consistency with authoritative sources
-
-Rate each card's accuracy and provide specific feedback on any issues found.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.3,
-                    "timeout": 25.0
-                },
-                "pedagogical_judge": {
-                    "instructions": """You are an educational assessment specialist.
-Your role is to evaluate flashcards for pedagogical effectiveness.
-
-Assess cards for:
-- Alignment with learning objectives
-- Appropriate difficulty level and cognitive load
-- Effective use of educational principles
-- Clear prerequisite knowledge requirements
-- Potential for promoting deep learning
-
-Provide detailed feedback on educational effectiveness and improvement suggestions.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.4,
-                    "timeout": 30.0
-                },
-                "clarity_judge": {
-                    "instructions": """You are a communication and clarity specialist.
-Your role is to ensure flashcards are clear, unambiguous, and well-written.
-
-Evaluate cards for:
-- Question clarity and specificity
-- Answer completeness and coherence
-- Absence of ambiguity or confusion
-- Appropriate language level for target audience
-- Effective use of examples and explanations
-
-Rate clarity and provide specific suggestions for improvement.""",
-                    "model": "gpt-4o-mini",
-                    "temperature": 0.3,
-                    "timeout": 20.0
-                },
-                "technical_judge": {
-                    "instructions": """You are a technical accuracy specialist for programming and technical content.
-Your role is to verify technical correctness and best practices.
-
-For technical cards, check:
-- Code syntax and functionality
-- Best practices and conventions
-- Security considerations
-- Performance implications
-- Tool and framework accuracy
-
-Provide detailed technical feedback and corrections.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.2,
-                    "timeout": 35.0
-                },
-                "completeness_judge": {
-                    "instructions": """You are a completeness and quality assurance specialist.
-Your role is to ensure flashcards meet all requirements and quality standards.
-
-Verify cards have:
-- All required fields and metadata
-- Proper formatting and structure
-- Appropriate tags and categorization
-- Complete explanations and examples
-- Consistent quality across the set
-
-Rate completeness and identify missing elements.""",
-                    "model": "gpt-4o-mini",
-                    "temperature": 0.3,
-                    "timeout": 20.0
-                },
-                "judge_coordinator": {
-                    "instructions": """You are the quality assurance coordinator.
-Your role is to orchestrate the judging process and synthesize feedback from specialist judges.
-
-Responsibilities:
-- Route cards to appropriate specialist judges
-- Coordinate parallel judging tasks
-- Synthesize feedback from multiple judges
-- Make final accept/reject/revise decisions
-- Manage judge workload and performance
-
-Balance speed with thoroughness in quality assessment.""",
-                    "model": "gpt-4o-mini",
-                    "temperature": 0.3,
-                    "timeout": 15.0
-                }
-            }
-        }
-        
-        with open(self.config_dir / "defaults" / "judges.yaml", 'w') as f:
-            yaml.dump(config, f, default_flow_style=False, indent=2)
-    
-    def _create_default_enhancer_configs(self):
-        """Create default configuration for enhancement agents"""
-        config = {
-            "agents": {
-                "revision_agent": {
-                    "instructions": """You are a content revision specialist.
-Your role is to improve flashcards based on feedback from quality judges.
-
-For each revision request:
-- Analyze specific feedback provided
-- Make targeted improvements to address issues
-- Maintain the card's educational intent
-- Preserve correct information while fixing problems
-- Improve clarity, accuracy, and pedagogical value
-
-Focus on iterative improvement rather than complete rewrites.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.6,
-                    "timeout": 40.0
-                },
-                "enhancement_agent": {
-                    "instructions": """You are a content enhancement specialist.
-Your role is to add missing elements and enrich flashcard content.
-
-Enhancement tasks:
-- Add missing explanations or examples
-- Improve metadata and tagging
-- Generate additional context or background
-- Create connections to related concepts
-- Enhance visual or structural elements
-
-Ensure enhancements add value without overwhelming the learner.""",
-                    "model": "gpt-4o",
-                    "temperature": 0.7,
-                    "timeout": 35.0
-                }
-            }
-        }
-        
-        with open(self.config_dir / "defaults" / "enhancers.yaml", 'w') as f:
-            yaml.dump(config, f, default_flow_style=False, indent=2)
+            logger.error(f"Failed to save agent config to {filename}: {e}")
 
 
 # Global config manager instance
 _global_config_manager: Optional[AgentConfigManager] = None
 
 
-def get_config_manager() -> AgentConfigManager:
+def get_config_manager(
+    model_overrides: Optional[Dict[str, str]] = None,
+    template_vars: Optional[Dict[str, Any]] = None,
+) -> AgentConfigManager:
     """Get the global agent configuration manager"""
     global _global_config_manager
     if _global_config_manager is None:
-        _global_config_manager = AgentConfigManager()
-    return _global_config_manager
+        _global_config_manager = AgentConfigManager(model_overrides, template_vars)
+    else:
+        if model_overrides:
+            _global_config_manager.update_models(model_overrides)
+        if template_vars:
+            _global_config_manager.update_template_vars(template_vars)
+    return _global_config_manager

ankigen_core/agents/enhancers.py

@@ -2,108 +2,81 @@
 
 import json
 import asyncio
-from typing import List, Dict, Any, Optional
+from typing import List
 from datetime import datetime
 
 from openai import AsyncOpenAI
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card, CardFront, CardBack
-from .base import BaseAgentWrapper, AgentConfig
+from .base import BaseAgentWrapper
 from .config import get_config_manager
-from .metrics import record_agent_execution
 from .judges import JudgeDecision
 
 
 class RevisionAgent(BaseAgentWrapper):
     """Agent for revising cards based on judge feedback"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("revision_agent")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="revision_agent",
-                instructions="""You are a content revision specialist.
-Improve flashcards based on specific feedback from quality judges.
-Make targeted improvements while maintaining educational intent.""",
-                model="gpt-4o",
-                temperature=0.6
+            raise ValueError(
+                "revision_agent configuration not found - agent system not properly initialized"
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def revise_card(
-        self,
-        card: Card,
-        judge_decisions: List[JudgeDecision],
-        max_iterations: int = 3
+        self, card: Card, judge_decisions: List[JudgeDecision], max_iterations: int = 3
     ) -> Card:
         """Revise a card based on judge feedback"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             # Collect all feedback and improvements
             all_feedback = []
             all_improvements = []
-            
+
             for decision in judge_decisions:
                 if not decision.approved:
                     all_feedback.append(f"{decision.judge_name}: {decision.feedback}")
                     all_improvements.extend(decision.improvements)
-            
+
             if not all_feedback:
                 # No revisions needed
                 return card
-            
+
             # Build revision prompt
-            user_input = self._build_revision_prompt(card, all_feedback, all_improvements)
-            
+            user_input = self._build_revision_prompt(
+                card, all_feedback, all_improvements
+            )
+
             # Execute revision
             response = await self.execute(user_input)
-            
+
             # Parse revised card
             revised_card = self._parse_revised_card(response, card)
-            
+
             # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_revised": 1,
-                    "feedback_sources": len(judge_decisions),
-                    "improvements_applied": len(all_improvements)
-                }
+
+            logger.info(
+                f"RevisionAgent successfully revised card: {card.front.question[:50]}..."
             )
-            
-            logger.info(f"RevisionAgent successfully revised card: {card.front.question[:50]}...")
             return revised_card
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"RevisionAgent failed to revise card: {e}")
             return card  # Return original card on failure
-    
+
     def _build_revision_prompt(
-        self,
-        card: Card,
-        feedback: List[str],
-        improvements: List[str]
+        self, card: Card, feedback: List[str], improvements: List[str]
     ) -> str:
         """Build the revision prompt"""
         feedback_str = "\n".join([f"- {fb}" for fb in feedback])
         improvements_str = "\n".join([f"- {imp}" for imp in improvements])
-        
+
         return f"""Revise this flashcard based on the provided feedback and improvement suggestions:
 
 Original Card:
@@ -143,7 +116,7 @@ Return the revised card as JSON:
     }},
     "revision_notes": "Summary of changes made based on feedback"
 }}"""
-    
+
     def _parse_revised_card(self, response: str, original_card: Card) -> Card:
         """Parse the revised card response"""
         try:
@@ -151,30 +124,30 @@ Return the revised card as JSON:
                 data = json.loads(response)
             else:
                 data = response
-            
+
             # Create revised card
             revised_card = Card(
                 card_type=data.get("card_type", original_card.card_type),
-                front=CardFront(
-                    question=data["front"]["question"]
-                ),
+                front=CardFront(question=data["front"]["question"]),
                 back=CardBack(
                     answer=data["back"]["answer"],
                     explanation=data["back"].get("explanation", ""),
-                    example=data["back"].get("example", "")
+                    example=data["back"].get("example", ""),
                 ),
-                metadata=data.get("metadata", original_card.metadata)
+                metadata=data.get("metadata", original_card.metadata),
             )
-            
+
             # Add revision tracking to metadata
             if revised_card.metadata is None:
                 revised_card.metadata = {}
-            
-            revised_card.metadata["revision_notes"] = data.get("revision_notes", "Revised based on judge feedback")
+
+            revised_card.metadata["revision_notes"] = data.get(
+                "revision_notes", "Revised based on judge feedback"
+            )
             revised_card.metadata["last_revised"] = datetime.now().isoformat()
-            
+
             return revised_card
-            
+
         except Exception as e:
             logger.error(f"Failed to parse revised card: {e}")
             return original_card
@@ -182,31 +155,24 @@ Return the revised card as JSON:
 
 class EnhancementAgent(BaseAgentWrapper):
     """Agent for enhancing cards with additional content and metadata"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("enhancement_agent")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="enhancement_agent",
-                instructions="""You are a content enhancement specialist.
-Add missing elements and enrich flashcard content without overwhelming learners.
-Enhance metadata, examples, and educational value.""",
-                model="gpt-4o",
-                temperature=0.7
+            raise ValueError(
+                "enhancement_agent configuration not found - agent system not properly initialized"
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def enhance_card(
-        self,
-        card: Card,
-        enhancement_targets: List[str] = None
+        self, card: Card, enhancement_targets: List[str] = None
     ) -> Card:
         """Enhance a card with additional content and metadata"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             # Default enhancement targets if none specified
             if not enhancement_targets:
@@ -216,53 +182,34 @@ Enhance metadata, examples, and educational value.""",
                     "metadata",
                     "learning_outcomes",
                     "prerequisites",
-                    "related_concepts"
+                    "related_concepts",
                 ]
-            
+
             user_input = self._build_enhancement_prompt(card, enhancement_targets)
-            
+
             # Execute enhancement
             response = await self.execute(user_input)
-            
+
             # Parse enhanced card
             enhanced_card = self._parse_enhanced_card(response, card)
-            
+
             # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_enhanced": 1,
-                    "enhancement_targets": enhancement_targets,
-                    "enhancements_applied": len(enhancement_targets)
-                }
+
+            logger.info(
+                f"EnhancementAgent successfully enhanced card: {card.front.question[:50]}..."
             )
-            
-            logger.info(f"EnhancementAgent successfully enhanced card: {card.front.question[:50]}...")
             return enhanced_card
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"EnhancementAgent failed to enhance card: {e}")
             return card  # Return original card on failure
-    
+
     def _build_enhancement_prompt(
-        self,
-        card: Card,
-        enhancement_targets: List[str]
+        self, card: Card, enhancement_targets: List[str]
     ) -> str:
         """Build the enhancement prompt"""
         targets_str = ", ".join(enhancement_targets)
-        
+
         return f"""Enhance this flashcard by adding missing elements and enriching the content:
 
 Current Card:
@@ -296,7 +243,7 @@ Return the enhanced card as JSON:
     }},
     "metadata": {{
         "topic": "specific topic",
-        "subject": "subject area", 
+        "subject": "subject area",
         "difficulty": "beginner|intermediate|advanced",
         "tags": ["comprehensive", "tag", "list"],
         "learning_outcomes": ["specific learning outcome 1", "outcome 2"],
@@ -309,7 +256,7 @@ Return the enhanced card as JSON:
     }},
     "enhancement_notes": "Summary of enhancements made"
 }}"""
-    
+
     def _parse_enhanced_card(self, response: str, original_card: Card) -> Card:
         """Parse the enhanced card response"""
         try:
@@ -317,86 +264,67 @@ Return the enhanced card as JSON:
                 data = json.loads(response)
             else:
                 data = response
-            
+
             # Create enhanced card
             enhanced_card = Card(
                 card_type=data.get("card_type", original_card.card_type),
-                front=CardFront(
-                    question=data["front"]["question"]
-                ),
+                front=CardFront(question=data["front"]["question"]),
                 back=CardBack(
                     answer=data["back"]["answer"],
-                    explanation=data["back"].get("explanation", original_card.back.explanation),
-                    example=data["back"].get("example", original_card.back.example)
+                    explanation=data["back"].get(
+                        "explanation", original_card.back.explanation
+                    ),
+                    example=data["back"].get("example", original_card.back.example),
                 ),
-                metadata=data.get("metadata", original_card.metadata)
+                metadata=data.get("metadata", original_card.metadata),
             )
-            
+
             # Add enhancement tracking to metadata
             if enhanced_card.metadata is None:
                 enhanced_card.metadata = {}
-            
-            enhanced_card.metadata["enhancement_notes"] = data.get("enhancement_notes", "Enhanced with additional content")
+
+            enhanced_card.metadata["enhancement_notes"] = data.get(
+                "enhancement_notes", "Enhanced with additional content"
+            )
             enhanced_card.metadata["last_enhanced"] = datetime.now().isoformat()
-            
+
             return enhanced_card
-            
+
         except Exception as e:
             logger.error(f"Failed to parse enhanced card: {e}")
             return original_card
-    
+
     async def enhance_card_batch(
-        self,
-        cards: List[Card],
-        enhancement_targets: List[str] = None
+        self, cards: List[Card], enhancement_targets: List[str] = None
     ) -> List[Card]:
         """Enhance multiple cards in batch"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             enhanced_cards = []
-            
+
             # Process cards in parallel for efficiency
-            tasks = [
-                self.enhance_card(card, enhancement_targets)
-                for card in cards
-            ]
-            
+            tasks = [self.enhance_card(card, enhancement_targets) for card in cards]
+
             results = await asyncio.gather(*tasks, return_exceptions=True)
-            
+
             for card, result in zip(cards, results):
                 if isinstance(result, Exception):
                     logger.warning(f"Enhancement failed for card: {result}")
                     enhanced_cards.append(card)  # Keep original
                 else:
                     enhanced_cards.append(result)
-            
+
             # Record batch execution
-            successful_enhancements = len([r for r in results if not isinstance(r, Exception)])
-            
-            record_agent_execution(
-                agent_name=f"{self.config.name}_batch",
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_processed": len(cards),
-                    "successful_enhancements": successful_enhancements,
-                    "enhancement_rate": successful_enhancements / len(cards) if cards else 0
-                }
+            successful_enhancements = len(
+                [r for r in results if not isinstance(r, Exception)]
+            )
+
+            logger.info(
+                f"EnhancementAgent batch complete: {successful_enhancements}/{len(cards)} cards enhanced"
             )
-            
-            logger.info(f"EnhancementAgent batch complete: {successful_enhancements}/{len(cards)} cards enhanced")
             return enhanced_cards
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=f"{self.config.name}_batch",
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"EnhancementAgent batch failed: {e}")
-            return cards  # Return original cards on failure
+            return cards  # Return original cards on failure

ankigen_core/agents/generators.py

@@ -1,7 +1,6 @@
 # Specialized generator agents for card generation
 
 import json
-import asyncio
 from typing import List, Dict, Any, Optional
 from datetime import datetime
 
@@ -9,106 +8,71 @@ from openai import AsyncOpenAI
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card, CardFront, CardBack
-from .base import BaseAgentWrapper, AgentConfig
+from .base import BaseAgentWrapper
 from .config import get_config_manager
-from .metrics import record_agent_execution
+from .schemas import CardsGenerationSchema
 
 
 class SubjectExpertAgent(BaseAgentWrapper):
     """Subject matter expert agent for domain-specific card generation"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI, subject: str = "general"):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("subject_expert")
-        
+
         if not base_config:
-            # Fallback config if not found
-            base_config = AgentConfig(
-                name="subject_expert",
-                instructions=f"""You are a world-class expert in {subject} with deep pedagogical knowledge.
-Generate high-quality flashcards that demonstrate mastery of {subject} concepts.
-Focus on technical accuracy, appropriate depth, and real-world applications.""",
-                model="gpt-4o",
-                temperature=0.7
+            raise ValueError(
+                "subject_expert configuration not found - agent system not properly initialized"
             )
-        
+
+        # Enable structured output for card generation
+        base_config.output_type = CardsGenerationSchema
+
         # Customize instructions for the specific subject
         if subject != "general" and base_config.custom_prompts:
             subject_prompt = base_config.custom_prompts.get(subject.lower(), "")
             if subject_prompt:
-                base_config.instructions += f"\n\nSubject-specific guidance: {subject_prompt}"
-        
+                base_config.instructions += (
+                    f"\n\nSubject-specific guidance: {subject_prompt}"
+                )
+
         super().__init__(base_config, openai_client)
         self.subject = subject
-    
+
     async def generate_cards(
-        self,
-        topic: str,
-        num_cards: int = 5,
-        difficulty: str = "intermediate",
-        prerequisites: List[str] = None,
-        context: Dict[str, Any] = None
+        self, topic: str, num_cards: int = 5, context: Optional[Dict[str, Any]] = None
     ) -> List[Card]:
-        """Generate subject-specific flashcards"""
-        start_time = datetime.now()
-        
+        """Generate flashcards for a given topic"""
         try:
-            user_input = self._build_generation_prompt(
-                topic=topic,
-                num_cards=num_cards,
-                difficulty=difficulty,
-                prerequisites=prerequisites or [],
-                context=context or {}
-            )
-            
-            # Execute the agent
-            response = await self.execute(user_input, context)
-            
-            # Parse the response into Card objects
-            cards = self._parse_cards_response(response, topic)
-            
-            # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "subject": self.subject,
-                    "topic": topic,
-                    "cards_generated": len(cards),
-                    "difficulty": difficulty
-                }
-            )
-            
-            logger.info(f"SubjectExpertAgent generated {len(cards)} cards for {topic}")
-            return cards
-            
+            user_input = f"Generate {num_cards} flashcards for the topic: {topic}"
+            if context:
+                user_input += f"\n\nAdditional context: {context}"
+
+            response, usage = await self.execute(user_input, context)
+
+            # Log usage information
+            if usage and usage.get("total_tokens", 0) > 0:
+                logger.info(
+                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                )
+
+            return self._parse_cards_response(response, topic)
+
         except Exception as e:
-            # Record failed execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e),
-                metadata={"subject": self.subject, "topic": topic}
-            )
-            
-            logger.error(f"SubjectExpertAgent failed to generate cards: {e}")
+            logger.error(f"Card generation failed: {e}")
             raise
-    
+
     def _build_generation_prompt(
         self,
         topic: str,
         num_cards: int,
         difficulty: str,
         prerequisites: List[str],
-        context: Dict[str, Any]
+        context: Dict[str, Any],
     ) -> str:
         """Build the generation prompt"""
         prerequisites_str = ", ".join(prerequisites) if prerequisites else "None"
-        
+
         prompt = f"""Generate {num_cards} high-quality flashcards for the topic: {topic}
 
 Subject: {self.subject}
@@ -146,145 +110,178 @@ Return your response as a JSON object with this structure:
         }}
     ]
 }}"""
-        
+
         if context.get("source_text"):
             prompt += f"\n\nBase the cards on this source material:\n{context['source_text'][:2000]}..."
-        
+
         return prompt
-    
-    def _parse_cards_response(self, response: str, topic: str) -> List[Card]:
+
+    def _parse_cards_response(self, response: Any, topic: str) -> List[Card]:
         """Parse the agent response into Card objects"""
         try:
-            # Try to parse as JSON
-            if isinstance(response, str):
+            # Handle structured output from CardsGenerationSchema
+            if hasattr(response, "cards"):
+                # Response is already a CardsGenerationSchema object
+                logger.info(f"✅ STRUCTURED OUTPUT RECEIVED: {type(response)}")
+                card_data_list = response.cards
+            elif isinstance(response, dict) and "cards" in response:
+                # Response is a dict with cards
+                card_data_list = response["cards"]
+            elif isinstance(response, str):
+                # Fallback: Clean up the response - remove markdown code blocks if present
+                response = response.strip()
+                if response.startswith("```json"):
+                    response = response[7:]  # Remove ```json
+                if response.startswith("```"):
+                    response = response[3:]  # Remove ```
+                if response.endswith("```"):
+                    response = response[:-3]  # Remove trailing ```
+                response = response.strip()
+
                 data = json.loads(response)
+                if "cards" not in data:
+                    raise ValueError("Response missing 'cards' field")
+                card_data_list = data["cards"]
             else:
-                data = response
-            
-            if "cards" not in data:
-                raise ValueError("Response missing 'cards' field")
-            
+                raise ValueError(f"Unexpected response format: {type(response)}")
+
             cards = []
-            for i, card_data in enumerate(data["cards"]):
+            for i, card_data in enumerate(card_data_list):
                 try:
-                    # Validate required fields
-                    if "front" not in card_data or "back" not in card_data:
-                        logger.warning(f"Skipping card {i}: missing front or back")
-                        continue
-                    
-                    front_data = card_data["front"]
-                    back_data = card_data["back"]
-                    
-                    if "question" not in front_data:
-                        logger.warning(f"Skipping card {i}: missing question")
-                        continue
-                    
-                    if "answer" not in back_data:
-                        logger.warning(f"Skipping card {i}: missing answer")
+                    # Handle both Pydantic models and dictionaries
+                    if hasattr(card_data, "front"):
+                        # Pydantic model
+                        front_data = card_data.front
+                        back_data = card_data.back
+                        metadata = card_data.metadata
+                        card_type = card_data.card_type
+                    else:
+                        # Dictionary
+                        if "front" not in card_data or "back" not in card_data:
+                            logger.warning(f"Skipping card {i}: missing front or back")
+                            continue
+                        front_data = card_data["front"]
+                        back_data = card_data["back"]
+                        metadata = card_data.get("metadata", {})
+                        card_type = card_data.get("card_type", "basic")
+
+                    # Extract question and answer
+                    if hasattr(front_data, "question"):
+                        question = front_data.question
+                    else:
+                        question = front_data.get("question", "")
+
+                    if hasattr(back_data, "answer"):
+                        answer = back_data.answer
+                        explanation = back_data.explanation
+                        example = back_data.example
+                    else:
+                        answer = back_data.get("answer", "")
+                        explanation = back_data.get("explanation", "")
+                        example = back_data.get("example", "")
+
+                    if not question or not answer:
+                        logger.warning(f"Skipping card {i}: missing question or answer")
                         continue
-                    
+
                     # Create Card object
                     card = Card(
-                        card_type=card_data.get("card_type", "basic"),
-                        front=CardFront(question=front_data["question"]),
+                        card_type=card_type,
+                        front=CardFront(question=question),
                         back=CardBack(
-                            answer=back_data["answer"],
-                            explanation=back_data.get("explanation", ""),
-                            example=back_data.get("example", "")
+                            answer=answer,
+                            explanation=explanation,
+                            example=example,
                         ),
-                        metadata=card_data.get("metadata", {})
+                        metadata=metadata
+                        if isinstance(metadata, dict)
+                        else metadata.dict()
+                        if hasattr(metadata, "dict")
+                        else {},
                     )
-                    
+
                     # Ensure metadata includes subject and topic
                     if card.metadata is not None:
                         if "subject" not in card.metadata:
                             card.metadata["subject"] = self.subject
                         if "topic" not in card.metadata:
                             card.metadata["topic"] = topic
-                    
+
                     cards.append(card)
-                    
+
                 except Exception as e:
                     logger.warning(f"Failed to parse card {i}: {e}")
                     continue
-            
+
+            logger.info(f"✅ PARSED {len(cards)} CARDS FROM STRUCTURED OUTPUT")
             return cards
-            
+
         except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse cards response as JSON: {e}")
+            logger.error(f"💥 JSON DECODE ERROR: {e}")
+            logger.error("💥 RAW RESPONSE THAT FAILED TO PARSE:")
+            logger.error("---FAILED RESPONSE START---")
+            logger.error(f"{response}")
+            logger.error("---FAILED RESPONSE END---")
+            logger.error(f"💥 RESPONSE TYPE: {type(response)}")
+            if isinstance(response, str):
+                logger.error(f"💥 RESPONSE LENGTH: {len(response)}")
+                logger.error(f"💥 FIRST 200 CHARS: {repr(response[:200])}")
+                logger.error(f"💥 LAST 200 CHARS: {repr(response[-200:])}")
             raise ValueError(f"Invalid JSON response from agent: {e}")
         except Exception as e:
-            logger.error(f"Failed to parse cards response: {e}")
+            logger.error(f"💥 GENERAL PARSING ERROR: {e}")
+            logger.error(f"💥 RESPONSE THAT CAUSED ERROR: {response}")
             raise
 
 
 class PedagogicalAgent(BaseAgentWrapper):
     """Pedagogical specialist for educational effectiveness"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("pedagogical")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="pedagogical",
-                instructions="""You are an educational specialist focused on learning theory and instructional design.
-Ensure all flashcards follow educational best practices using Bloom's Taxonomy, Spaced Repetition,
-and Cognitive Load Theory. Review for clear learning objectives and appropriate difficulty progression.""",
-                model="gpt-4o",
-                temperature=0.6
+            raise ValueError(
+                "pedagogical configuration not found - agent system not properly initialized"
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def review_cards(self, cards: List[Card]) -> List[Dict[str, Any]]:
         """Review cards for pedagogical effectiveness"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             reviews = []
-            
+
             for i, card in enumerate(cards):
                 user_input = self._build_review_prompt(card, i)
-                response = await self.execute(user_input)
-                
+                response, usage = await self.execute(user_input)
+
                 try:
-                    review_data = json.loads(response) if isinstance(response, str) else response
+                    review_data = (
+                        json.loads(response) if isinstance(response, str) else response
+                    )
                     reviews.append(review_data)
                 except Exception as e:
                     logger.warning(f"Failed to parse review for card {i}: {e}")
-                    reviews.append({
-                        "approved": True,
-                        "feedback": f"Review parsing failed: {e}",
-                        "improvements": []
-                    })
-            
+                    reviews.append(
+                        {
+                            "approved": True,
+                            "feedback": f"Review parsing failed: {e}",
+                            "improvements": [],
+                        }
+                    )
+
             # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_reviewed": len(cards),
-                    "approvals": len([r for r in reviews if r.get("approved", False)])
-                }
-            )
-            
+
             return reviews
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"PedagogicalAgent review failed: {e}")
             raise
-    
+
     def _parse_review_response(self, response) -> Dict[str, Any]:
         """Parse the review response into a dictionary"""
         try:
@@ -292,21 +289,25 @@ and Cognitive Load Theory. Review for clear learning objectives and appropriate
                 data = json.loads(response)
             else:
                 data = response
-            
+
             # Validate required fields
-            required_fields = ['pedagogical_quality', 'clarity', 'learning_effectiveness']
+            required_fields = [
+                "pedagogical_quality",
+                "clarity",
+                "learning_effectiveness",
+            ]
             if not all(field in data for field in required_fields):
                 raise ValueError("Missing required review fields")
-            
+
             return data
-            
+
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse review response as JSON: {e}")
             raise ValueError(f"Invalid review response: {e}")
         except Exception as e:
             logger.error(f"Failed to parse review response: {e}")
             raise ValueError(f"Invalid review response: {e}")
-    
+
     def _build_review_prompt(self, card: Card, index: int) -> str:
         """Build the review prompt for a single card"""
         return f"""Review this flashcard for pedagogical effectiveness:
@@ -340,68 +341,45 @@ Return your assessment as JSON:
 
 class ContentStructuringAgent(BaseAgentWrapper):
     """Content organization and formatting specialist"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("content_structuring")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="content_structuring",
-                instructions="""You are a content organization specialist focused on consistency and structure.
-Format and organize flashcard content for optimal learning with consistent formatting,
-proper metadata, clear questions, and appropriate categorization.""",
-                model="gpt-4o-mini",
-                temperature=0.5
+            raise ValueError(
+                "content_structuring configuration not found - agent system not properly initialized"
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def structure_cards(self, cards: List[Card]) -> List[Card]:
         """Structure and format cards for consistency"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             structured_cards = []
-            
+
             for i, card in enumerate(cards):
                 user_input = self._build_structuring_prompt(card, i)
-                response = await self.execute(user_input)
-                
+                response, usage = await self.execute(user_input)
+
                 try:
-                    structured_data = json.loads(response) if isinstance(response, str) else response
+                    structured_data = (
+                        json.loads(response) if isinstance(response, str) else response
+                    )
                     structured_card = self._parse_structured_card(structured_data, card)
                     structured_cards.append(structured_card)
                 except Exception as e:
                     logger.warning(f"Failed to structure card {i}: {e}")
                     structured_cards.append(card)  # Keep original on failure
-            
-            # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_structured": len(cards),
-                    "successful_structures": len([c for c in structured_cards if c != cards[i] for i in range(len(cards))])
-                }
-            )
-            
+
             return structured_cards
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"ContentStructuringAgent failed: {e}")
             raise
-    
+
     def _build_structuring_prompt(self, card: Card, index: int) -> str:
         """Build the structuring prompt for a single card"""
         return f"""Structure and format this flashcard for optimal learning:
@@ -444,21 +422,21 @@ Return the improved card as JSON:
         "category": "category name"
     }}
 }}"""
-    
-    def _parse_structured_card(self, structured_data: Dict[str, Any], original_card: Card) -> Card:
+
+    def _parse_structured_card(
+        self, structured_data: Dict[str, Any], original_card: Card
+    ) -> Card:
         """Parse structured card data into Card object"""
         try:
             return Card(
                 card_type=structured_data.get("card_type", original_card.card_type),
-                front=CardFront(
-                    question=structured_data["front"]["question"]
-                ),
+                front=CardFront(question=structured_data["front"]["question"]),
                 back=CardBack(
                     answer=structured_data["back"]["answer"],
                     explanation=structured_data["back"].get("explanation", ""),
-                    example=structured_data["back"].get("example", "")
+                    example=structured_data["back"].get("example", ""),
                 ),
-                metadata=structured_data.get("metadata", original_card.metadata)
+                metadata=structured_data.get("metadata", original_card.metadata),
             )
         except Exception as e:
             logger.warning(f"Failed to parse structured card: {e}")
@@ -467,28 +445,23 @@ Return the improved card as JSON:
 
 class GenerationCoordinator(BaseAgentWrapper):
     """Coordinates the multi-agent card generation workflow"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("generation_coordinator")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="generation_coordinator",
-                instructions="""You are the generation workflow coordinator.
-Orchestrate the card generation process and manage handoffs between specialized agents.
-Make decisions based on content type, user preferences, and system load.""",
-                model="gpt-4o-mini",
-                temperature=0.3
+            raise ValueError(
+                "generation_coordinator configuration not found - agent system not properly initialized"
             )
-        
+
         super().__init__(base_config, openai_client)
-        
+
         # Initialize specialized agents
         self.subject_expert = None
         self.pedagogical = PedagogicalAgent(openai_client)
         self.content_structuring = ContentStructuringAgent(openai_client)
-    
+
     async def coordinate_generation(
         self,
         topic: str,
@@ -497,73 +470,121 @@ Make decisions based on content type, user preferences, and system load.""",
         difficulty: str = "intermediate",
         enable_review: bool = True,
         enable_structuring: bool = True,
-        context: Dict[str, Any] = None
+        context: Dict[str, Any] = None,
     ) -> List[Card]:
         """Coordinate the full card generation pipeline"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             # Initialize subject expert for the specific subject
             if not self.subject_expert or self.subject_expert.subject != subject:
                 self.subject_expert = SubjectExpertAgent(self.openai_client, subject)
-            
+
             logger.info(f"Starting coordinated generation: {topic} ({subject})")
-            
+
             # Step 1: Generate initial cards
             cards = await self.subject_expert.generate_cards(
-                topic=topic,
-                num_cards=num_cards,
-                difficulty=difficulty,
-                context=context
+                topic=topic, num_cards=num_cards, context=context
             )
-            
+
             # Step 2: Pedagogical review (optional)
             if enable_review and cards:
                 logger.info("Performing pedagogical review...")
                 reviews = await self.pedagogical.review_cards(cards)
-                
+
                 # Filter or flag cards based on reviews
                 approved_cards = []
                 for card, review in zip(cards, reviews):
                     if review.get("approved", True):
                         approved_cards.append(card)
                     else:
-                        logger.info(f"Card flagged for revision: {card.front.question[:50]}...")
-                
+                        logger.info(
+                            f"Card flagged for revision: {card.front.question[:50]}..."
+                        )
+
                 cards = approved_cards
-            
+
             # Step 3: Content structuring (optional)
             if enable_structuring and cards:
                 logger.info("Performing content structuring...")
                 cards = await self.content_structuring.structure_cards(cards)
-            
+
             # Record successful coordination
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "topic": topic,
-                    "subject": subject,
-                    "cards_generated": len(cards),
-                    "review_enabled": enable_review,
-                    "structuring_enabled": enable_structuring
-                }
-            )
-            
+
             logger.info(f"Generation coordination complete: {len(cards)} cards")
             return cards
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e),
-                metadata={"topic": topic, "subject": subject}
-            )
-            
             logger.error(f"Generation coordination failed: {e}")
-            raise
+            raise
+
+    async def generate_structured_cards(
+        self,
+        topic: str,
+        num_cards: int = 5,
+        difficulty: str = "intermediate",
+        context: Optional[Dict[str, Any]] = None,
+    ) -> List[Card]:
+        """Generate structured flashcards with enhanced metadata"""
+        try:
+            user_input = f"""Generate {num_cards} structured flashcards for: {topic}
+
+Difficulty: {difficulty}
+Requirements:
+- Include detailed metadata
+- Add learning outcomes
+- Specify prerequisites
+- Include related concepts
+- Estimate study time"""
+
+            response, usage = await self.execute(user_input)
+
+            # Log usage information
+            if usage and usage.get("total_tokens", 0) > 0:
+                logger.info(
+                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                )
+
+            # Parse the structured response directly since it should be a CardsGenerationSchema
+            if hasattr(response, "cards") and response.cards:
+                return response.cards
+            else:
+                logger.warning("No cards found in structured response")
+                return []
+
+        except Exception as e:
+            logger.error(f"Structured card generation failed: {e}")
+            raise
+
+    async def generate_adaptive_cards(
+        self,
+        topic: str,
+        learning_style: str = "visual",
+        num_cards: int = 5,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> List[Card]:
+        """Generate cards adapted to specific learning styles"""
+        try:
+            user_input = f"""Generate {num_cards} flashcards for: {topic}
+
+Learning Style: {learning_style}
+Adapt the content format and presentation to match this learning style."""
+
+            response, usage = await self.execute(user_input)
+
+            # Log usage information
+            if usage and usage.get("total_tokens", 0) > 0:
+                logger.info(
+                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                )
+
+            # Parse the adaptive response directly since it should be a CardsGenerationSchema
+            if hasattr(response, "cards") and response.cards:
+                return response.cards
+            else:
+                logger.warning("No cards found in adaptive response")
+                return []
+
+        except Exception as e:
+            logger.error(f"Adaptive card generation failed: {e}")
+            raise

ankigen_core/agents/integration.py

@@ -1,65 +1,61 @@
 # Main integration module for AnkiGen agent system
 
-import asyncio
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Tuple
 from datetime import datetime
 
-from openai import AsyncOpenAI
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card
 from ankigen_core.llm_interface import OpenAIClientManager
 
-from .feature_flags import get_feature_flags, AgentMode
 from .generators import GenerationCoordinator, SubjectExpertAgent
-from .judges import JudgeCoordinator, JudgeDecision
+from .judges import JudgeCoordinator
 from .enhancers import RevisionAgent, EnhancementAgent
-from .metrics import get_metrics, record_agent_execution
 
 
 class AgentOrchestrator:
     """Main orchestrator for the AnkiGen agent system"""
-    
+
     def __init__(self, client_manager: OpenAIClientManager):
         self.client_manager = client_manager
         self.openai_client = None
-        
+
         # Initialize coordinators
         self.generation_coordinator = None
         self.judge_coordinator = None
         self.revision_agent = None
         self.enhancement_agent = None
-        
-        # Feature flags
-        self.feature_flags = get_feature_flags()
-        
-    async def initialize(self, api_key: str):
+
+        # All agents enabled by default
+        self.all_agents_enabled = True
+
+    async def initialize(self, api_key: str, model_overrides: Dict[str, str] = None):
         """Initialize the agent system"""
         try:
             # Initialize OpenAI client
             await self.client_manager.initialize_client(api_key)
             self.openai_client = self.client_manager.get_client()
-            
-            # Initialize agents based on feature flags
-            if self.feature_flags.enable_generation_coordinator:
-                self.generation_coordinator = GenerationCoordinator(self.openai_client)
-            
-            if self.feature_flags.enable_judge_coordinator:
-                self.judge_coordinator = JudgeCoordinator(self.openai_client)
-            
-            if self.feature_flags.enable_revision_agent:
-                self.revision_agent = RevisionAgent(self.openai_client)
-            
-            if self.feature_flags.enable_enhancement_agent:
-                self.enhancement_agent = EnhancementAgent(self.openai_client)
-            
+
+            # Set up model overrides if provided
+            if model_overrides:
+                from ankigen_core.agents.config import get_config_manager
+
+                config_manager = get_config_manager()
+                config_manager.update_models(model_overrides)
+                logger.info(f"Applied model overrides: {model_overrides}")
+
+            # Initialize all agents
+            self.generation_coordinator = GenerationCoordinator(self.openai_client)
+            self.judge_coordinator = JudgeCoordinator(self.openai_client)
+            self.revision_agent = RevisionAgent(self.openai_client)
+            self.enhancement_agent = EnhancementAgent(self.openai_client)
+
             logger.info("Agent system initialized successfully")
-            logger.info(f"Active agents: {self.feature_flags.get_enabled_agents()}")
-            
+
         except Exception as e:
             logger.error(f"Failed to initialize agent system: {e}")
             raise
-    
+
     async def generate_cards_with_agents(
         self,
         topic: str,
@@ -67,175 +63,148 @@ class AgentOrchestrator:
         num_cards: int = 5,
         difficulty: str = "intermediate",
         enable_quality_pipeline: bool = True,
-        context: Dict[str, Any] = None
+        context: Dict[str, Any] = None,
     ) -> Tuple[List[Card], Dict[str, Any]]:
         """Generate cards using the agent system"""
         start_time = datetime.now()
-        
+
         try:
-            # Check if agents should be used
-            if not self.feature_flags.should_use_agents():
-                raise ValueError("Agent mode not enabled")
-            
+            # Agents are always enabled now
+
             if not self.openai_client:
                 raise ValueError("Agent system not initialized")
-            
+
             logger.info(f"Starting agent-based card generation: {topic} ({subject})")
-            
+
             # Phase 1: Generation
             cards = await self._generation_phase(
                 topic=topic,
                 subject=subject,
                 num_cards=num_cards,
                 difficulty=difficulty,
-                context=context
+                context=context,
             )
-            
-            # Phase 2: Quality Assessment (optional)
+
+            # Phase 2: Quality Assessment
             quality_results = {}
-            if enable_quality_pipeline and self.feature_flags.enable_judge_coordinator:
+            if enable_quality_pipeline and self.judge_coordinator:
                 cards, quality_results = await self._quality_phase(cards)
-            
-            # Phase 3: Enhancement (optional)
-            if self.feature_flags.enable_enhancement_agent and self.enhancement_agent:
+
+            # Phase 3: Enhancement
+            if self.enhancement_agent:
                 cards = await self._enhancement_phase(cards)
-            
+
             # Collect metadata
             metadata = {
                 "generation_method": "agent_system",
-                "agents_used": self.feature_flags.get_enabled_agents(),
                 "generation_time": (datetime.now() - start_time).total_seconds(),
                 "cards_generated": len(cards),
                 "quality_results": quality_results,
                 "topic": topic,
                 "subject": subject,
-                "difficulty": difficulty
+                "difficulty": difficulty,
             }
-            
-            # Record overall execution
-            record_agent_execution(
-                agent_name="agent_orchestrator",
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata=metadata
+
+            logger.info(
+                f"Agent-based generation complete: {len(cards)} cards generated"
             )
-            
-            logger.info(f"Agent-based generation complete: {len(cards)} cards generated")
             return cards, metadata
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name="agent_orchestrator",
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e),
-                metadata={"topic": topic, "subject": subject}
-            )
-            
             logger.error(f"Agent-based generation failed: {e}")
             raise
-    
+
     async def _generation_phase(
         self,
         topic: str,
         subject: str,
         num_cards: int,
         difficulty: str,
-        context: Dict[str, Any] = None
+        context: Dict[str, Any] = None,
     ) -> List[Card]:
         """Execute the card generation phase"""
-        
-        if self.generation_coordinator and self.feature_flags.enable_generation_coordinator:
+
+        if self.generation_coordinator:
             # Use coordinated multi-agent generation
             cards = await self.generation_coordinator.coordinate_generation(
                 topic=topic,
                 subject=subject,
                 num_cards=num_cards,
                 difficulty=difficulty,
-                enable_review=self.feature_flags.enable_pedagogical_agent,
-                enable_structuring=self.feature_flags.enable_content_structuring_agent,
-                context=context
+                enable_review=True,
+                enable_structuring=True,
+                context=context,
             )
-        elif self.feature_flags.enable_subject_expert_agent:
+        else:
             # Use subject expert agent directly
             subject_expert = SubjectExpertAgent(self.openai_client, subject)
             cards = await subject_expert.generate_cards(
-                topic=topic,
-                num_cards=num_cards,
-                difficulty=difficulty,
-                context=context
+                topic=topic, num_cards=num_cards, difficulty=difficulty, context=context
             )
-        else:
-            # Fallback to legacy generation (would be implemented separately)
-            raise ValueError("No generation agents enabled")
-        
+
         logger.info(f"Generation phase complete: {len(cards)} cards generated")
         return cards
-    
+
     async def _quality_phase(
-        self,
-        cards: List[Card]
+        self, cards: List[Card]
     ) -> Tuple[List[Card], Dict[str, Any]]:
         """Execute the quality assessment and improvement phase"""
-        
+
         if not self.judge_coordinator:
             return cards, {"message": "Judge coordinator not available"}
-        
+
         logger.info(f"Starting quality assessment for {len(cards)} cards")
-        
+
         # Judge all cards
         judge_results = await self.judge_coordinator.coordinate_judgment(
             cards=cards,
-            enable_parallel=self.feature_flags.enable_parallel_judging,
-            min_consensus=self.feature_flags.min_judge_consensus
+            enable_parallel=True,
+            min_consensus=0.6,
         )
-        
+
         # Separate approved and rejected cards
         approved_cards = []
         rejected_cards = []
-        
+
         for card, decisions, approved in judge_results:
             if approved:
                 approved_cards.append(card)
             else:
                 rejected_cards.append((card, decisions))
-        
+
         # Attempt to revise rejected cards
         revised_cards = []
         if self.revision_agent and rejected_cards:
             logger.info(f"Attempting to revise {len(rejected_cards)} rejected cards")
-            
+
             for card, decisions in rejected_cards:
                 try:
                     revised_card = await self.revision_agent.revise_card(
                         card=card,
                         judge_decisions=decisions,
-                        max_iterations=self.feature_flags.max_revision_iterations
+                        max_iterations=2,
                     )
-                    
+
                     # Re-judge the revised card
-                    if self.feature_flags.enable_parallel_judging:
-                        revision_results = await self.judge_coordinator.coordinate_judgment(
-                            cards=[revised_card],
-                            enable_parallel=False,  # Single card, no need for parallel
-                            min_consensus=self.feature_flags.min_judge_consensus
-                        )
-                        
-                        if revision_results and revision_results[0][2]:  # If approved
-                            revised_cards.append(revised_card)
-                        else:
-                            logger.warning(f"Revised card still rejected: {card.front.question[:50]}...")
-                    else:
+                    revision_results = await self.judge_coordinator.coordinate_judgment(
+                        cards=[revised_card],
+                        enable_parallel=False,  # Single card, no need for parallel
+                        min_consensus=0.6,
+                    )
+
+                    if revision_results and revision_results[0][2]:  # If approved
                         revised_cards.append(revised_card)
-                        
+                    else:
+                        logger.warning(
+                            f"Revised card still rejected: {card.front.question[:50]}..."
+                        )
+
                 except Exception as e:
                     logger.error(f"Failed to revise card: {e}")
-        
+
         # Combine approved and successfully revised cards
         final_cards = approved_cards + revised_cards
-        
+
         # Prepare quality results
         quality_results = {
             "total_cards_judged": len(cards),
@@ -243,106 +212,49 @@ class AgentOrchestrator:
             "initially_rejected": len(rejected_cards),
             "successfully_revised": len(revised_cards),
             "final_approval_rate": len(final_cards) / len(cards) if cards else 0,
-            "judge_decisions": len(judge_results)
+            "judge_decisions": len(judge_results),
         }
-        
-        logger.info(f"Quality phase complete: {len(final_cards)}/{len(cards)} cards approved")
+
+        logger.info(
+            f"Quality phase complete: {len(final_cards)}/{len(cards)} cards approved"
+        )
         return final_cards, quality_results
-    
+
     async def _enhancement_phase(self, cards: List[Card]) -> List[Card]:
         """Execute the enhancement phase"""
-        
+
         if not self.enhancement_agent:
             return cards
-        
+
         logger.info(f"Starting enhancement for {len(cards)} cards")
-        
+
         enhanced_cards = await self.enhancement_agent.enhance_card_batch(
-            cards=cards,
-            enhancement_targets=["explanation", "example", "metadata"]
+            cards=cards, enhancement_targets=["explanation", "example", "metadata"]
         )
-        
+
         logger.info(f"Enhancement phase complete: {len(enhanced_cards)} cards enhanced")
         return enhanced_cards
-    
+
     def get_performance_metrics(self) -> Dict[str, Any]:
         """Get performance metrics for the agent system"""
-        metrics = get_metrics()
-        
+
+        # Basic performance info only
         return {
-            "agent_performance": metrics.get_performance_report(hours=24),
-            "quality_metrics": metrics.get_quality_metrics(),
-            "feature_flags": self.feature_flags.to_dict(),
-            "enabled_agents": self.feature_flags.get_enabled_agents()
+            "agents_enabled": True,
         }
 
 
 async def integrate_with_existing_workflow(
-    client_manager: OpenAIClientManager,
-    api_key: str,
-    **generation_params
+    client_manager: OpenAIClientManager, api_key: str, **generation_params
 ) -> Tuple[List[Card], Dict[str, Any]]:
     """Integration point for existing AnkiGen workflow"""
-    
-    feature_flags = get_feature_flags()
-    
-    # Check if agents should be used
-    if not feature_flags.should_use_agents():
-        logger.info("Agents disabled, falling back to legacy generation")
-        # Would call the existing generation logic here
-        raise NotImplementedError("Legacy fallback not implemented in this demo")
-    
+
+    # Agents are always enabled
+
     # Initialize and use agent system
     orchestrator = AgentOrchestrator(client_manager)
     await orchestrator.initialize(api_key)
-    
-    cards, metadata = await orchestrator.generate_cards_with_agents(**generation_params)
-    
-    return cards, metadata
 
+    cards, metadata = await orchestrator.generate_cards_with_agents(**generation_params)
 
-# Example usage function for testing/demo
-async def demo_agent_system():
-    """Demo function showing how to use the agent system"""
-    
-    # This would be replaced with actual API key in real usage
-    api_key = "your-openai-api-key"
-    
-    # Initialize client manager
-    client_manager = OpenAIClientManager()
-    
-    try:
-        # Create orchestrator
-        orchestrator = AgentOrchestrator(client_manager)
-        await orchestrator.initialize(api_key)
-        
-        # Generate cards with agents
-        cards, metadata = await orchestrator.generate_cards_with_agents(
-            topic="Python Functions",
-            subject="programming",
-            num_cards=3,
-            difficulty="intermediate",
-            enable_quality_pipeline=True
-        )
-        
-        print(f"Generated {len(cards)} cards:")
-        for i, card in enumerate(cards, 1):
-            print(f"\nCard {i}:")
-            print(f"Q: {card.front.question}")
-            print(f"A: {card.back.answer}")
-            print(f"Subject: {card.metadata.get('subject', 'Unknown')}")
-        
-        print(f"\nMetadata: {metadata}")
-        
-        # Get performance metrics
-        performance = orchestrator.get_performance_metrics()
-        print(f"\nPerformance: {performance}")
-        
-    except Exception as e:
-        logger.error(f"Demo failed: {e}")
-        raise
-
-
-if __name__ == "__main__":
-    # Run the demo
-    asyncio.run(demo_agent_system())
+    return cards, metadata

ankigen_core/agents/judges.py

@@ -2,8 +2,9 @@
 
 import json
 import asyncio
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Tuple, Optional
 from datetime import datetime
+from dataclasses import dataclass
 
 from openai import AsyncOpenAI
 
@@ -11,124 +12,105 @@ from ankigen_core.logging import logger
 from ankigen_core.models import Card
 from .base import BaseAgentWrapper, AgentConfig
 from .config import get_config_manager
-from .metrics import record_agent_execution
+from .schemas import JudgeDecisionSchema
 
 
+@dataclass
 class JudgeDecision:
-    """Represents a judge's decision on a card"""
-    
-    def __init__(
-        self,
-        approved: bool,
-        score: float,
-        feedback: str,
-        improvements: List[str] = None,
-        judge_name: str = "",
-        metadata: Dict[str, Any] = None
-    ):
-        self.approved = approved
-        self.score = score  # 0.0 to 1.0
-        self.feedback = feedback
-        self.improvements = improvements or []
-        self.judge_name = judge_name
-        self.metadata = metadata or {}
+    """Decision from a judge agent"""
+
+    approved: bool
+    score: float
+    feedback: str
+    judge_name: str
+    improvements: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}
+        if self.improvements is None:
+            self.improvements = []
 
 
 class ContentAccuracyJudge(BaseAgentWrapper):
     """Judge for factual accuracy and content correctness"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("content_accuracy_judge")
-        
+
         if not base_config:
-            base_config = AgentConfig(
-                name="content_accuracy_judge",
-                instructions="""You are a fact-checking and accuracy specialist.
-Verify the correctness and accuracy of flashcard content, checking for factual errors,
-misconceptions, and ensuring consistency with authoritative sources.""",
-                model="gpt-4o",
-                temperature=0.3
+            raise ValueError(
+                "content_accuracy_judge configuration not found - agent system not properly initialized"
             )
-        
+
+        # Enable structured output for judge decisions
+        base_config.response_format = JudgeDecisionSchema
+
         super().__init__(base_config, openai_client)
-    
-    async def judge_card(self, card: Card) -> JudgeDecision:
-        """Judge a single card for content accuracy"""
-        start_time = datetime.now()
-        
+
+    async def judge_card(
+        self, card: Card, context: Optional[Dict[str, Any]] = None
+    ) -> JudgeDecision:
+        """Judge a card for content accuracy"""
         try:
-            user_input = self._build_judgment_prompt(card)
-            response = await self.execute(user_input)
-            
-            # Parse the response
-            decision_data = json.loads(response) if isinstance(response, str) else response
-            decision = self._parse_decision(decision_data)
-            
-            # Record successful execution
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": 1,
-                    "approved": 1 if decision.approved else 0,
-                    "score": decision.score
-                }
-            )
-            
-            return decision
-            
+            user_input = f"""Evaluate this flashcard for factual accuracy:
+
+Front: {card.front.content}
+Back: {card.back.content}
+
+Assess:
+1. Factual correctness
+2. Completeness of information
+3. Clarity and precision
+4. Potential misconceptions
+
+Provide a score (0-1) and detailed feedback."""
+
+            response, usage = await self.execute(user_input)
+
+            # Log usage information
+            if usage and usage.get("total_tokens", 0) > 0:
+                logger.info(
+                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                )
+
+            return self._parse_judge_response(response, "ContentAccuracyJudge")
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
-            logger.error(f"ContentAccuracyJudge failed: {e}")
-            # Return default approval to avoid blocking workflow
-            return JudgeDecision(
-                approved=True,
-                score=0.5,
-                feedback=f"Judgment failed: {str(e)}",
-                judge_name=self.config.name
+            logger.error(f"Content accuracy judgment failed: {e}")
+            raise
+
+    def _parse_judge_response(
+        self, response: Dict[str, Any], judge_name: str
+    ) -> JudgeDecision:
+        """Parse the judge response into a JudgeDecision"""
+        decision_data = json.loads(response) if isinstance(response, str) else response
+        decision = self._parse_decision(decision_data)
+
+        # Enhanced logging for judge decisions
+        logger.info(f"🎯 {judge_name.upper()} DECISION:")
+        logger.info("   Card: [Card content]")
+        logger.info(f"   ✅ Approved: {decision.approved}")
+        logger.info(f"   📊 Score: {decision.score:.2f}")
+        logger.info(f"   💭 Feedback: {decision.feedback}")
+
+        if decision.metadata.get("factual_errors"):
+            logger.info(f"   ❌ Factual Errors: {decision.metadata['factual_errors']}")
+        if decision.metadata.get("terminology_issues"):
+            logger.info(
+                f"   ⚠️ Terminology Issues: {decision.metadata['terminology_issues']}"
             )
-    
-    def _build_judgment_prompt(self, card: Card) -> str:
-        """Build the judgment prompt for content accuracy"""
-        return f"""Evaluate this flashcard for factual accuracy and content correctness:
+        if decision.improvements:
+            logger.info(f"   🔧 Suggested Improvements: {decision.improvements}")
 
-Card:
-Question: {card.front.question}
-Answer: {card.back.answer}
-Explanation: {card.back.explanation}
-Example: {card.back.example}
-Subject: {card.metadata.get('subject', 'Unknown')}
-Topic: {card.metadata.get('topic', 'Unknown')}
+        logger.info(
+            f"   🎯 Judge Confidence: {decision.metadata.get('confidence', 'N/A')}"
+        )
 
-Evaluate for:
-1. Factual Accuracy: Are all statements factually correct?
-2. Source Consistency: Does content align with authoritative sources?
-3. Terminology: Is domain-specific terminology used correctly?
-4. Misconceptions: Does the card avoid or address common misconceptions?
-5. Currency: Is the information up-to-date?
+        return decision
 
-Return your assessment as JSON:
-{{
-    "approved": true/false,
-    "accuracy_score": 0.0-1.0,
-    "factual_errors": ["error1", "error2"],
-    "terminology_issues": ["issue1", "issue2"],
-    "misconceptions": ["misconception1"],
-    "suggestions": ["improvement1", "improvement2"],
-    "confidence": 0.0-1.0,
-    "detailed_feedback": "Comprehensive assessment of content accuracy"
-}}"""
-    
     def _parse_decision(self, decision_data: Dict[str, Any]) -> JudgeDecision:
         """Parse the judge response into a JudgeDecision"""
         return JudgeDecision(
@@ -141,72 +123,72 @@ Return your assessment as JSON:
                 "factual_errors": decision_data.get("factual_errors", []),
                 "terminology_issues": decision_data.get("terminology_issues", []),
                 "misconceptions": decision_data.get("misconceptions", []),
-                "confidence": decision_data.get("confidence", 0.5)
-            }
+                "confidence": decision_data.get("confidence", 0.5),
+            },
         )
 
 
 class PedagogicalJudge(BaseAgentWrapper):
     """Judge for educational effectiveness and pedagogical principles"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("pedagogical_judge")
-        
+
         if not base_config:
             base_config = AgentConfig(
                 name="pedagogical_judge",
                 instructions="""You are an educational assessment specialist.
 Evaluate flashcards for pedagogical effectiveness, learning objectives,
 cognitive levels, and educational best practices.""",
-                model="gpt-4o",
-                temperature=0.4
+                model="gpt-4.1",
+                temperature=0.4,
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def judge_card(self, card: Card) -> JudgeDecision:
         """Judge a single card for pedagogical effectiveness"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             user_input = self._build_judgment_prompt(card)
             response = await self.execute(user_input)
-            
-            decision_data = json.loads(response) if isinstance(response, str) else response
-            decision = self._parse_decision(decision_data)
-            
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": 1,
-                    "approved": 1 if decision.approved else 0,
-                    "score": decision.score
-                }
+
+            decision_data = (
+                json.loads(response) if isinstance(response, str) else response
             )
-            
+            decision = self._parse_decision(decision_data)
+
+            # Enhanced logging for pedagogical judge decisions
+            logger.info(f"🎓 {self.config.name.upper()} DECISION:")
+            logger.info(f"   Card: {card.front.question[:80]}...")
+            logger.info(f"   ✅ Approved: {decision.approved}")
+            logger.info(f"   📊 Score: {decision.score:.2f}")
+            logger.info(f"   💭 Feedback: {decision.feedback}")
+
+            if decision.metadata and decision.metadata.get("cognitive_level"):
+                logger.info(
+                    f"   🧠 Cognitive Level: {decision.metadata['cognitive_level']}"
+                )
+            if decision.metadata and decision.metadata.get("pedagogical_issues"):
+                logger.info(
+                    f"   ⚠️ Pedagogical Issues: {decision.metadata['pedagogical_issues']}"
+                )
+            if decision.improvements:
+                logger.info(f"   🔧 Suggested Improvements: {decision.improvements}")
+
             return decision
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"PedagogicalJudge failed: {e}")
             return JudgeDecision(
                 approved=True,
                 score=0.5,
                 feedback=f"Judgment failed: {str(e)}",
-                judge_name=self.config.name
+                judge_name=self.config.name,
             )
-    
+
     def _build_judgment_prompt(self, card: Card) -> str:
         """Build the judgment prompt for pedagogical effectiveness"""
         return f"""Evaluate this flashcard for pedagogical effectiveness:
@@ -237,7 +219,7 @@ Return your assessment as JSON:
     "improvement_suggestions": ["suggestion1", "suggestion2"],
     "detailed_feedback": "Comprehensive pedagogical assessment"
 }}"""
-    
+
     def _parse_decision(self, decision_data: Dict[str, Any]) -> JudgeDecision:
         """Parse the judge response into a JudgeDecision"""
         return JudgeDecision(
@@ -251,72 +233,70 @@ Return your assessment as JSON:
                 "cognitive_load": decision_data.get("cognitive_load", "medium"),
                 "learning_objectives": decision_data.get("learning_objectives", []),
                 "engagement_factors": decision_data.get("engagement_factors", []),
-                "pedagogical_issues": decision_data.get("pedagogical_issues", [])
-            }
+                "pedagogical_issues": decision_data.get("pedagogical_issues", []),
+            },
         )
 
 
 class ClarityJudge(BaseAgentWrapper):
     """Judge for clarity, readability, and communication effectiveness"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("clarity_judge")
-        
+
         if not base_config:
             base_config = AgentConfig(
                 name="clarity_judge",
                 instructions="""You are a communication and clarity specialist.
 Ensure flashcards are clear, unambiguous, well-written, and accessible
 to the target audience.""",
-                model="gpt-4o-mini",
-                temperature=0.3
+                model="gpt-4.1-mini",
+                temperature=0.3,
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def judge_card(self, card: Card) -> JudgeDecision:
         """Judge a single card for clarity and communication"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             user_input = self._build_judgment_prompt(card)
             response = await self.execute(user_input)
-            
-            decision_data = json.loads(response) if isinstance(response, str) else response
-            decision = self._parse_decision(decision_data)
-            
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": 1,
-                    "approved": 1 if decision.approved else 0,
-                    "score": decision.score
-                }
+
+            decision_data = (
+                json.loads(response) if isinstance(response, str) else response
             )
-            
+            decision = self._parse_decision(decision_data)
+
+            # Enhanced logging for clarity judge decisions
+            logger.info(f"✨ {self.config.name.upper()} DECISION:")
+            logger.info(f"   Card: {card.front.question[:80]}...")
+            logger.info(f"   ✅ Approved: {decision.approved}")
+            logger.info(f"   📊 Score: {decision.score:.2f}")
+            logger.info(f"   💭 Feedback: {decision.feedback}")
+
+            if decision.metadata and decision.metadata.get("readability_level"):
+                logger.info(
+                    f"   📚 Readability: {decision.metadata['readability_level']}"
+                )
+            if decision.metadata and decision.metadata.get("ambiguities"):
+                logger.info(f"   ❓ Ambiguities: {decision.metadata['ambiguities']}")
+            if decision.improvements:
+                logger.info(f"   🔧 Suggested Improvements: {decision.improvements}")
+
             return decision
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"ClarityJudge failed: {e}")
             return JudgeDecision(
                 approved=True,
                 score=0.5,
                 feedback=f"Judgment failed: {str(e)}",
-                judge_name=self.config.name
+                judge_name=self.config.name,
             )
-    
+
     def _build_judgment_prompt(self, card: Card) -> str:
         """Build the judgment prompt for clarity assessment"""
         return f"""Evaluate this flashcard for clarity and communication effectiveness:
@@ -346,7 +326,7 @@ Return your assessment as JSON:
     "improvement_suggestions": ["suggestion1", "suggestion2"],
     "detailed_feedback": "Comprehensive clarity assessment"
 }}"""
-    
+
     def _parse_decision(self, decision_data: Dict[str, Any]) -> JudgeDecision:
         """Parse the judge response into a JudgeDecision"""
         return JudgeDecision(
@@ -360,33 +340,33 @@ Return your assessment as JSON:
                 "answer_completeness": decision_data.get("answer_completeness", 0.5),
                 "readability_level": decision_data.get("readability_level", "unknown"),
                 "ambiguities": decision_data.get("ambiguities", []),
-                "clarity_issues": decision_data.get("clarity_issues", [])
-            }
+                "clarity_issues": decision_data.get("clarity_issues", []),
+            },
         )
 
 
 class TechnicalJudge(BaseAgentWrapper):
     """Judge for technical accuracy in programming and technical content"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("technical_judge")
-        
+
         if not base_config:
             base_config = AgentConfig(
                 name="technical_judge",
                 instructions="""You are a technical accuracy specialist for programming and technical content.
 Verify code syntax, best practices, security considerations, and technical correctness.""",
-                model="gpt-4o",
-                temperature=0.2
+                model="gpt-4.1",
+                temperature=0.2,
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def judge_card(self, card: Card) -> JudgeDecision:
         """Judge a single card for technical accuracy"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             # Only judge technical content
             if not self._is_technical_content(card):
@@ -394,60 +374,60 @@ Verify code syntax, best practices, security considerations, and technical corre
                     approved=True,
                     score=1.0,
                     feedback="Non-technical content - no technical review needed",
-                    judge_name=self.config.name
+                    judge_name=self.config.name,
                 )
-            
+
             user_input = self._build_judgment_prompt(card)
             response = await self.execute(user_input)
-            
-            decision_data = json.loads(response) if isinstance(response, str) else response
-            decision = self._parse_decision(decision_data)
-            
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": 1,
-                    "approved": 1 if decision.approved else 0,
-                    "score": decision.score,
-                    "is_technical": True
-                }
+
+            decision_data = (
+                json.loads(response) if isinstance(response, str) else response
             )
-            
+            decision = self._parse_decision(decision_data)
+
             return decision
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"TechnicalJudge failed: {e}")
             return JudgeDecision(
                 approved=True,
                 score=0.5,
                 feedback=f"Technical judgment failed: {str(e)}",
-                judge_name=self.config.name
+                judge_name=self.config.name,
             )
-    
+
     def _is_technical_content(self, card: Card) -> bool:
         """Determine if card contains technical content requiring technical review"""
         technical_keywords = [
-            "code", "programming", "algorithm", "function", "class", "method",
-            "syntax", "API", "database", "SQL", "python", "javascript", "java",
-            "framework", "library", "development", "software", "technical"
+            "code",
+            "programming",
+            "algorithm",
+            "function",
+            "class",
+            "method",
+            "syntax",
+            "API",
+            "database",
+            "SQL",
+            "python",
+            "javascript",
+            "java",
+            "framework",
+            "library",
+            "development",
+            "software",
+            "technical",
         ]
-        
-        content = f"{card.front.question} {card.back.answer} {card.back.explanation}".lower()
+
+        content = (
+            f"{card.front.question} {card.back.answer} {card.back.explanation}".lower()
+        )
         subject = card.metadata.get("subject", "").lower()
-        
-        return any(keyword in content or keyword in subject for keyword in technical_keywords)
-    
+
+        return any(
+            keyword in content or keyword in subject for keyword in technical_keywords
+        )
+
     def _build_judgment_prompt(self, card: Card) -> str:
         """Build the judgment prompt for technical accuracy"""
         return f"""Evaluate this technical flashcard for accuracy and best practices:
@@ -478,7 +458,7 @@ Return your assessment as JSON:
     "improvement_suggestions": ["suggestion1", "suggestion2"],
     "detailed_feedback": "Comprehensive technical assessment"
 }}"""
-    
+
     def _parse_decision(self, decision_data: Dict[str, Any]) -> JudgeDecision:
         """Parse the judge response into a JudgeDecision"""
         return JudgeDecision(
@@ -489,75 +469,59 @@ Return your assessment as JSON:
             judge_name=self.config.name,
             metadata={
                 "syntax_errors": decision_data.get("syntax_errors", []),
-                "best_practice_violations": decision_data.get("best_practice_violations", []),
+                "best_practice_violations": decision_data.get(
+                    "best_practice_violations", []
+                ),
                 "security_issues": decision_data.get("security_issues", []),
                 "performance_concerns": decision_data.get("performance_concerns", []),
-                "tool_inaccuracies": decision_data.get("tool_inaccuracies", [])
-            }
+                "tool_inaccuracies": decision_data.get("tool_inaccuracies", []),
+            },
         )
 
 
 class CompletenessJudge(BaseAgentWrapper):
     """Judge for completeness and quality standards"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("completeness_judge")
-        
+
         if not base_config:
             base_config = AgentConfig(
                 name="completeness_judge",
                 instructions="""You are a completeness and quality assurance specialist.
 Ensure flashcards meet all requirements, have complete information,
 and maintain consistent quality standards.""",
-                model="gpt-4o-mini",
-                temperature=0.3
+                model="gpt-4.1-mini",
+                temperature=0.3,
             )
-        
+
         super().__init__(base_config, openai_client)
-    
+
     async def judge_card(self, card: Card) -> JudgeDecision:
         """Judge a single card for completeness"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             user_input = self._build_judgment_prompt(card)
             response = await self.execute(user_input)
-            
-            decision_data = json.loads(response) if isinstance(response, str) else response
-            decision = self._parse_decision(decision_data)
-            
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": 1,
-                    "approved": 1 if decision.approved else 0,
-                    "score": decision.score
-                }
+
+            decision_data = (
+                json.loads(response) if isinstance(response, str) else response
             )
-            
+            decision = self._parse_decision(decision_data)
+
             return decision
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"CompletenessJudge failed: {e}")
             return JudgeDecision(
                 approved=True,
                 score=0.5,
                 feedback=f"Completeness judgment failed: {str(e)}",
-                judge_name=self.config.name
+                judge_name=self.config.name,
             )
-    
+
     def _build_judgment_prompt(self, card: Card) -> str:
         """Build the judgment prompt for completeness assessment"""
         return f"""Evaluate this flashcard for completeness and quality standards:
@@ -588,7 +552,7 @@ Return your assessment as JSON:
     "improvement_suggestions": ["suggestion1", "suggestion2"],
     "detailed_feedback": "Comprehensive completeness assessment"
 }}"""
-    
+
     def _parse_decision(self, decision_data: Dict[str, Any]) -> JudgeDecision:
         """Parse the judge response into a JudgeDecision"""
         return JudgeDecision(
@@ -601,54 +565,54 @@ Return your assessment as JSON:
                 "missing_fields": decision_data.get("missing_fields", []),
                 "incomplete_sections": decision_data.get("incomplete_sections", []),
                 "metadata_issues": decision_data.get("metadata_issues", []),
-                "quality_concerns": decision_data.get("quality_concerns", [])
-            }
+                "quality_concerns": decision_data.get("quality_concerns", []),
+            },
         )
 
 
 class JudgeCoordinator(BaseAgentWrapper):
     """Coordinates multiple judges and synthesizes their decisions"""
-    
+
     def __init__(self, openai_client: AsyncOpenAI):
         config_manager = get_config_manager()
         base_config = config_manager.get_agent_config("judge_coordinator")
-        
+
         if not base_config:
             base_config = AgentConfig(
                 name="judge_coordinator",
                 instructions="""You are the quality assurance coordinator.
 Orchestrate the judging process and synthesize feedback from specialist judges.
 Balance speed with thoroughness in quality assessment.""",
-                model="gpt-4o-mini",
-                temperature=0.3
+                model="gpt-4.1-mini",
+                temperature=0.3,
             )
-        
+
         super().__init__(base_config, openai_client)
-        
+
         # Initialize specialist judges
         self.content_accuracy = ContentAccuracyJudge(openai_client)
         self.pedagogical = PedagogicalJudge(openai_client)
         self.clarity = ClarityJudge(openai_client)
         self.technical = TechnicalJudge(openai_client)
         self.completeness = CompletenessJudge(openai_client)
-    
+
     async def coordinate_judgment(
         self,
         cards: List[Card],
         enable_parallel: bool = True,
-        min_consensus: float = 0.6
+        min_consensus: float = 0.6,
     ) -> List[Tuple[Card, List[JudgeDecision], bool]]:
         """Coordinate judgment of multiple cards"""
-        start_time = datetime.now()
-        
+        datetime.now()
+
         try:
             results = []
-            
+
             if enable_parallel:
                 # Process all cards in parallel
                 tasks = [self._judge_single_card(card, min_consensus) for card in cards]
                 card_results = await asyncio.gather(*tasks, return_exceptions=True)
-                
+
                 for card, result in zip(cards, card_results):
                     if isinstance(result, Exception):
                         logger.error(f"Parallel judgment failed for card: {result}")
@@ -664,62 +628,41 @@ Balance speed with thoroughness in quality assessment.""",
                     except Exception as e:
                         logger.error(f"Sequential judgment failed for card: {e}")
                         results.append((card, [], False))
-            
-                         # Calculate summary statistics
-             total_cards = len(cards)
-             approved_cards = len([result for _, _, approved in results if approved])
-            
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=True,
-                metadata={
-                    "cards_judged": total_cards,
-                    "cards_approved": approved_cards,
-                    "approval_rate": approved_cards / total_cards if total_cards > 0 else 0,
-                    "parallel_processing": enable_parallel
-                }
+
+            # Calculate summary statistics
+            total_cards = len(cards)
+            approved_cards = len([result for _, _, approved in results if approved])
+
+            logger.info(
+                f"Judge coordination complete: {approved_cards}/{total_cards} cards approved"
             )
-            
-            logger.info(f"Judge coordination complete: {approved_cards}/{total_cards} cards approved")
             return results
-            
+
         except Exception as e:
-            record_agent_execution(
-                agent_name=self.config.name,
-                start_time=start_time,
-                end_time=datetime.now(),
-                success=False,
-                error_message=str(e)
-            )
-            
             logger.error(f"Judge coordination failed: {e}")
             raise
-    
+
     async def _judge_single_card(
-        self,
-        card: Card,
-        min_consensus: float
+        self, card: Card, min_consensus: float
     ) -> Tuple[Card, List[JudgeDecision], bool]:
         """Judge a single card with all relevant judges"""
-        
+
         # Determine which judges to use based on card content
         judges = [
             self.content_accuracy,
             self.pedagogical,
             self.clarity,
-            self.completeness
+            self.completeness,
         ]
-        
+
         # Add technical judge only for technical content
         if self.technical._is_technical_content(card):
             judges.append(self.technical)
-        
+
         # Execute all judges in parallel
         judge_tasks = [judge.judge_card(card) for judge in judges]
         decisions = await asyncio.gather(*judge_tasks, return_exceptions=True)
-        
+
         # Filter out failed decisions
         valid_decisions = []
         for decision in decisions:
@@ -727,15 +670,35 @@ Balance speed with thoroughness in quality assessment.""",
                 valid_decisions.append(decision)
             else:
                 logger.warning(f"Judge decision failed: {decision}")
-        
+
         # Calculate consensus
         if not valid_decisions:
             return (card, [], False)
-        
+
         approval_votes = len([d for d in valid_decisions if d.approved])
         consensus_score = approval_votes / len(valid_decisions)
-        
+
         # Determine final approval based on consensus
         final_approval = consensus_score >= min_consensus
-        
-        return (card, valid_decisions, final_approval)
+
+        # Enhanced logging for judge coordination
+        logger.info("🏛️ JUDGE COORDINATION RESULT:")
+        logger.info(f"   Card: {card.front.question[:80]}...")
+        logger.info(f"   👥 Judges Consulted: {len(valid_decisions)}")
+        logger.info(f"   ✅ Approval Votes: {approval_votes}/{len(valid_decisions)}")
+        logger.info(
+            f"   📊 Consensus Score: {consensus_score:.2f} (min: {min_consensus:.2f})"
+        )
+        logger.info(
+            f"   🏆 Final Decision: {'APPROVED' if final_approval else 'REJECTED'}"
+        )
+
+        if not final_approval:
+            logger.info("   📝 Rejection Reasons:")
+            for decision in valid_decisions:
+                if not decision.approved:
+                    logger.info(
+                        f"     • {decision.judge_name}: {decision.feedback[:100]}..."
+                    )
+
+        return (card, valid_decisions, final_approval)

ankigen_core/agents/performance.py

@@ -5,27 +5,26 @@ import time
 import hashlib
 from typing import Dict, Any, List, Optional, Callable, TypeVar, Generic
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
 from functools import wraps, lru_cache
-import pickle
 import json
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card
 
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 @dataclass
 class CacheConfig:
     """Configuration for agent response caching"""
+
     enable_caching: bool = True
     cache_ttl: int = 3600  # seconds
     max_cache_size: int = 1000
     cache_backend: str = "memory"  # "memory" or "file"
     cache_directory: Optional[str] = None
-    
+
     def __post_init__(self):
         if self.cache_backend == "file" and not self.cache_directory:
             self.cache_directory = "cache/agents"
@@ -34,6 +33,7 @@ class CacheConfig:
 @dataclass
 class PerformanceConfig:
     """Configuration for performance optimizations"""
+
     enable_batch_processing: bool = True
     max_batch_size: int = 10
     batch_timeout: float = 2.0  # seconds
@@ -47,16 +47,17 @@ class PerformanceConfig:
 @dataclass
 class CacheEntry(Generic[T]):
     """Cache entry with metadata"""
+
     value: T
     created_at: float
     access_count: int = 0
     last_accessed: float = field(default_factory=time.time)
     cache_key: str = ""
-    
+
     def is_expired(self, ttl: int) -> bool:
         """Check if cache entry is expired"""
         return time.time() - self.created_at > ttl
-    
+
     def touch(self):
         """Update access metadata"""
         self.access_count += 1
@@ -65,60 +66,56 @@ class CacheEntry(Generic[T]):
 
 class MemoryCache(Generic[T]):
     """In-memory cache with LRU eviction"""
-    
+
     def __init__(self, config: CacheConfig):
         self.config = config
         self._cache: Dict[str, CacheEntry[T]] = {}
         self._access_order: List[str] = []
         self._lock = asyncio.Lock()
-    
+
     async def get(self, key: str) -> Optional[T]:
         """Get value from cache"""
         async with self._lock:
             entry = self._cache.get(key)
             if not entry:
                 return None
-            
+
             if entry.is_expired(self.config.cache_ttl):
                 await self._remove(key)
                 return None
-            
+
             entry.touch()
             self._update_access_order(key)
-            
+
             logger.debug(f"Cache hit for key: {key[:20]}...")
             return entry.value
-    
+
     async def set(self, key: str, value: T) -> None:
         """Set value in cache"""
         async with self._lock:
             # Check if we need to evict entries
             if len(self._cache) >= self.config.max_cache_size:
                 await self._evict_lru()
-            
-            entry = CacheEntry(
-                value=value,
-                created_at=time.time(),
-                cache_key=key
-            )
-            
+
+            entry = CacheEntry(value=value, created_at=time.time(), cache_key=key)
+
             self._cache[key] = entry
             self._update_access_order(key)
-            
+
             logger.debug(f"Cache set for key: {key[:20]}...")
-    
+
     async def remove(self, key: str) -> bool:
         """Remove entry from cache"""
         async with self._lock:
             return await self._remove(key)
-    
+
     async def clear(self) -> None:
         """Clear all cache entries"""
         async with self._lock:
             self._cache.clear()
             self._access_order.clear()
             logger.info("Cache cleared")
-    
+
     async def _remove(self, key: str) -> bool:
         """Internal remove method"""
         if key in self._cache:
@@ -127,25 +124,25 @@ class MemoryCache(Generic[T]):
                 self._access_order.remove(key)
             return True
         return False
-    
+
     async def _evict_lru(self) -> None:
         """Evict least recently used entries"""
         if not self._access_order:
             return
-        
+
         # Remove oldest entries
-        to_remove = self._access_order[:len(self._access_order) // 4]  # Remove 25%
+        to_remove = self._access_order[: len(self._access_order) // 4]  # Remove 25%
         for key in to_remove:
             await self._remove(key)
-        
+
         logger.debug(f"Evicted {len(to_remove)} cache entries")
-    
+
     def _update_access_order(self, key: str) -> None:
         """Update access order for LRU tracking"""
         if key in self._access_order:
             self._access_order.remove(key)
         self._access_order.append(key)
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics"""
         total_accesses = sum(entry.access_count for entry in self._cache.values())
@@ -153,137 +150,134 @@ class MemoryCache(Generic[T]):
             "entries": len(self._cache),
             "max_size": self.config.max_cache_size,
             "total_accesses": total_accesses,
-            "hit_rate": total_accesses / max(1, len(self._cache))
+            "hit_rate": total_accesses / max(1, len(self._cache)),
         }
 
 
 class BatchProcessor:
     """Batch processor for agent requests"""
-    
+
     def __init__(self, config: PerformanceConfig):
         self.config = config
         self._batches: Dict[str, List[Dict[str, Any]]] = {}
         self._batch_timers: Dict[str, asyncio.Task] = {}
         self._lock = asyncio.Lock()
-    
+
     async def add_request(
-        self,
-        batch_key: str,
-        request_data: Dict[str, Any],
-        processor_func: Callable
+        self, batch_key: str, request_data: Dict[str, Any], processor_func: Callable
     ) -> Any:
         """Add request to batch for processing"""
-        
+
         if not self.config.enable_batch_processing:
             # Process immediately if batching is disabled
             return await processor_func([request_data])
-        
+
         async with self._lock:
             # Initialize batch if needed
             if batch_key not in self._batches:
                 self._batches[batch_key] = []
                 self._start_batch_timer(batch_key, processor_func)
-            
+
             # Add request to batch
             self._batches[batch_key].append(request_data)
-            
+
             # Process immediately if batch is full
             if len(self._batches[batch_key]) >= self.config.max_batch_size:
                 return await self._process_batch(batch_key, processor_func)
-            
+
             # Wait for timer or batch completion
-            return await self._wait_for_batch_result(batch_key, request_data, processor_func)
-    
+            return await self._wait_for_batch_result(
+                batch_key, request_data, processor_func
+            )
+
     def _start_batch_timer(self, batch_key: str, processor_func: Callable) -> None:
         """Start timer for batch processing"""
+
         async def timer():
             await asyncio.sleep(self.config.batch_timeout)
             async with self._lock:
                 if batch_key in self._batches and self._batches[batch_key]:
                     await self._process_batch(batch_key, processor_func)
-        
+
         self._batch_timers[batch_key] = asyncio.create_task(timer())
-    
-    async def _process_batch(self, batch_key: str, processor_func: Callable) -> List[Any]:
+
+    async def _process_batch(
+        self, batch_key: str, processor_func: Callable
+    ) -> List[Any]:
         """Process accumulated batch"""
         if batch_key not in self._batches:
             return []
-        
+
         batch = self._batches.pop(batch_key)
-        
+
         # Cancel timer
         if batch_key in self._batch_timers:
             self._batch_timers[batch_key].cancel()
             del self._batch_timers[batch_key]
-        
+
         if not batch:
             return []
-        
+
         logger.debug(f"Processing batch {batch_key} with {len(batch)} requests")
-        
+
         try:
             # Process the batch
             results = await processor_func(batch)
             return results if isinstance(results, list) else [results]
-        
+
         except Exception as e:
             logger.error(f"Batch processing failed for {batch_key}: {e}")
             raise
-    
+
     async def _wait_for_batch_result(
-        self,
-        batch_key: str,
-        request_data: Dict[str, Any],
-        processor_func: Callable
+        self, batch_key: str, request_data: Dict[str, Any], processor_func: Callable
     ) -> Any:
         """Wait for batch processing to complete"""
         # This is a simplified implementation
         # In a real implementation, you'd use events/conditions to coordinate
         # between requests in the same batch
-        
+
         while batch_key in self._batches:
             await asyncio.sleep(0.1)
-        
+
         # For now, process individually as fallback
         return await processor_func([request_data])
 
 
 class RequestDeduplicator:
     """Deduplicates identical agent requests"""
-    
+
     def __init__(self):
         self._pending_requests: Dict[str, asyncio.Future] = {}
         self._lock = asyncio.Lock()
-    
+
     @lru_cache(maxsize=1000)
     def _generate_request_hash(self, request_data: str) -> str:
         """Generate hash for request deduplication"""
         return hashlib.md5(request_data.encode()).hexdigest()
-    
+
     async def deduplicate_request(
-        self,
-        request_data: Dict[str, Any],
-        processor_func: Callable
+        self, request_data: Dict[str, Any], processor_func: Callable
     ) -> Any:
         """Deduplicate and process request"""
-        
+
         # Generate hash for deduplication
         request_str = json.dumps(request_data, sort_keys=True)
         request_hash = self._generate_request_hash(request_str)
-        
+
         async with self._lock:
             # Check if request is already pending
             if request_hash in self._pending_requests:
                 logger.debug(f"Deduplicating request: {request_hash[:16]}...")
                 return await self._pending_requests[request_hash]
-            
+
             # Create future for this request
-            future = asyncio.create_task(self._process_unique_request(
-                request_hash, request_data, processor_func
-            ))
-            
+            future = asyncio.create_task(
+                self._process_unique_request(request_hash, request_data, processor_func)
+            )
+
             self._pending_requests[request_hash] = future
-            
+
             try:
                 result = await future
                 return result
@@ -291,12 +285,9 @@ class RequestDeduplicator:
                 # Clean up completed request
                 async with self._lock:
                     self._pending_requests.pop(request_hash, None)
-    
+
     async def _process_unique_request(
-        self,
-        request_hash: str,
-        request_data: Dict[str, Any],
-        processor_func: Callable
+        self, request_hash: str, request_data: Dict[str, Any], processor_func: Callable
     ) -> Any:
         """Process unique request"""
         logger.debug(f"Processing unique request: {request_hash[:16]}...")
@@ -305,36 +296,41 @@ class RequestDeduplicator:
 
 class PerformanceOptimizer:
     """Main performance optimization coordinator"""
-    
+
     def __init__(self, config: PerformanceConfig):
         self.config = config
-        self.cache = MemoryCache(config.cache_config) if config.enable_response_caching else None
-        self.batch_processor = BatchProcessor(config) if config.enable_batch_processing else None
-        self.deduplicator = RequestDeduplicator() if config.enable_request_deduplication else None
+        self.cache = (
+            MemoryCache(config.cache_config) if config.enable_response_caching else None
+        )
+        self.batch_processor = (
+            BatchProcessor(config) if config.enable_batch_processing else None
+        )
+        self.deduplicator = (
+            RequestDeduplicator() if config.enable_request_deduplication else None
+        )
         self._semaphore = asyncio.Semaphore(config.max_concurrent_requests)
-    
+
     async def optimize_agent_call(
         self,
         agent_name: str,
         request_data: Dict[str, Any],
         processor_func: Callable,
-        cache_key_generator: Optional[Callable[[Dict[str, Any]], str]] = None
+        cache_key_generator: Optional[Callable[[Dict[str, Any]], str]] = None,
     ) -> Any:
         """Optimize agent call with caching, batching, and deduplication"""
-        
+
         # Generate cache key
         cache_key = None
         if self.cache and cache_key_generator:
             cache_key = cache_key_generator(request_data)
-            
+
             # Check cache first
             cached_result = await self.cache.get(cache_key)
             if cached_result is not None:
                 return cached_result
-        
+
         # Apply rate limiting
         async with self._semaphore:
-            
             # Apply deduplication
             if self.deduplicator and self.config.enable_request_deduplication:
                 result = await self.deduplicator.deduplicate_request(
@@ -342,18 +338,15 @@ class PerformanceOptimizer:
                 )
             else:
                 result = await processor_func(request_data)
-            
+
             # Cache result
             if self.cache and cache_key and result is not None:
                 await self.cache.set(cache_key, result)
-            
+
             return result
-    
+
     async def optimize_batch_processing(
-        self,
-        batch_key: str,
-        request_data: Dict[str, Any],
-        processor_func: Callable
+        self, batch_key: str, request_data: Dict[str, Any], processor_func: Callable
     ) -> Any:
         """Optimize using batch processing"""
         if self.batch_processor:
@@ -362,7 +355,7 @@ class PerformanceOptimizer:
             )
         else:
             return await processor_func([request_data])
-    
+
     def get_performance_stats(self) -> Dict[str, Any]:
         """Get performance optimization statistics"""
         stats = {
@@ -375,12 +368,12 @@ class PerformanceOptimizer:
             "concurrency": {
                 "max_concurrent": self.config.max_concurrent_requests,
                 "current_available": self._semaphore._value,
-            }
+            },
         }
-        
+
         if self.cache:
             stats["cache"] = self.cache.get_stats()
-        
+
         return stats
 
 
@@ -388,7 +381,9 @@ class PerformanceOptimizer:
 _global_optimizer: Optional[PerformanceOptimizer] = None
 
 
-def get_performance_optimizer(config: Optional[PerformanceConfig] = None) -> PerformanceOptimizer:
+def get_performance_optimizer(
+    config: Optional[PerformanceConfig] = None,
+) -> PerformanceOptimizer:
     """Get global performance optimizer instance"""
     global _global_optimizer
     if _global_optimizer is None:
@@ -399,121 +394,82 @@ def get_performance_optimizer(config: Optional[PerformanceConfig] = None) -> Per
 # Decorators for performance optimization
 def cache_response(cache_key_func: Callable[[Any], str], ttl: int = 3600):
     """Decorator to cache function responses"""
+
     def decorator(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
             optimizer = get_performance_optimizer()
             if not optimizer.cache:
                 return await func(*args, **kwargs)
-            
+
             # Generate cache key
             cache_key = cache_key_func(*args, **kwargs)
-            
+
             # Check cache
             cached_result = await optimizer.cache.get(cache_key)
             if cached_result is not None:
                 return cached_result
-            
+
             # Execute function
             result = await func(*args, **kwargs)
-            
+
             # Cache result
             if result is not None:
                 await optimizer.cache.set(cache_key, result)
-            
+
             return result
-        
+
         return wrapper
+
     return decorator
 
 
 def rate_limit(max_concurrent: int = 5):
     """Decorator to apply rate limiting"""
     semaphore = asyncio.Semaphore(max_concurrent)
-    
+
     def decorator(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
             async with semaphore:
                 return await func(*args, **kwargs)
+
         return wrapper
+
     return decorator
 
 
 # Utility functions for cache key generation
-def generate_card_cache_key(topic: str, subject: str, num_cards: int, difficulty: str, **kwargs) -> str:
+def generate_card_cache_key(
+    topic: str, subject: str, num_cards: int, difficulty: str, **kwargs
+) -> str:
     """Generate cache key for card generation"""
     key_data = {
         "topic": topic,
         "subject": subject,
         "num_cards": num_cards,
         "difficulty": difficulty,
-        "context": kwargs.get("context", {})
+        "context": kwargs.get("context", {}),
     }
     key_str = json.dumps(key_data, sort_keys=True)
     return f"cards:{hashlib.md5(key_str.encode()).hexdigest()}"
 
 
-def generate_judgment_cache_key(cards: List[Card], judgment_type: str = "general") -> str:
+def generate_judgment_cache_key(
+    cards: List[Card], judgment_type: str = "general"
+) -> str:
     """Generate cache key for card judgment"""
     # Use card content to generate stable hash
     card_data = []
     for card in cards:
-        card_data.append({
-            "question": card.front.question,
-            "answer": card.back.answer,
-            "type": card.card_type
-        })
-    
-    key_data = {
-        "cards": card_data,
-        "judgment_type": judgment_type
-    }
+        card_data.append(
+            {
+                "question": card.front.question,
+                "answer": card.back.answer,
+                "type": card.card_type,
+            }
+        )
+
+    key_data = {"cards": card_data, "judgment_type": judgment_type}
     key_str = json.dumps(key_data, sort_keys=True)
     return f"judgment:{hashlib.md5(key_str.encode()).hexdigest()}"
-
-
-# Performance monitoring
-class PerformanceMonitor:
-    """Monitor performance metrics"""
-    
-    def __init__(self):
-        self._metrics: Dict[str, List[float]] = {}
-        self._lock = asyncio.Lock()
-    
-    async def record_execution_time(self, operation: str, execution_time: float):
-        """Record execution time for an operation"""
-        async with self._lock:
-            if operation not in self._metrics:
-                self._metrics[operation] = []
-            
-            self._metrics[operation].append(execution_time)
-            
-            # Keep only recent metrics (last 1000)
-            if len(self._metrics[operation]) > 1000:
-                self._metrics[operation] = self._metrics[operation][-1000:]
-    
-    def get_performance_report(self) -> Dict[str, Dict[str, float]]:
-        """Get performance report for all operations"""
-        report = {}
-        
-        for operation, times in self._metrics.items():
-            if times:
-                report[operation] = {
-                    "count": len(times),
-                    "avg_time": sum(times) / len(times),
-                    "min_time": min(times),
-                    "max_time": max(times),
-                    "p95_time": sorted(times)[int(len(times) * 0.95)] if len(times) > 20 else max(times)
-                }
-        
-        return report
-
-
-# Global performance monitor
-_global_monitor = PerformanceMonitor()
-
-
-def get_performance_monitor() -> PerformanceMonitor:
-    """Get global performance monitor"""
-    return _global_monitor

ankigen_core/agents/schemas.py

@@ -0,0 +1,136 @@
+"""
+Pydantic schemas for structured outputs from agents.
+These schemas ensure type safety and eliminate JSON parsing errors.
+"""
+
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class DifficultyLevel(str, Enum):
+    """Difficulty levels for flashcards"""
+
+    BEGINNER = "beginner"
+    INTERMEDIATE = "intermediate"
+    ADVANCED = "advanced"
+
+
+class CardType(str, Enum):
+    """Types of flashcards"""
+
+    BASIC = "basic"
+    CLOZE = "cloze"
+
+
+class CardFrontSchema(BaseModel):
+    """Schema for the front of a flashcard"""
+
+    question: str = Field(..., description="The question or prompt for the flashcard")
+
+
+class CardBackSchema(BaseModel):
+    """Schema for the back of a flashcard"""
+
+    answer: str = Field(..., description="The main answer to the question")
+    explanation: str = Field(..., description="Detailed explanation of the answer")
+    example: str = Field(..., description="A concrete example illustrating the concept")
+
+
+class CardMetadataSchema(BaseModel):
+    """Schema for flashcard metadata"""
+
+    topic: str = Field(..., description="The main topic of the card")
+    subject: str = Field(..., description="The subject area (e.g., Biology, History)")
+    difficulty: DifficultyLevel = Field(..., description="The difficulty level")
+    tags: Optional[List[str]] = Field(
+        None, description="Relevant tags for categorization"
+    )
+    learning_outcomes: Optional[List[str]] = Field(
+        None, description="What the learner should achieve"
+    )
+    prerequisites: Optional[List[str]] = Field(
+        None, description="Required prior knowledge"
+    )
+    related_concepts: Optional[List[str]] = Field(
+        None, description="Related concepts to explore"
+    )
+    estimated_time: Optional[str] = Field(None, description="Estimated time to learn")
+    common_mistakes: Optional[List[str]] = Field(
+        None, description="Common mistakes to avoid"
+    )
+    memory_aids: Optional[List[str]] = Field(
+        None, description="Memory aids or mnemonics"
+    )
+    real_world_applications: Optional[List[str]] = Field(
+        None, description="Real-world applications"
+    )
+
+
+class CardSchema(BaseModel):
+    """Complete schema for a flashcard"""
+
+    card_type: CardType = Field(..., description="The type of flashcard")
+    front: CardFrontSchema = Field(..., description="The front of the card")
+    back: CardBackSchema = Field(..., description="The back of the card")
+    metadata: CardMetadataSchema = Field(..., description="Metadata about the card")
+    enhancement_notes: Optional[str] = Field(
+        None, description="Notes about enhancements made"
+    )
+
+
+class CardsGenerationSchema(BaseModel):
+    """Schema for multiple cards generation"""
+
+    cards: List[CardSchema] = Field(..., description="List of generated flashcards")
+
+
+class JudgeDecisionSchema(BaseModel):
+    """Schema for judge decisions"""
+
+    approved: bool = Field(..., description="Whether the card is approved")
+    score: float = Field(
+        ..., ge=0.0, le=1.0, description="Quality score between 0 and 1"
+    )
+    feedback: str = Field(..., description="Detailed feedback about the card")
+    improvements: Optional[List[str]] = Field(
+        None, description="Suggested improvements"
+    )
+    reasoning: str = Field(..., description="Detailed reasoning for the decision")
+    confidence: float = Field(
+        ..., ge=0.0, le=1.0, description="Confidence in the decision"
+    )
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Additional metadata")
+
+
+class EnhancementSchema(BaseModel):
+    """Schema for card enhancements"""
+
+    enhanced_card: CardSchema = Field(..., description="The enhanced flashcard")
+    enhancement_summary: str = Field(..., description="Summary of what was enhanced")
+    enhancement_details: Optional[Dict[str, Any]] = Field(
+        None, description="Detailed enhancement information"
+    )
+
+
+class GenerationRequestSchema(BaseModel):
+    """Schema for generation requests"""
+
+    topic: str = Field(..., description="The topic to generate cards for")
+    subject: str = Field(..., description="The subject area")
+    num_cards: int = Field(..., ge=1, le=20, description="Number of cards to generate")
+    difficulty: DifficultyLevel = Field(..., description="Target difficulty level")
+    context: Optional[Dict[str, Any]] = Field(None, description="Additional context")
+    preferences: Optional[Dict[str, Any]] = Field(None, description="User preferences")
+
+
+class TokenUsageSchema(BaseModel):
+    """Schema for token usage tracking"""
+
+    prompt_tokens: int = Field(..., ge=0, description="Number of tokens in the prompt")
+    completion_tokens: int = Field(
+        ..., ge=0, description="Number of tokens in the completion"
+    )
+    total_tokens: int = Field(..., ge=0, description="Total tokens used")
+    estimated_cost: float = Field(..., ge=0.0, description="Estimated cost in USD")
+    model: str = Field(..., description="Model used for the request")

ankigen_core/agents/security.py

@@ -5,7 +5,7 @@ import hashlib
 import re
 from typing import Dict, Any, Optional, List
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import datetime
 from collections import defaultdict
 import asyncio
 
@@ -15,6 +15,7 @@ from ankigen_core.logging import logger
 @dataclass
 class RateLimitConfig:
     """Configuration for rate limiting"""
+
     requests_per_minute: int = 60
     requests_per_hour: int = 1000
     burst_limit: int = 10
@@ -24,243 +25,260 @@ class RateLimitConfig:
 @dataclass
 class SecurityConfig:
     """Security configuration for agents"""
+
     enable_input_validation: bool = True
     enable_output_filtering: bool = True
     enable_rate_limiting: bool = True
     max_input_length: int = 10000
     max_output_length: int = 50000
     blocked_patterns: List[str] = field(default_factory=list)
-    allowed_file_extensions: List[str] = field(default_factory=lambda: ['.txt', '.md', '.json', '.yaml'])
-    
+    allowed_file_extensions: List[str] = field(
+        default_factory=lambda: [".txt", ".md", ".json", ".yaml"]
+    )
+
     def __post_init__(self):
         if not self.blocked_patterns:
             self.blocked_patterns = [
-                r'(?i)(api[_\-]?key|secret|password|token|credential)',
-                r'(?i)(sk-[a-zA-Z0-9]{48,})',  # OpenAI API key pattern
-                r'(?i)(access[_\-]?token)',
-                r'(?i)(private[_\-]?key)',
-                r'(?i)(<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>)',  # Script tags
-                r'(?i)(javascript:|data:|vbscript:)',  # URL schemes
+                r"(?i)(api[_\-]?key|secret|password|token|credential)",
+                r"(?i)(sk-[a-zA-Z0-9]{48,})",  # OpenAI API key pattern
+                r"(?i)(access[_\-]?token)",
+                r"(?i)(private[_\-]?key)",
+                r"(?i)(<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>)",  # Script tags
+                r"(?i)(javascript:|data:|vbscript:)",  # URL schemes
             ]
 
 
 class RateLimiter:
     """Rate limiter for API calls and agent executions"""
-    
+
     def __init__(self, config: RateLimitConfig):
         self.config = config
         self._requests: Dict[str, List[float]] = defaultdict(list)
         self._locks: Dict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
-    
+
     async def check_rate_limit(self, identifier: str) -> bool:
         """Check if request is within rate limits"""
         async with self._locks[identifier]:
             now = time.time()
-            
+
             # Clean old requests
             self._requests[identifier] = [
-                req_time for req_time in self._requests[identifier]
+                req_time
+                for req_time in self._requests[identifier]
                 if now - req_time < 3600  # Keep last hour
             ]
-            
+
             recent_requests = self._requests[identifier]
-            
+
             # Check burst limit (last minute)
             last_minute = [req for req in recent_requests if now - req < 60]
             if len(last_minute) >= self.config.burst_limit:
                 logger.warning(f"Burst limit exceeded for {identifier}")
                 return False
-            
+
             # Check per-minute limit
             if len(last_minute) >= self.config.requests_per_minute:
                 logger.warning(f"Per-minute rate limit exceeded for {identifier}")
                 return False
-            
+
             # Check per-hour limit
             if len(recent_requests) >= self.config.requests_per_hour:
                 logger.warning(f"Per-hour rate limit exceeded for {identifier}")
                 return False
-            
+
             # Record this request
             self._requests[identifier].append(now)
             return True
-    
+
     def get_reset_time(self, identifier: str) -> Optional[datetime]:
         """Get when rate limits will reset for identifier"""
         if identifier not in self._requests:
             return None
-        
+
         now = time.time()
-        recent_requests = [
-            req for req in self._requests[identifier]
-            if now - req < 60
-        ]
-        
+        recent_requests = [req for req in self._requests[identifier] if now - req < 60]
+
         if len(recent_requests) >= self.config.requests_per_minute:
             oldest_request = min(recent_requests)
             return datetime.fromtimestamp(oldest_request + 60)
-        
+
         return None
 
 
 class SecurityValidator:
     """Security validator for agent inputs and outputs"""
-    
+
     def __init__(self, config: SecurityConfig):
         self.config = config
-        self._blocked_patterns = [re.compile(pattern) for pattern in config.blocked_patterns]
-    
+        self._blocked_patterns = [
+            re.compile(pattern) for pattern in config.blocked_patterns
+        ]
+
     def validate_input(self, input_text: str, source: str = "unknown") -> bool:
         """Validate input for security issues"""
         if not self.config.enable_input_validation:
             return True
-        
+
         try:
             # Check input length
             if len(input_text) > self.config.max_input_length:
                 logger.warning(f"Input too long from {source}: {len(input_text)} chars")
                 return False
-            
+
             # Check for blocked patterns
             for pattern in self._blocked_patterns:
                 if pattern.search(input_text):
                     logger.warning(f"Blocked pattern detected in input from {source}")
                     return False
-            
+
             # Check for suspicious content
             if self._contains_suspicious_content(input_text):
                 logger.warning(f"Suspicious content detected in input from {source}")
                 return False
-            
+
             return True
-            
+
         except Exception as e:
             logger.error(f"Error validating input from {source}: {e}")
             return False
-    
+
     def validate_output(self, output_text: str, agent_name: str = "unknown") -> bool:
         """Validate output for security issues"""
         if not self.config.enable_output_filtering:
             return True
-        
+
         try:
             # Check output length
             if len(output_text) > self.config.max_output_length:
-                logger.warning(f"Output too long from {agent_name}: {len(output_text)} chars")
+                logger.warning(
+                    f"Output too long from {agent_name}: {len(output_text)} chars"
+                )
                 return False
-            
+
             # Check for leaked sensitive information
             for pattern in self._blocked_patterns:
                 if pattern.search(output_text):
-                    logger.warning(f"Potential data leak detected in output from {agent_name}")
+                    logger.warning(
+                        f"Potential data leak detected in output from {agent_name}"
+                    )
                     return False
-            
+
             return True
-            
+
         except Exception as e:
             logger.error(f"Error validating output from {agent_name}: {e}")
             return False
-    
+
     def sanitize_input(self, input_text: str) -> str:
         """Sanitize input by removing potentially dangerous content"""
         try:
             # Remove HTML/XML tags
-            sanitized = re.sub(r'<[^>]+>', '', input_text)
-            
+            sanitized = re.sub(r"<[^>]+>", "", input_text)
+
             # Remove suspicious URLs
-            sanitized = re.sub(r'(?i)(javascript:|data:|vbscript:)[^\s]*', '[URL_REMOVED]', sanitized)
-            
+            sanitized = re.sub(
+                r"(?i)(javascript:|data:|vbscript:)[^\s]*", "[URL_REMOVED]", sanitized
+            )
+
             # Truncate if too long
             if len(sanitized) > self.config.max_input_length:
-                sanitized = sanitized[:self.config.max_input_length] + "...[TRUNCATED]"
-            
+                sanitized = sanitized[: self.config.max_input_length] + "...[TRUNCATED]"
+
             return sanitized
-            
+
         except Exception as e:
             logger.error(f"Error sanitizing input: {e}")
             return input_text[:1000]  # Return truncated original as fallback
-    
+
     def sanitize_output(self, output_text: str) -> str:
         """Sanitize output by removing sensitive information"""
         try:
             sanitized = output_text
-            
+
             # Replace potential API keys or secrets
             for pattern in self._blocked_patterns:
-                sanitized = pattern.sub('[REDACTED]', sanitized)
-            
+                sanitized = pattern.sub("[REDACTED]", sanitized)
+
             # Truncate if too long
             if len(sanitized) > self.config.max_output_length:
-                sanitized = sanitized[:self.config.max_output_length] + "...[TRUNCATED]"
-            
+                sanitized = (
+                    sanitized[: self.config.max_output_length] + "...[TRUNCATED]"
+                )
+
             return sanitized
-            
+
         except Exception as e:
             logger.error(f"Error sanitizing output: {e}")
             return output_text[:5000]  # Return truncated original as fallback
-    
+
     def _contains_suspicious_content(self, text: str) -> bool:
         """Check for suspicious content patterns"""
         suspicious_patterns = [
-            r'(?i)(\beval\s*\()',  # eval() calls
-            r'(?i)(\bexec\s*\()',  # exec() calls
-            r'(?i)(__import__)',   # Dynamic imports
-            r'(?i)(subprocess|os\.system)',  # System commands
-            r'(?i)(file://|ftp://)',  # File/FTP URLs
-            r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b',  # IP addresses
+            r"(?i)(\beval\s*\()",  # eval() calls
+            r"(?i)(\bexec\s*\()",  # exec() calls
+            r"(?i)(__import__)",  # Dynamic imports
+            r"(?i)(subprocess|os\.system)",  # System commands
+            r"(?i)(file://|ftp://)",  # File/FTP URLs
+            r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b",  # IP addresses
         ]
-        
+
         for pattern in suspicious_patterns:
             if re.search(pattern, text):
                 return True
-        
+
         return False
 
 
 class SecureAgentWrapper:
     """Secure wrapper for agent execution with rate limiting and validation"""
-    
-    def __init__(self, base_agent, rate_limiter: RateLimiter, validator: SecurityValidator):
+
+    def __init__(
+        self, base_agent, rate_limiter: RateLimiter, validator: SecurityValidator
+    ):
         self.base_agent = base_agent
         self.rate_limiter = rate_limiter
         self.validator = validator
         self._identifier = self._generate_identifier()
-    
+
     def _generate_identifier(self) -> str:
         """Generate unique identifier for rate limiting"""
-        agent_name = getattr(self.base_agent, 'config', {}).get('name', 'unknown')
+        agent_name = getattr(self.base_agent, "config", {}).get("name", "unknown")
         # Include agent name and some randomness for fairness
-        return hashlib.md5(f"{agent_name}_{id(self.base_agent)}".encode()).hexdigest()[:16]
-    
-    async def secure_execute(self, user_input: str, context: Dict[str, Any] = None) -> Any:
+        return hashlib.md5(f"{agent_name}_{id(self.base_agent)}".encode()).hexdigest()[
+            :16
+        ]
+
+    async def secure_execute(
+        self, user_input: str, context: Dict[str, Any] = None
+    ) -> Any:
         """Execute agent with security checks and rate limiting"""
-        
+
         # Rate limiting check
         if not await self.rate_limiter.check_rate_limit(self._identifier):
             reset_time = self.rate_limiter.get_reset_time(self._identifier)
             raise SecurityError(f"Rate limit exceeded. Reset at: {reset_time}")
-        
+
         # Input validation
         if not self.validator.validate_input(user_input, self._identifier):
             raise SecurityError("Input validation failed")
-        
+
         # Sanitize input
         sanitized_input = self.validator.sanitize_input(user_input)
-        
+
         try:
             # Execute the base agent
             result = await self.base_agent.execute(sanitized_input, context)
-            
+
             # Validate output
             if isinstance(result, str):
                 if not self.validator.validate_output(result, self._identifier):
                     raise SecurityError("Output validation failed")
-                
+
                 # Sanitize output
                 result = self.validator.sanitize_output(result)
-            
+
             return result
-            
+
         except Exception as e:
             logger.error(f"Secure execution failed for {self._identifier}: {e}")
             raise
@@ -268,6 +286,7 @@ class SecureAgentWrapper:
 
 class SecurityError(Exception):
     """Custom exception for security-related errors"""
+
     pass
 
 
@@ -284,7 +303,9 @@ def get_rate_limiter(config: Optional[RateLimitConfig] = None) -> RateLimiter:
     return _global_rate_limiter
 
 
-def get_security_validator(config: Optional[SecurityConfig] = None) -> SecurityValidator:
+def get_security_validator(
+    config: Optional[SecurityConfig] = None,
+) -> SecurityValidator:
     """Get global security validator instance"""
     global _global_validator
     if _global_validator is None:
@@ -292,8 +313,11 @@ def get_security_validator(config: Optional[SecurityConfig] = None) -> SecurityV
     return _global_validator
 
 
-def create_secure_agent(base_agent, rate_config: Optional[RateLimitConfig] = None, 
-                       security_config: Optional[SecurityConfig] = None) -> SecureAgentWrapper:
+def create_secure_agent(
+    base_agent,
+    rate_config: Optional[RateLimitConfig] = None,
+    security_config: Optional[SecurityConfig] = None,
+) -> SecureAgentWrapper:
     """Create a secure wrapper for an agent"""
     rate_limiter = get_rate_limiter(rate_config)
     validator = get_security_validator(security_config)
@@ -306,11 +330,11 @@ def set_secure_file_permissions(file_path: str):
     try:
         import os
         import stat
-        
+
         # Set read/write for owner only (0o600)
         os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR)
         logger.info(f"Set secure permissions for {file_path}")
-        
+
     except Exception as e:
         logger.warning(f"Could not set secure permissions for {file_path}: {e}")
 
@@ -319,19 +343,19 @@ def set_secure_file_permissions(file_path: str):
 def strip_html_tags(text: str) -> str:
     """Strip HTML tags from text (improved version)"""
     import html
-    
+
     # Decode HTML entities first
     text = html.unescape(text)
-    
+
     # Remove HTML/XML tags
-    text = re.sub(r'<[^>]+>', '', text)
-    
+    text = re.sub(r"<[^>]+>", "", text)
+
     # Remove remaining HTML entities
-    text = re.sub(r'&[a-zA-Z0-9#]+;', '', text)
-    
+    text = re.sub(r"&[a-zA-Z0-9#]+;", "", text)
+
     # Clean up whitespace
-    text = re.sub(r'\s+', ' ', text).strip()
-    
+    text = re.sub(r"\s+", " ", text).strip()
+
     return text
 
 
@@ -339,20 +363,20 @@ def validate_api_key_format(api_key: str) -> bool:
     """Validate OpenAI API key format without logging it"""
     if not api_key:
         return False
-    
+
     # Check basic format (starts with sk- and has correct length)
-    if not api_key.startswith('sk-'):
+    if not api_key.startswith("sk-"):
         return False
-    
+
     if len(api_key) < 20:  # Minimum reasonable length
         return False
-    
+
     # Check for obvious fake keys
-    fake_patterns = ['test', 'fake', 'demo', 'example', 'placeholder']
+    fake_patterns = ["test", "fake", "demo", "example", "placeholder"]
     lower_key = api_key.lower()
     if any(pattern in lower_key for pattern in fake_patterns):
         return False
-    
+
     return True
 
 
@@ -361,13 +385,13 @@ def sanitize_for_logging(text: str, max_length: int = 100) -> str:
     """Sanitize text for safe logging"""
     if not text:
         return "[EMPTY]"
-    
+
     # Remove potential secrets
     validator = get_security_validator()
     sanitized = validator.sanitize_output(text)
-    
+
     # Truncate for logging
     if len(sanitized) > max_length:
         sanitized = sanitized[:max_length] + "...[TRUNCATED]"
-    
-    return sanitized
+
+    return sanitized

ankigen_core/agents/templates/enhancers.j2

@@ -0,0 +1,17 @@
+{# Enhancement agent configuration template #}
+{
+    "revision_agent": {
+        "name": "revision_agent",
+        "instructions": "You are a content revision specialist.\nYour role is to improve flashcards based on feedback from quality judges.\n\nFor each revision request:\n- Analyze specific feedback provided\n- Make targeted improvements to address issues\n- Maintain the card's educational intent\n- Preserve correct information while fixing problems\n- Improve clarity, accuracy, and pedagogical value\n\nFocus on iterative improvement rather than complete rewrites.",
+        "model": "{{ revision_agent_model }}",
+        "temperature": 0.6,
+        "timeout": 40.0
+    },
+    "enhancement_agent": {
+        "name": "enhancement_agent",
+        "instructions": "You are a content enhancement specialist.\nYour role is to add missing elements and enrich flashcard content.\n\nEnhancement tasks:\n- Add missing explanations or examples\n- Improve metadata and tagging\n- Generate additional context or background\n- Create connections to related concepts\n- Enhance visual or structural elements\n\nEnsure enhancements add value without overwhelming the learner.",
+        "model": "{{ enhancement_agent_model }}",
+        "temperature": 0.7,
+        "timeout": 35.0
+    }
+}

ankigen_core/agents/templates/generators.j2

@@ -0,0 +1,37 @@
+{# Generator agent configuration template #}
+{
+    "subject_expert": {
+        "name": "subject_expert",
+        "instructions": "You are a world-class expert in {{ subject | default('the subject area') }} with deep pedagogical knowledge. \nYour role is to generate high-quality flashcards that demonstrate mastery of {{ subject | default('the subject') }} concepts.\n\nKey responsibilities:\n- Ensure technical accuracy and depth appropriate for the target level\n- Use domain-specific terminology correctly\n- Include practical applications and real-world examples\n- Connect concepts to prerequisite knowledge\n- Avoid oversimplification while maintaining clarity\n\nGenerate cards that test understanding, not just memorization.",
+        "model": "{{ subject_expert_model }}",
+        "temperature": 0.7,
+        "timeout": 45.0,
+        "custom_prompts": {
+            "math": "Focus on problem-solving strategies and mathematical reasoning",
+            "science": "Emphasize experimental design and scientific method",
+            "history": "Connect events to broader historical patterns and causation",
+            "programming": "Include executable examples and best practices"
+        }
+    },
+    "pedagogical": {
+        "name": "pedagogical",
+        "instructions": "You are an educational specialist focused on learning theory and instructional design.\nYour role is to ensure all flashcards follow educational best practices.\n\nApply these frameworks:\n- Bloom's Taxonomy: Ensure questions target appropriate cognitive levels\n- Spaced Repetition: Design cards for optimal retention\n- Cognitive Load Theory: Avoid overwhelming learners\n- Active Learning: Encourage engagement and application\n\nReview cards for:\n- Clear learning objectives\n- Appropriate difficulty progression\n- Effective use of examples and analogies\n- Prerequisite knowledge alignment",
+        "model": "{{ pedagogical_agent_model }}",
+        "temperature": 0.6,
+        "timeout": 30.0
+    },
+    "content_structuring": {
+        "name": "content_structuring",
+        "instructions": "You are a content organization specialist focused on consistency and structure.\nYour role is to format and organize flashcard content for optimal learning.\n\nEnsure all cards have:\n- Consistent formatting and style\n- Proper metadata and tagging\n- Clear, unambiguous questions\n- Complete, well-structured answers\n- Appropriate examples and explanations\n- Relevant categorization and difficulty levels\n\nMaintain high standards for readability and accessibility.",
+        "model": "{{ content_structuring_model }}",
+        "temperature": 0.5,
+        "timeout": 25.0
+    },
+    "generation_coordinator": {
+        "name": "generation_coordinator",
+        "instructions": "You are the generation workflow coordinator. \nYour role is to orchestrate the card generation process and manage handoffs between specialized agents.\n\nResponsibilities:\n- Route requests to appropriate specialist agents\n- Coordinate parallel generation tasks\n- Manage workflow state and progress\n- Handle errors and fallback strategies\n- Optimize generation pipelines\n\nMake decisions based on content type, user preferences, and system load.",
+        "model": "{{ generation_coordinator_model }}",
+        "temperature": 0.3,
+        "timeout": 20.0
+    }
+}

ankigen_core/agents/templates/judges.j2

@@ -0,0 +1,45 @@
+{# Judge agent configuration template #}
+{
+    "content_accuracy_judge": {
+        "name": "content_accuracy_judge",
+        "instructions": "You are a fact-checking and accuracy specialist.\nYour role is to verify the correctness and accuracy of flashcard content.\n\nEvaluate cards for:\n- Factual accuracy and up-to-date information\n- Proper use of terminology and definitions\n- Absence of misconceptions or errors\n- Appropriate level of detail for the target audience\n- Consistency with authoritative sources\n\nRate each card's accuracy and provide specific feedback on any issues found.",
+        "model": "{{ content_accuracy_judge_model }}",
+        "temperature": 0.3,
+        "timeout": 25.0
+    },
+    "pedagogical_judge": {
+        "name": "pedagogical_judge", 
+        "instructions": "You are an educational assessment specialist.\nYour role is to evaluate flashcards for pedagogical effectiveness.\n\nAssess cards for:\n- Alignment with learning objectives\n- Appropriate difficulty level and cognitive load\n- Effective use of educational principles\n- Clear prerequisite knowledge requirements\n- Potential for promoting deep learning\n\nProvide detailed feedback on educational effectiveness and improvement suggestions.",
+        "model": "{{ pedagogical_judge_model }}",
+        "temperature": 0.4,
+        "timeout": 30.0
+    },
+    "clarity_judge": {
+        "name": "clarity_judge",
+        "instructions": "You are a communication and clarity specialist.\nYour role is to ensure flashcards are clear, unambiguous, and well-written.\n\nEvaluate cards for:\n- Question clarity and specificity\n- Answer completeness and coherence\n- Absence of ambiguity or confusion\n- Appropriate language level for target audience\n- Effective use of examples and explanations\n\nRate clarity and provide specific suggestions for improvement.",
+        "model": "{{ clarity_judge_model }}",
+        "temperature": 0.3,
+        "timeout": 20.0
+    },
+    "technical_judge": {
+        "name": "technical_judge",
+        "instructions": "You are a technical accuracy specialist for programming and technical content.\nYour role is to verify technical correctness and best practices.\n\nFor technical cards, check:\n- Code syntax and functionality\n- Best practices and conventions\n- Security considerations\n- Performance implications\n- Tool and framework accuracy\n\nProvide detailed technical feedback and corrections.",
+        "model": "{{ technical_judge_model }}",
+        "temperature": 0.2,
+        "timeout": 35.0
+    },
+    "completeness_judge": {
+        "name": "completeness_judge",
+        "instructions": "You are a completeness and quality assurance specialist.\nYour role is to ensure flashcards meet all requirements and quality standards.\n\nVerify cards have:\n- All required fields and metadata\n- Proper formatting and structure\n- Appropriate tags and categorization\n- Complete explanations and examples\n- Consistent quality across the set\n\nRate completeness and identify missing elements.",
+        "model": "{{ completeness_judge_model }}",
+        "temperature": 0.3,
+        "timeout": 20.0
+    },
+    "judge_coordinator": {
+        "name": "judge_coordinator",
+        "instructions": "You are the quality assurance coordinator.\nYour role is to orchestrate the judging process and synthesize feedback from specialist judges.\n\nResponsibilities:\n- Route cards to appropriate specialist judges\n- Coordinate parallel judging tasks\n- Synthesize feedback from multiple judges\n- Make final accept/reject/revise decisions\n- Manage judge workload and performance\n\nBalance speed with thoroughness in quality assessment.",
+        "model": "{{ judge_coordinator_model }}",
+        "temperature": 0.3,
+        "timeout": 15.0
+    }
+}

ankigen_core/agents/templates/prompts.j2

@@ -0,0 +1,25 @@
+{# Prompt template configurations #}
+{
+    "subject_generation": {
+        "system_prompt": "You are an expert in {{ subject | default('general studies') }}. Generate {{ num_cards | default('5') }} flashcards covering key concepts for {{ difficulty | default('intermediate') }} level learners.",
+        "user_prompt_template": "Topic: {{ topic }}\nDifficulty: {{ difficulty | default('intermediate') }}\nPrerequisites: {{ prerequisites | default('none') }}\nFocus Areas: {{ focus_areas | default('core concepts') }}\n\nGenerate {{ num_cards | default('5') }} high-quality flashcards that help learners master this topic. Include examples, explanations, and common misconceptions where appropriate.",
+        "variables": {
+            "subject": "{{ subject | default('general') }}",
+            "num_cards": "{{ num_cards | default('5') }}",
+            "difficulty": "{{ difficulty | default('intermediate') }}",
+            "prerequisites": "{{ prerequisites | default('none') }}",
+            "topic": "{{ topic | default('general concepts') }}",
+            "focus_areas": "{{ focus_areas | default('core concepts') }}"
+        }
+    },
+    "quality_assessment": {
+        "system_prompt": "You are a quality assessment specialist for educational content. Evaluate flashcards for {{ assessment_type | default('overall quality') }}.",
+        "user_prompt_template": "Please evaluate the following flashcard for {{ assessment_type | default('quality') }}:\n\nQuestion: {{ question }}\nAnswer: {{ answer }}\n{% if explanation %}Explanation: {{ explanation }}{% endif %}\n\nProvide a rating (1-10) and specific feedback for improvement.",
+        "variables": {
+            "assessment_type": "{{ assessment_type | default('overall quality') }}",
+            "question": "{{ question }}",
+            "answer": "{{ answer }}",
+            "explanation": "{{ explanation | default('') }}"
+        }
+    }
+}

ankigen_core/agents/token_tracker.py

@@ -0,0 +1,210 @@
+"""
+Token usage tracking for OpenAI API calls using tiktoken.
+Provides accurate token counting and cost estimation.
+"""
+
+import tiktoken
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from ankigen_core.logging import logger
+
+
+@dataclass
+class TokenUsage:
+    """Track token usage for a single request"""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    estimated_cost: Optional[float]
+    model: str
+    timestamp: datetime = field(default_factory=datetime.now)
+
+
+class TokenTracker:
+    """Track token usage across multiple requests"""
+
+    def __init__(self):
+        self.usage_history: List[TokenUsage] = []
+        self.total_cost = 0.0
+        self.total_tokens = 0
+
+    def count_tokens_for_messages(
+        self, messages: List[Dict[str, str]], model: str
+    ) -> int:
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+        except KeyError:
+            encoding = tiktoken.get_encoding("o200k_base")
+
+        tokens_per_message = 3
+        tokens_per_name = 1
+
+        num_tokens = 0
+        for message in messages:
+            num_tokens += tokens_per_message
+            for key, value in message.items():
+                num_tokens += len(encoding.encode(str(value)))
+                if key == "name":
+                    num_tokens += tokens_per_name
+
+        num_tokens += 3
+        return num_tokens
+
+    def count_tokens_for_text(self, text: str, model: str) -> int:
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+        except KeyError:
+            encoding = tiktoken.get_encoding("o200k_base")
+
+        return len(encoding.encode(text))
+
+    def estimate_cost(
+        self, prompt_tokens: int, completion_tokens: int, model: str
+    ) -> Optional[float]:
+        return None
+
+    def track_usage_from_response(
+        self, response_data, model: str
+    ) -> Optional[TokenUsage]:
+        try:
+            if hasattr(response_data, "usage"):
+                usage = response_data.usage
+                prompt_tokens = usage.prompt_tokens
+                completion_tokens = usage.completion_tokens
+
+                actual_cost = None
+                if hasattr(usage, "total_cost"):
+                    actual_cost = usage.total_cost
+                elif hasattr(usage, "cost"):
+                    actual_cost = usage.cost
+
+                return self.track_usage(
+                    prompt_tokens, completion_tokens, model, actual_cost
+                )
+            return None
+        except Exception as e:
+            logger.error(f"Failed to track usage from response: {e}")
+            return None
+
+    def track_usage(
+        self,
+        prompt_tokens: int,
+        completion_tokens: int,
+        model: str,
+        actual_cost: Optional[float] = None,
+    ) -> TokenUsage:
+        total_tokens = prompt_tokens + completion_tokens
+
+        if actual_cost is not None:
+            final_cost = actual_cost
+        else:
+            final_cost = self.estimate_cost(prompt_tokens, completion_tokens, model)
+
+        usage = TokenUsage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=total_tokens,
+            estimated_cost=final_cost,
+            model=model,
+        )
+
+        self.usage_history.append(usage)
+        if final_cost:
+            self.total_cost += final_cost
+        self.total_tokens += total_tokens
+
+        logger.info(
+            f"💰 Token usage - Model: {model}, Prompt: {prompt_tokens}, Completion: {completion_tokens}, Cost: ${final_cost:.4f}"
+            if final_cost
+            else f"💰 Token usage - Model: {model}, Prompt: {prompt_tokens}, Completion: {completion_tokens}"
+        )
+
+        return usage
+
+    def get_session_summary(self) -> Dict[str, Any]:
+        if not self.usage_history:
+            return {
+                "total_requests": 0,
+                "total_tokens": 0,
+                "total_cost": 0.0,
+                "by_model": {},
+            }
+
+        by_model = {}
+        for usage in self.usage_history:
+            if usage.model not in by_model:
+                by_model[usage.model] = {"requests": 0, "tokens": 0, "cost": 0.0}
+            by_model[usage.model]["requests"] += 1
+            by_model[usage.model]["tokens"] += usage.total_tokens
+            if usage.estimated_cost:
+                by_model[usage.model]["cost"] += usage.estimated_cost
+
+        return {
+            "total_requests": len(self.usage_history),
+            "total_tokens": self.total_tokens,
+            "total_cost": self.total_cost,
+            "by_model": by_model,
+        }
+
+    def get_session_usage(self) -> Dict[str, Any]:
+        return self.get_session_summary()
+
+    def reset_session(self):
+        self.usage_history.clear()
+        self.total_cost = 0.0
+        self.total_tokens = 0
+        logger.info("🔄 Token usage tracking reset")
+
+    def track_usage_from_agents_sdk(
+        self, usage_dict: Dict[str, Any], model: str
+    ) -> Optional[TokenUsage]:
+        """Track usage from OpenAI Agents SDK usage format"""
+        try:
+            if not usage_dict or usage_dict.get("total_tokens", 0) == 0:
+                return None
+
+            prompt_tokens = usage_dict.get("input_tokens", 0)
+            completion_tokens = usage_dict.get("output_tokens", 0)
+
+            return self.track_usage(prompt_tokens, completion_tokens, model)
+        except Exception as e:
+            logger.error(f"Failed to track usage from agents SDK: {e}")
+            return None
+
+
+# Global token tracker instance
+_global_tracker = TokenTracker()
+
+
+def get_token_tracker() -> TokenTracker:
+    return _global_tracker
+
+
+def track_agent_usage(
+    prompt_text: str,
+    completion_text: str,
+    model: str,
+    actual_cost: Optional[float] = None,
+) -> TokenUsage:
+    tracker = get_token_tracker()
+
+    prompt_tokens = tracker.count_tokens_for_text(prompt_text, model)
+    completion_tokens = tracker.count_tokens_for_text(completion_text, model)
+
+    return tracker.track_usage(prompt_tokens, completion_tokens, model, actual_cost)
+
+
+def track_usage_from_openai_response(response_data, model: str) -> Optional[TokenUsage]:
+    tracker = get_token_tracker()
+    return tracker.track_usage_from_response(response_data, model)
+
+
+def track_usage_from_agents_sdk(
+    usage_dict: Dict[str, Any], model: str
+) -> Optional[TokenUsage]:
+    """Track usage from OpenAI Agents SDK usage format"""
+    tracker = get_token_tracker()
+    return tracker.track_usage_from_agents_sdk(usage_dict, model)

ankigen_core/card_generator.py

@@ -20,30 +20,29 @@ from ankigen_core.models import (
     CardBack,
 )  # Import necessary Pydantic models
 
+# Import agent system - required
+from ankigen_core.agents.integration import AgentOrchestrator
+from agents import set_tracing_disabled
+
 logger = get_logger()
 
-# Import agent system
-try:
-    from ankigen_core.agents.integration import AgentOrchestrator
-    from ankigen_core.agents.feature_flags import get_feature_flags
-    AGENTS_AVAILABLE = True
-    logger.info("Agent system loaded successfully")
-except ImportError:
-    # Graceful fallback if agent system not available
-    AGENTS_AVAILABLE = False
-    logger.info("Agent system not available, using legacy generation only")
+# Disable tracing to prevent metrics persistence issues
+set_tracing_disabled(True)
+
+AGENTS_AVAILABLE = True
+logger.info("Agent system loaded successfully")
 
 # --- Constants --- (Moved from app.py)
 AVAILABLE_MODELS = [
     {
         "value": "gpt-4.1",
-        "label": "gpt-4.1 (Best Quality)",
-        "description": "Highest quality, slower generation",
+        "label": "GPT-4.1 (Best Quality)",
+        "description": "Highest quality, large context window",
     },
     {
         "value": "gpt-4.1-nano",
-        "label": "gpt-4.1 Nano (Fast & Efficient)",
-        "description": "Optimized for speed and lower cost",
+        "label": "GPT-4.1 Nano (Ultra Fast)",
+        "description": "Ultra-fast and cost-effective",
     },
 ]
 
@@ -256,65 +255,118 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
 
     # --- AGENT SYSTEM INTEGRATION ---
     if AGENTS_AVAILABLE:
-        feature_flags = get_feature_flags()
-        if feature_flags.should_use_agents():
-            logger.info("🤖 Using agent system for card generation")
+        logger.info("🤖 Using agent system for card generation")
+        try:
+            # Initialize token tracker
+            from ankigen_core.agents.token_tracker import get_token_tracker
+
+            token_tracker = get_token_tracker()
+
+            # Initialize agent orchestrator with the actual model from UI
+            # Initialize orchestrator with model overrides
+            orchestrator = AgentOrchestrator(client_manager)
+
+            # Set model overrides for all agents
+            logger.info(f"Overriding all agent models to use: {model_name}")
+            model_overrides = {
+                "generation_coordinator": model_name,
+                "subject_expert": model_name,
+                "pedagogical_agent": model_name,
+                "content_structuring": model_name,
+                "enhancement_agent": model_name,
+                "revision_agent": model_name,
+                "content_accuracy_judge": model_name,
+                "pedagogical_judge": model_name,
+                "clarity_judge": model_name,
+                "technical_judge": model_name,
+                "completeness_judge": model_name,
+                "judge_coordinator": model_name,
+            }
+
+            # Initialize with model overrides
+            await orchestrator.initialize(api_key_input, model_overrides)
+
+            # Map generation mode to subject
+            agent_subject = "general"
+            if generation_mode == "subject":
+                agent_subject = subject if subject else "general"
+            elif generation_mode == "path":
+                agent_subject = "curriculum_design"
+            elif generation_mode == "text":
+                agent_subject = "content_analysis"
+
+            # Calculate total cards needed
+            total_cards_needed = topic_number * cards_per_topic
+
+            # Prepare context for text mode
+            context = {}
+            if generation_mode == "text" and source_text:
+                context["source_text"] = source_text
+
+            # Generate cards with agents using the actual model from UI
+            agent_cards, agent_metadata = await orchestrator.generate_cards_with_agents(
+                topic=subject if subject else "Mixed Topics",
+                subject=agent_subject,
+                num_cards=total_cards_needed,
+                difficulty="intermediate",  # Could be made configurable
+                enable_quality_pipeline=True,
+                context=context,
+            )
+
+            # Get token usage from session
             try:
-                # Initialize agent orchestrator
-                orchestrator = AgentOrchestrator(client_manager)
-                await orchestrator.initialize(api_key_input)
-                
-                # Map generation mode to subject
-                agent_subject = "general"
-                if generation_mode == "subject":
-                    agent_subject = subject if subject else "general"
-                elif generation_mode == "path":
-                    agent_subject = "curriculum_design"
-                elif generation_mode == "text":
-                    agent_subject = "content_analysis"
-                
-                # Calculate total cards needed
-                total_cards_needed = topic_number * cards_per_topic
-                
-                # Prepare context for text mode
-                context = {}
-                if generation_mode == "text" and source_text:
-                    context["source_text"] = source_text
-                
-                # Generate cards with agents
-                agent_cards, agent_metadata = await orchestrator.generate_cards_with_agents(
-                    topic=subject if subject else "Mixed Topics",
-                    subject=agent_subject,
-                    num_cards=total_cards_needed,
-                    difficulty="intermediate",  # Could be made configurable
-                    enable_quality_pipeline=True,
-                    context=context
-                )
-                
-                # Convert agent cards to dataframe format
-                if agent_cards:
-                    formatted_cards = format_cards_for_dataframe(
-                        agent_cards,
-                        topic_name=f"Agent Generated - {subject}" if subject else "Agent Generated",
-                        start_index=1
-                    )
-                    
-                    output_df = pd.DataFrame(formatted_cards, columns=get_dataframe_columns())
-                    total_cards_message = f"<div><b>🤖 Agent Generated Cards:</b> <span id='total-cards-count'>{len(output_df)}</span></div>"
-                    
-                    logger.info(f"Agent system generated {len(output_df)} cards successfully")
-                    return output_df, total_cards_message
+                # Try both method names for compatibility
+                if hasattr(token_tracker, "get_session_summary"):
+                    token_usage = token_tracker.get_session_summary()
+                elif hasattr(token_tracker, "get_session_usage"):
+                    token_usage = token_tracker.get_session_usage()
                 else:
-                    logger.warning("Agent system returned no cards, falling back to legacy")
-                    gr.Info("🔄 Agent system returned no cards, using legacy generation...")
-                    
+                    raise AttributeError("TokenTracker has no session summary method")
+
+                token_usage_html = f"<div style='margin-top: 8px;'><b>Token Usage:</b> {token_usage['total_tokens']} tokens</div>"
             except Exception as e:
-                logger.error(f"Agent system failed: {e}, falling back to legacy generation")
-                gr.Warning(f"🔄 Agent system error: {str(e)}, using legacy generation...")
-                # Continue to legacy generation below
+                logger.error(f"Token usage collection failed: {e}")
+                token_usage_html = "<div style='margin-top: 8px;'><b>Token Usage:</b> No usage data</div>"
 
-    # --- LEGACY SYSTEM INITIALIZATION AND VALIDATION ---
-    logger.info("Using legacy card generation system")
+            # Convert agent cards to dataframe format
+            if agent_cards:
+                formatted_cards = format_cards_for_dataframe(
+                    agent_cards,
+                    topic_name=f"Agent Generated - {subject}"
+                    if subject
+                    else "Agent Generated",
+                    start_index=1,
+                )
+
+                output_df = pd.DataFrame(
+                    formatted_cards, columns=get_dataframe_columns()
+                )
+                total_cards_message = f"<div><b>🤖 Agent Generated Cards:</b> <span id='total-cards-count'>{len(output_df)}</span></div>"
+
+                logger.info(
+                    f"Agent system generated {len(output_df)} cards successfully"
+                )
+                return output_df, total_cards_message, token_usage_html
+            else:
+                logger.error("Agent system returned no cards")
+                gr.Error("🤖 Agent system returned no cards")
+                return (
+                    pd.DataFrame(columns=get_dataframe_columns()),
+                    "Agent system returned no cards.",
+                    "",
+                )
+
+        except Exception as e:
+            logger.error(f"Agent system failed: {e}")
+            gr.Error(f"🤖 Agent system error: {str(e)}")
+            return (
+                pd.DataFrame(columns=get_dataframe_columns()),
+                f"Agent system error: {str(e)}",
+                "",
+            )
+
+    # This should never be reached since agents are required
+    logger.error("Agent system not available but required")
     if not api_key_input:
         logger.warning("No API key provided to orchestrator")
         gr.Error("OpenAI API key is required")
@@ -379,7 +431,7 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
                 )
 
             topics_for_generation = []
-            max(1, topic_number // len(individual_subjects))  # Distribute topic_number
+            # max(1, topic_number // len(individual_subjects))  # Distribute topic_number
 
             for ind_subject in individual_subjects:
                 # For single/multiple subjects, we might generate sub-topics or just use the subject as a topic
@@ -1023,3 +1075,12 @@ def generate_cards_from_crawled_content(
         }
         data_for_dataframe.append(card_dict)
     return data_for_dataframe
+
+
+def generate_token_usage_html(token_usage=None):
+    """Generate HTML for token usage display"""
+    if token_usage and isinstance(token_usage, dict):
+        total_tokens = token_usage.get("total_tokens", 0)
+        return f"<div style='margin-top: 8px;'><b>Token Usage:</b> {total_tokens} tokens</div>"
+    else:
+        return "<div style='margin-top: 8px;'><b>Token Usage:</b> No usage data</div>"

ankigen_core/exporters.py

@@ -80,35 +80,35 @@ BASIC_MODEL = genanki.Model(
                         </div>
                     </div>
                     <hr>
-                    
+
                     <div class=\"answer-section\">
                         <h3>Answer</h3>
                         <div class=\"answer\">{{Answer}}</div>
                     </div>
-                    
+
                     <div class=\"explanation-section\">
                         <h3>Explanation</h3>
                         <div class=\"explanation-text\">{{Explanation}}</div>
                     </div>
-                    
+
                     <div class=\"example-section\">
                         <h3>Example</h3>
-                        <div class=\"example-text\">{{Example}}</div> 
+                        <div class=\"example-text\">{{Example}}</div>
                         <!-- Example field might contain pre/code or plain text -->
                         <!-- Handled by how HTML is put into the Example field -->
                     </div>
-                    
+
                     <div class=\"metadata-section\">
                         <div class=\"learning-outcomes\">
                             <h3>Learning Outcomes</h3>
                             <div>{{Learning_Outcomes}}</div>
                         </div>
-                        
+
                         <div class=\"misconceptions\">
                             <h3>Common Misconceptions - Debunked</h3>
                             <div>{{Common_Misconceptions}}</div>
                         </div>
-                        
+
                         <div class=\"difficulty\">
                             <h3>Difficulty Level</h3>
                             <div>{{Difficulty}}</div>
@@ -132,20 +132,20 @@ BASIC_MODEL = genanki.Model(
             padding: 20px;
             background: #ffffff;
         }
-        
+
         @media (max-width: 768px) {
             .card {
                 font-size: 14px;
                 padding: 15px;
             }
         }
-        
+
         /* Question side */
         .question-side {
             position: relative;
             min-height: 200px;
         }
-        
+
         .difficulty-indicator {
             position: absolute;
             top: 10px;
@@ -154,30 +154,30 @@ BASIC_MODEL = genanki.Model(
             height: 10px;
             border-radius: 50%;
         }
-        
+
         .difficulty-indicator.beginner { background: #4ade80; }
         .difficulty-indicator.intermediate { background: #fbbf24; }
         .difficulty-indicator.advanced { background: #ef4444; }
-        
+
         .question {
             font-size: 1.3em;
             font-weight: 600;
             color: #2563eb;
             margin-bottom: 1.5em;
         }
-        
+
         .prerequisites {
             margin-top: 1em;
             font-size: 0.9em;
             color: #666;
         }
-        
+
         .prerequisites-toggle {
             color: #2563eb;
             cursor: pointer;
             text-decoration: underline;
         }
-        
+
         .prerequisites-content {
             display: none;
             margin-top: 0.5em;
@@ -185,11 +185,11 @@ BASIC_MODEL = genanki.Model(
             background: #f8fafc;
             border-radius: 4px;
         }
-        
+
         .prerequisites.show .prerequisites-content {
             display: block;
         }
-        
+
         /* Answer side */
         .answer-section,
         .explanation-section,
@@ -199,17 +199,17 @@ BASIC_MODEL = genanki.Model(
             border-radius: 8px;
             box-shadow: 0 2px 4px rgba(0,0,0,0.05);
         }
-        
+
         .answer-section {
             background: #f0f9ff;
             border-left: 4px solid #2563eb;
         }
-        
+
         .explanation-section {
             background: #f0fdf4;
             border-left: 4px solid #4ade80;
         }
-        
+
         .example-section {
             background: #fefce8; /* Light yellow */
             border-left: 4px solid #facc15; /* Yellow */
@@ -228,7 +228,7 @@ BASIC_MODEL = genanki.Model(
         .example-section code {
              font-family: 'Consolas', 'Monaco', 'Menlo', monospace;
         }
-        
+
         .metadata-section {
             margin-top: 2em;
             padding-top: 1em;
@@ -236,13 +236,13 @@ BASIC_MODEL = genanki.Model(
             font-size: 0.9em;
             color: #4b5563; /* Cool gray */
         }
-        
+
         .metadata-section h3 {
             font-size: 1em;
             color: #1f2937; /* Darker gray for headings */
             margin-bottom: 0.5em;
         }
-        
+
         .metadata-section > div {
             margin-bottom: 0.8em;
         }
@@ -254,7 +254,7 @@ BASIC_MODEL = genanki.Model(
         .source-url a:hover {
             text-decoration: underline;
         }
-        
+
         /* Styles for cloze deletion cards */
         .cloze {
             font-weight: bold;
@@ -263,14 +263,14 @@ BASIC_MODEL = genanki.Model(
         .nightMode .cloze {
             color: lightblue;
         }
-        
+
         /* General utility */
         hr {
             border: none;
             border-top: 1px dashed #cbd5e1; /* Light dashed line */
             margin: 1.5em 0;
         }
-        
+
         /* Rich text field styling (if Anki adds classes for these) */
         .field ul, .field ol {
             margin-left: 1.5em;
@@ -289,13 +289,13 @@ BASIC_MODEL = genanki.Model(
                 margin: 1em 0;
             }
         }
-        
+
         /* Animations */
         @keyframes fadeIn {
             from { opacity: 0; }
             to { opacity: 1; }
         }
-        
+
         .card {
             animation: fadeIn 0.3s ease-in-out;
         }
@@ -350,35 +350,35 @@ CLOZE_MODEL = genanki.Model(
                         </div>
                     </div>
                     <hr>
-                    
+
                     {{#Back Extra}}
                     <div class=\"back-extra-section\">
                         <h3>Additional Information</h3>
                         <div class=\"back-extra-text\">{{Back Extra}}</div>
                     </div>
                     {{/Back Extra}}
-                    
+
                     <div class=\"explanation-section\">
                         <h3>Explanation</h3>
                         <div class=\"explanation-text\">{{Explanation}}</div>
                     </div>
-                    
+
                     <div class=\"example-section\">
                         <h3>Example</h3>
                         <div class=\"example-text\">{{Example}}</div>
                     </div>
-                    
+
                     <div class=\"metadata-section\">
                         <div class=\"learning-outcomes\">
                             <h3>Learning Outcomes</h3>
                             <div>{{Learning_Outcomes}}</div>
                         </div>
-                        
+
                         <div class=\"misconceptions\">
                             <h3>Common Misconceptions - Debunked</h3>
                             <div>{{Common_Misconceptions}}</div>
                         </div>
-                        
+
                         <div class=\"difficulty\">
                             <h3>Difficulty Level</h3>
                             <div>{{Difficulty}}</div>
@@ -402,20 +402,20 @@ CLOZE_MODEL = genanki.Model(
             padding: 20px;
             background: #ffffff;
         }
-        
+
         @media (max-width: 768px) {
             .card {
                 font-size: 14px;
                 padding: 15px;
             }
         }
-        
+
         /* Question side */
         .question-side {
             position: relative;
             min-height: 200px;
         }
-        
+
         .difficulty-indicator {
             position: absolute;
             top: 10px;
@@ -424,30 +424,30 @@ CLOZE_MODEL = genanki.Model(
             height: 10px;
             border-radius: 50%;
         }
-        
+
         .difficulty-indicator.beginner { background: #4ade80; }
         .difficulty-indicator.intermediate { background: #fbbf24; }
         .difficulty-indicator.advanced { background: #ef4444; }
-        
+
         .question {
             font-size: 1.3em;
             font-weight: 600;
             color: #2563eb;
             margin-bottom: 1.5em;
         }
-        
+
         .prerequisites {
             margin-top: 1em;
             font-size: 0.9em;
             color: #666;
         }
-        
+
         .prerequisites-toggle {
             color: #2563eb;
             cursor: pointer;
             text-decoration: underline;
         }
-        
+
         .prerequisites-content {
             display: none;
             margin-top: 0.5em;
@@ -455,11 +455,11 @@ CLOZE_MODEL = genanki.Model(
             background: #f8fafc;
             border-radius: 4px;
         }
-        
+
         .prerequisites.show .prerequisites-content {
             display: block;
         }
-        
+
         /* Answer side */
         .answer-section,
         .explanation-section,
@@ -469,7 +469,7 @@ CLOZE_MODEL = genanki.Model(
             border-radius: 8px;
             box-shadow: 0 2px 4px rgba(0,0,0,0.05);
         }
-        
+
         .answer-section { /* Shared with question for cloze, but can be general */
             background: #f0f9ff;
             border-left: 4px solid #2563eb;
@@ -483,7 +483,7 @@ CLOZE_MODEL = genanki.Model(
             border-radius: 8px;
             box-shadow: 0 2px 4px rgba(0,0,0,0.05);
         }
-        
+
         .explanation-section {
             background: #f0fdf4;
             border-left: 4px solid #4ade80;
@@ -507,7 +507,7 @@ CLOZE_MODEL = genanki.Model(
         .example-section code {
              font-family: 'Consolas', 'Monaco', 'Menlo', monospace;
         }
-        
+
         .metadata-section {
             margin-top: 2em;
             padding-top: 1em;
@@ -515,13 +515,13 @@ CLOZE_MODEL = genanki.Model(
             font-size: 0.9em;
             color: #4b5563; /* Cool gray */
         }
-        
+
         .metadata-section h3 {
             font-size: 1em;
             color: #1f2937; /* Darker gray for headings */
             margin-bottom: 0.5em;
         }
-        
+
         .metadata-section > div {
             margin-bottom: 0.8em;
         }
@@ -533,7 +533,7 @@ CLOZE_MODEL = genanki.Model(
         .source-url a:hover {
             text-decoration: underline;
         }
-        
+
         /* Styles for cloze deletion cards */
         .cloze {
             font-weight: bold;
@@ -542,14 +542,14 @@ CLOZE_MODEL = genanki.Model(
         .nightMode .cloze {
             color: lightblue;
         }
-        
+
         /* General utility */
         hr {
             border: none;
             border-top: 1px dashed #cbd5e1; /* Light dashed line */
             margin: 1.5em 0;
         }
-        
+
         /* Rich text field styling (if Anki adds classes for these) */
         .field ul, .field ol {
             margin-left: 1.5em;

ankigen_core/ui_logic.py

@@ -15,7 +15,6 @@ import asyncio
 from ankigen_core.crawler import WebCrawler
 from ankigen_core.llm_interface import (
     OpenAIClientManager,
-    process_crawled_pages,
 )
 from ankigen_core.card_generator import (
     generate_cards_from_crawled_content,
@@ -37,12 +36,10 @@ from ankigen_core.models import (
 )
 
 # Import agent system for web crawling
-try:
-    from ankigen_core.agents.integration import AgentOrchestrator
-    from ankigen_core.agents.feature_flags import get_feature_flags
-    AGENTS_AVAILABLE_UI = True
-except ImportError:
-    AGENTS_AVAILABLE_UI = False
+# Agent system is required for web crawling
+from ankigen_core.agents.integration import AgentOrchestrator
+
+AGENTS_AVAILABLE_UI = True
 # --- End moved imports ---
 
 # Get an instance of the logger for this module
@@ -311,6 +308,7 @@ def create_crawler_main_mode_elements() -> (
         label="AI Model for Content Processing",  # Clarified label
         value=default_model_value_crawler,
         elem_id="crawler_model_dropdown",
+        allow_custom_value=True,
     )
     ui_components.append(model_dropdown)
 
@@ -544,120 +542,59 @@ async def crawl_and_generate(
             )
 
         # --- AGENT SYSTEM INTEGRATION FOR WEB CRAWLING ---
-        if AGENTS_AVAILABLE_UI:
-            feature_flags = get_feature_flags()
-            if feature_flags.should_use_agents():
-                crawler_ui_logger.info("🤖 Using agent system for web crawling card generation")
-                try:
-                    # Initialize agent orchestrator
-                    orchestrator = AgentOrchestrator(client_manager)
-                    await orchestrator.initialize("dummy-key")  # Key already in client_manager
-                    
-                    # Combine all crawled content into a single context
-                    combined_content = "\n\n--- PAGE BREAK ---\n\n".join([
-                        f"URL: {page.url}\nTitle: {page.title}\nContent: {page.text_content[:2000]}..."
-                        for page in crawled_pages[:10]  # Limit to first 10 pages to avoid token limits
-                    ])
-                    
-                    context = {
-                        "source_text": combined_content,
-                        "crawl_source": url,
-                        "pages_crawled": len(crawled_pages)
-                    }
-                    
-                    progress(0.6, desc="🤖 Processing with agent system...")
-                    
-                    # Generate cards with agents
-                    agent_cards, agent_metadata = await orchestrator.generate_cards_with_agents(
-                        topic=f"Content from {url}",
-                        subject="web_content",
-                        num_cards=min(len(crawled_pages) * 3, 50),  # 3 cards per page, max 50
-                        difficulty="intermediate",
-                        enable_quality_pipeline=True,
-                        context=context
-                    )
-                    
-                    if agent_cards:
-                        progress(0.9, desc=f"🤖 Agent system generated {len(agent_cards)} cards")
-                        
-                        cards_for_dataframe_export = generate_cards_from_crawled_content(agent_cards)
-                        
-                        final_message = f"🤖 Agent system processed content from {len(crawled_pages)} pages. Generated {len(agent_cards)} high-quality cards."
-                        progress(1.0, desc=final_message)
-                        
-                        return (
-                            final_message,
-                            cards_for_dataframe_export,
-                            agent_cards,
-                        )
-                    else:
-                        crawler_ui_logger.warning("Agent system returned no cards for web content, falling back to legacy")
-                        progress(0.5, desc="🔄 Agent system returned no cards, using legacy processing...")
-                        
-                except Exception as e:
-                    crawler_ui_logger.error(f"Agent system failed for web crawling: {e}, falling back to legacy")
-                    progress(0.5, desc=f"🔄 Agent error: {str(e)}, using legacy processing...")
-
-        # --- LEGACY WEB PROCESSING ---
-        crawler_ui_logger.info("Using legacy LLM processing for web content")
-        openai_client = client_manager.get_client()
-        processed_llm_pages = 0
-
-        def llm_progress_callback(completed_count: int, total_count: int):
-            nonlocal processed_llm_pages
-            processed_llm_pages = completed_count
-            progress(
-                0.5 + (completed_count / total_count) * 0.4,
-                desc=f"Processing content: {completed_count}/{total_count} pages processed by LLM.",
-            )
-
-        crawler_ui_logger.info(
-            f"Starting LLM processing for {len(crawled_pages)} pages..."
-        )
-        progress(
-            0.55, desc=f"Processing {len(crawled_pages)} pages with LLM ({model})..."
-        )
-        all_cards = await process_crawled_pages(  # This now returns List[Card]
-            openai_client=openai_client,
-            pages=crawled_pages,
-            model=model,
-            max_prompt_content_tokens=6000,
-            max_concurrent_requests=5,
-            custom_system_prompt=custom_system_prompt
-            if custom_system_prompt and custom_system_prompt.strip()
-            else None,
-            custom_user_prompt_template=custom_user_prompt_template
-            if custom_user_prompt_template and custom_user_prompt_template.strip()
-            else None,
-            progress_callback=llm_progress_callback,
-        )
-        crawler_ui_logger.info(
-            f"LLM processing finished. Generated {len(all_cards)} Card objects."  # Changed AnkiCardData to Card
+        crawler_ui_logger.info("🤖 Using agent system for web crawling card generation")
+
+        # Initialize agent orchestrator
+        orchestrator = AgentOrchestrator(client_manager)
+        await orchestrator.initialize("dummy-key")  # Key already in client_manager
+
+        # Combine all crawled content into a single context
+        combined_content = "\n\n--- PAGE BREAK ---\n\n".join(
+            [
+                f"URL: {page.url}\nTitle: {page.title}\nContent: {page.text_content[:2000]}..."
+                for page in crawled_pages[
+                    :10
+                ]  # Limit to first 10 pages to avoid token limits
+            ]
         )
-        progress(
-            0.9,
-            desc=f"LLM processing finished. Generated {len(all_cards)} Anki cards.",
+
+        context = {
+            "source_text": combined_content,
+            "crawl_source": url,
+            "pages_crawled": len(crawled_pages),
+        }
+
+        progress(0.6, desc="🤖 Processing with agent system...")
+
+        # Generate cards with agents
+        agent_cards, agent_metadata = await orchestrator.generate_cards_with_agents(
+            topic=f"Content from {url}",
+            subject="web_content",
+            num_cards=min(len(crawled_pages) * 3, 50),  # 3 cards per page, max 50
+            difficulty="intermediate",
+            enable_quality_pipeline=True,
+            context=context,
         )
 
-        if not all_cards:
-            progress(
-                1.0, desc="LLM processing complete, but no Anki cards were generated."
-            )
-            return (
-                "LLM processing complete, but no Anki cards were generated.",
-                pd.DataFrame().to_dict(orient="records"),  # Empty DataFrame data
-                [],  # Empty list of raw cards
+        if agent_cards:
+            progress(0.9, desc=f"🤖 Agent system generated {len(agent_cards)} cards")
+
+            cards_for_dataframe_export = generate_cards_from_crawled_content(
+                agent_cards
             )
 
-        cards_for_dataframe_export = generate_cards_from_crawled_content(
-            all_cards
-        )  # Expects List[Card]
-        if not cards_for_dataframe_export:
-            progress(
-                1.0, desc="Card processing (formatting, etc.) resulted in no cards."
+            final_message = f"🤖 Agent system processed content from {len(crawled_pages)} pages. Generated {len(agent_cards)} high-quality cards."
+            progress(1.0, desc=final_message)
+
+            return (
+                final_message,
+                cards_for_dataframe_export,
+                agent_cards,
             )
+        else:
+            progress(1.0, desc="🤖 Agent system returned no cards")
             return (
-                "Card processing resulted in no cards.",
+                "Agent system returned no cards",
                 pd.DataFrame().to_dict(orient="records"),
                 [],
             )
@@ -692,8 +629,8 @@ async def crawl_and_generate(
     return (
         final_message,
         cards_for_dataframe_export,
-        all_cards,
-    )  # all_cards is List[Card]
+        agent_cards,
+    )  # agent_cards is List[Card]
 
 
 # --- Card Preview and Editing Utilities (Task 13.3) ---

app.py

@@ -1,50 +1,45 @@
 # Standard library imports
+import asyncio
 import os
-from pathlib import Path  # Potentially for favicon_path
-from datetime import datetime
 import re
-import asyncio
+from datetime import datetime
+from pathlib import Path  # Potentially for favicon_path
 
 import gradio as gr
 import pandas as pd
 
-from ankigen_core.utils import (
-    get_logger,
-    ResponseCache,
-)  # fetch_webpage_text is used by card_generator
-
-from ankigen_core.llm_interface import (
-    OpenAIClientManager,
-)  # structured_output_completion is internal to core modules
 from ankigen_core.card_generator import (
-    orchestrate_card_generation,
     AVAILABLE_MODELS,
+    orchestrate_card_generation,
 )  # GENERATION_MODES is internal to card_generator
-from ankigen_core.learning_path import analyze_learning_path
 from ankigen_core.exporters import (
-    export_dataframe_to_csv,
     export_dataframe_to_apkg,
+    export_dataframe_to_csv,
 )  # Anki models (BASIC_MODEL, CLOZE_MODEL) are internal to exporters
+from ankigen_core.learning_path import analyze_learning_path
+from ankigen_core.llm_interface import (
+    OpenAIClientManager,
+)  # structured_output_completion is internal to core modules
 from ankigen_core.ui_logic import (
+    crawl_and_generate,
+    create_crawler_main_mode_elements,
     update_mode_visibility,
     use_selected_subjects,
-    create_crawler_main_mode_elements,
-    crawl_and_generate,
 )
+from ankigen_core.utils import (
+    ResponseCache,
+    get_logger,
+)  # fetch_webpage_text is used by card_generator
 
 # --- Initialization ---
 logger = get_logger()
 response_cache = ResponseCache()  # Initialize cache
 client_manager = OpenAIClientManager()  # Initialize client manager
 
-# Check agent system availability
-try:
-    from ankigen_core.agents.feature_flags import get_feature_flags
-    AGENTS_AVAILABLE_APP = True
-    logger.info("Agent system is available")
-except ImportError:
-    AGENTS_AVAILABLE_APP = False
-    logger.info("Agent system not available, using legacy generation only")
+# Agent system is required
+
+AGENTS_AVAILABLE_APP = True
+logger.info("Agent system is available")
 
 js_storage = """
 async () => {
@@ -61,13 +56,17 @@ async () => {
 }
 """
 
-custom_theme = gr.themes.Soft().set(
-    body_background_fill="*background_fill_secondary",
-    block_background_fill="*background_fill_primary",
-    block_border_width="0",
-    button_primary_background_fill="*primary_500",
-    button_primary_text_color="white",
-)
+try:
+    custom_theme = gr.themes.Soft().set(  # type: ignore
+        body_background_fill="*background_fill_secondary",
+        block_background_fill="*background_fill_primary",
+        block_border_width="0",
+        button_primary_background_fill="*primary_500",
+        button_primary_text_color="white",
+    )
+except (AttributeError, ImportError):
+    # Fallback for older gradio versions or when themes are not available
+    custom_theme = None
 
 # --- Example Data for Initialization ---
 example_data = pd.DataFrame(
@@ -129,15 +128,16 @@ def get_recent_logs(logger_name="ankigen") -> str:
         log_file = os.path.join(log_dir, f"{logger_name}_{timestamp}.log")
 
         if os.path.exists(log_file):
-            with open(log_file, "r") as f:
+            with open(log_file) as f:
                 lines = f.readlines()
                 # Display last N lines, e.g., 100
                 return "\n".join(lines[-100:])  # Ensured this is standard newline
         return f"Log file for today ({log_file}) not found or is empty."
     except Exception as e:
-        # Use the main app logger to log this error, but don't let it crash the UI function
+        # Use the main app logger to log this error, but don't let it crash the UI
+        # function
         logger.error(f"Error reading logs: {e}", exc_info=True)
-        return f"Error reading logs: {str(e)}"
+        return f"Error reading logs: {e!s}"
 
 
 def create_ankigen_interface():
@@ -154,26 +154,26 @@ def create_ankigen_interface():
             .export-group > .gradio-group { margin-bottom: 0 !important; padding-bottom: 5px !important; }
 
             /* REMOVING CSS previously intended for DataFrame readability to ensure plain text */
-            /* 
-            .explanation-text { 
-                background: #f0fdf4; 
-                border-left: 3px solid #4ade80; 
+            /*
+            .explanation-text {
+                background: #f0fdf4;
+                border-left: 3px solid #4ade80;
                 padding: 0.5em;
                 margin-bottom: 0.5em;
                 border-radius: 4px;
             }
-            .example-text-plain { 
-                background: #fff7ed; 
-                border-left: 3px solid #f97316; 
+            .example-text-plain {
+                background: #fff7ed;
+                border-left: 3px solid #f97316;
                 padding: 0.5em;
                 margin-bottom: 0.5em;
                 border-radius: 4px;
             }
-            pre code { 
+            pre code {
                 display: block;
                 padding: 0.8em;
-                background: #1e293b; 
-                color: #e2e8f0;     
+                background: #1e293b;
+                color: #e2e8f0;
                 border-radius: 4px;
                 overflow-x: auto;
                 font-family: 'Fira Code', 'Consolas', monospace;
@@ -187,25 +187,6 @@ def create_ankigen_interface():
         with gr.Column(elem_classes="contain"):
             gr.Markdown("# 📚 AnkiGen - Advanced Anki Card Generator")
             gr.Markdown("#### Generate comprehensive Anki flashcards using AI.")
-            
-            # Agent system status indicator
-            if AGENTS_AVAILABLE_APP:
-                try:
-                    feature_flags = get_feature_flags()
-                    if feature_flags.should_use_agents():
-                        agent_status_emoji = "🤖"
-                        agent_status_text = "**Agent System Active** - Enhanced quality with multi-agent pipeline"
-                    else:
-                        agent_status_emoji = "🔧"
-                        agent_status_text = "**Legacy Mode** - Set `ANKIGEN_AGENT_MODE=agent_only` to enable agents"
-                except:
-                    agent_status_emoji = "⚙️"
-                    agent_status_text = "**Agent System Available** - Configure environment variables to activate"
-            else:
-                agent_status_emoji = "💡"
-                agent_status_text = "**Legacy Mode** - Agent system not installed"
-            
-            gr.Markdown(f"{agent_status_emoji} {agent_status_text}")
 
             with gr.Accordion("Configuration Settings", open=True):
                 with gr.Row():
@@ -233,7 +214,8 @@ def create_ankigen_interface():
                                 lines=5,
                             )
                             analyze_button = gr.Button(
-                                "Analyze & Break Down", variant="secondary"
+                                "Analyze & Break Down",
+                                variant="secondary",
                             )
                         with gr.Group(visible=False) as text_mode:
                             source_text = gr.Textbox(
@@ -244,7 +226,7 @@ def create_ankigen_interface():
                         with gr.Group(visible=False) as web_mode:
                             # --- BEGIN INTEGRATED CRAWLER UI (Task 16) ---
                             logger.info(
-                                "Setting up integrated Web Crawler UI elements..."
+                                "Setting up integrated Web Crawler UI elements...",
                             )
                             (
                                 crawler_input_ui_elements,  # List of inputs like URL, depth, model, patterns
@@ -296,9 +278,10 @@ def create_ankigen_interface():
                                 value=default_model_value,
                                 label="Model Selection",
                                 info="Select AI model for generation",
+                                allow_custom_value=True,
                             )
                             _model_info = gr.Markdown(
-                                "**gpt-4.1**: Best quality | **gpt-4.1-nano**: Faster/Cheaper"
+                                "**gpt-4.1**: Best quality | **gpt-4.1-nano**: Faster/Cheaper",
                             )
                             topic_number = gr.Slider(
                                 label="Number of Topics",
@@ -328,6 +311,161 @@ def create_ankigen_interface():
                                 value=False,
                             )
 
+                            # Agent System Controls (simplified since we're agent-only)
+                            if AGENTS_AVAILABLE_APP:
+                                # Hidden dropdown for compatibility - always set to agent_only
+                                agent_mode_dropdown = gr.Dropdown(
+                                    choices=[("Agent Only", "agent_only")],
+                                    value="agent_only",
+                                    label="Agent Mode",
+                                    visible=False,
+                                )
+
+                                with gr.Accordion("Agent Configuration", open=False):
+                                    gr.Markdown("**Core Generation Pipeline**")
+                                    enable_subject_expert = gr.Checkbox(
+                                        label="Subject Expert Agent",
+                                        value=True,
+                                        info="Domain-specific expertise",
+                                    )
+                                    enable_generation_coordinator = gr.Checkbox(
+                                        label="Generation Coordinator",
+                                        value=True,
+                                        info="Orchestrates multi-agent generation",
+                                    )
+
+                                    gr.Markdown("**Quality Assurance**")
+                                    enable_content_judge = gr.Checkbox(
+                                        label="Content Accuracy Judge",
+                                        value=True,
+                                        info="Factual correctness validation",
+                                    )
+                                    enable_clarity_judge = gr.Checkbox(
+                                        label="Clarity Judge",
+                                        value=True,
+                                        info="Language clarity and comprehension",
+                                    )
+
+                                    gr.Markdown("**Optional Enhancements**")
+                                    enable_pedagogical_agent = gr.Checkbox(
+                                        label="Pedagogical Agent",
+                                        value=False,
+                                        info="Educational effectiveness review",
+                                    )
+                                    enable_pedagogical_judge = gr.Checkbox(
+                                        label="Pedagogical Judge",
+                                        value=False,
+                                        info="Learning theory compliance",
+                                    )
+                                    enable_enhancement_agent = gr.Checkbox(
+                                        label="Enhancement Agent",
+                                        value=False,
+                                        info="Content enrichment and metadata",
+                                    )
+
+                                    with gr.Accordion(
+                                        "🛠️ Agent Model Selection", open=False
+                                    ):
+                                        gr.Markdown("**Individual Agent Models**")
+
+                                        # Generator models
+                                        subject_expert_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1",
+                                            label="Subject Expert Model",
+                                            info="Model for domain expertise",
+                                            allow_custom_value=True,
+                                        )
+                                        generation_coordinator_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1-nano",
+                                            label="Generation Coordinator Model",
+                                            info="Model for orchestration",
+                                            allow_custom_value=True,
+                                        )
+
+                                        # Judge models
+                                        content_judge_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1",
+                                            label="Content Accuracy Judge Model",
+                                            info="Model for fact-checking",
+                                            allow_custom_value=True,
+                                        )
+                                        clarity_judge_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1-nano",
+                                            label="Clarity Judge Model",
+                                            info="Model for language clarity",
+                                            allow_custom_value=True,
+                                        )
+
+                                        # Enhancement models
+                                        pedagogical_agent_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1",
+                                            label="Pedagogical Agent Model",
+                                            info="Model for educational theory",
+                                            allow_custom_value=True,
+                                        )
+                                        enhancement_agent_model = gr.Dropdown(
+                                            choices=model_choices_ui,
+                                            value="gpt-4.1",
+                                            label="Enhancement Agent Model",
+                                            info="Model for content enrichment",
+                                            allow_custom_value=True,
+                                        )
+                            else:
+                                # Placeholder when agents not available
+                                agent_mode_dropdown = gr.Dropdown(
+                                    choices=[("Legacy Only", "legacy")],
+                                    value="legacy",
+                                    label="Agent Mode",
+                                    info="Agent system not available",
+                                    interactive=False,
+                                )
+                                enable_subject_expert = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_generation_coordinator = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_pedagogical_agent = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_content_judge = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_clarity_judge = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_pedagogical_judge = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+                                enable_enhancement_agent = gr.Checkbox(
+                                    value=False, visible=False
+                                )
+
+                                # Hidden model dropdowns for non-agent mode
+                                subject_expert_model = gr.Dropdown(
+                                    value="gpt-4.1", visible=False
+                                )
+                                generation_coordinator_model = gr.Dropdown(
+                                    value="gpt-4.1-nano", visible=False
+                                )
+                                content_judge_model = gr.Dropdown(
+                                    value="gpt-4.1", visible=False
+                                )
+                                clarity_judge_model = gr.Dropdown(
+                                    value="gpt-4.1-nano", visible=False
+                                )
+                                pedagogical_agent_model = gr.Dropdown(
+                                    value="gpt-4.1", visible=False
+                                )
+                                enhancement_agent_model = gr.Dropdown(
+                                    value="gpt-4.1", visible=False
+                                )
+
             generate_button = gr.Button("Generate Cards", variant="primary")
 
             with gr.Group(visible=False) as path_results:
@@ -349,7 +487,7 @@ def create_ankigen_interface():
                 gr.Markdown("### Generated Cards")
                 with gr.Accordion("Output Format", open=False):
                     gr.Markdown(
-                        "Cards: Index, Topic, Type, Q, A, Explanation, Example, Prerequisites, Outcomes, Misconceptions, Difficulty. Export: CSV, .apkg"
+                        "Cards: Index, Topic, Type, Q, A, Explanation, Example, Prerequisites, Outcomes, Misconceptions, Difficulty. Export: CSV, .apkg",
                     )
                     with gr.Accordion("Example Card Format", open=False):
                         gr.Code(
@@ -407,6 +545,12 @@ def create_ankigen_interface():
                     visible=False,
                 )
 
+                # Token usage display
+                token_usage_html = gr.HTML(
+                    value="<div style='margin-top: 8px;'><b>Token Usage:</b> <span id='token-usage-display'>No usage data</span></div>",
+                    visible=True,
+                )
+
                 # Export buttons
                 with gr.Row(elem_classes="export-group"):
                     export_csv_button = gr.Button("Export to CSV")
@@ -465,11 +609,11 @@ def create_ankigen_interface():
                     # to prevent a subsequent Gradio error about mismatched return values.
                     gr.Error(str(e))  # This will be shown in the UI.
                     empty_subjects_df = pd.DataFrame(
-                        columns=["Subject", "Prerequisites", "Time Estimate"]
+                        columns=["Subject", "Prerequisites", "Time Estimate"],
                     )
                     return (
                         gr.update(
-                            value=empty_subjects_df
+                            value=empty_subjects_df,
                         ),  # For subjects_list (DataFrame)
                         gr.update(value=""),  # For learning_order (Markdown)
                         gr.update(value=""),  # For projects (Markdown)
@@ -523,8 +667,96 @@ def create_ankigen_interface():
                 preference_prompt_val,
                 generate_cloze_checkbox_val,
                 llm_judge_checkbox_val,
+                agent_mode_val,
+                enable_subject_expert_val,
+                enable_generation_coordinator_val,
+                enable_pedagogical_agent_val,
+                enable_content_judge_val,
+                enable_clarity_judge_val,
+                enable_pedagogical_judge_val,
+                enable_enhancement_agent_val,
+                subject_expert_model_val,
+                generation_coordinator_model_val,
+                content_judge_model_val,
+                clarity_judge_model_val,
+                pedagogical_agent_model_val,
+                enhancement_agent_model_val,
                 progress=gr.Progress(track_tqdm=True),  # Added progress tracker
             ):
+                # Apply agent settings if agents are available
+                if AGENTS_AVAILABLE_APP:
+                    import os
+
+                    # Set agent mode
+                    os.environ["ANKIGEN_AGENT_MODE"] = agent_mode_val
+
+                    # Set individual agent flags (using correct environment variable names)
+                    os.environ["ANKIGEN_ENABLE_SUBJECT_EXPERT"] = str(
+                        enable_subject_expert_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_GENERATION_COORDINATOR"] = str(
+                        enable_generation_coordinator_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_PEDAGOGICAL_AGENT"] = str(
+                        enable_pedagogical_agent_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_CONTENT_JUDGE"] = str(
+                        enable_content_judge_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_CLARITY_JUDGE"] = str(
+                        enable_clarity_judge_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_PEDAGOGICAL_JUDGE"] = str(
+                        enable_pedagogical_judge_val
+                    ).lower()
+                    os.environ["ANKIGEN_ENABLE_ENHANCEMENT_AGENT"] = str(
+                        enable_enhancement_agent_val
+                    ).lower()
+
+                    # Enable additional required flags for proper agent coordination
+                    os.environ["ANKIGEN_ENABLE_JUDGE_COORDINATOR"] = (
+                        "true"  # Required for judge coordination
+                    )
+                    os.environ["ANKIGEN_ENABLE_PARALLEL_JUDGING"] = (
+                        "true"  # Enable parallel judging for performance
+                    )
+
+                    # Configure agent models from UI selections
+                    model_overrides = {
+                        "subject_expert": subject_expert_model_val,
+                        "generation_coordinator": generation_coordinator_model_val,
+                        "content_accuracy_judge": content_judge_model_val,
+                        "clarity_judge": clarity_judge_model_val,
+                        "pedagogical_agent": pedagogical_agent_model_val,
+                        "enhancement_agent": enhancement_agent_model_val,
+                    }
+
+                    # Template variables for Jinja rendering
+                    template_vars = {
+                        "subject": subject_val or "general studies",
+                        "difficulty": "intermediate",  # Could be made configurable
+                        "topic": subject_val or "general concepts",
+                    }
+
+                    # Initialize config manager with model overrides and template variables
+                    from ankigen_core.agents.config import get_config_manager
+
+                    get_config_manager(model_overrides, template_vars)
+
+                    # Log the agent configuration
+                    logger.info(f"Agent mode set to: {agent_mode_val}")
+                    logger.info(f"Model overrides: {model_overrides}")
+                    logger.info(
+                        f"Active agents: Subject Expert={enable_subject_expert_val}, Generation Coordinator={enable_generation_coordinator_val}, Content Judge={enable_content_judge_val}, Clarity Judge={enable_clarity_judge_val}"
+                    )
+
+                    # Reload feature flags to pick up the new environment variables
+                    try:
+                        # Agent system is available
+                        logger.info("Agent system enabled")
+                    except Exception as e:
+                        logger.warning(f"Failed to reload feature flags: {e}")
+
                 # Recreate the partial function call, but now it can be awaited
                 # The actual orchestrate_card_generation is already partially applied with client_manager and response_cache
                 # So, we need to get that specific partial object if it's stored, or redefine the partial logic here.
@@ -544,6 +776,7 @@ def create_ankigen_interface():
                     generate_cloze_checkbox_val,
                     llm_judge_checkbox_val,
                 )
+                # Expect 3-tuple return (dataframe, total_cards_html, token_usage_html)
 
             generate_button.click(
                 fn=handle_generate_click,  # MODIFIED: Use the new async handler
@@ -559,8 +792,22 @@ def create_ankigen_interface():
                     preference_prompt,
                     generate_cloze_checkbox,
                     llm_judge_checkbox,
+                    agent_mode_dropdown,
+                    enable_subject_expert,
+                    enable_generation_coordinator,
+                    enable_pedagogical_agent,
+                    enable_content_judge,
+                    enable_clarity_judge,
+                    enable_pedagogical_judge,
+                    enable_enhancement_agent,
+                    subject_expert_model,
+                    generation_coordinator_model,
+                    content_judge_model,
+                    clarity_judge_model,
+                    pedagogical_agent_model,
+                    enhancement_agent_model,
                 ],
-                outputs=[output, total_cards_html],
+                outputs=[output, total_cards_html, token_usage_html],
                 show_progress="full",
             )
 
@@ -583,19 +830,19 @@ def create_ankigen_interface():
                     if exported_path_relative:
                         exported_path_absolute = os.path.abspath(exported_path_relative)
                         gr.Info(
-                            f"CSV ready for download: {os.path.basename(exported_path_absolute)}"
+                            f"CSV ready for download: {os.path.basename(exported_path_absolute)}",
                         )
                         return gr.update(value=exported_path_absolute, visible=True)
-                    else:
-                        # This case might happen if export_dataframe_to_csv itself had an internal issue
-                        # and returned None, though it typically raises an error or returns path.
-                        gr.Warning("CSV export failed or returned no path.")
-                        return gr.update(value=None, visible=False)
+                    # This case might happen if export_dataframe_to_csv itself had an internal issue
+                    # and returned None, though it typically raises an error or returns path.
+                    gr.Warning("CSV export failed or returned no path.")
+                    return gr.update(value=None, visible=False)
                 except Exception as e:
                     logger.error(
-                        f"Error exporting DataFrame to CSV: {e}", exc_info=True
+                        f"Error exporting DataFrame to CSV: {e}",
+                        exc_info=True,
                     )
-                    gr.Error(f"Failed to export to CSV: {str(e)}")
+                    gr.Error(f"Failed to export to CSV: {e!s}")
                     return gr.update(value=None, visible=False)
 
             export_csv_button.click(
@@ -607,7 +854,8 @@ def create_ankigen_interface():
 
             # Define handler for APKG export from DataFrame (Item 5)
             async def handle_export_dataframe_to_apkg_click(
-                df: pd.DataFrame, subject_for_deck_name: str
+                df: pd.DataFrame,
+                subject_for_deck_name: str,
             ):
                 if df is None or df.empty:
                     gr.Warning("No cards generated to export.")
@@ -620,13 +868,17 @@ def create_ankigen_interface():
                 )
                 if subject_for_deck_name and subject_for_deck_name.strip():
                     clean_subject = re.sub(
-                        r"[^a-zA-Z0-9\s_.-]", "", subject_for_deck_name.strip()
+                        r"[^a-zA-Z0-9\s_.-]",
+                        "",
+                        subject_for_deck_name.strip(),
                     )
                     deck_name_inside_anki = f"AnkiGen - {clean_subject}"
                 elif not df.empty and "Topic" in df.columns and df["Topic"].iloc[0]:
                     first_topic = df["Topic"].iloc[0]
                     clean_first_topic = re.sub(
-                        r"[^a-zA-Z0-9\s_.-]", "", str(first_topic).strip()
+                        r"[^a-zA-Z0-9\s_.-]",
+                        "",
+                        str(first_topic).strip(),
                     )
                     deck_name_inside_anki = f"AnkiGen - {clean_first_topic}"
                 else:
@@ -657,14 +909,15 @@ def create_ankigen_interface():
                     exported_path_absolute = os.path.abspath(exported_path_relative)
 
                     gr.Info(
-                        f"Successfully exported deck '{deck_name_inside_anki}' to {exported_path_absolute}"
+                        f"Successfully exported deck '{deck_name_inside_anki}' to {exported_path_absolute}",
                     )
                     return gr.update(value=exported_path_absolute, visible=True)
                 except Exception as e:
                     logger.error(
-                        f"Error exporting DataFrame to APKG: {e}", exc_info=True
+                        f"Error exporting DataFrame to APKG: {e}",
+                        exc_info=True,
                     )
-                    gr.Error(f"Failed to export to APKG: {str(e)}")
+                    gr.Error(f"Failed to export to APKG: {e!s}")
                     return gr.update(value=None, visible=False)
 
             # Wire button to handler (Item 6)
@@ -675,9 +928,6 @@ def create_ankigen_interface():
                 api_name="export_main_to_apkg",
             )
 
-            # --- CRAWLER EVENT HANDLER (Task 16) ---
-            # This handler is for the new "Crawl Content & Prepare Cards" button within web_mode
-
             async def handle_web_crawl_click(
                 api_key_val: str,
                 url: str,
@@ -695,7 +945,7 @@ def create_ankigen_interface():
                 progress(0, desc="Initializing web crawl...")
                 yield {
                     web_crawl_status_textbox: gr.update(
-                        value="Initializing web crawl..."
+                        value="Initializing web crawl...",
                     ),
                     output: gr.update(value=None),  # Clear main output table
                     total_cards_html: gr.update(
@@ -708,7 +958,7 @@ def create_ankigen_interface():
                     logger.error("API Key is missing for web crawler operation.")
                     yield {
                         web_crawl_status_textbox: gr.update(
-                            value="Error: OpenAI API Key is required."
+                            value="Error: OpenAI API Key is required.",
                         ),
                     }
                     return
@@ -721,7 +971,7 @@ def create_ankigen_interface():
                     )
                     yield {
                         web_crawl_status_textbox: gr.update(
-                            value=f"Error: Client init failed: {str(e)}"
+                            value=f"Error: Client init failed: {e!s}",
                         ),
                     }
                     return
@@ -760,7 +1010,7 @@ def create_ankigen_interface():
                                 col in preview_df_value.columns for col in expected_cols
                             ):
                                 logger.warning(
-                                    "Crawled card data columns mismatch main output, attempting to use available data."
+                                    "Crawled card data columns mismatch main output, attempting to use available data.",
                                 )
                                 # Potentially select only common columns or reindex if necessary
                                 # For now, we'll pass it as is, Gradio might handle extra/missing cols gracefully or error.
@@ -772,7 +1022,8 @@ def create_ankigen_interface():
                             web_crawl_status_textbox: gr.update(value=message),
                             output: gr.update(value=preview_df_value),
                             total_cards_html: gr.update(
-                                visible=True, value=total_cards_update
+                                visible=True,
+                                value=total_cards_update,
                             ),
                         }
                     except Exception as e:
@@ -782,7 +1033,7 @@ def create_ankigen_interface():
                         )
                         yield {
                             web_crawl_status_textbox: gr.update(
-                                value=f"{message} (Error displaying cards: {str(e)})"
+                                value=f"{message} (Error displaying cards: {e!s})",
                             ),
                             output: gr.update(value=None),
                             total_cards_html: gr.update(visible=False),
@@ -790,36 +1041,12 @@ def create_ankigen_interface():
                 else:
                     yield {
                         web_crawl_status_textbox: gr.update(
-                            value=message
+                            value=message,
                         ),  # Message from crawl_and_generate (e.g. no cards)
                         output: gr.update(value=None),
                         total_cards_html: gr.update(visible=False),
                     }
 
-            # Wire the new crawl button
-            # Need to get the actual UI components from crawler_input_ui_elements by index or name
-            # Assuming create_crawler_main_mode_elements returns them in a predictable order in the list
-            # or returns them individually. The Tuple return is better.
-
-            # crawler_input_ui_elements[0] is url_input
-            # crawler_input_ui_elements[1] is max_depth_slider
-            # crawler_input_ui_elements[2] is crawler_req_per_sec_slider
-            # crawler_input_ui_elements[3] is model_dropdown
-            # crawler_input_ui_elements[4] is include_patterns_textbox
-            # crawler_input_ui_elements[5] is exclude_patterns_textbox
-
-            # The other components are returned individually:
-            # web_crawl_custom_system_prompt, web_crawl_custom_user_prompt_template,
-            # web_crawl_use_sitemap_checkbox, web_crawl_sitemap_url_textbox
-
-            # Already unpacked above:
-            # web_crawl_url_input = crawler_input_ui_elements[0]
-            # web_crawl_max_depth_slider = crawler_input_ui_elements[1]
-            # web_crawl_req_per_sec_slider = crawler_input_ui_elements[2]
-            # web_crawl_model_dropdown = crawler_input_ui_elements[3] # model for LLM processing
-            # web_crawl_include_patterns_textbox = crawler_input_ui_elements[4]
-            # web_crawl_exclude_patterns_textbox = crawler_input_ui_elements[5]
-
             web_crawl_button.click(
                 fn=handle_web_crawl_click,
                 inputs=[
@@ -858,7 +1085,7 @@ if __name__ == "__main__":
             ankigen_interface.launch(share=False, favicon_path=str(favicon_path))
         else:
             logger.warning(
-                f"Favicon not found at {favicon_path}, launching without it."
+                f"Favicon not found at {favicon_path}, launching without it.",
             )
             ankigen_interface.launch(share=False)
     except Exception as e:

uv.lock

@@ -25,6 +25,7 @@ dependencies = [
     { name = "gradio" },
     { name = "lxml" },
     { name = "openai" },
+    { name = "openai-agents" },
     { name = "pandas" },
     { name = "pydantic" },
     { name = "tenacity" },
@@ -50,6 +51,7 @@ requires-dist = [
     { name = "gradio", specifier = ">=5.34.2" },
     { name = "lxml", specifier = "==5.2.2" },
     { name = "openai", specifier = ">=1.91.0" },
+    { name = "openai-agents", specifier = ">=0.1.0" },
     { name = "pandas", specifier = "==2.2.3" },
     { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=4.2.0" },
     { name = "pydantic", specifier = "==2.10.6" },
@@ -86,6 +88,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
 ]
 
+[[package]]
+name = "attrs"
+version = "25.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload-time = "2025-03-13T11:10:22.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" },
+]
+
 [[package]]
 name = "audioop-lts"
 version = "0.2.1"
@@ -438,6 +449,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ea/72/1e76abc821f8efaaeb2e3bd727a6c97bf87c6a9a0ffacfed0647e587824a/gradio_client-1.10.3-py3-none-any.whl", hash = "sha256:941e7f8d9a160f88487e9780a3db2736a40ea2b8b69d53ffdb306e47ef658b76", size = 323599, upload-time = "2025-06-10T00:51:45.204Z" },
 ]
 
+[[package]]
+name = "griffe"
+version = "1.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/3e/5aa9a61f7c3c47b0b52a1d930302992229d191bf4bc76447b324b731510a/griffe-1.7.3.tar.gz", hash = "sha256:52ee893c6a3a968b639ace8015bec9d36594961e156e23315c8e8e51401fa50b", size = 395137, upload-time = "2025-04-23T11:29:09.147Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/c6/5c20af38c2a57c15d87f7f38bee77d63c1d2a3689f74fefaf35915dd12b2/griffe-1.7.3-py3-none-any.whl", hash = "sha256:c6b3ee30c2f0f17f30bcdef5068d6ab7a2a4f1b8bf1a3e74b56fffd21e1c5f75", size = 129303, upload-time = "2025-04-23T11:29:07.145Z" },
+]
+
 [[package]]
 name = "groovy"
 version = "0.1.2"
@@ -499,6 +522,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
+[[package]]
+name = "httpx-sse"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6e/fa/66bd985dd0b7c109a3bcb89272ee0bfb7e2b4d06309ad7b38ff866734b2a/httpx_sse-0.4.1.tar.gz", hash = "sha256:8f44d34414bc7b21bf3602713005c5df4917884f76072479b21f68befa4ea26e", size = 12998, upload-time = "2025-06-24T13:21:05.71Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/0a/6269e3473b09aed2dab8aa1a600c70f31f00ae1349bee30658f7e358a159/httpx_sse-0.4.1-py3-none-any.whl", hash = "sha256:cba42174344c3a5b06f255ce65b350880f962d99ead85e776f23c6618a377a37", size = 8054, upload-time = "2025-06-24T13:21:04.772Z" },
+]
+
 [[package]]
 name = "huggingface-hub"
 version = "0.33.1"
@@ -605,6 +637,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/4a/4175a563579e884192ba6e81725fc0448b042024419be8d83aa8a80a3f44/jiter-0.10.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3aa96f2abba33dc77f79b4cf791840230375f9534e5fac927ccceb58c5e604a5", size = 354213, upload-time = "2025-05-18T19:04:41.894Z" },
 ]
 
+[[package]]
+name = "jsonschema"
+version = "4.24.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bf/d3/1cf5326b923a53515d8f3a2cd442e6d7e94fcc444716e879ea70a0ce3177/jsonschema-4.24.0.tar.gz", hash = "sha256:0b4e8069eb12aedfa881333004bccaec24ecef5a8a6a4b6df142b2cc9599d196", size = 353480, upload-time = "2025-05-26T18:48:10.459Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/3d/023389198f69c722d039351050738d6755376c8fd343e91dc493ea485905/jsonschema-4.24.0-py3-none-any.whl", hash = "sha256:a462455f19f5faf404a7902952b6f0e3ce868f3ee09a359b05eca6673bd8412d", size = 88709, upload-time = "2025-05-26T18:48:08.417Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bf/ce/46fbd9c8119cfc3581ee5643ea49464d168028cfb5caff5fc0596d0cf914/jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608", size = 15513, upload-time = "2025-04-23T12:34:07.418Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/0e/b27cdbaccf30b890c40ed1da9fd4a3593a5cf94dae54fb34f8a4b74fcd3f/jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af", size = 18437, upload-time = "2025-04-23T12:34:05.422Z" },
+]
+
 [[package]]
 name = "lxml"
 version = "5.2.2"
@@ -684,6 +743,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" },
 ]
 
+[[package]]
+name = "mcp"
+version = "1.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "jsonschema" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "python-multipart" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/68/63045305f29ff680a9cd5be360c755270109e6b76f696ea6824547ddbc30/mcp-1.10.1.tar.gz", hash = "sha256:aaa0957d8307feeff180da2d9d359f2b801f35c0c67f1882136239055ef034c2", size = 392969, upload-time = "2025-06-27T12:03:08.982Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/3f/435a5b3d10ae242a9d6c2b33175551173c3c61fe637dc893be05c4ed0aaf/mcp-1.10.1-py3-none-any.whl", hash = "sha256:4d08301aefe906dce0fa482289db55ce1db831e3e67212e65b5e23ad8454b3c5", size = 150878, upload-time = "2025-06-27T12:03:07.328Z" },
+]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -771,6 +851,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7a/d2/f99bdd6fc737d6b3cf0df895508d621fc9a386b375a1230ee81d46c5436e/openai-1.91.0-py3-none-any.whl", hash = "sha256:207f87aa3bc49365e014fac2f7e291b99929f4fe126c4654143440e0ad446a5f", size = 735837, upload-time = "2025-06-23T18:27:08.913Z" },
 ]
 
+[[package]]
+name = "openai-agents"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffe" },
+    { name = "mcp" },
+    { name = "openai" },
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "types-requests" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/99/f8/a292d8f506997355755d88db619966539ec838ce18f070c5a101e5a430ec/openai_agents-0.1.0.tar.gz", hash = "sha256:a697a4fdd881a7a16db8c0dcafba0f17d9e90b6236a4b79923bd043b6ae86d80", size = 1379588, upload-time = "2025-06-27T20:58:03.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/5b/326e6b1b661dbef718977a8379f9702a4eec1df772450517870beeb3af35/openai_agents-0.1.0-py3-none-any.whl", hash = "sha256:6a8ef71d3f20aecba0f01bca2e059590d1c23f5adc02d780cb5921ea8a7ca774", size = 130620, upload-time = "2025-06-27T20:58:01.461Z" },
+]
+
 [[package]]
 name = "orjson"
 version = "3.10.18"
@@ -989,6 +1087,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186, upload-time = "2024-12-18T11:29:37.649Z" },
 ]
 
+[[package]]
+name = "pydantic-settings"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
+]
+
 [[package]]
 name = "pydub"
 version = "0.25.1"
@@ -1074,6 +1186,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
 ]
 
+[[package]]
+name = "python-dotenv"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
+]
+
 [[package]]
 name = "python-multipart"
 version = "0.0.20"
@@ -1118,6 +1239,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" },
 ]
 
+[[package]]
+name = "referencing"
+version = "0.36.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" },
+]
+
 [[package]]
 name = "regex"
 version = "2024.11.6"
@@ -1184,6 +1319,82 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229, upload-time = "2025-03-30T14:15:12.283Z" },
 ]
 
+[[package]]
+name = "rpds-py"
+version = "0.26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/aa/4456d84bbb54adc6a916fb10c9b374f78ac840337644e4a5eda229c81275/rpds_py-0.26.0.tar.gz", hash = "sha256:20dae58a859b0906f0685642e591056f1e787f3a8b39c8e8749a45dc7d26bdb0", size = 27385, upload-time = "2025-07-01T15:57:13.958Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/86/90eb87c6f87085868bd077c7a9938006eb1ce19ed4d06944a90d3560fce2/rpds_py-0.26.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:894514d47e012e794f1350f076c427d2347ebf82f9b958d554d12819849a369d", size = 363933, upload-time = "2025-07-01T15:54:15.734Z" },
+    { url = "https://files.pythonhosted.org/packages/63/78/4469f24d34636242c924626082b9586f064ada0b5dbb1e9d096ee7a8e0c6/rpds_py-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc921b96fa95a097add244da36a1d9e4f3039160d1d30f1b35837bf108c21136", size = 350447, upload-time = "2025-07-01T15:54:16.922Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/91/c448ed45efdfdade82348d5e7995e15612754826ea640afc20915119734f/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e1157659470aa42a75448b6e943c895be8c70531c43cb78b9ba990778955582", size = 384711, upload-time = "2025-07-01T15:54:18.101Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/43/e5c86fef4be7f49828bdd4ecc8931f0287b1152c0bb0163049b3218740e7/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:521ccf56f45bb3a791182dc6b88ae5f8fa079dd705ee42138c76deb1238e554e", size = 400865, upload-time = "2025-07-01T15:54:19.295Z" },
+    { url = "https://files.pythonhosted.org/packages/55/34/e00f726a4d44f22d5c5fe2e5ddd3ac3d7fd3f74a175607781fbdd06fe375/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9def736773fd56b305c0eef698be5192c77bfa30d55a0e5885f80126c4831a15", size = 517763, upload-time = "2025-07-01T15:54:20.858Z" },
+    { url = "https://files.pythonhosted.org/packages/52/1c/52dc20c31b147af724b16104500fba13e60123ea0334beba7b40e33354b4/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdad4ea3b4513b475e027be79e5a0ceac8ee1c113a1a11e5edc3c30c29f964d8", size = 406651, upload-time = "2025-07-01T15:54:22.508Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/77/87d7bfabfc4e821caa35481a2ff6ae0b73e6a391bb6b343db2c91c2b9844/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82b165b07f416bdccf5c84546a484cc8f15137ca38325403864bfdf2b5b72f6a", size = 386079, upload-time = "2025-07-01T15:54:23.987Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d4/7f2200c2d3ee145b65b3cddc4310d51f7da6a26634f3ac87125fd789152a/rpds_py-0.26.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d04cab0a54b9dba4d278fe955a1390da3cf71f57feb78ddc7cb67cbe0bd30323", size = 421379, upload-time = "2025-07-01T15:54:25.073Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/13/9fdd428b9c820869924ab62236b8688b122baa22d23efdd1c566938a39ba/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:79061ba1a11b6a12743a2b0f72a46aa2758613d454aa6ba4f5a265cc48850158", size = 562033, upload-time = "2025-07-01T15:54:26.225Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e1/b69686c3bcbe775abac3a4c1c30a164a2076d28df7926041f6c0eb5e8d28/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f405c93675d8d4c5ac87364bb38d06c988e11028a64b52a47158a355079661f3", size = 591639, upload-time = "2025-07-01T15:54:27.424Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/c9/1e3d8c8863c84a90197ac577bbc3d796a92502124c27092413426f670990/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dafd4c44b74aa4bed4b250f1aed165b8ef5de743bcca3b88fc9619b6087093d2", size = 557105, upload-time = "2025-07-01T15:54:29.93Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/c5/90c569649057622959f6dcc40f7b516539608a414dfd54b8d77e3b201ac0/rpds_py-0.26.0-cp312-cp312-win32.whl", hash = "sha256:3da5852aad63fa0c6f836f3359647870e21ea96cf433eb393ffa45263a170d44", size = 223272, upload-time = "2025-07-01T15:54:31.128Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/16/19f5d9f2a556cfed454eebe4d354c38d51c20f3db69e7b4ce6cff904905d/rpds_py-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:cf47cfdabc2194a669dcf7a8dbba62e37a04c5041d2125fae0233b720da6f05c", size = 234995, upload-time = "2025-07-01T15:54:32.195Z" },
+    { url = "https://files.pythonhosted.org/packages/83/f0/7935e40b529c0e752dfaa7880224771b51175fce08b41ab4a92eb2fbdc7f/rpds_py-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:20ab1ae4fa534f73647aad289003f1104092890849e0266271351922ed5574f8", size = 223198, upload-time = "2025-07-01T15:54:33.271Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/67/bb62d0109493b12b1c6ab00de7a5566aa84c0e44217c2d94bee1bd370da9/rpds_py-0.26.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:696764a5be111b036256c0b18cd29783fab22154690fc698062fc1b0084b511d", size = 363917, upload-time = "2025-07-01T15:54:34.755Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f3/34e6ae1925a5706c0f002a8d2d7f172373b855768149796af87bd65dcdb9/rpds_py-0.26.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e6c15d2080a63aaed876e228efe4f814bc7889c63b1e112ad46fdc8b368b9e1", size = 350073, upload-time = "2025-07-01T15:54:36.292Z" },
+    { url = "https://files.pythonhosted.org/packages/75/83/1953a9d4f4e4de7fd0533733e041c28135f3c21485faaef56a8aadbd96b5/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:390e3170babf42462739a93321e657444f0862c6d722a291accc46f9d21ed04e", size = 384214, upload-time = "2025-07-01T15:54:37.469Z" },
+    { url = "https://files.pythonhosted.org/packages/48/0e/983ed1b792b3322ea1d065e67f4b230f3b96025f5ce3878cc40af09b7533/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7da84c2c74c0f5bc97d853d9e17bb83e2dcafcff0dc48286916001cc114379a1", size = 400113, upload-time = "2025-07-01T15:54:38.954Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/36c0925fff6f660a80be259c5b4f5e53a16851f946eb080351d057698528/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c5fe114a6dd480a510b6d3661d09d67d1622c4bf20660a474507aaee7eeeee9", size = 515189, upload-time = "2025-07-01T15:54:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/13/45/cbf07fc03ba7a9b54662c9badb58294ecfb24f828b9732970bd1a431ed5c/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3100b3090269f3a7ea727b06a6080d4eb7439dca4c0e91a07c5d133bb1727ea7", size = 406998, upload-time = "2025-07-01T15:54:43.025Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/b0/8fa5e36e58657997873fd6a1cf621285ca822ca75b4b3434ead047daa307/rpds_py-0.26.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c03c9b0c64afd0320ae57de4c982801271c0c211aa2d37f3003ff5feb75bb04", size = 385903, upload-time = "2025-07-01T15:54:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f7/b25437772f9f57d7a9fbd73ed86d0dcd76b4c7c6998348c070d90f23e315/rpds_py-0.26.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5963b72ccd199ade6ee493723d18a3f21ba7d5b957017607f815788cef50eaf1", size = 419785, upload-time = "2025-07-01T15:54:46.043Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/6b/63ffa55743dfcb4baf2e9e77a0b11f7f97ed96a54558fcb5717a4b2cd732/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9da4e873860ad5bab3291438525cae80169daecbfafe5657f7f5fb4d6b3f96b9", size = 561329, upload-time = "2025-07-01T15:54:47.64Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/07/1f4f5e2886c480a2346b1e6759c00278b8a69e697ae952d82ae2e6ee5db0/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5afaddaa8e8c7f1f7b4c5c725c0070b6eed0228f705b90a1732a48e84350f4e9", size = 590875, upload-time = "2025-07-01T15:54:48.9Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/bc/e6639f1b91c3a55f8c41b47d73e6307051b6e246254a827ede730624c0f8/rpds_py-0.26.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4916dc96489616a6f9667e7526af8fa693c0fdb4f3acb0e5d9f4400eb06a47ba", size = 556636, upload-time = "2025-07-01T15:54:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/05/4c/b3917c45566f9f9a209d38d9b54a1833f2bb1032a3e04c66f75726f28876/rpds_py-0.26.0-cp313-cp313-win32.whl", hash = "sha256:2a343f91b17097c546b93f7999976fd6c9d5900617aa848c81d794e062ab302b", size = 222663, upload-time = "2025-07-01T15:54:52.023Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0b/0851bdd6025775aaa2365bb8de0697ee2558184c800bfef8d7aef5ccde58/rpds_py-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:0a0b60701f2300c81b2ac88a5fb893ccfa408e1c4a555a77f908a2596eb875a5", size = 234428, upload-time = "2025-07-01T15:54:53.692Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/e8/a47c64ed53149c75fb581e14a237b7b7cd18217e969c30d474d335105622/rpds_py-0.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:257d011919f133a4746958257f2c75238e3ff54255acd5e3e11f3ff41fd14256", size = 222571, upload-time = "2025-07-01T15:54:54.822Z" },
+    { url = "https://files.pythonhosted.org/packages/89/bf/3d970ba2e2bcd17d2912cb42874107390f72873e38e79267224110de5e61/rpds_py-0.26.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:529c8156d7506fba5740e05da8795688f87119cce330c244519cf706a4a3d618", size = 360475, upload-time = "2025-07-01T15:54:56.228Z" },
+    { url = "https://files.pythonhosted.org/packages/82/9f/283e7e2979fc4ec2d8ecee506d5a3675fce5ed9b4b7cb387ea5d37c2f18d/rpds_py-0.26.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f53ec51f9d24e9638a40cabb95078ade8c99251945dad8d57bf4aabe86ecee35", size = 346692, upload-time = "2025-07-01T15:54:58.561Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/03/7e50423c04d78daf391da3cc4330bdb97042fc192a58b186f2d5deb7befd/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab504c4d654e4a29558eaa5bb8cea5fdc1703ea60a8099ffd9c758472cf913f", size = 379415, upload-time = "2025-07-01T15:54:59.751Z" },
+    { url = "https://files.pythonhosted.org/packages/57/00/d11ee60d4d3b16808432417951c63df803afb0e0fc672b5e8d07e9edaaae/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd0641abca296bc1a00183fe44f7fced8807ed49d501f188faa642d0e4975b83", size = 391783, upload-time = "2025-07-01T15:55:00.898Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b3/1069c394d9c0d6d23c5b522e1f6546b65793a22950f6e0210adcc6f97c3e/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b312fecc1d017b5327afa81d4da1480f51c68810963a7336d92203dbb3d4f1", size = 512844, upload-time = "2025-07-01T15:55:02.201Z" },
+    { url = "https://files.pythonhosted.org/packages/08/3b/c4fbf0926800ed70b2c245ceca99c49f066456755f5d6eb8863c2c51e6d0/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c741107203954f6fc34d3066d213d0a0c40f7bb5aafd698fb39888af277c70d8", size = 402105, upload-time = "2025-07-01T15:55:03.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b0/db69b52ca07413e568dae9dc674627a22297abb144c4d6022c6d78f1e5cc/rpds_py-0.26.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc3e55a7db08dc9a6ed5fb7103019d2c1a38a349ac41901f9f66d7f95750942f", size = 383440, upload-time = "2025-07-01T15:55:05.398Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/e1/c65255ad5b63903e56b3bb3ff9dcc3f4f5c3badde5d08c741ee03903e951/rpds_py-0.26.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9e851920caab2dbcae311fd28f4313c6953993893eb5c1bb367ec69d9a39e7ed", size = 412759, upload-time = "2025-07-01T15:55:08.316Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/22/bb731077872377a93c6e93b8a9487d0406c70208985831034ccdeed39c8e/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dfbf280da5f876d0b00c81f26bedce274e72a678c28845453885a9b3c22ae632", size = 556032, upload-time = "2025-07-01T15:55:09.52Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/8b/393322ce7bac5c4530fb96fc79cc9ea2f83e968ff5f6e873f905c493e1c4/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:1cc81d14ddfa53d7f3906694d35d54d9d3f850ef8e4e99ee68bc0d1e5fed9a9c", size = 585416, upload-time = "2025-07-01T15:55:11.216Z" },
+    { url = "https://files.pythonhosted.org/packages/49/ae/769dc372211835bf759319a7aae70525c6eb523e3371842c65b7ef41c9c6/rpds_py-0.26.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dca83c498b4650a91efcf7b88d669b170256bf8017a5db6f3e06c2bf031f57e0", size = 554049, upload-time = "2025-07-01T15:55:13.004Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f9/4c43f9cc203d6ba44ce3146246cdc38619d92c7bd7bad4946a3491bd5b70/rpds_py-0.26.0-cp313-cp313t-win32.whl", hash = "sha256:4d11382bcaf12f80b51d790dee295c56a159633a8e81e6323b16e55d81ae37e9", size = 218428, upload-time = "2025-07-01T15:55:14.486Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/8b/9286b7e822036a4a977f2f1e851c7345c20528dbd56b687bb67ed68a8ede/rpds_py-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff110acded3c22c033e637dd8896e411c7d3a11289b2edf041f86663dbc791e9", size = 231524, upload-time = "2025-07-01T15:55:15.745Z" },
+    { url = "https://files.pythonhosted.org/packages/55/07/029b7c45db910c74e182de626dfdae0ad489a949d84a468465cd0ca36355/rpds_py-0.26.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:da619979df60a940cd434084355c514c25cf8eb4cf9a508510682f6c851a4f7a", size = 364292, upload-time = "2025-07-01T15:55:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d1/9b3d3f986216b4d1f584878dca15ce4797aaf5d372d738974ba737bf68d6/rpds_py-0.26.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ea89a2458a1a75f87caabefe789c87539ea4e43b40f18cff526052e35bbb4fdf", size = 350334, upload-time = "2025-07-01T15:55:18.922Z" },
+    { url = "https://files.pythonhosted.org/packages/18/98/16d5e7bc9ec715fa9668731d0cf97f6b032724e61696e2db3d47aeb89214/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feac1045b3327a45944e7dcbeb57530339f6b17baff154df51ef8b0da34c8c12", size = 384875, upload-time = "2025-07-01T15:55:20.399Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/13/aa5e2b1ec5ab0e86a5c464d53514c0467bec6ba2507027d35fc81818358e/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b818a592bd69bfe437ee8368603d4a2d928c34cffcdf77c2e761a759ffd17d20", size = 399993, upload-time = "2025-07-01T15:55:21.729Z" },
+    { url = "https://files.pythonhosted.org/packages/17/03/8021810b0e97923abdbab6474c8b77c69bcb4b2c58330777df9ff69dc559/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a8b0dd8648709b62d9372fc00a57466f5fdeefed666afe3fea5a6c9539a0331", size = 516683, upload-time = "2025-07-01T15:55:22.918Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b1/da8e61c87c2f3d836954239fdbbfb477bb7b54d74974d8f6fcb34342d166/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d3498ad0df07d81112aa6ec6c95a7e7b1ae00929fb73e7ebee0f3faaeabad2f", size = 408825, upload-time = "2025-07-01T15:55:24.207Z" },
+    { url = "https://files.pythonhosted.org/packages/38/bc/1fc173edaaa0e52c94b02a655db20697cb5fa954ad5a8e15a2c784c5cbdd/rpds_py-0.26.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24a4146ccb15be237fdef10f331c568e1b0e505f8c8c9ed5d67759dac58ac246", size = 387292, upload-time = "2025-07-01T15:55:25.554Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/eb/3a9bb4bd90867d21916f253caf4f0d0be7098671b6715ad1cead9fe7bab9/rpds_py-0.26.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a9a63785467b2d73635957d32a4f6e73d5e4df497a16a6392fa066b753e87387", size = 420435, upload-time = "2025-07-01T15:55:27.798Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/16/e066dcdb56f5632713445271a3f8d3d0b426d51ae9c0cca387799df58b02/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:de4ed93a8c91debfd5a047be327b7cc8b0cc6afe32a716bbbc4aedca9e2a83af", size = 562410, upload-time = "2025-07-01T15:55:29.057Z" },
+    { url = "https://files.pythonhosted.org/packages/60/22/ddbdec7eb82a0dc2e455be44c97c71c232983e21349836ce9f272e8a3c29/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:caf51943715b12af827696ec395bfa68f090a4c1a1d2509eb4e2cb69abbbdb33", size = 590724, upload-time = "2025-07-01T15:55:30.719Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/b4/95744085e65b7187d83f2fcb0bef70716a1ea0a9e5d8f7f39a86e5d83424/rpds_py-0.26.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4a59e5bc386de021f56337f757301b337d7ab58baa40174fb150accd480bc953", size = 558285, upload-time = "2025-07-01T15:55:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/37/37/6309a75e464d1da2559446f9c811aa4d16343cebe3dbb73701e63f760caa/rpds_py-0.26.0-cp314-cp314-win32.whl", hash = "sha256:92c8db839367ef16a662478f0a2fe13e15f2227da3c1430a782ad0f6ee009ec9", size = 223459, upload-time = "2025-07-01T15:55:33.312Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/6f/8e9c11214c46098b1d1391b7e02b70bb689ab963db3b19540cba17315291/rpds_py-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:b0afb8cdd034150d4d9f53926226ed27ad15b7f465e93d7468caaf5eafae0d37", size = 236083, upload-time = "2025-07-01T15:55:34.933Z" },
+    { url = "https://files.pythonhosted.org/packages/47/af/9c4638994dd623d51c39892edd9d08e8be8220a4b7e874fa02c2d6e91955/rpds_py-0.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:ca3f059f4ba485d90c8dc75cb5ca897e15325e4e609812ce57f896607c1c0867", size = 223291, upload-time = "2025-07-01T15:55:36.202Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/db/669a241144460474aab03e254326b32c42def83eb23458a10d163cb9b5ce/rpds_py-0.26.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5afea17ab3a126006dc2f293b14ffc7ef3c85336cf451564a0515ed7648033da", size = 361445, upload-time = "2025-07-01T15:55:37.483Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2d/133f61cc5807c6c2fd086a46df0eb8f63a23f5df8306ff9f6d0fd168fecc/rpds_py-0.26.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:69f0c0a3df7fd3a7eec50a00396104bb9a843ea6d45fcc31c2d5243446ffd7a7", size = 347206, upload-time = "2025-07-01T15:55:38.828Z" },
+    { url = "https://files.pythonhosted.org/packages/05/bf/0e8fb4c05f70273469eecf82f6ccf37248558526a45321644826555db31b/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:801a71f70f9813e82d2513c9a96532551fce1e278ec0c64610992c49c04c2dad", size = 380330, upload-time = "2025-07-01T15:55:40.175Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/a8/060d24185d8b24d3923322f8d0ede16df4ade226a74e747b8c7c978e3dd3/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df52098cde6d5e02fa75c1f6244f07971773adb4a26625edd5c18fee906fa84d", size = 392254, upload-time = "2025-07-01T15:55:42.015Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/7b/7c2e8a9ee3e6bc0bae26bf29f5219955ca2fbb761dca996a83f5d2f773fe/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9bc596b30f86dc6f0929499c9e574601679d0341a0108c25b9b358a042f51bca", size = 516094, upload-time = "2025-07-01T15:55:43.603Z" },
+    { url = "https://files.pythonhosted.org/packages/75/d6/f61cafbed8ba1499b9af9f1777a2a199cd888f74a96133d8833ce5eaa9c5/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9dfbe56b299cf5875b68eb6f0ebaadc9cac520a1989cac0db0765abfb3709c19", size = 402889, upload-time = "2025-07-01T15:55:45.275Z" },
+    { url = "https://files.pythonhosted.org/packages/92/19/c8ac0a8a8df2dd30cdec27f69298a5c13e9029500d6d76718130f5e5be10/rpds_py-0.26.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac64f4b2bdb4ea622175c9ab7cf09444e412e22c0e02e906978b3b488af5fde8", size = 384301, upload-time = "2025-07-01T15:55:47.098Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e1/6b1859898bc292a9ce5776016c7312b672da00e25cec74d7beced1027286/rpds_py-0.26.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:181ef9b6bbf9845a264f9aa45c31836e9f3c1f13be565d0d010e964c661d1e2b", size = 412891, upload-time = "2025-07-01T15:55:48.412Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/b9/ceb39af29913c07966a61367b3c08b4f71fad841e32c6b59a129d5974698/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:49028aa684c144ea502a8e847d23aed5e4c2ef7cadfa7d5eaafcb40864844b7a", size = 557044, upload-time = "2025-07-01T15:55:49.816Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/27/35637b98380731a521f8ec4f3fd94e477964f04f6b2f8f7af8a2d889a4af/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e5d524d68a474a9688336045bbf76cb0def88549c1b2ad9dbfec1fb7cfbe9170", size = 585774, upload-time = "2025-07-01T15:55:51.192Z" },
+    { url = "https://files.pythonhosted.org/packages/52/d9/3f0f105420fecd18551b678c9a6ce60bd23986098b252a56d35781b3e7e9/rpds_py-0.26.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1851f429b822831bd2edcbe0cfd12ee9ea77868f8d3daf267b189371671c80e", size = 554886, upload-time = "2025-07-01T15:55:52.541Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/c5/347c056a90dc8dd9bc240a08c527315008e1b5042e7a4cf4ac027be9d38a/rpds_py-0.26.0-cp314-cp314t-win32.whl", hash = "sha256:7bdb17009696214c3b66bb3590c6d62e14ac5935e53e929bcdbc5a495987a84f", size = 219027, upload-time = "2025-07-01T15:55:53.874Z" },
+    { url = "https://files.pythonhosted.org/packages/75/04/5302cea1aa26d886d34cadbf2dc77d90d7737e576c0065f357b96dc7a1a6/rpds_py-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f14440b9573a6f76b4ee4770c13f0b5921f71dde3b6fcb8dabbefd13b7fe05d7", size = 232821, upload-time = "2025-07-01T15:55:55.167Z" },
+]
+
 [[package]]
 name = "ruff"
 version = "0.12.0"
@@ -1266,6 +1477,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" },
 ]
 
+[[package]]
+name = "sse-starlette"
+version = "2.3.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/f4/989bc70cb8091eda43a9034ef969b25145291f3601703b82766e5172dfed/sse_starlette-2.3.6.tar.gz", hash = "sha256:0382336f7d4ec30160cf9ca0518962905e1b69b72d6c1c995131e0a703b436e3", size = 18284, upload-time = "2025-05-30T13:34:12.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/05/78850ac6e79af5b9508f8841b0f26aa9fd329a1ba00bf65453c2d312bcc8/sse_starlette-2.3.6-py3-none-any.whl", hash = "sha256:d49a8285b182f6e2228e2609c350398b2ca2c36216c2675d875f81e93548f760", size = 10606, upload-time = "2025-05-30T13:34:11.703Z" },
+]
+
 [[package]]
 name = "starlette"
 version = "0.46.2"
@@ -1347,6 +1570,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/76/42/3efaf858001d2c2913de7f354563e3a3a2f0decae3efe98427125a8f441e/typer-0.16.0-py3-none-any.whl", hash = "sha256:1f79bed11d4d02d4310e3c1b7ba594183bcedb0ac73b27a9e5f28f6fb5b98855", size = 46317, upload-time = "2025-05-26T14:30:30.523Z" },
 ]
 
+[[package]]
+name = "types-requests"
+version = "2.32.4.20250611"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/7f/73b3a04a53b0fd2a911d4ec517940ecd6600630b559e4505cc7b68beb5a0/types_requests-2.32.4.20250611.tar.gz", hash = "sha256:741c8777ed6425830bf51e54d6abe245f79b4dcb9019f1622b773463946bf826", size = 23118, upload-time = "2025-06-11T03:11:41.272Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/ea/0be9258c5a4fa1ba2300111aa5a0767ee6d18eb3fd20e91616c12082284d/types_requests-2.32.4.20250611-py3-none-any.whl", hash = "sha256:ad2fe5d3b0cb3c2c902c8815a70e7fb2302c4b8c1f77bdcd738192cdb3878072", size = 20643, upload-time = "2025-06-11T03:11:40.186Z" },
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.14.0"
@@ -1356,6 +1591,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839, upload-time = "2025-06-02T14:52:10.026Z" },
 ]
 
+[[package]]
+name = "typing-inspection"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },
+]
+
 [[package]]
 name = "tzdata"
 version = "2025.2"