maximem-synap-haystack 0.2.0__tar.gz → 0.2.2__tar.gz

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: maximem-synap-haystack
-Version: 0.2.0
+Version: 0.2.2
 Summary: Synap memory integration for Haystack — SynapMemoryStore + retriever/writer components
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
-Requires-Dist: maximem-synap>=0.2.0
-Requires-Dist: maximem-synap-integrations-common>=0.1.0
+Requires-Dist: maximem-synap>=0.5.3
+Requires-Dist: maximem-synap-integrations-common>=0.2.3
 Requires-Dist: haystack-ai>=2.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/maximem_synap_haystack.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: maximem-synap-haystack
-Version: 0.2.0
+Version: 0.2.2
 Summary: Synap memory integration for Haystack — SynapMemoryStore + retriever/writer components
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
-Requires-Dist: maximem-synap>=0.2.0
-Requires-Dist: maximem-synap-integrations-common>=0.1.0
+Requires-Dist: maximem-synap>=0.5.3
+Requires-Dist: maximem-synap-integrations-common>=0.2.3
 Requires-Dist: haystack-ai>=2.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/maximem_synap_haystack.egg-info/SOURCES.txt

@@ -5,10 +5,13 @@ maximem_synap_haystack.egg-info/dependency_links.txt
 maximem_synap_haystack.egg-info/requires.txt
 maximem_synap_haystack.egg-info/top_level.txt
 synap_haystack/__init__.py
+synap_haystack/hooks.py
 synap_haystack/retriever.py
 synap_haystack/short_term.py
 synap_haystack/store.py
 synap_haystack/writer.py
+tests/test_default_path.py
+tests/test_hooks.py
 tests/test_retriever.py
 tests/test_short_term.py
 tests/test_store.py

maximem_synap_haystack-0.2.2/maximem_synap_haystack.egg-info/requires.txt

@@ -0,0 +1,7 @@
+maximem-synap>=0.5.3
+maximem-synap-integrations-common>=0.2.3
+haystack-ai>=2.0
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maximem-synap-haystack"
-version = "0.2.0"
+version = "0.2.2"
 description = "Synap memory integration for Haystack — SynapMemoryStore + retriever/writer components"
 requires-python = ">=3.11"
 license = "Apache-2.0"
-dependencies = ["maximem-synap>=0.2.0", "maximem-synap-integrations-common>=0.1.0", "haystack-ai>=2.0"]
+dependencies = ["maximem-synap>=0.5.3", "maximem-synap-integrations-common>=0.2.3", "haystack-ai>=2.0"]
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "pytest-asyncio>=0.21"]

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/synap_haystack/__init__.py

@@ -5,12 +5,20 @@ Store-centric, matching the official ``mem0-haystack`` shape:
 - :class:`SynapMemoryStore` — the memory store (a plain object, not a component)
   that owns all Synap SDK interaction. ``add_memories`` / ``search_memories`` /
   ``search_memories_as_single_message`` / ``delete_*`` + ``to_dict`` / ``from_dict``.
+  It is also a Haystack ``ChatMessageStore`` (``write_messages`` /
+  ``retrieve_messages`` / ``count_messages``), so an experimental ``Agent`` takes it
+  as ``chat_message_store=`` and loads Synap's compaction and the turns after it
+  instead of a ten-message window. Turns are written on the gRPC stream, which
+  the first one opens (``SYNAP_AUTO_LISTEN=false`` turns that off).
 - :class:`SynapMemoryRetriever` — ``@component`` returning ``ChatMessage``s
   (Mem0-shaped chat read path).
 - :class:`SynapRetriever` — ``@component`` returning ``Document``s (RAG read path).
 - :class:`SynapMemoryWriter` — ``@component`` that records conversation turns.
-- :class:`SynapShortTermContext` — ``@component`` for the short-term conversation
-  context pipeline.
+- :class:`SynapHistoryHook` / :class:`SynapRecordHook` — hooks for haystack-ai 3's
+  ``Agent(hooks=...)``: Synap's compaction in place of the earlier turns
+  (``before_llm``) and the run recorded on the stream (``after_run``).
+- :class:`SynapShortTermContext` — ``@component`` emitting Synap's compaction of
+  the conversation for a prompt builder.
 
 The components accept a ready ``store=...`` or an ``sdk=...`` + scope kwargs.
 """
@@ -20,10 +28,17 @@ from synap_haystack.retriever import SynapMemoryRetriever, SynapRetriever
 from synap_haystack.writer import SynapMemoryWriter
 from synap_haystack.short_term import SynapShortTermContext
 
+try:  # needs haystack-ai 3's Agent hooks only at run time; importing is safe
+    from synap_haystack.hooks import SynapHistoryHook, SynapRecordHook
+except ImportError:  # pragma: no cover
+    SynapHistoryHook = SynapRecordHook = None  # type: ignore[assignment,misc]
+
 __all__ = [
     "SynapMemoryStore",
     "SynapMemoryRetriever",
     "SynapRetriever",
     "SynapMemoryWriter",
     "SynapShortTermContext",
+    "SynapHistoryHook",
+    "SynapRecordHook",
 ]

maximem_synap_haystack-0.2.2/synap_haystack/hooks.py

@@ -0,0 +1,127 @@
+"""Synap's compaction in place of a Haystack agent's earlier turns, via hooks.
+
+Haystack 3's ``Agent`` has no chat-message store. It takes ``hooks``: objects run
+at points in its loop that mutate the live ``State`` in place. That is where its
+own compaction lives (``haystack.hooks.compaction.CompactionHook``), and it is
+where Synap's goes:
+
+- :class:`SynapHistoryHook` on ``before_llm``: once Synap has compacted the
+  conversation, every turn before the current one in ``state["messages"]`` is
+  replaced by Synap's compaction (a system message) and the turns after it.
+  Until then, and whenever Synap cannot answer, the messages are left alone.
+  The agent's own compaction hooks can stay installed: with a short history they
+  do not fire, and they are the fallback.
+- :class:`SynapRecordHook` on ``after_run``: records the run's turns on Synap's
+  gRPC stream (opened by the first one) and reports its tool calls, results and
+  reasoning, through :meth:`SynapMemoryStore.write_messages`.
+
+::
+
+    store = SynapMemoryStore(sdk, user_id="alice")
+    agent = Agent(
+        chat_generator=...,
+        hooks={
+            "before_llm": [SynapHistoryHook(store, "conv-1")],
+            "after_run": [SynapRecordHook(store, "conv-1")],
+        },
+    )
+
+On haystack-ai 2.x use ``SynapMemoryStore`` as the experimental ``Agent``'s
+``chat_message_store`` instead; this module needs the 3.x ``Agent.hooks``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+from haystack.core.serialization import default_from_dict, default_to_dict
+from haystack.dataclasses import ChatMessage, ChatRole
+
+from synap_integrations_common import (
+    fetch_compacted_history,
+    run_async,
+    splice_history,
+)
+
+from synap_haystack.store import RECORDED_KEY, SynapMemoryStore
+
+logger = logging.getLogger(__name__)
+
+_ROLES = {ChatRole.USER: "user", ChatRole.ASSISTANT: "assistant", ChatRole.SYSTEM: "system"}
+
+
+def _role_of(message: ChatMessage) -> str:
+    return _ROLES.get(message.role, "other")
+
+
+def _text_of(message: ChatMessage) -> str:
+    return message.text or ""
+
+
+def _replace(_current: Any, new: Any) -> Any:
+    return new
+
+
+class _StoreHook:
+    """Shared construction and serialization for the two hooks."""
+
+    def __init__(self, store: SynapMemoryStore, chat_history_id: str) -> None:
+        if store is None:
+            raise ValueError(f"{type(self).__name__} requires a store")
+        if not chat_history_id or not str(chat_history_id).strip():
+            raise ValueError(f"{type(self).__name__} requires a non-empty chat_history_id")
+        self.store = store
+        self.chat_history_id = chat_history_id
+
+    def to_dict(self) -> Dict[str, Any]:
+        return default_to_dict(self, store=self.store.to_dict(), chat_history_id=self.chat_history_id)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "_StoreHook":
+        init = dict(data.get("init_parameters", {}))
+        init["store"] = SynapMemoryStore.from_dict(init["store"])
+        return default_from_dict(cls, {**data, "init_parameters": init})
+
+
+class SynapHistoryHook(_StoreHook):
+    """``before_llm`` hook: Synap's compaction in place of the earlier turns."""
+
+    def run(self, state: Any) -> None:
+        run_async(self.run_async(state))
+
+    async def run_async(self, state: Any) -> None:
+        messages = list(state.get("messages") or [])
+        if not any(_role_of(m) == "user" for m in messages):
+            return
+        history = await fetch_compacted_history(self.store.sdk, self.chat_history_id)
+        if history is None:
+            return
+
+        def make(role: str, text: str) -> ChatMessage:
+            if role == "system":
+                return ChatMessage.from_system(text)
+            meta = {RECORDED_KEY: self.chat_history_id}  # Synap already has it
+            return (ChatMessage.from_assistant(text, meta=meta) if role == "assistant"
+                    else ChatMessage.from_user(text, meta=meta))
+
+        try:
+            spliced = splice_history(messages, history, role_of=_role_of, text_of=_text_of,
+                                     make_message=make)
+        except Exception:  # noqa: BLE001 — the agent's own messages still stand
+            logger.warning("synap: could not splice the compacted history", exc_info=True)
+            return
+        state.set("messages", spliced, handler_override=_replace)
+
+
+class SynapRecordHook(_StoreHook):
+    """``after_run`` hook: record the run on Synap, each message once."""
+
+    def run(self, state: Any) -> None:
+        self.store.write_messages(self.chat_history_id, list(state.get("messages") or []))
+
+    async def run_async(self, state: Any) -> None:
+        await self.store.awrite_messages(self.chat_history_id, list(state.get("messages") or []))
+
+
+__all__ = ["SynapHistoryHook", "SynapRecordHook"]

{maximem_synap_haystack-0.2.0 → maximem_synap_haystack-0.2.2}/synap_haystack/short_term.py

@@ -5,8 +5,14 @@ Mirrors the LangGraph template, adapted to Haystack's
 ``sdk.conversation.context.get_context_for_prompt`` (cache-first behind
 ``SYNAP_SDK_ST_AUTHORITATIVE``).
 
-Exposes :class:`SynapShortTermContext` — a component that emits the
-formatted Synap short-term context string on its ``synap_st`` output.
+Exposes :class:`SynapShortTermContext` — a component that emits Synap's
+compaction of the conversation, as a string, on its ``synap_st`` output. It is
+the compaction only: the turns after it are the ones your pipeline already
+passes (a chat history, an agent's messages), and Synap's ``formatted_context``
+carries them too, so a block built from it showed every recent turn twice. Until
+the conversation has been compacted the block is empty. (An agent should use
+``SynapMemoryStore`` as its ``chat_message_store`` instead, which replaces the
+history it loads.)
 Wire it before your prompt builder, then reference ``{synap_st}`` (or
 your prompt builder's variable name) in the template. The component
 re-fetches on every pipeline run, so ST stays fresh.
@@ -18,7 +24,7 @@ Quality contract identical to the LangGraph adapter:
   raise abort the whole pipeline. The default ``on_error="fallback"``
   emits the bare user system text (or empty string) on SDK failure,
   with an ERROR log. ``on_error="raise"`` surfaces failures.
-- Empty ST is a no-op — never wipes the user's system text.
+- No compaction yet is a no-op — never wipes the user's system text.
 """
 
 from __future__ import annotations
@@ -141,8 +147,14 @@ class SynapShortTermContext:
                     conversation_id=self.conversation_id,
                     style=self.style,
                 )
-            if getattr(response, "available", False):
-                st_block = (getattr(response, "formatted_context", None) or "").strip()
+            compaction = getattr(response, "context_block", None)
+            if getattr(response, "available", True) is not False and isinstance(compaction, str) \
+                    and compaction.strip():
+                parts = [compaction.strip()]
+                found = getattr(response, "history_block", None)
+                if isinstance(found, str) and found.strip():
+                    parts.append(found.strip())
+                st_block = "\n\n".join(parts)
         except SynapIntegrationError:
             if self.on_error == "raise":
                 raise