Python: [BREAKING] PR2 — Wire context provider pipeline, remove old types, update all consumers (#3850)

* PR2: Wire context provider pipeline and update all internal consumers

- Replace AgentThread with AgentSession across all packages
- Replace ContextProvider with BaseContextProvider across all packages
- Replace context_provider param with context_providers (Sequence)
- Replace thread= with session= in run() signatures
- Replace get_new_thread() with create_session()
- Add get_session(service_session_id) to agent interface
- DurableAgentThread -> DurableAgentSession
- Remove _notify_thread_of_new_messages from WorkflowAgent
- Wire before_run/after_run context provider pipeline in RawAgent
- Auto-inject InMemoryHistoryProvider when no providers configured

* fix: update all tests for context provider pipeline, fix lazy-loaders, remove old test files

* refactor: update all sample files for context provider pipeline (AgentThread→AgentSession, ContextProvider→BaseContextProvider)

* fix: update remaining ag-ui references (client docstring, getting_started sample)

* fix: make get_session service_session_id keyword-only to avoid confusion with session_id

* refactor: rename _RunContext.thread_messages to session_messages

* refactor: remove _threads.py, _memory.py, and old provider files; migrate devui to use plain message lists

* rename: remove _new_ prefix from test files

* refactor: rewrite SlidingWindowChatMessageStore as SlidingWindowHistoryProvider(InMemoryHistoryProvider)

* fix: read full history from session state directly instead of reaching into provider internals

* fix: update stale .pyi stubs, sample imports, and README references for new provider types

* fix: remove stale message_store, _notify_thread_of_new_messages, and session_id.key references in samples

* refactor: merge context_providers and sessions sample folders into sessions, remove aggregate_context_provider

* refactor: UserInfoMemory stores state in session.state instead of instance attributes

* feat: add Pydantic BaseModel support to session state serialization

Pydantic models stored in session.state are now automatically serialized
via model_dump() and restored via model_validate() during to_dict()/from_dict()
round-trips. Models are auto-registered on first serialization; use
register_state_type() for cold-start deserialization.

Also export register_state_type as a public API.

* fix mem0

* Update sample README links and descriptions for session terminology

- Replace 'thread' with 'session' in sample descriptions across all READMEs
- Update file links for renamed samples (mem0_sessions, redis_sessions, etc.)
- Fix Threads section → Sessions section in main samples/README.md
- Update tools, middleware, workflows, durabletask, azure_functions READMEs
- Update architecture diagrams in concepts/tools/README.md
- Update migration guides (autogen, semantic-kernel)

* Fix broken Redis README link to renamed sample

* Fix Mem0 OSS client search: pass scoping params as direct kwargs

AsyncMemory (OSS) expects user_id/agent_id/run_id as direct kwargs,
while AsyncMemoryClient (Platform) expects them in a filters dict.
Adds tests for both client types.

Port of fix from #3844 to new Mem0ContextProvider.

* Fix rebase issues: restore missing _conversation_state.py and checkpoint decode logic

- Add back _conversation_state.py (encode/decode_chat_messages) lost in rebase
- Fix on_checkpoint_restore to decode cache/conversation with decode_chat_messages
- Fix on_checkpoint_restore to use decode_checkpoint_value for pending requests
- Add tests/workflow/__init__.py for relative import support
- Fix test_agent_executor checkpoint selection (checkpoints[1] not superstep)

* Add STORES_BY_DEFAULT ClassVar to skip redundant InMemoryHistoryProvider injection

Chat clients that store history server-side by default (OpenAI Responses API,
Azure AI Agent) now declare STORES_BY_DEFAULT = True. The agent checks this
during auto-injection and skips InMemoryHistoryProvider unless the user
explicitly sets store=False.

* Fix broken markdown links in azure_ai and redis READMEs

* Fix getting-started samples to use session API instead of removed thread/ContextProvider API

* updates to workflow as agent

* fix group chat import

* Rename Thread→Session throughout, fix service_session_id propagation, remove stale AGUIThread

- Fix: Propagate conversation_id from ChatResponse back to session.service_session_id
  in both streaming and non-streaming paths in _agents.py
- Rename AgentThreadException → AgentSessionException
- Remove stale AGUIThread from ag_ui lazy-loader
- Rename use_service_thread → use_service_session in ag-ui package
- Rename test functions from *_thread_* to *_session_*
- Rename sample files from *_thread* to *_session*
- Update docstrings and comments: thread → session
- Update _mcp.py kwargs filter: add 'session' alongside 'thread'
- Fix ContinuationToken docstring example: thread=thread → session=session
- Fix _clients.py docstring: 'Agent threads' → 'Agent sessions'

* Fix broken markdown links after thread→session file renames

* fix azure ai test

python/packages/claude/agent_framework_claude/_agent.py

@@ -12,12 +12,13 @@ from agent_framework import (
     AgentMiddlewareTypes,
     AgentResponse,
     AgentResponseUpdate,
-    AgentThread,
+    AgentSession,
     BaseAgent,
+    BaseContextProvider,
     Content,
-    ContextProvider,
     FunctionTool,
     Message,
+    ResponseStream,
     get_logger,
     normalize_messages,
 )
@@ -184,9 +185,9 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         .. code-block:: python
 
             async with ClaudeAgent() as agent:
-                thread = agent.get_new_thread()
-                await agent.run("Remember my name is Alice", thread=thread)
-                response = await agent.run("What's my name?", thread=thread)
+                session = agent.create_session()
+                await agent.run("Remember my name is Alice", session=session)
+                response = await agent.run("What's my name?", session=session)
                 # Claude will remember "Alice" from the same session
 
         With Agent Framework tools:
@@ -214,7 +215,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         id: str | None = None,
         name: str | None = None,
         description: str | None = None,
-        context_provider: ContextProvider | None = None,
+        context_providers: Sequence[BaseContextProvider] | None = None,
         middleware: Sequence[AgentMiddlewareTypes] | None = None,
         tools: FunctionTool
         | Callable[..., Any]
@@ -237,7 +238,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
             id: Unique identifier for the agent.
             name: Name of the agent.
             description: Description of the agent.
-            context_provider: Context provider for the agent.
+            context_providers: Context providers for the agent.
             middleware: List of middleware.
             tools: Tools for the agent. Can be:
                 - Strings for built-in tools (e.g., "Read", "Write", "Bash", "Glob")
@@ -250,7 +251,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
             id=id,
             name=name,
             description=description,
-            context_provider=context_provider,
+            context_providers=context_providers,
             middleware=middleware,
         )
 
@@ -559,7 +560,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         messages: str | Message | Sequence[str | Message] | None = None,
         *,
         stream: Literal[True],
-        thread: AgentThread | None = None,
+        session: AgentSession | None = None,
         options: OptionsT | MutableMapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AsyncIterable[AgentResponseUpdate]: ...
@@ -570,7 +571,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         messages: str | Message | Sequence[str | Message] | None = None,
         *,
         stream: Literal[False] = ...,
-        thread: AgentThread | None = None,
+        session: AgentSession | None = None,
         options: OptionsT | MutableMapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AgentResponse[Any]: ...
@@ -580,7 +581,7 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         messages: str | Message | Sequence[str | Message] | None = None,
         *,
         stream: bool = False,
-        thread: AgentThread | None = None,
+        session: AgentSession | None = None,
         options: OptionsT | MutableMapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AsyncIterable[AgentResponseUpdate] | Awaitable[AgentResponse[Any]]:
@@ -592,46 +593,36 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
         Keyword Args:
             stream: If True, returns an async iterable of updates. If False (default),
                 returns an awaitable AgentResponse.
-            thread: The conversation thread. If thread has service_thread_id set,
+            session: The conversation session. If session has service_session_id set,
                 the agent will resume that session.
             options: Runtime options (model, permission_mode can be changed per-request).
             kwargs: Additional keyword arguments.
 
         Returns:
-            When stream=True: An AsyncIterable[AgentResponseUpdate] for streaming updates.
+            When stream=True: An ResponseStream for streaming updates.
             When stream=False: An Awaitable[AgentResponse] with the complete response.
         """
-        if stream:
-            return self._run_streaming(messages, thread=thread, options=options, **kwargs)
-        return self._run_non_streaming(messages, thread=thread, options=options, **kwargs)
-
-    async def _run_non_streaming(
-        self,
-        messages: str | Message | Sequence[str | Message] | None = None,
-        *,
-        thread: AgentThread | None = None,
-        options: OptionsT | MutableMapping[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> AgentResponse[Any]:
-        """Internal non-streaming implementation."""
-        thread = thread or self.get_new_thread()
-        return await AgentResponse.from_update_generator(
-            self._run_streaming(messages, thread=thread, options=options, **kwargs)
+        response = ResponseStream(
+            self._get_stream(messages, session=session, options=options, **kwargs),
+            finalizer=AgentResponse.from_updates,
         )
+        if stream:
+            return response
+        return response.get_final_response()
 
-    async def _run_streaming(
+    async def _get_stream(
         self,
         messages: str | Message | Sequence[str | Message] | None = None,
         *,
-        thread: AgentThread | None = None,
+        session: AgentSession | None = None,
         options: OptionsT | MutableMapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AsyncIterable[AgentResponseUpdate]:
         """Internal streaming implementation."""
-        thread = thread or self.get_new_thread()
+        session = session or self.create_session()
 
         # Ensure we're connected to the right session
-        await self._ensure_session(thread.service_thread_id)
+        await self._ensure_session(session.service_session_id)
 
         if not self._client:
             raise ServiceException("Claude SDK client not initialized.")
@@ -696,6 +687,6 @@ class ClaudeAgent(BaseAgent, Generic[OptionsT]):
                     raise ServiceException(f"Claude API error: {error_msg}")
                 session_id = message.session_id
 
-        # Update thread with session ID
+        # Update session with session ID
         if session_id:
-            thread.service_thread_id = session_id
+            session.service_session_id = session_id

python/packages/claude/tests/test_claude_agent.py

@@ -4,7 +4,7 @@ from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
-from agent_framework import AgentResponseUpdate, AgentThread, Content, Message, tool
+from agent_framework import AgentResponseUpdate, AgentSession, Content, Message, tool
 from agent_framework._settings import load_settings
 
 from agent_framework_claude import ClaudeAgent, ClaudeAgentOptions, ClaudeAgentSettings
@@ -267,12 +267,12 @@ class TestClaudeAgentRun:
 
         with patch("agent_framework_claude._agent.ClaudeSDKClient", return_value=mock_client):
             agent = ClaudeAgent()
-            thread = agent.get_new_thread()
-            await agent.run("Hello", thread=thread)
-            assert thread.service_thread_id == "test-session-id"
+            session = agent.create_session()
+            await agent.run("Hello", session=session)
+            assert session.service_session_id == "test-session-id"
 
-    async def test_run_with_thread(self) -> None:
-        """Test run with existing thread."""
+    async def test_run_with_session(self) -> None:
+        """Test run with existing session."""
         from claude_agent_sdk import AssistantMessage, ResultMessage, TextBlock
         from claude_agent_sdk.types import StreamEvent
 
@@ -302,9 +302,9 @@ class TestClaudeAgentRun:
 
         with patch("agent_framework_claude._agent.ClaudeSDKClient", return_value=mock_client):
             agent = ClaudeAgent()
-            thread = agent.get_new_thread()
-            thread.service_thread_id = "existing-session"
-            await agent.run("Hello", thread=thread)
+            session = agent.create_session()
+            session.service_session_id = "existing-session"
+            await agent.run("Hello", session=session)
 
 
 # region Test ClaudeAgent Run Stream
@@ -440,26 +440,18 @@ class TestClaudeAgentRunStream:
 class TestClaudeAgentSessionManagement:
     """Tests for ClaudeAgent session management."""
 
-    def test_get_new_thread(self) -> None:
-        """Test get_new_thread creates a new thread."""
+    def test_create_session(self) -> None:
+        """Test create_session creates a new session."""
         agent = ClaudeAgent()
-        thread = agent.get_new_thread()
-        assert isinstance(thread, AgentThread)
-        assert thread.service_thread_id is None
+        session = agent.create_session()
+        assert isinstance(session, AgentSession)
+        assert session.service_session_id is None
 
-    def test_get_new_thread_with_service_thread_id(self) -> None:
-        """Test get_new_thread with existing service_thread_id."""
+    def test_create_session_with_service_session_id(self) -> None:
+        """Test create_session with existing service_session_id."""
         agent = ClaudeAgent()
-        thread = agent.get_new_thread(service_thread_id="existing-session-123")
-        assert isinstance(thread, AgentThread)
-        assert thread.service_thread_id == "existing-session-123"
-
-    def test_thread_inherits_context_provider(self) -> None:
-        """Test that thread inherits context provider."""
-        mock_provider = MagicMock()
-        agent = ClaudeAgent(context_provider=mock_provider)
-        thread = agent.get_new_thread()
-        assert thread.context_provider == mock_provider
+        session = agent.create_session(session_id="existing-session-123")
+        assert isinstance(session, AgentSession)
 
     async def test_ensure_session_creates_client(self) -> None:
         """Test _ensure_session creates client when not started."""