resolving comments

Author: Aayush Kataria

agent_memory_toolkit/aio/chat.py

@@ -146,8 +146,6 @@ def _build_kwargs(
             len(messages),
         )
         kwargs: dict[str, Any] = {"model": self._model, "messages": messages}
-        # Force temperature=1.0 across all callers — see chat.py for rationale.
-        kwargs["temperature"] = 1.0
         if response_format is not None:
             kwargs["response_format"] = response_format
         kwargs.update(extra)

agent_memory_toolkit/aio/cosmos_memory_client.py

@@ -124,6 +124,10 @@ async def close(self) -> None:
             self._turns_container_client = None
             self._counter_container_client = None
             self._store = None
+            self._pipeline = None
+        if self._processor is not None and not self._processor_explicit:
+            await self._close_maybe_async(self._processor)
+            self._processor = None
         await self._embeddings_client.close()
         await self._close_maybe_async(self._chat_client)
         for owns, cred in (
@@ -659,11 +663,12 @@ async def extract_memories(self, user_id: str, thread_id: str, recent_k: Optiona
     async def synthesize_procedural(self, user_id: str, *, force: bool = False) -> dict[str, Any]:
         processor = self._get_processor()
         if not isinstance(processor, AsyncInProcessProcessor):
-            return {
-                "status": "deferred",
-                "reason": "durable_auto_trigger",
-                "message": "Procedural synthesis runs reactively in the Function App; call get_procedural_prompt() later.",
-            }
+            raise NotImplementedError(
+                "Procedural synthesis runs automatically after reconcile in durable mode; "
+                "manual invocation via the SDK is not supported when the Durable Function "
+                "app is the active processor. Use get_procedural_prompt() to read the "
+                "latest synthesized prompt."
+            )
         return await processor.synthesize_procedural(user_id=user_id, force=force)
 
     async def generate_thread_summary(

agent_memory_toolkit/aio/processors/durable.py

@@ -99,12 +99,11 @@ async def synthesize_procedural(
         user_id: str,
         force: bool = False,
     ) -> dict[str, Any]:
-        logger.debug(
-            "AsyncDurableFunctionProcessor.synthesize_procedural deferred user_id=%s force=%s",
-            user_id,
-            force,
+        raise NotImplementedError(
+            "Procedural synthesis runs automatically after reconcile in durable mode; "
+            "manual invocation via the SDK is not supported when the Durable Function "
+            "app is the active processor."
         )
-        return {"status": "deferred", "reason": "durable_auto_trigger"}
 
     async def close(self) -> None:
         logger.debug("AsyncDurableFunctionProcessor.close no-op")

agent_memory_toolkit/aio/services/pipeline.py

@@ -43,6 +43,10 @@
     parse_llm_json,
 )
 from agent_memory_toolkit.prompts._schemas import response_format_for
+from agent_memory_toolkit.services.pipeline import (
+    PROCEDURAL_MAX_EPISODES,
+    PROCEDURAL_MAX_FACTS,
+)
 
 logger = get_logger("agent_memory_toolkit.pipeline.aio")
 
@@ -679,6 +683,14 @@ async def synthesize_procedural(
             for doc in behavioral_fact_docs
             if isinstance(doc.get("content"), str) and doc.get("content", "").strip()
         ]
+        if len(behavioral_fact_docs) > PROCEDURAL_MAX_FACTS:
+            logger.warning(
+                "synthesize_procedural truncating behavioral facts user_id=%s total=%d cap=%d",
+                user_id,
+                len(behavioral_fact_docs),
+                PROCEDURAL_MAX_FACTS,
+            )
+            behavioral_fact_docs = behavioral_fact_docs[:PROCEDURAL_MAX_FACTS]
         behavioral_fact_ids = [doc["id"] for doc in behavioral_fact_docs]
 
         episodic_docs = await self._container.query_items(
@@ -709,6 +721,14 @@ async def synthesize_procedural(
             if isinstance(doc.get("metadata", {}).get("lesson"), str)
             and doc.get("metadata", {}).get("lesson", "").strip()
         ]
+        if len(episodic_with_lessons) > PROCEDURAL_MAX_EPISODES:
+            logger.warning(
+                "synthesize_procedural truncating episodic lessons user_id=%s total=%d cap=%d",
+                user_id,
+                len(episodic_with_lessons),
+                PROCEDURAL_MAX_EPISODES,
+            )
+            episodic_with_lessons = episodic_with_lessons[:PROCEDURAL_MAX_EPISODES]
         source_episodic_ids = [doc["id"] for doc in episodic_with_lessons]
 
         current_source_ids = set(behavioral_fact_ids) | set(source_episodic_ids)

agent_memory_toolkit/aio/store/memory_store.py

@@ -540,12 +540,22 @@ async def list_tags(
 
     async def _mutate_tags(self, memory_id: str, user_id: str, thread_id: str, tags: list[str], *, add: bool) -> None:
         from azure.core import MatchConditions
-        from azure.cosmos.exceptions import CosmosAccessConditionFailedError
+        from azure.cosmos.exceptions import (
+            CosmosAccessConditionFailedError,
+            CosmosResourceNotFoundError,
+        )
 
         normalized = {t.strip().lower() for t in tags if t and t.strip()}
         attempts = 0
         while True:
-            doc = await self._container.read_item(item=memory_id, partition_key=[user_id, thread_id])
+            try:
+                doc = await self._container.read_item(item=memory_id, partition_key=[user_id, thread_id])
+                target_container = self._container
+            except CosmosResourceNotFoundError:
+                if self._turns_container is None:
+                    raise
+                doc = await self._turns_container.read_item(item=memory_id, partition_key=[user_id, thread_id])
+                target_container = self._turns_container
             existing_tags = set(doc.get("tags", []))
             if add:
                 existing_tags.update(normalized)
@@ -558,7 +568,7 @@ async def _mutate_tags(self, memory_id: str, user_id: str, thread_id: str, tags:
             if etag := doc.get("_etag"):
                 kwargs.update(match_condition=MatchConditions.IfNotModified, etag=etag)
             try:
-                await self._container.replace_item(**kwargs)
+                await target_container.replace_item(**kwargs)
                 return
             except CosmosAccessConditionFailedError as exc:
                 attempts += 1

agent_memory_toolkit/chat.py

@@ -154,17 +154,16 @@ def _build_kwargs(
             len(messages),
         )
         kwargs: dict[str, Any] = {"model": self._model, "messages": messages}
+        if response_format is not None:
+            kwargs["response_format"] = response_format
+        kwargs.update(extra)
         # Force temperature=1.0 across all callers. Newer Azure OpenAI models
         # (gpt-5.x family, o-series reasoning models) only accept the default
         # value (1.0) and reject any other; older models (gpt-4o, gpt-4o-mini)
         # accept 1.0 as a valid value. Hardcoding to 1.0 keeps behavior uniform
         # across the deployment matrix and lets prompt engineering — not a
         # sampling knob — be the sole control for output determinism.
         kwargs["temperature"] = 1.0
-        if response_format is not None:
-            kwargs["response_format"] = response_format
-        kwargs.update(extra)
-        kwargs["temperature"] = 1.0
         return kwargs
 
     def generate(

agent_memory_toolkit/cosmos_memory_client.py

@@ -113,6 +113,9 @@ def close(self) -> None:
             self._counter_container_client = None
             self._store = None
             self._pipeline = None
+        if self._processor is not None and not self._processor_explicit:
+            self._close_sync_closeable(self._processor)
+            self._processor = None
         self._close_sync_closeable(self._chat_client)
         self._close_sync_closeable(self._embeddings_client)
         for owns, cred in (
@@ -657,15 +660,14 @@ def extract_memories(
         return self._get_pipeline().extract_memories(user_id, thread_id, recent_k)
 
     def synthesize_procedural(self, user_id: str, *, force: bool = False) -> dict[str, Any]:
-        """Trigger synthesized procedural prompt generation for a user."""
         processor = self._get_processor()
         if not isinstance(processor, InProcessProcessor):
-            logger.debug("synthesize_procedural deferred to Function App auto-trigger user_id=%s", user_id)
-            return {
-                "status": "deferred",
-                "reason": "durable_auto_trigger",
-                "message": "Procedural synthesis runs reactively in the Function App; call get_procedural_prompt() later.",
-            }
+            raise NotImplementedError(
+                "Procedural synthesis runs automatically after reconcile in durable mode; "
+                "manual invocation via the SDK is not supported when the Durable Function "
+                "app is the active processor. Use get_procedural_prompt() to read the "
+                "latest synthesized prompt."
+            )
         return processor.synthesize_procedural(user_id=user_id, force=force)
 
     def generate_thread_summary(

agent_memory_toolkit/processors/durable.py

@@ -104,12 +104,11 @@ def synthesize_procedural(
         user_id: str,
         force: bool = False,
     ) -> dict[str, Any]:
-        logger.debug(
-            "DurableFunctionProcessor.synthesize_procedural deferred user_id=%s force=%s",
-            user_id,
-            force,
+        raise NotImplementedError(
+            "Procedural synthesis runs automatically after reconcile in durable mode; "
+            "manual invocation via the SDK is not supported when the Durable Function "
+            "app is the active processor."
         )
-        return {"status": "deferred", "reason": "durable_auto_trigger"}
 
     def close(self) -> None:
         logger.debug("DurableFunctionProcessor.close no-op")

agent_memory_toolkit/prompts/_schemas.py

@@ -174,42 +174,91 @@
 
 # ---------------------------------------------------------------------------
 # summarize.prompty — first-pass thread summary
+#
+# Mirrors the 6-field shape the prompty actually instructs the model to emit
+# (see ``summarize.prompty`` lines ~69-88). Strict mode would silently drop
+# every field outside this list; the consumer in ``services/pipeline.py``
+# reads ``parsed["overview"]`` and stores ``parsed`` whole under
+# ``metadata.structured_summary``, so the schema must carry the full shape.
 # ---------------------------------------------------------------------------
+_SUMMARY_ACTION_ITEM = {
+    "type": "object",
+    "properties": {
+        "owner": {"type": ["string", "null"]},
+        "task": {"type": "string"},
+        "deadline": {"type": ["string", "null"]},
+    },
+    "required": ["owner", "task", "deadline"],
+    "additionalProperties": False,
+}
+
 SUMMARIZE_SCHEMA: dict[str, Any] = {
     "type": "object",
     "properties": {
-        "summary": {"type": "string"},
+        "overview": {"type": "string"},
         "key_points": {"type": "array", "items": {"type": "string"}},
+        "decisions": {"type": "array", "items": {"type": "string"}},
+        "open_issues": {"type": "array", "items": {"type": "string"}},
+        "action_items": {"type": "array", "items": _SUMMARY_ACTION_ITEM},
         "topics": {"type": "array", "items": {"type": "string"}},
     },
-    "required": ["summary", "key_points", "topics"],
+    "required": [
+        "overview",
+        "key_points",
+        "decisions",
+        "open_issues",
+        "action_items",
+        "topics",
+    ],
     "additionalProperties": False,
 }
 
 
 # ---------------------------------------------------------------------------
 # summarize_update.prompty — incremental thread summary update
+# Same shape as the first-pass schema; both prompties emit the same payload.
 # ---------------------------------------------------------------------------
 SUMMARIZE_UPDATE_SCHEMA: dict[str, Any] = SUMMARIZE_SCHEMA
 
 
 # ---------------------------------------------------------------------------
 # user_summary.prompty — first-pass user profile
+#
+# Mirrors the 8 sections the prompty body documents (see
+# ``user_summary.prompty`` lines ~35-86 and the JSON example block). Each
+# section is a flat string array; the full ``parsed`` dict is persisted under
+# ``metadata.structured_summary`` and the ``content`` field is composed from
+# ``key_facts`` for vector retrieval.
 # ---------------------------------------------------------------------------
 USER_SUMMARY_SCHEMA: dict[str, Any] = {
     "type": "object",
     "properties": {
-        "summary": {"type": "string"},
-        "key_attributes": {"type": "array", "items": {"type": "string"}},
+        "key_facts": {"type": "array", "items": {"type": "string"}},
+        "personal_preferences": {"type": "array", "items": {"type": "string"}},
+        "account_environment": {"type": "array", "items": {"type": "string"}},
+        "goals_current_work": {"type": "array", "items": {"type": "string"}},
+        "behavioral_patterns": {"type": "array", "items": {"type": "string"}},
+        "compliance_requirements": {"type": "array", "items": {"type": "string"}},
+        "open_items": {"type": "array", "items": {"type": "string"}},
         "topics": {"type": "array", "items": {"type": "string"}},
     },
-    "required": ["summary", "key_attributes", "topics"],
+    "required": [
+        "key_facts",
+        "personal_preferences",
+        "account_environment",
+        "goals_current_work",
+        "behavioral_patterns",
+        "compliance_requirements",
+        "open_items",
+        "topics",
+    ],
     "additionalProperties": False,
 }
 
 
 # ---------------------------------------------------------------------------
 # user_summary_update.prompty — incremental user profile update
+# Same shape as the first-pass schema.
 # ---------------------------------------------------------------------------
 USER_SUMMARY_UPDATE_SCHEMA: dict[str, Any] = USER_SUMMARY_SCHEMA
 

agent_memory_toolkit/prompts/dedup.prompty

@@ -5,7 +5,6 @@ description: Reconcile a pool of active facts — collapse duplicates and resolv
 model:
   apiType: chat
   options:
-    temperature: 0.0
     seed: 43
     maxOutputTokens: 2000
     additionalProperties: