zrb 1.21.6__py3-none-any.whl → 1.21.28__py3-none-any.whl

zrb/builtin/llm/tool/file.py

@@ -2,71 +2,15 @@ import fnmatch
 import json
 import os
 import re
-import sys
-from typing import Any, Literal, Optional
+from typing import Any, Optional
 
 from zrb.builtin.llm.tool.sub_agent import create_sub_agent_tool
 from zrb.config.config import CFG
 from zrb.config.llm_rate_limitter import llm_rate_limitter
 from zrb.context.any_context import AnyContext
+from zrb.task.llm.file_tool_model import FileReplacement, FileToRead, FileToWrite
 from zrb.util.file import read_file, read_file_with_line_numbers, write_file
 
-if sys.version_info >= (3, 12):
-    from typing import NotRequired, TypedDict
-else:
-    from typing_extensions import NotRequired, TypedDict
-
-
-class FileToRead(TypedDict):
-    """
-    Configuration for reading a file or file section.
-
-    Attributes:
-        path (str): Absolute or relative path to the file
-        start_line (int | None): Starting line number (1-based, inclusive). If None, reads from beginning.
-        end_line (int | None): Ending line number (1-based, exclusive). If None, reads to end.
-    """
-
-    path: str
-    start_line: NotRequired[int | None]
-    end_line: NotRequired[int | None]
-
-
-class FileToWrite(TypedDict):
-    """
-    Configuration for writing content to a file.
-
-    Attributes:
-        path (str): Absolute or relative path where file will be written.
-        content (str): Content to write. CRITICAL: For JSON, ensure all special characters in this string are properly escaped.
-        mode (str): Mode for writing: 'w' (overwrite, default), 'a' (append), 'x' (create exclusively).
-    """
-
-    path: str
-    content: str
-    mode: NotRequired[Literal["w", "wt", "tw", "a", "at", "ta", "x", "xt", "tx"]]
-
-
-class Replacement(TypedDict):
-    """
-    Configuration for a single text replacement operation.
-
-    Attributes:
-        old_string (str): Exact text to find and replace (must match file content exactly)
-        new_string (str): New text to replace with
-    """
-
-    old_string: str
-    new_string: str
-
-
-class FileReplacement(TypedDict):
-    """Represents a file replacement operation with path and one or more replacements."""
-
-    path: str
-    replacements: list[Replacement]
-
-
 DEFAULT_EXCLUDED_PATTERNS = [
     # Common Python artifacts
     "__pycache__",
@@ -138,20 +82,21 @@ DEFAULT_EXCLUDED_PATTERNS = [
 
 def list_files(
     path: str = ".",
-    recursive: bool = True,
     include_hidden: bool = False,
+    depth: int = 3,
     excluded_patterns: Optional[list[str]] = None,
 ) -> dict[str, list[str]]:
     """
-    Lists files and directories recursively or non-recursively.
+    Lists files recursively up to a specified depth.
 
     Example:
-    list_files(path='src', recursive=True, include_hidden=False)
+    list_files(path='src', include_hidden=False, depth=2)
 
     Args:
         path (str): Directory path. Defaults to current directory.
-        recursive (bool): List recursively. Defaults to True.
         include_hidden (bool): Include hidden files. Defaults to False.
+        depth (int): Maximum depth to traverse. Defaults to 3.
+            Minimum depth is 1 (current directory only).
         excluded_patterns (list[str]): Glob patterns to exclude.
 
     Returns:
@@ -169,50 +114,30 @@ def list_files(
         if excluded_patterns is not None
         else DEFAULT_EXCLUDED_PATTERNS
     )
+    if depth <= 0:
+        depth = 1
     try:
-        if recursive:
-            for root, dirs, files in os.walk(abs_path, topdown=True):
-                # Filter directories in-place
-                dirs[:] = [
-                    d
-                    for d in dirs
-                    if (include_hidden or not _is_hidden(d))
-                    and not is_excluded(d, patterns_to_exclude)
-                ]
-                # Process files
-                for filename in files:
-                    if (include_hidden or not _is_hidden(filename)) and not is_excluded(
-                        filename, patterns_to_exclude
-                    ):
-                        full_path = os.path.join(root, filename)
-                        # Check rel path for patterns like '**/node_modules/*'
-                        rel_full_path = os.path.relpath(full_path, abs_path)
-                        is_rel_path_excluded = is_excluded(
-                            rel_full_path, patterns_to_exclude
-                        )
-                        if not is_rel_path_excluded:
-                            all_files.append(full_path)
-        else:
-            # Non-recursive listing (top-level only)
-            for item in os.listdir(abs_path):
-                full_path = os.path.join(abs_path, item)
-                # Include both files and directories if not recursive
-                if (include_hidden or not _is_hidden(item)) and not is_excluded(
-                    item, patterns_to_exclude
+        initial_depth = abs_path.rstrip(os.sep).count(os.sep)
+        for root, dirs, files in os.walk(abs_path, topdown=True):
+            current_depth = root.rstrip(os.sep).count(os.sep) - initial_depth
+            if current_depth >= depth - 1:
+                del dirs[:]
+            dirs[:] = [
+                d
+                for d in dirs
+                if (include_hidden or not _is_hidden(d))
+                and not is_excluded(d, patterns_to_exclude)
+            ]
+            for filename in files:
+                if (include_hidden or not _is_hidden(filename)) and not is_excluded(
+                    filename, patterns_to_exclude
                 ):
-                    all_files.append(full_path)
-        # Return paths relative to the original path requested
-        try:
-            rel_files = [os.path.relpath(f, abs_path) for f in all_files]
-            return {"files": sorted(rel_files)}
-        except (
-            ValueError
-        ) as e:  # Handle case where path is '.' and abs_path is CWD root
-            if "path is on mount '" in str(e) and "' which is not on mount '" in str(e):
-                # If paths are on different mounts, just use absolute paths
-                rel_files = all_files
-                return {"files": sorted(rel_files)}
-            raise
+                    full_path = os.path.join(root, filename)
+                    rel_full_path = os.path.relpath(full_path, abs_path)
+                    if not is_excluded(rel_full_path, patterns_to_exclude):
+                        all_files.append(rel_full_path)
+        return {"files": sorted(all_files)}
+
     except (OSError, IOError) as e:
         raise OSError(f"Error listing files in {path}: {e}")
     except Exception as e:
@@ -255,10 +180,12 @@ def read_from_file(
     Reads content from one or more files, optionally specifying line ranges.
 
     Examples:
+    ```
     # Read entire content of a single file
     read_from_file(file={'path': 'path/to/file.txt'})
 
     # Read specific lines from a file
+    # The content will be returned with line numbers in the format: "LINE_NUMBER | line content"
     read_from_file(file={'path': 'path/to/large_file.log', 'start_line': 100, 'end_line': 150})
 
     # Read multiple files
@@ -266,12 +193,14 @@ def read_from_file(
         {'path': 'path/to/file1.txt'},
         {'path': 'path/to/file2.txt', 'start_line': 1, 'end_line': 5}
     ])
+    ```
 
     Args:
         file (FileToRead | list[FileToRead]): A single file configuration or a list of them.
 
     Returns:
         dict: Content and metadata for a single file, or a dict of results for multiple files.
+        The `content` field in the returned dictionary will have line numbers in the format: "LINE_NUMBER | line content"
     """
     is_list = isinstance(file, list)
     files = file if is_list else [file]
@@ -327,17 +256,23 @@ def write_to_file(
     file: FileToWrite | list[FileToWrite],
 ) -> str | dict[str, Any]:
     """
-    Writes content to one or more files, with options for overwrite, append, or exclusive creation.
+    Writes content to one or more files, with options for overwrite, append, or exclusive
+    creation.
 
-    CRITICAL: The content for each file MUST NOT exceed 4000 characters. If your content is larger,
-    you MUST split it into chunks and make multiple calls to this tool. The first call should use
-    'w' mode, and subsequent calls for the same file should use 'a' mode.
+    **CRITICAL - PREVENT JSON ERRORS:**
+    1. **ESCAPING:** Do NOT double-escape quotes.
+       - CORRECT: "content": "He said \"Hello\""
+       - WRONG:   "content": "He said \\"Hello\\""  <-- This breaks JSON parsing!
+    2. **SIZE LIMIT:** Content MUST NOT exceed 4000 characters.
+       - Exceeding this causes truncation and EOF errors.
+       - Split larger content into multiple sequential calls (first 'w', then 'a').
 
     Examples:
+    ```
     # Overwrite 'file.txt' with initial content
     write_to_file(file={'path': 'path/to/file.txt', 'content': 'Initial content.'})
 
-    # Append a second chunk to 'file.txt' (note the newline for separate lines)
+    # Append a second chunk to 'file.txt' (note the newline at the beginning of the content)
     write_to_file(file={'path': 'path/to/file.txt', 'content': '\nSecond chunk.', 'mode': 'a'})
 
     # Write to multiple files
@@ -345,6 +280,7 @@ def write_to_file(
         {'path': 'path/to/file1.txt', 'content': 'Content for file 1'},
         {'path': 'path/to/file2.txt', 'content': 'Content for file 2', 'mode': 'w'}
     ])
+    ```
 
     Args:
         file (FileToWrite | list[FileToWrite]): A single file configuration or a list of them.
@@ -490,47 +426,72 @@ def replace_in_file(
     file: FileReplacement | list[FileReplacement],
 ) -> str | dict[str, Any]:
     """
-    Replaces exact string occurrences in one or more files.
+    Replaces exact text in files.
 
-    CRITICAL: `old_string` must match file content exactly (including whitespace, newlines).
+    **CRITICAL INSTRUCTIONS:**
+    1. **READ FIRST:** Use `read_file` to get exact content. Do not guess.
+    2. **EXACT MATCH:** `old_text` must match file content EXACTLY (whitespace, newlines).
+    3. **ESCAPING:** Do NOT double-escape quotes in `new_text`. Use `\"`, not `\\"`.
+    4. **SIZE LIMIT:** `new_text` MUST NOT exceed 4000 chars to avoid truncation/EOF errors.
+    5. **MINIMAL CONTEXT:** Keep `old_text` small (target lines + 2-3 context lines).
+    6. **DEFAULT:** Replaces **ALL** occurrences. Set `count=1` for first occurrence only.
 
     Examples:
-    # Single file replacement
-    replace_in_file(file={'path': 'path/to/file.txt', 'replacements': [{'old_string': 'old', 'new_string': 'new'}]})
-
-    # Multiple file replacements
+    ```
+    # Replace ALL occurrences
     replace_in_file(file=[
-        {'path': 'path/to/file1.txt', 'replacements': [{'old_string': 'foo', 'new_string': 'bar'}]},
-        {'path': 'path/to/file2.txt', 'replacements': [{'old_string': 'old', 'new_string': 'new'}]}
+        {'path': 'file.txt', 'old_text': 'foo', 'new_text': 'bar'},
+        {'path': 'file.txt', 'old_text': 'baz', 'new_text': 'qux'}
     ])
 
+    # Replace ONLY the first occurrence
+    replace_in_file(
+        file={'path': 'file.txt', 'old_text': 'foo', 'new_text': 'bar', 'count': 1}
+    )
+
+    # Replace code block (include context for safety)
+    replace_in_file(
+        file={
+            'path': 'app.py',
+            'old_text': '    def old_fn():\n        pass',
+            'new_text': '    def new_fn():\n        pass'
+        }
+    )
+    ```
+
     Args:
-        file (FileReplacement | list[FileReplacement]): A single file configuration or a list of them.
+        file: Single replacement config or list of them.
 
     Returns:
-        Success message for single file, or dict with success/errors for multiple files.
+        Success message or error dict.
     """
     # Normalize to list
     file_replacements = file if isinstance(file, list) else [file]
+    # Group replacements by file path to minimize file I/O
+    replacements_by_path: dict[str, list[FileReplacement]] = {}
+    for r in file_replacements:
+        path = r["path"]
+        if path not in replacements_by_path:
+            replacements_by_path[path] = []
+        replacements_by_path[path].append(r)
     success = []
     errors = {}
-    for file_replacement_config in file_replacements:
-        path = file_replacement_config["path"]
-        replacements = file_replacement_config["replacements"]
+    for path, replacements in replacements_by_path.items():
         try:
             abs_path = os.path.abspath(os.path.expanduser(path))
             if not os.path.exists(abs_path):
                 raise FileNotFoundError(f"File not found: {path}")
             content = read_file(abs_path)
             original_content = content
-            # Apply all replacements
+            # Apply all replacements for this file
             for replacement in replacements:
-                old_string = replacement["old_string"]
-                new_string = replacement["new_string"]
-                if old_string not in content:
-                    raise ValueError(f"old_string not found in file: {path}")
-                # Replace first occurrence only (maintains current behavior)
-                content = content.replace(old_string, new_string, 1)
+                old_text = replacement["old_text"]
+                new_text = replacement["new_text"]
+                count = replacement.get("count", -1)
+                if old_text not in content:
+                    raise ValueError(f"old_text not found in file: {path}")
+                # Replace occurrences
+                content = content.replace(old_text, new_text, count)
             # Only write if content actually changed
             if content != original_content:
                 write_file(abs_path, content)
@@ -542,16 +503,15 @@ def replace_in_file(
     # Return appropriate response based on input type
     if isinstance(file, list):
         return {"success": success, "errors": errors}
-    else:
-        if errors:
-            raise RuntimeError(
-                f"Error applying replacement to {file['path']}: {errors[file['path']]}"
-            )
-        return f"Successfully applied replacement(s) to {file['path']}"
+    path = file["path"]
+    if errors:
+        error_message = errors[path]
+        raise RuntimeError(f"Error applying replacement to {path}: {error_message}")
+    return f"Successfully applied replacement(s) to {path}"
 
 
 async def analyze_file(
-    ctx: AnyContext, path: str, query: str, token_limit: int | None = None
+    ctx: AnyContext, path: str, query: str, token_threshold: int | None = None
 ) -> dict[str, Any]:
     """
     Analyzes a file using a sub-agent for complex questions.
@@ -562,29 +522,39 @@ async def analyze_file(
     Args:
         ctx (AnyContext): The execution context.
         path (str): The path to the file to analyze.
-        query (str): A specific analysis query with clear guidelines and necessary information.
-        token_limit (int | None): Max tokens.
+        query (str): A specific analysis query with clear guidelines and
+            necessary information.
+        token_threshold (int | None): Max tokens.
 
     Returns:
         Analysis results.
     """
-    if token_limit is None:
-        token_limit = CFG.LLM_FILE_ANALYSIS_TOKEN_LIMIT
+    if token_threshold is None:
+        token_threshold = CFG.LLM_FILE_ANALYSIS_TOKEN_THRESHOLD
     abs_path = os.path.abspath(os.path.expanduser(path))
     if not os.path.exists(abs_path):
         raise FileNotFoundError(f"File not found: {path}")
     file_content = read_file(abs_path)
     _analyze_file = create_sub_agent_tool(
         tool_name="analyze_file",
-        tool_description="Analyze file content using LLM sub-agent for complex questions about code structure, documentation quality, or file-specific analysis. Use for questions that require understanding beyond simple text reading.",
+        tool_description=(
+            "Analyze file content using LLM sub-agent "
+            "for complex questions about code structure, documentation "
+            "quality, or file-specific analysis. Use for questions that "
+            "require understanding beyond simple text reading."
+        ),
         system_prompt=CFG.LLM_FILE_EXTRACTOR_SYSTEM_PROMPT,
         tools=[read_from_file, search_files],
+        auto_summarize=False,
+        remember_history=False,
     )
     payload = json.dumps(
         {
             "instruction": query,
             "file_path": abs_path,
-            "file_content": llm_rate_limitter.clip_prompt(file_content, token_limit),
+            "file_content": llm_rate_limitter.clip_prompt(
+                file_content, token_threshold
+            ),
         }
     )
     return await _analyze_file(ctx, payload)

zrb/builtin/llm/tool/note.py

@@ -5,10 +5,12 @@ from zrb.config.llm_context.config import llm_context_config
 
 def read_long_term_note() -> str:
     """
-    Reads the global long-term note, shared across all projects and conversations.
+    Retrieves the GLOBAL long-term memory shared across ALL sessions and projects.
+
+    CRITICAL: Consult this first for user preferences, facts, and cross-project context.
 
     Returns:
-        str: The content of the long-term note.
+        str: The current global note content.
     """
     contexts = llm_context_config.get_notes()
     return contexts.get("/", "")
@@ -16,28 +18,39 @@ def read_long_term_note() -> str:
 
 def write_long_term_note(content: str) -> str:
     """
-    Writes or overwrites the global long-term note.
-    Use to remember key user preferences, goals, or facts relevant across all projects.
+    Persists CRITICAL facts to the GLOBAL long-term memory.
+
+    USE EAGERLY to save or update:
+    - User preferences (e.g., "I prefer Python", "No unit tests").
+    - User information (e.g., user name, user email address).
+    - Important facts (e.g., "My API key is in .env").
+    - Cross-project goals.
+    - Anything that will be useful for future interaction across projects.
+
+    WARNING: This OVERWRITES the entire global note.
 
     Args:
-        content (str): The information to save (overwrites entire note).
+        content (str): The text to strictly memorize.
 
     Returns:
-        str: A confirmation message.
+        str: Confirmation message.
     """
     llm_context_config.write_note(content, "/")
-    return "Long term note saved"
+    return "Global long-term note saved."
 
 
 def read_contextual_note(path: str | None = None) -> str:
     """
-    Reads a contextual note for a specific file or directory.
+    Retrieves LOCAL memory specific to a file or directory path.
+
+    Use to recall project-specific architecture, code summaries, or past decisions
+    relevant to the current working location.
 
     Args:
-        path (str | None): The file or directory path. Defaults to current working directory.
+        path (str | None): Target file/dir. Defaults to current working directory (CWD).
 
     Returns:
-        str: The content of the contextual note.
+        str: The local note content for the path.
     """
     if path is None:
         path = os.getcwd()
@@ -48,17 +61,24 @@ def read_contextual_note(path: str | None = None) -> str:
 
 def write_contextual_note(content: str, path: str | None = None) -> str:
     """
-    Writes or overwrites a note for a specific file or directory.
-    Use to save findings, summaries, or conclusions about a part of the project.
+    Persists LOCAL facts specific to a file or directory.
+
+    USE EAGERLY to save or update:
+    - Architectural patterns for this project/directory.
+    - Summaries of large files or directories.
+    - Specific guidelines for this project.
+    - Anything related to this directory that will be useful for future interaction.
+
+    WARNING: This OVERWRITES the note for the specific path.
 
     Args:
-        content (str): The information to save (overwrites any existing note).
-        path (str | None): The file or directory path. Defaults to current working directory.
+        content (str): The text to memorize for this location.
+        path (str | None): Target file/dir. Defaults to CWD.
 
     Returns:
-        str: A confirmation message.
+        str: Confirmation message.
     """
     if path is None:
         path = os.getcwd()
     llm_context_config.write_note(content, path)
-    return f"Contextual note saved to {path}"
+    return f"Contextual note saved for: {path}"

zrb/builtin/llm/tool/rag.py

@@ -45,22 +45,31 @@ def create_rag_from_directory(
     openai_embedding_model: str | None = None,
 ):
     """
-    Create a powerful RAG (Retrieval-Augmented Generation) tool for querying a local knowledge base.
+    Create a powerful RAG (Retrieval-Augmented Generation) tool for querying a local
+    knowledge base.
 
-    This factory function generates a tool that performs semantic search over a directory of documents. It automatically indexes the documents into a vector database (ChromaDB) and keeps it updated as files change.
+    This factory function generates a tool that performs semantic search over a directory of
+    documents. It automatically indexes the documents into a vector database (ChromaDB) and
+    keeps it updated as files change.
 
-    The generated tool is ideal for answering questions based on a specific set of documents, such as project documentation or internal wikis.
+    The generated tool is ideal for answering questions based on a specific set of documents,
+    such as project documentation or internal wikis.
 
     Args:
         tool_name (str): The name for the generated RAG tool (e.g., "search_project_docs").
-        tool_description (str): A clear description of what the tool does and when to use it. This is what the LLM will see.
-        document_dir_path (str, optional): The path to the directory containing the documents to be indexed.
-        vector_db_path (str, optional): The path where the ChromaDB vector database will be stored.
-        vector_db_collection (str, optional): The name of the collection within the vector database.
+        tool_description (str): A clear description of what the tool does and when to use it.
+            This is what the LLM will see.
+        document_dir_path (str, optional): The path to the directory containing the documents
+            to be indexed.
+        vector_db_path (str, optional): The path where the ChromaDB vector database will be
+            stored.
+        vector_db_collection (str, optional): The name of the collection within the vector
+            database.
         chunk_size (int, optional): The size of text chunks for embedding.
         overlap (int, optional): The overlap between text chunks.
         max_result_count (int, optional): The maximum number of search results to return.
-        file_reader (list[RAGFileReader], optional): A list of custom file readers for specific file types.
+        file_reader (list[RAGFileReader], optional): A list of custom file readers for
+            specific file types.
         openai_api_key (str, optional): Your OpenAI API key for generating embeddings.
         openai_base_url (str, optional): An optional base URL for the OpenAI API.
         openai_embedding_model (str, optional): The embedding model to use.

zrb/builtin/llm/tool/sub_agent.py

@@ -1,14 +1,21 @@
+import json
 from collections.abc import Callable
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Coroutine
 
 from zrb.context.any_context import AnyContext
-from zrb.task.llm.agent import create_agent_instance, run_agent_iteration
+from zrb.task.llm.agent import create_agent_instance
+from zrb.task.llm.agent_runner import run_agent_iteration
 from zrb.task.llm.config import get_model, get_model_settings
 from zrb.task.llm.prompt import get_system_and_user_prompt
+from zrb.task.llm.subagent_conversation_history import (
+    get_ctx_subagent_history,
+    set_ctx_subagent_history,
+)
 
 if TYPE_CHECKING:
     from pydantic_ai import Tool
+    from pydantic_ai._agent_graph import HistoryProcessor
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
     from pydantic_ai.toolsets import AbstractToolset
@@ -25,29 +32,41 @@ def create_sub_agent_tool(
     tools: "list[ToolOrCallable]" = [],
     toolsets: list["AbstractToolset[None]"] = [],
     yolo_mode: bool | list[str] | None = None,
+    history_processors: list["HistoryProcessor"] | None = None,
     log_indent_level: int = 2,
-) -> Callable[[AnyContext, str], Coroutine[Any, Any, dict[str, Any]]]:
+    agent_name: str | None = None,
+    auto_summarize: bool = True,
+    remember_history: bool = True,
+) -> Callable[[AnyContext, str], Coroutine[Any, Any, Any]]:
     """
     Create a tool that is another AI agent, capable of handling complex, multi-step sub-tasks.
 
-    This factory function generates a tool that, when used, spins up a temporary, specialized AI agent. This "sub-agent" has its own system prompt, tools, and context, allowing it to focus on accomplishing a specific task without being distracted by the main conversation.
+    This factory function generates a tool that, when used, spins up a temporary, specialized
+    AI agent. This "sub-agent" has its own system prompt, tools, and context, allowing it to
+    focus on accomplishing a specific task without being distracted by the main conversation.
 
     This is ideal for delegating complex tasks like analyzing a file or a repository.
 
     Args:
         tool_name (str): The name for the generated sub-agent tool.
-        tool_description (str): A clear description of the sub-agent's purpose and when to use it. This is what the LLM will see.
-        system_prompt (str, optional): The system prompt that will guide the sub-agent's behavior.
+        tool_description (str): A clear description of the sub-agent's purpose and when to
+            use it. This is what the LLM will see.
+        system_prompt (str, optional): The system prompt that will guide the sub-agent's
+            behavior.
         model (str | Model, optional): The language model the sub-agent will use.
         model_settings (ModelSettings, optional): Specific settings for the sub-agent's model.
-        tools (list, optional): A list of tools that will be exclusively available to the sub-agent.
+        tools (list, optional): A list of tools that will be exclusively available to the
+            sub-agent.
         toolsets (list, optional): A list of Toolsets for the sub-agent.
 
     Returns:
-        An asynchronous function that serves as the sub-agent tool. When called, it runs the sub-agent with a given query and returns its final result.
+        An asynchronous function that serves as the sub-agent tool. When called, it runs the
+        sub-agent with a given query and returns its final result.
     """
+    if agent_name is None:
+        agent_name = f"{tool_name}_agent"
 
-    async def run_sub_agent(ctx: AnyContext, query: str) -> dict[str, Any]:
+    async def run_sub_agent(ctx: AnyContext, query: str) -> Any:
         """
         Runs the sub-agent with the given query.
         """
@@ -66,7 +85,6 @@ def create_sub_agent_tool(
             ctx=ctx,
             model_settings_attr=model_settings,
         )
-
         if system_prompt is None:
             resolved_system_prompt, query = get_system_and_user_prompt(
                 ctx=ctx,
@@ -86,24 +104,32 @@ def create_sub_agent_tool(
             tools=tools,
             toolsets=toolsets,
             yolo_mode=yolo_mode,
+            history_processors=history_processors,
+            auto_summarize=auto_summarize,
         )
-
         sub_agent_run = None
         # Run the sub-agent iteration
-        # Start with an empty history for the sub-agent
+        history_list = (
+            get_ctx_subagent_history(ctx, agent_name) if remember_history else []
+        )
         sub_agent_run = await run_agent_iteration(
             ctx=ctx,
             agent=sub_agent_agent,
             user_prompt=query,
             attachments=[],
-            history_list=[],
+            history_list=history_list,
             log_indent_level=log_indent_level,
         )
-
         # Return the sub-agent's final message content
         if sub_agent_run and sub_agent_run.result:
             # Return the final message content
-            return {"result": sub_agent_run.result.output}
+            if remember_history:
+                set_ctx_subagent_history(
+                    ctx,
+                    agent_name,
+                    json.loads(sub_agent_run.result.all_messages_json()),
+                )
+            return sub_agent_run.result.output
         ctx.log_warning("Sub-agent run did not produce a result.")
         raise ValueError(f"{tool_name} not returning any result")
 
@@ -117,7 +143,7 @@ def create_sub_agent_tool(
             query (str): The query or task for the sub-agent.
 
         Returns:
-            dict[str, Any]: The final response or result from the sub-agent.
+            Any: The final response or result from the sub-agent.
         """
     ).strip()