haystack-ai 3.1.1__tar.gz → 3.2.0__tar.gz

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: haystack-ai
-Version: 3.1.1
+Version: 3.2.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

haystack_ai-3.2.0/VERSION.txt

@@ -0,0 +1 @@
+3.2.0

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

@@ -65,9 +65,11 @@ from haystack.utils.deserialization import deserialize_component_inplace
 
 logger = logging.getLogger(__name__)
 
-# `exit_reason` values the Agent sets when it stops without a tool exit condition: a tool-call-free reply, or the
-# `max_agent_steps` budget running out. A tool exit condition instead reports the tool's name.
+# `exit_reason` values the Agent sets when it stops without a tool exit condition: a tool-call-free reply, an
+# incomplete model generation, or the `max_agent_steps` budget running out.
 _EXIT_REASON_TEXT = "text"
+_EXIT_REASON_LENGTH = "length"
+_EXIT_REASON_CONTENT_FILTER = "content_filter"
 _EXIT_REASON_MAX_STEPS = "max_agent_steps"
 
 # Run-metadata state keys the Agent populates automatically during a run. Users may not define them in their own
@@ -82,6 +84,7 @@ _RUN_METADATA_STATE_KEYS: dict[str, dict[str, Any]] = {
 # Internal state keys the Agent manages for run control and hooks. Like run-metadata keys they are reserved and cannot
 # be redefined by users, but unlike them they are NOT exposed as Agent inputs or outputs (purely internal state):
 # - `continue_run`: set by an `on_exit` hook to keep the Agent running instead of stopping (re-read each exit attempt).
+# - `stop_run`: set by a hook to stop the run, read before each LLM call and used as the `exit_reason`.
 # - `tools`: the flattened tools available in the current step, so a hook can inspect them (e.g. HITL confirmation).
 # - `hook_context`: per-run request-scoped resources passed to `run`/`run_async` for hooks to read.
 # - `context_tokens`: approximate current context-window size, refreshed after each LLM call, for hooks to read
@@ -89,6 +92,7 @@ _RUN_METADATA_STATE_KEYS: dict[str, dict[str, Any]] = {
 #   exposed as an output because it is a best-effort snapshot; see `_record_context_tokens`.
 _INTERNAL_STATE_KEYS: dict[str, dict[str, Any]] = {
     "continue_run": {"type": bool, "handler": replace_values},
+    "stop_run": {"type": str, "handler": replace_values},
     "tools": {"type": list, "handler": replace_values},
     "hook_context": {"type": dict[str, Any], "handler": replace_values},
     "context_tokens": {"type": int, "handler": replace_values},
@@ -147,17 +151,36 @@ def _consume_continue_run(state: State) -> bool:
     return should_continue
 
 
-def _is_text_exit(messages: list[ChatMessage]) -> bool:
+def _get_model_exit_reason(messages: list[ChatMessage]) -> str | None:
     """
-    Return whether `messages` end in a plain assistant text reply with no tool calls anywhere in the batch.
+    Return the exit reason for a terminal assistant reply without tool calls.
 
-    This is the "no tool call" exit for the model's own replies. The last message must be a non-empty assistant text
-    message, so an invalid response (e.g. one with no tool calls and no text) does not trigger an exit.
+    Incomplete generation reasons take precedence over text so callers can distinguish a partial response from a
+    complete answer. An empty response without a recognized terminal reason does not trigger an exit, preserving the
+    Agent's recovery behavior for malformed tool calls that a Chat Generator discarded.
     """
-    if not messages:
-        return False
+    # If the messages list is empty or the last message has tool calls, don't exit.
+    if not messages or any(message.tool_call for message in messages):
+        return None
+
     last = messages[-1]
-    return not any(m.tool_call for m in messages) and last.is_from(ChatRole.ASSISTANT) and bool(last.text)
+
+    # If the last message is not from the assistant, don't exit.
+    if not last.is_from(ChatRole.ASSISTANT):
+        return None
+
+    # If the finish reason on the last message is length or content_filter, exit with that reason.
+    if last.meta.get("finish_reason") == _EXIT_REASON_LENGTH:
+        return _EXIT_REASON_LENGTH
+    if last.meta.get("finish_reason") == _EXIT_REASON_CONTENT_FILTER:
+        return _EXIT_REASON_CONTENT_FILTER
+
+    # If the last message has text, exit with the text reason.
+    if last.text:
+        return _EXIT_REASON_TEXT
+
+    # If we reached here no valid exit reason was found, so don't exit.
+    return None
 
 
 def _pending_tool_call_messages_from_state(state: State) -> list[ChatMessage]:
@@ -435,9 +458,12 @@ class Agent:
         """
         # --- Validation ---
         self._chat_generator_supports_tools: bool = "tools" in inspect.signature(chat_generator.run).parameters
-        # We use an explicit None check for tools b/c testing for truthiness calls __len__, which for SearchableToolset
-        # would iterate and prematurely warm it up at init.
-        if tools is not None and not self._chat_generator_supports_tools:
+        # An empty list carries no tools, so it must not trip this check: `tools` is normalized to `[]` below, and
+        # both `clone()` and `to_dict()` feed that normalized value straight back into `__init__`. This mirrors the
+        # equivalent check in `run()`. Only a list is measured; a Toolset is never tested for truthiness here b/c
+        # that calls __len__, which for SearchableToolset would iterate and prematurely warm it up at init.
+        tools_provided = tools is not None and (not isinstance(tools, list) or len(tools) > 0)
+        if tools_provided and not self._chat_generator_supports_tools:
             raise TypeError(
                 f"{type(chat_generator).__name__} does not accept tools parameter in its run method. "
                 "The Agent component requires a chat generator that supports tools when tools are provided."
@@ -838,9 +864,11 @@ class Agent:
               `meta["usage"]`.
             - "tool_call_counts": Mapping of tool name to the number of times that tool was invoked.
             - "exit_reason": Why the Agent stopped, useful for routing the output downstream (e.g. with a
-              `ConditionalRouter`). One of: `"text"` (the model returned a reply with no tool calls), 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).
+              `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.
             - Any additional keys defined in the `state_schema`.
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}
@@ -922,9 +950,11 @@ class Agent:
               `meta["usage"]`.
             - "tool_call_counts": Mapping of tool name to the number of times that tool was invoked.
             - "exit_reason": Why the Agent stopped, useful for routing the output downstream (e.g. with a
-              `ConditionalRouter`). One of: `"text"` (the model returned a reply with no tool calls), 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).
+              `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.
             - Any additional keys defined in the `state_schema`.
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}
@@ -978,6 +1008,10 @@ class Agent:
             exe_context.state.set("tools", current_tools, handler_override=replace_values)
 
             _run_hooks(hooks=self.hooks, hook_point=BEFORE_LLM, state=exe_context.state)
+            # A hook requested a stop: end the run at the step boundary, before spending another LLM call.
+            if (reason := exe_context.state.data.get("stop_run")) is not None:
+                exe_context.state.set("exit_reason", reason)
+                return False
             chat_generator_inputs = {
                 "messages": exe_context.state.data["messages"],
                 **exe_context.chat_generator_inputs,
@@ -993,17 +1027,18 @@ class Agent:
             _record_llm_usage(state=exe_context.state, llm_messages=llm_messages)
             _record_context_tokens(state=exe_context.state, llm_messages=llm_messages)
 
-            # Stop on the "no tool call" exit: no tools available, or a plain assistant text reply (see _is_text_exit).
-            if not current_tools or _is_text_exit(messages=llm_messages):
+            # Stop when there are no tools, or the model produced a terminal reply without tool calls.
+            model_exit_reason = _get_model_exit_reason(messages=llm_messages)
+            if not current_tools or model_exit_reason is not None:
                 exe_context.counter += 1
                 exe_context.state.set("step_count", exe_context.counter)
-                exe_context.state.set("exit_reason", _EXIT_REASON_TEXT)
+                exe_context.state.set("exit_reason", model_exit_reason or _EXIT_REASON_TEXT)
                 return self._continue_after_exit_hooks(exe_context=exe_context)
 
             _run_hooks(hooks=self.hooks, hook_point=BEFORE_TOOL, state=exe_context.state)
             # Re-read the pending tool calls from State so that any rewrites a before_tool hook made (e.g.
             # ConfirmationHook rejecting or modifying calls) are honored by the executor.
-            pending_tool_call_messages = _pending_tool_call_messages_from_state(exe_context.state)
+            pending_tool_call_messages = _pending_tool_call_messages_from_state(state=exe_context.state)
 
             tool_execution_inputs = {
                 "messages": pending_tool_call_messages,
@@ -1041,6 +1076,10 @@ class Agent:
             exe_context.state.set("tools", current_tools, handler_override=replace_values)
 
             await _run_hooks_async(hooks=self.hooks, hook_point=BEFORE_LLM, state=exe_context.state)
+            # A hook requested a stop: end the run at the step boundary, before spending another LLM call.
+            if (reason := exe_context.state.data.get("stop_run")) is not None:
+                exe_context.state.set("exit_reason", reason)
+                return False
             chat_generator_inputs = {
                 "messages": exe_context.state.data["messages"],
                 **exe_context.chat_generator_inputs,
@@ -1058,17 +1097,18 @@ class Agent:
             _record_llm_usage(state=exe_context.state, llm_messages=llm_messages)
             _record_context_tokens(state=exe_context.state, llm_messages=llm_messages)
 
-            # Stop on the "no tool call" exit: no tools available, or a plain assistant text reply (see _is_text_exit).
-            if not current_tools or _is_text_exit(messages=llm_messages):
+            # Stop when there are no tools, or the model produced a terminal reply without tool calls.
+            model_exit_reason = _get_model_exit_reason(messages=llm_messages)
+            if not current_tools or model_exit_reason is not None:
                 exe_context.counter += 1
                 exe_context.state.set("step_count", exe_context.counter)
-                exe_context.state.set("exit_reason", _EXIT_REASON_TEXT)
+                exe_context.state.set("exit_reason", model_exit_reason or _EXIT_REASON_TEXT)
                 return await self._continue_after_exit_hooks_async(exe_context=exe_context)
 
             await _run_hooks_async(hooks=self.hooks, hook_point=BEFORE_TOOL, state=exe_context.state)
             # Re-read the pending tool calls from State so that any rewrites a before_tool hook made (e.g.
             # ConfirmationHook rejecting or modifying calls) are honored by the executor.
-            pending_tool_call_messages = _pending_tool_call_messages_from_state(exe_context.state)
+            pending_tool_call_messages = _pending_tool_call_messages_from_state(state=exe_context.state)
 
             tool_execution_inputs = {
                 "messages": pending_tool_call_messages,

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

@@ -234,7 +234,7 @@ class ChatPromptBuilder:
         :returns: A dictionary with the following keys:
             - `prompt`: The updated list of `ChatMessage` objects after rendering the templates.
         :raises ValueError:
-            If `chat_messages` is empty or contains elements that are not instances of `ChatMessage`.
+            If `template` is empty or contains elements that are not instances of `ChatMessage`.
         """
         kwargs = kwargs or {}
         template_variables = template_variables or {}

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/converters/csv.py

@@ -22,7 +22,8 @@ class CSVToDocument:
     """
     Converts CSV files to Documents.
 
-    By default, it uses UTF-8 encoding when converting files but
+    By default, it uses UTF-8 encoding (`utf-8-sig`, which also strips a byte order mark if
+    present) when converting files but
     you can also set a custom encoding.
     It can attach metadata to the resulting documents.
 
@@ -44,7 +45,7 @@ class CSVToDocument:
 
     def __init__(
         self,
-        encoding: str = "utf-8",
+        encoding: str = "utf-8-sig",
         store_full_path: bool = False,
         *,
         conversion_mode: Literal["file", "row"] = "file",

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

@@ -113,23 +113,30 @@ class DocumentToImageContent:
         :returns:
             Dictionary containing one key:
             - "image_contents": ImageContents created from the processed documents. These contain base64-encoded image
-                data and metadata. The order corresponds to order of input documents.
-        :raises ValueError:
-            If any document is missing the required metadata keys, has an invalid file path, or has an unsupported
-            MIME type. The error message will specify which document and what information is missing or incorrect.
+                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.
         """
         if not documents:
             return {"image_contents": []}
 
-        images_source_info = _extract_image_sources_info(
-            documents=documents, file_path_meta_field=self.file_path_meta_field, root_path=self.root_path
-        )
-
         image_contents: list[ImageContent | None] = [None] * len(documents)
 
         pdf_page_infos: list[_PDFPageInfo] = []
 
-        for doc_idx, image_source_info in enumerate(images_source_info):
+        for doc_idx, document in enumerate(documents):
+            # Validate each document on its own so one invalid document leaves None in its slot
+            # instead of failing the whole batch
+            try:
+                image_source_info = _extract_image_sources_info(
+                    documents=[document], file_path_meta_field=self.file_path_meta_field, root_path=self.root_path
+                )[0]
+            except ValueError as error:
+                logger.warning(
+                    "Skipping document with ID {document_id}: {error}", document_id=document.id, error=str(error)
+                )
+                continue
+
             mime_type = image_source_info["mime_type"]
             path = image_source_info["path"]
             if mime_type == "application/pdf":
@@ -146,7 +153,7 @@ class DocumentToImageContent:
                     base64_image=base64_image,
                     mime_type=mime_type,
                     detail=self.detail,
-                    meta={"file_path": documents[doc_idx].meta[self.file_path_meta_field]},
+                    meta={"file_path": document.meta[self.file_path_meta_field]},
                 )
 
         # efficiently convert PDF pages to images: each PDF is opened and processed only once

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

@@ -187,7 +187,7 @@ class JSONConverter:
             to a different document.
         """
         try:
-            file_content = source.data.decode("utf-8")
+            file_content = source.data.decode("utf-8-sig")
         except UnicodeError as exc:
             logger.warning(
                 "Failed to extract text from {source}. Skipping it. Error: {error}",

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/converters/markdown.py

@@ -52,7 +52,7 @@ class MarkdownToDocument:
         table_to_single_line: bool = False,
         progress_bar: bool = True,
         store_full_path: bool = False,
-        encoding: str = "utf-8",
+        encoding: str = "utf-8-sig",
         *,
         extract_frontmatter: bool = False,
     ) -> None:

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/converters/multi_file_converter.py

@@ -52,14 +52,14 @@ class MultiFileConverter:
 
     Usage example:
     ```
-    from haystack.super_components.converters import MultiFileConverter
+    from haystack.components.converters import MultiFileConverter
 
     converter = MultiFileConverter()
     converter.run(sources=["test/test_files/txt/doc_1.txt", "test/test_files/pdf/sample_pdf_1.pdf"], meta={})
     ```
     """
 
-    def __init__(self, encoding: str = "utf-8", json_content_key: str = "content") -> None:
+    def __init__(self, encoding: str = "utf-8-sig", json_content_key: str = "content") -> None:
         """
         Initialize the MultiFileConverter.
 

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/converters/output_adapter.py

@@ -136,8 +136,12 @@ class OutputAdapter:
             # we try to evaluate it and would fail.
             # This must be done cause the output could be different literal structures.
             # This doesn't support any user types.
+            # When the declared output_type is str we skip literal evaluation so that a
+            # rendered string that happens to be a valid Python literal (e.g. "1,000" -> (1, 0),
+            # "42" -> 42, "None" -> None) is returned unchanged instead of being coerced to
+            # another type, which would violate the declared output_type.
             with contextlib.suppress(Exception):
-                if not self._unsafe:
+                if not self._unsafe and self.output_type is not str:
                     output_result = ast.literal_eval(output_result)
 
             adapted_outputs["output"] = output_result

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/converters/txt.py

@@ -18,7 +18,8 @@ class TextFileToDocument:
     """
     Converts text files to documents your pipeline can query.
 
-    By default, it uses UTF-8 encoding when converting files but
+    By default, it uses UTF-8 encoding (`utf-8-sig`, which also strips a byte order mark if
+    present) when converting files but
     you can also set custom encoding.
     It can attach metadata to the resulting documents.
 
@@ -36,7 +37,7 @@ class TextFileToDocument:
     ```
     """
 
-    def __init__(self, encoding: str = "utf-8", store_full_path: bool = False) -> None:
+    def __init__(self, encoding: str = "utf-8-sig", store_full_path: bool = False) -> None:
         """
         Creates a TextFileToDocument component.
 

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

@@ -209,6 +209,10 @@ class XLSXToDocument:
                     if row_idx < len(df) and col_idx < len(df.columns):
                         cell_value = df.iat[row_idx, col_idx]
                         text = str(cell_value) if pd.notna(cell_value) else ""
+                        # Hyperlink text must be assignable to numeric and other typed columns.
+                        column = df.columns[col_idx]
+                        if df[column].dtype != object:
+                            df[column] = df[column].astype(object)
                         if self.link_format == "markdown":
                             df.iat[row_idx, col_idx] = f"[{text}]({url})"
                         else:
@@ -227,10 +231,15 @@ class XLSXToDocument:
                     "index": True,
                     "headers": value.columns,
                     "tablefmt": "pipe",
+                    "missingval": "",
                     **self.table_format_kwargs,
                 }
-                # to_markdown uses tabulate
-                tables.append(value.to_markdown(**resolved_kwargs))
+                # 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
+                # to_csv already writes it, and so missingval keeps working.
+                filled = value.astype(object).where(value.notna(), None)
+                tables.append(filled.to_markdown(**resolved_kwargs))
             # add sheet_name to metadata
             metadata.append({"xlsx": {"sheet_name": key}})
         return tables, metadata

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/embedders/openai_document_embedder.py

@@ -297,7 +297,7 @@ class OpenAIDocumentEmbedder:
             batches = async_tqdm(batches, desc="Calculating embeddings")
 
         for batch in batches:
-            args: dict[str, Any] = {"model": self.model, "input": [b[1] for b in batch]}
+            args: dict[str, Any] = {"model": self.model, "input": [b[1] for b in batch], "encoding_format": "float"}
 
             if self.dimensions is not None:
                 args["dimensions"] = self.dimensions

{haystack_ai-3.1.1 → haystack_ai-3.2.0}/haystack/components/extractors/image/llm_document_content_extractor.py

@@ -6,7 +6,6 @@ import asyncio
 import json
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import replace
-from functools import partial
 from typing import Any, Literal
 
 from jinja2 import meta
@@ -273,19 +272,25 @@ class LLMDocumentContentExtractor:
         meta_updates = {k: v for k, v in parsed.items() if k != DOCUMENT_CONTENT_KEY}
         return content, meta_updates, None
 
+    @staticmethod
+    def _fail(document: Document, error: str) -> tuple[Document, bool]:
+        """Return a copy of ``document`` with ``extraction_error`` set, flagged as failed."""
+        return replace(document, meta={**document.meta, "extraction_error": error}), False
+
     def _run_on_thread(
-        self, image_content: ImageContent | None, parent_span: tracing.Span | None = None
-    ) -> dict[str, Any]:
+        self, document: Document, image_content: ImageContent | None, parent_span: tracing.Span | None = None
+    ) -> tuple[Document, bool]:
         """
         Execute the LLM inference in a separate thread for each document.
 
-        :param image_content: The image content for one document, or None if conversion failed.
+        :param document: The document to extract content for.
+        :param image_content: The image content for the document, or None if conversion failed.
         :param parent_span: Span to nest the generator span under, captured on the calling thread.
         :returns:
-            The LLM response if successful, or a dictionary with an "error" key on failure.
+            The updated document and True on success, or the document with failure metadata and False.
         """
         if image_content is None:
-            return {"error": "Document has no content, skipping LLM call."}
+            return self._fail(document, "Document has no content, skipping LLM call.")
 
         # the prompt is the same for all documents, so we can set it up once here for each document/thread
         message = ChatMessage.from_user(content_parts=[TextContent(text=self.prompt), image_content])
@@ -304,23 +309,24 @@ class LLMDocumentContentExtractor:
                 class_name=self._chat_generator.__class__.__name__,
                 error=e,
             )
-            result = {"error": "LLM failed with exception: " + str(e)}
+            return self._fail(document, "LLM failed with exception: " + str(e))
 
-        return result
+        return self._process_llm_results(document, result["replies"][0])
 
     async def _run_async(
-        self, image_content: ImageContent | None, parent_span: tracing.Span | None = None
-    ) -> dict[str, Any]:
+        self, document: Document, image_content: ImageContent | None, parent_span: tracing.Span | None = None
+    ) -> tuple[Document, bool]:
         """
         Execute the LLM inference asynchronously for each document.
 
-        :param image_content: The image content for one document, or None if conversion failed.
+        :param document: The document to extract content for.
+        :param image_content: The image content for the document, or None if conversion failed.
         :param parent_span: Span to nest the generator span under, captured on the calling task.
         :returns:
-            The LLM response if successful, or a dictionary with an "error" key on failure.
+            The updated document and True on success, or the document with failure metadata and False.
         """
         if image_content is None:
-            return {"error": "Document has no content, skipping LLM call."}
+            return self._fail(document, "Document has no content, skipping LLM call.")
 
         # the prompt is the same for all documents, so we can set it up once here for each document
         message = ChatMessage.from_user(content_parts=[TextContent(text=self.prompt), image_content])
@@ -339,28 +345,23 @@ class LLMDocumentContentExtractor:
                 class_name=self._chat_generator.__class__.__name__,
                 error=e,
             )
-            result = {"error": "LLM failed with exception: " + str(e)}
+            return self._fail(document, "LLM failed with exception: " + str(e))
 
-        return result
+        return self._process_llm_results(document, result["replies"][0])
 
     @staticmethod
-    def _process_llm_results(document: Document, result: dict[str, Any]) -> tuple[Document, bool]:
+    def _process_llm_results(document: Document, reply: ChatMessage) -> tuple[Document, bool]:
         """
-        Process one document's LLM result using the unified response logic.
+        Process one document's LLM reply using the unified response logic.
 
         Returns (updated_document, True if success else False).
         """
-        if "error" in result:
-            new_meta = {**document.meta, "extraction_error": result["error"]}
-            return replace(document, meta=new_meta), False
-
         # remove potentially existing error metadata from previous runs
         new_meta = {**document.meta}
         new_meta.pop("extraction_error", None)
 
         # process the LLM response considering the possible response formats
-        response_text = result["replies"][0].text
-        content, meta_updates, error = LLMDocumentContentExtractor._process_response(response_text)
+        content, meta_updates, error = LLMDocumentContentExtractor._process_response(reply.text or "")
 
         if error:
             new_meta["extraction_error"] = error
@@ -390,12 +391,15 @@ class LLMDocumentContentExtractor:
         parent_span = tracing.tracer.current_span()
 
         with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            results = executor.map(partial(self._run_on_thread, parent_span=parent_span), image_contents)
+            results = executor.map(
+                lambda document, image_content: self._run_on_thread(document, image_content, parent_span=parent_span),
+                documents,
+                image_contents,
+            )
 
         successful_documents = []
         failed_documents = []
-        for document, result in zip(documents, results, strict=True):
-            doc, success = self._process_llm_results(document, result)
+        for doc, success in results:
             if success:
                 successful_documents.append(doc)
             else:
@@ -422,7 +426,10 @@ class LLMDocumentContentExtractor:
 
         await self.warm_up_async()
 
-        image_contents = self._document_to_image_content.run(documents=documents)["image_contents"]
+        # Reading the files and rendering PDF pages is blocking work and `DocumentToImageContent` has no
+        # `run_async`, so it runs in a thread instead of on the event loop.
+        conversion_result = await _execute_component_async(self._document_to_image_content, documents=documents)
+        image_contents = conversion_result["image_contents"]
 
         # Capture the current span here so concurrent tasks nest their generator spans under the component span.
         parent_span = tracing.tracer.current_span()
@@ -430,16 +437,20 @@ class LLMDocumentContentExtractor:
         # Run the LLM on each image content, bounding concurrency per task so max_workers is enforced.
         sem = asyncio.Semaphore(max(1, self.max_workers))
 
-        async def _bounded_run(image_content: ImageContent | None) -> dict[str, Any]:
+        async def _bounded_run(document: Document, image_content: ImageContent | None) -> tuple[Document, bool]:
             async with sem:
-                return await self._run_async(image_content, parent_span=parent_span)
+                return await self._run_async(document, image_content, parent_span=parent_span)
 
-        results = await asyncio.gather(*[_bounded_run(image_content) for image_content in image_contents])
+        results = await asyncio.gather(
+            *[
+                _bounded_run(document, image_content)
+                for document, image_content in zip(documents, image_contents, strict=True)
+            ]
+        )
 
         successful_documents = []
         failed_documents = []
-        for document, result in zip(documents, results, strict=True):
-            doc, success = self._process_llm_results(document, result)
+        for doc, success in results:
             if success:
                 successful_documents.append(doc)
             else:

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

@@ -268,20 +268,6 @@ class LLMMetadataExtractor:
         deserialize_chatgenerator_inplace(data["init_parameters"], key="chat_generator")
         return default_from_dict(cls, data)
 
-    def _extract_metadata(self, llm_answer: str) -> dict[str, Any]:
-        try:
-            parsed_metadata = _parse_dict_from_json(llm_answer, 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=llm_answer,
-            )
-            if self.raise_on_failure:
-                raise e
-            return {"error": "Response is not valid JSON or missing keys. Error: " + str(e)}
-
-        return parsed_metadata
-
     def _prepare_prompts(
         self, documents: list[Document], expanded_range: list[int] | None = None
     ) -> list[ChatMessage | None]:
@@ -368,18 +354,27 @@ class LLMMetadataExtractor:
                 failed_documents.append(replace(document, meta=new_meta))
                 continue
 
-            parsed_metadata = self._extract_metadata(result["replies"][0].text)
-            if "error" in parsed_metadata:
-                new_meta["metadata_extraction_error"] = parsed_metadata["error"]
-                new_meta["metadata_extraction_response"] = result["replies"][0]
+            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
 
-            for key in parsed_metadata:
-                new_meta[key] = parsed_metadata[key]
-                # 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)
+            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