Skip to content

Build and run agents you can see, understand and trust.

fix(model): preserve OpenAI Responses refusal text (#3136)

Long Jina833ab9fc13e
diff --git a/src/agentscope/model/_openai_response/_model.py b/src/agentscope/model/_openai_response/_model.py
index 569ba12b7..b30bbe7d1 100644
--- a/src/agentscope/model/_openai_response/_model.py
+++ b/src/agentscope/model/_openai_response/_model.py
@@ -281,7 +281,7 @@ class OpenAIResponseModel(ChatModelBase):
"""
usage: ChatUsage | None = None
response_id: str = _generate_id()
- text_id: str = _generate_id()
+ text_block_ids: dict[tuple[str, int], str] = {}
reasoning_block_ids: dict[str, dict[tuple[str, int], str]] = {}
# Mapping from Responses API item id (fc_xxx) to (call_id, name)
# so subsequent argument deltas can be routed to the right tool
@@ -333,8 +333,19 @@ class OpenAIResponseModel(ChatModelBase):
),
)
- elif event_type == "response.output_text.delta":
- delta_res.append_text(event.delta, block_id=text_id)
+ elif event_type in (
+ "response.output_text.delta",
+ "response.refusal.delta",
+ ):
+ # Keep message content parts separate while accumulating
+ # fragmented deltas into their original ordered blocks.
+ delta_res.append_text(
+ event.delta,
+ block_id=text_block_ids.setdefault(
+ (event.item_id, event.content_index),
+ _generate_id(),
+ ),
+ )
elif event_type == "response.output_item.added":
item = event.item
@@ -476,6 +487,10 @@ class OpenAIResponseModel(ChatModelBase):
content_blocks.append(
TextBlock(type="text", text=part.text),
)
+ elif getattr(part, "type", None) == "refusal":
+ content_blocks.append(
+ TextBlock(type="text", text=part.refusal),
+ )
elif item_type == "function_call":
content_blocks.append(
diff --git a/tests/model_openai_response_test.py b/tests/model_openai_response_test.py
index b2547fe0d..0a7da8430 100644
--- a/tests/model_openai_response_test.py
+++ b/tests/model_openai_response_test.py
@@ -5,15 +5,16 @@
Tests cover both non-streaming and streaming modes.
OpenAI Responses API uses event-based streaming with response.completed.
"""
-from typing import Any
+from typing import Any, cast
import unittest
from unittest import IsolatedAsyncioTestCase
from unittest.mock import AsyncMock, MagicMock
from openai import APIError
+from openai.types.responses import ResponseOutputMessage
from pydantic import BaseModel
-from utils import AnyString
+from utils import AnyString, AnyValue
from agentscope.message import (
AssistantMsg,
@@ -26,7 +27,7 @@ from agentscope.message import (
ToolResultState,
ThinkingBlock,
)
-from agentscope.model import OpenAIResponseModel
+from agentscope.model import ChatResponse, ChatUsage, OpenAIResponseModel
from agentscope.credential import OpenAICredential
from agentscope.tool import ToolChoice
@@ -127,6 +128,9 @@ def _mock_completion(
def _make_event(event_type: str, **kwargs: Any) -> MagicMock:
"""Build a mock Responses API streaming event."""
+ if event_type in ("response.output_text.delta", "response.refusal.delta"):
+ kwargs.setdefault("item_id", "msg_test123")
+ kwargs.setdefault("content_index", 0)
event = MagicMock()
event.type = event_type
for key, val in kwargs.items():
@@ -137,6 +141,27 @@ def _make_event(event_type: str, **kwargs: Any) -> MagicMock:
return event
+def _mock_message(
+ item_id: str,
+ parts: list[tuple[str, str]],
+) -> ResponseOutputMessage:
+ """Build SDK message parts for text/refusal parser comparisons."""
+ return ResponseOutputMessage.model_validate(
+ {
+ "id": item_id,
+ "type": "message",
+ "role": "assistant",
+ "status": "completed",
+ "content": [
+ {"type": kind, "text": text, "annotations": []}
+ if kind == "output_text"
+ else {"type": kind, "refusal": text}
+ for kind, text in parts
+ ],
+ },
+ )
+
+
class _MockAsyncEventStream:
"""Mock async iterator over Response events."""
@@ -620,6 +645,132 @@ class TestOpenAIResponseStream(IsolatedAsyncioTestCase):
self.mock_client = MagicMock()
self.model.client = self.mock_client
+ async def test_stream_text_and_refusal_part_boundaries(self) -> None:
+ """Mixed parts match non-streaming without repeating done text."""
+ for output in (
+ [_mock_message("msg_one", [("refusal", "Cannot help.")])],
+ [
+ _mock_message(
+ "msg_one",
+ [
+ ("output_text", "Before."),
+ ("refusal", "Cannot help."),
+ ("output_text", "After."),
+ ],
+ ),
+ ],
+ [
+ _mock_message("msg_one", [("output_text", "First.")]),
+ _mock_message("msg_two", [("refusal", "Cannot help.")]),
+ ],
+ [
+ _mock_message(
+ "msg_one",
+ [("output_text", "First."), ("output_text", "Second.")],
+ ),
+ ],
+ ):
+ with self.subTest(output=output):
+ completed = _mock_completion()
+ completed.output = output
+ completed.usage.input_tokens_details = MagicMock(
+ cached_tokens=3,
+ )
+ parts = [
+ (item.id, index, part.type, part.text)
+ if part.type == "output_text"
+ else (item.id, index, part.type, part.refusal)
+ for item in output
+ for index, part in enumerate(item.content)
+ ]
+ expected = ChatResponse(
+ id=A,
+ created_at=A,
+ is_last=True,
+ content=[
+ TextBlock.model_construct(
+ id=A,
+ created_at=A,
+ text=text,
+ )
+ for _, _, _, text in parts
+ ],
+ usage=ChatUsage(
+ input_tokens=10,
+ output_tokens=5,
+ cache_input_tokens=3,
+ time=cast(float, AnyValue()),
+ ),
+ )
+ self.model.stream = False
+ self.mock_client.responses.create = AsyncMock(
+ return_value=completed,
+ )
+ self.assertEqual(await self.model([]), expected)
+ self.mock_client.responses.create.assert_awaited_once()
+
+ events = [
+ _make_event(
+ f"response.{kind}.delta",
+ item_id=item_id,
+ content_index=index,
+ delta=text[:2] if fragment == 0 else text[2:],
+ )
+ for fragment in range(2)
+ for item_id, index, kind, text in parts
+ ]
+ events.extend(
+ _make_event(
+ f"response.{kind}.done",
+ item_id=item_id,
+ content_index=index,
+ **(
+ {"text": text}
+ if kind == "output_text"
+ else {"refusal": text}
+ ),
+ )
+ for item_id, index, kind, text in parts
+ )
+ events.append(
+ _make_event("response.completed", response=completed),
+ )
+ self.model.stream = True
+ self.mock_client.responses.create = AsyncMock(
+ return_value=_MockAsyncEventStream(events),
+ )
+ responses = [r async for r in await self.model([])]
+ self.assertEqual(
+ responses[:-1],
+ [
+ ChatResponse(
+ id=A,
+ created_at=A,
+ is_last=False,
+ content=[
+ TextBlock.model_construct(
+ id=A,
+ created_at=A,
+ text=text[:2]
+ if fragment == 0
+ else text[2:],
+ ),
+ ],
+ )
+ for fragment in range(2)
+ for _, _, _, text in parts
+ ],
+ )
+ self.assertEqual(responses[-1], expected)
+ self.mock_client.responses.create.assert_awaited_once()
+ self.assertEqual(
+ AssistantMsg(
+ name="assistant",
+ content=responses[-1].content,
+ ).get_text_content(),
+ "\n".join(text for _, _, _, text in parts),
+ )
+
async def test_stream_errors_propagate(self) -> None:
"""Failed stream events raise APIError instead of a partial reply."""
body = {"code": "server_error", "message": "Generation failed."}