vibesurf 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

vibe_surf/llm/openai_compatible.py

@@ -31,30 +31,63 @@ from pydantic import BaseModel
 
 from browser_use.llm.openai.chat import ChatOpenAI
 from browser_use.llm.messages import BaseMessage
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypeVar, overload
+
+import httpx
+from openai import APIConnectionError, APIStatusError, AsyncOpenAI, RateLimitError
+from openai.types.chat import ChatCompletionContentPartTextParam
+from openai.types.chat.chat_completion import ChatCompletion
+from openai.types.shared.chat_model import ChatModel
+from openai.types.shared_params.reasoning_effort import ReasoningEffort
+from openai.types.shared_params.response_format_json_schema import JSONSchema, ResponseFormatJSONSchema
+from pydantic import BaseModel
+
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.exceptions import ModelProviderError
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.openai.serializer import OpenAIMessageSerializer
 from browser_use.llm.schema import SchemaOptimizer
-from browser_use.llm.views import ChatInvokeCompletion
+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
 
 T = TypeVar('T', bound=BaseModel)
 
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
+
 
 @dataclass
 class ChatOpenAICompatible(ChatOpenAI):
     """
-    OpenAI-compatible chat model with automatic Gemini schema fix support.
+    OpenAI-compatible chat model with automatic schema fix support for Gemini, Kimi, and Qwen models.
     
-    This class extends browser_use's ChatOpenAI to automatically detect Gemini models
+    This class extends browser_use's ChatOpenAI to automatically detect special models
     and apply the necessary schema fixes to work with OpenAI-compatible APIs.
     
-    When a model name starts with 'gemini', this class will automatically apply
-    the schema transformations required by Gemini models to prevent validation errors
-    like "Unable to submit request because one or more response schemas specified 
-    other fields alongside any_of".
-    """
+    Supported models:
+    - Gemini models: Removes 'additionalProperties', 'title', 'default' and resolves $ref
+    - Kimi/Moonshot models: Removes 'min_items', 'max_items', 'minItems', 'maxItems', 'default' with anyOf
+    - Qwen models: Ensures 'json' keyword is present in messages when using response_format
     
+    The class automatically detects the model type and applies appropriate fixes.
+    """
+
     def _is_gemini_model(self) -> bool:
         """Check if the current model is a Gemini model."""
         return str(self.model).lower().startswith('gemini')
+
+    def _is_kimi_model(self) -> bool:
+        """Check if the current model is a Kimi/Moonshot model."""
+        model_str = str(self.model).lower()
+        return 'kimi' in model_str or 'moonshot' in model_str
     
+    def _is_qwen_model(self) -> bool:
+        """Check if the current model is a Qwen model."""
+        model_str = str(self.model).lower()
+        return 'qwen' in model_str
+
     def _fix_gemini_schema(self, schema: dict[str, Any]) -> dict[str, Any]:
         """
         Convert a Pydantic model to a Gemini-compatible schema.
@@ -64,11 +97,11 @@ class ChatOpenAICompatible(ChatOpenAI):
         
         Adapted from browser_use.llm.google.chat.ChatGoogle._fix_gemini_schema
         """
-        
+
         # Handle $defs and $ref resolution
         if '$defs' in schema:
             defs = schema.pop('$defs')
-            
+
             def resolve_refs(obj: Any) -> Any:
                 if isinstance(obj, dict):
                     if '$ref' in obj:
@@ -89,9 +122,9 @@ class ChatOpenAICompatible(ChatOpenAI):
                 elif isinstance(obj, list):
                     return [resolve_refs(item) for item in obj]
                 return obj
-            
+
             schema = resolve_refs(schema)
-        
+
         # Remove unsupported properties
         def clean_schema(obj: Any) -> Any:
             if isinstance(obj, dict):
@@ -102,136 +135,221 @@ class ChatOpenAICompatible(ChatOpenAI):
                         cleaned_value = clean_schema(value)
                         # Handle empty object properties - Gemini doesn't allow empty OBJECT types
                         if (
-                            key == 'properties'
-                            and isinstance(cleaned_value, dict)
-                            and len(cleaned_value) == 0
-                            and isinstance(obj.get('type', ''), str)
-                            and obj.get('type', '').upper() == 'OBJECT'
+                                key == 'properties'
+                                and isinstance(cleaned_value, dict)
+                                and len(cleaned_value) == 0
+                                and isinstance(obj.get('type', ''), str)
+                                and obj.get('type', '').upper() == 'OBJECT'
                         ):
                             # Convert empty object to have at least one property
                             cleaned['properties'] = {'_placeholder': {'type': 'string'}}
                         else:
                             cleaned[key] = cleaned_value
-                
+
                 # If this is an object type with empty properties, add a placeholder
                 if (
-                    isinstance(cleaned.get('type', ''), str)
-                    and cleaned.get('type', '').upper() == 'OBJECT'
-                    and 'properties' in cleaned
-                    and isinstance(cleaned['properties'], dict)
-                    and len(cleaned['properties']) == 0
+                        isinstance(cleaned.get('type', ''), str)
+                        and cleaned.get('type', '').upper() == 'OBJECT'
+                        and 'properties' in cleaned
+                        and isinstance(cleaned['properties'], dict)
+                        and len(cleaned['properties']) == 0
                 ):
                     cleaned['properties'] = {'_placeholder': {'type': 'string'}}
-                
+
                 return cleaned
             elif isinstance(obj, list):
                 return [clean_schema(item) for item in obj]
             return obj
+
+        return clean_schema(schema)
+
+    def _fix_kimi_schema(self, schema: dict[str, Any]) -> dict[str, Any]:
+        """
+        Convert a Pydantic model to a Kimi/Moonshot-compatible schema.
+        
+        This function removes unsupported keywords like 'min_items' that Moonshot API doesn't support.
         
+        Args:
+            schema: The original JSON schema
+            
+        Returns:
+            A cleaned schema compatible with Moonshot API
+        """
+
+        def clean_schema(obj: Any) -> Any:
+            if isinstance(obj, dict):
+                cleaned = {}
+                has_any_of = 'anyOf' in obj
+                
+                for key, value in obj.items():
+                    # Remove unsupported keywords for Moonshot
+                    if key in ['min_items', 'minItems']:
+                        continue
+                    # Remove 'default' when 'anyOf' is present (Moonshot restriction)
+                    elif key == 'default' and has_any_of:
+                        continue
+                    # Remove other problematic keywords
+                    elif key in ['title', 'additionalProperties']:
+                        continue
+                    else:
+                        cleaned[key] = clean_schema(value)
+                return cleaned
+            elif isinstance(obj, list):
+                return [clean_schema(item) for item in obj]
+            return obj
+
         return clean_schema(schema)
-    
+
     @overload
-    async def ainvoke(self, messages: list[BaseMessage], output_format: None = None) -> ChatInvokeCompletion[str]: ...
-    
-    @overload  
-    async def ainvoke(self, messages: list[BaseMessage], output_format: type[T]) -> ChatInvokeCompletion[T]: ...
-    
+    async def ainvoke(self, messages: list[BaseMessage], output_format: None = None) -> ChatInvokeCompletion[str]:
+        ...
+
+    @overload
+    async def ainvoke(self, messages: list[BaseMessage], output_format: type[T]) -> ChatInvokeCompletion[T]:
+        ...
+
     async def ainvoke(
-        self, messages: list[BaseMessage], output_format: type[T] | None = None
+            self, messages: list[BaseMessage], output_format: type[T] | None = None
     ) -> ChatInvokeCompletion[T] | ChatInvokeCompletion[str]:
         """
         Invoke the model with the given messages.
-        
-        Automatically applies Gemini schema fixes when using Gemini models.
-        
+
         Args:
             messages: List of chat messages
             output_format: Optional Pydantic model class for structured output
-            
+
         Returns:
             Either a string response or an instance of output_format
         """
-        
-        # If this is not a Gemini model or no structured output is requested,
+        # If this is not a special model or no structured output is requested,
         # use the parent implementation directly
-        if not self._is_gemini_model() or output_format is None:
+        if not (self._is_gemini_model() or self._is_kimi_model()) or output_format is None:
             return await super().ainvoke(messages, output_format)
-        
-        # For Gemini models with structured output, we need to intercept and fix the schema
-        from browser_use.llm.openai.serializer import OpenAIMessageSerializer
-        from browser_use.llm.exceptions import ModelProviderError
-        from openai.types.shared_params.response_format_json_schema import JSONSchema, ResponseFormatJSONSchema
-        from typing import Any
-        from collections.abc import Iterable
-        from openai.types.chat import ChatCompletionContentPartTextParam
-        
+
         openai_messages = OpenAIMessageSerializer.serialize_messages(messages)
-        
+
         try:
             model_params: dict[str, Any] = {}
-            
+
             if self.temperature is not None:
                 model_params['temperature'] = self.temperature
-            
+
             if self.frequency_penalty is not None:
                 model_params['frequency_penalty'] = self.frequency_penalty
-            
+
             if self.max_completion_tokens is not None:
                 model_params['max_completion_tokens'] = self.max_completion_tokens
-            
+
             if self.top_p is not None:
                 model_params['top_p'] = self.top_p
-            
+
             if self.seed is not None:
                 model_params['seed'] = self.seed
-            
+
             if self.service_tier is not None:
                 model_params['service_tier'] = self.service_tier
-            
-            # Create the JSON schema and apply Gemini fixes
-            original_schema = SchemaOptimizer.create_optimized_json_schema(output_format)
-            fixed_schema = self._fix_gemini_schema(original_schema)
-            
-            response_format: JSONSchema = {
-                'name': 'agent_output',
-                'strict': True,
-                'schema': fixed_schema,
-            }
-            
-            # Add JSON schema to system prompt if requested
-            if self.add_schema_to_system_prompt and openai_messages and openai_messages[0]['role'] == 'system':
-                schema_text = f'\n<json_schema>\n{response_format}\n</json_schema>'
-                if isinstance(openai_messages[0]['content'], str):
-                    openai_messages[0]['content'] += schema_text
-                elif isinstance(openai_messages[0]['content'], Iterable):
-                    openai_messages[0]['content'] = list(openai_messages[0]['content']) + [
-                        ChatCompletionContentPartTextParam(text=schema_text, type='text')
-                    ]
-            
-            # Make the API call with the fixed schema
-            response = await self.get_client().chat.completions.create(
-                model=self.model,
-                messages=openai_messages,
-                response_format=ResponseFormatJSONSchema(json_schema=response_format, type='json_schema'),
-                **model_params,
-            )
-            
-            if response.choices[0].message.content is None:
-                raise ModelProviderError(
-                    message='Failed to parse structured output from model response',
-                    status_code=500,
-                    model=self.name,
+
+            if self.reasoning_models and any(str(m).lower() in str(self.model).lower() for m in self.reasoning_models):
+                model_params['reasoning_effort'] = self.reasoning_effort
+                del model_params['temperature']
+                del model_params['frequency_penalty']
+
+            if output_format is None:
+                # Return string response
+                response = await self.get_client().chat.completions.create(
+                    model=self.model,
+                    messages=openai_messages,
+                    **model_params,
                 )
-            
-            usage = self._get_usage(response)
-            
-            parsed = output_format.model_validate_json(response.choices[0].message.content)
-            
-            return ChatInvokeCompletion(
-                completion=parsed,
-                usage=usage,
+
+                usage = self._get_usage(response)
+                return ChatInvokeCompletion(
+                    completion=response.choices[0].message.content or '',
+                    usage=usage,
+                )
+
+            else:
+                original_schema = SchemaOptimizer.create_optimized_json_schema(output_format)
+
+                # Apply appropriate schema fix based on model type
+                if self._is_gemini_model():
+                    logger.debug(f"🔧 Applying Gemini schema fixes for model: {self.model}")
+                    fixed_schema = self._fix_gemini_schema(original_schema)
+                elif self._is_kimi_model():
+                    logger.debug(f"🔧 Applying Kimi/Moonshot schema fixes for model: {self.model}")
+                    fixed_schema = self._fix_kimi_schema(original_schema)
+                else:
+                    fixed_schema = original_schema
+
+                response_format: JSONSchema = {
+                    'name': 'agent_output',
+                    'strict': True,
+                    'schema': fixed_schema,
+                }
+
+                # Add JSON schema to system prompt if requested
+                if self.add_schema_to_system_prompt and openai_messages and openai_messages[0]['role'] == 'system':
+                    schema_text = f'\n<json_schema>\n{response_format}\n</json_schema>'
+                    if isinstance(openai_messages[0]['content'], str):
+                        openai_messages[0]['content'] += schema_text
+                    elif isinstance(openai_messages[0]['content'], Iterable):
+                        openai_messages[0]['content'] = list(openai_messages[0]['content']) + [
+                            ChatCompletionContentPartTextParam(text=schema_text, type='text')
+                        ]
+
+                # Return structured response
+                response = await self.get_client().chat.completions.create(
+                    model=self.model,
+                    messages=openai_messages,
+                    response_format=ResponseFormatJSONSchema(json_schema=response_format, type='json_schema'),
+                    **model_params,
+                )
+
+                if response.choices[0].message.content is None:
+                    raise ModelProviderError(
+                        message='Failed to parse structured output from model response',
+                        status_code=500,
+                        model=self.name,
+                    )
+
+                usage = self._get_usage(response)
+
+                parsed = output_format.model_validate_json(response.choices[0].message.content)
+
+                return ChatInvokeCompletion(
+                    completion=parsed,
+                    usage=usage,
+                )
+
+        except RateLimitError as e:
+            error_message = e.response.json().get('error', {})
+            error_message = (
+                error_message.get('message', 'Unknown model error') if isinstance(error_message,
+                                                                                  dict) else error_message
             )
-            
+            raise ModelProviderError(
+                message=error_message,
+                status_code=e.response.status_code,
+                model=self.name,
+            ) from e
+
+        except APIConnectionError as e:
+            raise ModelProviderError(message=str(e), model=self.name) from e
+
+        except APIStatusError as e:
+            try:
+                error_message = e.response.json().get('error', {})
+            except Exception:
+                error_message = e.response.text
+            error_message = (
+                error_message.get('message', 'Unknown model error') if isinstance(error_message,
+                                                                                  dict) else error_message
+            )
+            raise ModelProviderError(
+                message=error_message,
+                status_code=e.response.status_code,
+                model=self.name,
+            ) from e
+
         except Exception as e:
-            # Let parent class handle all exception types
-            raise ModelProviderError(message=str(e), model=self.name) from e
+            raise ModelProviderError(message=str(e), model=self.name) from e

vibe_surf/logger.py

@@ -0,0 +1,99 @@
+"""
+Logger configuration for VibeSurf.
+"""
+import logging
+import os
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+
+from .common import get_workspace_dir
+
+
+def setup_logger(name: str = "vibesurf") -> logging.Logger:
+    """
+    Set up and configure the logger for VibeSurf.
+    
+    Args:
+        name (str): Logger name, defaults to "vibesurf"
+        
+    Returns:
+        logging.Logger: Configured logger instance
+    """
+    # Get debug flag from environment variable
+    debug_mode = os.getenv("VIBESURF_DEBUG", "false").lower() in ("true", "1", "yes", "on")
+    log_level = logging.DEBUG if debug_mode else logging.INFO
+    
+    # Create logger
+    logger = logging.getLogger(name)
+    logger.setLevel(log_level)
+    
+    # Avoid adding handlers multiple times
+    if logger.handlers:
+        return logger
+    
+    # Create formatter with file and line info
+    if log_level == logging.DEBUG:
+        formatter = logging.Formatter(
+            fmt='%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(funcName)s() - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+    else:
+        formatter = logging.Formatter(
+            fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+    
+    # Console handler - log to terminal
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(log_level)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler - log to file
+    try:
+        workspace_dir = get_workspace_dir()
+        logs_dir = os.path.join(workspace_dir, "logs")
+        os.makedirs(logs_dir, exist_ok=True)
+        
+        # Create log filename with current date
+        current_date = datetime.now().strftime("%Y-%m-%d")
+        log_filename = f"log_{current_date}.log"
+        log_filepath = os.path.join(logs_dir, log_filename)
+        
+        # Use RotatingFileHandler to manage log file size
+        file_handler = RotatingFileHandler(
+            log_filepath,
+            maxBytes=10 * 1024 * 1024,  # 10MB
+            backupCount=5,
+            encoding='utf-8'
+        )
+        file_handler.setLevel(log_level)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+        
+        logger.info(f"Logger initialized. Log level: {logging.getLevelName(log_level)}")
+        logger.info(f"WorkSpace directory: {workspace_dir}")
+        logger.info(f"Log file: {log_filepath}")
+        
+    except Exception as e:
+        logger.error(f"Failed to setup file logging: {e}")
+        logger.warning("Continuing with console logging only")
+    
+    return logger
+
+
+def get_logger(name: str = "vibesurf") -> logging.Logger:
+    """
+    Get or create a logger instance.
+    
+    Args:
+        name (str): Logger name, defaults to "vibesurf"
+        
+    Returns:
+        logging.Logger: Logger instance
+    """
+    return setup_logger(name)
+
+
+# Create default logger instance
+default_logger = get_logger()