def _prepare_clone_url_with_token(self, repo_url_to_clone: str) -> str | None:
     if "bitbucket.org" not in repo_url_to_clone:
         get_logger().error("Repo URL is not a valid bitbucket URL.")
         return None
     bearer_token = self.bearer_token
     if not bearer_token:
         get_logger().error("No bearer token provided. Returning None")
         return None
 
     #For example: For repo: https://bitbucket.org/codiumai/pr-agent-tests.git
     #clone url will be: https://x-token-auth:<token>@bitbucket.org/codiumai/pr-agent-tests.git
-    (scheme, base_url) = repo_url_to_clone.split("bitbucket.org")
-    if not all([scheme, base_url]):
-        get_logger().error(f"repo_url_to_clone: {repo_url_to_clone} is not a valid bitbucket URL.")
+    try:
+        parsed_url = urlparse(repo_url_to_clone)
+        scheme = f"{parsed_url.scheme}://"
+        netloc = parsed_url.netloc
+        path = parsed_url.path
+        
+        if not all([scheme, netloc, path]):
+            get_logger().error(f"repo_url_to_clone: {repo_url_to_clone} is not a valid bitbucket URL.")
+            return None
+            
+        clone_url = f"{scheme}x-token-auth:{bearer_token}@{netloc}{path}"
+        return clone_url
+    except Exception as e:
+        get_logger().error(f"Failed to parse repo URL: {repo_url_to_clone}, error: {e}")
         return None
-    clone_url = f"{scheme}x-token-auth:{bearer_token}@bitbucket.org{base_url}"
-    return clone_url

-if force_accurate and 'claude' in model and get_settings(use_context=False).get('anthropic.key'):
-    return self.calc_claude_tokens(patch) # API call to Anthropic for accurate token counting for Claude models
+if force_accurate and 'claude' in model:
+    if get_settings(use_context=False).get('anthropic.key'):
+        return self.calc_claude_tokens(patch) # API call to Anthropic for accurate token counting for Claude models
+    else:
+        get_logger().warning("Anthropic API key missing for accurate Claude token counting, falling back to estimate")
 #else: Non Anthropic provided model

-- file_name: "src/file1.py"
+- file_name: "docs/getting-started.md"
   relevant_section_header_string: |
     ...

-anthropic>=0.48
+anthropic>=0.48,<0.49
 #anthropic[vertex]==0.47.1

 +            self.bearer_token = bearer = context.get("bitbucket_bearer_token", None)
 +            if not bearer and get_settings().get("BITBUCKET.BEARER_TOKEN", None):
 +                self.bearer_token = bearer = get_settings().get("BITBUCKET.BEARER_TOKEN", None)
-+            s.headers["Authorization"] = f"Bearer {bearer}"
++            if bearer:
++                s.headers["Authorization"] = f"Bearer {bearer}"

 def calc_claude_tokens(self, patch):
     try:
         import anthropic
         from pr_agent.algo import MAX_TOKENS
         client = anthropic.Anthropic(api_key=get_settings(use_context=False).get('anthropic.key'))
-        MaxTokens = MAX_TOKENS[get_settings().config.model]
+        model = get_settings().config.model
+        MaxTokens = MAX_TOKENS.get(model, 100000)  # Default fallback value if model not found
 
         # Check if the content size is too large (9MB limit)
         if len(patch.encode('utf-8')) > 9_000_000:
             get_logger().warning(
                 "Content too large for Anthropic token counting API, falling back to local tokenizer"
             )
             return MaxTokens

 self.bearer_token = bearer = context.get("bitbucket_bearer_token", None)
 if not bearer and get_settings().get("BITBUCKET.BEARER_TOKEN", None):
     self.bearer_token = bearer = get_settings().get("BITBUCKET.BEARER_TOKEN", None)
-s.headers["Authorization"] = f"Bearer {bearer}"
+if bearer:
+    s.headers["Authorization"] = f"Bearer {bearer}"
+else:
+    get_logger().warning("No bearer token found for Bitbucket authorization")

-model_token_count_estimate_factor=0.3 # factor to increase the token count estimate, in order to reduce likelihood of model failure due to too many tokens.
+model_token_count_estimate_factor=0.3 # factor (0.0-1.0) to increase the token count estimate, in order to reduce likelihood of model failure due to too many tokens. Higher values provide more buffer but may reduce efficiency.

 def extract_model_answer_and_relevant_sources(ai_response: str) -> str | None:
     # It is assumed that the input contains several sections with leading "### ",
     # where the answer is the last one of them having the format: "### Answer:\n"), since the model returns the answer
     # AFTER the user question. By splitting using the string: "### Answer:\n" and grabbing the last part,
     # the model answer is guaranteed to be in that last part, provided it is followed by a "#### Relevant Sources:\n\n".
     # (for more details, see here: https://github.com/Codium-ai/pr-agent-pro/blob/main/pr_agent/tools/pr_help_message.py#L173)
     """
     For example:
     ### Question: \nHow does one request to re-review a PR?\n\n
     ### Answer:\nAccording to the documentation, one needs to invoke the command: /review\n\n
     #### Relevant Sources:\n\n...
 
     The answer part is: "According to the documentation, one needs to invoke the command: /review\n\n"
     followed by "Relevant Sources:\n\n".
     """
     if "### Answer:\n" in ai_response:
         model_answer_and_relevant_sources_sections_in_response = ai_response.split("### Answer:\n")[-1]
         # Split such part by "Relevant Sources" section to contain only the model answer:
         if "#### Relevant Sources:\n\n" in model_answer_and_relevant_sources_sections_in_response:
             model_answer_section_in_response \
                 = model_answer_and_relevant_sources_sections_in_response.split("#### Relevant Sources:\n\n")[0]
             get_logger().info(f"Found model answer: {model_answer_section_in_response}")
-            return model_answer_and_relevant_sources_sections_in_response \
-                if len(model_answer_section_in_response) > 0 else None
+            return model_answer_section_in_response if len(model_answer_section_in_response) > 0 else None
     get_logger().warning(f"Either no answer section found, or that section is malformed: {ai_response}")
     return None

 def modify_answer_section(ai_response: str) -> str | None:
     # Gets the model's answer and relevant sources section, repacing the heading of the answer section with:
     # :bulb: Auto-generated documentation-based answer:
     """
     For example: The following input:
 
     ### Question: \nThe following general issue was asked by a user: Title: How does one request to re-review a PR? More Info: I cannot seem to find to do this.
     ### Answer:\nAccording to the documentation, one needs to invoke the command: /review
     #### Relevant Sources...
 
     Should become:
 
     ### :bulb: Auto-generated documentation-based answer:\n
     According to the documentation, one needs to invoke the command: /review
     #### Relevant Sources...
     """
-    model_answer_and_relevant_sections_in_response \
-        = extract_model_answer_and_relevant_sources(ai_response)
-    if model_answer_and_relevant_sections_in_response is not None:
-        cleaned_question_with_answer = "### :bulb: Auto-generated documentation-based answer:\n"
-        cleaned_question_with_answer += model_answer_and_relevant_sections_in_response
-        return cleaned_question_with_answer
+    model_answer_section = extract_model_answer_and_relevant_sources(ai_response)
+    if model_answer_section is not None:
+        # Extract the relevant sources section from the original response
+        if "#### Relevant Sources:\n\n" in ai_response:
+            relevant_sources = "#### Relevant Sources:\n\n" + ai_response.split("#### Relevant Sources:\n\n")[1]
+            cleaned_question_with_answer = "### :bulb: Auto-generated documentation-based answer:\n"
+            cleaned_question_with_answer += model_answer_section + relevant_sources
+            return cleaned_question_with_answer
+        else:
+            cleaned_question_with_answer = "### :bulb: Auto-generated documentation-based answer:\n"
+            cleaned_question_with_answer += model_answer_section
+            return cleaned_question_with_answer
     get_logger().warning(f"Either no answer section found, or that section is malformed: {ai_response}")
     return None

 def get_canonical_url_parts(self, repo_git_url:str, desired_branch:str) -> Tuple[str, str]:
     owner = None
     repo = None
     scheme_and_netloc = None
 
     if repo_git_url: #If user provided an external git url, which may be different than what this provider was initialized with, we cannot use self.repo
         repo_path = self._get_owner_and_repo_path(repo_git_url)
         parsed_git_url = urlparse(repo_git_url)
         scheme_and_netloc = parsed_git_url.scheme + "://" + parsed_git_url.netloc
         if repo_path.count('/') == 1: #Has to have the form <owner>/<repo>
             owner, repo = repo_path.split('/')
         else:
             get_logger().error(f"Invalid repo_path: {repo_path} from repo_git_url: {repo_git_url}")
             return ("", "")
     if (not owner or not repo) and self.repo: #"else" - User did not provide an external git url, use self.repo object:
         owner, repo = self.repo.split('/')
         scheme_and_netloc = self.base_url_html
         desired_branch = self.get_pr_branch()
-    if not any([scheme_and_netloc, owner, repo]): #"else": Not invoked from a PR context,but no provided git url for context
+    if not all([scheme_and_netloc, owner, repo]): #"else": Not invoked from a PR context,but no provided git url for context
         get_logger().error(f"Unable to get canonical url parts since missing context (PR or explicit git url)")
         return ("", "")
 
     prefix = f"{scheme_and_netloc}/{owner}/{repo}/blob/{desired_branch}"
     suffix = ""  # github does not add a suffix
     return (prefix, suffix)

-class relevant_section(BaseModel):
+class RelevantSection(BaseModel):
     file_name: str = Field(description="The name of the relevant file")
     relevant_section_header_string: str = Field(description="The exact text of the relevant markdown/restructured text section heading from the relevant file  (starting with '#', '##', etc.). Return empty string if the entire file is the relevant section, or if the relevant section has no heading")

-- file_name: "src/file1.py"
+- file_name: "docs/getting-started.md"

-if str(section['relevant_section_header_string']).strip():
-    markdown_header = format_markdown_header(section['relevant_section_header_string'])
+if str(section.get('relevant_section_header_string', '')).strip():
+    markdown_header = format_markdown_header(section.get('relevant_section_header_string', ''))
     if base_url_prefix:
         answer_str += f"> - {base_url_prefix}{file}{base_url_suffix}#{markdown_header}\n"