diff --git a/mcp-server/README.md b/mcp-server/README.md index 4580cfa4..26d45e8c 100644 --- a/mcp-server/README.md +++ b/mcp-server/README.md @@ -147,6 +147,11 @@ python test_module.py ### 聊天功能 - `chat` - 发送聊天消息 +- `agent_chat` - 调用智能体完成多步检索与工具调用 + +两种聊天工具均按 SSE 空行边界组装事件,支持一个事件包含多行 `data:`。 +连接结束时尚未遇到空行的事件会被丢弃;单个事件的数据缓冲上限为 8 MiB, +超过上限会返回错误并关闭响应连接。 ### 块管理 - `list_chunks` - 列出知识块 diff --git a/mcp-server/test_chat_sse.py b/mcp-server/test_chat_sse.py new file mode 100644 index 00000000..2f3bb974 --- /dev/null +++ b/mcp-server/test_chat_sse.py @@ -0,0 +1,140 @@ +"""Regression tests for the SSE consumer shared by the two chat tools.""" + +import json +import unittest +from unittest import mock + +import requests + +import weknora_mcp_server as srv + + +class ChatSSETest(unittest.TestCase): + def setUp(self): + self.client = srv.WeKnoraClient("http://example.test/api/v1", "test-key") + + def consume(self, lines, *, agent=False): + response = mock.MagicMock() + response.iter_lines.return_value = iter(lines) + self.response = response + with mock.patch.object(self.client.session, "post", return_value=response): + if agent: + return self.client.agent_chat("session-1", "question", "agent-1") + return self.client.chat("session-1", "question") + + def test_multiline_answers_and_references_in_both_chat_paths(self): + lines = [ + b'data: {"response_type":"answer",', + 'data: "content":"你好"}'.encode(), + b"", + b'data: {"response_type":"references",', + b'data: "knowledge_references":[{"id":"chunk-1"}]}', + b"", + b'data: {"response_type":"complete"}', + b"", + ] + for agent in (False, True): + with self.subTest(agent=agent): + result = self.consume(lines, agent=agent) + self.assertEqual(result["answer"], "你好") + self.assertEqual(result["references"], [{"id": "chunk-1"}]) + self.assertEqual(result["session_id"], "session-1") + + def test_dispatches_once_per_frame_not_once_per_data_line(self): + result = self.consume( + [ + b'data: {"response_type":"answer","content":"not a frame"}', + b'data: {"response_type":"answer","content":"still same frame"}', + b"", + b'data: {"response_type":"answer","content":"valid frame"}', + b"", + ] + ) + self.assertEqual(result["answer"], "valid frame") + + def test_ignores_metadata_comments_and_empty_frames(self): + result = self.consume( + [ + "", + ": heartbeat", + "event: message", + "id: 42", + "retry: 1000", + "", + "data:", + "", + 'data:{"response_type":"answer",', + ": another heartbeat", + 'data: "content":"hello"}', + "", + ] + ) + self.assertEqual(result["answer"], "hello") + + def test_multiline_error_propagates_and_closes_response(self): + with self.assertRaisesRegex(requests.RequestException, "upstream failed"): + self.consume( + [ + b'data: {"response_type":"error",', + b'data: "content":"upstream failed"}', + b"", + ] + ) + self.response.__exit__.assert_called_once() + + def test_multiline_complete_stops_before_later_events(self): + result = self.consume( + [ + b'data: {"response_type":"answer","content":"done"}', + b"", + b'data: {"response_type":', + b'data: "complete"}', + b"", + b'data: {"response_type":"error","content":"must not read"}', + b"", + ] + ) + self.assertEqual(result["answer"], "done") + self.response.__exit__.assert_called_once() + + def test_discards_unterminated_event_at_eof(self): + result = self.consume( + [b'data: {"response_type":"answer","content":"unfinished"}'] + ) + self.assertEqual(result["answer"], "") + + def test_crlf_multiline_frame_with_fragmented_utf8(self): + wire = ( + 'data: {"response_type":"answer",\r\n' + 'data: "content":"你好"}\r\n\r\n' + 'data: {"response_type":"complete"}\r\n\r\n' + ).encode() + # Exercise requests' real line iterator, with a UTF-8 code point split + # across transport chunks rather than pre-decoded lines. + split = wire.index("你".encode()) + 1 + response = requests.Response() + response.status_code = 200 + response._content_consumed = True + with mock.patch.object( + response, "iter_content", return_value=iter([wire[:split], wire[split:]]) + ), mock.patch.object(self.client.session, "post", return_value=response): + result = self.client.chat("session-1", "question") + self.assertEqual(result["answer"], "你好") + + def test_rejects_oversized_event_and_closes_response(self): + with mock.patch.object(srv, "MAX_SSE_EVENT_BYTES", 64, create=True): + with self.assertRaisesRegex(requests.RequestException, "SSE event exceeds"): + self.consume([b"data: " + b"x" * 32] * 3) + self.response.__exit__.assert_called_once() + + def test_event_size_limit_resets_after_each_frame(self): + payload = json.dumps({"response_type": "answer", "content": "hello"}) + with mock.patch.object( + srv, "MAX_SSE_EVENT_BYTES", len(payload.encode()) + 1, create=True + ): + result = self.consume(["data: " + payload, ""] * 3) + self.assertEqual(result["answer"], "hello" * 3) + + +if __name__ == "__main__": + unittest.main() diff --git a/mcp-server/weknora_mcp_server.py b/mcp-server/weknora_mcp_server.py index be1145ac..8efbf732 100644 --- a/mcp-server/weknora_mcp_server.py +++ b/mcp-server/weknora_mcp_server.py @@ -37,6 +37,9 @@ except ValueError: logger.warning("WEKNORA_CHAT_TIMEOUT is not a valid integer; falling back to 300s.") WEKNORA_CHAT_TIMEOUT = 300 +# Bound the data accumulated while waiting for an SSE event's blank line. +MAX_SSE_EVENT_BYTES = 8 * 1024 * 1024 + # Network transport defaults kept for backward compatibility with pre-2.x deployments. SSE_MESSAGE_PATH = "/sse/messages/" STREAMABLE_HTTP_STATELESS = True @@ -507,6 +510,7 @@ class WeKnoraClient: data: {"response_type": "references", "knowledge_references": [...]} data: {"response_type": "complete"} + A blank line ends each event; multiple data lines are joined with newlines. We accumulate answer chunks and extract references, returning them as a dict. """ try: @@ -521,19 +525,35 @@ class WeKnoraClient: answer_chunks: list = [] references: list = [] debug_events: list = [] + data_lines: list[str] = [] + event_bytes = 0 # Use context manager to ensure the connection is returned to the pool # even when breaking early on a 'complete' event. with response: for raw_line in response.iter_lines(): - if not raw_line: - continue if isinstance(raw_line, bytes): raw_line = raw_line.decode("utf-8") - # Each SSE event is prefixed with "data: " followed by JSON payload - if not raw_line.startswith("data:"): + if raw_line: + field, _, value = raw_line.partition(":") + if field == "data": + # SSE removes at most one leading space from a value. + if value.startswith(" "): + value = value[1:] + event_bytes += len(value.encode("utf-8")) + 1 + if event_bytes > MAX_SSE_EVENT_BYTES: + raise RequestException( + f"SSE event exceeds {MAX_SSE_EVENT_BYTES} bytes" + ) + data_lines.append(value) continue - payload = raw_line[5:].lstrip(" ") + # Dispatch only at the blank-line boundary. Incomplete data + # at EOF is discarded, as required by the SSE protocol. + if not data_lines: + continue + payload = "\n".join(data_lines) + data_lines = [] + event_bytes = 0 try: event_data = json.loads(payload) except json.JSONDecodeError: