deepanalysts 0.2.2__tar.gz → 0.2.4__tar.gz

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.2
+Version: 0.2.4
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT
-Project-URL: Homepage, https://github.com/SKE-Labs/embient-cli
-Project-URL: Documentation, https://github.com/SKE-Labs/embient-cli/tree/main/libs/deepanalysts
-Project-URL: Repository, https://github.com/SKE-Labs/embient-cli.git
-Project-URL: Issues, https://github.com/SKE-Labs/embient-cli/issues
+Project-URL: Homepage, https://github.com/SKE-Labs/deepalpha-cli
+Project-URL: Documentation, https://github.com/SKE-Labs/deepalpha-cli/tree/main/libs/deepanalysts
+Project-URL: Repository, https://github.com/SKE-Labs/deepalpha-cli.git
+Project-URL: Issues, https://github.com/SKE-Labs/deepalpha-cli/issues
 Keywords: langchain,langgraph,agents,middleware,ai,trading
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -57,7 +57,7 @@ Deep Analysts provides a complete middleware stack for LangChain agents:
 - **Backends**: Store (LangGraph BaseStore), Sandbox (subprocess execution), Composite (path-based routing)
 - **API Integration**: Basement client for syncing skills/memories to cloud
 
-Uses only langchain, langgraph, and standard libraries (no external embient dependencies).
+Uses only langchain, langgraph, and standard libraries (no external deepalpha dependencies).
 
 ## Usage
 
@@ -196,7 +196,7 @@ middleware_stack = [
 from deepanalysts.clients import BasementClient
 
 client = BasementClient(
-    base_url="https://basement.embient.ai",
+    base_url="https://basement.deepalpha.mn",
     token="jwt-token",
 )
 

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/README.md

@@ -22,7 +22,7 @@ Deep Analysts provides a complete middleware stack for LangChain agents:
 - **Backends**: Store (LangGraph BaseStore), Sandbox (subprocess execution), Composite (path-based routing)
 - **API Integration**: Basement client for syncing skills/memories to cloud
 
-Uses only langchain, langgraph, and standard libraries (no external embient dependencies).
+Uses only langchain, langgraph, and standard libraries (no external deepalpha dependencies).
 
 ## Usage
 
@@ -161,7 +161,7 @@ middleware_stack = [
 from deepanalysts.clients import BasementClient
 
 client = BasementClient(
-    base_url="https://basement.embient.ai",
+    base_url="https://basement.deepalpha.mn",
     token="jwt-token",
 )
 

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts/backends/sandbox.py

@@ -88,9 +88,9 @@ os.makedirs(parent_dir, exist_ok=True)
 
 with open(file_path, 'w') as f:
     f.write(content)
-" <<'__EMBIENT_EOF__'
+" <<'__DEEPALPHA_EOF__'
 {payload_b64}
-__EMBIENT_EOF__"""
+__DEEPALPHA_EOF__"""
 
 # Use heredoc to pass edit parameters via stdin to avoid ARG_MAX limits.
 # Stdin format: base64-encoded JSON with {{"path": str, "old": str, "new": str}}.
@@ -146,9 +146,9 @@ with open(file_path, 'w') as f:
     f.write(result)
 
 print(count)
-" <<'__EMBIENT_EOF__'
+" <<'__DEEPALPHA_EOF__'
 {payload_b64}
-__EMBIENT_EOF__"""
+__DEEPALPHA_EOF__"""
 
 _READ_COMMAND_TEMPLATE = """python3 -c "
 import os

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts/clients/basement.py

@@ -1,7 +1,7 @@
 """Basement API client for skills and memories.
 
 This provides a generic client interface that can be configured for either
-cloud (park) or local (embient-cli) usage.
+cloud (park) or local (deepalpha-cli) usage.
 """
 
 from __future__ import annotations
@@ -15,7 +15,7 @@ import httpx
 logger = logging.getLogger(__name__)
 
 # Default API endpoint (can be overridden via BASEMENT_API env var)
-DEFAULT_BASEMENT_API = os.environ.get("BASEMENT_API", "https://basement.embient.ai")
+DEFAULT_BASEMENT_API = os.environ.get("BASEMENT_API", "https://basement.deepalpha.mn")
 
 
 @runtime_checkable
@@ -52,7 +52,7 @@ class BasementClient:
         """Initialize the client.
 
         Args:
-            base_url: API base URL (defaults to basement.embient.ai)
+            base_url: API base URL (defaults to basement.deepalpha.mn)
             token: Static JWT token to use
             token_provider: Callable that returns JWT token dynamically
             timeout: Request timeout in seconds

deepanalysts-0.2.4/deepanalysts/middleware/_utils.py

@@ -0,0 +1,82 @@
+"""Utility functions for middleware."""
+
+from __future__ import annotations
+
+from langchain_core.messages import SystemMessage
+
+# Key used in SystemMessage.additional_kwargs to store section names.
+# Parallel to content_blocks: sections[i] names blocks[i].
+SECTIONS_KEY = "_prompt_sections"
+
+
+def _preserve_kwargs(system_message: SystemMessage | None) -> dict:
+    """Return a copy of additional_kwargs from a system message, or empty dict."""
+    if system_message is None:
+        return {}
+    return dict(system_message.additional_kwargs)
+
+
+def append_to_system_message(
+    system_message: SystemMessage | None,
+    text: str,
+) -> SystemMessage:
+    """Append text to a system message.
+
+    Handles both string content and content blocks properly by using
+    content_blocks API which always returns a list.  Preserves
+    ``additional_kwargs`` (including section metadata) from the original
+    message.
+
+    Args:
+        system_message: Existing system message or None.
+        text: Text to add to the system message.
+
+    Returns:
+        New SystemMessage with the text appended.
+    """
+    new_content: list[str | dict[str, str]] = list(system_message.content_blocks) if system_message else []
+    if new_content:
+        text = f"\n\n{text}"
+    new_content.append({"type": "text", "text": text})
+    return SystemMessage(content=new_content, additional_kwargs=_preserve_kwargs(system_message))
+
+
+def insert_after_section(
+    system_message: SystemMessage | None,
+    text: str,
+    section_name: str,
+) -> SystemMessage:
+    """Insert a content block after a named section.
+
+    Section names are stored in ``additional_kwargs[SECTIONS_KEY]`` as a list
+    parallel to the content blocks.  If *section_name* is found, the new text
+    is inserted immediately after that block; otherwise the call falls back to
+    :func:`append_to_system_message`.
+
+    Args:
+        system_message: Existing system message (may carry section metadata).
+        text: Text to insert.
+        section_name: Name of the section to insert after.
+
+    Returns:
+        New SystemMessage with the text inserted at the correct position.
+    """
+    if system_message is None:
+        return append_to_system_message(None, text)
+
+    sections: list[str] = system_message.additional_kwargs.get(SECTIONS_KEY, [])
+    if section_name not in sections:
+        return append_to_system_message(system_message, text)
+
+    blocks: list[str | dict[str, str]] = list(system_message.content_blocks)
+    idx = sections.index(section_name)
+    insert_at = idx + 1
+
+    blocks.insert(insert_at, {"type": "text", "text": f"\n\n{text}"})
+
+    new_sections = list(sections)
+    new_sections.insert(insert_at, f"_after_{section_name}")
+
+    kwargs = _preserve_kwargs(system_message)
+    kwargs[SECTIONS_KEY] = new_sections
+    return SystemMessage(content=blocks, additional_kwargs=kwargs)

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts/middleware/memory.py

@@ -18,8 +18,8 @@ from deepanalysts.backends import CompositeBackend
 middleware = MemoryMiddleware(
     backend=backend,
     sources=[
-        "~/.embient/AGENTS.md",
-        "./.embient/AGENTS.md",
+        "~/.deepalpha/AGENTS.md",
+        "./.deepalpha/AGENTS.md",
     ],
 )
 
@@ -50,7 +50,7 @@ from typing import TYPE_CHECKING, Annotated, NotRequired, Protocol, TypedDict
 
 from langchain_core.runnables import RunnableConfig
 
-from deepanalysts.middleware._utils import append_to_system_message
+from deepanalysts.middleware._utils import append_to_system_message, insert_after_section
 
 if TYPE_CHECKING:
     from deepanalysts.backends.protocol import (
@@ -134,6 +134,7 @@ class MemoryMiddleware(AgentMiddleware):
         backend: BACKEND_TYPES | None = None,
         sources: list[str] | None = None,
         loader: MemoryLoaderProtocol | None = None,
+        insert_after: str | None = None,
     ) -> None:
         """Initialize the memory middleware.
 
@@ -141,15 +142,20 @@ class MemoryMiddleware(AgentMiddleware):
             backend: Backend instance or factory function that takes runtime
                      and returns a backend. Use a factory for StateBackend.
                      Optional if using loader mode.
-            sources: List of memory file paths to load (e.g., ["~/.embient/AGENTS.md",
-                     "./.embient/AGENTS.md"]). Display names are automatically derived
+            sources: List of memory file paths to load (e.g., ["~/.deepalpha/AGENTS.md",
+                     "./.deepalpha/AGENTS.md"]). Display names are automatically derived
                      from the paths. Sources are loaded in order. Optional if using loader.
             loader: Optional loader for API-based memory loading.
                     When provided, takes precedence over backend/sources.
+            insert_after: If set, insert the memory section after this named prompt
+                         section instead of appending at the end.  Section names are
+                         tracked via ``additional_kwargs["_prompt_sections"]`` on the
+                         ``SystemMessage``.  Falls back to append if not found.
         """
         self._backend = backend
         self.sources = sources or []
         self.loader = loader
+        self.insert_after = insert_after
         self.system_prompt_template = MEMORY_SYSTEM_PROMPT
 
     def _get_backend(self, state: MemoryState, runtime: Runtime, config: RunnableConfig) -> BackendProtocol:
@@ -358,6 +364,9 @@ class MemoryMiddleware(AgentMiddleware):
         instead of just string concatenation. Skips injection entirely
         when no memory content is loaded.
 
+        When ``insert_after`` is set, the memory section is inserted after
+        the named prompt section rather than appended at the end.
+
         Args:
             request: Model request to modify.
 
@@ -376,7 +385,12 @@ class MemoryMiddleware(AgentMiddleware):
             memory_contents=memory_contents,
         )
 
-        system_message = append_to_system_message(request.system_message, memory_section)
+        if self.insert_after:
+            system_message = insert_after_section(
+                request.system_message, memory_section, self.insert_after
+            )
+        else:
+            system_message = append_to_system_message(request.system_message, memory_section)
         return request.override(system_message=system_message)
 
     def wrap_model_call(

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts/middleware/skills.py

@@ -71,7 +71,7 @@ from langchain_core.runnables import RunnableConfig
 from langgraph.prebuilt import ToolRuntime
 from langgraph.runtime import Runtime
 
-from deepanalysts.middleware._utils import append_to_system_message
+from deepanalysts.middleware._utils import append_to_system_message, insert_after_section
 
 logger = logging.getLogger(__name__)
 
@@ -450,6 +450,7 @@ class SkillsMiddleware(AgentMiddleware):
         sources: list[str] | None = None,
         loader: SkillsLoaderProtocol | None = None,
         agent_name: str = "orchestrator",
+        insert_after: str | None = None,
     ) -> None:
         """Initialize the skills middleware.
 
@@ -462,11 +463,15 @@ class SkillsMiddleware(AgentMiddleware):
             loader: Optional loader for API-based skill loading.
                     When provided, takes precedence over backend/sources.
             agent_name: Agent name for filtering skills by target_agents (default: "orchestrator").
+            insert_after: If set, insert the skills section after this named prompt
+                         section instead of appending at the end.  Falls back to
+                         append if the section is not found.
         """
         self._backend = backend
         self.sources = sources or []
         self.loader = loader
         self.agent_name = agent_name
+        self.insert_after = insert_after
         self.system_prompt_template = SKILLS_SYSTEM_PROMPT
 
     def _get_backend(self, state: SkillsState, runtime: Runtime, config: RunnableConfig) -> BackendProtocol:
@@ -528,6 +533,9 @@ class SkillsMiddleware(AgentMiddleware):
         instead of just string concatenation. Skips injection entirely
         when no skills are available.
 
+        When ``insert_after`` is set, the skills section is inserted after
+        the named prompt section rather than appended at the end.
+
         Args:
             request: Model request to modify
 
@@ -546,7 +554,12 @@ class SkillsMiddleware(AgentMiddleware):
             skills_list=skills_list,
         )
 
-        system_message = append_to_system_message(request.system_message, skills_section)
+        if self.insert_after:
+            system_message = insert_after_section(
+                request.system_message, skills_section, self.insert_after
+            )
+        else:
+            system_message = append_to_system_message(request.system_message, skills_section)
         return request.override(system_message=system_message)
 
     def before_agent(self, state: SkillsState, runtime: Runtime, config: RunnableConfig) -> SkillsStateUpdate | None:

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.2
+Version: 0.2.4
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT
-Project-URL: Homepage, https://github.com/SKE-Labs/embient-cli
-Project-URL: Documentation, https://github.com/SKE-Labs/embient-cli/tree/main/libs/deepanalysts
-Project-URL: Repository, https://github.com/SKE-Labs/embient-cli.git
-Project-URL: Issues, https://github.com/SKE-Labs/embient-cli/issues
+Project-URL: Homepage, https://github.com/SKE-Labs/deepalpha-cli
+Project-URL: Documentation, https://github.com/SKE-Labs/deepalpha-cli/tree/main/libs/deepanalysts
+Project-URL: Repository, https://github.com/SKE-Labs/deepalpha-cli.git
+Project-URL: Issues, https://github.com/SKE-Labs/deepalpha-cli/issues
 Keywords: langchain,langgraph,agents,middleware,ai,trading
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -57,7 +57,7 @@ Deep Analysts provides a complete middleware stack for LangChain agents:
 - **Backends**: Store (LangGraph BaseStore), Sandbox (subprocess execution), Composite (path-based routing)
 - **API Integration**: Basement client for syncing skills/memories to cloud
 
-Uses only langchain, langgraph, and standard libraries (no external embient dependencies).
+Uses only langchain, langgraph, and standard libraries (no external deepalpha dependencies).
 
 ## Usage
 
@@ -196,7 +196,7 @@ middleware_stack = [
 from deepanalysts.clients import BasementClient
 
 client = BasementClient(
-    base_url="https://basement.embient.ai",
+    base_url="https://basement.deepalpha.mn",
     token="jwt-token",
 )
 

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/deepanalysts.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ deepanalysts/utils/retry.py
 tests/test_basement.py
 tests/test_composite_backend.py
 tests/test_filesystem_middleware.py
+tests/test_prompt_sections.py
 tests/test_sandbox_backend.py
 tests/test_skills_middleware.py
 tests/test_store_backend.py

{deepanalysts-0.2.2 → deepanalysts-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepanalysts"
-version = "0.2.2"
+version = "0.2.4"
 description = "LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support"
 readme = "README.md"
 license = { text = "MIT" }
@@ -26,10 +26,10 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/SKE-Labs/embient-cli"
-Documentation = "https://github.com/SKE-Labs/embient-cli/tree/main/libs/deepanalysts"
-Repository = "https://github.com/SKE-Labs/embient-cli.git"
-Issues = "https://github.com/SKE-Labs/embient-cli/issues"
+Homepage = "https://github.com/SKE-Labs/deepalpha-cli"
+Documentation = "https://github.com/SKE-Labs/deepalpha-cli/tree/main/libs/deepanalysts"
+Repository = "https://github.com/SKE-Labs/deepalpha-cli.git"
+Issues = "https://github.com/SKE-Labs/deepalpha-cli/issues"
 
 [project.optional-dependencies]
 postgres = [

deepanalysts-0.2.4/tests/test_prompt_sections.py

@@ -0,0 +1,177 @@
+"""Tests for section-aware system message utilities.
+
+Tests append_to_system_message (preserves additional_kwargs), insert_after_section,
+and SECTIONS_KEY constant from deepanalysts.middleware._utils.
+"""
+
+import pytest
+from langchain_core.messages import SystemMessage
+
+from deepanalysts.middleware._utils import (
+    SECTIONS_KEY,
+    append_to_system_message,
+    insert_after_section,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def empty_msg() -> SystemMessage:
+    """SystemMessage with no section metadata."""
+    return SystemMessage(content="plain text")
+
+
+@pytest.fixture
+def sectioned_msg() -> SystemMessage:
+    """SystemMessage with three named sections as content blocks."""
+    return SystemMessage(
+        content=[
+            {"type": "text", "text": "Base prompt"},
+            {"type": "text", "text": "Session context"},
+            {"type": "text", "text": "User account"},
+        ],
+        additional_kwargs={
+            SECTIONS_KEY: ["base", "session", "user_account"],
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# append_to_system_message
+# ---------------------------------------------------------------------------
+
+
+class TestAppendToSystemMessage:
+    def test_append_to_none_creates_message(self):
+        msg = append_to_system_message(None, "hello")
+        assert len(msg.content_blocks) == 1
+        assert msg.content_blocks[0]["text"] == "hello"
+
+    def test_append_adds_block(self, empty_msg: SystemMessage):
+        msg = append_to_system_message(empty_msg, "extra")
+        assert len(msg.content_blocks) == 2
+        assert msg.content_blocks[1]["text"] == "\n\nextra"
+
+    def test_preserves_additional_kwargs(self, sectioned_msg: SystemMessage):
+        msg = append_to_system_message(sectioned_msg, "appended")
+        assert SECTIONS_KEY in msg.additional_kwargs
+        assert msg.additional_kwargs[SECTIONS_KEY] == ["base", "session", "user_account"]
+
+    def test_preserves_other_kwargs(self):
+        original = SystemMessage(
+            content="text",
+            additional_kwargs={"custom_key": "custom_value", SECTIONS_KEY: ["a"]},
+        )
+        msg = append_to_system_message(original, "more")
+        assert msg.additional_kwargs["custom_key"] == "custom_value"
+        assert msg.additional_kwargs[SECTIONS_KEY] == ["a"]
+
+    def test_does_not_mutate_original(self, sectioned_msg: SystemMessage):
+        original_blocks = len(sectioned_msg.content_blocks)
+        append_to_system_message(sectioned_msg, "new stuff")
+        assert len(sectioned_msg.content_blocks) == original_blocks
+
+
+# ---------------------------------------------------------------------------
+# insert_after_section
+# ---------------------------------------------------------------------------
+
+
+class TestInsertAfterSection:
+    def test_inserts_after_named_section(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "Preferences", "user_account")
+        blocks = msg.content_blocks
+        assert len(blocks) == 4
+        # New block should be at index 3 (after user_account at index 2)
+        assert "Preferences" in blocks[3]["text"]
+
+    def test_inserts_after_first_section(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "After base", "base")
+        blocks = msg.content_blocks
+        assert len(blocks) == 4
+        assert "After base" in blocks[1]["text"]
+        # Original session should shift to index 2
+        assert blocks[2]["text"] == "Session context"
+
+    def test_inserts_after_middle_section(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "After session", "session")
+        blocks = msg.content_blocks
+        assert len(blocks) == 4
+        assert "After session" in blocks[2]["text"]
+        assert blocks[3]["text"] == "User account"
+
+    def test_updates_section_names(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "Prefs", "user_account")
+        sections = msg.additional_kwargs[SECTIONS_KEY]
+        assert sections == ["base", "session", "user_account", "_after_user_account"]
+
+    def test_falls_back_to_append_when_section_not_found(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "Fallback", "nonexistent")
+        blocks = msg.content_blocks
+        assert len(blocks) == 4
+        assert "Fallback" in blocks[-1]["text"]
+
+    def test_falls_back_to_append_on_none_message(self):
+        msg = insert_after_section(None, "New content", "any_section")
+        assert len(msg.content_blocks) == 1
+        assert "New content" in msg.content_blocks[0]["text"]
+
+    def test_falls_back_when_no_sections_metadata(self, empty_msg: SystemMessage):
+        msg = insert_after_section(empty_msg, "Content", "base")
+        # Should append (2 blocks: original + appended)
+        assert len(msg.content_blocks) == 2
+
+    def test_preserves_other_kwargs(self):
+        original = SystemMessage(
+            content=[{"type": "text", "text": "A"}],
+            additional_kwargs={
+                SECTIONS_KEY: ["a"],
+                "custom": "value",
+            },
+        )
+        msg = insert_after_section(original, "B", "a")
+        assert msg.additional_kwargs["custom"] == "value"
+
+    def test_does_not_mutate_original(self, sectioned_msg: SystemMessage):
+        original_blocks = len(sectioned_msg.content_blocks)
+        original_sections = list(sectioned_msg.additional_kwargs[SECTIONS_KEY])
+        insert_after_section(sectioned_msg, "New", "base")
+        assert len(sectioned_msg.content_blocks) == original_blocks
+        assert sectioned_msg.additional_kwargs[SECTIONS_KEY] == original_sections
+
+    def test_multiple_inserts_chain_correctly(self, sectioned_msg: SystemMessage):
+        """Two sequential inserts should both land in the right place."""
+        msg = insert_after_section(sectioned_msg, "After account", "user_account")
+        msg = insert_after_section(msg, "After session", "session")
+        sections = msg.additional_kwargs[SECTIONS_KEY]
+        assert sections == [
+            "base",
+            "session",
+            "_after_session",
+            "user_account",
+            "_after_user_account",
+        ]
+        assert len(msg.content_blocks) == 5
+
+    def test_prepends_newlines_to_inserted_text(self, sectioned_msg: SystemMessage):
+        msg = insert_after_section(sectioned_msg, "Content", "base")
+        inserted = msg.content_blocks[1]["text"]
+        assert inserted.startswith("\n\n")
+
+
+# ---------------------------------------------------------------------------
+# SECTIONS_KEY constant
+# ---------------------------------------------------------------------------
+
+
+class TestSectionsKey:
+    def test_key_is_string(self):
+        assert isinstance(SECTIONS_KEY, str)
+
+    def test_key_starts_with_underscore(self):
+        """Convention: private metadata keys start with underscore."""
+        assert SECTIONS_KEY.startswith("_")

deepanalysts-0.2.2/deepanalysts/middleware/_utils.py

@@ -1,26 +0,0 @@
-"""Utility functions for middleware."""
-
-from langchain_core.messages import SystemMessage
-
-
-def append_to_system_message(
-    system_message: SystemMessage | None,
-    text: str,
-) -> SystemMessage:
-    """Append text to a system message.
-
-    Handles both string content and content blocks properly by using
-    content_blocks API which always returns a list.
-
-    Args:
-        system_message: Existing system message or None.
-        text: Text to add to the system message.
-
-    Returns:
-        New SystemMessage with the text appended.
-    """
-    new_content: list[str | dict[str, str]] = list(system_message.content_blocks) if system_message else []
-    if new_content:
-        text = f"\n\n{text}"
-    new_content.append({"type": "text", "text": text})
-    return SystemMessage(content=new_content)