solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/agent/sac/patch_adk.py

@@ -7,9 +7,10 @@
 # Purpose: Fix event filtering and function response handling in LLM flows
 # =============================================================================
 import google.adk.flows.llm_flows.contents
+from google.adk.flows.llm_flows.contents import _contains_empty_content
 from google.adk.flows.llm_flows.contents import _is_event_belongs_to_branch
 from google.adk.flows.llm_flows.contents import _is_auth_event
-from google.adk.flows.llm_flows.contents import _convert_foreign_event
+from google.adk.flows.llm_flows.contents import _present_other_agent_message
 from google.adk.flows.llm_flows.contents import _is_other_agent_reply
 from google.adk.flows.llm_flows.contents import _rearrange_events_for_async_function_responses_in_history
 from google.adk.flows.llm_flows.contents import remove_client_function_call_id
@@ -39,16 +40,7 @@ def _patch_get_contents(
   # Parse the events, leaving the contents and the function calls and
   # responses from the current agent.
   for event in events:
-    if (
-        not event.content
-        or not event.content.role
-        or not event.content.parts
-        or (event.content.parts[0].text == '' and not event.content.parts[0].function_response)
-    ):
-      # Skip events without content, or generated neither by user nor by model
-      # or has empty text.
-      # E.g. events purely for mutating session states.
-
+    if _contains_empty_content(event):
       continue
     if not _is_event_belongs_to_branch(current_branch, event):
       # Skip events not belong to current branch.
@@ -56,11 +48,11 @@ def _patch_get_contents(
     if _is_auth_event(event):
       # Skip auth events.
       continue
-    filtered_events.append(
-        _convert_foreign_event(event)
-        if _is_other_agent_reply(agent_name, event)
-        else event
-    )
+    if _is_other_agent_reply(agent_name, event):
+      if converted_event := _present_other_agent_message(event):
+        filtered_events.append(converted_event)
+    else:
+      filtered_events.append(event)
 
   # Rearrange events for proper function call/response pairing
   result_events = filtered_events

solace_agent_mesh/agent/sac/task_execution_context.py

@@ -4,7 +4,10 @@ Encapsulates the runtime state for a single, in-flight agent task.
 
 import asyncio
 import threading
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from solace_ai_connector.common.message import Message as SolaceMessage
 
 
 class TaskExecutionContext:
@@ -33,17 +36,30 @@ class TaskExecutionContext:
         self.artifact_signals_to_return: List[Dict[str, Any]] = []
         self.event_loop: Optional[asyncio.AbstractEventLoop] = None
         self.lock: threading.Lock = threading.Lock()
-        
+        self.is_paused: bool = False  # Track if task is paused waiting for peer/auth
+
         # Token usage tracking
         self.total_input_tokens: int = 0
         self.total_output_tokens: int = 0
         self.total_cached_input_tokens: int = 0
         self.token_usage_by_model: Dict[str, Dict[str, int]] = {}
         self.token_usage_by_source: Dict[str, Dict[str, int]] = {}
-        
+
+        # Generic flags storage for task-level state
+        self._flags: Dict[str, Any] = {}
+
         # Generic security storage (enterprise use only)
         self._security_context: Dict[str, Any] = {}
 
+        # Original Solace message for ACK/NACK operations
+        # Stored here instead of a2a_context to avoid serialization issues
+        self._original_solace_message: Optional["SolaceMessage"] = None
+
+        # Turn tracking for proper spacing between LLM turns
+        self._current_invocation_id: Optional[str] = None
+        self._first_text_seen_in_turn: bool = False
+        self._need_spacing_before_next_text: bool = False
+
     def cancel(self) -> None:
         """Signals that the task should be cancelled."""
         self.cancellation_event.set()
@@ -52,6 +68,26 @@ class TaskExecutionContext:
         """Checks if the cancellation event has been set."""
         return self.cancellation_event.is_set()
 
+    def set_paused(self, paused: bool) -> None:
+        """
+        Marks the task as paused (waiting for peer response or user input).
+
+        Args:
+            paused: True if task is paused, False if resuming.
+        """
+        with self.lock:
+            self.is_paused = paused
+
+    def get_is_paused(self) -> bool:
+        """
+        Checks if the task is currently paused.
+
+        Returns:
+            True if task is paused (waiting for peer/auth), False otherwise.
+        """
+        with self.lock:
+            return self.is_paused
+
     def append_to_streaming_buffer(self, text: str) -> None:
         """Appends a chunk of text to the main streaming buffer."""
         with self.lock:
@@ -295,10 +331,116 @@ class TaskExecutionContext:
     def clear_security_data(self) -> None:
         """
         Clear all security data.
-        
+
         This method is provided for completeness but is not explicitly called.
         Security data is automatically cleaned up when the TaskExecutionContext
         is removed from active_tasks and garbage collected.
         """
         with self.lock:
             self._security_context.clear()
+
+    def set_original_solace_message(self, message: Optional["SolaceMessage"]) -> None:
+        """
+        Store the original Solace message for this task.
+
+        This message is used for ACK/NACK operations when the task completes.
+        Stored separately from a2a_context to avoid serialization issues when
+        the context is persisted to the ADK session state.
+
+        Args:
+            message: The Solace message that initiated this task, or None
+        """
+        with self.lock:
+            self._original_solace_message = message
+
+    def get_original_solace_message(self) -> Optional["SolaceMessage"]:
+        """
+        Retrieve the original Solace message for this task.
+
+        Returns:
+            The Solace message that initiated this task, or None if not available
+        """
+        with self.lock:
+            return self._original_solace_message
+
+    def check_and_update_invocation(self, new_invocation_id: str) -> bool:
+        """
+        Check if this is a new turn (different invocation_id) and update tracking.
+
+        Args:
+            new_invocation_id: The invocation_id from the current ADK event
+
+        Returns:
+            True if this is a new turn (invocation_id changed), False otherwise
+        """
+        with self.lock:
+            is_new_turn = (
+                self._current_invocation_id is not None
+                and self._current_invocation_id != new_invocation_id
+            )
+
+            if is_new_turn:
+                # Mark that we need spacing before the next text
+                self._need_spacing_before_next_text = True
+
+            if is_new_turn or self._current_invocation_id is None:
+                self._current_invocation_id = new_invocation_id
+                self._first_text_seen_in_turn = False
+
+            return is_new_turn
+
+    def is_first_text_in_turn(self) -> bool:
+        """
+        Check if this is the first text we're seeing in the current turn,
+        and mark it as seen.
+
+        Returns:
+            True if this is the first text in the turn, False otherwise
+        """
+        with self.lock:
+            if not self._first_text_seen_in_turn:
+                self._first_text_seen_in_turn = True
+                return True
+            return False
+
+    def should_add_turn_spacing(self) -> bool:
+        """
+        Check if we need to add spacing before the next text (because it's a new turn).
+        This flag is set when a new invocation starts and cleared after spacing is added.
+
+        Returns:
+            True if spacing should be added, False otherwise
+        """
+        with self.lock:
+            if self._need_spacing_before_next_text:
+                self._need_spacing_before_next_text = False
+                return True
+            return False
+
+    def set_flag(self, key: str, value: Any) -> None:
+        """
+        Set a task-level flag.
+
+        This method provides a generic mechanism for storing task-level state
+        that needs to persist across different parts of the task execution.
+
+        Args:
+            key: The flag name
+            value: The flag value
+        """
+        with self.lock:
+            self._flags[key] = value
+
+    def get_flag(self, key: str, default: Any = None) -> Any:
+        """
+        Get a task-level flag.
+
+        Args:
+            key: The flag name
+            default: Default value to return if flag not found
+
+        Returns:
+            The flag value, or default if not found
+        """
+        with self.lock:
+            return self._flags.get(key, default)

solace_agent_mesh/agent/tools/__init__.py

@@ -11,5 +11,8 @@ from . import general_agent_tools
 from . import audio_tools
 from . import image_tools
 from . import web_tools
+from . import time_tools
 from . import test_tools
+from . import deep_research_tools
+from . import web_search_tools
 from . import dynamic_tool

solace_agent_mesh/agent/tools/audio_tools.py

@@ -43,7 +43,7 @@ VOICE_TONE_MAPPING = {
     "excitable": ["Fenrir"],
     "youthful": ["Leda"],
     "breezy": ["Aoede"],
-    "easy-going": ["Callirhoe", "Umbriel"],
+    "easy-going": ["Callirrhoe", "Umbriel"],
     "breathy": ["Enceladus"],
     "clear": ["Iapetus", "Erinome"],
     "smooth": ["Algieba", "Despina"],
@@ -81,7 +81,7 @@ GENDER_TO_VOICE_MAPPING = {
         "Kore",
         "Leda",
         "Aoede",
-        "Callirhoe",
+        "Callirrhoe",
         "Autonoe",
         "Despina",
         "Erinome",
@@ -120,7 +120,7 @@ if not ALL_AVAILABLE_VOICES:
         "Fenrir",
         "Leda",
         "Aoede",
-        "Callirhoe",
+        "Callirrhoe",
         "Umbriel",
         "Enceladus",
         "Iapetus",