mseep-lightfast-mcp 0.0.1__py3-none-any.whl

tools/ai/conversation_session.py

@@ -0,0 +1,342 @@
+"""Conversation session management for AI interactions."""
+
+import time
+from typing import Any, Dict, List
+
+import mcp.types as mcp_types
+
+from tools.common import (
+    ConversationError,
+    ConversationStep,
+    OperationStatus,
+    Result,
+    ToolResult,
+    get_logger,
+    with_correlation_id,
+    with_operation_context,
+)
+
+from .providers.base_provider import BaseAIProvider
+from .tool_executor import ToolExecutor
+
+logger = get_logger("ConversationSession")
+
+
+class ConversationSession:
+    """Manages a single conversation session with AI and tool execution."""
+
+    def __init__(
+        self,
+        session_id: str,
+        max_steps: int,
+        ai_provider: BaseAIProvider,
+        tool_executor: ToolExecutor,
+        available_tools: Dict[str, tuple[mcp_types.Tool, str]],
+    ):
+        """Initialize a conversation session."""
+        self.session_id = session_id
+        self.max_steps = max_steps
+        self.ai_provider = ai_provider
+        self.tool_executor = tool_executor
+        self.available_tools = available_tools
+
+        # Conversation state
+        self.messages: List[Dict[str, Any]] = []
+        self.steps: List[ConversationStep] = []
+        self.current_step_number = 0
+        self.is_complete = False
+
+        logger.info(f"Created conversation session {session_id}")
+
+    @with_correlation_id
+    @with_operation_context(operation="process_message")
+    async def process_message(self, message: str) -> Result[List[ConversationStep]]:
+        """Process a user message and generate response steps."""
+        if self.is_complete:
+            return Result(
+                status=OperationStatus.FAILED,
+                error="Conversation session is already complete",
+                error_code="SESSION_COMPLETE",
+            )
+
+        # Add user message to conversation
+        self.messages.append({"role": "user", "content": message})
+
+        logger.info(
+            f"Processing message in session {self.session_id}",
+            session_id=self.session_id,
+            message_length=len(message),
+        )
+
+        new_steps: List[ConversationStep] = []
+
+        try:
+            # Generate steps until completion or max steps reached
+            for step_num in range(self.current_step_number, self.max_steps):
+                if self.is_complete:
+                    break
+
+                step_result = await self._generate_step(step_num)
+                if not step_result.is_success:
+                    return Result(
+                        status=OperationStatus.FAILED,
+                        error=f"Failed to generate step {step_num}: {step_result.error}",
+                        error_code="STEP_GENERATION_FAILED",
+                    )
+
+                step = step_result.data
+                if step is None:
+                    return Result(
+                        status=OperationStatus.FAILED,
+                        error=f"Step {step_num} returned None data",
+                        error_code="NULL_STEP_DATA",
+                    )
+
+                self.steps.append(step)
+                new_steps.append(step)
+                self.current_step_number += 1
+
+                # Update conversation messages
+                await self._update_conversation_messages(step)
+
+                # Check if conversation should continue
+                if not step.tool_calls or step.finish_reason == "stop":
+                    self.is_complete = True
+                    break
+
+            # Mark as complete if we've reached max steps
+            if self.current_step_number >= self.max_steps:
+                self.is_complete = True
+
+            logger.info(
+                f"Processed message with {len(new_steps)} steps",
+                session_id=self.session_id,
+                steps_generated=len(new_steps),
+                is_complete=self.is_complete,
+            )
+
+            return Result(status=OperationStatus.SUCCESS, data=new_steps)
+
+        except Exception as e:
+            error = ConversationError(
+                f"Error processing message: {e}",
+                session_id=self.session_id,
+                step_number=self.current_step_number,
+                cause=e,
+            )
+            logger.error("Message processing failed", error=error)
+            return Result(
+                status=OperationStatus.FAILED,
+                error=str(error),
+                error_code=error.error_code,
+            )
+
+    async def _generate_step(self, step_number: int) -> Result[ConversationStep]:
+        """Generate a single conversation step."""
+        start_time = time.time()
+
+        try:
+            # Generate AI response
+            step_result = await self.ai_provider.generate_step(
+                messages=self.messages,
+                available_tools=self.available_tools,
+                step_number=step_number,
+            )
+
+            if not step_result.is_success:
+                return step_result
+
+            step = step_result.data
+            if step is None:
+                return Result(
+                    status=OperationStatus.FAILED,
+                    error=f"AI provider returned None step data for step {step_number}",
+                    error_code="NULL_AI_STEP_DATA",
+                )
+
+            # Execute any tool calls
+            if step.tool_calls:
+                logger.debug(
+                    f"Executing {len(step.tool_calls)} tool calls",
+                    session_id=self.session_id,
+                    step_number=step_number,
+                )
+
+                tool_results = await self.tool_executor.execute_tools_concurrently(
+                    step.tool_calls
+                )
+
+                # Add results to step
+                for result in tool_results:
+                    step.add_tool_result(result)
+
+            # Calculate step duration
+            step.duration_ms = (time.time() - start_time) * 1000
+
+            logger.debug(
+                f"Generated step {step_number}",
+                session_id=self.session_id,
+                step_number=step_number,
+                has_text=bool(step.text),
+                tool_calls=len(step.tool_calls),
+                tool_results=len(step.tool_results),
+                duration_ms=step.duration_ms,
+            )
+
+            return Result(status=OperationStatus.SUCCESS, data=step)
+
+        except Exception as e:
+            error = ConversationError(
+                f"Error generating step {step_number}: {e}",
+                session_id=self.session_id,
+                step_number=step_number,
+                cause=e,
+            )
+            logger.error("Step generation failed", error=error)
+            return Result(
+                status=OperationStatus.FAILED,
+                error=str(error),
+                error_code=error.error_code,
+            )
+
+    async def _update_conversation_messages(self, step: ConversationStep):
+        """Update conversation messages with step results."""
+        if self.ai_provider.provider_name == "claude":
+            await self._update_messages_claude_format(step)
+        elif self.ai_provider.provider_name == "openai":
+            await self._update_messages_openai_format(step)
+        else:
+            # Generic format
+            await self._update_messages_generic_format(step)
+
+    async def _update_messages_claude_format(self, step: ConversationStep):
+        """Update messages in Claude format."""
+        if step.tool_calls:
+            # Claude format: tool calls and results in assistant message content
+            content_blocks: List[Dict[str, Any]] = []
+
+            # Add text content if any
+            if step.text:
+                content_blocks.append({"type": "text", "text": step.text})
+
+            # Add tool use blocks
+            for tc in step.tool_calls:
+                tool_use_block = {
+                    "type": "tool_use",
+                    "id": tc.id,
+                    "name": tc.tool_name,
+                    "input": tc.arguments,
+                }
+                content_blocks.append(tool_use_block)
+
+            assistant_message = {
+                "role": "assistant",
+                "content": content_blocks,
+            }
+            self.messages.append(assistant_message)
+
+            # Add user message with tool results
+            tool_result_blocks: List[Dict[str, Any]] = []
+            for result in step.tool_results:
+                tool_result_blocks.append(
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": result.id,
+                        "content": self._format_tool_result_content(result),
+                    }
+                )
+
+            if tool_result_blocks:
+                user_message = {
+                    "role": "user",
+                    "content": tool_result_blocks,
+                }
+                self.messages.append(user_message)
+        else:
+            # Regular text response
+            self.messages.append({"role": "assistant", "content": step.text})
+
+    async def _update_messages_openai_format(self, step: ConversationStep):
+        """Update messages in OpenAI format."""
+        if step.tool_calls:
+            # OpenAI format: separate tool call and tool result messages
+            assistant_message = {
+                "role": "assistant",
+                "content": step.text or "",
+                "tool_calls": [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.tool_name,
+                            "arguments": str(tc.arguments),  # OpenAI expects string
+                        },
+                    }
+                    for tc in step.tool_calls
+                ],
+            }
+            self.messages.append(assistant_message)
+
+            # Add tool result messages
+            for result in step.tool_results:
+                tool_message = {
+                    "role": "tool",
+                    "tool_call_id": result.id,
+                    "content": self._format_tool_result_content(result),
+                }
+                self.messages.append(tool_message)
+        else:
+            # Regular text response
+            self.messages.append({"role": "assistant", "content": step.text})
+
+    async def _update_messages_generic_format(self, step: ConversationStep):
+        """Update messages in generic format."""
+        # Simple format for unknown providers
+        content = step.text or ""
+
+        if step.tool_calls:
+            content += f"\n\nTool calls executed: {len(step.tool_calls)}"
+            for result in step.tool_results:
+                if result.result:
+                    content += f"\n- {result.tool_name}: {result.result}"
+                elif result.error:
+                    content += f"\n- {result.tool_name}: Error - {result.error}"
+
+        self.messages.append({"role": "assistant", "content": content})
+
+    def _format_tool_result_content(self, result: ToolResult) -> str:
+        """Format tool result content for messages."""
+        if result.result is not None:
+            if isinstance(result.result, (dict, list)):
+                import json
+
+                return json.dumps(result.result)
+            else:
+                return str(result.result)
+        elif result.error:
+            return f"Error: {result.error}"
+        else:
+            return "No result"
+
+    def get_conversation_summary(self) -> Dict[str, Any]:
+        """Get a summary of the conversation session."""
+        total_tool_calls = sum(len(step.tool_calls) for step in self.steps)
+        successful_tool_calls = sum(
+            len([r for r in step.tool_results if not r.error]) for step in self.steps
+        )
+
+        return {
+            "session_id": self.session_id,
+            "steps": len(self.steps),
+            "messages": len(self.messages),
+            "total_tool_calls": total_tool_calls,
+            "successful_tool_calls": successful_tool_calls,
+            "is_complete": self.is_complete,
+            "max_steps": self.max_steps,
+        }
+
+    async def close(self):
+        """Close the conversation session and clean up resources."""
+        logger.info(f"Closing conversation session {self.session_id}")
+        self.is_complete = True
+        # Could add cleanup logic here if needed

tools/ai/providers/__init__.py

@@ -0,0 +1,11 @@
+"""AI provider abstractions for different AI services."""
+
+from .base_provider import BaseAIProvider
+from .claude_provider import ClaudeProvider
+from .openai_provider import OpenAIProvider
+
+__all__ = [
+    "BaseAIProvider",
+    "ClaudeProvider",
+    "OpenAIProvider",
+]

tools/ai/providers/base_provider.py

@@ -0,0 +1,64 @@
+"""Base AI provider interface for different AI services."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+import mcp.types as mcp_types
+
+from tools.common import ConversationStep, Result, ToolCall
+
+
+class BaseAIProvider(ABC):
+    """Base interface for AI providers (Claude, OpenAI, etc.)."""
+
+    def __init__(self, api_key: str):
+        """Initialize the AI provider."""
+        self.api_key = api_key
+
+    @abstractmethod
+    async def generate_step(
+        self,
+        messages: List[Dict[str, Any]],
+        available_tools: Dict[str, tuple[mcp_types.Tool, str]],
+        step_number: int,
+    ) -> Result[ConversationStep]:
+        """Generate a single conversation step with potential tool calls."""
+        pass
+
+    @abstractmethod
+    def build_tools_context(
+        self, available_tools: Dict[str, tuple[mcp_types.Tool, str]]
+    ) -> str:
+        """Build a context description of available tools."""
+        pass
+
+    @abstractmethod
+    def format_tool_for_api(
+        self, mcp_tool: mcp_types.Tool, server_name: str
+    ) -> Dict[str, Any]:
+        """Convert MCP tool to provider-specific format."""
+        pass
+
+    @abstractmethod
+    def parse_tool_calls(self, response: Any) -> List[ToolCall]:
+        """Parse tool calls from provider response."""
+        pass
+
+    @abstractmethod
+    def format_messages_for_api(
+        self, messages: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Format messages for the provider's API."""
+        pass
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        pass
+
+    @property
+    @abstractmethod
+    def default_model(self) -> str:
+        """Get the default model for this provider."""
+        pass

tools/ai/providers/claude_provider.py

@@ -0,0 +1,200 @@
+"""Claude AI provider implementation."""
+
+import json
+from typing import Any, Dict, List
+
+import anthropic
+import mcp.types as mcp_types
+
+from tools.common import (
+    ConversationStep,
+    OperationStatus,
+    Result,
+    ToolCall,
+    get_logger,
+)
+
+from .base_provider import BaseAIProvider
+
+logger = get_logger("ClaudeProvider")
+
+
+class ClaudeProvider(BaseAIProvider):
+    """Claude AI provider implementation."""
+
+    def __init__(self, api_key: str):
+        """Initialize Claude provider."""
+        super().__init__(api_key)
+        self.client = anthropic.AsyncAnthropic(api_key=api_key)
+
+    @property
+    def provider_name(self) -> str:
+        """Get the provider name."""
+        return "claude"
+
+    @property
+    def default_model(self) -> str:
+        """Get the default model for this provider."""
+        return "claude-3-5-sonnet-20241022"
+
+    async def generate_step(
+        self,
+        messages: List[Dict[str, Any]],
+        available_tools: Dict[str, tuple[mcp_types.Tool, str]],
+        step_number: int,
+    ) -> Result[ConversationStep]:
+        """Generate a single conversation step with potential tool calls."""
+        try:
+            # Build system prompt with tools context
+            tools_context = self.build_tools_context(available_tools)
+            system_prompt = f"""You are an AI assistant that can control multiple creative applications through MCP servers.
+
+{tools_context}
+
+You can use the available tools to interact with the connected servers. When you need to perform actions, use the appropriate tools. For conversational responses, respond normally with helpful information."""
+
+            # Build tools for Claude's native tool calling
+            claude_tools = []
+            for tool_name, (mcp_tool, server_name) in available_tools.items():
+                claude_tool = self.format_tool_for_api(mcp_tool, server_name)
+                claude_tools.append(claude_tool)
+
+            logger.debug(f"Making Claude API call with {len(claude_tools)} tools")
+
+            # Make API call with explicit parameters
+            if claude_tools:
+                response = await self.client.messages.create(
+                    model=self.default_model,
+                    max_tokens=4000,
+                    system=system_prompt,
+                    messages=self.format_messages_for_api(messages),  # type: ignore
+                    tools=claude_tools,  # type: ignore
+                )
+            else:
+                response = await self.client.messages.create(
+                    model=self.default_model,
+                    max_tokens=4000,
+                    system=system_prompt,
+                    messages=self.format_messages_for_api(messages),  # type: ignore
+                )
+
+            # Create conversation step
+            step = ConversationStep(step_number=step_number)
+
+            # Parse Claude's response
+            if response.content:
+                for content_block in response.content:
+                    if content_block.type == "text":
+                        step.text = content_block.text
+                    elif content_block.type == "tool_use":
+                        # Convert Claude's tool call to our format
+                        arguments = content_block.input
+                        if not isinstance(arguments, dict):
+                            arguments = {}
+                        tool_call = ToolCall(
+                            id=content_block.id,
+                            tool_name=content_block.name,
+                            arguments=arguments,
+                        )
+                        step.add_tool_call(tool_call)
+
+            # Set finish reason if no tool calls and no text
+            if not step.tool_calls and not step.text:
+                step.finish_reason = "stop"
+
+            return Result(status=OperationStatus.SUCCESS, data=step)
+
+        except Exception as e:
+            logger.error("Claude API call failed", error=e)
+            return Result(
+                status=OperationStatus.FAILED,
+                error=f"Claude API error: {e}",
+                error_code="CLAUDE_API_ERROR",
+            )
+
+    def build_tools_context(
+        self, available_tools: Dict[str, tuple[mcp_types.Tool, str]]
+    ) -> str:
+        """Build a context description of available tools."""
+        if not available_tools:
+            return "No connected servers or tools available."
+
+        tools_desc = []
+        tools_by_server: Dict[str, List[mcp_types.Tool]] = {}
+
+        # Group tools by server
+        for tool_name, (mcp_tool, server_name) in available_tools.items():
+            if server_name not in tools_by_server:
+                tools_by_server[server_name] = []
+            tools_by_server[server_name].append(mcp_tool)
+
+        # Build description
+        for server_name, server_tools in tools_by_server.items():
+            tools_desc.append(f"**{server_name} Server**:")
+            for tool in server_tools:
+                description = tool.description or "No description available"
+                tools_desc.append(f"  - {tool.name}: {description}")
+
+        return "Connected Servers and Available Tools:\n" + "\n".join(tools_desc)
+
+    def format_tool_for_api(
+        self, mcp_tool: mcp_types.Tool, server_name: str
+    ) -> Dict[str, Any]:
+        """Convert MCP tool to Claude tool format."""
+        return {
+            "name": mcp_tool.name,
+            "description": mcp_tool.description
+            or f"Call {mcp_tool.name} on {server_name} server",
+            "input_schema": mcp_tool.inputSchema,
+        }
+
+    def parse_tool_calls(self, response: Any) -> List[ToolCall]:
+        """Parse tool calls from Claude response."""
+        tool_calls = []
+
+        if hasattr(response, "content"):
+            for content_block in response.content:
+                if hasattr(content_block, "type") and content_block.type == "tool_use":
+                    tool_call = ToolCall(
+                        id=getattr(content_block, "id", ""),
+                        tool_name=getattr(content_block, "name", ""),
+                        arguments=getattr(content_block, "input", {}),
+                    )
+                    tool_calls.append(tool_call)
+
+        return tool_calls
+
+    def format_messages_for_api(
+        self, messages: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Format messages for Claude's API."""
+        # Claude expects messages without system messages (those go in system parameter)
+        formatted_messages = []
+
+        for message in messages:
+            if message.get("role") != "system":
+                formatted_messages.append(message)
+
+        return formatted_messages
+
+    def format_tool_results_for_api(
+        self, tool_calls: List[ToolCall], tool_results: List[Any]
+    ) -> List[Dict[str, Any]]:
+        """Format tool results for Claude's API."""
+        # Claude expects tool results in user messages
+        tool_result_blocks = []
+
+        for tool_call, result in zip(tool_calls, tool_results):
+            tool_result_blocks.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": tool_call.id,
+                    "content": json.dumps(result.result)
+                    if hasattr(result, "result") and result.result
+                    else result.error
+                    if hasattr(result, "error")
+                    else "No result",
+                }
+            )
+
+        return tool_result_blocks