vibesurf 0.1.23__tar.gz → 0.1.25__tar.gz

{vibesurf-0.1.23 → vibesurf-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.23
+Version: 0.1.25
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0
@@ -43,6 +43,7 @@ Requires-Dist: nanoid>=2.0.0
 Requires-Dist: markdownify>=1.2.0
 Requires-Dist: pathvalidate>=3.3.1
 Requires-Dist: dashscope>=1.24.5
+Requires-Dist: yfinance>=0.2.66
 Dynamic: license-file
 
 # VibeSurf: A powerful browser assistant for vibe surfing

{vibesurf-0.1.23 → vibesurf-0.1.25}/pyproject.toml

@@ -44,6 +44,7 @@ dependencies = [
     "markdownify>=1.2.0",
     "pathvalidate>=3.3.1",
     "dashscope>=1.24.5",
+    "yfinance>=0.2.66",
 ]
 
 [project.urls]

{vibesurf-0.1.23 → vibesurf-0.1.25}/tests/test_agents.py

@@ -18,9 +18,11 @@ from vibe_surf.browser.agen_browser_profile import AgentBrowserProfile
 from vibe_surf.tools.browser_use_tools import BrowserUseTools
 from vibe_surf.tools.vibesurf_tools import VibeSurfTools
 from vibe_surf.llm.openai_compatible import ChatOpenAICompatible
+from browser_use.llm.deepseek.chat import ChatDeepSeek
 from vibe_surf.agents.browser_use_agent import BrowserUseAgent
 from vibe_surf.agents.vibe_surf_agent import VibeSurfAgent
 
+
 async def run_single_bu_agent():
     import platform
     if platform.system() != "Darwin":
@@ -46,9 +48,13 @@ async def run_single_bu_agent():
     #                            base_url=os.getenv("ALIBABA_ENDPOINT"),
     #                            api_key=os.getenv("ALIBABA_API_KEY"))
 
-    llm = ChatOpenAICompatible(model='kimi-k2-turbo-preview',
-                               base_url=os.getenv("MOONSHOT_ENDPOINT"),
-                               api_key=os.getenv("MOONSHOT_API_KEY"))
+    # llm = ChatOpenAICompatible(model='kimi-k2-turbo-preview',
+    #                            base_url=os.getenv("MOONSHOT_ENDPOINT"),
+    #                            api_key=os.getenv("MOONSHOT_API_KEY"))
+
+    llm = ChatOpenAICompatible(model='deepseek-reasoner',
+                               base_url=os.getenv("DEEPSEEK_ENDPOINT"),
+                               api_key=os.getenv("DEEPSEEK_API_KEY"))
 
     task = "Search Google for 'Elon Mask' and tell me the top 3 results"
 
@@ -159,20 +165,22 @@ async def test_vibe_surf_agent():
     await main_browser_session.start()
     vs_tools = VibeSurfTools()
     browser_manager = BrowserManager(main_browser_session=main_browser_session)
-    llm = ChatOpenAICompatible(model='gemini-2.5-flash',
-                               base_url=os.getenv("OPENAI_ENDPOINT"),
-                               api_key=os.getenv("OPENAI_API_KEY"))
+    # llm = ChatOpenAICompatible(model='gemini-2.5-flash',
+    #                            base_url=os.getenv("OPENAI_ENDPOINT"),
+    #                            api_key=os.getenv("OPENAI_API_KEY"))
+
+    llm = ChatOpenAICompatible(model='deepseek-chat',
+                               base_url=os.getenv("DEEPSEEK_ENDPOINT"),
+                               api_key=os.getenv("DEEPSEEK_API_KEY"))
 
-    
     # Create VibeSurfAgent
     agent = VibeSurfAgent(
         llm=llm,
         browser_manager=browser_manager,
         tools=vs_tools,
-        workspace_dir=os.path.abspath("./tmp/vibesurf_tests"),
-        calculate_token_cost=True
+        workspace_dir=os.path.abspath("./tmp/vibesurf_tests")
     )
-    
+
     try:
         # Test 1: Simple task (should not require browser)
         print("🧪 Testing simple task...")
@@ -200,16 +208,16 @@ async def test_vibe_surf_agent():
         # print("🎉 All VibeSurfAgent tests passed!")
 
         # Test 4: Browser parallel task
-        print("🧪 Testing browser parallel tasks...")
-        browser_task = "Search for Dify, n8n, browser-use and click into their own homepage, take screenshot and save"
-        result4 = await agent.run(browser_task)
-        print(f"✅ Browser task result:")
-        pprint.pprint(result4)
-        with open("./tmp/vibesurf_tests/parallel_test.md", "w", encoding='utf-8') as fw:
-            fw.write(result4)
-        assert result4 is not None and len(result4) > 0
+        # print("🧪 Testing browser parallel tasks...")
+        # browser_task = "Search for Dify, n8n, browser-use and click into their own homepage, take screenshot and save"
+        # result4 = await agent.run(browser_task)
+        # print(f"✅ Browser task result:")
+        # pprint.pprint(result4)
+        # with open("./tmp/vibesurf_tests/parallel_test.md", "w", encoding='utf-8') as fw:
+        #     fw.write(result4)
+        # assert result4 is not None and len(result4) > 0
         print("🎉 All VibeSurfAgent tests passed!")
-        
+
     except Exception as e:
         print(f"❌ VibeSurfAgent test failed: {e}")
         raise e
@@ -240,7 +248,6 @@ async def test_vibe_surf_agent_control():
     llm = ChatOpenAICompatible(model='gemini-2.5-pro',
                                base_url=os.getenv("OPENAI_ENDPOINT"),
                                api_key=os.getenv("OPENAI_API_KEY"))
-    
 
     # Create VibeSurfAgent
     agent = VibeSurfAgent(
@@ -253,69 +260,69 @@ async def test_vibe_surf_agent_control():
 
     try:
         print("🧪 Testing VibeSurfAgent control functionality...")
-        
+
         # Test 1: Status check when idle
         print("📊 Testing initial status...")
         status = agent.get_status()
         print(f"Initial status: {status.overall_status}")
         assert status.overall_status == "idle"
-        
+
         # Test 2: Start a long-running browser task
         print("🚀 Starting long-running browser task...")
         browser_task = "Search for Dify, n8n, langflow and gather relative information, and generate a detailed report for comparison"
-        
+
         # Start task in background
         async def run_task():
             return await agent.run(browser_task)
-        
+
         task_coroutine = asyncio.create_task(run_task())
-        
+
         # Wait a bit for task to start
         await asyncio.sleep(10)
-        
+
         # Test 3: Check status during execution
         print("📊 Checking status during execution...")
         status = agent.get_status()
         print(f"Running status: {status.overall_status}")
         print(f"Progress: {status.progress}")
         print(f"Active agents: {len(status.agent_statuses)}")
-        
+
         # Test 4: Pause execution
         print("⏸️ Testing pause functionality...")
         pause_result = await agent.pause("Testing pause functionality")
         print(f"Pause result: {pause_result.success} - {pause_result.message}")
         assert pause_result.success
-        
+
         # Check status after pause
         await asyncio.sleep(1)
         status = agent.get_status()
         print(f"Paused status: {status.overall_status}")
         assert status.overall_status == "paused"
-        
+
         # Test 5: Resume execution
         print("▶️ Testing resume functionality...")
         resume_result = await agent.resume("Testing resume functionality")
         print(f"Resume result: {resume_result.success} - {resume_result.message}")
         assert resume_result.success
-        
+
         # Check status after resume
         await asyncio.sleep(1)
         status = agent.get_status()
         print(f"Resumed status: {status.overall_status}")
-        
+
         # Let it run a bit more
         await asyncio.sleep(50)
-        
+
         # Test 6: Stop execution
         print("🛑 Testing stop functionality...")
         stop_result = await agent.stop("Testing stop functionality")
         print(f"Stop result: {stop_result.success} - {stop_result.message}")
-        
+
         # Check status after stop (should be stopped even if stop had issues)
         await asyncio.sleep(1)
         status = agent.get_status()
         print(f"Stopped status: {status.overall_status}")
-        
+
         # Wait for task to complete (it should be cancelled)
         try:
             result = await asyncio.wait_for(task_coroutine, timeout=3)
@@ -329,38 +336,38 @@ async def test_vibe_surf_agent_control():
                 pass
         except asyncio.CancelledError:
             print("✅ Task was cancelled as expected")
-        
+
         # Verify stop worked (may have timed out but should still be effective)
         if stop_result.success:
             assert status.overall_status == "idle"
         else:
             print(f"⚠️ Stop operation had issues but continuing: {stop_result.message}")
-        
+
         # Test 7: Test simple task control (should work quickly)
         print("🔄 Testing control on simple task...")
         simple_task = "Find out who is the founder of Browser-Use."
-        
+
         async def run_simple_task():
             return await agent.run(simple_task)
-        
+
         simple_task_coroutine = asyncio.create_task(run_simple_task())
-        
+
         # Pause quickly
         await asyncio.sleep(0.5)
         pause_result = await agent.pause("Testing simple task pause")
         print(f"Simple task pause: {pause_result.success}")
-        
+
         # Resume
         await asyncio.sleep(0.5)
         resume_result = await agent.resume("Testing simple task resume")
         print(f"Simple task resume: {resume_result.success}")
-        
+
         # Let it complete
         simple_result = await simple_task_coroutine
         print(f"Simple task completed: {len(simple_result) > 0}")
         print(simple_result)
         print("🎉 All VibeSurfAgent control tests passed!")
-        
+
     except Exception as e:
         print(f"❌ VibeSurfAgent control test failed: {e}")
         import traceback
@@ -377,7 +384,7 @@ async def test_vibe_surf_agent_control():
 
 
 if __name__ == "__main__":
-    asyncio.run(run_single_bu_agent())
+    # asyncio.run(run_single_bu_agent())
     # asyncio.run(run_multi_bu_agents())
-    # asyncio.run(test_vibe_surf_agent())
+    asyncio.run(test_vibe_surf_agent())
     # asyncio.run(test_vibe_surf_agent_control())

{vibesurf-0.1.23 → vibesurf-0.1.25}/tests/test_tools.py

@@ -116,8 +116,19 @@ async def test_vibesurf_tools():
     print(tools.registry.registry.actions.keys())
 
 
+async def test_finance_tools():
+    from vibe_surf.tools.finance_tools import FinanceDataRetriever
+
+    retriever = FinanceDataRetriever('TSLA')
+
+    result = retriever.get_finance_data(["get_news"])
+
+    pdb.set_trace()
+
+
 if __name__ == '__main__':
     # asyncio.run(test_tools_with_mcp())
     # asyncio.run(test_filesystem())
     # asyncio.run(test_bu_tools())
-    asyncio.run(test_vibesurf_tools())
+    # asyncio.run(test_vibesurf_tools())
+    asyncio.run(test_finance_tools())

{vibesurf-0.1.23 → vibesurf-0.1.25}/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 = 'g415c8bc4e'
+__commit_id__ = commit_id = 'gb2d55c9c9'

{vibesurf-0.1.23 → vibesurf-0.1.25}/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}"

{vibesurf-0.1.23 → vibesurf-0.1.25}/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))
         

{vibesurf-0.1.23 → vibesurf-0.1.25}/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
             )

{vibesurf-0.1.23 → vibesurf-0.1.25}/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,

{vibesurf-0.1.23 → vibesurf-0.1.25}/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: