mirror of
https://github.com/NCBM/plyngent.git
synced 2026-11-07 15:37:55 +08:00
NCBM
2fdbc3ce5d
DeepSeek's Anthropic compat answers a hosted search inside the turn: the response carries the `thinking` that picked the query, the `server_tool_use`, and the `web_search_tool_result`. The response mapping kept text and tool_use only, so the round lost its evidence — and the `thinking` signature, which only the provider can verify, could not go back at all. `AssistantChatMessage.provider_blocks` carries those blocks as raw JSON now (`thinking` text *and* signature, the query, the result entries with an `encrypted_content` the API rejects when trimmed) and the assistant turn hands them back first, ahead of its text and tool_use blocks; `thinking` also lands in `reasoning_content`, so the chain of thought streams as reasoning like every other surface's. `AnthropicRawContentBlock` names the provider fields a streamed block carries, and `AnthropicServerToolUseContent` keeps the `caller` metadata the wire sends.
390 lines
14 KiB
Python
390 lines
14 KiB
Python
"""Tests for Anthropic Messages chat ↔ native conversion."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
import msgspec
|
|
from msgspec import UNSET
|
|
|
|
from plyngent.agent.messages_bridge import (
|
|
anthropic_response_to_assistant,
|
|
anthropic_response_to_chat_completion,
|
|
anthropic_stop_to_finish_reason,
|
|
anthropic_usage_to_dict,
|
|
chat_messages_to_anthropic,
|
|
chat_param_to_anthropic_param,
|
|
provider_tools_to_anthropic_tools,
|
|
tool_items_to_anthropic_tools,
|
|
)
|
|
from plyngent.lmproto.anthropic.model import (
|
|
AnthropicAssistantMessage,
|
|
AnthropicMessageResponse,
|
|
AnthropicResponseText,
|
|
AnthropicResponseToolUse,
|
|
AnthropicServerToolUseContent,
|
|
AnthropicThinkingContent,
|
|
AnthropicToolDefinition,
|
|
AnthropicToolResultContent,
|
|
AnthropicToolUseContent,
|
|
AnthropicUsage,
|
|
AnthropicUserMessage,
|
|
AnthropicWebSearchToolResultContent,
|
|
)
|
|
from plyngent.lmproto.openai_compatible.model import (
|
|
AssistantChatMessage,
|
|
AssistantFunctionTool,
|
|
AssistantFunctionToolCall,
|
|
ChatCompletionsParam,
|
|
DeveloperChatMessage,
|
|
ReasoningEffort,
|
|
SystemChatMessage,
|
|
ToolChatMessage,
|
|
ToolFunction,
|
|
ToolFunctionItem,
|
|
UserChatMessage,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from plyngent.typedef import Unset
|
|
|
|
|
|
def test_tool_items_to_anthropic_tools() -> None:
|
|
items = [
|
|
ToolFunctionItem(
|
|
function=ToolFunction(
|
|
name="read_file",
|
|
description="Read a file",
|
|
parameters={"type": "object", "properties": {"path": {"type": "string"}}},
|
|
)
|
|
)
|
|
]
|
|
tools = tool_items_to_anthropic_tools(items)
|
|
assert len(tools) == 1
|
|
assert tools[0].name == "read_file"
|
|
assert tools[0].input_schema is not UNSET
|
|
|
|
|
|
def test_chat_messages_system_and_tool_round() -> None:
|
|
messages = [
|
|
SystemChatMessage(content="You are helpful."),
|
|
UserChatMessage(content="hi"),
|
|
AssistantChatMessage(
|
|
content=None,
|
|
tool_calls=[
|
|
AssistantFunctionToolCall(
|
|
id="call_1",
|
|
function=AssistantFunctionTool(name="read_file", arguments='{"path":"a"}'),
|
|
)
|
|
],
|
|
),
|
|
ToolChatMessage(content="file body", tool_call_id="call_1"),
|
|
]
|
|
system, items = chat_messages_to_anthropic(messages)
|
|
assert system == "You are helpful."
|
|
assert len(items) == 3
|
|
assert isinstance(items[0], AnthropicUserMessage)
|
|
assert items[0].content == "hi"
|
|
assert isinstance(items[1], AnthropicAssistantMessage)
|
|
assert isinstance(items[1].content, list)
|
|
assert any(isinstance(b, AnthropicToolUseContent) and b.id == "call_1" for b in items[1].content)
|
|
assert isinstance(items[2], AnthropicUserMessage)
|
|
assert isinstance(items[2].content, list)
|
|
assert isinstance(items[2].content[0], AnthropicToolResultContent)
|
|
assert items[2].content[0].tool_use_id == "call_1"
|
|
assert items[2].content[0].content == "file body"
|
|
|
|
|
|
def test_developer_becomes_user_prefix() -> None:
|
|
system, items = chat_messages_to_anthropic(
|
|
[
|
|
SystemChatMessage(content="persona"),
|
|
UserChatMessage(content="go"),
|
|
DeveloperChatMessage(content="checkpoint"),
|
|
]
|
|
)
|
|
assert system == "persona"
|
|
assert len(items) == 2
|
|
assert isinstance(items[1], AnthropicUserMessage)
|
|
assert items[1].content == "[developer] checkpoint"
|
|
|
|
|
|
def test_merge_consecutive_tool_results() -> None:
|
|
messages = [
|
|
UserChatMessage(content="go"),
|
|
AssistantChatMessage(
|
|
content=None,
|
|
tool_calls=[
|
|
AssistantFunctionToolCall(
|
|
id="c1",
|
|
function=AssistantFunctionTool(name="a", arguments="{}"),
|
|
),
|
|
AssistantFunctionToolCall(
|
|
id="c2",
|
|
function=AssistantFunctionTool(name="b", arguments="{}"),
|
|
),
|
|
],
|
|
),
|
|
ToolChatMessage(content="r1", tool_call_id="c1"),
|
|
ToolChatMessage(content="r2", tool_call_id="c2"),
|
|
]
|
|
_, items = chat_messages_to_anthropic(messages)
|
|
assert len(items) == 3 # user, assistant, one merged tool-result user
|
|
assert isinstance(items[2], AnthropicUserMessage)
|
|
assert isinstance(items[2].content, list)
|
|
assert len(items[2].content) == 2
|
|
|
|
|
|
def test_anthropic_response_to_assistant_with_tools() -> None:
|
|
response = AnthropicMessageResponse(
|
|
id="msg_1",
|
|
model="claude-test",
|
|
stop_reason="tool_use",
|
|
content=[
|
|
AnthropicResponseText(text="calling"),
|
|
AnthropicResponseToolUse(id="tu_1", name="add", input={"a": 1, "b": 2}),
|
|
],
|
|
usage=AnthropicUsage(input_tokens=12, output_tokens=4),
|
|
)
|
|
assistant = anthropic_response_to_assistant(response)
|
|
assert assistant.content == "calling"
|
|
assert assistant.tool_calls is not UNSET
|
|
assert len(assistant.tool_calls) == 1
|
|
call = assistant.tool_calls[0]
|
|
assert isinstance(call, AssistantFunctionToolCall)
|
|
assert call.id == "tu_1"
|
|
assert call.function.name == "add"
|
|
assert '"a":1' in call.function.arguments or '"a": 1' in call.function.arguments
|
|
|
|
|
|
def test_anthropic_response_to_assistant_keeps_thinking_and_search_blocks() -> None:
|
|
"""A server-side search is not a registry call, but it is the round's evidence."""
|
|
response = AnthropicMessageResponse(
|
|
id="msg_search",
|
|
model="deepseek-flash",
|
|
stop_reason="end_turn",
|
|
content=[
|
|
AnthropicThinkingContent(thinking="Let me search.", signature="sig-1"),
|
|
AnthropicServerToolUseContent(
|
|
id="call_00_1",
|
|
name="web_search",
|
|
input={"query": "DeepSeek-V4"},
|
|
caller={"type": "direct"},
|
|
),
|
|
AnthropicWebSearchToolResultContent(
|
|
tool_use_id="call_00_1",
|
|
content=[{"type": "web_search_result", "url": "https://api-docs.deepseek.com"}],
|
|
),
|
|
AnthropicResponseText(text="DeepSeek-V4 is out."),
|
|
],
|
|
usage=AnthropicUsage(input_tokens=16592, output_tokens=1419),
|
|
)
|
|
assistant = anthropic_response_to_assistant(response)
|
|
assert assistant.content == "DeepSeek-V4 is out."
|
|
assert assistant.tool_calls is UNSET
|
|
# The chain of thought is the round's reasoning text; the signature it must
|
|
# go back with only exists on the block.
|
|
assert assistant.reasoning_content == "Let me search."
|
|
assert assistant.provider_blocks == [
|
|
{"type": "thinking", "thinking": "Let me search.", "signature": "sig-1"},
|
|
{
|
|
"type": "server_tool_use",
|
|
"id": "call_00_1",
|
|
"name": "web_search",
|
|
"input": {"query": "DeepSeek-V4"},
|
|
"caller": {"type": "direct"},
|
|
},
|
|
{
|
|
"type": "web_search_tool_result",
|
|
"tool_use_id": "call_00_1",
|
|
"content": [{"type": "web_search_result", "url": "https://api-docs.deepseek.com"}],
|
|
},
|
|
]
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_hands_provider_blocks_back() -> None:
|
|
"""The next request carries the round's thinking and search blocks first."""
|
|
assistant = AssistantChatMessage(
|
|
content="DeepSeek-V4 is out.",
|
|
reasoning_content="Let me search.",
|
|
provider_blocks=[
|
|
{"type": "thinking", "thinking": "Let me search.", "signature": "sig-1"},
|
|
{
|
|
"type": "web_search_tool_result",
|
|
"tool_use_id": "call_00_1",
|
|
"content": [{"type": "web_search_result", "encrypted_content": "sd918tZXSvVp"}],
|
|
},
|
|
],
|
|
tool_calls=[
|
|
AssistantFunctionToolCall(
|
|
id="tu_1",
|
|
function=AssistantFunctionTool(name="read_file", arguments='{"path": "a.py"}'),
|
|
)
|
|
],
|
|
)
|
|
param = ChatCompletionsParam(model="deepseek-flash", messages=[assistant])
|
|
built = chat_param_to_anthropic_param(param)
|
|
# The wire shape: DeepSeek answers a trimmed ``encrypted_content`` with 422.
|
|
data = msgspec.json.decode(msgspec.json.encode(built))
|
|
assert data["messages"] == [
|
|
{
|
|
"role": "assistant",
|
|
"content": [
|
|
{"type": "thinking", "thinking": "Let me search.", "signature": "sig-1"},
|
|
{
|
|
"type": "web_search_tool_result",
|
|
"tool_use_id": "call_00_1",
|
|
"content": [{"type": "web_search_result", "encrypted_content": "sd918tZXSvVp"}],
|
|
},
|
|
{"type": "text", "text": "DeepSeek-V4 is out."},
|
|
{"type": "tool_use", "id": "tu_1", "name": "read_file", "input": {"path": "a.py"}},
|
|
],
|
|
}
|
|
]
|
|
|
|
|
|
def test_provider_tools_to_anthropic_tools_maps_the_search_intent() -> None:
|
|
"""The config default (``{"type": "web_search"}``) becomes the server tool."""
|
|
assert provider_tools_to_anthropic_tools(None) == []
|
|
assert provider_tools_to_anthropic_tools([]) == []
|
|
assert provider_tools_to_anthropic_tools([{"type": "web_search"}]) == [
|
|
{"type": "web_search_20250305", "name": "web_search"}
|
|
]
|
|
# A cap (or any other key) survives the mapping.
|
|
assert provider_tools_to_anthropic_tools([{"type": "web_search", "max_uses": 3}]) == [
|
|
{"type": "web_search_20250305", "name": "web_search", "max_uses": 3}
|
|
]
|
|
# An entry that already names the surface's tool passes through.
|
|
assert provider_tools_to_anthropic_tools([{"type": "web_search_20260209", "name": "web_search"}]) == [
|
|
{"type": "web_search_20260209", "name": "web_search"}
|
|
]
|
|
# Entries without a type are dropped (nothing to declare on the wire).
|
|
assert provider_tools_to_anthropic_tools([{"name": "web_search"}]) == []
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_merges_provider_tools_after_local_ones() -> None:
|
|
param = ChatCompletionsParam(
|
|
model="deepseek-flash",
|
|
messages=[UserChatMessage(content="hi")],
|
|
tools=[
|
|
ToolFunctionItem(
|
|
function=ToolFunction(
|
|
name="read_file",
|
|
description="Read a file.",
|
|
parameters={"type": "object", "properties": {}},
|
|
)
|
|
)
|
|
],
|
|
)
|
|
built = chat_param_to_anthropic_param(param, provider_tools=[{"type": "web_search"}])
|
|
tools = built.tools
|
|
assert tools is not UNSET
|
|
assert isinstance(tools[0], AnthropicToolDefinition)
|
|
assert tools[0].name == "read_file"
|
|
assert tools[1] == {"type": "web_search_20250305", "name": "web_search"}
|
|
|
|
|
|
def test_anthropic_response_to_chat_completion_usage() -> None:
|
|
response = AnthropicMessageResponse(
|
|
id="msg_1",
|
|
model="claude-test",
|
|
stop_reason="end_turn",
|
|
content=[AnthropicResponseText(text="done")],
|
|
usage=AnthropicUsage(input_tokens=9, output_tokens=3),
|
|
)
|
|
chat = anthropic_response_to_chat_completion(response)
|
|
assert chat.choices[0].message.content == "done"
|
|
assert chat.choices[0].finish_reason == "stop"
|
|
assert chat.usage is not UNSET
|
|
assert chat.usage["prompt_tokens"] == 9
|
|
assert chat.usage["completion_tokens"] == 3
|
|
|
|
|
|
def test_stop_reason_mapping() -> None:
|
|
assert anthropic_stop_to_finish_reason("end_turn", has_tool_calls=False) == "stop"
|
|
assert anthropic_stop_to_finish_reason("tool_use", has_tool_calls=True) == "tool_calls"
|
|
assert anthropic_stop_to_finish_reason("max_tokens", has_tool_calls=False) == "length"
|
|
assert anthropic_stop_to_finish_reason("refusal", has_tool_calls=False) == "content_filter"
|
|
assert anthropic_stop_to_finish_reason(None, has_tool_calls=True) == "tool_calls"
|
|
|
|
|
|
def test_usage_to_dict() -> None:
|
|
assert anthropic_usage_to_dict(AnthropicUsage(input_tokens=1, output_tokens=2)) == {
|
|
"prompt_tokens": 1,
|
|
"completion_tokens": 2,
|
|
"total_tokens": 3,
|
|
"input_tokens": 1,
|
|
"output_tokens": 2,
|
|
}
|
|
assert anthropic_usage_to_dict(AnthropicUsage()) is None
|
|
|
|
|
|
def test_chat_param_to_anthropic_param() -> None:
|
|
param = ChatCompletionsParam(
|
|
model="claude-test",
|
|
messages=[
|
|
SystemChatMessage(content="Be brief."),
|
|
UserChatMessage(content="hi"),
|
|
],
|
|
tools=[ToolFunctionItem(function=ToolFunction(name="f", description="d", parameters={"type": "object"}))],
|
|
temperature=0.2,
|
|
max_completion_tokens=1024,
|
|
)
|
|
body = chat_param_to_anthropic_param(param)
|
|
assert body.model == "claude-test"
|
|
assert body.max_tokens == 1024
|
|
assert body.system == "Be brief."
|
|
assert body.tools is not UNSET
|
|
assert len(body.tools) == 1
|
|
assert body.temperature == 0.2
|
|
# No effort configured → no thinking block, provider default applies.
|
|
assert body.thinking is UNSET
|
|
|
|
|
|
def _effort_param(effort: ReasoningEffort | Unset = UNSET) -> ChatCompletionsParam:
|
|
return ChatCompletionsParam(
|
|
model="claude-test",
|
|
messages=[UserChatMessage(content="hi")],
|
|
reasoning_effort=effort,
|
|
)
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_thinking_from_effort() -> None:
|
|
body = chat_param_to_anthropic_param(_effort_param("medium"))
|
|
assert body.thinking is not UNSET
|
|
assert body.thinking.type == "enabled"
|
|
assert body.thinking.budget_tokens == 8192
|
|
# A budget equal to max_tokens is invalid for Anthropic, so the default
|
|
# output limit grows to leave room after it.
|
|
assert body.max_tokens == 8192 + 1024
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_thinking_raises_max_tokens() -> None:
|
|
# Anthropic requires budget_tokens < max_tokens; the answer keeps room after
|
|
# the reasoning budget instead of the budget being shrunk to fit.
|
|
body = chat_param_to_anthropic_param(_effort_param("high"))
|
|
assert body.thinking is not UNSET
|
|
assert body.thinking.budget_tokens == 16384
|
|
assert body.max_tokens == 16384 + 1024
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_explicit_thinking_budget() -> None:
|
|
body = chat_param_to_anthropic_param(_effort_param("minimal"), thinking_budget_tokens=20000)
|
|
assert body.thinking is not UNSET
|
|
assert body.thinking.budget_tokens == 20000
|
|
assert body.max_tokens == 20000 + 1024
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_thinking_budget_floor() -> None:
|
|
body = chat_param_to_anthropic_param(_effort_param("minimal"), thinking_budget_tokens=100)
|
|
assert body.thinking is not UNSET
|
|
assert body.thinking.budget_tokens == 1024
|
|
assert body.max_tokens == 8192
|
|
|
|
|
|
def test_chat_param_to_anthropic_param_thinking_disabled() -> None:
|
|
body = chat_param_to_anthropic_param(_effort_param("none"))
|
|
assert body.thinking is not UNSET
|
|
assert body.thinking.type == "disabled"
|
|
assert body.thinking.budget_tokens is UNSET
|