vibesurf 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.23'
-__version_tuple__ = version_tuple = (0, 1, 23)
+__version__ = version = '0.1.25'
+__version_tuple__ = version_tuple = (0, 1, 25)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/vibe_surf_agent.py

@@ -479,7 +479,7 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
                     llm=vibesurf_agent.llm,
                     file_system=vibesurf_agent.file_system,
                 )
-                if "skill_search" in action_name or "skill_crawl" in action_name or "skill_summary" in action_name:
+                if action_name in ["skill_search", "skill_crawl", "skill_summary", "skill_finance"]:
                     state.current_step = "END"
                     # Format final response
                     final_response = f"{result.extracted_content}"

vibe_surf/backend/api/config.py

@@ -234,7 +234,9 @@ async def update_llm_profile(
         
         # Return updated profile
         updated_profile = await LLMProfileQueries.get_profile(db, profile_name)
-        
+        from ..shared_state import current_llm_profile_name
+        if current_llm_profile_name != profile_name:
+            current_llm_profile_name = None
         # Use safe extraction to avoid greenlet issues
         return LLMProfileResponse(**_profile_to_response_dict(updated_profile))
         

vibe_surf/backend/utils/llm_factory.py

@@ -142,8 +142,9 @@ def create_llm_from_profile(llm_profile) -> BaseChatModel:
             )
 
         elif provider == "deepseek":
-            return ChatDeepSeek(
+            return ChatOpenAICompatible(
                 model=model,
+                base_url="https://api.deepseek.com",
                 api_key=api_key,
                 **common_params
             )

vibe_surf/llm/openai_compatible.py

@@ -51,6 +51,8 @@ from browser_use.llm.openai.serializer import OpenAIMessageSerializer
 from browser_use.llm.schema import SchemaOptimizer
 from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
 
+from json_repair import repair_json
+
 T = TypeVar('T', bound=BaseModel)
 
 from vibe_surf.logger import get_logger
@@ -74,6 +76,8 @@ class ChatOpenAICompatible(ChatOpenAI):
     The class automatically detects the model type and applies appropriate fixes.
     """
 
+    max_completion_tokens: int | None = 16000
+
     def _is_gemini_model(self) -> bool:
         """Check if the current model is a Gemini model."""
         return str(self.model).lower().startswith('gemini')
@@ -82,6 +86,11 @@ class ChatOpenAICompatible(ChatOpenAI):
         """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_deepseek_model(self) -> bool:
+        """Check if the current model is a Kimi/Moonshot model."""
+        model_str = str(self.model).lower()
+        return 'deepseek' in model_str
     
     def _is_qwen_model(self) -> bool:
         """Check if the current model is a Qwen model."""
@@ -223,10 +232,10 @@ class ChatOpenAICompatible(ChatOpenAI):
         """
         # If this is not a special model or no structured output is requested,
         # use the parent implementation directly
-        if self._is_qwen_model() or self._is_kimi_model():
+        if self._is_qwen_model() or self._is_kimi_model() or self._is_deepseek_model() :
             self.add_schema_to_system_prompt = True
 
-        if not (self._is_gemini_model() or self._is_kimi_model() or self._is_qwen_model()) or output_format is None:
+        if not (self._is_gemini_model() or self._is_kimi_model() or self._is_qwen_model() or self._is_deepseek_model()) or output_format is None:
             return await super().ainvoke(messages, output_format)
         openai_messages = OpenAIMessageSerializer.serialize_messages(messages)
 
@@ -241,6 +250,7 @@ class ChatOpenAICompatible(ChatOpenAI):
 
             if self.max_completion_tokens is not None:
                 model_params['max_completion_tokens'] = self.max_completion_tokens
+                model_params['max_tokens'] = self.max_completion_tokens
 
             if self.top_p is not None:
                 model_params['top_p'] = self.top_p
@@ -298,12 +308,22 @@ class ChatOpenAICompatible(ChatOpenAI):
                         ]
 
                 # 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 self.add_schema_to_system_prompt:
+                    response = await self.get_client().chat.completions.create(
+                        model=self.model,
+                        messages=openai_messages,
+                        response_format={
+                            'type': 'json_object'
+                        },
+                        **model_params,
+                    )
+                else:
+                    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(
@@ -313,8 +333,12 @@ class ChatOpenAICompatible(ChatOpenAI):
                     )
 
                 usage = self._get_usage(response)
-
-                parsed = output_format.model_validate_json(response.choices[0].message.content)
+                output_content = response.choices[0].message.content
+                try:
+                    parsed = output_format.model_validate_json(output_content)
+                except Exception as e:
+                    repair_content = repair_json(output_content)
+                    parsed = output_format.model_validate_json(repair_content)
 
                 return ChatInvokeCompletion(
                     completion=parsed,

vibe_surf/tools/file_system.py

@@ -224,9 +224,9 @@ class CustomFileSystem(FileSystem):
     def _is_valid_filename(self, file_name: str) -> bool:
         """Check if filename matches the required pattern: name.extension"""
         # Build extensions pattern from _file_types
-        file_name = os.path.basename(file_name)
+        file_name = os.path.splitext(file_name)[1]
         extensions = '|'.join(self._file_types.keys())
-        pattern = rf'^[a-zA-Z0-9_\-]+\.({extensions})$'
+        pattern = rf'\.({extensions})$'
         return bool(re.match(pattern, file_name))
 
     async def append_file(self, full_filename: str, content: str) -> str: