fix(stream): don't block event loop in EventQueue

[matino]

Description

Fixes #111 🦕

Warning

Backwards incompatible change, as EventQueue.enqueue_event() becomes async.

The implementation of the AgentExecutor usually looks like this:

class SomeAgentExecutor(AgentExecutor):

    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
        task_updater = TaskUpdater(event_queue, context.task_id, context.context_id)
        task_updater.start_work()
        
        async for event in self._run_async(...):
            if event.is_final_response():
                task_updater.add_artifact(parts)
                task_updater.complete()
                break
            task_updater.update_status(
                TaskState.working,
                message=task_updater.new_agent_message(parts),
            )

The issue is that the loop inside execute() calls task_updater.update_status() synchronously.
If update_status is not an async function, then the execute() method does not yield control back to the event loop during each iteration. That’s why everything gets blocked until the loop finishes.

So the first step is to make sure that update_status() and event_queue.enqueue_event() are async functions.
Still, this is not enough, since EventQueue uses put_nowait(), so it never actually suspends.
So the 2nd step is to switch from queue.put_nowait() to queue.put().

This is still not enough.
By default, an asyncio.Queue is unbounded , so queue.put never actually suspends the producer.
Therefore, the producer loop in SomeAgentExecutor still runs full-speed without yielding.
So the 3rd step is to make the queue bounded. I have set the size to 1024, but it can be actually lower or higher if needed.