temporary fixes to pass typecheck and old_versions CI tests

Author: habema

src/agents/__init__.py

@@ -23,7 +23,6 @@
     RunErrorDetails,
     UserError,
 )
-from .extensions.memory import SQLAlchemySession
 from .guardrail import (
     GuardrailFunctionOutput,
     InputGuardrail,
@@ -223,7 +222,6 @@ def enable_verbose_stdout_logging():
     "AgentHooks",
     "Session",
     "SQLiteSession",
-    "SQLAlchemySession",
     "RunContextWrapper",
     "TContext",
     "RunErrorDetails",

src/agents/extensions/memory/sqlalchemy_session.py

@@ -25,7 +25,7 @@
 import json
 from typing import Any
 
-from sqlalchemy import (  # type: ignore
+from sqlalchemy import (
     TIMESTAMP,
     Column,
     ForeignKey,
@@ -40,10 +40,10 @@
     text as sql_text,
     update,
 )
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine  # type: ignore
-from sqlalchemy.orm import sessionmaker  # type: ignore
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
+from sqlalchemy.ext.asyncio import async_sessionmaker
 
-from ...items import TResponseInputItem  # type: ignore
+from ...items import TResponseInputItem
 from ...memory.session import SessionABC
 
 
@@ -124,7 +124,7 @@ def __init__(
         )
 
         # Index for efficient retrieval of messages per session ordered by time
-        from sqlalchemy import Index  # type: ignore
+        from sqlalchemy import Index
 
         Index(
             f"idx_{messages_table}_session_time",
@@ -133,8 +133,8 @@ def __init__(
         )
 
         # Async session factory
-        self._session_factory: sessionmaker[AsyncSession] = sessionmaker(
-            self._engine, expire_on_commit=False, class_=AsyncSession
+        self._session_factory = async_sessionmaker(
+            self._engine, expire_on_commit=False
         )
 
         self._create_tables = create_tables
@@ -252,40 +252,28 @@ async def pop_item(self) -> TResponseInputItem | None:
         await self._ensure_tables()
         async with self._session_factory() as sess:
             async with sess.begin():
-                # First try dialects that support DELETE … RETURNING for atomicity
-                try:
-                    stmt = (
-                        delete(self._messages)
-                        .where(self._messages.c.session_id == self.session_id)
-                        .order_by(self._messages.c.created_at.desc())
-                        .limit(1)
-                        .returning(self._messages.c.message_data)
-                    )
-                    result = await sess.execute(stmt)
-                    row = result.scalar_one_or_none()
-                except Exception:  # pragma: no cover – fallback path
-                    # Fallback for dialects that don't support ORDER BY in DELETE
-                    subq = (
-                        select(self._messages.c.id)
-                        .where(self._messages.c.session_id == self.session_id)
-                        .order_by(self._messages.c.created_at.desc())
-                        .limit(1)
-                    )
-                    res = await sess.execute(subq)
-                    row_id = res.scalar_one_or_none()
-                    if row_id is None:
-                        return None
-                    # Fetch data before deleting
-                    res_data = await sess.execute(
-                        select(self._messages.c.message_data).where(self._messages.c.id == row_id)
-                    )
-                    row = res_data.scalar_one_or_none()
-                    await sess.execute(delete(self._messages).where(self._messages.c.id == row_id))
+                # Fallback for all dialects - get ID first, then delete
+                subq = (
+                    select(self._messages.c.id)
+                    .where(self._messages.c.session_id == self.session_id)
+                    .order_by(self._messages.c.created_at.desc())
+                    .limit(1)
+                )
+                res = await sess.execute(subq)
+                row_id = res.scalar_one_or_none()
+                if row_id is None:
+                    return None
+                # Fetch data before deleting
+                res_data = await sess.execute(
+                    select(self._messages.c.message_data).where(self._messages.c.id == row_id)
+                )
+                row = res_data.scalar_one_or_none()
+                await sess.execute(delete(self._messages).where(self._messages.c.id == row_id))
 
                 if row is None:
                     return None
                 try:
-                    return json.loads(row)
+                    return json.loads(row)  # type: ignore[no-any-return]
                 except json.JSONDecodeError:
                     return None
 

tests/extensions/memory/test_sqlalchemy_session.py

@@ -2,6 +2,8 @@
 
 import pytest
 
+pytest.importorskip("sqlalchemy")  # Skip tests if SQLAlchemy is not installed
+
 from agents import Agent, Runner, TResponseInputItem
 from agents.extensions.memory.sqlalchemy_session import SQLAlchemySession
 from tests.fake_model import FakeModel
@@ -58,6 +60,7 @@ async def test_runner_integration(agent: Agent):
     session = SQLAlchemySession.from_url(session_id, url=DB_URL)
 
     # First turn
+    assert isinstance(agent.model, FakeModel)
     agent.model.set_next_output([get_text_message("San Francisco")])
     result1 = await Runner.run(
         agent,
@@ -86,6 +89,7 @@ async def test_session_isolation(agent: Agent):
     session2 = SQLAlchemySession.from_url(session_id_2, url=DB_URL)
 
     # Interact with session 1
+    assert isinstance(agent.model, FakeModel)
     agent.model.set_next_output([get_text_message("I like cats.")])
     await Runner.run(agent, "I like cats.", session=session1)