vibesurf 0.1.11__tar.gz → 0.1.12__tar.gz

{vibesurf-0.1.11 → vibesurf-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.11
+Version: 0.1.12
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.11'
-__version_tuple__ = version_tuple = (0, 1, 11)
+__version__ = version = '0.1.12'
+__version_tuple__ = version_tuple = (0, 1, 12)
 
-__commit_id__ = commit_id = 'g542374226'
+__commit_id__ = commit_id = 'gaff176eb4'

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/agents/vibe_surf_agent.py

@@ -363,6 +363,7 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
 
     # Format context information
     context_info = []
+    context_info.append(f"Current Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     if browser_tabs:
         browser_tabs_info = {}
         for tab in browser_tabs:

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/backend/api/task.py

@@ -248,7 +248,7 @@ async def stop_task(control_request: TaskControlRequest):
                 active_task["end_time"] = datetime.now()
 
             # Clear active task
-            # clear_active_task()
+            clear_active_task()
 
             return {
                 "success": True,

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/cli.py

@@ -341,7 +341,8 @@ def start_backend(port: int) -> None:
 def get_browser_execution_path() -> Optional[str]:
     """Get browser execution path from envs.json or environment variables."""
     # 1. Load environment variables
-    from .common import get_workspace_dir
+    from vibe_surf.common import get_workspace_dir
+
     workspace_dir = get_workspace_dir()
     os.makedirs(workspace_dir, exist_ok=True)
     logger.info("WorkSpace directory: {}".format(workspace_dir))

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/llm/openai_compatible.py

@@ -53,25 +53,41 @@ 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.
@@ -147,6 +163,43 @@ class ChatOpenAICompatible(ChatOpenAI):
 
         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]:
         ...
@@ -168,9 +221,9 @@ class ChatOpenAICompatible(ChatOpenAI):
         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)
 
         openai_messages = OpenAIMessageSerializer.serialize_messages(messages)
@@ -217,7 +270,17 @@ class ChatOpenAICompatible(ChatOpenAI):
 
             else:
                 original_schema = SchemaOptimizer.create_optimized_json_schema(output_format)
-                fixed_schema = self._fix_gemini_schema(original_schema)
+
+                # 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,

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibe_surf/tools/file_system.py

@@ -229,6 +229,26 @@ class CustomFileSystem(FileSystem):
         pattern = rf'^[a-zA-Z0-9_\-]+\.({extensions})$'
         return bool(re.match(pattern, file_name))
 
+    async def append_file(self, full_filename: str, content: str) -> str:
+        """Append content to file using file-specific append method"""
+        if not self._is_valid_filename(full_filename):
+            return INVALID_FILENAME_ERROR_MESSAGE
+
+        full_path = self.data_dir / full_filename
+        is_file_exist = await self.file_exist(full_filename)
+        if not is_file_exist:
+            return f"File '{full_filename}' not found."
+
+        try:
+            with open(str(full_path), encoding='utf-8', mode='a') as f:
+                f.write(content)
+
+            return f'Data appended to file {full_filename} successfully.'
+        except FileSystemError as e:
+            return str(e)
+        except Exception as e:
+            return f"Error: Could not append to file '{full_filename}'. {str(e)}"
+
     async def write_file(self, full_filename: str, content: str) -> str:
         """Write content to file using file-specific write method"""
         if not self._is_valid_filename(full_filename):
@@ -249,8 +269,9 @@ class CustomFileSystem(FileSystem):
                 file_obj = file_class(name=name_without_ext)
                 self.files[full_filename] = file_obj  # Use full filename as key
 
-            # Use file-specific write method
-            await file_obj.write(content, self.data_dir)
+            with open(str(full_path), encoding='utf-8', mode='w') as f:
+                f.write(content)
+
             return f'Data written to file {full_filename} successfully.'
         except FileSystemError as e:
             return str(e)
@@ -282,7 +303,8 @@ class CustomFileSystem(FileSystem):
                 self.files[full_filename] = file_obj  # Use full filename as key
 
             # Use file-specific write method
-            await file_obj.write('', self.data_dir)
+            with open(str(full_path), encoding='utf-8', mode='w') as f:
+                f.write('')
             return f'Create file {full_filename} successfully.'
         except FileSystemError as e:
             return str(e)

{vibesurf-0.1.11 → vibesurf-0.1.12}/vibesurf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.11
+Version: 0.1.12
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0