chatterer 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

chatterer/tools/citation_chunking/prompt.py

@@ -0,0 +1,157 @@
+"""
+ragent/prompt/citation_chunking.py
+
+This module defines prompt constants for citation chunking.
+The LLM is expected to return JSON objects that include only the text snippets for the beginning and end of the citation span.
+The character indices will be computed in a post‐processing step.
+"""
+
+from functools import cache
+
+
+@cache
+def generate_instruction() -> str:
+    from .chunks import CitationChunk, CitationChunks
+    from .reference import (
+        MultiMatchRegex,
+        SingleMatchCitation,
+    )
+
+    return (
+        "You are an AI specialized in 'citation-based text chunking'.\n"
+        "Given a document, perform the following steps:\n"
+        "1) Identify the major topics in the document.\n"
+        "2) For each topic, provide a list of citation objects indicating the text snippets at the beginning and end of the relevant paragraph(s) for that topic.\n\n"
+        "Important:\n"
+        "- Return citation objects with 'start_text' and 'end_text' fields to precisely capture the text span. Do NOT include character indices.\n"
+        "- If a regular expression based matching is more appropriate for a topic (e.g. for multiple matches), you may include a regex object of type 'multi_match_regex'.\n\n"
+        "Return JSON strictly in the following format:\n"
+        "{json_example}\n\n"
+        "1) Return only valid JSON (no extra keys).\n"
+        "2) Do NOT include any commentary.\n"
+        "3) Ensure that the citations capture the entire relevant paragraph without overlap or omission."
+    ).format(
+        json_example=CitationChunks(
+            citation_chunks=[
+                CitationChunk(
+                    subject="Quantum Advantage",
+                    references=[
+                        SingleMatchCitation(
+                            start_from="Starting snippet...",
+                            end_at="... Ending snippet",
+                        ),
+                        MultiMatchRegex(
+                            type="multi_match_regex",
+                            regular_expression="Some.*?regex.*?pattern",
+                        ),
+                    ],
+                ),
+            ]
+        ).model_dump_json(indent=2)
+    )
+
+
+@cache
+def generate_human_assistant_fewshot_examples() -> list[tuple[str, str]]:
+    from .chunks import CitationChunk, CitationChunks
+    from .reference import SingleMatchCitation
+
+    return [
+        (
+            "Agent-Semantic Chunking of the following text:\n\n"
+            "Title: Revolutionary Breakthrough in Quantum Computing\n\n"
+            "In a landmark development, researchers at the National Quantum Laboratory unveiled a quantum computer "
+            "that demonstrates clear quantum advantage by performing computations that are infeasible on classical systems.\n\n"
+            "The breakthrough is the result of years of rigorous research and international collaboration. "
+            "The system leverages entanglement and superposition to process complex algorithms at unprecedented speeds.\n\n"
+            "However, practical applications are still emerging, and experts caution about scalability challenges. "
+            "Meanwhile, several tech giants are expressing keen interest in integrating quantum technology into future products.\n\n"
+            "Please classify the major topics and return the exact text snippets (for the start and end of the relevant paragraphs) for each topic.",
+            CitationChunks(
+                citation_chunks=[
+                    CitationChunk(
+                        subject="Quantum Advantage",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="In a landmark development",
+                                end_at="on classical systems.",
+                            ),
+                        ],
+                    ),
+                    CitationChunk(
+                        subject="Research Collaboration",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="The breakthrough is the result",
+                                end_at="unprecedented speeds.",
+                            ),
+                        ],
+                    ),
+                    CitationChunk(
+                        subject="Practical Challenges",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="However, practical applications",
+                                end_at="scalability challenges.",
+                            ),
+                        ],
+                    ),
+                    CitationChunk(
+                        subject="Industry Interest",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="Meanwhile, several tech giants",
+                                end_at="future products.",
+                            ),
+                        ],
+                    ),
+                ]
+            ).model_dump_json(indent=2),
+        ),
+        (
+            "Agent-Semantic Chunking of the following text:\n\n"
+            "Title: Rising Seas and Coastal Erosion: A Global Crisis\n\n"
+            "Communities worldwide face the impacts of climate change as rising sea levels lead to accelerated coastal erosion, "
+            "jeopardizing homes and critical infrastructure.\n\n"
+            'In a small coastal town, residents noted that "the encroaching sea" has already begun to claim beachfront properties, '
+            "prompting local authorities to implement emergency measures.\n\n"
+            "Environmental experts warn that without significant intervention, the frequency and severity of these events will increase, "
+            "further exacerbating the global climate crisis.\n\n"
+            "Please classify the major topics and return the exact text snippets (for the start and end of the relevant paragraphs) for each topic.",
+            CitationChunks(
+                citation_chunks=[
+                    CitationChunk(
+                        subject="Coastal Erosion Impact",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="Communities worldwide face the impacts",
+                                end_at="critical infrastructure.",
+                            ),
+                        ],
+                    ),
+                    CitationChunk(
+                        subject="Local Emergency Response",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="In a small coastal town",
+                                end_at="emergency measures.",
+                            ),
+                        ],
+                    ),
+                    CitationChunk(
+                        subject="Expert Warning",
+                        references=[
+                            SingleMatchCitation(
+                                start_from="Environmental experts warn",
+                                end_at="global climate crisis.",
+                            ),
+                        ],
+                    ),
+                ]
+            ).model_dump_json(indent=2),
+        ),
+    ]
+
+
+def generate_fewshot_affirmative_response() -> str:
+    return "Great! I will now perform the citation-based chunking. Please provide the document to process!"

chatterer/tools/citation_chunking/reference.py

@@ -0,0 +1,26 @@
+from typing import Literal, TypeAlias
+
+from pydantic import BaseModel, Field
+
+
+class MultiMatchRegex(BaseModel):
+    type: Literal["multi_match_regex"] = Field(
+        description="A regex pattern that should match multiple instances of the subject in the document."
+    )
+    regular_expression: str = Field(
+        description="The regex pattern that should match multiple instances of the subject in the document."
+    )
+
+    def __hash__(self) -> int:
+        return hash((self.type, self.regular_expression))
+
+
+class SingleMatchCitation(BaseModel):
+    start_from: str = Field(description="A snippet of text at the beginning of the cited section.")
+    end_at: str = Field(description="A snippet of text at the end of the cited section.")
+
+    def __hash__(self) -> int:
+        return hash((self.start_from, self.end_at))
+
+
+Reference: TypeAlias = SingleMatchCitation | MultiMatchRegex

chatterer/tools/citation_chunking/utils.py

@@ -0,0 +1,138 @@
+from typing import Callable, NamedTuple, Self, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class MatchedText(NamedTuple):
+    text: str
+    start_idx: int
+    end_idx: int
+
+    @classmethod
+    def from_text(
+        cls,
+        full_text: str,
+        len_func: Callable[[str], int],
+        chunk_size: int = 2048,
+        token_overlap: int = 0,
+        separator: str = "\n",
+    ) -> list[Self]:
+        """
+        토큰 수 제한과 선택적 오버랩을 기준으로 텍스트를 청크로 분할합니다.
+        각 청크는 원본 텍스트 내의 위치 정보 (start_idx, end_idx)와 함께 반환됩니다.
+        텍스트는 separator 문자열로 분할하며, 토큰 수는 len_func 함수를 통해 계산합니다.
+
+        Args:
+            full_text: 분할할 전체 텍스트.
+            len_func: 주어진 텍스트의 토큰 수를 반환하는 함수.
+            chunk_size: 각 청크의 최대 토큰 수. 기본값은 2048.
+            token_overlap: 청크 간 중첩할 토큰 수. 기본값은 0.
+            separator: 텍스트를 분할할 구분자 문자열. 기본값은 "\n".
+
+        Returns:
+            각 요소가 (chunk_text, start_idx, end_idx)인 튜플의 리스트.
+            chunk_text는 whole_text 내에서 whole_text[start_idx:end_idx]와 동일한 부분 문자열입니다.
+        """
+        text_chunks: list[Self] = []
+        sep_token_count: int = len_func(separator)
+        sep_len = len(separator)
+
+        # 먼저, separator를 기준으로 원본 텍스트를 분할하되 각 조각의 시작/종료 인덱스를 기록합니다.
+        piece_infos: list[Self] = []  # 각 튜플: (piece_text, start_index, end_index)
+        start_idx = 0
+        while True:
+            idx = full_text.find(separator, start_idx)
+            if idx == -1:
+                # 마지막 조각: separator가 더 이상 없으므로 전체 남은 부분을 추가합니다.
+                piece_infos.append(
+                    cls(
+                        text=full_text[start_idx:],
+                        start_idx=start_idx,
+                        end_idx=len(full_text),
+                    )
+                )
+                break
+            else:
+                piece_infos.append(
+                    cls(
+                        text=full_text[start_idx:idx],
+                        start_idx=start_idx,
+                        end_idx=idx,
+                    )
+                )
+                start_idx = idx + sep_len
+
+        current_chunk: list[Self] = []
+        current_token_count: int = 0
+        i = 0
+        while i < len(piece_infos):
+            piece_info = piece_infos[i]
+            piece = piece_info.text
+            piece_start = piece_info.start_idx
+            piece_end = piece_info.end_idx
+            # 원래 코드는 각 조각에 separator의 토큰 수도 포함합니다.
+            piece_token_count: int = len_func(piece) + sep_token_count
+
+            # 현재 청크에 추가하면 chunk_size를 초과하는 경우
+            if current_token_count + piece_token_count > chunk_size:
+                # 단일 조각이 chunk_size보다 큰 경우엔 어쩔 수 없이 추가합니다.
+                if not current_chunk:
+                    current_chunk.append(
+                        cls(
+                            text=piece,
+                            start_idx=piece_start,
+                            end_idx=piece_end,
+                        )
+                    )
+                    current_token_count += piece_token_count
+                    i += 1
+                # 현재 청크 완성 → 청크에 추가
+                chunk_start = current_chunk[0].start_idx
+                # current_chunk에 담긴 조각들은 원본 텍스트상 연속되어 있으므로,
+                # 청크의 종료 인덱스는 마지막 조각의 end_index가 됩니다.
+                chunk_end = current_chunk[-1].end_idx
+                # 원본 텍스트의 해당 구간을 그대로 추출하면 separator가 포함됩니다.
+                chunk_text = full_text[chunk_start:chunk_end]
+                text_chunks.append(
+                    cls(
+                        text=chunk_text,
+                        start_idx=chunk_start,
+                        end_idx=chunk_end,
+                    )
+                )
+
+                # token_overlap이 적용되는 경우: 청크 끝부분 일부를 다음 청크에 오버랩합니다.
+                if token_overlap > 0:
+                    overlap_chunk: list[Self] = []
+                    overlap_count: int = 0
+                    # 뒤에서부터 역순으로 오버랩할 조각들을 선택합니다.
+                    for j in range(len(current_chunk) - 1, -1, -1):
+                        p_text = current_chunk[j].text
+                        p_token_count = len_func(p_text) + sep_token_count
+                        # 최소 한 조각은 포함하고, 오버랩 토큰 수가 token_overlap 이하라면 계속 추가
+                        if overlap_count + p_token_count <= token_overlap or not overlap_chunk:
+                            overlap_chunk.insert(0, current_chunk[j])
+                            overlap_count += p_token_count
+                        else:
+                            break
+                    current_chunk = overlap_chunk.copy()
+                    current_token_count = overlap_count
+                else:
+                    current_chunk.clear()
+                    current_token_count = 0
+            else:
+                # 청크에 추가 후 다음 조각 진행
+                current_chunk.append(cls(text=piece, start_idx=piece_start, end_idx=piece_end))
+                current_token_count += piece_token_count
+                i += 1
+
+        # 남은 조각이 있다면 마지막 청크로 추가합니다.
+        if current_chunk:
+            chunk_start = current_chunk[0].start_idx
+            chunk_end = current_chunk[-1].end_idx
+            chunk_text = full_text[chunk_start:chunk_end]
+            text_chunks.append(cls(text=chunk_text, start_idx=chunk_start, end_idx=chunk_end))
+
+        return text_chunks

chatterer/tools/convert_to_text.py

@@ -57,10 +57,11 @@ PathOrReadable: TypeAlias = FileDescriptorOrPath | Readable
 class HtmlToMarkdownOptions(TypedDict):
     """
     TypedDict for options used in HTML to Markdown conversion.
-    
+
     Contains various configuration options for controlling how HTML is converted to Markdown,
     including formatting preferences, escape behaviors, and styling options.
     """
+
     autolinks: NotRequired[bool]
     bullets: NotRequired[str]
     code_language: NotRequired[str]
@@ -86,10 +87,10 @@ class HtmlToMarkdownOptions(TypedDict):
 def get_default_html_to_markdown_options() -> HtmlToMarkdownOptions:
     """
     Returns the default options for HTML to Markdown conversion.
-    
+
     This function provides a set of sensible defaults for the markdownify library,
     including settings for bullets, escaping, heading styles, and other formatting options.
-    
+
     Returns:
         HtmlToMarkdownOptions: A dictionary of default conversion options.
     """
@@ -124,10 +125,11 @@ def get_default_html_to_markdown_options() -> HtmlToMarkdownOptions:
 class CodeSnippets(NamedTuple):
     """
     A named tuple that represents code snippets extracted from Python files.
-    
+
     Contains the paths to the files, the concatenated text of all snippets,
     and the base directory of the files.
     """
+
     paths: list[Path]
     snippets_text: str
     base_dir: Path
@@ -136,11 +138,11 @@ class CodeSnippets(NamedTuple):
     def from_path_or_pkgname(cls, path_or_pkgname: str, ban_file_patterns: Optional[list[str]] = None) -> Self:
         """
         Creates a CodeSnippets instance from a file path or package name.
-        
+
         Args:
             path_or_pkgname: Path to a file/directory or a Python package name.
             ban_file_patterns: Optional list of patterns to exclude files.
-            
+
         Returns:
             A new CodeSnippets instance with extracted code snippets.
         """
@@ -156,10 +158,10 @@ class CodeSnippets(NamedTuple):
     def metadata(self) -> str:
         """
         Generates metadata about the code snippets.
-        
+
         Returns a string containing information about the file tree structure,
         total number of files, tokens (if tiktoken is available), and lines.
-        
+
         Returns:
             str: Formatted metadata string.
         """
@@ -182,7 +184,7 @@ class CodeSnippets(NamedTuple):
         def _display_tree(tree: FileTree, prefix: str = "") -> None:
             """
             Helper function to recursively display a file tree structure.
-            
+
             Args:
                 tree: The file tree dictionary to display.
                 prefix: Current line prefix for proper indentation.
@@ -224,15 +226,15 @@ def html_to_markdown(html: str, options: Optional[HtmlToMarkdownOptions]) -> str
 def pdf_to_text(path_or_file: PathOrReadable) -> str:
     """
     Convert a PDF file to plain text.
-    
+
     Extracts text from each page of a PDF file and formats it with page markers.
-    
+
     Args:
         path_or_file: Path to a PDF file or a readable object containing PDF data.
-        
+
     Returns:
         str: Extracted text with page markers.
-        
+
     Raises:
         FileNotFoundError: If the file cannot be found or opened.
     """
@@ -264,10 +266,10 @@ def anything_to_markdown(
 ) -> str:
     """
     Convert various types of content to Markdown format.
-    
+
     Uses the MarkItDown library to convert different types of content (URLs, files, API responses)
     to Markdown format.
-    
+
     Args:
         source: The source content to convert (URL string, Response object, or Path).
         requests_session: Optional requests Session for HTTP requests.
@@ -276,7 +278,7 @@ def anything_to_markdown(
         style_map: Optional style mapping configuration.
         exiftool_path: Optional path to exiftool for metadata extraction.
         docintel_endpoint: Optional Document Intelligence API endpoint.
-        
+
     Returns:
         str: The converted Markdown content.
     """
@@ -300,13 +302,13 @@ pyscripts_to_snippets = CodeSnippets.from_path_or_pkgname
 def _pattern_to_regex(pattern: str) -> re.Pattern[str]:
     """
     Converts an fnmatch pattern to a regular expression.
-    
+
     In this function, '**' is converted to match any character including directory separators.
     The remaining '*' matches any character except directory separators, and '?' matches a single character.
-    
+
     Args:
         pattern: The fnmatch pattern to convert.
-        
+
     Returns:
         A compiled regular expression pattern.
     """
@@ -326,16 +328,16 @@ def _pattern_to_regex(pattern: str) -> re.Pattern[str]:
 def _is_banned(p: Path, ban_patterns: list[str]) -> bool:
     """
     Checks if a given path matches any of the ban patterns.
-    
-    Determines if the path p matches any pattern in ban_patterns using either 
+
+    Determines if the path p matches any pattern in ban_patterns using either
     fnmatch-based or recursive patterns (i.e., containing '**').
-    
+
     Note: Patterns should use POSIX-style paths (i.e., '/' separators).
-    
+
     Args:
         p: The path to check.
         ban_patterns: List of patterns to match against.
-        
+
     Returns:
         bool: True if the path matches any ban pattern, False otherwise.
     """
@@ -355,13 +357,13 @@ def _is_banned(p: Path, ban_patterns: list[str]) -> bool:
 def _get_a_snippet(fpath: Path) -> str:
     """
     Extracts a code snippet from a Python file.
-    
+
     Reads the file, parses it as Python code, and returns a formatted code snippet
     with the relative path as a header in markdown code block format.
-    
+
     Args:
         fpath: Path to the Python file.
-        
+
     Returns:
         str: Formatted code snippet or empty string if the file doesn't exist.
     """
@@ -386,33 +388,30 @@ def _get_a_snippet(fpath: Path) -> str:
 def _get_base_dir(target_files: Sequence[Path]) -> Path:
     """
     Determines the common base directory for a sequence of file paths.
-    
+
     Finds the directory with the shortest path that is a parent to at least one file.
-    
+
     Args:
         target_files: Sequence of file paths.
-        
+
     Returns:
         Path: The common base directory.
     """
-    return sorted(
-        {file_path.parent for file_path in target_files},
-        key=lambda p: len(p.parts),
-    )[0]
+    return Path(os.path.commonpath(target_files))
 
 
 def _get_pyscript_paths(path_or_pkgname: str, ban_fn_patterns: Optional[list[str]] = None) -> list[Path]:
     """
     Gets paths to Python script files from a directory, file, or package name.
-    
+
     If path_or_pkgname is a directory, finds all .py files recursively.
     If it's a file, returns just that file.
     If it's a package name, imports the package and finds all .py files in its directory.
-    
+
     Args:
         path_or_pkgname: Path to directory/file or package name.
         ban_fn_patterns: Optional list of patterns to exclude files.
-        
+
     Returns:
         list[Path]: List of paths to Python files.
     """
@@ -430,7 +429,7 @@ def _get_pyscript_paths(path_or_pkgname: str, ban_fn_patterns: Optional[list[str
             )
             if p.is_file()
         ]
-    return [p for p in pypaths if ban_fn_patterns and not _is_banned(p, ban_fn_patterns)]
+    return [p for p in pypaths if not ban_fn_patterns or not _is_banned(p, ban_fn_patterns)]
 
 
 @contextmanager
@@ -439,13 +438,13 @@ def _open_stream(
 ) -> Iterator[Optional[BytesReadable]]:
     """
     Context manager for opening a file or using an existing stream.
-    
+
     Handles different types of input (file paths, byte streams, string streams)
     and yields a BytesReadable object that can be used to read binary data.
-    
+
     Args:
         path_or_file: File path or readable object.
-        
+
     Yields:
         Optional[BytesReadable]: A readable binary stream or None if opening fails.
     """

chatterer/tools/webpage_to_markdown/playwright_bot.py

@@ -30,6 +30,7 @@ import playwright.async_api
 import playwright.sync_api
 
 from ...language_model import DEFAULT_IMAGE_DESCRIPTION_INSTRUCTION, Chatterer
+from ...utils.image import Base64Image, get_default_image_processing_config
 from ..convert_to_text import HtmlToMarkdownOptions, get_default_html_to_markdown_options, html_to_markdown
 from .utils import (
     DEFAULT_UA,
@@ -41,7 +42,6 @@ from .utils import (
     SelectedLineRanges,
     WaitUntil,
     aget_image_url_and_markdown_links,
-    get_default_image_processing_config,
     get_default_playwright_launch_options,
     get_image_url_and_markdown_links,
     replace_images,
@@ -392,6 +392,8 @@ Markdown-formatted webpage content is provided below for your reference:
         timeout: Union[float, int] = 8,
         keep_page: bool = False,
         referer: Optional[str] = None,
+        describe_images: bool = True,
+        filter: bool = True,
     ) -> str:
         """
         Convert a URL's page to Markdown and use a language model (Chatterer) to filter out unimportant lines.
@@ -409,6 +411,8 @@ Markdown-formatted webpage content is provided below for your reference:
             timeout (float | int): Navigation timeout (in seconds).
             keep_page (bool): If True, do not close the page after processing.
             referer (Optional[str]): Referer URL to set.
+            describe_images (bool): If True, describe images in the Markdown text.
+            filter (bool): If True, filter the important lines using the language model.
 
         Returns:
             str: Filtered Markdown containing only the important lines.
@@ -423,7 +427,10 @@ Markdown-formatted webpage content is provided below for your reference:
             keep_page=keep_page,
             referer=referer,
         )
-        markdown_content = self.describe_images(markdown_text=markdown_content, referer_url=url)
+        if describe_images:
+            markdown_content = self.describe_images(markdown_text=markdown_content, referer_url=url)
+        if not filter:
+            return markdown_content
         lines = markdown_content.split("\n")
         line_length = len(lines)
         important_lines: set[int] = set()
@@ -465,6 +472,8 @@ Markdown-formatted webpage content is provided below for your reference:
         timeout: Union[float, int] = 8,
         keep_page: bool = False,
         referer: Optional[str] = None,
+        describe_images: bool = True,
+        filter: bool = True,
     ) -> str:
         """
         Asynchronously convert a URL's page to Markdown and use the language model (Chatterer)
@@ -483,6 +492,8 @@ Markdown-formatted webpage content is provided below for your reference:
             timeout (float | int): Navigation timeout (in seconds).
             keep_page (bool): If True, do not close the page after processing.
             referer (Optional[str]): Referer URL to set.
+            describe_images (bool): If True, describe images in the Markdown text.
+            filter (bool): If True, filter the important lines using the language model.
 
         Returns:
             str: Filtered Markdown containing only the important lines.
@@ -497,7 +508,10 @@ Markdown-formatted webpage content is provided below for your reference:
             keep_page=keep_page,
             referer=referer,
         )
-        markdown_content = await self.adescribe_images(markdown_text=markdown_content, referer_url=url)
+        if describe_images:
+            markdown_content = await self.adescribe_images(markdown_text=markdown_content, referer_url=url)
+        if not filter:
+            return markdown_content
         lines = markdown_content.split("\n")
         line_length = len(lines)
         important_lines: set[int] = set()
@@ -529,10 +543,12 @@ Markdown-formatted webpage content is provided below for your reference:
         """
         Replace image URLs in Markdown text with their alt text and generate descriptions using a language model.
         """
-        image_url_and_markdown_links: dict[Optional[str], list[MarkdownLink]] = get_image_url_and_markdown_links(
-            markdown_text=markdown_text,
-            headers=self.headers | {"Referer": referer_url},
-            config=self.image_processing_config,
+        image_url_and_markdown_links: dict[Optional[Base64Image], list[MarkdownLink]] = (
+            get_image_url_and_markdown_links(
+                markdown_text=markdown_text,
+                headers=self.headers | {"Referer": referer_url},
+                config=self.image_processing_config,
+            )
         )
 
         image_description_and_references: ImageDescriptionAndReferences = ImageDescriptionAndReferences({})
@@ -540,7 +556,7 @@ Markdown-formatted webpage content is provided below for your reference:
             if image_url is not None:
                 try:
                     image_summary: str = self.chatterer.describe_image(
-                        image_url=image_url,
+                        image_url=image_url.data_uri,
                         instruction=self.image_description_instruction,
                     )
                 except Exception:
@@ -560,7 +576,9 @@ Markdown-formatted webpage content is provided below for your reference:
         """
         Replace image URLs in Markdown text with their alt text and generate descriptions using a language model.
         """
-        image_url_and_markdown_links: dict[Optional[str], list[MarkdownLink]] = await aget_image_url_and_markdown_links(
+        image_url_and_markdown_links: dict[
+            Optional[Base64Image], list[MarkdownLink]
+        ] = await aget_image_url_and_markdown_links(
             markdown_text=markdown_text,
             headers=self.headers | {"Referer": referer_url},
             config=self.image_processing_config,
@@ -576,7 +594,7 @@ Markdown-formatted webpage content is provided below for your reference:
             return True
 
         coros: list[Awaitable[Optional[str]]] = [
-            self.chatterer.adescribe_image(image_url=image_url, instruction=self.image_description_instruction)
+            self.chatterer.adescribe_image(image_url=image_url.data_uri, instruction=self.image_description_instruction)
             if image_url is not None
             else dummy()
             for image_url in image_url_and_markdown_links.keys()