Is there a way to document RPC return type in asyncApi docs?

[gri38]

Hello.

When we subscribe to a queue to answer a RPC call, it seems we cannot document the return type.

H§ere a small exemple:

import logging

from faststream import FastStream
from faststream.rabbit import RabbitBroker
from pydantic import BaseModel, conint

broker = RabbitBroker()
app = FastStream(broker)


class In(BaseModel):
    i: str
    j: conint(gt=0)

class Out(BaseModel):
    k: str
    l: float


@broker.subscriber("RPC",
                   title="RPC",
                   description="This queue is used to for RPC",

                   )
async def rpc_handler(input: In) -> Out:
    logging.info(f"{input=}")
    return Out(k=input.i, l=input.j)

If I run with faststream docs serve rpc:app I cannot see Out in the doc (http://localhost:8000).

Is there a way to do so ?

When I use the RabbitRouter, I can see in the router @subscriber decorator:

# FastAPI args
        response_model: Annotated[
            Any,
            Doc(
                """
                The type to use for the response.

                It could be any valid Pydantic *field* type. So, it doesn't have to
                be a Pydantic model, it could be other things, like a `list`, `dict`,
                etc.

                It will be used for:

                * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                    show it as the response (JSON Schema).
                * Serialization: you could return an arbitrary object and the
                    `response_model` would be used to serialize that object into the
                    corresponding JSON.
                * Filtering: the JSON sent to the client will only contain the data
                    (fields) defined in the `response_model`. If you returned an object
                    that contains an attribute `password` but the `response_model` does
                    not include that field, the JSON sent to the client would not have
                    that `password`.
                * Validation: whatever you return will be serialized with the
                    `response_model`, converting any data as necessary to generate the
                    corresponding JSON. But if the data in the object returned is not
                    valid, that would mean a violation of the contract with the client,
                    so it's an error from the API developer. So, FastAPI will raise an
                    error and return a 500 error code (Internal Server Error).

                Read more about it in the
                [FastAPI docs for Response Model](https://fastapi.tiangolo.com/tutorial/response-model/).
                """
            ),

But even with response_model: nothing in asyncAPI.

Thanks for any tips, even for "it's not possible" ;-)

[Lancetnik]

Hi! Sorry for answering so late: I had a vacation this time
I created #1586 issue to track this feature progress. Now I have no example, now such documentation should looks in AsyncAPI 2.6.0

[gri38]

Hi.
No worry, vacation is higher priority than faststream ;-)
I will mark this as answered since you opened #1586
As far as I'm concerned, if you find a way to do in asyncAPI 3.0 and not in 2.6.0, ... it's great.

I've seen you expect to handle asyncAPI 3.0 in you roadmap, for next major version ...

Thanks for your answer.

[Lancetnik]

I am sure, that it can be implemented in AsyncAPI 2.6.0 too, but just can't find any example (regular HTTP/RPC schema should be fine). If you can help with it - it will be really great! Anyway, thank you for the point to improve our project