maximem-synap-semantic-kernel 0.2.2__tar.gz → 0.2.3__tar.gz

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: maximem-synap-semantic-kernel
-Version: 0.2.2
+Version: 0.2.3
 Summary: Synap memory integration for Microsoft Semantic Kernel
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
 Requires-Dist: maximem-synap>=0.5.3
-Requires-Dist: maximem-synap-integrations-common>=0.2.1
+Requires-Dist: maximem-synap-integrations-common>=0.2.3
 Requires-Dist: semantic-kernel>=1.37
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/maximem_synap_semantic_kernel.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: maximem-synap-semantic-kernel
-Version: 0.2.2
+Version: 0.2.3
 Summary: Synap memory integration for Microsoft Semantic Kernel
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
 Requires-Dist: maximem-synap>=0.5.3
-Requires-Dist: maximem-synap-integrations-common>=0.2.1
+Requires-Dist: maximem-synap-integrations-common>=0.2.3
 Requires-Dist: semantic-kernel>=1.37
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/maximem_synap_semantic_kernel.egg-info/SOURCES.txt

@@ -5,9 +5,11 @@ maximem_synap_semantic_kernel.egg-info/dependency_links.txt
 maximem_synap_semantic_kernel.egg-info/requires.txt
 maximem_synap_semantic_kernel.egg-info/top_level.txt
 synap_semantic_kernel/__init__.py
+synap_semantic_kernel/history.py
 synap_semantic_kernel/plugin.py
 synap_semantic_kernel/short_term.py
 synap_semantic_kernel/stream.py
+tests/test_history.py
 tests/test_plugin.py
 tests/test_short_term.py
 tests/test_stream.py

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/maximem_synap_semantic_kernel.egg-info/requires.txt

@@ -1,5 +1,5 @@
 maximem-synap>=0.5.3
-maximem-synap-integrations-common>=0.2.1
+maximem-synap-integrations-common>=0.2.3
 semantic-kernel>=1.37
 
 [dev]

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maximem-synap-semantic-kernel"
-version = "0.2.2"
+version = "0.2.3"
 description = "Synap memory integration for Microsoft Semantic Kernel"
 requires-python = ">=3.11"
 license = "Apache-2.0"
-dependencies = ["maximem-synap>=0.5.3", "maximem-synap-integrations-common>=0.2.1", "semantic-kernel>=1.37"]
+dependencies = ["maximem-synap>=0.5.3", "maximem-synap-integrations-common>=0.2.3", "semantic-kernel>=1.37"]
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "pytest-asyncio>=0.21"]

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/synap_semantic_kernel/__init__.py

@@ -8,11 +8,18 @@ Three plug-in points:
    message that carries Synap's recent-conversation block.
 3. **Report the turn** — :class:`SynapAgentThread` reports user and
    assistant turns, and :func:`attach_synap_filters` reports the tool call
-   and its result. Turns go out on the Synap stream when one is open and
-   fall back to ``sdk.conversation.record_message`` when it is not; never
-   both.
+   and its result. The first turn opens the Synap gRPC stream, and turns go
+   out on it; they fall back to ``sdk.conversation.record_message`` only if
+   the stream cannot open, never both. ``SYNAP_AUTO_LISTEN=false`` keeps
+   everything on REST.
+
+:class:`SynapAgentThread` also sends the model Synap's compaction in place of
+the earlier turns once Synap has compacted the conversation
+(:class:`SynapChatHistoryReducer`). Semantic Kernel's own reducers stay in
+place and are the fallback when Synap has nothing.
 """
 
+from synap_semantic_kernel.history import SynapChatHistoryReducer
 from synap_semantic_kernel.plugin import SynapPlugin
 from synap_semantic_kernel.short_term import synap_st_chat_message
 from synap_semantic_kernel.stream import (
@@ -25,6 +32,7 @@ __all__ = [
     "SynapPlugin",
     "synap_st_chat_message",
     "SynapAgentThread",
+    "SynapChatHistoryReducer",
     "attach_synap_filters",
     "synap_auto_function_filter",
 ]

maximem_synap_semantic_kernel-0.2.3/synap_semantic_kernel/history.py

@@ -0,0 +1,98 @@
+"""Put Synap's compaction where Semantic Kernel's chat history goes.
+
+Semantic Kernel's answer to a long chat is a :class:`ChatHistoryReducer`: a
+``ChatHistory`` with a ``reduce()`` that truncates or summarizes it in place.
+:class:`SynapChatHistoryReducer` is one whose ``reduce()`` asks Synap for the
+conversation as Synap holds it and, once a compaction exists, replaces every
+turn before the current one with the compaction block and the turns after it
+(:func:`synap_integrations_common.splice_history`). With no compaction yet, or
+on any error, it changes nothing: the history stays as the framework has it.
+
+A reducer only runs when somebody calls ``reduce()``. Semantic Kernel's agents
+never do: ``ChatCompletionAgent`` builds the model's input from
+``thread.get_messages()`` and does not reduce, and ``ChatHistoryAgentThread``
+appends with the synchronous ``add_message``, which skips ``auto_reduce``.
+:class:`~synap_semantic_kernel.SynapAgentThread` therefore calls ``reduce()``
+itself, at the top of ``get_messages()``, which is the one place every agent
+call reads the history.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional, Sequence
+
+from pydantic import Field
+from semantic_kernel.contents import AuthorRole, ChatMessageContent, TextContent
+from semantic_kernel.contents.history_reducer.chat_history_reducer import ChatHistoryReducer
+
+from synap_integrations_common import fetch_compacted_history, splice_history
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_ROLES = (AuthorRole.SYSTEM, AuthorRole.DEVELOPER)
+
+
+def _role(message: ChatMessageContent) -> str:
+    if message.role in _SYSTEM_ROLES:
+        return "system"
+    if message.role == AuthorRole.USER:
+        return "user"
+    if message.role == AuthorRole.ASSISTANT:
+        return "assistant"
+    return "other"
+
+
+def _text(message: ChatMessageContent) -> str:
+    """Every text block, not just the first (``.content`` drops the rest)."""
+    parts = [item.text for item in message.items if isinstance(item, TextContent) and item.text]
+    return "".join(parts) if parts else (message.content or "")
+
+
+def _make(role: str, text: str) -> ChatMessageContent:
+    author = {"system": AuthorRole.SYSTEM, "assistant": AuthorRole.ASSISTANT}.get(role, AuthorRole.USER)
+    return ChatMessageContent(role=author, content=text)
+
+
+async def splice_messages(
+    sdk: Any, conversation_id: str, messages: Sequence[ChatMessageContent],
+) -> Optional[List[ChatMessageContent]]:
+    """The messages with Synap's compaction in place of the earlier turns, or
+    None when Synap has nothing to replace them with. Never raises."""
+    history = await fetch_compacted_history(sdk, conversation_id)
+    if history is None:
+        return None
+    try:
+        return splice_history(
+            messages, history, role_of=_role, text_of=_text, make_message=_make,
+        )
+    except Exception:  # noqa: BLE001 — the framework's own history still stands
+        logger.warning("synap semantic-kernel: splice failed (conversation_id=%s)",
+                       conversation_id, exc_info=True)
+        return None
+
+
+class SynapChatHistoryReducer(ChatHistoryReducer):
+    """A ``ChatHistory`` that swaps in Synap's compaction when reduced.
+
+    Use it anywhere Semantic Kernel takes a ``ChatHistory``; call
+    ``await history.reduce()`` before a model call. :class:`SynapAgentThread`
+    does that for you.
+
+    ``reduce()`` returns the history when it changed it and ``None`` when it
+    did not, as Semantic Kernel's own reducers do.
+    """
+
+    sdk: Any = Field(exclude=True)
+    conversation_id: str
+    target_count: int = Field(default=1, gt=0)
+
+    async def reduce(self) -> Optional["SynapChatHistoryReducer"]:
+        spliced = await splice_messages(self.sdk, self.conversation_id, self.messages)
+        if spliced is None:
+            return None
+        self.messages = spliced
+        return self
+
+
+__all__ = ["SynapChatHistoryReducer", "splice_messages"]

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/synap_semantic_kernel/short_term.py

@@ -18,6 +18,12 @@ Quality contract identical to the LangGraph adapter:
 - Empty ST is a no-op — never wipes the user's system text.
 - Returns ``None`` when both ST and ``system`` are empty so callers can
   skip the system message cleanly.
+
+The ST block carries the recent turns. It is for a call that sends the model
+no history of its own; next to one, those turns would go out twice. Pass the
+history you are sending to the factory and the block is left out when it holds
+any turns. A :class:`SynapAgentThread` already sends Synap's compaction in
+place of the earlier turns, so it needs neither.
 """
 
 from __future__ import annotations
@@ -25,7 +31,7 @@ from __future__ import annotations
 import logging
 from typing import Awaitable, Callable, Literal, Optional
 
-from semantic_kernel.contents import AuthorRole, ChatMessageContent
+from semantic_kernel.contents import AuthorRole, ChatHistory, ChatMessageContent
 from maximem_synap import MaximemSynapSDK
 from synap_integrations_common import (
     SynapIntegrationError,
@@ -119,7 +125,7 @@ def synap_st_chat_message(
     preamble_open: Optional[str] = _DEFAULT_OPEN,
     preamble_close: Optional[str] = _DEFAULT_CLOSE,
     on_error: _OnError = "fallback",
-) -> Callable[[], Awaitable[Optional[ChatMessageContent]]]:
+) -> Callable[..., Awaitable[Optional[ChatMessageContent]]]:
     """Return an async factory producing a combined system ``ChatMessageContent``.
 
     Call the returned coroutine to get a
@@ -127,6 +133,10 @@ def synap_st_chat_message(
     is ``<ST block in preamble tags>\\n\\n<system>``. Returns ``None``
     when both inputs are empty.
 
+    The coroutine takes an optional ``chat_history``: the history you are about
+    to send. When it holds user or assistant turns the ST block (which carries
+    the recent turns) is left out and only ``system`` is returned.
+
     Args:
         sdk: Initialised :class:`MaximemSynapSDK`.
         conversation_id: Synap conversation ID. **Required.**
@@ -161,8 +171,13 @@ def synap_st_chat_message(
         sdk, conversation_id, style, on_error, "synap_st_chat_message"
     )
 
-    async def _factory() -> Optional[ChatMessageContent]:
-        st_block = await _fetch_st_block(
+    async def _factory(
+        chat_history: Optional[ChatHistory] = None,
+    ) -> Optional[ChatMessageContent]:
+        sends_turns = chat_history is not None and any(
+            m.role in (AuthorRole.USER, AuthorRole.ASSISTANT) for m in chat_history.messages
+        )
+        st_block = "" if sends_turns else await _fetch_st_block(
             sdk,
             conversation_id,
             style,

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/synap_semantic_kernel/stream.py

@@ -18,8 +18,13 @@ two places, and a caller wires both:
 ``user_message`` and ``assistant_message`` from the stream itself
 (``grpc/servicer.py``, ``_persist_message``), so reporting a turn AND calling
 ``sdk.conversation.record_message`` writes it twice and extracts it twice.
-:func:`report_turn` returns whether it actually went out, which is what makes
-the choice decidable rather than guessed.
+:func:`record_turn` makes that choice, and the first turn opens the stream
+when none is running (``SYNAP_AUTO_LISTEN=false`` turns that off).
+
+**Synap's compaction replaces Semantic Kernel's.** The thread is also where the
+agent reads its history (``get_messages``), so once Synap has compacted the
+conversation the model is sent the compaction block and the turns after it in
+place of the earlier turns (see :mod:`synap_semantic_kernel.history`).
 
 Tool calls, tool results and reasoning are anticipation hints. The server does
 not persist them, so they have no REST fallback and no double-write to avoid.
@@ -34,7 +39,7 @@ from __future__ import annotations
 
 import json
 import logging
-from typing import Any, Awaitable, Callable, Optional
+from typing import Any, AsyncIterable, Awaitable, Callable, Optional
 
 from semantic_kernel.agents import ChatHistoryAgentThread
 from semantic_kernel.contents import (
@@ -50,15 +55,17 @@ from semantic_kernel.contents.kernel_content import KernelContent
 from semantic_kernel.filters import FilterTypes
 
 from maximem_synap import MaximemSynapSDK
-from synap_integrations_common import wrap_sdk_errors_async
+from synap_integrations_common import is_synap_history
 from synap_integrations_common.stream_events import (
     end_session,
+    record_turn,
     report_reasoning,
     report_tool_call,
     report_tool_result,
-    report_turn,
 )
 
+from synap_semantic_kernel.history import SynapChatHistoryReducer, splice_messages
+
 logger = logging.getLogger(__name__)
 
 
@@ -173,7 +180,8 @@ def _carries_tool_traffic(message: ChatMessageContent) -> bool:
 
 
 class SynapAgentThread(ChatHistoryAgentThread):
-    """A ``ChatHistoryAgentThread`` that reports each turn to Synap.
+    """A ``ChatHistoryAgentThread`` that reports each turn to Synap and sends
+    the model Synap's compaction once there is one.
 
     Drop it in where you would pass a plain thread::
 
@@ -193,8 +201,12 @@ class SynapAgentThread(ChatHistoryAgentThread):
             a B2C instance (user_context_isolation=equals_customer): the server
             rejects a call carrying one with HTTP 400. Leave it unset there.
             Empty string means customer-less.
-        chat_history / thread_id: passed straight through to
-            :class:`ChatHistoryAgentThread`.
+        chat_history: the thread's history. Left unset it is a
+            :class:`SynapChatHistoryReducer`, which Synap's compaction replaces
+            turns in. Pass your own (a Semantic Kernel reducer, say) and it
+            stays as it is: the model is still sent Synap's compaction in place
+            of the earlier turns, but your history is not rewritten.
+        thread_id: passed straight through to :class:`ChatHistoryAgentThread`.
     """
 
     def __init__(
@@ -213,6 +225,8 @@ class SynapAgentThread(ChatHistoryAgentThread):
             raise ValueError("SynapAgentThread requires a non-empty conversation_id")
         if not user_id:
             raise ValueError("SynapAgentThread requires a non-empty user_id")
+        if chat_history is None:
+            chat_history = SynapChatHistoryReducer(sdk=sdk, conversation_id=conversation_id)
         super().__init__(chat_history=chat_history, thread_id=thread_id)
         self._sdk = sdk
         self._synap_conversation_id = conversation_id
@@ -240,6 +254,23 @@ class SynapAgentThread(ChatHistoryAgentThread):
                 self._synap_conversation_id, exc, exc_info=True,
             )
 
+    async def get_messages(self) -> AsyncIterable[ChatMessageContent]:
+        """The history the agent sends the model: Synap's compaction in place of
+        the turns before the current one, once Synap has compacted the
+        conversation; the framework's own messages otherwise."""
+        ours = isinstance(self._chat_history, SynapChatHistoryReducer)
+        if ours:
+            await self._chat_history.reduce()  # never raises: see splice_messages
+        # Raises on a deleted thread, as the base class does.
+        messages = [message async for message in super().get_messages()]
+        if not ours:
+            spliced = await splice_messages(
+                self._sdk, self._synap_conversation_id, messages)
+            if spliced is not None:
+                messages = spliced
+        for message in messages:
+            yield message
+
     async def _delete(self) -> None:
         """Deleting the thread ends the Synap session for its conversation."""
         await end_session(self._sdk, self._synap_conversation_id)
@@ -268,40 +299,22 @@ class SynapAgentThread(ChatHistoryAgentThread):
             # so reporting it here would extract the same words twice.
             return
         text = _turn_text(message)
-        if not text:
+        if not text or is_synap_history(text):
             return
         await self._record_turn(
             "user" if role == AuthorRole.USER else "assistant", text
         )
 
     async def _record_turn(self, role: str, content: str) -> None:
-        # ⚠ Stream first, REST only for what the stream did not take, never
-        # both: the server persists the turn from the stream itself, so a
-        # `record_message` on top of a delivered event stores it twice and
-        # extracts it twice.
-        if await report_turn(
+        # Stream first (opened if need be), REST only if the stream cannot
+        # carry it, never both: the server persists the turn from the stream
+        # itself, so a `record_message` on top of a delivered event stores it
+        # twice and extracts it twice.
+        await record_turn(
             self._sdk, role=role, content=content,
             conversation_id=self._synap_conversation_id,
             user_id=self._synap_user_id, customer_id=self._synap_customer_id,
-        ):
-            return
-        # The one swallow point is `_on_new_message`; everything below it is
-        # free to raise, and `wrap_sdk_errors_async` adds the operation name
-        # and the ids to the log on the way past.
-        async with wrap_sdk_errors_async(
-            "semantic_kernel.record_turn",
-            logger,
-            conversation_id=self._synap_conversation_id,
-            user_id=self._synap_user_id,
-            role=role,
-        ):
-            await self._sdk.conversation.record_message(
-                conversation_id=self._synap_conversation_id,
-                role=role,
-                content=content,
-                user_id=self._synap_user_id,
-                customer_id=self._synap_customer_id,
-            )
+        )
 
 
 # ─── the tool call and its result ───────────────────────────────────────

maximem_synap_semantic_kernel-0.2.3/tests/test_history.py

@@ -0,0 +1,261 @@
+"""Synap's compaction reaches the model through Semantic Kernel's thread.
+
+These run a real ``ChatCompletionAgent`` on a service that records exactly the
+chat history it was sent, so they prove the framework reads the history through
+the seam, not that a stand-in does.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any, List
+from unittest.mock import AsyncMock
+
+import pytest
+from semantic_kernel.agents import ChatCompletionAgent
+from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
+from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
+from semantic_kernel.contents import AuthorRole, ChatHistory, ChatMessageContent
+from semantic_kernel.contents.history_reducer.chat_history_truncation_reducer import (
+    ChatHistoryTruncationReducer,
+)
+
+from synap_integrations_common import set_auto_listen
+from synap_semantic_kernel import (
+    SynapAgentThread,
+    SynapChatHistoryReducer,
+    synap_st_chat_message,
+)
+
+BLOCK = "## Conversation so far (compacted 2026-10-22)\nThe user is planning a trip to Lisbon."
+
+
+class RecordingService(ChatCompletionClientBase):
+    """Answers "ok" and keeps what it was sent."""
+
+    ai_model_id: str = "fake"
+    sent: List[List[ChatMessageContent]] = []
+
+    async def _inner_get_chat_message_contents(self, chat_history, settings):
+        self.sent.append(list(chat_history.messages))
+        return [ChatMessageContent(role=AuthorRole.ASSISTANT, content="ok")]
+
+    def get_prompt_execution_settings_class(self):
+        return PromptExecutionSettings
+
+    @property
+    def last(self) -> str:
+        return "\n".join(f"{m.role.value}:{m.content}" for m in self.sent[-1])
+
+
+class FakeInstance:
+    """Behaves like sdk.instance: listen() flips is_listening on."""
+
+    def __init__(self):
+        self.is_listening = False
+        self.listen_calls = 0
+        self.send_message = AsyncMock()
+        self.record_tool_call = AsyncMock()
+        self.record_tool_result = AsyncMock()
+        self.record_thinking = AsyncMock()
+        self.end_session = AsyncMock()
+        self._controller = SimpleNamespace(_transport=object())
+
+    async def listen(self):
+        self.listen_calls += 1
+        self.is_listening = True
+
+    async def stop_listening(self):
+        self.is_listening = False
+
+
+def make_sdk(compaction=True, recent=(("user", "flights?"), ("assistant", "TAP at 9am"))):
+    ctx = SimpleNamespace(context_block=None, history_block=None, recent_messages=[], compaction_id=None)
+    if compaction:
+        ctx = SimpleNamespace(
+            context_block=BLOCK, history_block=None, compaction_id="cmp_1",
+            recent_messages=[SimpleNamespace(role=r, content=c) for r, c in recent],
+        )
+    return SimpleNamespace(
+        instance=FakeInstance(),
+        _initialized=True,
+        conversation=SimpleNamespace(
+            record_message=AsyncMock(),
+            context=SimpleNamespace(get_context_for_prompt=AsyncMock(return_value=ctx)),
+        ),
+    )
+
+
+def earlier_turns() -> ChatHistory:
+    return ChatHistory(messages=[
+        ChatMessageContent(role=AuthorRole.USER, content="I want to visit Portugal"),
+        ChatMessageContent(role=AuthorRole.ASSISTANT, content="Great, when?"),
+        ChatMessageContent(role=AuthorRole.USER, content="In May, for a week"),
+        ChatMessageContent(role=AuthorRole.ASSISTANT, content="Lisbon is lovely in May."),
+    ])
+
+
+def agent_on(service):
+    return ChatCompletionAgent(service=service, name="travel", instructions="You are a travel agent.")
+
+
+def thread_for(sdk, **kw):
+    return SynapAgentThread(sdk, conversation_id="conv-1", user_id="u1", customer_id="c1", **kw)
+
+
+# ---------------------------------------------------------------------------
+# The seam, driven by the real framework
+# ---------------------------------------------------------------------------
+
+
+class TestCompactionReachesTheModel:
+    @pytest.mark.asyncio
+    async def test_the_default_thread_sends_the_compaction_in_place_of_earlier_turns(self):
+        svc = RecordingService(sent=[])
+        thread = thread_for(make_sdk(), chat_history=None)
+        for m in earlier_turns().messages:
+            await thread.on_new_message(m)
+        await agent_on(svc).get_response(messages="and the hotel?", thread=thread)
+        seen = svc.last
+        assert "The user is planning a trip to Lisbon" in seen
+        assert "<synap_conversation_history>" in seen
+        assert "I want to visit Portugal" not in seen
+        assert "In May, for a week" not in seen
+        assert "TAP at 9am" in seen
+        assert "and the hotel?" in seen
+        # the agent's own instructions are still first
+        assert svc.sent[-1][0].content == "You are a travel agent."
+
+    @pytest.mark.asyncio
+    async def test_the_default_history_is_the_synap_reducer(self):
+        assert isinstance(thread_for(make_sdk())._chat_history, SynapChatHistoryReducer)
+
+    @pytest.mark.asyncio
+    async def test_messages_are_untouched_when_synap_has_no_compaction(self):
+        svc = RecordingService(sent=[])
+        thread = thread_for(make_sdk(compaction=False))
+        for m in earlier_turns().messages:
+            await thread.on_new_message(m)
+        await agent_on(svc).get_response(messages="and the hotel?", thread=thread)
+        assert "I want to visit Portugal" in svc.last
+        assert "In May, for a week" in svc.last
+        assert "synap_conversation_history" not in svc.last
+
+    @pytest.mark.asyncio
+    async def test_messages_are_untouched_when_the_sdk_fails(self):
+        svc = RecordingService(sent=[])
+        sdk = make_sdk()
+        sdk.conversation.context.get_context_for_prompt = AsyncMock(side_effect=RuntimeError("down"))
+        thread = thread_for(sdk)
+        for m in earlier_turns().messages:
+            await thread.on_new_message(m)
+        await agent_on(svc).get_response(messages="and the hotel?", thread=thread)
+        assert "In May, for a week" in svc.last
+
+    @pytest.mark.asyncio
+    async def test_the_compaction_is_never_recorded_back_as_a_turn(self):
+        svc = RecordingService(sent=[])
+        sdk = make_sdk()
+        thread = thread_for(sdk)
+        for m in earlier_turns().messages:
+            await thread.on_new_message(m)
+        sdk.instance.send_message.reset_mock()
+        await agent_on(svc).get_response(messages="and the hotel?", thread=thread)
+        await agent_on(svc).get_response(messages="and the car?", thread=thread)
+        for call in sdk.instance.send_message.await_args_list:
+            assert "synap_conversation_history" not in call.kwargs["content"]
+        assert svc.last.count("<synap_conversation_history>") == 1
+
+    @pytest.mark.asyncio
+    async def test_a_callers_own_history_is_spliced_for_the_model_but_not_rewritten(self):
+        svc = RecordingService(sent=[])
+        mine = ChatHistoryTruncationReducer(target_count=50, threshold_count=10)
+        for m in earlier_turns().messages:
+            mine.add_message(m)
+        thread = thread_for(make_sdk(), chat_history=mine)
+        await agent_on(svc).get_response(messages="and the hotel?", thread=thread)
+        assert "The user is planning a trip to Lisbon" in svc.last
+        assert "In May, for a week" not in svc.last
+        stored = " ".join(str(m.content) for m in mine.messages)
+        assert "In May, for a week" in stored
+        assert "synap_conversation_history" not in stored
+
+    @pytest.mark.asyncio
+    async def test_the_reducer_on_its_own_replaces_in_place_and_reports_a_change(self):
+        history = SynapChatHistoryReducer(sdk=make_sdk(), conversation_id="conv-1")
+        for m in earlier_turns().messages:
+            history.add_message(m)
+        history.add_message(ChatMessageContent(role=AuthorRole.USER, content="and the hotel?"))
+        assert await history.reduce() is history
+        text = " ".join(str(m.content) for m in history.messages)
+        assert "Lisbon" in text and "In May, for a week" not in text and "and the hotel?" in text
+
+    @pytest.mark.asyncio
+    async def test_the_reducer_returns_none_when_there_is_nothing_to_replace(self):
+        history = SynapChatHistoryReducer(sdk=make_sdk(compaction=False), conversation_id="conv-1")
+        history.add_message(ChatMessageContent(role=AuthorRole.USER, content="hi"))
+        assert await history.reduce() is None
+        assert len(history.messages) == 1
+
+
+# ---------------------------------------------------------------------------
+# The ST message does not repeat turns the framework sends
+# ---------------------------------------------------------------------------
+
+
+class TestSTMessageDoesNotDuplicateTurns:
+    def _sdk(self):
+        sdk = make_sdk(compaction=False)
+        sdk.conversation.context.get_context_for_prompt = AsyncMock(return_value=SimpleNamespace(
+            available=True, formatted_context="User asked about Lisbon."))
+        return sdk
+
+    @pytest.mark.asyncio
+    async def test_with_no_history_the_block_is_sent(self):
+        msg = await synap_st_chat_message(self._sdk(), "conv-1", system="Be brief.")()
+        assert "User asked about Lisbon." in msg.content
+
+    @pytest.mark.asyncio
+    async def test_next_to_a_history_with_turns_only_the_system_text_is_sent(self):
+        sdk = self._sdk()
+        msg = await synap_st_chat_message(sdk, "conv-1", system="Be brief.")(earlier_turns())
+        assert msg.content == "Be brief."
+        sdk.conversation.context.get_context_for_prompt.assert_not_awaited()
+
+
+# ---------------------------------------------------------------------------
+# The stream is the default path: nobody called listen()
+# ---------------------------------------------------------------------------
+
+
+class TestStreamOpensByDefault:
+    @pytest.mark.asyncio
+    async def test_the_first_turn_opens_the_stream_and_both_turns_go_on_it(self):
+        svc = RecordingService(sent=[])
+        sdk = make_sdk(compaction=False)
+        assert sdk.instance.is_listening is False
+        await agent_on(svc).get_response(messages="where is my order", thread=thread_for(sdk))
+        assert sdk.instance.listen_calls == 1
+        sent = [(c.kwargs["event_type"], c.kwargs["content"])
+                for c in sdk.instance.send_message.await_args_list]
+        assert sent == [("user_message", "where is my order"), ("assistant_message", "ok")]
+        sdk.conversation.record_message.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_a_stream_that_will_not_open_falls_back_to_rest(self):
+        svc = RecordingService(sent=[])
+        sdk = make_sdk(compaction=False)
+        sdk.instance.listen = AsyncMock(side_effect=ConnectionError("no route"))
+        await agent_on(svc).get_response(messages="hi", thread=thread_for(sdk))
+        roles = [c.kwargs["role"] for c in sdk.conversation.record_message.await_args_list]
+        assert roles == ["user", "assistant"]
+        sdk.instance.send_message.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_opting_out_keeps_turns_on_rest_and_never_listens(self):
+        svc = RecordingService(sent=[])
+        sdk = make_sdk(compaction=False)
+        set_auto_listen(sdk, False)
+        await agent_on(svc).get_response(messages="hi", thread=thread_for(sdk))
+        assert sdk.instance.listen_calls == 0
+        assert sdk.conversation.record_message.await_count == 2

{maximem_synap_semantic_kernel-0.2.2 → maximem_synap_semantic_kernel-0.2.3}/tests/test_stream.py

@@ -5,7 +5,8 @@ model search and store memory, and short_term put a context block in the
 prompt, but nothing ever told Synap what was said. Anticipation saw an empty
 conversation.
 
-The rule these pin is "stream first, REST only as a fallback, never both".
+The rule these pin is "stream first (opened by the first turn), REST only as a
+fallback, never both".
 The server persists `user_message` and `assistant_message` from the stream
 itself, so a `record_message` on top of a delivered stream event writes the
 same turn twice and extracts it twice.
@@ -44,6 +45,7 @@ from semantic_kernel.functions import (
     kernel_function,
 )
 
+from synap_integrations_common import set_auto_listen
 from synap_semantic_kernel.stream import (
     SynapAgentThread,
     _tool_args,
@@ -64,6 +66,9 @@ _rebuild_auto_function_invocation_context()
 def _streaming_sdk(is_listening: bool = True):
     sdk = MagicMock()
     sdk.instance.is_listening = is_listening
+    if not is_listening:
+        # these tests are about the REST fallback; opening a stream is test_history's
+        set_auto_listen(sdk, False)
     sdk.instance.send_message = AsyncMock()
     sdk.instance.record_tool_call = AsyncMock()
     sdk.instance.record_tool_result = AsyncMock()