Skip to content

Commit 5a80698

Browse files
authored
fix(realtime): bound incoming WebSocket message size by default (#5102)
1 parent 91f5cfd commit 5a80698

2 files changed

Lines changed: 121 additions & 3 deletions

File tree

‎src/agents/realtime/openai_realtime.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -542,8 +542,8 @@ class TransportConfig(TypedDict):
542542

543543
max_size: NotRequired[int | None]
544544
"""Maximum size in bytes of an incoming websocket message.
545-
Defaults to None (no limit). Set an explicit byte limit to bound memory usage for
546-
long-lived connections behind proxies or in memory-constrained containers."""
545+
Defaults to 8 MiB (8 * 1024 * 1024 bytes). Messages above the limit close the connection.
546+
Set a different byte limit to match application needs, or None to disable the limit."""
547547

548548

549549
class OpenAIRealtimeWebSocketModel(RealtimeModel):
@@ -680,7 +680,7 @@ async def _create_websocket_connection(
680680
connect_kwargs: dict[str, Any] = {
681681
"user_agent_header": _USER_AGENT,
682682
"additional_headers": headers,
683-
"max_size": None, # Allow any size of message
683+
"max_size": 8 * 1024 * 1024,
684684
}
685685

686686
if transport_config:
Lines changed: 118 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,118 @@
1+
import asyncio
2+
import json
3+
4+
import pytest
5+
from websockets.asyncio.server import ServerConnection, serve
6+
from websockets.exceptions import ConnectionClosedError
7+
from websockets.frames import CloseCode
8+
9+
from agents.realtime.model import RealtimeModelConfig, RealtimeModelListener
10+
from agents.realtime.model_events import (
11+
RealtimeModelEvent,
12+
RealtimeModelExceptionEvent,
13+
RealtimeModelOutputTextDeltaEvent,
14+
RealtimeModelRawServerEvent,
15+
)
16+
from agents.realtime.openai_realtime import (
17+
OpenAIRealtimeSIPModel,
18+
OpenAIRealtimeWebSocketModel,
19+
TransportConfig,
20+
)
21+
22+
23+
@pytest.mark.asyncio
24+
@pytest.mark.parametrize("model_type", [OpenAIRealtimeWebSocketModel, OpenAIRealtimeSIPModel])
25+
@pytest.mark.parametrize(
26+
("transport_config", "message_size", "accepted"),
27+
[
28+
pytest.param(None, 8 * 1024 * 1024, True, id="default-at-limit"),
29+
pytest.param(None, 8 * 1024 * 1024 + 1, False, id="default-over-limit"),
30+
pytest.param(
31+
{"ping_interval": None}, 8 * 1024 * 1024 + 1, False, id="other-config-over-limit"
32+
),
33+
pytest.param({"max_size": 1024}, 1025, False, id="explicit-smaller-limit"),
34+
pytest.param(
35+
{"max_size": 9 * 1024 * 1024}, 8 * 1024 * 1024 + 1, True, id="explicit-larger-limit"
36+
),
37+
pytest.param({"max_size": None}, 8 * 1024 * 1024 + 1, True, id="explicit-unlimited"),
38+
],
39+
)
40+
async def test_incoming_message_size_limit(
41+
model_type: type[OpenAIRealtimeWebSocketModel],
42+
transport_config: TransportConfig | None,
43+
message_size: int,
44+
accepted: bool,
45+
) -> None:
46+
events: list[RealtimeModelEvent] = []
47+
result_received = asyncio.Event()
48+
peer_closed = asyncio.Event()
49+
peer_close_code: int | None = None
50+
51+
class Listener(RealtimeModelListener):
52+
async def on_event(self, event: RealtimeModelEvent) -> None:
53+
events.append(event)
54+
if isinstance(event, RealtimeModelOutputTextDeltaEvent | RealtimeModelExceptionEvent):
55+
result_received.set()
56+
57+
payload = {
58+
"type": "response.output_text.delta",
59+
"event_id": "event_test",
60+
"response_id": "resp_test",
61+
"item_id": "item_test",
62+
"output_index": 0,
63+
"content_index": 0,
64+
"delta": "",
65+
}
66+
payload["delta"] = "x" * (message_size - len(json.dumps(payload).encode("utf-8")))
67+
message = json.dumps(payload)
68+
assert len(message.encode("utf-8")) == message_size
69+
70+
async def handler(websocket: ServerConnection) -> None:
71+
nonlocal peer_close_code
72+
# Wait for session.update before sending the response.
73+
await websocket.recv()
74+
# Keep the library's default compression enabled on both ends. For rejections,
75+
# each frame fits the limit; bound the assembled, decompressed message.
76+
if accepted:
77+
await websocket.send(message)
78+
else:
79+
midpoint = len(message) // 2
80+
await websocket.send([message[:midpoint], message[midpoint:]])
81+
await websocket.wait_closed()
82+
peer_close_code = websocket.close_code
83+
peer_closed.set()
84+
85+
model = model_type(transport_config=transport_config)
86+
model.add_listener(Listener())
87+
async with serve(handler, "127.0.0.1", 0) as server:
88+
port = server.sockets[0].getsockname()[1]
89+
options: RealtimeModelConfig = {
90+
"api_key": "test-key",
91+
"url": f"ws://127.0.0.1:{port}/v1/realtime",
92+
}
93+
if model_type is OpenAIRealtimeSIPModel:
94+
options["call_id"] = "call_test"
95+
try:
96+
await model.connect(options)
97+
await asyncio.wait_for(result_received.wait(), timeout=5)
98+
failures = [event for event in events if isinstance(event, RealtimeModelExceptionEvent)]
99+
text_events = [
100+
event for event in events if isinstance(event, RealtimeModelOutputTextDeltaEvent)
101+
]
102+
if accepted:
103+
assert not failures
104+
assert len(text_events) == 1
105+
assert text_events[0].delta == payload["delta"]
106+
else:
107+
assert not text_events
108+
assert not any(isinstance(event, RealtimeModelRawServerEvent) for event in events)
109+
assert len(failures) == 1
110+
exception = failures[0].exception
111+
assert isinstance(exception, ConnectionClosedError)
112+
assert exception.sent is not None
113+
assert exception.sent.code == CloseCode.MESSAGE_TOO_BIG
114+
await asyncio.wait_for(peer_closed.wait(), timeout=5)
115+
assert peer_close_code == CloseCode.MESSAGE_TOO_BIG
116+
finally:
117+
await model.close()
118+
await asyncio.wait_for(peer_closed.wait(), timeout=5)

0 commit comments

Comments
 (0)