solace-agent-mesh 1.0.2__py3-none-any.whl → 1.0.5__py3-none-any.whl

solace_agent_mesh/agent/sac/app.py

@@ -246,8 +246,8 @@ class SamAgentApp(App):
                         "type": "string",
                         "required": False,
                         "default": "namespace",
-                        "enum": ["namespace", "app", "custom"],
-                        "description": "Scope for filesystem artifacts: 'namespace' (default, shared by namespace), 'app' (isolated by app name), 'custom' (use artifact_scope_value).",
+                        "enum": ["namespace", "app"],
+                        "description": "Process-wide scope for all artifact services. 'namespace' (default): shared by all components in the namespace. 'app': isolated by agent/gateway name. This setting must be consistent for all components in the same process.",
                     },
                     "artifact_scope_value": {
                         "type": "string",
@@ -340,6 +340,13 @@ class SamAgentApp(App):
                 "default": 0,
                 "description": "Minimum size in bytes for accumulated text from LLM stream before sending a status update. If 0 or less, batching is disabled and updates are sent per chunk. Final LLM chunks are always sent regardless of this threshold.",
             },
+            {
+                "name": "max_message_size_bytes",
+                "required": False,
+                "type": "integer",
+                "default": 10_000_000,
+                "description": "Maximum allowed message size in bytes before rejecting publication to prevent broker disconnections. Default: 10MB",
+            },
             {
                 "name": "enable_artifact_content_instruction",
                 "required": False,
@@ -551,6 +558,7 @@ class SamAgentApp(App):
         app_config = app_info.get("app_config", {})
         namespace = app_config.get("namespace")
         agent_name = app_config.get("agent_name")
+        broker_request_response = app_info.get("broker_request_response")
 
         if not namespace or not isinstance(namespace, str):
             raise ValueError(
@@ -619,6 +627,8 @@ class SamAgentApp(App):
             "component_config": {},
             "subscriptions": generated_subs,
         }
+        if broker_request_response:
+            component_definition["broker_request_response"] = broker_request_response
 
         app_info["components"] = [component_definition]
         log.debug("Replaced 'components' in app_info with programmatic definition.")

solace_agent_mesh/agent/sac/component.py

@@ -67,7 +67,9 @@ from ...common.a2a_protocol import (
     get_gateway_status_topic,
 )
 from ...agent.utils.config_parser import resolve_instruction_provider
-from ...agent.utils.artifact_helpers import get_latest_artifact_version
+from ...agent.utils.artifact_helpers import (
+    get_latest_artifact_version,
+)
 from ...agent.adk.services import (
     initialize_session_service,
     initialize_artifact_service,
@@ -92,6 +94,8 @@ from ...agent.adk.invocation_monitor import InvocationMonitor
 from ...common.middleware.registry import MiddlewareRegistry
 from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT
 from ...agent.tools.registry import tool_registry
+from ...common.utils.message_utils import validate_message_size
+from ...common.exceptions import MessageSizeExceededError
 
 if TYPE_CHECKING:
     from .task_execution_context import TaskExecutionContext
@@ -232,6 +236,11 @@ class SamAgentComponent(ComponentBase):
                 raise ValueError(
                     "Internal Error: Inter-agent comms config missing after validation."
                 )
+
+            self.max_message_size_bytes = self.get_config(
+                "max_message_size_bytes", 10_000_000
+            )
+
             log.info("%s Configuration retrieved successfully.", self.log_identifier)
         except Exception as e:
             log.error(
@@ -394,6 +403,7 @@ class SamAgentComponent(ComponentBase):
                 self.session_service = initialize_session_service(self)
                 self.artifact_service = initialize_artifact_service(self)
                 self.memory_service = initialize_memory_service(self)
+
                 log.info(
                     "%s Synchronous ADK services initialized.", self.log_identifier
                 )
@@ -2968,6 +2978,29 @@ class SamAgentComponent(ComponentBase):
     ):
         """Helper to publish A2A messages via the SAC App."""
         try:
+            max_size_bytes = self.max_message_size_bytes
+
+            # Validate message size
+            is_valid, actual_size = validate_message_size(
+                payload, max_size_bytes, self.log_identifier
+            )
+
+            if not is_valid:
+                error_msg = (
+                    f"Message size validation failed: payload size ({actual_size} bytes) "
+                    f"exceeds maximum allowed size ({max_size_bytes} bytes)"
+                )
+                log.error("%s %s", self.log_identifier, error_msg)
+                raise MessageSizeExceededError(actual_size, max_size_bytes, error_msg)
+
+            # Debug logging to show message size when publishing
+            log.debug(
+                "%s Publishing message to topic %s (size: %d bytes)",
+                self.log_identifier,
+                topic,
+                actual_size,
+            )
+
             app = self.get_app()
             if app:
                 if self.invocation_monitor:
@@ -2985,6 +3018,9 @@ class SamAgentComponent(ComponentBase):
                     "%s Cannot publish message: Not running within a SAC App context.",
                     self.log_identifier,
                 )
+        except MessageSizeExceededError:
+            # Re-raise MessageSizeExceededError without wrapping
+            raise
         except Exception as e:
             log.exception(
                 "%s Failed to publish A2A message to topic %s: %s",

solace_agent_mesh/agent/tools/builtin_artifact_tools.py

@@ -1888,12 +1888,19 @@ async def delete_artifact(
                 "ArtifactService does not support deleting artifacts."
             )
 
+        if version is not None:
+            log.warning(
+                "%s Deleting a specific version (%s) is not supported by the current artifact service interface. "
+                "All versions of the artifact will be deleted.",
+                log_identifier,
+                version,
+            )
+
         await artifact_service.delete_artifact(
             app_name=app_name,
             user_id=user_id,
             session_id=session_id,
             filename=filename,
-            version=version,
         )
 
         log.info(

solace_agent_mesh/agent/tools/peer_agent_tool.py

@@ -7,6 +7,7 @@ import uuid
 
 from google.adk.tools import BaseTool, ToolContext
 from google.genai import types as adk_types
+from pydantic import BaseModel, Field
 from solace_ai_connector.common.log import log
 
 from ...common.types import (
@@ -16,6 +17,17 @@ from ...common.types import (
     AgentCard,
 )
 from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT
+from ...common.exceptions import MessageSizeExceededError
+
+class ArtifactIdentifier(BaseModel):
+    """Identifies a specific version of an artifact."""
+
+    filename: str = Field(..., description="The filename of the artifact.")
+    version: Union[str, int] = Field(
+        "latest",
+        description="The version of the artifact (e.g., 'latest' or a number).",
+    )
+
 
 PEER_TOOL_PREFIX = "peer_"
 CORRELATION_DATA_PREFIX = "a2a_subtask_"
@@ -24,8 +36,14 @@ CORRELATION_DATA_PREFIX = "a2a_subtask_"
 class PeerAgentTool(BaseTool):
     """
     An ADK Tool that represents a discovered peer agent and handles task delegation
-    via the A2A protocol over Solace. Uses an asyncio Queue to block and wait for
-    the asynchronous response. Handles artifact passthrough from peer responses.
+    via the A2A protocol over Solace.
+
+    This tool is long-running and operates in a "fire-and-forget" manner. It sends a
+    task to a peer agent, including a `task_description` and an optional list of
+    `artifacts` to provide context. The artifact identifiers are passed in the
+    A2A message metadata, and the peer agent is responsible for fetching them.
+
+    The response from the peer is handled asynchronously by the agent's event handlers.
     """
 
     is_long_running = True
@@ -85,10 +103,24 @@ class PeerAgentTool(BaseTool):
                     type=adk_types.Type.STRING,
                     description="The original user query or relevant context.",
                 ),
-                "data_artifacts": adk_types.Schema(
+                "artifacts": adk_types.Schema(
                     type=adk_types.Type.ARRAY,
-                    items=adk_types.Schema(type=adk_types.Type.STRING),
-                    description="A list of artifact filenames to be sent to the peer agent for context.",
+                    items=adk_types.Schema(
+                        type=adk_types.Type.OBJECT,
+                        properties={
+                            "filename": adk_types.Schema(
+                                type=adk_types.Type.STRING,
+                                description="The filename of the artifact.",
+                            ),
+                            "version": adk_types.Schema(
+                                type=adk_types.Type.STRING,
+                                description="The version of the artifact (e.g., 'latest' or a number). Defaults to 'latest'.",
+                                nullable=True,
+                            ),
+                        },
+                        required=["filename"],
+                    ),
+                    description="A list of artifacts to provide as context to the peer agent.",
                     nullable=True,
                 ),
             },
@@ -106,11 +138,11 @@ class PeerAgentTool(BaseTool):
             parameters=parameters_schema,
         )
 
-    async def _prepare_a2a_parts(
+    def _prepare_a2a_parts(
         self, args: Dict[str, Any], tool_context: ToolContext
-    ) -> List[Union[TextPart, FilePart]]:
+    ) -> List[TextPart]:
         """
-        Prepares the A2A message parts from tool arguments, including text and artifacts.
+        Prepares the A2A message parts from tool arguments.
         """
         task_description = args.get("task_description", "No description provided.")
         calling_agent_name = self.host_component.agent_name or "Unknown Agent"
@@ -118,73 +150,16 @@ class PeerAgentTool(BaseTool):
         # Create the multi-agent context message
         context_message = (
             f"You are part of a multi-agent AI platform. The task below is being sent to you by agent '{calling_agent_name}'. "
-            f"You must perform this task to the best of your abilities. All artifacts that you create will automatically be "
-            f"returned to the calling agent, but you must provide context and description for which artifacts are important "
-            f"and how they should be used. Note that the calling agent will not see any of your history - only the text "
-            f"that you respond with.\n\n"
+            "You must perform this task to the best of your abilities. All artifacts that you create will automatically be "
+            "returned to the calling agent, but you must provide context and description for which artifacts are important "
+            "and how they should be used. Note that the calling agent will not see any of your history - only the text "
+            "that you respond with.\n\n"
+            "Note that if the request has not provided the information you need to do your job, you must ask for it. "
+            "You must not 'make up' data unless specifically instructed to do so.\n\n"
             f"Now please execute this task that was given to you:\n\n{task_description}"
         )
 
-        a2a_message_parts = [TextPart(text=context_message)]
-
-        artifact_names = args.get("data_artifacts", [])
-        if not isinstance(artifact_names, list):
-            log.warning(
-                "%s 'data_artifacts' argument is not a list, ignoring. Value: %s",
-                self.log_identifier,
-                artifact_names,
-            )
-            artifact_names = []
-
-        if artifact_names:
-            log.debug(
-                "%s Preparing to include %d artifacts in peer request.",
-                self.log_identifier,
-                len(artifact_names),
-            )
-            a2a_context = tool_context.state.get("a2a_context", {})
-            for artifact_name in artifact_names:
-                try:
-                    loaded_part = (
-                        await self.host_component.artifact_service.load_artifact(
-                            app_name=tool_context._invocation_context.app_name,
-                            user_id=tool_context._invocation_context.user_id,
-                            session_id=tool_context._invocation_context.session.id,
-                            filename=artifact_name,
-                            version=None,
-                        )
-                    )
-                    if loaded_part:
-                        a2a_file_part = await self.host_component._translate_adk_part_to_a2a_filepart(
-                            loaded_part, artifact_name, a2a_context
-                        )
-                        if a2a_file_part:
-                            a2a_message_parts.append(a2a_file_part)
-                            log.info(
-                                "%s Included latest artifact '%s' in peer request.",
-                                self.log_identifier,
-                                artifact_name,
-                            )
-                        else:
-                            log.warning(
-                                "%s Failed to translate loaded artifact '%s' to A2A part. Skipping.",
-                                self.log_identifier,
-                                artifact_name,
-                            )
-                    else:
-                        log.warning(
-                            "%s Could not load artifact '%s' to include in peer request. Skipping.",
-                            self.log_identifier,
-                            artifact_name,
-                        )
-                except Exception as e:
-                    log.exception(
-                        "%s Error loading artifact '%s' for peer request: %s",
-                        self.log_identifier,
-                        artifact_name,
-                        e,
-                    )
-        return a2a_message_parts
+        return [TextPart(text=context_message)]
 
     async def run_async(
         self, *, args: Dict[str, Any], tool_context: ToolContext
@@ -236,8 +211,29 @@ class PeerAgentTool(BaseTool):
                 task_context_obj.parallel_tool_calls.get(invocation_id),
             )
 
-            a2a_message_parts = await self._prepare_a2a_parts(args, tool_context)
-            a2a_message = A2AMessage(role="user", parts=a2a_message_parts)
+            a2a_message_parts = self._prepare_a2a_parts(args, tool_context)
+            a2a_metadata = {}
+            raw_artifacts = args.get("artifacts", [])
+            if raw_artifacts and isinstance(raw_artifacts, list):
+                try:
+                    # The ADK gives us a list of dicts, not Pydantic models
+                    # so we can use them directly.
+                    a2a_metadata["invoked_with_artifacts"] = raw_artifacts
+                    log.debug(
+                        "%s Included %d artifact identifiers in A2A message metadata.",
+                        log_identifier,
+                        len(raw_artifacts),
+                    )
+                except Exception as e:
+                    log.warning(
+                        "%s Failed to serialize artifact identifiers: %s. Proceeding without them.",
+                        log_identifier,
+                        e,
+                    )
+
+            a2a_message = A2AMessage(
+                role="user", parts=a2a_message_parts, metadata=a2a_metadata
+            )
 
             correlation_data = {
                 "adk_function_call_id": tool_context.function_call_id,
@@ -259,16 +255,28 @@ class PeerAgentTool(BaseTool):
                 component=self.host_component,
             )
 
-            self.host_component.submit_a2a_task(
-                target_agent_name=self.target_agent_name,
-                a2a_message=a2a_message,
-                original_session_id=original_session_id,
-                main_logical_task_id=main_logical_task_id,
-                user_id=user_id,
-                user_config=user_config,
-                sub_task_id=sub_task_id,
-                function_call_id=tool_context.function_call_id,
-            )
+            try:
+                self.host_component.submit_a2a_task(
+                    target_agent_name=self.target_agent_name,
+                    a2a_message=a2a_message,
+                    original_session_id=original_session_id,
+                    main_logical_task_id=main_logical_task_id,
+                    user_id=user_id,
+                    user_config=user_config,
+                    sub_task_id=sub_task_id,
+                    function_call_id=tool_context.function_call_id,
+                )
+            except MessageSizeExceededError as e:
+                log.error(
+                    "%s Message size exceeded for peer agent request: %s",
+                    log_identifier,
+                    e,
+                )
+                return {
+                    "status": "error",
+                    "message": f"Error: {str(e)}. Message size exceeded for peer agent request.",
+                }
+
             log.info(
                 "%s Registered active peer sub-task %s for main task %s.",
                 log_identifier,

solace_agent_mesh/agent/utils/artifact_helpers.py

@@ -8,17 +8,21 @@ import json
 import csv
 import io
 import inspect
-import datetime
 import os
+import yaml
+import traceback
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional, Tuple, List, Union, TYPE_CHECKING
-from datetime import timezone
 from google.adk.artifacts import BaseArtifactService
 from google.genai import types as adk_types
 from solace_ai_connector.common.log import log
+from ...common.types import ArtifactInfo
 from ...common.utils.mime_helpers import is_text_based_mime_type, is_text_based_file
+from ...agent.utils.context_helpers import get_original_session_id
 
 if TYPE_CHECKING:
     from google.adk.tools import ToolContext
+    from ...agent.sac.component import SamAgentComponent
 
 METADATA_SUFFIX = ".metadata.json"
 DEFAULT_SCHEMA_MAX_KEYS = 20
@@ -155,13 +159,9 @@ def _infer_schema(
             "text/x-yaml",
         ]:
             try:
-                import yaml
-
                 data = yaml.safe_load(content_bytes)
                 schema_info["structure"] = _inspect_structure(data, depth, max_keys)
                 schema_info["inferred"] = True
-            except ImportError:
-                schema_info["error"] = "YAML inference skipped: PyYAML not installed."
             except (yaml.YAMLError, UnicodeDecodeError) as e:
                 schema_info["error"] = f"YAML structure inference failed: {e}"
     except Exception as e:
@@ -188,7 +188,7 @@ async def save_artifact_with_metadata(
     content_bytes: bytes,
     mime_type: str,
     metadata_dict: Dict[str, Any],
-    timestamp: datetime.datetime,
+    timestamp: datetime,
     explicit_schema: Optional[Dict] = None,
     schema_inference_depth: int = 2,
     schema_max_keys: int = DEFAULT_SCHEMA_MAX_KEYS,
@@ -399,6 +399,143 @@ def format_metadata_for_llm(metadata: Dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
+async def generate_artifact_metadata_summary(
+    component: "SamAgentComponent",
+    artifact_identifiers: List[Dict[str, Any]],
+    user_id: str,
+    session_id: str,
+    app_name: str,
+    header_text: Optional[str] = None,
+) -> str:
+    """
+    Loads metadata for a list of artifacts and formats it into a human-readable
+    YAML summary string, suitable for LLM context.
+    """
+    if not artifact_identifiers:
+        return ""
+
+    log_identifier = f"{component.log_identifier}[ArtifactSummary]"
+    summary_parts = []
+    if header_text:
+        summary_parts.append(header_text)
+
+    if not (component.artifact_service and user_id and session_id):
+        log.warning(
+            "%s Cannot load artifact metadata: missing artifact_service or context.",
+            log_identifier,
+        )
+        for artifact_ref in artifact_identifiers:
+            filename = artifact_ref.get("filename", "unknown")
+            version = artifact_ref.get("version", "latest")
+            summary_parts.append(
+                f"---\nArtifact: '{filename}' (version: {version})\nError: Could not load metadata. Host component context missing."
+            )
+        return "\n\n".join(summary_parts)
+
+    for artifact_ref in artifact_identifiers:
+        filename = artifact_ref.get("filename")
+        version = artifact_ref.get("version", "latest")
+        if not filename:
+            log.warning(
+                "%s Skipping artifact with no filename in identifier: %s",
+                log_identifier,
+                artifact_ref,
+            )
+            continue
+
+        try:
+            metadata_result = await load_artifact_content_or_metadata(
+                artifact_service=component.artifact_service,
+                app_name=app_name,
+                user_id=user_id,
+                session_id=get_original_session_id(session_id),
+                filename=filename,
+                version=version,
+                load_metadata_only=True,
+            )
+            if metadata_result.get("status") == "success":
+                metadata = metadata_result.get("metadata", {})
+                resolved_version = metadata_result.get("version", version)
+                artifact_header = (
+                    f"Artifact: '{filename}' (version: {resolved_version})"
+                )
+
+                # Remove redundant fields before dumping to YAML
+                metadata.pop("filename", None)
+                metadata.pop("version", None)
+
+                TRUNCATION_LIMIT_BYTES = 1024
+                TRUNCATION_MESSAGE = "\n... [truncated] ..."
+
+                try:
+                    formatted_metadata_str = yaml.safe_dump(
+                        metadata,
+                        default_flow_style=False,
+                        sort_keys=False,
+                        allow_unicode=True,
+                    )
+
+                    if (
+                        len(formatted_metadata_str.encode("utf-8"))
+                        > TRUNCATION_LIMIT_BYTES
+                    ):
+                        cutoff = TRUNCATION_LIMIT_BYTES - len(
+                            TRUNCATION_MESSAGE.encode("utf-8")
+                        )
+                        # Ensure we don't cut in the middle of a multi-byte character
+                        encoded_str = formatted_metadata_str.encode("utf-8")
+                        if cutoff > 0:
+                            truncated_encoded = encoded_str[:cutoff]
+                            formatted_metadata_str = (
+                                truncated_encoded.decode("utf-8", "ignore")
+                                + TRUNCATION_MESSAGE
+                            )
+                        else:
+                            formatted_metadata_str = TRUNCATION_MESSAGE
+
+                    summary_parts.append(
+                        f"---\n{artifact_header}\n{formatted_metadata_str}"
+                    )
+                except Exception as e_format:
+                    log.error(
+                        "%s Error formatting metadata for %s v%s: %s",
+                        log_identifier,
+                        filename,
+                        version,
+                        e_format,
+                    )
+                    summary_parts.append(
+                        f"---\n{artifact_header}\nError: Could not format metadata."
+                    )
+            else:
+                error_message = metadata_result.get(
+                    "message", "Could not load metadata."
+                )
+                log.warning(
+                    "%s Failed to load metadata for %s v%s: %s",
+                    log_identifier,
+                    filename,
+                    version,
+                    error_message,
+                )
+                artifact_header = f"Artifact: '{filename}' (version: {version})"
+                summary_parts.append(f"---\n{artifact_header}\nError: {error_message}")
+        except Exception as e_meta:
+            log.error(
+                "%s Unexpected error loading metadata for %s v%s: %s",
+                log_identifier,
+                filename,
+                version,
+                e_meta,
+            )
+            artifact_header = f"Artifact: '{filename}' (version: {version})"
+            summary_parts.append(
+                f"---\n{artifact_header}\nError: An unexpected error occurred while loading metadata."
+            )
+
+    return "\n\n".join(summary_parts)
+
+
 def decode_and_get_bytes(
     content_str: str, mime_type: str, log_identifier: str
 ) -> Tuple[bytes, str]:
@@ -441,12 +578,6 @@ def decode_and_get_bytes(
     return file_bytes, final_mime_type
 
 
-from google.adk.artifacts import BaseArtifactService
-from datetime import datetime, timezone
-import traceback
-from ...common.types import ArtifactInfo
-
-
 async def get_latest_artifact_version(
     artifact_service: BaseArtifactService,
     app_name: str,
@@ -476,7 +607,10 @@ async def get_latest_artifact_version(
             return None
 
         versions = await artifact_service.list_versions(
-            app_name=app_name, user_id=user_id, session_id=session_id, filename=filename
+            app_name=app_name,
+            user_id=user_id,
+            session_id=session_id,
+            filename=filename,
         )
         if not versions:
             log.debug("%s No versions found for artifact.", log_identifier)