complete workflow more testing needed

Author: Zvi Fried

src/mcp_as_a_judge/coding_task_manager.py

@@ -0,0 +1,224 @@
+"""
+Coding task manager for enhanced MCP as a Judge workflow v3.
+
+This module provides helper functions for managing coding tasks,
+including creation, updates, state transitions, and persistence.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Optional
+
+from mcp_as_a_judge.db.conversation_history_service import ConversationHistoryService
+from mcp_as_a_judge.models.task_metadata import TaskMetadata, TaskState
+
+# Set up logger directly to avoid circular imports
+logger = logging.getLogger(__name__)
+
+
+async def create_new_coding_task(
+    user_request: str,
+    task_name: str,
+    task_title: str,
+    task_description: str,
+    user_requirements: str,
+    tags: list[str],
+    conversation_service: ConversationHistoryService,
+) -> TaskMetadata:
+    """
+    Create a new coding task with auto-generated task_id.
+    
+    Args:
+        user_request: Original user request
+        task_name: Human-readable task name
+        task_title: Display title
+        task_description: Detailed description
+        user_requirements: Initial requirements
+        tags: Task tags
+        conversation_service: Conversation service
+        
+    Returns:
+        New TaskMetadata instance
+    """
+    logger.info(f"📝 Creating new coding task: {task_title}")
+    
+    # Create new TaskMetadata with auto-generated UUID
+    task_metadata = TaskMetadata(
+        name=task_name,
+        title=task_title,
+        description=task_description,
+        user_requirements=user_requirements,
+        state=TaskState.CREATED,  # Default state for new tasks
+        tags=tags,
+    )
+    
+    # Add initial requirements to history if provided
+    if user_requirements:
+        task_metadata.update_requirements(user_requirements, source="initial")
+    
+    logger.info(f"✅ Created new task metadata: {task_metadata.task_id}")
+    return task_metadata
+
+
+async def update_existing_coding_task(
+    task_id: str,
+    user_request: str,
+    task_name: str,
+    task_title: str,
+    task_description: str,
+    user_requirements: Optional[str],
+    state: Optional[TaskState],
+    tags: list[str],
+    conversation_service: ConversationHistoryService,
+) -> TaskMetadata:
+    """
+    Update an existing coding task.
+    
+    Args:
+        task_id: Immutable task ID
+        user_request: Original user request
+        task_name: Updated task name
+        task_title: Updated title
+        task_description: Updated description
+        user_requirements: Updated requirements
+        state: Updated state
+        tags: Updated tags
+        conversation_service: Conversation service
+        
+    Returns:
+        Updated TaskMetadata instance
+        
+    Raises:
+        ValueError: If task not found or invalid state transition
+    """
+    logger.info(f"📝 Updating existing coding task: {task_id}")
+    
+    # Load existing task metadata from conversation history
+    existing_metadata = await load_task_metadata_from_history(
+        task_id=task_id,
+        conversation_service=conversation_service,
+    )
+    
+    if not existing_metadata:
+        raise ValueError(f"Task not found: {task_id}")
+    
+    # Update mutable fields
+    existing_metadata.name = task_name
+    existing_metadata.title = task_title
+    existing_metadata.description = task_description
+    existing_metadata.tags = tags
+    existing_metadata.updated_at = datetime.now()
+    
+    # Update requirements if provided
+    if user_requirements is not None:
+        existing_metadata.update_requirements(user_requirements, source="update")
+    
+    # Update state if provided (with validation)
+    if state is not None:
+        validate_state_transition(existing_metadata.state, state)
+        existing_metadata.update_state(state)
+    
+    logger.info(f"✅ Updated task metadata: {task_id}")
+    return existing_metadata
+
+
+async def load_task_metadata_from_history(
+    task_id: str,
+    conversation_service: ConversationHistoryService,
+) -> Optional[TaskMetadata]:
+    """
+    Load TaskMetadata from conversation history using task_id as primary key.
+    
+    Args:
+        task_id: Task ID to load
+        conversation_service: Conversation service
+        
+    Returns:
+        TaskMetadata if found, None otherwise
+    """
+    try:
+        # Use task_id as primary key for conversation history
+        conversation_history = await conversation_service.get_conversation_history(
+            session_id=task_id
+        )
+        
+        # Look for the most recent task metadata record
+        for record in reversed(conversation_history):
+            if record.source == "set_coding_task" and "task_metadata" in record.output:
+                # Parse the task metadata from the record
+                output_data = json.loads(record.output)
+                if "current_task_metadata" in output_data:
+                    metadata_dict = output_data["current_task_metadata"]
+                    return TaskMetadata.model_validate(metadata_dict)
+        
+        return None
+        
+    except Exception as e:
+        logger.warning(f"⚠️ Failed to load task metadata from history: {e}")
+        return None
+
+
+async def save_task_metadata_to_history(
+    task_metadata: TaskMetadata,
+    user_request: str,
+    action: str,
+    conversation_service: ConversationHistoryService,
+) -> None:
+    """
+    Save TaskMetadata to conversation history using task_id as primary key.
+    
+    Args:
+        task_metadata: Task metadata to save
+        user_request: Original user request
+        action: Action taken ("created" or "updated")
+        conversation_service: Conversation service
+    """
+    try:
+        # Use task_id as primary key for conversation history
+        await conversation_service.save_tool_interaction(
+            session_id=task_metadata.task_id,
+            tool_name="set_coding_task",
+            tool_input=user_request,
+            tool_output=json.dumps({
+                "action": action,
+                "current_task_metadata": task_metadata.model_dump(mode='json'),
+                "timestamp": datetime.now().isoformat(),
+            }),
+        )
+        
+        logger.info(f"💾 Saved task metadata to conversation history: {task_metadata.task_id}")
+        
+    except Exception as e:
+        logger.error(f"❌ Failed to save task metadata to history: {e}")
+        # Don't raise - this is not critical for tool operation
+
+
+def validate_state_transition(current_state: TaskState, new_state: TaskState) -> None:
+    """
+    Validate that the state transition is allowed.
+    
+    Args:
+        current_state: Current TaskState
+        new_state: Requested new TaskState
+        
+    Raises:
+        ValueError: If transition is not allowed
+    """
+    # Define valid state transitions
+    valid_transitions = {
+        TaskState.CREATED: [TaskState.PLANNING, TaskState.BLOCKED, TaskState.CANCELLED],
+        TaskState.PLANNING: [TaskState.PLAN_APPROVED, TaskState.CREATED, TaskState.BLOCKED, TaskState.CANCELLED],
+        TaskState.PLAN_APPROVED: [TaskState.IMPLEMENTING, TaskState.PLANNING, TaskState.BLOCKED, TaskState.CANCELLED],
+        TaskState.IMPLEMENTING: [TaskState.IMPLEMENTING, TaskState.REVIEW_READY, TaskState.PLAN_APPROVED, TaskState.BLOCKED, TaskState.CANCELLED],
+        TaskState.REVIEW_READY: [TaskState.COMPLETED, TaskState.IMPLEMENTING, TaskState.BLOCKED, TaskState.CANCELLED],
+        TaskState.COMPLETED: [TaskState.CANCELLED],  # Only allow cancellation of completed tasks
+        TaskState.BLOCKED: [TaskState.CREATED, TaskState.PLANNING, TaskState.PLAN_APPROVED, TaskState.IMPLEMENTING, TaskState.REVIEW_READY, TaskState.CANCELLED],
+        TaskState.CANCELLED: [],  # No transitions from cancelled state
+    }
+    
+    if new_state not in valid_transitions.get(current_state, []):
+        raise ValueError(
+            f"Invalid state transition: {current_state.value} → {new_state.value}. "
+            f"Valid transitions from {current_state.value}: {[s.value for s in valid_transitions.get(current_state, [])]}"
+        )

src/mcp_as_a_judge/constants.py

@@ -5,7 +5,7 @@
 """
 
 # LLM Configuration
-MAX_TOKENS = 10000  # Maximum tokens for all LLM requests
+MAX_TOKENS = 25000  # Maximum tokens for all LLM requests - increased for comprehensive responses
 DEFAULT_TEMPERATURE = 0.1  # Default temperature for LLM requests
 
 # Timeout Configuration

src/mcp_as_a_judge/messaging/factory.py

@@ -4,13 +4,17 @@
 This module implements the factory pattern for creating the appropriate
 messaging provider based on capabilities and preferences. It automatically
 detects MCP sampling capability and selects the best available provider.
+
+The factory handles ALL message format decisions to ensure consistency.
 """
 
+from typing import Any
 from mcp.server.fastmcp import Context
 
 from mcp_as_a_judge.messaging.interface import MessagingConfig, MessagingProvider
 from mcp_as_a_judge.messaging.llm_api_provider import LLMAPIProvider
 from mcp_as_a_judge.messaging.mcp_sampling_provider import MCPSamplingProvider
+from mcp_as_a_judge.messaging.converters import mcp_messages_to_universal, validate_message_conversion
 
 
 class MessagingProviderFactory:
@@ -62,6 +66,66 @@ def create_provider(ctx: Context, config: MessagingConfig) -> MessagingProvider:
             f"MCP sampling: {sampling_available}, LLM API: {llm_available}"
         )
 
+    @staticmethod
+    def get_provider_with_messages(
+        ctx: Context,
+        messages: list[Any],
+        config: MessagingConfig
+    ) -> tuple[MessagingProvider, list[Any]]:
+        """
+        Get the appropriate provider and convert messages to the correct format.
+
+        This method makes ALL message format decisions at the factory level
+        to ensure consistency throughout the system.
+
+        Args:
+            ctx: MCP context for capability detection
+            messages: Input messages (typically SamplingMessage objects)
+            config: Messaging configuration
+
+        Returns:
+            Tuple of (provider, formatted_messages) where formatted_messages
+            are in the correct format for the selected provider
+        """
+        # Check provider availability
+        sampling_provider = MCPSamplingProvider(ctx)
+        llm_provider = LLMAPIProvider()
+
+        sampling_available = sampling_provider.is_available()
+        llm_available = llm_provider.is_available()
+
+        if config.prefer_sampling:
+            # Prefer sampling first, fall back to LLM API
+            if sampling_available:
+                # MCP sampling expects SamplingMessage objects directly
+                return sampling_provider, messages
+            elif llm_available:
+                # LLM API expects universal Message objects
+                universal_messages = mcp_messages_to_universal(messages)
+
+                # Validate conversion
+                if not validate_message_conversion(messages, universal_messages):
+                    raise ValueError("Failed to convert messages to universal format")
+
+                return llm_provider, universal_messages
+        else:
+            # Force LLM API only (no fallback to sampling)
+            if llm_available:
+                # LLM API expects universal Message objects
+                universal_messages = mcp_messages_to_universal(messages)
+
+                # Validate conversion
+                if not validate_message_conversion(messages, universal_messages):
+                    raise ValueError("Failed to convert messages to universal format")
+
+                return llm_provider, universal_messages
+
+        # No providers available
+        raise RuntimeError(
+            f"No messaging providers available. "
+            f"MCP sampling: {sampling_available}, LLM API: {llm_available}"
+        )
+
     @staticmethod
     def check_sampling_capability(ctx: Context) -> bool:
         """Check if the context has sampling capability enabled.