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

solace_agent_mesh/common/middleware/middleware_llm.txt

@@ -0,0 +1,174 @@
+Here is the DEVELOPER GUIDE for the `middleware` directory.
+
+## Quick Summary
+The `middleware` directory provides a pluggable framework for system components that can be extended or replaced at runtime. It offers a registry system to dynamically bind custom implementations for core functionalities like configuration resolution. The default implementations provide permissive behavior, making them suitable for development and testing environments where all features are enabled by default.
+
+## Files Overview
+- `__init__.py`: Exposes the main public classes of the middleware package for easy importing.
+- `config_resolver.py`: Defines the default, permissive configuration resolution middleware.
+- `registry.py`: Provides the `MiddlewareRegistry` for dynamically binding custom middleware implementations.
+
+## Developer API Reference
+
+### __init__.py
+**Purpose:** This file serves as the entry point to the `middleware` package, exporting the primary public interfaces for developers to use.
+
+**Usage Examples:**
+```python
+# Import the main classes directly from the middleware package
+from solace_ai_connector.common.middleware import ConfigResolver, MiddlewareRegistry
+
+# Now you can use ConfigResolver and MiddlewareRegistry
+print(ConfigResolver)
+print(MiddlewareRegistry)
+```
+
+---
+
+### config_resolver.py
+**Purpose:** This file provides a pluggable interface for resolving user-specific configuration and determining feature availability. The default `ConfigResolver` class is permissive, allowing all operations and enabling all features, which is ideal for development or simple deployments.
+
+**Import:** `from solace_ai_connector.common.middleware import ConfigResolver`
+
+**Classes:**
+- `ConfigResolver()` - A class containing static methods to resolve user-specific configuration and determine feature availability. This default implementation is permissive.
+  - `resolve_user_config(user_identity: Any, gateway_context: Dict[str, Any], base_config: Dict[str, Any]) -> Dict[str, Any]` - (async) Resolves user-specific configuration. The default implementation returns the `base_config` unchanged.
+  - `is_feature_enabled(user_config: Dict[str, Any], feature_descriptor: Dict[str, Any], context: Dict[str, Any]) -> bool` - Checks if a feature is enabled for a user. The default implementation always returns `True`.
+  - `validate_operation_config(user_config: Dict[str, Any], operation_spec: Dict[str, Any], validation_context: Dict[str, Any]) -> Dict[str, Any]` - Validates if an operation is allowed for a user. The default implementation always returns a dictionary with `{'valid': True}`.
+  - `filter_available_options(user_config: Dict[str, Any], available_options: List[Dict[str, Any]], filter_context: Dict[str, Any]) -> List[Dict[str, Any]]` - Filters a list of options based on user permissions. The default implementation returns the original `available_options` list.
+
+**Usage Examples:**
+```python
+import asyncio
+from solace_ai_connector.common.middleware import ConfigResolver
+
+async def main():
+    # Example user identity and base configuration
+    user_id = "test-user@example.com"
+    base_conf = {"api_key": "default_key", "allowed_models": ["gpt-3.5-turbo"]}
+
+    # 1. Resolve user configuration (default implementation returns base_conf)
+    user_config = await ConfigResolver.resolve_user_config(
+        user_identity=user_id,
+        gateway_context={"gateway_id": "gw-1"},
+        base_config=base_conf
+    )
+    print(f"Resolved User Config: {user_config}")
+
+    # 2. Check if a feature is enabled (default is always True)
+    feature_desc = {"feature_type": "ai_tool", "function_name": "code_interpreter"}
+    is_enabled = ConfigResolver.is_feature_enabled(
+        user_config=user_config,
+        feature_descriptor=feature_desc,
+        context={}
+    )
+    print(f"Is Feature Enabled: {is_enabled}")
+
+    # 3. Validate an operation (default is always valid)
+    op_spec = {"operation_type": "model_inference", "model": "gpt-4"}
+    validation = ConfigResolver.validate_operation_config(
+        user_config=user_config,
+        operation_spec=op_spec,
+        validation_context={}
+    )
+    print(f"Operation Validation: {validation}")
+
+    # 4. Filter available options (default returns all options)
+    all_models = [
+        {"name": "gpt-3.5-turbo", "provider": "openai"},
+        {"name": "gpt-4", "provider": "openai"},
+    ]
+    available_models = ConfigResolver.filter_available_options(
+        user_config=user_config,
+        available_options=all_models,
+        filter_context={"type": "language_model"}
+    )
+    print(f"Filtered Options: {available_models}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+### registry.py
+**Purpose:** This file provides the `MiddlewareRegistry`, a static class that allows developers to dynamically bind, or "plug in," their own custom middleware implementations at runtime. This is the core of the pluggable system.
+
+**Import:** `from solace_ai_connector.common.middleware import MiddlewareRegistry`
+
+**Classes:**
+- `MiddlewareRegistry()` - A registry for managing middleware implementations. All methods are class methods.
+  - `bind_config_resolver(resolver_class: Type)` - Binds a custom class that implements the `ConfigResolver` interface. This new class will be used for all subsequent configuration resolution calls.
+  - `get_config_resolver() -> Type` - Returns the currently bound `ConfigResolver` class. If no custom resolver has been bound, it returns the default `ConfigResolver`.
+  - `register_initialization_callback(callback: callable)` - Registers a function to be executed when `initialize_middleware()` is called. Useful for setting up custom middleware components at application startup.
+  - `initialize_middleware()` - Executes all registered initialization callbacks. This should be called once during application startup.
+  - `reset_bindings()` - Resets all bindings back to their defaults. This is primarily useful for testing environments.
+  - `get_registry_status() -> Dict[str, Any]` - Returns a dictionary containing the current status of the registry, such as which resolver is bound.
+
+**Usage Examples:**
+```python
+import asyncio
+from typing import Any, Dict, List
+from solace_ai_connector.common.middleware import MiddlewareRegistry, ConfigResolver
+
+# 1. Define a custom ConfigResolver implementation
+class MyCustomConfigResolver:
+    """A custom resolver that only allows 'admin' users to use 'gpt-4'."""
+    @staticmethod
+    async def resolve_user_config(user_identity: Any, **kwargs) -> Dict[str, Any]:
+        if user_identity == "admin":
+            return {"role": "admin", "allowed_models": ["gpt-4", "gpt-3.5-turbo"]}
+        return {"role": "user", "allowed_models": ["gpt-3.5-turbo"]}
+
+    @staticmethod
+    def validate_operation_config(user_config: Dict, operation_spec: Dict, **kwargs) -> Dict:
+        model = operation_spec.get("model")
+        if model and model not in user_config.get("allowed_models", []):
+            return {"valid": False, "reason": f"Model '{model}' not allowed for this user."}
+        return {"valid": True}
+    
+    # Inherit other methods from the default for simplicity
+    is_feature_enabled = ConfigResolver.is_feature_enabled
+    filter_available_options = ConfigResolver.filter_available_options
+
+# 2. Define an initialization callback
+def setup_custom_logging():
+    print("Custom middleware initialization logic is running!")
+
+# 3. Bind the custom components
+MiddlewareRegistry.bind_config_resolver(MyCustomConfigResolver)
+MiddlewareRegistry.register_initialization_callback(setup_custom_logging)
+
+# 4. Initialize the middleware (e.g., at application startup)
+print("--- Initializing Middleware ---")
+MiddlewareRegistry.initialize_middleware()
+print("--- Initialization Complete ---")
+
+# 5. Use the middleware system
+async def check_permissions():
+    # The registry will now use MyCustomConfigResolver automatically
+    CurrentResolver = MiddlewareRegistry.get_config_resolver()
+    print(f"Current resolver is: {CurrentResolver.__name__}")
+
+    # Check an admin user
+    admin_config = await CurrentResolver.resolve_user_config("admin")
+    validation_result = CurrentResolver.validate_operation_config(
+        admin_config, {"model": "gpt-4"}
+    )
+    print(f"Admin validation for gpt-4: {validation_result}")
+
+    # Check a regular user
+    user_config = await CurrentResolver.resolve_user_config("user")
+    validation_result = CurrentResolver.validate_operation_config(
+        user_config, {"model": "gpt-4"}
+    )
+    print(f"User validation for gpt-4: {validation_result}")
+
+# Run the example
+asyncio.run(check_permissions())
+
+# 6. Check status and reset (useful for testing)
+print(f"\nRegistry Status: {MiddlewareRegistry.get_registry_status()}")
+MiddlewareRegistry.reset_bindings()
+print(f"Registry Status after reset: {MiddlewareRegistry.get_registry_status()}")
+```

solace_agent_mesh/common/middleware/registry.py

@@ -0,0 +1,125 @@
+"""
+Registry for dynamically binding middleware implementations.
+
+This module provides a registry system that allows middleware implementations
+to be bound at runtime, enabling pluggable behavior for configuration resolution
+and other middleware functions.
+"""
+
+from typing import Optional, Type, Dict, Any, List
+from solace_ai_connector.common.log import log
+
+LOG_IDENTIFIER = "[MiddlewareRegistry]"
+
+
+class MiddlewareRegistry:
+    """
+    Registry for middleware implementations that can be overridden at runtime.
+
+    This registry allows different implementations of middleware to be bound
+    dynamically, enabling extensibility and customization of system behavior.
+    """
+
+    _config_resolver: Optional[Type] = None
+    _initialization_callbacks: List[callable] = []
+
+    @classmethod
+    def bind_config_resolver(cls, resolver_class: Type):
+        """
+        Bind a custom config resolver implementation.
+
+        Args:
+            resolver_class: Class that implements the ConfigResolver interface
+        """
+        cls._config_resolver = resolver_class
+        log.info(
+            "%s Bound custom config resolver: %s",
+            LOG_IDENTIFIER,
+            resolver_class.__name__,
+        )
+
+    @classmethod
+    def get_config_resolver(cls) -> Type:
+        """
+        Get the current config resolver implementation.
+
+        Returns:
+            The bound config resolver class, or the default ConfigResolver if none bound.
+        """
+        if cls._config_resolver:
+            return cls._config_resolver
+
+        from .config_resolver import ConfigResolver
+
+        return ConfigResolver
+
+    @classmethod
+    def register_initialization_callback(cls, callback: callable):
+        """
+        Register a callback to be called during system initialization.
+
+        Args:
+            callback: Function to call during initialization
+        """
+        cls._initialization_callbacks.append(callback)
+        log.debug(
+            "%s Registered initialization callback: %s",
+            LOG_IDENTIFIER,
+            callback.__name__,
+        )
+
+    @classmethod
+    def initialize_middleware(cls):
+        """
+        Initialize all registered middleware components.
+
+        This should be called during system startup to initialize any
+        bound middleware implementations.
+        """
+        log.info("%s Initializing middleware components...", LOG_IDENTIFIER)
+
+        for callback in cls._initialization_callbacks:
+            try:
+                callback()
+                log.debug(
+                    "%s Executed initialization callback: %s",
+                    LOG_IDENTIFIER,
+                    callback.__name__,
+                )
+            except Exception as e:
+                log.error(
+                    "%s Error executing initialization callback %s: %s",
+                    LOG_IDENTIFIER,
+                    callback.__name__,
+                    e,
+                )
+
+        log.info("%s Middleware initialization complete.", LOG_IDENTIFIER)
+
+    @classmethod
+    def reset_bindings(cls):
+        """
+        Reset all bindings to defaults.
+
+        This is useful for testing or when switching between different
+        middleware configurations.
+        """
+        cls._config_resolver = None
+        cls._initialization_callbacks = []
+        log.info("%s Reset all middleware bindings", LOG_IDENTIFIER)
+
+    @classmethod
+    def get_registry_status(cls) -> Dict[str, Any]:
+        """
+        Get the current status of the middleware registry.
+
+        Returns:
+            Dict containing information about bound middleware implementations.
+        """
+        return {
+            "config_resolver": (
+                cls._config_resolver.__name__ if cls._config_resolver else "default"
+            ),
+            "initialization_callbacks": len(cls._initialization_callbacks),
+            "has_custom_bindings": cls._config_resolver is not None,
+        }

solace_agent_mesh/common/server/__init__.py

@@ -0,0 +1,4 @@
+from .server import A2AServer
+from .task_manager import TaskManager, InMemoryTaskManager
+
+__all__ = ["A2AServer", "TaskManager", "InMemoryTaskManager"]

solace_agent_mesh/common/server/server.py

@@ -0,0 +1,122 @@
+from starlette.applications import Starlette
+from starlette.responses import JSONResponse
+from sse_starlette.sse import EventSourceResponse
+from starlette.requests import Request
+from ...common.types import (
+    A2ARequest,
+    JSONRPCResponse,
+    InvalidRequestError,
+    JSONParseError,
+    GetTaskRequest,
+    CancelTaskRequest,
+    SendTaskRequest,
+    SetTaskPushNotificationRequest,
+    GetTaskPushNotificationRequest,
+    InternalError,
+    AgentCard,
+    TaskResubscriptionRequest,
+    SendTaskStreamingRequest,
+)
+from pydantic import ValidationError
+import json
+from typing import AsyncIterable, Any
+from solace_ai_connector.common.log import log
+
+from ...common.server.task_manager import TaskManager
+
+
+class A2AServer:
+    def __init__(
+        self,
+        host="0.0.0.0",
+        port=5000,
+        endpoint="/",
+        agent_card: AgentCard = None,
+        task_manager: TaskManager = None,
+    ):
+        self.host = host
+        self.port = port
+        self.endpoint = endpoint
+        self.task_manager = task_manager
+        self.agent_card = agent_card
+        self.app = Starlette()
+        self.app.add_route(self.endpoint, self._process_request, methods=["POST"])
+        self.app.add_route(
+            "/.well-known/agent.json", self._get_agent_card, methods=["GET"]
+        )
+
+    def start(self):
+        if self.agent_card is None:
+            raise ValueError("agent_card is not defined")
+
+        if self.task_manager is None:
+            raise ValueError("request_handler is not defined")
+
+        import uvicorn
+
+        uvicorn.run(self.app, host=self.host, port=self.port)
+
+    def _get_agent_card(self, request: Request) -> JSONResponse:
+        return JSONResponse(self.agent_card.model_dump(exclude_none=True))
+
+    async def _process_request(self, request: Request):
+        try:
+            body = await request.json()
+            json_rpc_request = A2ARequest.validate_python(body)
+
+            if isinstance(json_rpc_request, GetTaskRequest):
+                result = await self.task_manager.on_get_task(json_rpc_request)
+            elif isinstance(json_rpc_request, SendTaskRequest):
+                result = await self.task_manager.on_send_task(json_rpc_request)
+            elif isinstance(json_rpc_request, SendTaskStreamingRequest):
+                result = await self.task_manager.on_send_task_subscribe(
+                    json_rpc_request
+                )
+            elif isinstance(json_rpc_request, CancelTaskRequest):
+                result = await self.task_manager.on_cancel_task(json_rpc_request)
+            elif isinstance(json_rpc_request, SetTaskPushNotificationRequest):
+                result = await self.task_manager.on_set_task_push_notification(
+                    json_rpc_request
+                )
+            elif isinstance(json_rpc_request, GetTaskPushNotificationRequest):
+                result = await self.task_manager.on_get_task_push_notification(
+                    json_rpc_request
+                )
+            elif isinstance(json_rpc_request, TaskResubscriptionRequest):
+                result = await self.task_manager.on_resubscribe_to_task(
+                    json_rpc_request
+                )
+            else:
+                log.warning("Unexpected request type: %s", type(json_rpc_request))
+                raise ValueError("Unexpected request type: %s" % type(request))
+
+            return self._create_response(result)
+
+        except Exception as e:
+            return self._handle_exception(e)
+
+    def _handle_exception(self, e: Exception) -> JSONResponse:
+        if isinstance(e, json.decoder.JSONDecodeError):
+            json_rpc_error = JSONParseError()
+        elif isinstance(e, ValidationError):
+            json_rpc_error = InvalidRequestError(data=json.loads(e.json()))
+        else:
+            log.error("Unhandled exception: %s", e, exc_info=True)
+            json_rpc_error = InternalError()
+
+        response = JSONRPCResponse(id=None, error=json_rpc_error)
+        return JSONResponse(response.model_dump(exclude_none=True), status_code=400)
+
+    def _create_response(self, result: Any) -> JSONResponse | EventSourceResponse:
+        if isinstance(result, AsyncIterable):
+
+            async def event_generator(result) -> AsyncIterable[dict[str, str]]:
+                async for item in result:
+                    yield {"data": item.model_dump_json(exclude_none=True)}
+
+            return EventSourceResponse(event_generator(result))
+        elif isinstance(result, JSONRPCResponse):
+            return JSONResponse(result.model_dump(exclude_none=True))
+        else:
+            log.error("Unexpected result type: %s", type(result))
+            raise ValueError("Unexpected result type: %s" % type(result))

solace_agent_mesh/common/server/server_llm.txt

@@ -0,0 +1,169 @@
+## Quick Summary
+The `server` directory provides a complete, stand-alone Agent-to-Agent (A2A) communication server. It is built using Starlette and implements the JSON-RPC 2.0 protocol for handling various task-related requests, including standard request-response, task streaming via Server-Sent Events (SSE), and push notification management. It features an extensible task management system with a default in-memory implementation.
+
+## Files Overview
+- `__init__.py`: Exposes the primary public classes (`A2AServer`, `TaskManager`, `InMemoryTaskManager`) for easy access.
+- `server.py`: Contains the main `A2AServer` class, which sets up the Starlette web application, defines HTTP endpoints, and routes incoming A2A requests to the task manager.
+- `task_manager.py`: Defines the `TaskManager` abstract base class, which outlines the contract for handling all task operations, and provides a concrete `InMemoryTaskManager` implementation.
+- `utils.py`: A collection of utility functions for creating standardized error responses and checking modality compatibility.
+
+## Developer API Reference
+
+### __init__.py
+**Purpose:** This file makes the core server components available for direct import from the `server` package, simplifying access for developers.
+**Import:** `from solace_ai_connector.common.server import A2AServer, TaskManager, InMemoryTaskManager`
+
+---
+
+### server.py
+**Purpose:** Implements the core HTTP server for Agent-to-Agent (A2A) communication. It handles JSON-RPC request parsing, routing to the appropriate task manager methods, and response generation, including support for Server-Sent Events (SSE).
+**Import:** `from solace_ai_connector.common.server import A2AServer`
+
+**Classes:**
+- `A2AServer(host: str = "0.0.0.0", port: int = 5000, endpoint: str = "/", agent_card: AgentCard = None, task_manager: TaskManager = None)` - A Starlette-based web server that exposes A2A endpoints.
+  - `start() -> None` - Starts the web server using uvicorn. Raises a `ValueError` if `agent_card` or `task_manager` are not set.
+  - `host: str` - The host address the server will bind to.
+  - `port: int` - The port the server will listen on.
+  - `endpoint: str` - The main API endpoint path for receiving JSON-RPC requests.
+  - `task_manager: TaskManager` - The handler responsible for all task-related business logic.
+  - `agent_card: AgentCard` - The metadata for the agent, served at `/.well-known/agent.json`.
+  
+**Usage Examples:**
+```python
+# main.py
+from solace_ai_connector.common.server import A2AServer, InMemoryTaskManager
+from solace_ai_connector.common.types import AgentCard
+
+# 1. Define the agent's capabilities and metadata
+my_agent_card = AgentCard(
+    id="my-awesome-agent-v1",
+    name="Awesome Agent",
+    version="1.0.0",
+    description="An agent that does awesome things.",
+    documentation_url="https://example.com/docs",
+    supported_tasks=["summarize", "translate"],
+    input_modalities=["text/plain"],
+    output_modalities=["text/plain"]
+)
+
+# 2. Instantiate a task manager (or use your own custom implementation)
+# This example uses a basic in-memory manager.
+# For a real agent, you would extend InMemoryTaskManager to implement your logic.
+class MyAgentTaskManager(InMemoryTaskManager):
+    async def on_send_task(self, request):
+        # Implement your agent's logic here
+        pass
+    async def on_send_task_subscribe(self, request):
+        # Implement your agent's streaming logic here
+        pass
+
+task_manager = MyAgentTaskManager()
+
+# 3. Create and configure the server
+server = A2AServer(
+    host="127.0.0.1",
+    port=8080,
+    endpoint="/api/v1/a2a",
+    agent_card=my_agent_card,
+    task_manager=task_manager
+)
+
+# 4. Start the server
+if __name__ == "__main__":
+    print("Starting A2A Server...")
+    server.start()
+```
+
+---
+
+### task_manager.py
+**Purpose:** Defines the abstract interface for task management and provides a ready-to-use, in-memory implementation. This is the core component for implementing an agent's business logic.
+**Import:** `from solace_ai_connector.common.server import TaskManager, InMemoryTaskManager`
+
+**Classes:**
+- `TaskManager()` - An abstract base class that defines the interface for handling all A2A task-related operations. Developers must implement these methods in a subclass.
+  - `on_get_task(request: GetTaskRequest) -> GetTaskResponse` - Handles a request to retrieve the status and details of a task.
+  - `on_cancel_task(request: CancelTaskRequest) -> CancelTaskResponse` - Handles a request to cancel an ongoing task.
+  - `on_send_task(request: SendTaskRequest) -> SendTaskResponse` - Handles a standard request-response task submission.
+  - `on_send_task_subscribe(request: SendTaskStreamingRequest) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]` - Handles a task submission that requires a streaming response (SSE).
+  - `on_set_task_push_notification(request: SetTaskPushNotificationRequest) -> SetTaskPushNotificationResponse` - Handles a request to configure push notifications for a task.
+  - `on_get_task_push_notification(request: GetTaskPushNotificationRequest) -> GetTaskPushNotificationResponse` - Handles a request to retrieve the push notification configuration for a task.
+  - `on_resubscribe_to_task(request: TaskResubscriptionRequest) -> Union[AsyncIterable[SendTaskResponse], JSONRPCResponse]` - Handles a request to resubscribe to a streaming task.
+
+- `InMemoryTaskManager()` - A concrete implementation of `TaskManager` that stores tasks and push notification configurations in memory. It provides helper methods to manage task state and SSE subscriptions. It is designed to be extended.
+  - `upsert_task(task_send_params: TaskSendParams) -> Task` - Creates a new task or retrieves an existing one by its ID, adding the new message to its history.
+  - `update_store(task_id: str, status: TaskStatus, artifacts: list[Artifact]) -> Task` - Updates the status, message history, and artifacts of a specific task.
+  - `set_push_notification_info(task_id: str, notification_config: PushNotificationConfig) -> None` - Stores the push notification configuration for a given task.
+  - `get_push_notification_info(task_id: str) -> PushNotificationConfig` - Retrieves the push notification configuration for a given task.
+  - `has_push_notification_info(task_id: str) -> bool` - Checks if a push notification configuration exists for a task.
+  - `setup_sse_consumer(task_id: str, is_resubscribe: bool = False) -> asyncio.Queue` - Creates and registers an `asyncio.Queue` for a new SSE subscriber for a given task.
+  - `enqueue_events_for_sse(task_id: str, task_update_event: Any) -> None` - Puts a new event (e.g., `TaskStatusUpdateEvent`) into the queues of all active SSE subscribers for a task.
+  - `dequeue_events_for_sse(request_id: str, task_id: str, sse_event_queue: asyncio.Queue) -> AsyncIterable[SendTaskStreamingResponse]` - An async generator that yields events from an SSE queue, wrapping them in `SendTaskStreamingResponse` objects.
+
+**Usage Examples:**
+```python
+# custom_task_manager.py
+import asyncio
+from solace_ai_connector.common.server import InMemoryTaskManager
+from solace_ai_connector.common.types import (
+    SendTaskRequest, SendTaskResponse, Task, TaskStatus, TaskState,
+    SendTaskStreamingRequest, SendTaskStreamingResponse, TaskStatusUpdateEvent
+)
+from typing import AsyncIterable, Union
+
+class MyCustomTaskManager(InMemoryTaskManager):
+    # Implement the core logic for a standard task
+    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+        task = await self.upsert_task(request.params)
+        print(f"Received task {task.id} with message: {request.params.message.content}")
+        
+        # Simulate work
+        await asyncio.sleep(2)
+        
+        # Update task status to completed
+        final_status = TaskStatus(state=TaskState.COMPLETED)
+        await self.update_store(task.id, final_status, [])
+        
+        return SendTaskResponse(id=request.id, result=task)
+
+    # Implement the core logic for a streaming task
+    async def on_send_task_subscribe(
+        self, request: SendTaskStreamingRequest
+    ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
+        
+        await self.upsert_task(request.params)
+        sse_queue = await self.setup_sse_consumer(request.params.id)
+
+        # Start the background task processing
+        asyncio.create_task(self._process_streaming_task(request.params.id))
+
+        # Return the async generator that will stream responses
+        return self.dequeue_events_for_sse(request.id, request.params.id, sse_queue)
+
+    async def _process_streaming_task(self, task_id: str):
+        # Simulate streaming work
+        for i in range(5):
+            await asyncio.sleep(1)
+            update = TaskStatusUpdateEvent(
+                status=TaskStatus(state=TaskState.IN_PROGRESS),
+                message={"content": f"Step {i+1} complete"}
+            )
+            # Enqueue the update for all subscribers
+            await self.enqueue_events_for_sse(task_id, update)
+        
+        # Send final event
+        final_update = TaskStatusUpdateEvent(
+            status=TaskStatus(state=TaskState.COMPLETED),
+            final=True
+        )
+        await self.enqueue_events_for_sse(task_id, final_update)
+```
+
+---
+
+### utils.py
+**Purpose:** Provides common utility functions used within the server, primarily for creating standardized JSON-RPC error responses and performing compatibility checks.
+**Import:** `from solace_ai_connector.common.server.utils import are_modalities_compatible, new_incompatible_types_error, new_not_implemented_error`
+
+**Functions:**
+- `are_modalities_compatible(server_output_