fix(uagents): prevent sync-query future leak and cross-talk in ASGI server

[PrazwalR]

Summary

The ASGI /submit handler leaked entries in the server-side sync-response map
(ASGIServer._queries) and could cross-wire concurrent sync queries.

_queries[env.sender] was created before the envelope signature was verified
and before the target was confirmed routable, and it was never removed on the
failure paths:

• signature verification failed → early return (entry leaked)
• target not routable → early return (entry leaked)
• sync request timed out waiting for a reply → no cleanup (entry leaked)

Only the happy path (handler replies) removed the entry, via context.send_raw.

Impact

• Unauthenticated memory-exhaustion DoS. /submit needs no auth. A caller
  sending sync requests (x-uagents-connection: sync) with a user... sender
  (signature check skipped) and any unroutable target adds a permanent dict entry
  per request. The key is env.sender, an arbitrary wire string, so each entry's
  size is attacker-controlled. The dict never shrinks.
• Concurrent-query cross-talk. _queries was keyed by sender only, so two
  in-flight sync queries from the same caller collided (second overwrote the
  first's Future).

Fix

• Register the response Future only after signature + routing checks pass.
• Key _queries by (sender, session) so concurrent queries never collide.
• Remove the entry in a finally around the sync wait (happy path already
  deletes it in context.send_raw, so pop(..., None) is a safe no-op there).
• Resolve replies by (sender, session) in context.send_raw; update type hints.

Files: asgi.py, context.py, agent.py (type hints), tests/test_server.py
(sync helper updated for the tuple key).

Testing

• Existing suites pass: test_server, test_context, test_agent,
  test_protocol, test_msg_verify.
• Verified end-to-end (asgi → message queue → consumer → on_message handler →
  ctx.send → future resolved), plus failure/timeout/concurrency/load cases:
  every failure, timeout, and unroutable path leaves _queries empty; concurrent
  same-sender / different-session queries each receive their own reply with no
  cross-talk.
• ruff check clean on changed files.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR hardens the ASGI /submit sync-query mechanism by preventing _queries map leaks on failure/timeout paths and eliminating cross-talk between concurrent sync queries from the same sender by keying futures with (sender, session).

Changes:

• Move sync Future registration to occur only after signature verification and routing checks pass.
• Key pending sync-query futures by (sender, session) and resolve replies using that tuple key.
• Ensure _queries cleanup via finally so timeouts/cancellations don’t leak entries.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 1 comment.

File	Description
python/src/uagents/asgi.py	Registers sync-query futures later, uses (sender, session) keys, and guarantees cleanup in finally.
python/src/uagents/context.py	Updates send_raw typing/docs and resolves sync replies via (sender, session) to avoid cross-talk.
python/src/uagents/agent.py	Updates _queries type hints to reflect tuple-keyed futures.
python/tests/test_server.py	Updates test helper to locate tuple-keyed query futures.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.