asyncapi-python 0.3.0rc2__tar.gz → 0.3.0rc4__tar.gz

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asyncapi-python
-Version: 0.3.0rc2
+Version: 0.3.0rc4
 Summary: Easily generate type-safe and async Python applications from AsyncAPI 3 specifications.
 Author-email: Yaroslav Petrov <yaroslav.v.petrov@gmail.com>
 License: Apache-2.0
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 # AsyncAPI Python Code Generator
 >
 > [!IMPORTANT]
-> Although commits to dev branch might seem infrequent, the project is under active development **as of August 2025**.
+> Although commits to dev branch might seem infrequent, the project is under active development **as of November 2025**.
 >
 > We currently produce only those changes that are required to satisfy our personal use cases.
 >

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/README.md

@@ -1,7 +1,7 @@
 # AsyncAPI Python Code Generator
 >
 > [!IMPORTANT]
-> Although commits to dev branch might seem infrequent, the project is under active development **as of August 2025**.
+> Although commits to dev branch might seem infrequent, the project is under active development **as of November 2025**.
 >
 > We currently produce only those changes that are required to satisfy our personal use cases.
 >

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asyncapi-python"
-version = "0.3.0rc2"
+version = "0.3.0rc4"
 license = { text = "Apache-2.0" }
 description = "Easily generate type-safe and async Python applications from AsyncAPI 3 specifications."
 authors = [{ name = "Yaroslav Petrov", email = "yaroslav.v.petrov@gmail.com" }]

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/codec/__init__.py

@@ -2,5 +2,4 @@
 
 from .registry import CodecRegistry
 
-
 __all__ = ["CodecRegistry"]

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/codec/json.py

@@ -1,6 +1,6 @@
 import json
-from typing import Type, ClassVar
 from types import ModuleType
+from typing import ClassVar, Type
 
 from pydantic import BaseModel, ValidationError
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/codec/registry.py

@@ -1,7 +1,9 @@
-from typing import ClassVar, Any
 from types import ModuleType
-from asyncapi_python.kernel.codec import CodecFactory, Codec
+from typing import Any, ClassVar
+
+from asyncapi_python.kernel.codec import Codec, CodecFactory
 from asyncapi_python.kernel.document.message import Message
+
 from .json import JsonCodecFactory
 
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/wire/amqp/factory.py

@@ -1,7 +1,8 @@
 """AMQP wire factory implementation"""
 
 import secrets
-from typing import Optional, Callable, Any, cast
+from typing import Any, Callable, Optional, cast
+
 from typing_extensions import Unpack
 
 try:
@@ -13,11 +14,11 @@ except ImportError as e:
     ) from e
 
 from asyncapi_python.kernel.wire import AbstractWireFactory, EndpointParams
-from asyncapi_python.kernel.wire.typing import Producer, Consumer
+from asyncapi_python.kernel.wire.typing import Consumer, Producer
 
-from .message import AmqpWireMessage, AmqpIncomingMessage
-from .producer import AmqpProducer
 from .consumer import AmqpConsumer
+from .message import AmqpIncomingMessage, AmqpWireMessage
+from .producer import AmqpProducer
 from .resolver import resolve_amqp_config
 
 
@@ -31,7 +32,6 @@ class AmqpWire(AbstractWireFactory[AmqpWireMessage, AmqpIncomingMessage]):
     def __init__(
         self,
         connection_url: str,
-        service_name: str = "app",
         robust: bool = False,
         reconnect_interval: float = 1.0,
         max_reconnect_interval: float = 60.0,
@@ -45,7 +45,6 @@ class AmqpWire(AbstractWireFactory[AmqpWireMessage, AmqpIncomingMessage]):
 
         Args:
             connection_url: AMQP connection URL
-            service_name: Service name prefix for app_id
             robust: Enable robust connection with auto-reconnect (default: False)
             reconnect_interval: Initial reconnect interval in seconds (for robust mode)
             max_reconnect_interval: Maximum reconnect interval in seconds (for robust mode)
@@ -55,9 +54,10 @@ class AmqpWire(AbstractWireFactory[AmqpWireMessage, AmqpIncomingMessage]):
             on_connection_lost: Callback when connection is lost (for non-robust mode)
         """
         self._connection_url = connection_url
-        # Generate app_id with service name plus 8 random hex characters
+        # Generate fallback app_id with random hex characters
+        # Note: For RPC, app_id should be provided via EndpointParams from application level
         random_hex = secrets.token_hex(4)  # 4 bytes = 8 hex chars
-        self._app_id = f"{service_name}-{random_hex}"
+        self._app_id = f"wire-{random_hex}"
         self._connection: AbstractConnection | None = None
         self._robust = robust
         self._reconnect_interval = reconnect_interval
@@ -135,8 +135,12 @@ class AmqpWire(AbstractWireFactory[AmqpWireMessage, AmqpIncomingMessage]):
         # Generate operation name from available information
         operation_name = self._generate_operation_name(kwargs)
 
+        # Use provided app_id if available, otherwise use instance app_id
+        # This allows application-level control over queue naming
+        app_id = kwargs.get("app_id", self._app_id)
+
         # Resolve AMQP configuration using pattern matching
-        config = resolve_amqp_config(kwargs, operation_name, self._app_id)
+        config = resolve_amqp_config(kwargs, operation_name, app_id)
 
         connection = await self._get_connection()
 
@@ -154,8 +158,12 @@ class AmqpWire(AbstractWireFactory[AmqpWireMessage, AmqpIncomingMessage]):
         # Generate operation name from available information
         operation_name = self._generate_operation_name(kwargs)
 
+        # Use provided app_id if available, otherwise use instance app_id
+        # This allows application-level control over queue naming
+        app_id = kwargs.get("app_id", self._app_id)
+
         # Resolve AMQP configuration using pattern matching
-        config = resolve_amqp_config(kwargs, operation_name, self._app_id)
+        config = resolve_amqp_config(kwargs, operation_name, app_id)
 
         connection = await self._get_connection()
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/wire/amqp/producer.py

@@ -3,10 +3,11 @@
 from typing import Any
 
 try:
-    from aio_pika import Message as AmqpMessage, ExchangeType  # type: ignore[import-not-found]
+    from aio_pika import ExchangeType
+    from aio_pika import Message as AmqpMessage  # type: ignore[import-not-found]
     from aio_pika.abc import (  # type: ignore[import-not-found]
-        AbstractConnection,
         AbstractChannel,
+        AbstractConnection,
         AbstractExchange,
     )
 except ImportError as e:
@@ -100,11 +101,38 @@ class AmqpProducer(Producer[AmqpWireMessage]):
 
         self._started = False
 
-    async def send_batch(self, messages: list[AmqpWireMessage]) -> None:
-        """Send a batch of messages using the configured exchange"""
+    async def send_batch(
+        self, messages: list[AmqpWireMessage], *, address_override: str | None = None
+    ) -> None:
+        """Send a batch of messages using the configured exchange
+
+        Args:
+            messages: Messages to send
+            address_override: Optional dynamic routing key/queue to override static config.
+                            If provided, overrides self._routing_key for this send operation.
+                            If None, uses static routing_key from configuration/bindings.
+        """
         if not self._started or not self._channel or not self._target_exchange:
             raise RuntimeError("Producer not started")
 
+        # Determine effective routing key: override takes precedence over static config
+        effective_routing_key = (
+            address_override if address_override is not None else self._routing_key
+        )
+
+        # Validate we have a destination
+        # Fail ONLY if both are truly missing:
+        # - address_override is None (not provided by caller)
+        # - AND self._routing_key is "" (no static config was derived from channel/bindings/operation)
+        # Note: empty string IS valid when explicitly configured (fanout exchanges, default exchange)
+        if address_override is None and not self._routing_key:
+            raise ValueError(
+                f"Cannot send: no routing destination available. "
+                f"RPC replies require reply_to from the request, or the channel must "
+                f"have address/bindings/operation-name to derive destination. "
+                f"(address_override={address_override}, routing_key={self._routing_key!r})"
+            )
+
         for message in messages:
             amqp_message = AmqpMessage(
                 body=message.payload,
@@ -113,8 +141,8 @@ class AmqpProducer(Producer[AmqpWireMessage]):
                 reply_to=message.reply_to,
             )
 
-            # Publish to the configured target exchange (not always default)
+            # Publish to the configured target exchange with dynamic or static routing key
             await self._target_exchange.publish(
                 amqp_message,
-                routing_key=self._routing_key,
+                routing_key=effective_routing_key,
             )

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/wire/amqp/resolver.py

@@ -1,12 +1,13 @@
 """Binding resolution with comprehensive pattern matching"""
 
 from typing import Any
-from asyncapi_python.kernel.wire import EndpointParams
-from asyncapi_python.kernel.document.channel import Channel
+
 from asyncapi_python.kernel.document.bindings import AmqpChannelBinding
+from asyncapi_python.kernel.document.channel import Channel
+from asyncapi_python.kernel.wire import EndpointParams
 
-from .config import AmqpConfig, AmqpBindingType
-from .utils import validate_parameters_strict, substitute_parameters
+from .config import AmqpBindingType, AmqpConfig
+from .utils import substitute_parameters, validate_parameters_strict
 
 
 def resolve_amqp_config(
@@ -57,17 +58,32 @@ def resolve_amqp_config(
                 },
             )
 
-        # Reply channel with explicit address - shared channel with filtering
+        # Reply channel with explicit address - check if direct queue or topic exchange
         case (True, _, address, _) if address:
             resolved_address = substitute_parameters(address, param_values)
-            return AmqpConfig(
-                queue_name=f"reply-{app_id}",  # App-specific reply queue
-                exchange_name=resolved_address,  # Shared exchange for replies
-                exchange_type="topic",  # Enable pattern matching for filtering
-                routing_key=app_id,  # Filter messages by app_id
-                binding_type=AmqpBindingType.REPLY,
-                queue_properties={"durable": True, "exclusive": False},
-            )
+            # If address starts with "reply-", treat it as a direct queue name (RPC pattern)
+            if resolved_address.startswith("reply-"):
+                return AmqpConfig(
+                    queue_name=resolved_address,  # Use address as queue name
+                    exchange_name="",  # Default exchange for direct routing
+                    routing_key=resolved_address,  # Route directly to queue
+                    binding_type=AmqpBindingType.REPLY,
+                    queue_properties={
+                        "durable": False,
+                        "exclusive": True,
+                        "auto_delete": True,
+                    },
+                )
+            else:
+                # Topic-based reply pattern - shared exchange with filtering
+                return AmqpConfig(
+                    queue_name=f"reply-{app_id}",  # App-specific reply queue
+                    exchange_name=resolved_address,  # Shared exchange for replies
+                    exchange_type="topic",  # Enable pattern matching for filtering
+                    routing_key=app_id,  # Filter messages by app_id
+                    binding_type=AmqpBindingType.REPLY,
+                    queue_properties={"durable": True, "exclusive": False},
+                )
 
         # Reply channel with binding - defer to binding resolution
         case (True, binding, _, _) if binding and binding.type == "queue":

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/wire/amqp/utils.py

@@ -3,6 +3,7 @@
 # TODO: This thing should be general wire utils, not tied to specific wire
 
 import re
+
 from asyncapi_python.kernel.document.channel import Channel
 
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/contrib/wire/in_memory.py

@@ -4,10 +4,11 @@ import asyncio
 from collections import defaultdict, deque
 from dataclasses import dataclass, field
 from typing import Any, AsyncGenerator
+
 from typing_extensions import Unpack
 
 from asyncapi_python.kernel.wire import AbstractWireFactory, EndpointParams
-from asyncapi_python.kernel.wire.typing import Producer, Consumer
+from asyncapi_python.kernel.wire.typing import Consumer, Producer
 
 
 @dataclass
@@ -142,13 +143,34 @@ class InMemoryProducer(Producer[InMemoryMessage]):
         """Stop the producer"""
         self._started = False
 
-    async def send_batch(self, messages: list[InMemoryMessage]) -> None:
-        """Send a batch of messages to the channel"""
+    async def send_batch(
+        self, messages: list[InMemoryMessage], *, address_override: str | None = None
+    ) -> None:
+        """Send a batch of messages to the channel
+
+        Args:
+            messages: Messages to send
+            address_override: Optional dynamic channel name to override static config.
+                            If provided, overrides self._channel_name for this send operation.
+                            If None, uses static channel_name from configuration.
+        """
         if not self._started:
             raise RuntimeError("Producer not started")
 
+        # Determine effective channel: override takes precedence over static config
+        effective_channel = (
+            address_override if address_override is not None else self._channel_name
+        )
+
+        # Validate we have a destination
+        if not effective_channel:
+            raise ValueError(
+                f"Cannot send: no channel specified. "
+                f"address_override={address_override}, channel_name={self._channel_name}"
+            )
+
         for message in messages:
-            await _bus.publish(self._channel_name, message)
+            await _bus.publish(effective_channel, message)
 
 
 class InMemoryConsumer(Consumer[InMemoryIncomingMessage]):

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/application.py

@@ -1,12 +1,14 @@
 import asyncio
-from typing import TypedDict, Any
-from typing_extensions import Unpack, Required, NotRequired
+from typing import Any, TypedDict
+
+from typing_extensions import NotRequired, Required, Unpack
 
 from asyncapi_python.kernel.document.operation import Operation
 from asyncapi_python.kernel.wire import AbstractWireFactory
+
+from .codec import CodecFactory
 from .endpoint import AbstractEndpoint, EndpointFactory
 from .endpoint.abc import EndpointParams
-from .codec import CodecFactory
 
 
 class BaseApplication:

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/codec.py

@@ -3,6 +3,7 @@ from types import ModuleType
 from typing import Generic, Protocol
 
 from asyncapi_python.kernel.document.message import Message
+
 from .typing import T_DecodedPayload, T_EncodedPayload
 
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/document/channel.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
 from typing import Any
-from .message import Message
-from .common import *
+
 from .bindings import AmqpChannelBinding
+from .common import *
+from .message import Message
 
 __all__ = ["AddressParameter", "ChannelBindings", "Channel"]
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/document/message.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any
-from .common import *
+
 from .bindings import AmqpMessageBinding
+from .common import *
 
 __all__ = [
     "CorrelationId",

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/document/operation.py

@@ -1,9 +1,10 @@
 from dataclasses import dataclass
 from typing import Any, Literal
-from .common import *
+
+from .bindings import AmqpOperationBinding
 from .channel import Channel
+from .common import *
 from .message import Message
-from .bindings import AmqpOperationBinding
 
 __all__ = [
     "SecurityScheme",

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/endpoint/__init__.py

@@ -1,10 +1,12 @@
 from typing import ClassVar, Literal
+
 from typing_extensions import Unpack
+
 from .abc import AbstractEndpoint
 from .publisher import Publisher
-from .subscriber import Subscriber
 from .rpc_client import RpcClient
 from .rpc_server import RpcServer
+from .subscriber import Subscriber
 
 __all__ = [
     "AbstractEndpoint",

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/endpoint/abc.py

@@ -1,19 +1,23 @@
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Generic, TypedDict, overload, Union
-from typing_extensions import Unpack, Required, NotRequired
+from typing import Any, Callable, Generic, TypedDict, Union, overload
+
+from typing_extensions import NotRequired, Required, Unpack
 
-from ..typing import Handler, T_Input, T_Output, BatchConfig
-from asyncapi_python.kernel.wire import AbstractWireFactory
-from asyncapi_python.kernel.document import Operation
 from asyncapi_python.kernel.codec import Codec, CodecFactory
+from asyncapi_python.kernel.document import Operation
+from asyncapi_python.kernel.wire import AbstractWireFactory
+
+from ..typing import BatchConfig, Handler, T_Input, T_Output
 
 
-class EndpointParams(TypedDict):
+class EndpointParams(TypedDict, total=False):
     """Optional parameters for endpoint configuration"""
 
-    disable_handler_validation: NotRequired[
-        bool
-    ]  # Opt-out of handler enforcement for testing
+    service_name: str  # Service name for generating app_id
+    default_rpc_timeout: (
+        float | None
+    )  # Default timeout in seconds for RPC client requests (default: 180.0), or None to disable
+    disable_handler_validation: bool  # Opt-out of handler enforcement for testing
 
 
 class HandlerParams(TypedDict):

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/endpoint/publisher.py

@@ -1,11 +1,13 @@
 from typing import Generic
+
 from typing_extensions import Unpack
 
+from asyncapi_python.kernel.wire import Producer
+
+from ..typing import T_Input
 from .abc import AbstractEndpoint, Send
 from .exceptions import UninitializedError
 from .message import WireMessage
-from ..typing import T_Input
-from asyncapi_python.kernel.wire import Producer
 
 
 class Publisher(AbstractEndpoint, Send[T_Input, None], Generic[T_Input]):

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/endpoint/rpc_client.py

@@ -1,15 +1,15 @@
 import asyncio
 from typing import Generic
-from typing_extensions import Unpack
 from uuid import uuid4
 
-from .abc import AbstractEndpoint, Send
-from .exceptions import UninitializedError, TimeoutError
-from .message import WireMessage
-from ..typing import T_Input, T_Output, IncomingMessage
-from asyncapi_python.kernel.wire import Producer
+from typing_extensions import NotRequired, Unpack
 
+from asyncapi_python.kernel.wire import Producer
 
+from ..typing import IncomingMessage, T_Input, T_Output
+from .abc import AbstractEndpoint, Send
+from .exceptions import TimeoutError, UninitializedError
+from .message import WireMessage
 from .rpc_reply_handler import global_reply_handler
 
 
@@ -21,6 +21,13 @@ class RpcClient(AbstractEndpoint, Send[T_Input, T_Output], Generic[T_Input, T_Ou
     a single reply consumer and background task for efficiency.
     """
 
+    class RouterInputs(Send.RouterInputs):
+        """Router inputs for RPC client, extending Send.RouterInputs with timeout"""
+
+        timeout: NotRequired[
+            float | None
+        ]  # Timeout in seconds for this RPC request, or None to disable timeout
+
     def __init__(self, **kwargs: Unpack[AbstractEndpoint.Inputs]):
         super().__init__(**kwargs)
         # Instance-specific state
@@ -44,7 +51,12 @@ class RpcClient(AbstractEndpoint, Send[T_Input, T_Output], Generic[T_Input, T_Ou
         global_reply_handler.increment_instance_count()
 
         # Ensure global reply handling is set up (only happens once)
-        await global_reply_handler.ensure_reply_handler(self._wire, self._operation)
+        await global_reply_handler.ensure_reply_handler(
+            self._wire, self._operation, self._endpoint_params
+        )
+
+        # Extract service_name from endpoint_params for app_id
+        service_name = self._endpoint_params.get("service_name", "app")
 
         # Create instance-specific producer for sending requests
         self._producer = await self._wire.create_producer(
@@ -52,6 +64,7 @@ class RpcClient(AbstractEndpoint, Send[T_Input, T_Output], Generic[T_Input, T_Ou
             parameters={},
             op_bindings=self._operation.bindings,
             is_reply=False,
+            app_id=service_name,
         )
 
         # Start producer
@@ -70,18 +83,17 @@ class RpcClient(AbstractEndpoint, Send[T_Input, T_Output], Generic[T_Input, T_Ou
         if remaining_count == 0:
             await global_reply_handler.cleanup_if_last_instance()
 
-    async def __call__(
-        self,
-        payload: T_Input,
-        /,
-        timeout: float = 30.0,
-        **kwargs: Unpack[Send.RouterInputs],
+    async def __call__(  # type: ignore[override]
+        self, payload: T_Input, /, **kwargs: Unpack[RouterInputs]
     ) -> T_Output:
         """Send an RPC request and wait for response using global reply handling
 
         Args:
             payload: The request payload to send
-            timeout: Maximum time to wait for response (default 30 seconds)
+            **kwargs: Router inputs including optional timeout:
+                     - Not provided: uses default_rpc_timeout from endpoint_params (default: 180.0)
+                     - float: uses the specified timeout in seconds
+                     - None: disables timeout (waits indefinitely)
 
         Returns:
             The response payload
@@ -93,6 +105,14 @@ class RpcClient(AbstractEndpoint, Send[T_Input, T_Output], Generic[T_Input, T_Ou
         if not self._producer:
             raise UninitializedError()
 
+        # Determine timeout: use provided value, or fall back to endpoint_params default
+        if "timeout" in kwargs:
+            # Explicitly provided (could be float or None)
+            timeout = kwargs["timeout"]
+        else:
+            # Not provided, use default from endpoint_params
+            timeout = self._endpoint_params.get("default_rpc_timeout", 180.0)
+
         # Generate correlation ID for this request
         correlation_id: str = str(uuid4())
 

{asyncapi_python-0.3.0rc2 → asyncapi_python-0.3.0rc4}/src/asyncapi_python/kernel/endpoint/rpc_reply_handler.py

@@ -2,11 +2,13 @@
 
 import asyncio
 import secrets
-
-from ..typing import IncomingMessage
 from typing import Any
-from asyncapi_python.kernel.wire import Consumer, AbstractWireFactory
+
 from asyncapi_python.kernel.document import Channel, Operation
+from asyncapi_python.kernel.wire import AbstractWireFactory, Consumer
+
+from ..typing import IncomingMessage
+from .abc import EndpointParams
 
 
 class GlobalRpcReplyHandler:
@@ -25,37 +27,59 @@ class GlobalRpcReplyHandler:
         self._instance_count: int = 0
 
     async def ensure_reply_handler(
-        self, wire_factory: AbstractWireFactory[Any, Any], operation: Operation
+        self,
+        wire_factory: AbstractWireFactory[Any, Any],
+        operation: Operation,
+        endpoint_params: EndpointParams,
     ) -> None:
-        """Ensure reply consumer and task are running"""
+        """Ensure reply consumer and task are running
+
+        Args:
+            wire_factory: Wire factory for creating consumer
+            operation: Operation definition
+            endpoint_params: Endpoint parameters including service_name
+        """
         if self._reply_consumer is None:
-            # Create reply consumer (only once for all instances)
-            reply_channel = self._get_or_create_reply_channel(operation)
+            # Extract service_name from endpoint_params
+            service_name = endpoint_params.get("service_name", "app")
 
+            # Generate app_id with service name + random hex (same format as AmqpWire)
+            random_hex = secrets.token_hex(4)  # 4 bytes = 8 hex chars
+            app_id = f"{service_name}-{random_hex}"
+
+            # Use app_id as the reply queue name
+            self._reply_queue_name = f"reply-{app_id}"
+
+            # Create reply channel with the generated queue name as address
+            reply_channel = self._get_or_create_reply_channel(
+                operation, self._reply_queue_name
+            )
+
+            # Create reply consumer with the channel (wire factory will use the address)
             self._reply_consumer = await wire_factory.create_consumer(
                 channel=reply_channel,
                 parameters={},
                 op_bindings=None,
                 is_reply=True,
+                app_id=app_id,
             )
 
-            # Generate unique reply queue name for all clients
-            self._reply_queue_name = f"reply-{secrets.token_hex(8)}"
-
             # Start the consumer
             await self._reply_consumer.start()
 
             # Start background task
             self._consume_task = asyncio.create_task(self._consume_all_replies())
 
-    def _get_or_create_reply_channel(self, operation: Operation) -> Channel:
-        """Get reply channel from operation or create default one"""
+    def _get_or_create_reply_channel(
+        self, operation: Operation, queue_name: str
+    ) -> Channel:
+        """Get reply channel from operation or create default one with specified queue name"""
         if operation.reply and operation.reply.channel:
             return operation.reply.channel
         else:
-            # Create a default reply channel for global use
+            # Create a default reply channel with the generated queue name as address
             return Channel(
-                address=None,  # Use default/null address for global reply queue
+                address=queue_name,  # Use the generated queue name as address
                 title="Global RPC Reply Queue",
                 summary=None,
                 description=None,