march-agent 0.1.1__py3-none-any.whl

march_agent/gateway_client.py

@@ -0,0 +1,506 @@
+"""
+Gateway client for connecting to the Agent Gateway service.
+Handles gRPC communication for Kafka and HTTP for other services.
+"""
+
+import json
+import logging
+import queue
+import threading
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Optional, Any, Tuple
+
+import grpc
+import requests
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class KafkaMessage:
+    """Represents a message received from Kafka via the gateway."""
+    topic: str
+    partition: int
+    offset: int
+    key: str
+    headers: Dict[str, str]
+    body: Dict[str, Any]
+    timestamp: int
+
+
+class GatewayClient:
+    """
+    Client for communicating with the Agent Gateway.
+
+    Provides:
+    - gRPC bidirectional streaming for Kafka consume/produce
+    - HTTP proxy for AI Inventory and Conversation Store
+    """
+
+    def __init__(self, gateway_url: str, api_key: str, secure: bool = False):
+        """
+        Initialize the gateway client.
+
+        Args:
+            gateway_url: Gateway endpoint (e.g., "agent-gateway:8080")
+            api_key: API key for authentication
+            secure: If True, use TLS for gRPC and HTTPS for HTTP requests
+        """
+        # Both gRPC and HTTP use the same endpoint (multiplexed via cmux)
+        self.grpc_url = gateway_url
+        self.secure = secure
+        scheme = "https" if secure else "http"
+        self.http_url = f"{scheme}://{gateway_url}"
+        self.api_key = api_key
+
+        self.channel: Optional[grpc.Channel] = None
+        self.stub = None
+        self.stream = None
+
+        self.connection_id: Optional[str] = None
+        self.subscribed_topics: List[str] = []
+
+        self._running = False
+        self._send_queue: queue.Queue = queue.Queue()
+        self._lock = threading.Lock()
+
+        # Import generated protobuf code lazily
+        self._pb = None
+        self._pb_grpc = None
+
+        # Topic handlers (for compatibility, routing done by MarchAgentApp)
+        self._handlers: Dict[str, Callable] = {}
+
+        # Async HTTP session
+        self._http_session: Optional[aiohttp.ClientSession] = None
+
+    def _load_protobuf(self):
+        """Lazily load protobuf modules."""
+        if self._pb is None:
+            from . import gateway_pb2 as pb
+            from . import gateway_pb2_grpc as pb_grpc
+            self._pb = pb
+            self._pb_grpc = pb_grpc
+
+    @property
+    def ai_inventory_url(self) -> str:
+        """HTTP URL for AI Inventory service via proxy."""
+        return f"{self.http_url}/s/ai-inventory"
+
+    @property
+    def conversation_store_url(self) -> str:
+        """HTTP URL for Conversation Store service via proxy."""
+        return f"{self.http_url}/s/conversation-store"
+
+    @property
+    def ai_memory_url(self) -> str:
+        """HTTP URL for AI Memory service via proxy."""
+        return f"{self.http_url}/s/ai-memory"
+
+    def register_handler(self, topic: str, handler: Callable) -> None:
+        """
+        Register a handler for a topic.
+
+        Note: Message routing is handled by MarchAgentApp._consume_loop(),
+        this method is kept for compatibility.
+        """
+        self._handlers[topic] = handler
+        logger.debug(f"Registered handler for topic: {topic}")
+
+    def connect(self, agent_names: List[str]) -> List[str]:
+        """
+        Connect to the gateway and authenticate.
+
+        Args:
+            agent_names: List of agent names to subscribe to
+
+        Returns:
+            List of subscribed topic names
+        """
+        self._load_protobuf()
+        pb = self._pb
+        pb_grpc = self._pb_grpc
+
+        logger.info(f"Connecting to gRPC gateway at {self.grpc_url} (secure={self.secure})")
+
+        # Create gRPC channel with keepalive settings
+        options = [
+            ('grpc.keepalive_time_ms', 30000),  # Send keepalive ping every 30s
+            ('grpc.keepalive_timeout_ms', 10000),  # Wait 10s for ping ack
+            ('grpc.keepalive_permit_without_calls', True),  # Allow pings without active calls
+            ('grpc.http2.min_time_between_pings_ms', 10000),  # Min time between pings
+            ('grpc.http2.max_pings_without_data', 0),  # Unlimited pings without data
+        ]
+
+        if self.secure:
+            # Use system default SSL credentials for TLS
+            credentials = grpc.ssl_channel_credentials()
+            self.channel = grpc.secure_channel(self.grpc_url, credentials, options=options)
+        else:
+            self.channel = grpc.insecure_channel(self.grpc_url, options=options)
+        self.stub = pb_grpc.AgentGatewayStub(self.channel)
+
+        # Start bidirectional stream
+        self._running = True
+
+        # Prepare auth message to send first
+        auth_request = pb.ClientMessage(
+            auth=pb.AuthRequest(
+                api_key=self.api_key,
+                agent_names=agent_names
+            )
+        )
+
+        # Create request iterator that sends auth first, then reads from queue
+        self._request_iterator = self._generate_requests(auth_request)
+
+        # Start the stream
+        self.stream = self.stub.AgentStream(self._request_iterator)
+
+        # Wait for auth response
+        try:
+            response = next(self.stream)
+
+            if response.HasField("error"):
+                error = response.error
+                raise AuthenticationError(f"Authentication failed: {error.message}")
+
+            if response.HasField("auth_response"):
+                auth_resp = response.auth_response
+                self.connection_id = auth_resp.connection_id
+                self.subscribed_topics = list(auth_resp.subscribed_topics)
+
+                logger.info(f"Connected to gateway (connection_id: {self.connection_id})")
+                logger.info(f"Subscribed to topics: {self.subscribed_topics}")
+
+                return self.subscribed_topics
+            else:
+                raise GatewayError(f"Unexpected response type")
+
+        except grpc.RpcError as e:
+            raise GatewayError(f"gRPC error during auth: {e}")
+
+    def _generate_requests(self, first_message=None):
+        """Generator that yields requests. Sends first_message immediately, then from queue."""
+        # Send the first message (auth) immediately
+        if first_message:
+            logger.debug("Sending auth message")
+            yield first_message
+
+        # Then continue with queued messages
+        while self._running:
+            try:
+                msg = self._send_queue.get(timeout=0.1)
+                yield msg
+            except queue.Empty:
+                continue
+
+    def subscribe(self, agent_name: str) -> str:
+        """
+        Subscribe to an additional agent's topic.
+
+        Args:
+            agent_name: Name of the agent to subscribe to
+
+        Returns:
+            Topic name that was subscribed to
+        """
+        pb = self._pb
+
+        if not self.stream:
+            raise GatewayError("Not connected to gateway")
+
+        msg = pb.ClientMessage(
+            subscribe=pb.SubscribeRequest(agent_name=agent_name)
+        )
+        self._send_queue.put(msg)
+
+        # Wait for response
+        try:
+            response = next(self.stream)
+
+            if response.HasField("error"):
+                raise GatewayError(f"Subscribe failed: {response.error.message}")
+
+            if response.HasField("subscribe_ack"):
+                topic = response.subscribe_ack.topic
+                self.subscribed_topics.append(topic)
+                logger.info(f"Subscribed to topic: {topic}")
+                return topic
+
+        except grpc.RpcError as e:
+            raise GatewayError(f"Subscribe failed: {e}")
+
+        raise GatewayError("Unexpected response")
+
+    def unsubscribe(self, agent_name: str) -> None:
+        """
+        Unsubscribe from an agent's topic.
+
+        Args:
+            agent_name: Name of the agent to unsubscribe from
+        """
+        pb = self._pb
+
+        if not self.stream:
+            raise GatewayError("Not connected to gateway")
+
+        msg = pb.ClientMessage(
+            unsubscribe=pb.UnsubscribeRequest(agent_name=agent_name)
+        )
+        self._send_queue.put(msg)
+
+        topic = f"{agent_name}.inbox"
+        if topic in self.subscribed_topics:
+            self.subscribed_topics.remove(topic)
+        logger.info(f"Unsubscribed from agent: {agent_name}")
+
+    def produce(
+        self,
+        topic: str,
+        key: str,
+        headers: Dict[str, str],
+        body: Dict[str, Any],
+        correlation_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Produce a message to Kafka via the gateway.
+
+        Args:
+            topic: Target topic (usually "router.inbox")
+            key: Message key (usually conversation_id)
+            headers: Message headers
+            body: Message body
+            correlation_id: Optional correlation ID for tracking
+
+        Returns:
+            Produce acknowledgment with partition and offset
+        """
+        pb = self._pb
+
+        if not self.stream:
+            raise GatewayError("Not connected to gateway")
+
+        # Serialize body to JSON bytes
+        body_bytes = json.dumps(body).encode('utf-8')
+
+        msg = pb.ClientMessage(
+            produce=pb.ProduceRequest(
+                topic=topic,
+                key=key,
+                headers=headers,
+                body=body_bytes,
+                correlation_id=correlation_id or ""
+            )
+        )
+        self._send_queue.put(msg)
+
+        # Don't block waiting for ack
+        return {"status": "sent", "topic": topic}
+
+    def consume_one(self, timeout: float = 1.0) -> Optional[KafkaMessage]:
+        """
+        Consume a single message (blocking).
+
+        Args:
+            timeout: Maximum time to wait for a message
+
+        Returns:
+            KafkaMessage or None if timeout
+        """
+        if not self.stream:
+            raise GatewayError("Not connected to gateway")
+
+        try:
+            response = next(self.stream)
+
+            if response.HasField("message"):
+                kafka_msg = response.message
+
+                # Parse body from JSON bytes
+                try:
+                    body = json.loads(kafka_msg.body.decode('utf-8'))
+                except json.JSONDecodeError:
+                    body = {}
+
+                return KafkaMessage(
+                    topic=kafka_msg.topic,
+                    partition=kafka_msg.partition,
+                    offset=kafka_msg.offset,
+                    key=kafka_msg.key,
+                    headers=dict(kafka_msg.headers),
+                    body=body,
+                    timestamp=kafka_msg.timestamp
+                )
+            elif response.HasField("produce_ack"):
+                logger.debug(f"Received produce_ack for topic {response.produce_ack.topic}")
+                return None
+            elif response.HasField("pong"):
+                return None
+            elif response.HasField("error"):
+                logger.error(f"Gateway error: {response.error.message}")
+                return None
+            else:
+                logger.debug(f"Received other message type")
+                return None
+
+        except StopIteration:
+            logger.warning("Stream ended")
+            raise GatewayError("Stream ended unexpectedly")
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
+                return None
+            logger.error(f"Error in consume_one: {e}")
+            raise GatewayError(f"Consume error: {e}")
+
+    def ping(self) -> int:
+        """
+        Send a ping to the gateway.
+
+        Returns:
+            Client timestamp sent
+        """
+        pb = self._pb
+
+        if not self.stream:
+            raise GatewayError("Not connected to gateway")
+
+        timestamp = int(time.time() * 1000)
+        msg = pb.ClientMessage(
+            ping=pb.PingRequest(timestamp=timestamp)
+        )
+        self._send_queue.put(msg)
+        return timestamp
+
+    async def _get_http_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session."""
+        if self._http_session is None or self._http_session.closed:
+            timeout = aiohttp.ClientTimeout(total=30.0)
+            self._http_session = aiohttp.ClientSession(timeout=timeout)
+        return self._http_session
+
+    async def close_async(self):
+        """Close async HTTP session."""
+        if self._http_session and not self._http_session.closed:
+            await self._http_session.close()
+
+    def close(self) -> None:
+        """Close the gateway connection."""
+        self._running = False
+
+        if self.channel:
+            try:
+                self.channel.close()
+            except Exception:
+                pass
+            self.channel = None
+
+        self.stream = None
+        self.stub = None
+        self.connection_id = None
+        self.subscribed_topics = []
+        logger.info("gRPC gateway connection closed")
+
+    # HTTP Proxy Methods (Sync - for registration)
+
+    def http_post(self, service: str, path: str, **kwargs) -> requests.Response:
+        """
+        Make a sync POST request (used for registration).
+
+        Args:
+            service: Service name ("ai-inventory" or "conversation-store")
+            path: Request path
+            **kwargs: Additional arguments passed to requests.post
+
+        Returns:
+            Response object
+        """
+        url = f"{self.http_url}/s/{service}{path}"
+        return requests.post(url, **kwargs)
+
+    # HTTP Proxy Methods (Async - for runtime)
+
+    async def http_get_async(self, service: str, path: str, **kwargs):
+        """
+        Make an async GET request to a service via the gateway proxy.
+
+        Args:
+            service: Service name ("ai-inventory" or "conversation-store")
+            path: Request path
+            **kwargs: Additional arguments passed to aiohttp
+
+        Returns:
+            Response object
+        """
+        url = f"{self.http_url}/s/{service}{path}"
+        session = await self._get_http_session()
+        async with session.get(url, **kwargs) as response:
+            response.raise_for_status()
+            return response
+
+    async def http_post_async(self, service: str, path: str, **kwargs):
+        """
+        Make an async POST request to a service via the gateway proxy.
+
+        Args:
+            service: Service name ("ai-inventory" or "conversation-store")
+            path: Request path
+            **kwargs: Additional arguments passed to aiohttp
+
+        Returns:
+            Response object
+        """
+        url = f"{self.http_url}/s/{service}{path}"
+        session = await self._get_http_session()
+        async with session.post(url, **kwargs) as response:
+            response.raise_for_status()
+            return response
+
+    async def http_patch_async(self, service: str, path: str, **kwargs):
+        """
+        Make an async PATCH request to a service via the gateway proxy.
+
+        Args:
+            service: Service name ("ai-inventory" or "conversation-store")
+            path: Request path
+            **kwargs: Additional arguments passed to aiohttp
+
+        Returns:
+            Response object
+        """
+        url = f"{self.http_url}/s/{service}{path}"
+        session = await self._get_http_session()
+        async with session.patch(url, **kwargs) as response:
+            response.raise_for_status()
+            return response
+
+    async def http_delete_async(self, service: str, path: str, **kwargs):
+        """
+        Make an async DELETE request to a service via the gateway proxy.
+
+        Args:
+            service: Service name ("ai-inventory" or "conversation-store")
+            path: Request path
+            **kwargs: Additional arguments passed to aiohttp
+
+        Returns:
+            Response object
+        """
+        url = f"{self.http_url}/s/{service}{path}"
+        session = await self._get_http_session()
+        async with session.delete(url, **kwargs) as response:
+            response.raise_for_status()
+            return response
+
+
+class GatewayError(Exception):
+    """Base exception for gateway errors."""
+    pass
+
+
+class AuthenticationError(GatewayError):
+    """Raised when authentication fails."""
+    pass

march_agent/gateway_pb2.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: gateway.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'gateway.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rgateway.proto\x12\x07gateway\"\xf6\x01\n\rClientMessage\x12$\n\x04\x61uth\x18\x01 \x01(\x0b\x32\x14.gateway.AuthRequestH\x00\x12.\n\tsubscribe\x18\x02 \x01(\x0b\x32\x19.gateway.SubscribeRequestH\x00\x12\x32\n\x0bunsubscribe\x18\x03 \x01(\x0b\x32\x1b.gateway.UnsubscribeRequestH\x00\x12*\n\x07produce\x18\x04 \x01(\x0b\x32\x17.gateway.ProduceRequestH\x00\x12$\n\x04ping\x18\x05 \x01(\x0b\x32\x14.gateway.PingRequestH\x00\x42\t\n\x07payload\"\xd4\x02\n\rServerMessage\x12.\n\rauth_response\x18\x01 \x01(\x0b\x32\x15.gateway.AuthResponseH\x00\x12(\n\x07message\x18\x02 \x01(\x0b\x32\x15.gateway.KafkaMessageH\x00\x12*\n\x0bproduce_ack\x18\x03 \x01(\x0b\x32\x13.gateway.ProduceAckH\x00\x12.\n\rsubscribe_ack\x18\x04 \x01(\x0b\x32\x15.gateway.SubscribeAckH\x00\x12\x32\n\x0funsubscribe_ack\x18\x05 \x01(\x0b\x32\x17.gateway.UnsubscribeAckH\x00\x12%\n\x04pong\x18\x06 \x01(\x0b\x32\x15.gateway.PongResponseH\x00\x12\'\n\x05\x65rror\x18\x07 \x01(\x0b\x32\x16.gateway.ErrorResponseH\x00\x42\t\n\x07payload\"3\n\x0b\x41uthRequest\x12\x0f\n\x07\x61pi_key\x18\x01 \x01(\t\x12\x13\n\x0b\x61gent_names\x18\x02 \x03(\t\"@\n\x0c\x41uthResponse\x12\x15\n\rconnection_id\x18\x01 \x01(\t\x12\x19\n\x11subscribed_topics\x18\x02 \x03(\t\"&\n\x10SubscribeRequest\x12\x12\n\nagent_name\x18\x01 \x01(\t\"\x1d\n\x0cSubscribeAck\x12\r\n\x05topic\x18\x01 \x01(\t\"(\n\x12UnsubscribeRequest\x12\x12\n\nagent_name\x18\x01 \x01(\t\"$\n\x0eUnsubscribeAck\x12\x12\n\nagent_name\x18\x01 \x01(\t\"\xb9\x01\n\x0eProduceRequest\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x0b\n\x03key\x18\x02 \x01(\t\x12\x35\n\x07headers\x18\x03 \x03(\x0b\x32$.gateway.ProduceRequest.HeadersEntry\x12\x0c\n\x04\x62ody\x18\x04 \x01(\x0c\x12\x16\n\x0e\x63orrelation_id\x18\x05 \x01(\t\x1a.\n\x0cHeadersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"V\n\nProduceAck\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x11\n\tpartition\x18\x02 \x01(\x05\x12\x0e\n\x06offset\x18\x03 \x01(\x03\x12\x16\n\x0e\x63orrelation_id\x18\x04 \x01(\t\"\xd3\x01\n\x0cKafkaMessage\x12\r\n\x05topic\x18\x01 \x01(\t\x12\x11\n\tpartition\x18\x02 \x01(\x05\x12\x0e\n\x06offset\x18\x03 \x01(\x03\x12\x0b\n\x03key\x18\x04 \x01(\t\x12\x33\n\x07headers\x18\x05 \x03(\x0b\x32\".gateway.KafkaMessage.HeadersEntry\x12\x0c\n\x04\x62ody\x18\x06 \x01(\x0c\x12\x11\n\ttimestamp\x18\x07 \x01(\x03\x1a.\n\x0cHeadersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\" \n\x0bPingRequest\x12\x11\n\ttimestamp\x18\x01 \x01(\x03\"B\n\x0cPongResponse\x12\x18\n\x10\x63lient_timestamp\x18\x01 \x01(\x03\x12\x18\n\x10server_timestamp\x18\x02 \x01(\x03\"F\n\rErrorResponse\x12\x0c\n\x04\x63ode\x18\x01 \x01(\t\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x16\n\x0e\x63orrelation_id\x18\x03 \x01(\t2Q\n\x0c\x41gentGateway\x12\x41\n\x0b\x41gentStream\x12\x16.gateway.ClientMessage\x1a\x16.gateway.ServerMessage(\x01\x30\x01\x42 Z\x1e\x61gent-gateway/internal/grpc/pbb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'gateway_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z\036agent-gateway/internal/grpc/pb'
+  _globals['_PRODUCEREQUEST_HEADERSENTRY']._loaded_options = None
+  _globals['_PRODUCEREQUEST_HEADERSENTRY']._serialized_options = b'8\001'
+  _globals['_KAFKAMESSAGE_HEADERSENTRY']._loaded_options = None
+  _globals['_KAFKAMESSAGE_HEADERSENTRY']._serialized_options = b'8\001'
+  _globals['_CLIENTMESSAGE']._serialized_start=27
+  _globals['_CLIENTMESSAGE']._serialized_end=273
+  _globals['_SERVERMESSAGE']._serialized_start=276
+  _globals['_SERVERMESSAGE']._serialized_end=616
+  _globals['_AUTHREQUEST']._serialized_start=618
+  _globals['_AUTHREQUEST']._serialized_end=669
+  _globals['_AUTHRESPONSE']._serialized_start=671
+  _globals['_AUTHRESPONSE']._serialized_end=735
+  _globals['_SUBSCRIBEREQUEST']._serialized_start=737
+  _globals['_SUBSCRIBEREQUEST']._serialized_end=775
+  _globals['_SUBSCRIBEACK']._serialized_start=777
+  _globals['_SUBSCRIBEACK']._serialized_end=806
+  _globals['_UNSUBSCRIBEREQUEST']._serialized_start=808
+  _globals['_UNSUBSCRIBEREQUEST']._serialized_end=848
+  _globals['_UNSUBSCRIBEACK']._serialized_start=850
+  _globals['_UNSUBSCRIBEACK']._serialized_end=886
+  _globals['_PRODUCEREQUEST']._serialized_start=889
+  _globals['_PRODUCEREQUEST']._serialized_end=1074
+  _globals['_PRODUCEREQUEST_HEADERSENTRY']._serialized_start=1028
+  _globals['_PRODUCEREQUEST_HEADERSENTRY']._serialized_end=1074
+  _globals['_PRODUCEACK']._serialized_start=1076
+  _globals['_PRODUCEACK']._serialized_end=1162
+  _globals['_KAFKAMESSAGE']._serialized_start=1165
+  _globals['_KAFKAMESSAGE']._serialized_end=1376
+  _globals['_KAFKAMESSAGE_HEADERSENTRY']._serialized_start=1028
+  _globals['_KAFKAMESSAGE_HEADERSENTRY']._serialized_end=1074
+  _globals['_PINGREQUEST']._serialized_start=1378
+  _globals['_PINGREQUEST']._serialized_end=1410
+  _globals['_PONGRESPONSE']._serialized_start=1412
+  _globals['_PONGRESPONSE']._serialized_end=1478
+  _globals['_ERRORRESPONSE']._serialized_start=1480
+  _globals['_ERRORRESPONSE']._serialized_end=1550
+  _globals['_AGENTGATEWAY']._serialized_start=1552
+  _globals['_AGENTGATEWAY']._serialized_end=1633
+# @@protoc_insertion_point(module_scope)

march_agent/gateway_pb2_grpc.py

@@ -0,0 +1,101 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import gateway_pb2 as gateway__pb2
+
+GRPC_GENERATED_VERSION = '1.76.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in gateway_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class AgentGatewayStub(object):
+    """Bidirectional streaming service for agent communication
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.AgentStream = channel.stream_stream(
+                '/gateway.AgentGateway/AgentStream',
+                request_serializer=gateway__pb2.ClientMessage.SerializeToString,
+                response_deserializer=gateway__pb2.ServerMessage.FromString,
+                _registered_method=True)
+
+
+class AgentGatewayServicer(object):
+    """Bidirectional streaming service for agent communication
+    """
+
+    def AgentStream(self, request_iterator, context):
+        """Main bidirectional stream for all agent communication
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_AgentGatewayServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'AgentStream': grpc.stream_stream_rpc_method_handler(
+                    servicer.AgentStream,
+                    request_deserializer=gateway__pb2.ClientMessage.FromString,
+                    response_serializer=gateway__pb2.ServerMessage.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'gateway.AgentGateway', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('gateway.AgentGateway', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class AgentGateway(object):
+    """Bidirectional streaming service for agent communication
+    """
+
+    @staticmethod
+    def AgentStream(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_stream(
+            request_iterator,
+            target,
+            '/gateway.AgentGateway/AgentStream',
+            gateway__pb2.ClientMessage.SerializeToString,
+            gateway__pb2.ServerMessage.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)