haystack-ai 3.2.0rc1__tar.gz → 3.3.0__tar.gz

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: haystack-ai
-Version: 3.2.0-rc1
+Version: 3.3.0
 Summary: LLM framework to build customizable, production-ready LLM applications. Connect components (models, vector DBs, file converters) to pipelines or agents that can interact with your data.
 Project-URL: CI: GitHub, https://github.com/deepset-ai/haystack/actions
 Project-URL: Docs: RTD, https://haystack.deepset.ai/overview/intro
@@ -25,6 +25,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
+Requires-Dist: anyio>=4.14.2
 Requires-Dist: docstring-parser
 Requires-Dist: filetype
 Requires-Dist: httpx
@@ -56,16 +57,6 @@ Description-Content-Type: text/markdown
 | Meta    | [![Discord](https://img.shields.io/discord/993534733298450452?logo=discord)](https://discord.com/invite/qZxjM4bAHU) [![Twitter Follow](https://img.shields.io/twitter/follow/haystack_ai)](https://twitter.com/haystack_ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 </div>
 
-<div align="center">
-
-# 🎉🎊✨ &nbsp; Haystack 3.0 is out! &nbsp; ✨🎊🎉
-
-### Read the announcement [here](https://haystack.deepset.ai/blog/haystack-3-release)!
-
-## 🥳 🎈 🎆 🪅 🎇 🍾 🥂 🎁 🌈
-
-</div>
-
 [Haystack](https://haystack.deepset.ai/) is an open-source AI orchestration framework for building production-ready LLM applications in Python.
 
 Design modular pipelines and agent workflows with explicit control over retrieval, routing, memory, and generation. Build scalable RAG systems, multimodal applications, semantic search, question answering, and autonomous agents, all in a transparent architecture that lets you experiment, customize deeply, and deploy with confidence.

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/README.md

@@ -9,16 +9,6 @@
 | Meta    | [![Discord](https://img.shields.io/discord/993534733298450452?logo=discord)](https://discord.com/invite/qZxjM4bAHU) [![Twitter Follow](https://img.shields.io/twitter/follow/haystack_ai)](https://twitter.com/haystack_ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 </div>
 
-<div align="center">
-
-# 🎉🎊✨ &nbsp; Haystack 3.0 is out! &nbsp; ✨🎊🎉
-
-### Read the announcement [here](https://haystack.deepset.ai/blog/haystack-3-release)!
-
-## 🥳 🎈 🎆 🪅 🎇 🍾 🥂 🎁 🌈
-
-</div>
-
 [Haystack](https://haystack.deepset.ai/) is an open-source AI orchestration framework for building production-ready LLM applications in Python.
 
 Design modular pipelines and agent workflows with explicit control over retrieval, routing, memory, and generation. Build scalable RAG systems, multimodal applications, semantic search, question answering, and autonomous agents, all in a transparent architecture that lets you experiment, customize deeply, and deploy with confidence.

haystack_ai-3.3.0/VERSION.txt

@@ -0,0 +1 @@
+3.3.0

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/agents/agent.py

@@ -866,9 +866,10 @@ class Agent:
             - "exit_reason": Why the Agent stopped, useful for routing the output downstream (e.g. with a
               `ConditionalRouter`). One of: `"text"` (the model returned a complete reply with no tool calls),
               `"length"` or `"content_filter"` (the model returned an incomplete reply, which may contain partial
-              text), the name of the tool that satisfied a tool exit condition (in which case `last_message` is that
-              tool's result), or `"max_agent_steps"` (the Agent hit `max_agent_steps` before meeting an exit
-              condition), or a custom reason a hook supplied through the `stop_run` state key.
+              text), the name of the tool that satisfied a tool exit condition (its result is the last tool message in
+              `messages` whose `tool_call_result.origin.tool_name` matches it, which may not be `last_message` when
+              the model called several tools at once), or `"max_agent_steps"` (the Agent hit `max_agent_steps` before
+              meeting an exit condition), or a custom reason a hook supplied through the `stop_run` state key.
             - Any additional keys defined in the `state_schema`.
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}
@@ -952,9 +953,10 @@ class Agent:
             - "exit_reason": Why the Agent stopped, useful for routing the output downstream (e.g. with a
               `ConditionalRouter`). One of: `"text"` (the model returned a complete reply with no tool calls),
               `"length"` or `"content_filter"` (the model returned an incomplete reply, which may contain partial
-              text), the name of the tool that satisfied a tool exit condition (in which case `last_message` is that
-              tool's result), or `"max_agent_steps"` (the Agent hit `max_agent_steps` before meeting an exit
-              condition), or a custom reason a hook supplied through the `stop_run` state key.
+              text), the name of the tool that satisfied a tool exit condition (its result is the last tool message in
+              `messages` whose `tool_call_result.origin.tool_name` matches it, which may not be `last_message` when
+              the model called several tools at once), or `"max_agent_steps"` (the Agent hit `max_agent_steps` before
+              meeting an exit condition), or a custom reason a hook supplied through the `stop_run` state key.
             - Any additional keys defined in the `state_schema`.
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/agents/tool_calling.py

@@ -449,8 +449,9 @@ def _schedule_tool_calls(tool_calls: list[ToolCall], tools: list[Tool]) -> list[
     once — cannot be ordered by the read-after-write rule alone, so they are broken deterministically by call order
     (the lowest-index remaining call runs next, on its own).
 
-    Pure write-write overlaps create no dependency: nobody reads the contended key, and outputs are merged into State
-    sequentially in call order afterward, so the result stays deterministic without serializing execution.
+    Write-write overlaps alone create no dependency. Outputs are merged into State after each batch, in the
+    LLM's requested order within that batch, so subsequent batches see the updated values. This keeps merging
+    deterministic, but does not guarantee that writes follow the LLM's requested order across batches.
 
     :param tool_calls: The tool calls to schedule, in call order.
     :param tools: The resolved Tool for each entry in `tool_calls` (parallel list).
@@ -498,8 +499,7 @@ def _finalize_tool_result(
     Turn a single tool invocation result into a tool-result ChatMessage, merging outputs into State.
 
     On a `ToolInvocationError`, either re-raise (when `raise_on_failure`) or return an error message. Otherwise
-    merge the tool's outputs into State (in call order, so write-write merges stay deterministic) and build the
-    result message.
+    merge the tool's outputs into State and build the result message.
     """
     if isinstance(result, ToolInvocationError):
         if raise_on_failure:

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/builders/chat_prompt_builder.py

@@ -176,12 +176,13 @@ class ChatPromptBuilder:
                         # infer variables from template
                         if message.text is None:
                             raise ValueError(NO_TEXT_ERROR_MESSAGE.format(role=message.role.value, message=message))
-                        if message.text and "templatize_part" in message.text:
-                            raise ValueError(FILTER_NOT_ALLOWED_ERROR_MESSAGE)
-                        assigned_variables, template_variables = _extract_template_variables_and_assignments(
-                            env=self._env, template=message.text
-                        )
-                        extracted_variables += list(template_variables - assigned_variables)
+                        for text in message.texts:
+                            if "templatize_part" in text:
+                                raise ValueError(FILTER_NOT_ALLOWED_ERROR_MESSAGE)
+                            assigned_variables, template_variables = _extract_template_variables_and_assignments(
+                                env=self._env, template=text
+                            )
+                            extracted_variables += list(template_variables - assigned_variables)
             elif isinstance(template, str):
                 assigned_variables, template_variables = _extract_template_variables_and_assignments(
                     env=self._env, template=template
@@ -263,12 +264,15 @@ class ChatPromptBuilder:
                     self._validate_variables(set(template_variables_combined.keys()))
                     if message.text is None:
                         raise ValueError(NO_TEXT_ERROR_MESSAGE.format(role=message.role.value, message=message))
-                    if message.text and "templatize_part" in message.text:
-                        raise ValueError(FILTER_NOT_ALLOWED_ERROR_MESSAGE)
-                    compiled_template = self._env.from_string(message.text)
-                    rendered_text = compiled_template.render(template_variables_combined)
+                    rendered_content = list(message._content)
+                    for index, part in enumerate(rendered_content):
+                        if isinstance(part, TextContent):
+                            if "templatize_part" in part.text:
+                                raise ValueError(FILTER_NOT_ALLOWED_ERROR_MESSAGE)
+                            rendered_text = self._env.from_string(part.text).render(template_variables_combined)
+                            rendered_content[index] = TextContent(text=rendered_text)
                     # use dataclasses.replace to avoid in-place mutation of the original message
-                    rendered_message: ChatMessage = replace(message, _content=[TextContent(text=rendered_text)])
+                    rendered_message: ChatMessage = replace(message, _content=rendered_content)
                     processed_messages.append(rendered_message)
                 else:
                     processed_messages.append(message)

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/converters/docx.py

@@ -5,6 +5,7 @@
 import csv
 import io
 import os
+import re
 from dataclasses import asdict, dataclass
 from enum import Enum
 from io import StringIO
@@ -18,10 +19,15 @@ from haystack.lazy_imports import LazyImport
 
 logger = logging.getLogger(__name__)
 
+# A Markdown table row ends at a line break and its columns are separated by pipes, so
+# neither can survive inside a cell.
+_MARKDOWN_CELL_BREAK_PATTERN = re.compile(r"\s*(?:\r\n|\r|\n)\s*")
+_MARKDOWN_CELL_PIPE_PATTERN = re.compile(r"(?<!\\)(\\*)\|")
+
 with LazyImport("Run 'pip install python-docx'") as docx_import:
     import docx
     from docx.document import Document as DocxDocument
-    from docx.table import Table
+    from docx.table import Table, _Cell
     from docx.text.hyperlink import Hyperlink
     from docx.text.paragraph import Paragraph
     from docx.text.run import Run
@@ -305,6 +311,31 @@ class DOCXToDocument:
 
         return text
 
+    @staticmethod
+    def _escape_markdown_cell(text: str) -> str:
+        """
+        Makes a cell's text safe to put between the pipes of a Markdown table row.
+
+        A cell spanning several paragraphs arrives with newlines in it, which would end
+        the row in the middle, and a pipe in a cell would be read as a column separator.
+
+        :param text: The cell text.
+        :returns: The text with line breaks collapsed and pipes escaped.
+        """
+        text = _MARKDOWN_CELL_BREAK_PATTERN.sub(" ", text)
+        # The backslash run in front of the pipe is doubled first, so a backslash the
+        # cell already contains cannot consume the escape.
+        return _MARKDOWN_CELL_PIPE_PATTERN.sub(lambda match: match.group(1) * 2 + r"\|", text)
+
+    def _cell_text(self, cell: "_Cell") -> str:
+        """
+        Returns a table cell's text with links formatted like links in body paragraphs.
+
+        :param cell: The DOCX table cell.
+        :returns: The cell's paragraphs joined by newlines, as `cell.text` joins them.
+        """
+        return "\n".join(self._process_links_in_paragraph(paragraph) for paragraph in cell.paragraphs)
+
     def _table_to_markdown(self, table: "Table") -> str:
         """
         Converts a DOCX table to a Markdown string.
@@ -315,10 +346,10 @@ class DOCXToDocument:
         markdown: list[str] = []
         max_col_widths: list[int] = []
 
-        # Calculate max width for each column
+        # Calculate max width for each column, on the escaped text that is written out
         for row in table.rows:
             for i, cell in enumerate(row.cells):
-                cell_text = cell.text.strip()
+                cell_text = self._escape_markdown_cell(self._cell_text(cell).strip())
                 if i >= len(max_col_widths):
                     max_col_widths.append(len(cell_text))
                 else:
@@ -326,7 +357,10 @@ class DOCXToDocument:
 
         # Process rows
         for i, row in enumerate(table.rows):
-            md_row = [cell.text.strip().ljust(max_col_widths[j]) for j, cell in enumerate(row.cells)]
+            md_row = [
+                self._escape_markdown_cell(self._cell_text(cell).strip()).ljust(max_col_widths[j])
+                for j, cell in enumerate(row.cells)
+            ]
             markdown.append("| " + " | ".join(md_row) + " |")
 
             # Add separator after header row
@@ -348,7 +382,7 @@ class DOCXToDocument:
 
         # Process rows
         for row in table.rows:
-            csv_row = [cell.text.strip() for cell in row.cells]
+            csv_row = [self._cell_text(cell).strip() for cell in row.cells]
             csv_writer.writerow(csv_row)
 
         # Get the CSV as a string and strip any trailing newlines

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/converters/image/document_to_image.py

@@ -114,8 +114,8 @@ class DocumentToImageContent:
             Dictionary containing one key:
             - "image_contents": ImageContents created from the processed documents. These contain base64-encoded image
                 data and metadata. The order corresponds to the order of the input documents. A document that is
-                missing the required metadata keys, has an invalid file path, or has an unsupported MIME type gets
-                None in its position and a logged warning with the reason.
+                missing the required metadata keys, has an invalid file path, has an unsupported MIME type, or points
+                to a PDF page that cannot be converted gets None in its position and a logged warning with the reason.
         """
         if not documents:
             return {"image_contents": []}

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/converters/image/image_utils.py

@@ -164,7 +164,11 @@ def _convert_pdf_to_images(
 
     for page_number in resolved_page_range:
         if page_number < 1 or page_number > num_pages:
-            logger.warning("Page {page_number} is out of range for the PDF file. Skipping it.", page_number=page_number)
+            logger.warning(
+                "Page {page_number} is out of range for the PDF file {file_path}. Skipping it.",
+                page_number=page_number,
+                file_path=bytestream.meta.get("file_path"),
+            )
             continue
 
         # Get dimensions of the page
@@ -312,7 +316,8 @@ def _batch_convert_pdf_pages_to_images(
     :param size: Optional tuple of width and height to resize the images to.
     :param return_base64: If True, return base64 encoded images instead of PIL images.
 
-    :returns: Dictionary mapping document indices to images (PIL.Image or base64 string).
+    :returns: Dictionary mapping document indices to images (PIL.Image or base64 string). Documents whose page could
+        not be converted are not included.
     """
     if not pdf_page_infos:
         return {}
@@ -325,16 +330,18 @@ def _batch_convert_pdf_pages_to_images(
 
     for pdf_path, page_infos_for_pdf in page_infos_by_pdf_path.items():
         page_numbers_to_convert = [info["page_number"] for info in page_infos_for_pdf]
-        bytestream = ByteStream.from_file_path(pdf_path)
+        bytestream = ByteStream.from_file_path(pdf_path, meta={"file_path": str(pdf_path)})
 
         converted_pages = _convert_pdf_to_images(
             bytestream=bytestream, return_base64=return_base64, page_range=page_numbers_to_convert, size=size
         )
 
-        # Map results back to document indices
+        # Map results back to document indices. Pages that could not be converted (out of range, or the PDF
+        # could not be read) are missing from the results, so their documents are left out.
         page_number_to_image = dict(converted_pages)
         for page_info in page_infos_for_pdf:
-            converted_images_by_doc_index[page_info["doc_idx"]] = page_number_to_image[page_info["page_number"]]
+            if page_info["page_number"] in page_number_to_image:
+                converted_images_by_doc_index[page_info["doc_idx"]] = page_number_to_image[page_info["page_number"]]
 
     # mypy is not able to infer that we match the declared return type
     return converted_images_by_doc_index  # type: ignore[return-value]

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/converters/json.py

@@ -238,6 +238,9 @@ class JSONConverter:
                     logger.warning("Expected a scalar value but got {obj}. Skipping it.", obj=obj)
                     continue
 
+                if text is not None and not isinstance(text, str):
+                    text = str(text)
+
                 meta = {}
                 if meta_fields == "*":
                     meta = {k: v for k, v in obj.items() if k != self._content_key}

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/converters/xlsx.py

@@ -234,6 +234,15 @@ class XLSXToDocument:
                     "missingval": "",
                     **self.table_format_kwargs,
                 }
+                if resolved_kwargs["tablefmt"] == "pipe":
+                    value = value.replace(
+                        {
+                            r"\r\n|\r|\n": " ",  # keep in-cell line breaks from creating extra Markdown rows
+                            r"(\\*)\|": r"\1\1\\|",  # escape pipes but preserve any preceding literal backslashes
+                        },
+                        regex=True,
+                    )
+
                 # to_markdown uses tabulate, whose missingval only covers None: a NaN
                 # reaches the formatter as a number and is written out as "nan". Replace
                 # the empty cells with None so an empty cell reads as empty, the way

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/embedders/mock_document_embedder.py

@@ -81,13 +81,13 @@ class MockDocumentEmbedder:
         :param meta_fields_to_embed: List of metadata fields to embed along with the document text.
         :param embedding_separator: Separator used to concatenate the metadata fields to the document text.
         :param progress_bar: Accepted for interface compatibility with real Document Embedders and ignored.
-        :raises ValueError: If both `embedding` and `embedding_fn` are provided, if `dimension` is not positive, or
-            if `embedding` is an empty list.
+        :raises ValueError: If both `embedding` and `embedding_fn` are provided, if `embedding` is an empty list,
+            or if neither is provided and `dimension` is not positive.
         :raises TypeError: If `embedding` is not a sequence of numbers.
         """
         if embedding is not None and embedding_fn is not None:
             raise ValueError("Pass either 'embedding' or 'embedding_fn', not both.")
-        if dimension <= 0:
+        if embedding is None and embedding_fn is None and dimension <= 0:
             raise ValueError("'dimension' must be a positive integer.")
 
         self.embedding = _coerce_embedding(embedding, name="'embedding'") if embedding is not None else None

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/embedders/mock_text_embedder.py

@@ -70,13 +70,13 @@ class MockTextEmbedder:
         :param meta: Additional metadata merged into the output `meta`.
         :param prefix: A string to add at the beginning of the text before embedding.
         :param suffix: A string to add at the end of the text before embedding.
-        :raises ValueError: If both `embedding` and `embedding_fn` are provided, if `dimension` is not positive, or
-            if `embedding` is an empty list.
+        :raises ValueError: If both `embedding` and `embedding_fn` are provided, if `embedding` is an empty list,
+            or if neither is provided and `dimension` is not positive.
         :raises TypeError: If `embedding` is not a sequence of numbers.
         """
         if embedding is not None and embedding_fn is not None:
             raise ValueError("Pass either 'embedding' or 'embedding_fn', not both.")
-        if dimension <= 0:
+        if embedding is None and embedding_fn is None and dimension <= 0:
             raise ValueError("'dimension' must be a positive integer.")
 
         self.embedding = _coerce_embedding(embedding, name="'embedding'") if embedding is not None else None

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/extractors/llm_metadata_extractor.py

@@ -5,10 +5,8 @@
 import copy
 import json
 from asyncio import Semaphore, gather
-from collections.abc import Iterable
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import replace
-from functools import partial
 from typing import Any
 
 from jinja2 import meta
@@ -297,10 +295,17 @@ class LLMMetadataExtractor:
 
         return all_prompts
 
-    def _run_on_thread(self, prompt: ChatMessage | None, parent_span: tracing.Span | None = None) -> dict[str, Any]:
-        # If prompt is None, return an error dictionary
+    @staticmethod
+    def _fail(document: Document, error: str, response: ChatMessage | None = None) -> tuple[Document, bool]:
+        """Return a copy of ``document`` with the failure metadata set, flagged as failed."""
+        new_meta = {**document.meta, "metadata_extraction_error": error, "metadata_extraction_response": response}
+        return replace(document, meta=new_meta), False
+
+    def _run_on_thread(
+        self, document: Document, prompt: ChatMessage | None, parent_span: tracing.Span | None = None
+    ) -> tuple[Document, bool]:
         if prompt is None:
-            return {"error": "Document has no content, skipping LLM call."}
+            return self._fail(document, "Document has no content, skipping LLM call.")
 
         try:
             with _trace_chat_generator_run(
@@ -316,13 +321,14 @@ class LLMMetadataExtractor:
                 class_name=self._chat_generator.__class__.__name__,
                 error=e,
             )
-            result = {"error": "LLM failed with exception: " + str(e)}
-        return result
+            return self._fail(document, "LLM failed with exception: " + str(e))
+        return self._process_reply(document, result["replies"][0])
 
-    async def _run_async(self, prompt: ChatMessage | None, parent_span: tracing.Span | None = None) -> dict[str, Any]:
-        # If prompt is None, return an error dictionary
+    async def _run_async(
+        self, document: Document, prompt: ChatMessage | None, parent_span: tracing.Span | None = None
+    ) -> tuple[Document, bool]:
         if prompt is None:
-            return {"error": "Document has no content, skipping LLM call."}
+            return self._fail(document, "Document has no content, skipping LLM call.")
 
         try:
             with _trace_chat_generator_run(
@@ -338,45 +344,33 @@ class LLMMetadataExtractor:
                 class_name=self._chat_generator.__class__.__name__,
                 error=e,
             )
-            result = {"error": "LLM failed with exception: " + str(e)}
-        return result
+            return self._fail(document, "LLM failed with exception: " + str(e))
+        return self._process_reply(document, result["replies"][0])
 
-    def _process_results(
-        self, documents: list[Document], results: Iterable[dict[str, Any]]
-    ) -> tuple[list[Document], list[Document]]:
-        successful_documents = []
-        failed_documents = []
-        for document, result in zip(documents, results, strict=True):
-            new_meta = {**document.meta}
-            if "error" in result:
-                new_meta["metadata_extraction_error"] = result["error"]
-                new_meta["metadata_extraction_response"] = None
-                failed_documents.append(replace(document, meta=new_meta))
-                continue
+    def _process_reply(self, document: Document, reply: ChatMessage) -> tuple[Document, bool]:
+        """
+        Parse one document's LLM reply into metadata.
 
-            reply = result["replies"][0]
-            try:
-                parsed_metadata = _parse_dict_from_json(
-                    reply.text, expected_keys=self.expected_keys, raise_on_failure=True
-                )
-            except (ValueError, json.JSONDecodeError) as e:
-                logger.warning(
-                    "Response from the LLM is not valid JSON or missing expected keys. Received output: {response}",
-                    response=reply.text,
-                )
-                if self.raise_on_failure:
-                    raise
-                new_meta["metadata_extraction_error"] = "Response is not valid JSON or missing keys. Error: " + str(e)
-                new_meta["metadata_extraction_response"] = reply
-                failed_documents.append(replace(document, meta=new_meta))
-                continue
+        Returns (updated_document, True if success else False).
+        """
+        try:
+            parsed_metadata = _parse_dict_from_json(
+                reply.text or "", expected_keys=self.expected_keys, raise_on_failure=True
+            )
+        except (ValueError, json.JSONDecodeError) as e:
+            logger.warning(
+                "Response from the LLM is not valid JSON or missing expected keys. Received output: {response}",
+                response=reply.text,
+            )
+            if self.raise_on_failure:
+                raise
+            return self._fail(document, "Response is not valid JSON or missing keys. Error: " + str(e), response=reply)
 
-            new_meta.update(parsed_metadata)
-            # Remove metadata_extraction_error and metadata_extraction_response if present from previous runs.
-            new_meta.pop("metadata_extraction_error", None)
-            new_meta.pop("metadata_extraction_response", None)
-            successful_documents.append(replace(document, meta=new_meta))
-        return successful_documents, failed_documents
+        new_meta = {**document.meta, **parsed_metadata}
+        # Remove metadata_extraction_error and metadata_extraction_response if present from previous runs.
+        new_meta.pop("metadata_extraction_error", None)
+        new_meta.pop("metadata_extraction_response", None)
+        return replace(document, meta=new_meta), True
 
     @component.output_types(documents=list[Document], failed_documents=list[Document])
     def run(self, documents: list[Document], page_range: list[str | int] | None = None) -> dict[str, Any]:
@@ -421,9 +415,19 @@ class LLMMetadataExtractor:
 
         # Run the LLM on each prompt
         with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            results = executor.map(partial(self._run_on_thread, parent_span=parent_span), all_prompts)
+            results = executor.map(
+                lambda document, prompt: self._run_on_thread(document, prompt, parent_span=parent_span),
+                documents,
+                all_prompts,
+            )
 
-        successful_documents, failed_documents = self._process_results(documents, results)
+        successful_documents = []
+        failed_documents = []
+        for doc, success in results:
+            if success:
+                successful_documents.append(doc)
+            else:
+                failed_documents.append(doc)
 
         return {"documents": successful_documents, "failed_documents": failed_documents}
 
@@ -474,12 +478,20 @@ class LLMMetadataExtractor:
         # Run the LLM on each prompt, bounding concurrency per task so max_workers is enforced.
         sem = Semaphore(max(1, self.max_workers))
 
-        async def _bounded_run(prompt: ChatMessage | None) -> dict[str, Any]:
+        async def _bounded_run(document: Document, prompt: ChatMessage | None) -> tuple[Document, bool]:
             async with sem:
-                return await self._run_async(prompt, parent_span=parent_span)
+                return await self._run_async(document, prompt, parent_span=parent_span)
 
-        results = await gather(*[_bounded_run(prompt) for prompt in all_prompts])
+        results = await gather(
+            *[_bounded_run(document, prompt) for document, prompt in zip(documents, all_prompts, strict=True)]
+        )
 
-        successful_documents, failed_documents = self._process_results(documents, results)
+        successful_documents = []
+        failed_documents = []
+        for doc, success in results:
+            if success:
+                successful_documents.append(doc)
+            else:
+                failed_documents.append(doc)
 
         return {"documents": successful_documents, "failed_documents": failed_documents}

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/fetchers/link_content.py

@@ -143,7 +143,7 @@ class LinkContentFetcher:
         self.retry_attempts = retry_attempts
         self.timeout = timeout
         self.http2 = http2
-        self.client_kwargs = client_kwargs or {}
+        self.client_kwargs = dict(client_kwargs or {})
         self.request_headers = request_headers or {}
 
         # Configure default client settings

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/joiners/branch.py

@@ -113,8 +113,10 @@ class BranchJoiner:
         :returns:
             A deserialized `BranchJoiner` instance.
         """
-        data["init_parameters"]["type_"] = deserialize_type(data["init_parameters"]["type_"])
-        return default_from_dict(cls, data)
+        # Copy so the caller's data keeps the serialized type and can be deserialized again
+        init_parameters = dict(data["init_parameters"])
+        init_parameters["type_"] = deserialize_type(init_parameters["type_"])
+        return default_from_dict(cls, {**data, "init_parameters": init_parameters})
 
     def run(self, **kwargs: Any) -> dict[str, Any]:
         """

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/preprocessors/sentence_tokenizer.py

@@ -42,6 +42,9 @@ ISO639_TO_NLTK = {
 
 QUOTE_SPANS_RE = re.compile(r'"[^"]*"|\'[^\']*\'')
 
+# Closing brackets and quotes that can trail a sentence ending, as in `He said "Hi." Bye.` or `(Hi.) Bye.`
+SENTENCE_CLOSING_CHARS_RE = r"[\)\]}\"'’”»]*"
+
 if nltk_imports.is_successful():
 
     def load_sentence_tokenizer(
@@ -105,8 +108,10 @@ if nltk_imports.is_successful():
                     self._period_context_fmt
                     % {
                         "NonWord": self._re_non_word_chars,
-                        # SentEndChars might be followed by closing brackets, so we match them here.
-                        "SentEndChars": self._re_sent_end_chars + r"[\)\]}]*",
+                        # SentEndChars might be followed by closing brackets or quotes, so we match them here.
+                        # If we don't, the whitespace after e.g. `."` is behind the closing quote, the pattern
+                        # above can't reach it and it ends up in none of the sentences we return.
+                        "SentEndChars": self._re_sent_end_chars + SENTENCE_CLOSING_CHARS_RE,
                     },
                     re.UNICODE | re.VERBOSE,
                 )
@@ -201,6 +206,10 @@ class SentenceSplitter:
         start, end = span
         next_start, next_end = next_span
 
+        # with keep_white_spaces=True a span also covers the whitespace up to the next sentence, the rules below
+        # look at where the sentence itself ends
+        end = start + len(text[start:end].rstrip())
+
         # sentence. sentence"\nsentence -> no split (end << quote_end)
         # sentence.", sentence -> no split (end < quote_end)
         # sentence?", sentence -> no split (end < quote_end)
@@ -214,6 +223,16 @@ class SentenceSplitter:
             # question is cited
             return True
 
+        # sentence.", sentence -> no split (end == quote_end): widening the closing-char class (see
+        # period_context_re) moves the boundary just past the closing quote instead of leaving it inside,
+        # so anything other than whitespace directly after the quote continues the sentence.
+        if any(
+            quote_start < end == quote_end and quote_end < len(text) and not text[quote_end].isspace()
+            for quote_start, quote_end in quote_spans
+        ):
+            # e.g. `He said "Hi.", then left.` -> the punctuation continues the sentence
+            return True
+
         if re.search(r"(^|\n)\s*\d{1,2}\.$", text[start:end]) is not None:
             # sentence ends with a numeration
             return True

{haystack_ai-3.2.0rc1 → haystack_ai-3.3.0}/haystack/components/preprocessors/text_cleaner.py

@@ -84,7 +84,11 @@ class TextCleaner:
         :param texts: List of strings to clean.
         :returns: A dictionary with the following key:
             - `texts`:  the cleaned list of strings.
+        :raises TypeError:
+            If `texts` is not a list or any element is not a string.
         """
+        if not isinstance(texts, list) or not all(isinstance(text, str) for text in texts):
+            raise TypeError("`texts` must be a list of strings.")
 
         if self._regex:
             texts = [self._regex.sub("", text) for text in texts]