solace-agent-mesh 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

solace_agent_mesh/agent/proxies/base/config.py

@@ -0,0 +1,85 @@
+"""
+Pydantic configuration models for proxy applications.
+"""
+
+from typing import List, Literal, Optional
+
+from pydantic import Field, model_validator
+
+from ....common.utils.pydantic_utils import SamConfigBase
+
+
+class ArtifactServiceConfig(SamConfigBase):
+    """Configuration for the shared Artifact Service."""
+
+    type: str = Field(
+        ..., description="Service type (e.g., 'memory', 'gcs', 'filesystem')."
+    )
+    base_path: Optional[str] = Field(
+        default=None,
+        description="Base directory path (required for type 'filesystem').",
+    )
+    bucket_name: Optional[str] = Field(
+        default=None, description="GCS bucket name (required for type 'gcs')."
+    )
+    artifact_scope: Literal["namespace", "app", "custom"] = Field(
+        default="namespace", description="Process-wide scope for all artifact services."
+    )
+    artifact_scope_value: Optional[str] = Field(
+        default=None,
+        description="Custom identifier for artifact scope (required if artifact_scope is 'custom').",
+    )
+
+    @model_validator(mode="after")
+    def check_artifact_scope(self) -> "ArtifactServiceConfig":
+        if self.artifact_scope == "custom" and not self.artifact_scope_value:
+            raise ValueError(
+                "'artifact_scope_value' is required when 'artifact_scope' is 'custom'."
+            )
+        if self.artifact_scope != "custom" and self.artifact_scope_value:
+            from solace_ai_connector.common.log import log
+            log.warning(
+                "Configuration Warning: 'artifact_scope_value' is ignored when 'artifact_scope' is not 'custom'."
+            )
+        return self
+
+
+class ProxiedAgentConfig(SamConfigBase):
+    """Base configuration for a proxied agent."""
+
+    name: str = Field(
+        ...,
+        description="The name the agent will have on the Solace mesh.",
+    )
+    request_timeout_seconds: Optional[int] = Field(
+        default=None,
+        description="Optional timeout override for this specific agent.",
+    )
+
+
+class BaseProxyAppConfig(SamConfigBase):
+    """Base configuration for all proxy applications."""
+
+    namespace: str = Field(
+        ...,
+        description="Absolute topic prefix for A2A communication (e.g., 'myorg/dev').",
+    )
+    proxied_agents: List[ProxiedAgentConfig] = Field(
+        ...,
+        min_length=1,
+        description="A list of downstream agents to be proxied.",
+    )
+    artifact_service: ArtifactServiceConfig = Field(
+        default_factory=lambda: ArtifactServiceConfig(type="memory"),
+        description="Configuration for the shared Artifact Service.",
+    )
+    discovery_interval_seconds: int = Field(
+        default=60,
+        ge=0,
+        description="Interval (seconds) to re-fetch agent cards. <= 0 disables periodic discovery.",
+    )
+    default_request_timeout_seconds: int = Field(
+        default=300,
+        gt=0,
+        description="Default timeout in seconds for requests to downstream agents.",
+    )

solace_agent_mesh/agent/proxies/base/proxy_task_context.py

@@ -0,0 +1,17 @@
+"""
+Encapsulates the runtime state for a single, in-flight proxied agent task.
+"""
+
+from typing import Any, Dict
+from dataclasses import dataclass
+
+
+@dataclass
+class ProxyTaskContext:
+    """
+    A class to hold all runtime state and control mechanisms for a single proxied agent task.
+    This object is created when a task is initiated and destroyed when it completes.
+    """
+
+    task_id: str
+    a2a_context: Dict[str, Any]

solace_agent_mesh/agent/sac/app.py

@@ -23,7 +23,7 @@ from ...common.a2a import (
     get_agent_status_subscription_topic,
     get_sam_events_subscription_topic,
 )
-from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT, TEXT_ARTIFACT_CONTEXT_MAX_LENGTH_CAPACITY, TEXT_ARTIFACT_CONTEXT_DEFAULT_LENGTH
+from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT, TEXT_ARTIFACT_CONTEXT_MAX_LENGTH_CAPACITY, TEXT_ARTIFACT_CONTEXT_DEFAULT_LENGTH, HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
 from ...agent.sac.component import SamAgentComponent
 from ...agent.utils.artifact_helpers import DEFAULT_SCHEMA_MAX_KEYS
 from ...common.utils.pydantic_utils import SamConfigBase
@@ -79,6 +79,12 @@ class AgentDiscoveryConfig(SamConfigBase):
     enabled: bool = Field(
         default=True, description="Enable discovery and instruction injection."
     )
+    health_check_ttl_seconds: int = Field(
+        default=HEALTH_CHECK_TTL_SECONDS, description="Time-to-live in seconds after which an unresponsive agent is de-registered."
+    )
+    health_check_interval_seconds: int = Field(
+        default=HEALTH_CHECK_INTERVAL_SECONDS, description="Interval in seconds between health checks."
+    )
 
 
 class InterAgentCommunicationConfig(SamConfigBase):
@@ -452,8 +458,8 @@ class SamAgentApp(App):
         broker_config["queue_name"] = generated_queue_name
         log.debug("Injected generated broker.queue_name: %s", generated_queue_name)
 
-        broker_config["temporary_queue"] = True
-        log.debug("Set broker_config.temporary_queue = True")
+        broker_config["temporary_queue"] = app_info.get("broker", {}).get("temporary_queue", True)
+        log.debug("Set broker_config.temporary_queue = %s", broker_config["temporary_queue"])
 
         super().__init__(app_info, **kwargs)
         log.debug("%s Agent initialization complete.", agent_name)

solace_agent_mesh/agent/sac/component.py

@@ -8,10 +8,8 @@ import asyncio
 import functools
 import threading
 import concurrent.futures
-import uuid
 import fnmatch
-import base64
-from datetime import datetime, timezone
+import time
 import json
 from solace_ai_connector.common.message import (
     Message as SolaceMessage,
@@ -73,9 +71,10 @@ from ...agent.tools.peer_agent_tool import (
     PEER_TOOL_PREFIX,
 )
 from ...common.middleware.registry import MiddlewareRegistry
-from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT
+from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT, HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
 from ...agent.tools.registry import tool_registry
 from ...common.sac.sam_component_base import SamComponentBase
+from ...common.agent_registry import AgentRegistry
 
 log = logging.getLogger(__name__)
 
@@ -113,6 +112,7 @@ class SamAgentComponent(SamComponentBase):
 
     CORRELATION_DATA_PREFIX = CORRELATION_DATA_PREFIX
     HOST_COMPONENT_VERSION = "1.0.0-alpha"
+    HEALTH_CHECK_TIMER_ID = "agent_health_check"
 
     def __init__(self, **kwargs):
         """
@@ -129,6 +129,9 @@ class SamAgentComponent(SamComponentBase):
         super().__init__(info, **kwargs)
         self.agent_name = self.get_config("agent_name")
         log.info("%s Initializing A2A ADK Host Component...", self.log_identifier)
+        
+        # Initialize the agent registry for health tracking
+        self.agent_registry = AgentRegistry()
         try:
             self.namespace = self.get_config("namespace")
             if not self.namespace:
@@ -237,7 +240,7 @@ class SamAgentComponent(SamComponentBase):
         self.adk_agent: LlmAgent = None
         self.runner: Runner = None
         self.agent_card_tool_manifest: List[Dict[str, Any]] = []
-        self.peer_agents: Dict[str, Any] = {}
+        self.peer_agents: Dict[str, Any] = {}  # Keep for backward compatibility
         self._card_publish_timer_id: str = f"publish_card_{self.agent_name}"
         self._async_init_future = None
         self.peer_response_queues: Dict[str, asyncio.Queue] = {}
@@ -414,6 +417,26 @@ class SamAgentComponent(SamComponentBase):
                     "%s Agent card publishing interval not configured or invalid, card will not be published periodically.",
                     self.log_identifier,
                 )
+                
+            # Set up health check timer if enabled
+            health_check_interval_seconds = self.agent_discovery_config.get("health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+            if health_check_interval_seconds > 0:
+                log.info(
+                    "%s Scheduling agent health check every %d seconds.",
+                    self.log_identifier,
+                    health_check_interval_seconds,
+                )
+                self.add_timer(
+                    delay_ms=health_check_interval_seconds * 1000,
+                    timer_id=self.HEALTH_CHECK_TIMER_ID,
+                    interval_ms=health_check_interval_seconds * 1000,
+                )
+            else:
+                log.warning(
+                    "%s Agent health check interval not configured or invalid, health checks will not run periodically.",
+                    self.log_identifier,
+                )
+                
             log.info(
                 "%s Initialization complete for agent: %s",
                 self.log_identifier,
@@ -488,10 +511,14 @@ class SamAgentComponent(SamComponentBase):
                     )
 
     def handle_timer_event(self, timer_data: Dict[str, Any]):
-        """Handles timer events, specifically for agent card publishing."""
+        """Handles timer events for agent card publishing and health checks."""
         log.debug("%s Received timer event: %s", self.log_identifier, timer_data)
-        if timer_data.get("timer_id") == self._card_publish_timer_id:
+        timer_id = timer_data.get("timer_id")
+        
+        if timer_id == self._card_publish_timer_id:
             publish_agent_card(self)
+        elif timer_id == self.HEALTH_CHECK_TIMER_ID:
+            self._check_agent_health()
 
     async def handle_cache_expiry_event(self, cache_data: Dict[str, Any]):
         """
@@ -866,7 +893,8 @@ class SamAgentComponent(SamComponentBase):
         peer_tools_to_add = []
         allowed_peer_descriptions = []
 
-        for peer_name, agent_card in self.peer_agents.items():
+        # Sort peer agents alphabetically to ensure consistent tool ordering for prompt caching
+        for peer_name, agent_card in sorted(self.peer_agents.items()):
             if not isinstance(agent_card, AgentCard) or peer_name == self_name:
                 continue
 
@@ -2991,6 +3019,7 @@ class SamAgentComponent(SamComponentBase):
         """Clean up resources on component shutdown."""
         log.info("%s Cleaning up A2A ADK Host Component.", self.log_identifier)
         self.cancel_timer(self._card_publish_timer_id)
+        self.cancel_timer(self.HEALTH_CHECK_TIMER_ID)
 
         cleanup_func_details = self.get_config("agent_cleanup_function")
 
@@ -3151,6 +3180,129 @@ class SamAgentComponent(SamComponentBase):
         For now, using the agent name, but could be made more robust (e.g., hostname + agent name).
         """
         return self.agent_name
+        
+    def _check_agent_health(self):
+        """
+        Checks the health of peer agents and de-registers unresponsive ones.
+        This is called periodically by the health check timer.
+        Uses TTL-based expiration to determine if an agent is unresponsive.
+        """
+            
+        log.debug("%s Performing agent health check...", self.log_identifier)
+        
+        ttl_seconds = self.agent_discovery_config.get("health_check_ttl_seconds", HEALTH_CHECK_TTL_SECONDS)
+        health_check_interval = self.agent_discovery_config.get("health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+        
+        log.debug(
+            "%s Health check configuration: interval=%d seconds, TTL=%d seconds",
+            self.log_identifier,
+            health_check_interval,
+            ttl_seconds
+        )
+
+        # Validate configuration values
+        if ttl_seconds <= 0 or health_check_interval <= 0 or ttl_seconds < health_check_interval:
+            log.error(
+                "%s agent_health_check_ttl_seconds (%d) and agent_health_check_interval_seconds (%d) must be positive and TTL must be greater than interval.",
+                self.log_identifier,
+                ttl_seconds,
+                health_check_interval
+            )
+            raise ValueError(f"Invalid health check configuration. agent_health_check_ttl_seconds ({ttl_seconds}) and agent_health_check_interval_seconds ({health_check_interval}) must be positive and TTL must be greater than interval.")
+        
+        # Get all agent names from the registry
+        agent_names = self.agent_registry.get_agent_names()
+        total_agents = len(agent_names)
+        agents_to_deregister = []
+        
+        log.debug("%s Checking health of %d peer agents", self.log_identifier, total_agents)
+        
+        for agent_name in agent_names:
+            # Skip our own agent
+            if agent_name == self.agent_name:
+                continue
+                
+            # Check if the agent's TTL has expired
+            is_expired, time_since_last_seen = self.agent_registry.check_ttl_expired(agent_name, ttl_seconds)
+            
+            if is_expired:
+                log.warning(
+                    "%s Agent '%s' TTL has expired. De-registering. Time since last seen: %d seconds (TTL: %d seconds)",
+                    self.log_identifier,
+                    agent_name,
+                    time_since_last_seen,
+                    ttl_seconds
+                )
+                agents_to_deregister.append(agent_name)
+            
+        # De-register unresponsive agents
+        for agent_name in agents_to_deregister:
+            self._deregister_agent(agent_name)
+            
+        log.debug(
+            "%s Agent health check completed. Total agents: %d, De-registered: %d",
+            self.log_identifier,
+            total_agents,
+            len(agents_to_deregister)
+        )
+        
+    def _deregister_agent(self, agent_name: str):
+        """
+        De-registers an agent from the registry and publishes a de-registration event.
+        """
+        # Remove from registry
+        registry_removed = self.agent_registry.remove_agent(agent_name)
+        
+        # Always remove from peer_agents regardless of registry result
+        peer_removed = False
+        if agent_name in self.peer_agents:
+            del self.peer_agents[agent_name]
+            peer_removed = True
+            log.info(
+                "%s Removed agent '%s' from peer_agents dictionary",
+                self.log_identifier,
+                agent_name
+            )
+        
+        # Publish de-registration event if agent was in either data structure
+        if registry_removed or peer_removed:
+            try:
+                # Create a de-registration event topic
+                namespace = self.get_config("namespace")
+                deregistration_topic = f"{namespace}/a2a/events/agent/deregistered"
+                
+                current_time = time.time()
+                
+                # Create the payload
+                deregistration_payload = {
+                    "event_type": "agent.deregistered",
+                    "agent_name": agent_name,
+                    "reason": "health_check_failure",
+                    "metadata": {
+                        "timestamp": current_time,
+                        "deregistered_by": self.agent_name
+                    }
+                }
+                
+                # Publish the event
+                self.publish_a2a_message(
+                    payload=deregistration_payload,
+                    topic=deregistration_topic
+                )
+                
+                log.info(
+                    "%s Published de-registration event for agent '%s' to topic '%s'",
+                    self.log_identifier,
+                    agent_name,
+                    deregistration_topic
+                )
+            except Exception as e:
+                log.error(
+                    "%s Failed to publish de-registration event for agent '%s': %s",
+                    self.log_identifier,
+                    agent_name,
+                    e
+                )
 
     async def _resolve_early_embeds_and_handle_signals(
         self, raw_text: str, a2a_context: Dict

solace_agent_mesh/agent/tools/audio_tools.py

@@ -25,6 +25,7 @@ from pydub import AudioSegment
 from ...agent.utils.artifact_helpers import (
     load_artifact_content_or_metadata,
     save_artifact_with_metadata,
+    ensure_correct_extension,
     DEFAULT_SCHEMA_MAX_KEYS,
 )
 from ...agent.utils.context_helpers import get_original_session_id
@@ -1210,14 +1211,18 @@ async def concatenate_audio(
 
 async def transcribe_audio(
     audio_filename: str,
+    output_filename: Optional[str] = None,
+    description: Optional[str] = None,
     tool_context: ToolContext = None,
     tool_config: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     """
-    Transcribes an audio recording using an OpenAI-compatible audio transcription API.
+    Transcribes an audio recording and saves the transcription as a text artifact.
 
     Args:
         audio_filename: The filename (and optional :version) of the input audio artifact.
+        output_filename: Optional filename for the transcription text file (without extension).
+        description: Optional description of the transcription for metadata.
         tool_context: The context provided by the ADK framework.
         tool_config: Configuration dictionary containing model, api_base, api_key.
 
@@ -1225,9 +1230,10 @@ async def transcribe_audio(
         A dictionary containing:
         - "status": "success" or "error".
         - "message": A descriptive message about the outcome.
-        - "transcription": The transcribed text from the API (if successful).
-        - "audio_filename": The name of the input audio artifact (if successful).
-        - "audio_version": The version of the input audio artifact (if successful).
+        - "output_filename": The name of the saved transcription artifact.
+        - "output_version": The version of the saved transcription artifact.
+        - "audio_filename": The name of the input audio artifact.
+        - "audio_version": The version of the input audio artifact.
     """
     log_identifier = f"[AudioTools:transcribe_audio:{audio_filename}]"
     if not tool_context:
@@ -1340,8 +1346,28 @@ async def transcribe_audio(
             )
 
         audio_bytes = audio_artifact_part.inline_data.data
+        audio_mime_type = audio_artifact_part.inline_data.mime_type or "application/octet-stream"
         log.debug(f"{log_identifier} Loaded audio artifact: {len(audio_bytes)} bytes")
 
+        # Load source audio metadata to copy description
+        source_audio_metadata = {}
+        try:
+            metadata_result = await load_artifact_content_or_metadata(
+                artifact_service=artifact_service,
+                app_name=app_name,
+                user_id=user_id,
+                session_id=session_id,
+                filename=filename_base_for_load,
+                version=version_to_load,
+                load_metadata_only=True,
+                log_identifier_prefix=f"{log_identifier}[source_metadata]",
+            )
+            if metadata_result.get("status") == "success":
+                source_audio_metadata = metadata_result.get("metadata", {})
+                log.debug(f"{log_identifier} Loaded source audio metadata")
+        except Exception as meta_err:
+            log.warning(f"{log_identifier} Could not load source audio metadata: {meta_err}")
+
         temp_file_path = None
         try:
             file_ext = os.path.splitext(filename_base_for_load)[1]
@@ -1383,12 +1409,93 @@ async def transcribe_audio(
                 f"{log_identifier} Audio transcribed successfully. Transcription length: {len(transcription)} characters"
             )
 
+            # Determine output filename
+            if output_filename:
+                final_filename = ensure_correct_extension(output_filename, "txt")
+            else:
+                # Auto-generate from source audio filename
+                base_name = os.path.splitext(filename_base_for_load)[0]
+                final_filename = f"{base_name}_transcription.txt"
+
+            # Build comprehensive metadata
+            transcription_word_count = len(transcription.split())
+            transcription_char_count = len(transcription)
+            
+            # Build description from multiple sources
+            description_parts = []
+            
+            # Add user-provided description
+            if description:
+                description_parts.append(description)
+            
+            # Add source audio description if available
+            source_description = source_audio_metadata.get("description")
+            if source_description:
+                description_parts.append(f"Source: {source_description}")
+            
+            # Add source audio info
+            description_parts.append(f"Transcribed from audio file '{filename_base_for_load}' (version {version_to_load}, {audio_mime_type})")
+            
+            # Combine all description parts
+            final_description = ". ".join(description_parts)
+            
+            metadata = {
+                "description": final_description,
+                "source_audio_filename": filename_base_for_load,
+                "source_audio_version": version_to_load,
+                "source_audio_mime_type": audio_mime_type,
+                "transcription_model": model_name,
+                "transcription_timestamp": datetime.now(timezone.utc).isoformat(),
+                "transcription_word_count": transcription_word_count,
+                "transcription_char_count": transcription_char_count,
+                "generation_tool": "transcribe_audio",
+            }
+            
+            # Copy source audio description separately for reference
+            if source_description:
+                metadata["source_audio_description"] = source_description
+            
+            # Add user-provided description separately if provided
+            if description:
+                metadata["user_provided_description"] = description
+
+            # Save transcription as text artifact
+            transcription_bytes = transcription.encode("utf-8")
+            
+            save_result = await save_artifact_with_metadata(
+                artifact_service=artifact_service,
+                app_name=app_name,
+                user_id=user_id,
+                session_id=session_id,
+                filename=final_filename,
+                content_bytes=transcription_bytes,
+                mime_type="text/plain",
+                metadata_dict=metadata,
+                timestamp=datetime.now(timezone.utc),
+                schema_max_keys=DEFAULT_SCHEMA_MAX_KEYS,
+                tool_context=tool_context,
+            )
+
+            if save_result.get("status") != "success":
+                error_msg = save_result.get("message", "Failed to save transcription artifact")
+                log.error(f"{log_identifier} {error_msg}")
+                return {
+                    "status": "error",
+                    "message": f"Transcription succeeded but failed to save as artifact: {error_msg}",
+                }
+
+            log.info(
+                f"{log_identifier} Transcription saved to '{final_filename}' v{save_result['data_version']}"
+            )
+
             return {
                 "status": "success",
-                "message": "Audio transcribed successfully",
-                "transcription": transcription,
+                "message": "Audio transcribed and saved successfully",
+                "output_filename": final_filename,
+                "output_version": save_result["data_version"],
                 "audio_filename": filename_base_for_load,
                 "audio_version": version_to_load,
+                "result_preview": f"Transcription saved to '{final_filename}' (v{save_result['data_version']}). Length: {transcription_char_count} characters, {transcription_word_count} words."
             }
 
         finally:
@@ -1600,9 +1707,9 @@ concatenate_audio_tool_def = BuiltinTool(
 transcribe_audio_tool_def = BuiltinTool(
     name="transcribe_audio",
     implementation=transcribe_audio,
-    description="Transcribes an audio recording using an OpenAI-compatible audio transcription API.",
+    description="Transcribes an audio recording and saves the transcription as a text artifact.",
     category="audio",
-    required_scopes=["tool:audio:transcribe"],
+    required_scopes=["tool:audio:transcribe", "tool:artifact:create"],
     parameters=adk_types.Schema(
         type=adk_types.Type.OBJECT,
         properties={
@@ -1610,6 +1717,16 @@ transcribe_audio_tool_def = BuiltinTool(
                 type=adk_types.Type.STRING,
                 description="The filename (and optional :version) of the input audio artifact.",
             ),
+            "output_filename": adk_types.Schema(
+                type=adk_types.Type.STRING,
+                description="Optional filename for the transcription text file (without .txt extension). If not provided, will auto-generate from source audio filename.",
+                nullable=True,
+            ),
+            "description": adk_types.Schema(
+                type=adk_types.Type.STRING,
+                description="Optional description of the transcription for metadata (e.g., 'Transcription of customer support call about billing inquiry'). Will be combined with source audio description if available.",
+                nullable=True,
+            ),
         },
         required=["audio_filename"],
     ),

solace_agent_mesh/agent/tools/web_tools.py

@@ -92,7 +92,12 @@ async def web_request(
         log.error(f"{log_identifier} ToolContext is missing.")
         return {"status": "error", "message": "ToolContext is missing."}
 
-    if not _is_safe_url(url):
+    # Check if loopback URLs are allowed (for testing)
+    allow_loopback = False
+    if tool_config:
+        allow_loopback = tool_config.get("allow_loopback", False)
+    
+    if not allow_loopback and not _is_safe_url(url):
         log.error(f"{log_identifier} URL is not safe to request: {url}")
         return {"status": "error", "message": "URL is not safe to request."}
 
@@ -150,10 +155,9 @@ async def web_request(
             )
 
         response_content_bytes = response.content
-        response_headers = dict(response.headers)
         response_status_code = response.status_code
         original_content_type = (
-            response_headers.get("content-type", "application/octet-stream")
+            response.headers.get("content-type", "application/octet-stream")
             .split(";")[0]
             .strip()
         )
@@ -238,7 +242,7 @@ async def web_request(
                 {k: v for k, v in headers.items() if k.lower() != "authorization"}
             ),
             "response_status_code": response_status_code,
-            "response_headers": json.dumps(response_headers),
+            "response_headers": json.dumps(dict(response.headers)),
             "original_content_type": original_content_type,
             "processed_content_type": processed_content_type,
             "timestamp": datetime.now(timezone.utc).isoformat(),
@@ -285,7 +289,8 @@ async def web_request(
         return {
             "status": "success",
             "message": f"Successfully fetched content from {url} (status: {response_status_code}). "
-            f"Saved as artifact '{final_artifact_filename}' v{save_result['data_version']}.",
+            f"Saved as artifact '{final_artifact_filename}' v{save_result['data_version']}. "
+            f"Analyze the content of '{final_artifact_filename}' before providing a final answer to the user.",
             "output_filename": final_artifact_filename,
             "output_version": save_result["data_version"],
             "response_status_code": response_status_code,