fix: preserve legacy get_items semantics

Author: HuxleyHu98

src/agents/extensions/memory/advanced_sqlite_session.py

@@ -140,8 +140,8 @@ async def add_items(
     async def get_items(
         self,
         limit: int | None = None,
-        wrapper: RunContextWrapper[Any] | None = None,
         branch_id: str | None = None,
+        wrapper: RunContextWrapper[Any] | None = None,
     ) -> list[TResponseInputItem]:
         """Get items from current or specified branch.
 

src/agents/extensions/memory/encrypt_session.py

@@ -206,10 +206,16 @@ async def get_items(
         limit: int | None = None,
         wrapper: RunContextWrapper[Any] | None = None,
     ) -> list[TResponseInputItem]:
-        if wrapper is not None and _method_accepts_wrapper(self.underlying_session.get_items):
+        accepts_wrapper = wrapper is not None and _method_accepts_wrapper(
+            self.underlying_session.get_items
+        )
+        if limit is None:
+            if accepts_wrapper:
+                encrypted_items = await self.underlying_session.get_items(wrapper=wrapper)
+            else:
+                encrypted_items = await self.underlying_session.get_items()
+        elif accepts_wrapper:
             encrypted_items = await self.underlying_session.get_items(limit, wrapper=wrapper)
-        elif limit is None and not _method_accepts_limit(self.underlying_session.get_items):
-            encrypted_items = await self.underlying_session.get_items()
         else:
             encrypted_items = await self.underlying_session.get_items(limit)
         valid_items: list[TResponseInputItem] = []

src/agents/run_internal/session_persistence.py

@@ -82,10 +82,15 @@ async def _session_get_items(
     *,
     wrapper: RunContextWrapper[Any] | None = None,
 ) -> list[TResponseInputItem]:
-    if wrapper is not None and _session_method_accepts_wrapper(session.get_items):
-        return await session.get_items(limit=limit, wrapper=wrapper)
-    if limit is None and not _session_method_accepts_limit(session.get_items):
+    accepts_wrapper = wrapper is not None and _session_method_accepts_wrapper(session.get_items)
+
+    if limit is None:
+        if accepts_wrapper:
+            return await session.get_items(wrapper=wrapper)
         return await session.get_items()
+
+    if accepts_wrapper:
+        return await session.get_items(limit=limit, wrapper=wrapper)
     return await session.get_items(limit=limit)
 
 

tests/extensions/memory/test_advanced_sqlite_wrapper_compat.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from agents.extensions.memory.advanced_sqlite_session import AdvancedSQLiteSession
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_advanced_sqlite_get_items_preserves_branch_id_positional_argument() -> None:
+    with tempfile.TemporaryDirectory() as temp_dir:
+        db_path = Path(temp_dir) / "advanced.db"
+        session = AdvancedSQLiteSession(session_id="test", db_path=db_path, create_tables=True)
+
+        await session.add_items([
+            {"role": "user", "content": "main message"},
+        ])
+        branch_id = await session.create_branch_from_turn(1, "branch-a")
+        assert branch_id == "branch-a"
+        await session.add_items([
+            {"role": "user", "content": "branch message"},
+        ])
+        await session.switch_to_branch("main")
+
+        branch_items = await session.get_items(50, "branch-a")
+        contents = [item.get("content") for item in branch_items if isinstance(item, dict)]
+
+        assert "branch message" in contents
+        assert "main message" not in contents

tests/test_session.py

@@ -10,6 +10,7 @@
 from agents import Agent, RunConfig, Runner, SQLiteSession, TResponseInputItem
 from agents.memory.session import SessionABC
 from agents.run_context import RunContextWrapper
+from agents.run_internal.session_persistence import prepare_input_with_session
 
 from .fake_model import FakeModel
 from .test_responses import get_text_message
@@ -133,6 +134,27 @@ async def clear_session(self) -> None:
         self.items.clear()
 
 
+class DefaultLimitedSession:
+    session_id = "default-limited"
+
+    def __init__(self) -> None:
+        self.items: list[TResponseInputItem] = []
+        self.get_call_count = 0
+
+    async def get_items(self, limit: int = 1) -> list[TResponseInputItem]:
+        self.get_call_count += 1
+        return list(self.items[-limit:]) if limit > 0 else []
+
+    async def add_items(self, items: list[TResponseInputItem]) -> None:
+        self.items.extend(items)
+
+    async def pop_item(self) -> TResponseInputItem | None:
+        return self.items.pop() if self.items else None
+
+    async def clear_session(self) -> None:
+        self.items.clear()
+
+
 # Parametrized tests for different runner methods
 @pytest.mark.parametrize("runner_method", ["run", "run_sync", "run_streamed"])
 @pytest.mark.asyncio
@@ -296,6 +318,26 @@ async def test_legacy_session_without_limit_keyword_remains_compatible(runner_me
     assert session.items
 
 
+@pytest.mark.asyncio
+async def test_get_items_preserves_default_limit_when_none_is_unset() -> None:
+    session = DefaultLimitedSession()
+    session.items = [
+        {"role": "user", "content": "one"},
+        {"role": "assistant", "content": "two"},
+    ]
+
+    prepared_input, _ = await prepare_input_with_session(
+        "new",
+        session,
+        session_input_callback=None,
+    )
+
+    assert isinstance(prepared_input, list)
+    assert prepared_input[0]["content"] == "two"
+    assert prepared_input[1]["content"] == "new"
+    assert session.get_call_count == 1
+
+
 @pytest.mark.parametrize("runner_method", ["run", "run_sync", "run_streamed"])
 @pytest.mark.asyncio
 async def test_session_memory_different_sessions_parametrized(runner_method):