agent-pack-haystack 0.0.2__tar.gz → 0.1.0__tar.gz

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [integrations/agent_pack-v0.0.2] - 2026-08-26
+
+### 🚀 Features
+
+- Use `AgentTool` in Deep Research Agent (#3850)
+
+### 🐛 Bug Fixes
+
+- Fix new issues raised by ruff 0.16.0 (#3670)
+
+### 🧹 Chores
+
+- Re-standardize READMEs (#3768)
+
+
 ## [integrations/agent_pack-v0.0.1] - 2026-07-20
 
 ### 🚀 Features

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-pack-haystack
-Version: 0.0.2
+Version: 0.1.0
 Summary: Pre-configured Haystack Agents
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/agent_pack#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/src/haystack_integrations/agent_pack/advanced_rag/agent.py

@@ -2,17 +2,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any
-
 from haystack import Document, Pipeline
 from haystack.components.agents import Agent
 from haystack.components.generators.chat import OpenAIResponsesChatGenerator
 from haystack.components.generators.chat.types import ChatGenerator
 from haystack.components.retrievers.types import TextRetriever
 from haystack.document_stores.types import DocumentStore
-from haystack.hooks import Hook, HookPoint
 from haystack.lazy_imports import LazyImport
-from haystack.tools import Tool, Toolset, ToolsType
+from haystack.tools import Tool, Toolset
 
 from haystack_integrations.agent_pack.advanced_rag import prompts
 from haystack_integrations.agent_pack.advanced_rag.hooks import BackupAnswerHook
@@ -61,11 +58,6 @@ def create_advanced_rag_agent(
     system_prompt: str | None = None,
     max_agent_steps: int = 20,
     max_fetched_docs: int = 10,
-    extra_tools: ToolsType | None = None,
-    state_schema: dict[str, Any] | None = None,
-    hooks: dict[HookPoint, list[Hook]] | None = None,
-    raise_on_tool_invocation_failure: bool = False,
-    tool_concurrency_limit: int = 4,
 ) -> Agent:
     """
     Create the advanced RAG agent.
@@ -79,6 +71,9 @@ def create_advanced_rag_agent(
     metadata inspection tools and must implement the metadata introspection methods (`get_metadata_fields_info`,
     `get_metadata_field_unique_values`, `get_metadata_field_min_max`).
 
+    To customize the returned agent further (e.g. add tools or hooks), use `Agent.clone`:
+    `agent = agent.clone(tools=[*agent.tools, my_tool])`.
+
     :param document_store: The document store the metadata inspection tools and the `fetch_documents_by_filter` tool
         run against.
     :param retriever: What retrieves for the `search_documents` tool (required). Either a standalone retriever
@@ -104,15 +99,6 @@ def create_advanced_rag_agent(
     :param max_fetched_docs: Maximum number of documents `fetch_documents_by_filter` shows per fetch. A filter fetch is
         not bounded by a retriever's `top_k`, so this caps the tool result instead; the scored `search_documents` tool
         is bounded by the `top_k` configured on your retrieval components.
-    :param extra_tools: Additional tools (or toolsets) for the agent, appended after the built-in document-store
-        toolset and the retrieval tool.
-    :param state_schema: Additional entries merged into the agent's state schema. The built-in `documents` entry
-        (the accumulated retrieved documents) always takes precedence.
-    :param hooks: Additional hooks per hook point, merged with the built-in hooks. For `after_run`, the built-in
-        backup-answer hook runs first, so custom hooks see the final answer.
-    :param raise_on_tool_invocation_failure: If True, a failing tool call raises instead of being returned to the LLM
-        as an error message it can recover from (the default).
-    :param tool_concurrency_limit: Maximum number of tool calls executed in parallel within one agent step.
     :returns: The advanced RAG `Agent`. Call it with the question as a user message,
         `agent.run(messages=[ChatMessage.from_user(question)])`; the answer is in `last_message` (a `ChatMessage`) and
         `documents` carries every document the agent retrieved during the run (deduplicated by id, in first-retrieved
@@ -150,12 +136,6 @@ def create_advanced_rag_agent(
         DocumentStoreToolset(document_store, max_fetched_docs=max_fetched_docs),
         retrieval_tool,
     ]
-    if extra_tools is not None:
-        tools.extend([extra_tools] if isinstance(extra_tools, Toolset) else list(extra_tools))
-
-    merged_hooks: dict[HookPoint, list[Hook]] = {"after_run": [BackupAnswerHook(chat_generator=backup_answer_llm)]}
-    for hook_point, point_hooks in (hooks or {}).items():
-        merged_hooks.setdefault(hook_point, []).extend(point_hooks)
 
     return Agent(
         chat_generator=llm,
@@ -163,8 +143,6 @@ def create_advanced_rag_agent(
         tools=tools,
         exit_conditions=["text"],
         max_agent_steps=max_agent_steps,
-        state_schema={**(state_schema or {}), "documents": {"type": list[Document]}},
-        hooks=merged_hooks,
-        raise_on_tool_invocation_failure=raise_on_tool_invocation_failure,
-        tool_concurrency_limit=tool_concurrency_limit,
+        state_schema={"documents": {"type": list[Document]}},
+        hooks={"after_run": [BackupAnswerHook(chat_generator=backup_answer_llm)]},
     )

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/src/haystack_integrations/agent_pack/deep_research/agent.py

@@ -18,7 +18,7 @@ from haystack.components.generators.chat import OpenAIResponsesChatGenerator
 from haystack.components.generators.chat.types import ChatGenerator
 from haystack.dataclasses import ChatMessage
 from haystack.lazy_imports import LazyImport
-from haystack.tools import AgentTool
+from haystack.tools import AgentTool, Tool
 
 from haystack_integrations.agent_pack.deep_research import prompts
 from haystack_integrations.agent_pack.deep_research.hooks import ScopeHook, WriteHook
@@ -54,27 +54,29 @@ def _collect_note(current: list[str] | None, message: ChatMessage) -> list[str]:
 def _make_researcher_agent(
     *,
     researcher_llm: ChatGenerator,
-    summarizer_llm: ChatGenerator,
+    page_summary_llm: ChatGenerator,
+    search_tool: Tool | None,
     max_researcher_steps: int,
-    max_search_results: int,
-    max_content_length: int,
+    max_page_chars: int,
 ) -> Agent:
     """
     The reusable sub-researcher.
 
     :param researcher_llm: LLM that drives the search/read/think loop and writes the summary.
-    :param summarizer_llm: LLM used inside the `read_url` tool to summarize a page toward the question.
+    :param page_summary_llm: LLM used inside the `read_url` tool to summarize a page toward the question.
+    :param search_tool: Web search tool. Defaults to `TavilyWebSearchTool(top_k=10)`.
     :param max_researcher_steps: Cap on the researcher's agent loop (search/read/think + final summary).
-    :param max_search_results: Results returned per `web_search` call.
-    :param max_content_length: Raw page chars fed to the summarizer (pre-summarization cap).
+    :param max_page_chars: Raw page chars fed to the summarizer (pre-summarization cap).
     """
-    tavily_import.check()
+    if search_tool is None:
+        tavily_import.check()
+        search_tool = TavilyWebSearchTool(top_k=10)
     return Agent(
         chat_generator=researcher_llm,
         system_prompt=prompts.RESEARCHER_TEMPLATE,
         tools=[
-            TavilyWebSearchTool(top_k=max_search_results),
-            make_read_url_tool(summarizer_llm=summarizer_llm, max_content_length=max_content_length),
+            search_tool,
+            make_read_url_tool(page_summary_llm=page_summary_llm, max_page_chars=max_page_chars),
             think_tool,
         ],
         exit_conditions=["text"],  # exits when it writes its summary
@@ -84,55 +86,62 @@ def _make_researcher_agent(
 
 def create_deep_research_agent(
     *,
-    scope_llm: ChatGenerator | None = None,
-    orchestrator_llm: ChatGenerator | None = None,
+    llm: ChatGenerator | None = None,
+    system_prompt: str | None = None,
+    max_agent_steps: int = 8,
+    brief_llm: ChatGenerator | None = None,
     researcher_llm: ChatGenerator | None = None,
-    summarizer_llm: ChatGenerator | None = None,
-    writer_llm: ChatGenerator | None = None,
-    max_subtopics: int = 5,
-    max_concurrent_researchers: int = 5,
-    max_orchestrator_steps: int = 8,
+    search_tool: Tool | None = None,
+    page_summary_llm: ChatGenerator | None = None,
+    report_llm: ChatGenerator | None = None,
     max_researcher_steps: int = 20,
-    max_search_results: int = 10,
-    max_content_length: int = 50_000,
+    max_concurrent_researchers: int = 5,
+    max_subtopics: int = 5,
+    max_page_chars: int = 50_000,
 ) -> Agent:
     """
     Create the deep research agent.
 
-    :param scope_llm: LLM that rewrites the user query into a focused research brief.
+    To customize the returned agent further (e.g. add tools or hooks), use `Agent.clone`:
+    `agent = agent.clone(tools=[*agent.tools, my_tool])`.
+
+    :param llm: LLM that plans the investigation and delegates the sub-questions.
         Defaults to `OpenAIResponsesChatGenerator("gpt-5.4")`.
-    :param orchestrator_llm: LLM that plans the investigation and delegates the sub-questions.
+    :param system_prompt: Overrides the pre-made system prompt. `{{ max_subtopics }}` is replaced with the value of
+        `max_subtopics`.
+    :param max_agent_steps: Maximum steps for the agent loop (reflect -> delegate rounds).
+    :param brief_llm: LLM that rewrites the user query into a focused research brief.
         Defaults to `OpenAIResponsesChatGenerator("gpt-5.4")`.
     :param researcher_llm: LLM that drives each sub-researcher's search/read/think loop.
         Defaults to `OpenAIResponsesChatGenerator("gpt-5.4-mini")`.
-    :param summarizer_llm: LLM used inside the `read_url` tool to summarize a fetched page toward
+    :param search_tool: Web search tool used by each sub-researcher. Defaults to `TavilyWebSearchTool(top_k=10)`,
+        which requires `tavily-haystack`. The pre-made researcher prompt refers to the tool as `web_search`.
+    :param page_summary_llm: LLM used inside the `read_url` tool to summarize a fetched page toward
         the question. Defaults to `OpenAIResponsesChatGenerator("gpt-5.4-mini")`.
-    :param writer_llm: LLM that turns the brief plus collected notes into the final report.
+    :param report_llm: LLM that turns the brief plus collected notes into the final report.
         Defaults to `OpenAIResponsesChatGenerator("gpt-5.4")`.
-    :param max_subtopics: Maximum number of sub-questions the orchestrator may delegate (breadth).
-    :param max_concurrent_researchers: Maximum number of sub-researchers that run at the same time.
-    :param max_orchestrator_steps: Maximum steps for the orchestrator's agent loop (reflect -> delegate rounds).
     :param max_researcher_steps: Maximum steps for each sub-researcher's agent loop.
-    :param max_search_results: Number of results returned per `web_search` call.
-    :param max_content_length: Maximum raw page characters fed to the summarizer, before summarization.
+    :param max_concurrent_researchers: Maximum number of sub-researchers that run at the same time.
+    :param max_subtopics: Maximum number of sub-questions the agent may delegate (breadth).
+    :param max_page_chars: Maximum raw page characters fed to the summarizer, before summarization.
     :returns: The deep research `Agent`. Call it with the question as a user message,
         `agent.run(messages=[ChatMessage.from_user(question)])`; it returns a dict whose main output is
         `report` (the final markdown report, a `str`). The dict also carries the intermediate `brief`
         (`str`) and `notes` (`list[str]`), plus the standard Agent outputs `messages`, `last_message`,
         `step_count`, `token_usage` and `tool_call_counts`.
     """
-    scope_llm = scope_llm or _default_llm("gpt-5.4")
-    orchestrator_llm = orchestrator_llm or _default_llm("gpt-5.4")
+    llm = llm or _default_llm("gpt-5.4")
+    brief_llm = brief_llm or _default_llm("gpt-5.4")
     researcher_llm = researcher_llm or _default_llm("gpt-5.4-mini")
-    summarizer_llm = summarizer_llm or _default_llm("gpt-5.4-mini")
-    writer_llm = writer_llm or _default_llm("gpt-5.4")
+    page_summary_llm = page_summary_llm or _default_llm("gpt-5.4-mini")
+    report_llm = report_llm or _default_llm("gpt-5.4")
 
     researcher = _make_researcher_agent(
         researcher_llm=researcher_llm,
-        summarizer_llm=summarizer_llm,
+        page_summary_llm=page_summary_llm,
+        search_tool=search_tool,
         max_researcher_steps=max_researcher_steps,
-        max_search_results=max_search_results,
-        max_content_length=max_content_length,
+        max_page_chars=max_page_chars,
     )
 
     research_subtopic = AgentTool(
@@ -147,22 +156,22 @@ def create_deep_research_agent(
     )
 
     scope = ScopeHook(
-        generator=scope_llm,
+        generator=brief_llm,
         prompt_builder=ChatPromptBuilder(template=prompts.SCOPE_TEMPLATE, required_variables=["query"]),
     )
     write = WriteHook(
-        generator=writer_llm,
+        generator=report_llm,
         prompt_builder=ChatPromptBuilder(template=prompts.WRITER_TEMPLATE, required_variables=["replies", "notes"]),
     )
 
-    system_prompt = prompts.ORCHESTRATOR_TEMPLATE.replace("{{ max_subtopics }}", str(max_subtopics))
+    system_prompt = (system_prompt or prompts.ORCHESTRATOR_TEMPLATE).replace("{{ max_subtopics }}", str(max_subtopics))
 
     return Agent(
-        chat_generator=orchestrator_llm,
+        chat_generator=llm,
         system_prompt=system_prompt,
         tools=[research_subtopic, think_tool],
         exit_conditions=["text"],
-        max_agent_steps=max_orchestrator_steps,
+        max_agent_steps=max_agent_steps,
         tool_concurrency_limit=max_concurrent_researchers,
         state_schema={"notes": {"type": list}, "brief": {"type": str}, "report": {"type": str}},
         hooks={"before_run": [scope], "after_run": [write]},

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/src/haystack_integrations/agent_pack/deep_research/tools.py

@@ -65,14 +65,14 @@ def _read_url_result(result: dict) -> str:
     return "Page not read: the page returned no readable text."
 
 
-def make_read_url_tool(*, summarizer_llm: ChatGenerator, max_content_length: int) -> PipelineTool:
+def make_read_url_tool(*, page_summary_llm: ChatGenerator, max_page_chars: int) -> PipelineTool:
     """
     `read_url` = PipelineTool over a fetch -> convert to text -> summarize-based-on-question pipeline.
 
-    :param summarizer_llm: LLM that summarizes the fetched page toward the agent's question.
-    :param max_content_length: Raw page chars fed to the summarizer (pre-summarization cap).
+    :param page_summary_llm: LLM that summarizes the fetched page toward the agent's question.
+    :param max_page_chars: Raw page chars fed to the summarizer (pre-summarization cap).
     """
-    template = prompts.SUMMARIZE_TEMPLATE.replace("__MAXLEN__", str(max_content_length))
+    template = prompts.SUMMARIZE_TEMPLATE.replace("__MAXLEN__", str(max_page_chars))
 
     pipe = Pipeline()
     pipe.add_component("fetcher", LinkContentFetcher(raise_on_failure=True, retry_attempts=2, timeout=10))
@@ -82,7 +82,7 @@ def make_read_url_tool(*, summarizer_llm: ChatGenerator, max_content_length: int
     pipe.add_component("joiner", DocumentJoiner())
     pipe.add_component("content_gate", ContentGate())
     pipe.add_component("builder", ChatPromptBuilder(template=template, required_variables=["question", "documents"]))
-    pipe.add_component("summarizer", summarizer_llm)
+    pipe.add_component("summarizer", page_summary_llm)
     pipe.connect("fetcher.streams", "router.sources")
     pipe.connect("router.text/html", "html.sources")
     pipe.connect("router.application/pdf", "pdf.sources")

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/tests/advanced_rag/test_agent.py

@@ -4,13 +4,11 @@ import re
 import pytest
 from haystack import Document, Pipeline
 from haystack.components.agents import Agent
-from haystack.components.agents.state import State
 from haystack.components.generators.chat import MockChatGenerator, OpenAIResponsesChatGenerator
 from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
 from haystack.dataclasses import ChatMessage, ToolCall
 from haystack.document_stores.in_memory import InMemoryDocumentStore
-from haystack.hooks import hook
-from haystack.tools import Toolset, tool
+from haystack.tools import Toolset
 
 from haystack_integrations.agent_pack.advanced_rag import agent as agent_module
 from haystack_integrations.agent_pack.advanced_rag.agent import _default_llm, create_advanced_rag_agent
@@ -122,39 +120,6 @@ class TestCreateAdvancedRagAgent:
         )
         assert _flat_tool_names(agent.tools) == EXPECTED_TOOL_NAMES
 
-    def test_supports_extra_tools_state_schema_and_hooks(self, store):
-        @tool
-        def extra_tool(text: str) -> str:
-            """Do something extra."""
-            return text
-
-        @hook
-        def custom_after_run(state: State) -> None:  # noqa: ARG001
-            return None
-
-        @hook
-        def custom_before_llm(state: State) -> None:  # noqa: ARG001
-            return None
-
-        agent = create_advanced_rag_agent(
-            document_store=store,
-            retriever=InMemoryBM25Retriever(document_store=store),
-            llm=MockChatGenerator(),
-            extra_tools=[extra_tool],
-            state_schema={"notes": {"type": list}},
-            hooks={"after_run": [custom_after_run], "before_llm": [custom_before_llm]},
-            raise_on_tool_invocation_failure=True,
-            tool_concurrency_limit=2,
-        )
-
-        assert _flat_tool_names(agent.tools) == [*EXPECTED_TOOL_NAMES, "extra_tool"]
-        assert set(agent.state_schema) >= {"notes", "documents"}
-        # The built-in backup-answer hook runs first, custom after_run hooks after it.
-        assert [type(h) for h in agent.hooks["after_run"]] == [BackupAnswerHook, type(custom_after_run)]
-        assert agent.hooks["before_llm"] == [custom_before_llm]
-        assert agent.raise_on_tool_invocation_failure is True
-        assert agent.tool_concurrency_limit == 2
-
     def test_backup_answer_llm_is_never_the_agent_llm(self, store):
         llm = MockChatGenerator()
         agent = create_advanced_rag_agent(
@@ -174,15 +139,6 @@ class TestCreateAdvancedRagAgent:
         )
         assert agent.hooks["after_run"][0].chat_generator is backup_llm
 
-    def test_built_in_documents_state_entry_wins_over_custom(self, store):
-        agent = create_advanced_rag_agent(
-            document_store=store,
-            retriever=InMemoryBM25Retriever(document_store=store),
-            llm=MockChatGenerator(),
-            state_schema={"documents": {"type": str}},
-        )
-        assert agent.state_schema["documents"]["type"] == list[Document]
-
     def test_accepts_a_custom_system_prompt(self, store):
         agent = create_advanced_rag_agent(
             document_store=store,

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/tests/deep_research/test_agent.py

@@ -5,7 +5,7 @@ from haystack.components.agents import Agent
 from haystack.components.generators.chat import MockChatGenerator, OpenAIResponsesChatGenerator
 from haystack.core.serialization import allow_deserialization_module
 from haystack.dataclasses import ChatMessage, ToolCall
-from haystack.tools import AgentTool
+from haystack.tools import AgentTool, tool
 
 from haystack_integrations.agent_pack.deep_research.agent import (
     _collect_note,
@@ -47,10 +47,10 @@ def test_collect_note_skips_empty_message():
 def test_make_researcher_agent_wires_the_three_tools():
     researcher = _make_researcher_agent(
         researcher_llm=MockChatGenerator(),
-        summarizer_llm=MockChatGenerator(),
+        page_summary_llm=MockChatGenerator(),
+        search_tool=None,
         max_researcher_steps=12,
-        max_search_results=4,
-        max_content_length=1000,
+        max_page_chars=1000,
     )
     assert isinstance(researcher, Agent)
     assert [t.name for t in researcher.tools] == ["web_search", "read_url", "think_tool"]
@@ -58,16 +58,32 @@ def test_make_researcher_agent_wires_the_three_tools():
     assert researcher.max_agent_steps == 12
 
 
+def test_make_researcher_agent_with_custom_search_tool():
+    @tool
+    def my_search(query: str) -> str:
+        """Search."""
+        return query
+
+    researcher = _make_researcher_agent(
+        researcher_llm=MockChatGenerator(),
+        page_summary_llm=MockChatGenerator(),
+        search_tool=my_search,
+        max_researcher_steps=12,
+        max_page_chars=1000,
+    )
+    assert [t.name for t in researcher.tools] == ["my_search", "read_url", "think_tool"]
+
+
 def test_create_deep_research_agent():
     agent = create_deep_research_agent(
-        scope_llm=MockChatGenerator(),
-        orchestrator_llm=MockChatGenerator(),
+        llm=MockChatGenerator(),
+        brief_llm=MockChatGenerator(),
         researcher_llm=MockChatGenerator(),
-        summarizer_llm=MockChatGenerator(),
-        writer_llm=MockChatGenerator(),
+        page_summary_llm=MockChatGenerator(),
+        report_llm=MockChatGenerator(),
         max_subtopics=3,
         max_concurrent_researchers=2,
-        max_orchestrator_steps=6,
+        max_agent_steps=6,
     )
     assert [t.name for t in agent.tools] == ["research_subtopic", "think_tool"]
     assert isinstance(agent.tools[0], AgentTool)
@@ -86,15 +102,28 @@ def test_create_deep_research_agent():
     assert default_agent.chat_generator.model == "gpt-5.4"
 
 
+def test_create_deep_research_agent_with_custom_system_prompt():
+    agent = create_deep_research_agent(
+        llm=MockChatGenerator(),
+        brief_llm=MockChatGenerator(),
+        researcher_llm=MockChatGenerator(),
+        page_summary_llm=MockChatGenerator(),
+        report_llm=MockChatGenerator(),
+        system_prompt="Delegate at most {{ max_subtopics }} sub-questions.",
+        max_subtopics=2,
+    )
+    assert agent.system_prompt == "Delegate at most 2 sub-questions."
+
+
 def test_deep_research_run(monkeypatch):
     # agent.run() warms up the TavilyWebSearch tool component, which resolves TAVILY_API_KEY
     monkeypatch.setenv("TAVILY_API_KEY", "test-key")
     agent = create_deep_research_agent(
-        scope_llm=MockChatGenerator("Brief: investigate the causes of X."),
-        orchestrator_llm=MockChatGenerator(responses=_delegate_then_stop("What causes X?")),
+        llm=MockChatGenerator(responses=_delegate_then_stop("What causes X?")),
+        brief_llm=MockChatGenerator("Brief: investigate the causes of X."),
         researcher_llm=MockChatGenerator("X is caused by Y (https://example.com/x).\nSources:\nhttps://example.com/x"),
-        summarizer_llm=MockChatGenerator(),
-        writer_llm=MockChatGenerator("# Report\nX is caused by Y (https://example.com/x)."),
+        page_summary_llm=MockChatGenerator(),
+        report_llm=MockChatGenerator("# Report\nX is caused by Y (https://example.com/x)."),
         max_subtopics=1,
     )
     result = agent.run(messages=[ChatMessage.from_user("Tell me about X")])
@@ -108,11 +137,11 @@ def test_deep_research_run(monkeypatch):
 def test_create_deep_research_agent_serialization_roundtrip():
     allow_deserialization_module("haystack_integrations.agent_pack.*")
     agent = create_deep_research_agent(
-        scope_llm=MockChatGenerator(),
-        orchestrator_llm=MockChatGenerator(),
+        llm=MockChatGenerator(),
+        brief_llm=MockChatGenerator(),
         researcher_llm=MockChatGenerator(),
-        summarizer_llm=MockChatGenerator(),
-        writer_llm=MockChatGenerator(),
+        page_summary_llm=MockChatGenerator(),
+        report_llm=MockChatGenerator(),
     )
 
     restored = Agent.from_dict(agent.to_dict())
@@ -131,7 +160,7 @@ def test_create_deep_research_agent_serialization_roundtrip():
     reason="OPENAI_API_KEY and TAVILY_API_KEY required",
 )
 def test_deep_research_live_run():
-    agent = create_deep_research_agent(max_subtopics=2, max_orchestrator_steps=4, max_researcher_steps=6)
+    agent = create_deep_research_agent(max_subtopics=2, max_agent_steps=4, max_researcher_steps=6)
     result = agent.run(messages=[ChatMessage.from_user("What are the main causes and effects of ocean acidification?")])
 
     assert result["brief"].strip()

{agent_pack_haystack-0.0.2 → agent_pack_haystack-0.1.0}/tests/deep_research/test_tools.py

@@ -38,7 +38,7 @@ def test_read_url_result_reports_no_readable_text():
 
 
 def test_make_read_url_tool_builds_pipeline_tool():
-    tool = make_read_url_tool(summarizer_llm=MockChatGenerator(), max_content_length=1234)
+    tool = make_read_url_tool(page_summary_llm=MockChatGenerator(), max_page_chars=1234)
     assert isinstance(tool, PipelineTool)
     assert tool.name == "read_url"
     assert tool._input_mapping == {"urls": ["fetcher.urls"], "question": ["builder.question"]}