alita-sdk 0.3.374__py3-none-any.whl → 0.3.423__py3-none-any.whl

alita_sdk/configurations/zephyr_essential.py

@@ -18,3 +18,78 @@ class ZephyrEssentialConfiguration(BaseModel):
     )
     base_url: Optional[str] = Field(description="Zephyr Essential API Base URL", default=None)
     token: SecretStr = Field(description="Zephyr Essential API Token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Essential (Zephyr Scale).
+        
+        Args:
+            settings: Dictionary containing Zephyr Essential configuration
+                - base_url: Zephyr Essential API Base URL (optional, defaults to Zephyr Scale Cloud API)
+                - token: Zephyr Essential API Token (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Get base_url or use default
+        base_url = settings.get("base_url")
+        if base_url:
+            base_url = base_url.strip().rstrip("/")
+            # Validate URL format if provided
+            if not base_url.startswith(("http://", "https://")):
+                return "Zephyr Essential URL must start with http:// or https://"
+        else:
+            # Default to Zephyr Scale Cloud API
+            base_url = "https://api.zephyrscale.smartbear.com/v2"
+        
+        # Validate token
+        token = settings.get("token")
+        if not token:
+            return "Zephyr Essential API token is required"
+        
+        # Extract token value if it's a SecretStr
+        token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+        
+        if not token_value or not str(token_value).strip():
+            return "Zephyr Essential API token cannot be empty"
+        
+        # Test connection using /projects endpoint (requires authentication)
+        test_url = f"{base_url}/projects"
+        
+        headers = {
+            "Authorization": f"Bearer {str(token_value).strip()}"
+        }
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid API token"
+            elif response.status_code == 403:
+                return "Access forbidden: token lacks required permissions"
+            elif response.status_code == 404:
+                return "Zephyr Essential API endpoint not found: verify the API URL"
+            else:
+                return f"Zephyr Essential API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Essential at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Essential at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Essential: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/runtime/clients/client.py

@@ -568,7 +568,7 @@ class AlitaClient:
     def predict_agent(self, llm: ChatOpenAI, instructions: str = "You are a helpful assistant.",
                       tools: Optional[list] = None, chat_history: Optional[List[Any]] = None,
                       memory=None, runtime='langchain', variables: Optional[list] = None,
-                      store: Optional[BaseStore] = None):
+                      store: Optional[BaseStore] = None, debug_mode: Optional[bool] = False):
         """
         Create a predict-type agent with minimal configuration.
 
@@ -581,6 +581,7 @@ class AlitaClient:
             runtime: Runtime type (default: 'langchain')
             variables: Optional list of variables for the agent
             store: Optional store for memory
+            debug_mode: Enable debug mode for cases when assistant can be initialized without tools
 
         Returns:
             Runnable agent ready for execution
@@ -600,7 +601,7 @@ class AlitaClient:
             'variables': variables
         }
         return LangChainAssistant(self, agent_data, llm,
-                                  chat_history, "predict", memory=memory, store=store).runnable()
+                                  chat_history, "predict", memory=memory, store=store, debug_mode=debug_mode).runnable()
 
     def test_toolkit_tool(self, toolkit_config: dict, tool_name: str, tool_params: dict = None,
                           runtime_config: dict = None, llm_model: str = None,

alita_sdk/runtime/clients/sandbox_client.py

@@ -143,6 +143,7 @@ class SandboxClient:
         self.configurations_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=configurations&unsecret=true'
         self.ai_section_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=ai'
         self.image_generation_url = f'{self.base_url}{self.llm_path}/images/generations'
+        self.auth_user_url = f'{self.base_url}{self.api_path}/auth/user'
         self.configurations: list = configurations or []
         self.model_timeout = kwargs.get('model_timeout', 120)
         self.model_image_generation = kwargs.get('model_image_generation')
@@ -363,3 +364,10 @@ class SandboxClient:
         url = f'{self.artifact_url}/{bucket_name}'
         data = requests.delete(url, headers=self.headers, verify=False, params={'filename': quote(artifact_name)})
         return self._process_requst(data)
+
+    def get_user_data(self) -> Dict[str, Any]:
+        resp = requests.get(self.auth_user_url, headers=self.headers, verify=False)
+        if resp.ok:
+            return resp.json()
+        logger.error(f'Failed to fetch user data: {resp.status_code} - {resp.text}')
+        raise ApiDetailsRequestError(f'Failed to fetch user data with status code {resp.status_code}.')

alita_sdk/runtime/langchain/assistant.py

@@ -17,6 +17,7 @@ from .constants import REACT_ADDON, REACT_VARS, XML_ADDON
 from .chat_message_template import Jinja2TemplatedChatMessagesTemplate
 from ..tools.echo import EchoTool
 from langchain_core.tools import BaseTool, ToolException
+from jinja2 import Environment, DebugUndefined
 
 logger = logging.getLogger(__name__)
 
@@ -29,7 +30,8 @@ class Assistant:
                  app_type: str = "openai",
                  tools: Optional[list] = [],
                  memory: Optional[Any] = None,
-                 store: Optional[BaseStore] = None):
+                 store: Optional[BaseStore] = None,
+                 debug_mode: Optional[bool] = False):
 
         self.app_type = app_type
         self.memory = memory
@@ -77,11 +79,17 @@ class Assistant:
         else:
             # For predict agents, initialize memory store to None since they don't use memory
             self.store = None
-        
+
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools
-        
-        self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client, memory_store=self.store)
+        version_tools = data['tools']
+        # Handle internal tools
+        meta = data.get('meta', {})
+        if meta.get("internal_tools"):
+            for internal_tool_name in meta.get("internal_tools"):
+                version_tools.append({"type": "internal_tool", "name": internal_tool_name})
+
+        self.tools = get_tools(version_tools, alita_client=alita, llm=self.client, memory_store=self.store, debug_mode=debug_mode)
         if tools:
             self.tools += tools
         # Handle prompt setup
@@ -118,9 +126,11 @@ class Assistant:
             if variables:
                 self.prompt.partial_variables = variables
             try:
-                logger.info(f"Client was created with client setting: temperature - {self.client._get_model_default_parameters}")
+                logger.info(
+                    f"Client was created with client setting: temperature - {self.client._get_model_default_parameters}")
             except Exception as e:
-                logger.info(f"Client was created with client setting: temperature - {self.client.temperature} : {self.client.max_tokens}")
+                logger.info(
+                    f"Client was created with client setting: temperature - {self.client.temperature} : {self.client.max_tokens}")
 
     def _configure_store(self, memory_tool: dict | None) -> None:
         """
@@ -137,11 +147,9 @@ class Assistant:
     def runnable(self):
         if self.app_type == 'pipeline':
             return self.pipeline()
-        elif self.app_type == 'openai':
-            return self.getOpenAIToolsAgentExecutor()
         elif self.app_type == 'xml':
             return self.getXMLAgentExecutor()
-        elif self.app_type in ['predict', 'react']:
+        elif self.app_type in ['predict', 'react', 'openai']:
             return self.getLangGraphReactAgent()
         else:
             self.tools = [EchoTool()] + self.tools
@@ -159,7 +167,6 @@ class Assistant:
         agent = create_json_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
-
     def getXMLAgentExecutor(self):
         # Exclude compiled graph runnables from simple tool agents
         simple_tools = [t for t in self.tools if isinstance(t, (BaseTool, CompiledStateGraph))]
@@ -180,34 +187,6 @@ class Assistant:
         # Exclude compiled graph runnables from simple tool agents
         simple_tools = [t for t in self.tools if isinstance(t, (BaseTool, CompiledStateGraph))]
         
-        # Add sandbox tool by default for react agents
-        try:
-            from ..tools.sandbox import create_sandbox_tool
-            sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True)
-            simple_tools.append(sandbox_tool)
-            logger.info("Added PyodideSandboxTool to react agent")
-        except ImportError as e:
-            logger.warning(f"Failed to add PyodideSandboxTool: {e}. Install langchain-sandbox to enable this feature.")
-        except RuntimeError as e:
-            if "Deno" in str(e):
-                logger.warning("Failed to add PyodideSandboxTool: Deno is required. Install from https://docs.deno.com/runtime/getting_started/installation/")
-            else:
-                logger.warning(f"Failed to add PyodideSandboxTool: {e}")
-        except Exception as e:
-            logger.error(f"Error adding PyodideSandboxTool: {e}")
-        
-        # Add image generation tool if model is configured
-        if self.alita_client.model_image_generation is not None:
-            try:
-                from ..tools.image_generation import (
-                    create_image_generation_tool
-                )
-                image_tool = create_image_generation_tool(self.alita_client)
-                simple_tools.append(image_tool)
-                logger.info("Added ImageGenerationTool to react agent")
-            except Exception as e:
-                logger.error(f"Error adding ImageGenerationTool: {e}")
-        
         # Set up memory/checkpointer if available
         checkpointer = None
         if self.memory is not None:
@@ -241,6 +220,10 @@ class Assistant:
         # Only use prompt_instructions if explicitly specified (for predict app_type)
         if self.app_type == "predict" and isinstance(self.prompt, str):
             prompt_instructions = self.prompt
+
+        # take the system message from the openai prompt as a prompt instructions
+        if self.app_type == "openai" and hasattr(self.prompt, 'messages'):
+            prompt_instructions = self.__take_prompt_from_openai_messages()
         
         # Create a unified YAML schema with conditional tool binding
         # Build the base node configuration
@@ -282,6 +265,9 @@ class Assistant:
         schema_dict = {
             'name': 'react_agent',
             'state': {
+                'input': {
+                    'type': 'str'
+                },
                 'messages': state_messages_config
             },
             'nodes': [{
@@ -290,6 +276,21 @@ class Assistant:
                 'prompt': {
                     'template': escaped_prompt
                 },
+                'input_mapping': {
+                    'system': {
+                        'type': 'fixed',
+                        'value': escaped_prompt
+                    },
+                    'task': {
+                        'type': 'variable',
+                        'value': 'input'
+                    },
+                    'chat_history': {
+                        'type': 'variable',
+                        'value': 'messages'
+                    }
+                },
+                'step_limit': self.max_iterations,
                 'input': ['messages'],
                 'output': ['messages'],
                 'transition': 'END'
@@ -315,7 +316,8 @@ class Assistant:
             store=self.store,
             debug=False,
             for_subgraph=False,
-            alita_client=self.alita_client
+            alita_client=self.alita_client,
+            steps_limit=self.max_iterations
         )
         
         return agent
@@ -330,7 +332,8 @@ class Assistant:
         agent = create_graph(
             client=self.client, tools=self.tools,
             yaml_schema=self.prompt, memory=memory,
-            alita_client=self.alita_client
+            alita_client=self.alita_client,
+            steps_limit=self.max_iterations
         )
         #
         return agent
@@ -341,3 +344,16 @@ class Assistant:
 
     def predict(self, messages: list[BaseMessage]):
         return self.client.invoke(messages)
+
+    def __take_prompt_from_openai_messages(self):
+        if self.prompt and self.prompt.messages:
+            for message in self.prompt.messages:
+                # we don't need any message placeholder from the openai agent prompt
+                if hasattr(message, 'variable_name'):
+                    continue
+                # take only the content of the system message from the openai prompt
+                if isinstance(message, SystemMessage):
+                    environment = Environment(undefined=DebugUndefined)
+                    template = environment.from_string(message.content)
+                    return template.render(self.prompt.partial_variables)
+        return None

alita_sdk/runtime/langchain/constants.py

@@ -80,3 +80,7 @@ DEFAULT_MULTIMODAL_PROMPT = """
 - Maintain a structured and logical flow in the output to enhance understanding and usability.
 - Avoid presenting the entire prompt for user.
 """
+
+ELITEA_RS = "elitea_response"
+PRINTER = "printer"
+PRINTER_NODE_RS = "printer_output"

alita_sdk/runtime/langchain/document_loaders/AlitaDocxMammothLoader.py

@@ -1,4 +1,5 @@
 import re
+import uuid
 from io import BytesIO
 
 import mammoth.images
@@ -8,6 +9,9 @@ from langchain_core.document_loaders import BaseLoader
 from langchain_core.documents import Document
 from mammoth import convert_to_html
 from markdownify import markdownify
+from docx import Document as DocxDocument
+from docx.oxml.ns import qn
+from bs4 import BeautifulSoup
 
 from alita_sdk.tools.chunkers.sematic.markdown_chunker import markdown_by_headers_chunker
 from .utils import perform_llm_prediction_for_image_bytes
@@ -17,6 +21,7 @@ class AlitaDocxMammothLoader(BaseLoader):
     """
     Loader for Docx files using Mammoth to convert to HTML, with image handling,
     and then Markdownify to convert HTML to markdown.
+    Detects bordered paragraphs and text boxes and treats them as code blocks.
     """
     def __init__(self, **kwargs):
         """
@@ -97,6 +102,295 @@ class AlitaDocxMammothLoader(BaseLoader):
         new_md = pattern.sub(replace_placeholder, original_md)
         return new_md
 
+    def __has_border(self, paragraph):
+        """
+        Check if a paragraph has border formatting.
+        
+        Args:
+            paragraph: A python-docx Paragraph object.
+            
+        Returns:
+            bool: True if paragraph has any border, False otherwise.
+        """
+        pPr = paragraph._element.pPr
+        if pPr is not None:
+            pBdr = pPr.find(qn('w:pBdr'))
+            if pBdr is not None:
+                # Check if any border side exists (top, bottom, left, right)
+                for side in ['top', 'bottom', 'left', 'right']:
+                    border = pBdr.find(qn(f'w:{side}'))
+                    if border is not None:
+                        # Check if border is not "none" or has a width
+                        val = border.get(qn('w:val'))
+                        if val and val != 'none':
+                            return True
+        return False
+
+    def __find_text_boxes(self, doc):
+        """
+        Find all text boxes in document by searching OOXML structure.
+        Text boxes are typically in w:txbxContent elements.
+        
+        Args:
+            doc: A python-docx Document object.
+            
+        Returns:
+            list: List of tuples (element, paragraphs_inside_textbox).
+        """
+        text_boxes = []
+        
+        # Iterate through document body XML to find text box content elements
+        for element in doc.element.body.iter():
+            # Look for text box content elements
+            if element.tag.endswith('txbxContent'):
+                # Collect all paragraphs inside this text box
+                txbx_paragraphs = []
+                for txbx_para_element in element.iter():
+                    if txbx_para_element.tag.endswith('p'):
+                        txbx_paragraphs.append(txbx_para_element)
+                
+                if txbx_paragraphs:
+                    text_boxes.append((element, txbx_paragraphs))
+        
+        return text_boxes
+
+    def __create_marker_paragraph(self, marker_text):
+        """
+        Create a paragraph element with marker text.
+        
+        Args:
+            marker_text (str): The marker text to insert.
+            
+        Returns:
+            Element: An OOXML paragraph element.
+        """
+        from docx.oxml import OxmlElement
+        
+        p = OxmlElement('w:p')
+        r = OxmlElement('w:r')
+        t = OxmlElement('w:t')
+        t.text = marker_text
+        r.append(t)
+        p.append(r)
+        return p
+
+    def __inject_markers_for_paragraph(self, paragraph, start_marker, end_marker):
+        """
+        Inject marker paragraphs before and after a bordered paragraph.
+        
+        Args:
+            paragraph: A python-docx Paragraph object.
+            start_marker (str): The start marker text.
+            end_marker (str): The end marker text.
+        """
+        # Insert start marker paragraph before
+        marker_p_start = self.__create_marker_paragraph(start_marker)
+        paragraph._element.addprevious(marker_p_start)
+        
+        # Insert end marker paragraph after
+        marker_p_end = self.__create_marker_paragraph(end_marker)
+        paragraph._element.addnext(marker_p_end)
+
+    def __inject_markers_for_textbox(self, textbox_element, paragraph_elements, start_marker, end_marker):
+        """
+        Inject markers around text box content.
+        
+        Args:
+            textbox_element: The w:txbxContent element.
+            paragraph_elements: List of paragraph elements inside the text box.
+            start_marker (str): The start marker text.
+            end_marker (str): The end marker text.
+        """
+        if not paragraph_elements:
+            return
+        
+        # Insert start marker before first paragraph in text box
+        first_para = paragraph_elements[0]
+        marker_p_start = self.__create_marker_paragraph(start_marker)
+        first_para.addprevious(marker_p_start)
+        
+        # Insert end marker after last paragraph in text box
+        last_para = paragraph_elements[-1]
+        marker_p_end = self.__create_marker_paragraph(end_marker)
+        last_para.addnext(marker_p_end)
+
+    def __detect_and_mark_bordered_content(self, docx_stream):
+        """
+        Detects bordered paragraphs and text boxes, injects unique markers around them.
+        Groups consecutive bordered paragraphs into single code blocks.
+        
+        Args:
+            docx_stream: A file-like object containing the DOCX document.
+            
+        Returns:
+            tuple: (modified_docx_stream, start_marker, end_marker)
+        """
+        # Load document with python-docx
+        doc = DocxDocument(docx_stream)
+        
+        # Generate unique markers to avoid conflicts with document content
+        unique_id = uuid.uuid4().hex[:8]
+        start_marker = f"<<<BORDERED_BLOCK_START_{unique_id}>>>"
+        end_marker = f"<<<BORDERED_BLOCK_END_{unique_id}>>>"
+        
+        # Group consecutive bordered paragraphs together
+        bordered_groups = []
+        current_group = []
+        
+        for para in doc.paragraphs:
+            if self.__has_border(para):
+                current_group.append(para)
+            else:
+                if current_group:
+                    # End of a bordered group
+                    bordered_groups.append(current_group)
+                    current_group = []
+        
+        # Don't forget the last group if document ends with bordered paragraphs
+        if current_group:
+            bordered_groups.append(current_group)
+        
+        # Collect all text boxes
+        # text_boxes = self.__find_text_boxes(doc)
+        
+        # Inject markers around each group of consecutive bordered paragraphs
+        for group in bordered_groups:
+            if group:
+                # Add start marker before first paragraph in group
+                first_para = group[0]
+                marker_p_start = self.__create_marker_paragraph(start_marker)
+                first_para._element.addprevious(marker_p_start)
+                
+                # Add end marker after last paragraph in group
+                last_para = group[-1]
+                marker_p_end = self.__create_marker_paragraph(end_marker)
+                last_para._element.addnext(marker_p_end)
+        
+        # Inject markers around text box content
+        # for textbox_element, para_elements in text_boxes:
+        #     self.__inject_markers_for_textbox(textbox_element, para_elements, start_marker, end_marker)
+        
+        # Save modified document to BytesIO
+        output = BytesIO()
+        doc.save(output)
+        output.seek(0)
+        
+        return output, start_marker, end_marker
+
+    def __contains_complex_structure(self, content_html):
+        """
+        Check if HTML content contains tables, lists, or other complex structures.
+        
+        Args:
+            content_html (str): HTML content to analyze.
+            
+        Returns:
+            bool: True if content contains tables/lists, False otherwise.
+        """
+        content_soup = BeautifulSoup(content_html, 'html.parser')
+        
+        # Check for tables
+        if content_soup.find('table'):
+            return True
+        
+        # Check for lists (ul, ol)
+        if content_soup.find('ul') or content_soup.find('ol'):
+            return True
+        
+        return False
+
+    def __escape_hash_symbols(self, html_content):
+        """
+        Escape hash (#) symbols at the beginning of lines in HTML to prevent
+        them from being treated as markdown headers.
+        
+        Args:
+            html_content (str): HTML content.
+            
+        Returns:
+            str: HTML with escaped hash symbols.
+        """
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Process all text-containing elements
+        for element in soup.find_all(['p', 'li', 'td', 'th', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']):
+            if element.string:
+                text = element.string
+                # If line starts with #, escape it
+                if text.strip().startswith('#'):
+                    element.string = text.replace('#', '\\#', 1)
+        
+        return str(soup)
+
+    def __wrap_marked_sections_in_code_blocks(self, html, start_marker, end_marker):
+        """
+        Find content between markers and wrap appropriately:
+        - Simple text/code → <pre><code> block
+        - Tables/lists → Custom wrapper with preserved structure
+        
+        Args:
+            html (str): The HTML content from Mammoth.
+            start_marker (str): The start marker text.
+            end_marker (str): The end marker text.
+            
+        Returns:
+            str: HTML with marked sections wrapped appropriately.
+        """
+        import html as html_module
+        
+        # Mammoth escapes < and > to &lt; and &gt;, so we need to escape our markers too
+        escaped_start = html_module.escape(start_marker)
+        escaped_end = html_module.escape(end_marker)
+        
+        # Pattern to find content between HTML-escaped markers (including HTML tags)
+        # The markers will be in separate <p> tags, and content in between
+        pattern = re.compile(
+            f'<p>{re.escape(escaped_start)}</p>(.*?)<p>{re.escape(escaped_end)}</p>',
+            re.DOTALL
+        )
+        
+        def replace_with_appropriate_wrapper(match):
+            content = match.group(1)
+            
+            # Detect if content has complex structure (tables, lists)
+            has_complex_structure = self.__contains_complex_structure(content)
+            
+            if has_complex_structure:
+                # Preserve structure: keep HTML as-is, escape # symbols
+                escaped_content = self.__escape_hash_symbols(content)
+                # Wrap in a div with special class for potential custom handling
+                return f'<div class="alita-bordered-content">{escaped_content}</div>'
+            else:
+                # Simple text/code: extract as plain text and wrap in code block
+                content_soup = BeautifulSoup(content, 'html.parser')
+                
+                # Extract text from each paragraph separately to preserve line breaks
+                lines = []
+                for element in content_soup.find_all(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']):
+                    # Replace <br /> within paragraphs with newlines
+                    for br in element.find_all('br'):
+                        br.replace_with('\n')
+                    text = element.get_text()
+                    # Preserve leading whitespace (indentation), only strip trailing
+                    lines.append(text.rstrip())
+                
+                # If no paragraphs found, just get all text
+                if not lines:
+                    content = content.replace('<br />', '\n').replace('<br/>', '\n').replace('<br>', '\n')
+                    content_text = content_soup.get_text()
+                    lines = [line.rstrip() for line in content_text.split('\n')]
+                
+                # Join lines, strip only leading/trailing empty lines
+                content_text = '\n'.join(lines).strip()
+                # Return as code block (need to HTML-escape the content)
+                content_escaped = html_module.escape(content_text)
+                return f'<pre><code>{content_escaped}</code></pre>'
+        
+        # Replace all marked sections with appropriate wrappers
+        result_html = pattern.sub(replace_with_appropriate_wrapper, html)
+        
+        return result_html
+
     def load(self):
         """
         Loads and converts the Docx file to markdown format.
@@ -131,6 +425,7 @@ class AlitaDocxMammothLoader(BaseLoader):
     def _convert_docx_to_markdown(self, docx_file):
         """
         Converts the content of a Docx file to markdown format.
+        Detects bordered content and treats it as code blocks.
 
         Args:
             docx_file (BinaryIO): The Docx file object.
@@ -138,11 +433,28 @@ class AlitaDocxMammothLoader(BaseLoader):
         Returns:
             str: The markdown content extracted from the Docx file.
         """
+        # Step 1: Detect and mark bordered content
+        # Reset stream position if needed
+        if hasattr(docx_file, 'seek'):
+            docx_file.seek(0)
+        
+        marked_docx, start_marker, end_marker = self.__detect_and_mark_bordered_content(docx_file)
+        
+        # Step 2: Convert marked DOCX to HTML using Mammoth
         if self.extract_images:
             # Extract images using the provided image handler
-            result = convert_to_html(docx_file, convert_image=mammoth.images.img_element(self.__handle_image))
+            result = convert_to_html(marked_docx, convert_image=mammoth.images.img_element(self.__handle_image))
         else:
             # Ignore images
-            result = convert_to_html(docx_file, convert_image=lambda image: "")
-        content = markdownify(result.value, heading_style="ATX")
+            result = convert_to_html(marked_docx, convert_image=lambda image: "")
+        
+        # Step 3: Wrap marked sections in <pre><code> tags
+        html_with_code_blocks = self.__wrap_marked_sections_in_code_blocks(
+            result.value, start_marker, end_marker
+        )
+        
+        # Step 4: Convert HTML to markdown
+        content = markdownify(html_with_code_blocks, heading_style="ATX")
+        
+        # Step 5: Post-process markdown (for image transcripts, etc.)
         return self.__postprocess_original_md(content)