vibesurf 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

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,13 @@ 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:
+                    pdb.set_trace()
+                    repair_content = repair_json(output_content)
+                    parsed = output_format.model_validate_json(repair_content)
 
                 return ChatInvokeCompletion(
                     completion=parsed,

vibe_surf/tools/browser_use_tools.py

@@ -462,96 +462,6 @@ class BrowserUseTools(Tools, VibeSurfTools):
                 logger.error(f'Failed to switch tab: {str(e)}')
                 return ActionResult(error=f'Failed to switch to tab {params.tab_id or params.url}: {str(e)}')
 
-        @self.registry.action(
-            """Extract structured, semantic data (e.g. product description, price, all information about XYZ) from the current webpage based on a textual query.
-        This tool takes the entire markdown of the page and extracts the query from it.
-        Set extract_links=True ONLY if your query requires extracting links/URLs from the page.
-        Only use this for specific queries for information retrieval from the page. Don't use this to get interactive elements - the tool does not see HTML elements, only the markdown.
-        Note: Extracting from the same page will yield the same results unless more content is loaded (e.g., through scrolling for dynamic content, or new page is loaded) - so one extraction per page state is sufficient. If you want to scrape a listing of many elements always first scroll a lot until the page end to load everything and then call this tool in the end.
-        If you called extract_structured_data in the last step and the result was not good (e.g. because of antispam protection), use the current browser state and scrolling to get the information, dont call extract_structured_data again.
-        """,
-            param_model=ExtractionAction
-        )
-        async def extract_structured_data(
-                params: ExtractionAction,
-                browser_session: AgentBrowserSession,
-                page_extraction_llm: BaseChatModel,
-                file_system: FileSystem,
-        ):
-            try:
-                # Use AgentBrowserSession's direct method to get HTML content
-                target_id = None
-                if params.tab_id:
-                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
-                page_html = await browser_session.get_html_content(target_id)
-
-                # Simple markdown conversion
-                import re
-                import markdownify
-
-                if params.extract_links:
-                    content = markdownify.markdownify(page_html, heading_style='ATX', bullets='-')
-                else:
-                    content = markdownify.markdownify(page_html, heading_style='ATX', bullets='-', strip=['a'])
-                    # Remove all markdown links and images, keep only the text
-                    content = re.sub(r'!\[.*?\]\([^)]*\)', '', content, flags=re.MULTILINE | re.DOTALL)  # Remove images
-                    content = re.sub(
-                        r'\[([^\]]*)\]\([^)]*\)', r'\1', content, flags=re.MULTILINE | re.DOTALL
-                    )  # Convert [text](url) -> text
-
-                # Remove weird positioning artifacts
-                content = re.sub(r'❓\s*\[\d+\]\s*\w+.*?Position:.*?Size:.*?\n?', '', content,
-                                 flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'Primary: UNKNOWN\n\nNo specific evidence found', '', content,
-                                 flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'UNKNOWN CONFIDENCE', '', content, flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'!\[\]\(\)', '', content, flags=re.MULTILINE | re.DOTALL)
-
-                # Simple truncation to 30k characters
-                if len(content) > 30000:
-                    content = content[:30000] + '\n\n... [Content truncated at 30k characters] ...'
-
-                # Simple prompt
-                prompt = f"""Extract the requested information from this webpage content.
-                
-Query: {params.query}
-
-Webpage Content:
-{content}
-
-Provide the extracted information in a clear, structured format."""
-
-                from browser_use.llm.messages import UserMessage
-
-                response = await asyncio.wait_for(
-                    page_extraction_llm.ainvoke([UserMessage(content=prompt)]),
-                    timeout=120.0,
-                )
-
-                extracted_content = f'Query: {params.query}\nExtracted Content:\n{response.completion}'
-
-                # Simple memory handling
-                if len(extracted_content) < 1000:
-                    memory = extracted_content
-                    include_extracted_content_only_once = False
-                else:
-                    save_result = await file_system.save_extracted_content(extracted_content)
-                    current_url = await browser_session.get_current_page_url()
-                    memory = (
-                        f'Extracted content from {current_url} for query: {params.query}\nContent saved to file system: {save_result}'
-                    )
-                    include_extracted_content_only_once = True
-
-                logger.info(f'📄 {memory}')
-                return ActionResult(
-                    extracted_content=extracted_content,
-                    include_extracted_content_only_once=include_extracted_content_only_once,
-                    long_term_memory=memory,
-                )
-            except Exception as e:
-                logger.debug(f'Error extracting content: {e}')
-                raise RuntimeError(str(e))
-
         @self.registry.action(
             'Take a screenshot of the current page and save it to the file system',
             param_model=NoParamsAction

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: