kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/llm/api_communication_service.py

@@ -16,6 +16,9 @@ from typing import Any, Dict, List, Optional
 
 import aiohttp
 
+from .api_adapters import get_adapter, BaseAPIAdapter
+from .profile_manager import LLMProfile
+
 logger = logging.getLogger(__name__)
 
 
@@ -29,77 +32,25 @@ class APICommunicationService:
     Eliminates API concerns from the main LLM service class.
     """
     
-    def __init__(self, config, raw_conversations_dir):
+    def __init__(self, config, raw_conversations_dir, profile: LLMProfile):
         """Initialize API communication service.
 
         Args:
             config: Configuration manager for API settings
             raw_conversations_dir: Directory for raw interaction logs
+            profile: LLM profile with configuration (resolves env vars -> config -> defaults)
         """
         self.config = config
         self.raw_conversations_dir = raw_conversations_dir
 
-        # Load API configuration (environment variables take precedence over config)
-
-        # API endpoint/URL
-        self.api_url = os.environ.get("KOLLABOR_API_ENDPOINT") or config.get("core.llm.api_url", "http://localhost:1234")
-        if os.environ.get("KOLLABOR_API_ENDPOINT"):
-            logger.debug("Using API endpoint from KOLLABOR_API_ENDPOINT environment variable")
-
-        # Model name
-        self.model = os.environ.get("KOLLABOR_API_MODEL") or config.get("core.llm.model", "qwen/qwen3-4b")
-        if os.environ.get("KOLLABOR_API_MODEL"):
-            logger.debug("Using model from KOLLABOR_API_MODEL environment variable")
-
-        # Temperature (with type conversion)
-        env_temperature = os.environ.get("KOLLABOR_API_TEMPERATURE")
-        if env_temperature:
-            try:
-                self.temperature = float(env_temperature)
-                logger.debug("Using temperature from KOLLABOR_API_TEMPERATURE environment variable")
-            except ValueError:
-                logger.warning(f"Invalid KOLLABOR_API_TEMPERATURE value: {env_temperature}, using config/default")
-                self.temperature = config.get("core.llm.temperature", 0.7)
-        else:
-            self.temperature = config.get("core.llm.temperature", 0.7)
-
-        # Timeout (with type conversion)
-        env_timeout = os.environ.get("KOLLABOR_API_TIMEOUT")
-        if env_timeout:
-            try:
-                self.timeout = int(env_timeout)
-                logger.debug("Using timeout from KOLLABOR_API_TIMEOUT environment variable")
-            except ValueError:
-                logger.warning(f"Invalid KOLLABOR_API_TIMEOUT value: {env_timeout}, using config/default")
-                self.timeout = config.get("core.llm.timeout", 30000)
-        else:
-            self.timeout = config.get("core.llm.timeout", 30000)
+        # Initialize from profile (resolves env vars through profile's getter methods)
+        self.update_from_profile(profile)
 
-        # Streaming (not typically set via env, kept for completeness)
+        # Streaming (from config, not profile-specific)
         self.enable_streaming = config.get("core.llm.enable_streaming", False)
 
-        # Max tokens (with type conversion)
-        env_max_tokens = os.environ.get("KOLLABOR_API_MAX_TOKENS")
-        if env_max_tokens:
-            try:
-                self.max_tokens = int(env_max_tokens)
-                logger.debug("Using max tokens from KOLLABOR_API_MAX_TOKENS environment variable")
-            except ValueError:
-                logger.warning(f"Invalid KOLLABOR_API_MAX_TOKENS value: {env_max_tokens}, using config/default")
-                self.max_tokens = config.get("core.llm.max_tokens", None)
-        else:
-            self.max_tokens = config.get("core.llm.max_tokens", None)
-
-        # API token (supports both KOLLABOR_API_TOKEN and KOLLABOR_API_KEY)
-        self.api_token = (
-            os.environ.get("KOLLABOR_API_TOKEN")
-            or os.environ.get("KOLLABOR_API_KEY")
-            or config.get("core.llm.api_token")
-        )
-        if os.environ.get("KOLLABOR_API_TOKEN"):
-            logger.debug("Using API token from KOLLABOR_API_TOKEN environment variable")
-        elif os.environ.get("KOLLABOR_API_KEY"):
-            logger.debug("Using API token from KOLLABOR_API_KEY environment variable")
+        # Session tracking for raw log linking
+        self.current_session_id: Optional[str] = None
 
         # HTTP session state with enhanced lifecycle management
         self.session = None
@@ -114,6 +65,10 @@ class APICommunicationService:
         # Token usage tracking
         self.last_token_usage = {}
 
+        # Native tool calling support
+        self.last_tool_calls = []  # Tool calls from last response
+        self.last_stop_reason = ""  # Stop reason from last response
+
         # Resource monitoring and statistics
         self._connection_stats = {
             'total_requests': 0,
@@ -124,13 +79,56 @@ class APICommunicationService:
             'connection_errors': 0
         }
 
-        logger.info(f"API service initialized for {self.api_url}")
-    
-    async def initialize(self):
+        logger.info(f"API service initialized for {self.api_url} (profile: {profile.name})")
+
+    def set_session_id(self, session_id: str) -> None:
+        """Set current session ID for raw log linking.
+
+        Args:
+            session_id: Session identifier from conversation logger
+        """
+        self.current_session_id = session_id
+        logger.debug(f"API service session ID set to: {session_id}")
+
+    def update_from_profile(self, profile: LLMProfile) -> None:
+        """Update API settings from a profile.
+
+        Uses profile getter methods that resolve env var -> config -> default.
+
+        Args:
+            profile: LLMProfile with configuration
+        """
+        old_url = getattr(self, 'api_url', None)
+        old_model = getattr(self, 'model', None)
+        old_format = getattr(self, 'tool_format', 'openai')
+
+        # Get all values from profile (getter methods resolve env vars)
+        self.api_url = profile.get_endpoint()
+        self.model = profile.get_model()
+        self.temperature = profile.get_temperature()
+        self.tool_format = profile.get_tool_format()
+        self.max_tokens = profile.get_max_tokens()
+        self.timeout = profile.get_timeout()
+        self.api_token = profile.get_token()
+
+        # Recreate adapter if tool format or URL changed
+        if self.tool_format != old_format or self.api_url != old_url:
+            self._adapter = get_adapter(self.tool_format, self.api_url)
+        elif not hasattr(self, '_adapter'):
+            # First initialization
+            self._adapter = get_adapter(self.tool_format, self.api_url)
+
+        if old_url and old_model:
+            logger.info(
+                f"API service updated: {old_model}@{old_url} ({old_format}) -> "
+                f"{self.model}@{self.api_url} ({self.tool_format})"
+            )
+
+    async def initialize(self) -> bool:
         """Initialize HTTP session with proper error handling and resource management."""
         async with self._session_lock:
             if self._initialized:
-                return
+                return True
 
             try:
                 # Create session with proper configuration and resource limits
@@ -291,7 +289,46 @@ class APICommunicationService:
             Dictionary containing token usage info
         """
         return self.last_token_usage.copy()
-    
+
+    def get_last_tool_calls(self) -> List[Any]:
+        """Get tool calls from the last API call (native function calling).
+
+        Returns:
+            List of ToolCallResult objects from last response
+        """
+        return self.last_tool_calls.copy() if self.last_tool_calls else []
+
+    def has_pending_tool_calls(self) -> bool:
+        """Check if last response has tool calls that need execution.
+
+        Returns:
+            True if there are tool calls to execute
+        """
+        return bool(self.last_tool_calls)
+
+    def get_last_stop_reason(self) -> str:
+        """Get stop reason from last response.
+
+        Returns:
+            Stop reason string (e.g., 'end_turn', 'tool_use', 'max_tokens')
+        """
+        return self.last_stop_reason
+
+    def format_tool_result(self, tool_id: str, result: Any, is_error: bool = False) -> Dict[str, Any]:
+        """Format a tool execution result for sending back to the LLM.
+
+        Uses the adapter to format in the correct API format (OpenAI/Anthropic).
+
+        Args:
+            tool_id: The tool call ID from the original request
+            result: The tool execution result
+            is_error: Whether the result is an error
+
+        Returns:
+            Formatted tool result message for conversation
+        """
+        return self._adapter.format_tool_result(tool_id, result, is_error)
+
     def cancel_current_request(self):
         """Cancel any active API request."""
         self.cancel_requested = True
@@ -301,13 +338,15 @@ class APICommunicationService:
             self.current_request_task.cancel()
     
     async def call_llm(self, conversation_history: List[Dict[str, str]],
-                       max_history: int = None, streaming_callback=None) -> str:
+                       max_history: int = None, streaming_callback=None,
+                       tools: List[Dict[str, Any]] = None) -> str:
         """Make API call to LLM with conversation history and robust error handling.
 
         Args:
             conversation_history: List of conversation messages
             max_history: Maximum number of messages to send (optional)
             streaming_callback: Optional callback for streaming content chunks
+            tools: Optional list of tool definitions for native function calling
 
         Returns:
             LLM response content
@@ -337,17 +376,15 @@ class APICommunicationService:
         # Prepare messages for API
         messages = self._prepare_messages(conversation_history, max_history)
 
-        # Build request payload
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "temperature": self.temperature,
-            "stream": self.enable_streaming
-        }
-
-        # Add max_tokens if configured
-        if self.max_tokens:
-            payload["max_tokens"] = int(self.max_tokens)
+        # Build request payload using adapter
+        payload = self._adapter.format_request(
+            messages=messages,
+            model=self.model,
+            temperature=self.temperature,
+            stream=self.enable_streaming,
+            max_tokens=int(self.max_tokens) if self.max_tokens else None,
+            tools=tools  # Native function calling (OpenAI/Anthropic format)
+        )
 
         # Execute request with cancellation support and comprehensive error handling
         self.current_request_task = asyncio.create_task(
@@ -415,16 +452,17 @@ class APICommunicationService:
             # Log raw request
             self._log_raw_interaction(payload)
 
-            # Build headers for authentication
-            headers = {"Content-Type": "application/json"}
-            if self.api_token:
-                headers["Authorization"] = f"Bearer {self.api_token}"
+            # Build headers using adapter (handles auth format differences)
+            headers = self._adapter.get_headers(self.api_token)
 
-            # Determine the correct URL
-            if "/chat/completions" in self.api_url:
+            # Determine URL - prefer user's configured URL if it's a full endpoint
+            # This handles custom APIs like z.ai that have non-standard paths
+            if "/chat/completions" in self.api_url or "/messages" in self.api_url:
+                # User provided full endpoint URL, use it directly
                 url = self.api_url
             else:
-                url = f"{self.api_url}/v1/chat/completions"
+                # User provided base URL, use adapter's endpoint pattern
+                url = self._adapter.api_endpoint
 
             # Execute request with proper timeout and error handling
             timeout_val = None if self.timeout == 0 else self.timeout
@@ -446,11 +484,17 @@ class APICommunicationService:
                 if response.status == 200:
                     if self.enable_streaming:
                         content = await self._handle_streaming_response(response)
+                        self.last_tool_calls = []  # Streaming doesn't support tool calls yet
                     else:
                         data = await response.json()
-                        content = data["choices"][0]["message"]["content"]
-                        # Extract token usage if available
-                        self.last_token_usage = data.get("usage", {})
+                        # Use adapter to parse response (handles OpenAI vs Anthropic formats)
+                        parsed = self._adapter.parse_response(data)
+                        content = parsed.content
+                        # Extract token usage from unified format
+                        self.last_token_usage = parsed.usage
+                        # Store tool calls for native function calling
+                        self.last_tool_calls = parsed.tool_calls
+                        self.last_stop_reason = parsed.stop_reason
 
                     # Log successful response
                     self._log_raw_interaction(
@@ -504,30 +548,31 @@ class APICommunicationService:
             raise
 
     async def _execute_request(self, payload: Dict[str, Any]) -> str:
-        """Execute the actual HTTP request.
-        
+        """Execute the actual HTTP request (legacy method - uses adapter for parsing).
+
+        Note: This is a legacy method. Prefer _execute_request_with_error_handling
+        which has better error handling and session recovery.
+
         Args:
             payload: Request payload
-            
+
         Returns:
             Response content
         """
         start_time = time.time()
-        
+
         try:
             # Log raw request
             self._log_raw_interaction(payload)
 
-            # Build headers for authentication
-            headers = {"Content-Type": "application/json"}
-            if self.api_token:
-                headers["Authorization"] = f"Bearer {self.api_token}"
+            # Build headers using adapter (handles auth format differences)
+            headers = self._adapter.get_headers(self.api_token)
 
-            # Determine the correct URL - if it already contains the full path, use as-is
-            if "/chat/completions" in self.api_url:
+            # Determine URL - prefer user's configured URL if it's a full endpoint
+            if "/chat/completions" in self.api_url or "/messages" in self.api_url:
                 url = self.api_url
             else:
-                url = f"{self.api_url}/v1/chat/completions"
+                url = self._adapter.api_endpoint
 
             async with self.session.post(
                 url,
@@ -535,39 +580,40 @@ class APICommunicationService:
                 headers=headers,
                 timeout=aiohttp.ClientTimeout(total=None if self.timeout == 0 else self.timeout)
             ) as response:
-                
+
                 request_duration = time.time() - start_time
-                
+
                 if response.status == 200:
                     if self.enable_streaming:
                         content = await self._handle_streaming_response(response)
                     else:
                         data = await response.json()
-                        content = data["choices"][0]["message"]["content"]
-
-                        # Extract token usage if available
-                        self.last_token_usage = data.get("usage", {})
+                        # Use adapter to parse response (handles OpenAI vs Anthropic formats)
+                        parsed = self._adapter.parse_response(data)
+                        content = parsed.content
+                        # Extract token usage from unified format
+                        self.last_token_usage = parsed.usage
 
                     # Log successful response with full data
                     self._log_raw_interaction(payload, response_data=data if not self.enable_streaming else {"choices": [{"message": {"content": content}}]})
-                    
+
                     logger.debug(f"API call completed in {request_duration:.2f}s")
                     return content
-                    
+
                 else:
                     error_text = await response.text()
                     error_msg = f"LLM API error: {response.status} - {error_text}"
-                    
+
                     # Log error response
                     self._log_raw_interaction(payload, error=error_msg)
-                    
+
                     raise Exception(error_msg)
-                    
+
         except asyncio.TimeoutError:
             error_msg = f"LLM API timeout after {self.timeout} seconds"
             self._log_raw_interaction(payload, error=error_msg)
             raise Exception(error_msg)
-            
+
         except Exception as e:
             # Log any other exceptions
             if not str(e).startswith("LLM API error"):
@@ -655,14 +701,22 @@ class APICommunicationService:
             cancelled: Whether the request was cancelled (optional)
         """
         try:
-            # Create filename with timestamp
-            timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
-            filename = f"raw_llm_interactions_{timestamp}.jsonl"
+            # Create filename with session ID for easy correlation
+            # Format: {session_id}_raw_{timestamp}.jsonl or fallback to raw_llm_interactions_{timestamp}.jsonl
+            timestamp = datetime.now().strftime("%H%M%S")
+            if self.current_session_id:
+                # e.g., session_2025-12-11_112522_raw_112635.jsonl
+                filename = f"{self.current_session_id}_raw_{timestamp}.jsonl"
+            else:
+                # Fallback if no session ID set
+                date_timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
+                filename = f"raw_llm_interactions_{date_timestamp}.jsonl"
             filepath = self.raw_conversations_dir / filename
             
-            # Create log entry
+            # Create log entry with session linking
             log_entry = {
                 "timestamp": datetime.now().isoformat(),
+                "session_id": self.current_session_id,  # Links to conversations/session_*.jsonl
                 "request": {
                     "url": f"{self.api_url}/v1/chat/completions",
                     "method": "POST",