diff --git a/src/acp/_deserialize.py b/src/acp/_deserialize.py index d847d8e..46e6023 100644 --- a/src/acp/_deserialize.py +++ b/src/acp/_deserialize.py @@ -11,7 +11,7 @@ from collections.abc import Callable from typing import Any -from pydantic import ValidationError +from pydantic import BaseModel, ValidationError from pydantic_core import PydanticUseDefault @@ -50,6 +50,11 @@ def skip_invalid_items(value: Any, handler: Callable[[Any], Any], _info: Any = N Restores ``x-deserialize-skip-invalid-items``. Each item is validated through the field's own list handler, so item coercion and salvaging still apply to the survivors. + + Only wire data is skipped. An item that is already a model instance was built in local + code, so a validation failure there is a programming error (for example passing + ``McpServerHttp`` where the tagged ``HttpMcpServer`` is expected) and is raised instead of + being dropped silently. """ if not isinstance(value, list): return handler(value) @@ -58,5 +63,7 @@ def skip_invalid_items(value: Any, handler: Callable[[Any], Any], _info: Any = N try: salvaged.append(handler([item])[0]) except ValidationError: + if isinstance(item, BaseModel): + raise continue return salvaged diff --git a/tests/test_deserialize.py b/tests/test_deserialize.py index 42188ff..47a0d76 100644 --- a/tests/test_deserialize.py +++ b/tests/test_deserialize.py @@ -6,10 +6,19 @@ from typing import Any -from pydantic import BaseModel, field_validator +import pytest +from pydantic import BaseModel, ValidationError, field_validator from acp._deserialize import salvage_on_error, skip_invalid_items -from acp.schema import ReadTextFileRequest, ToolCallUpdate, WriteTextFileRequest +from acp.schema import ( + HttpHeader, + HttpMcpServer, + McpServerHttp, + NewSessionRequest, + ReadTextFileRequest, + ToolCallUpdate, + WriteTextFileRequest, +) class _Salvage(BaseModel): @@ -60,3 +69,46 @@ def test_skip_invalid_items_on_generated_model() -> None: good = {"type": "content", "content": {"type": "text", "text": "ok"}} update = ToolCallUpdate.model_validate({"toolCallId": "t", "content": [good, {"bogus": 1}]}) assert len(update.content or []) == 1 + + +class _Item(BaseModel): + n: int + + +class _Other(BaseModel): + s: str + + +class _SkipModels(BaseModel): + xs: list[_Item] = [] + + @field_validator("xs", mode="wrap") + @classmethod + def _v(cls, value: Any, handler: Any) -> Any: + return skip_invalid_items(value, handler) + + +def test_skip_invalid_items_raises_for_local_model_instances() -> None: + # Wire data (dicts) stays lenient... + assert _SkipModels.model_validate({"xs": [{"n": 1}, {"bogus": 1}]}).xs == [_Item(n=1)] + # ...but a wrong model built in code is a programming error, not data from a newer peer. + with pytest.raises(ValidationError): + _SkipModels(xs=[_Item(n=1), _Other(s="x")]) # type: ignore[list-item] + + +def test_new_session_request_rejects_untagged_mcp_server_instance() -> None: + headers = [HttpHeader(name="Authorization", value="Bearer x")] + untagged = McpServerHttp(name="m", url="http://127.0.0.1:1/mcp", headers=headers) + with pytest.raises(ValidationError): + NewSessionRequest(cwd="/w", mcp_servers=[untagged]) # type: ignore[list-item] + ok = NewSessionRequest( + cwd="/w", mcp_servers=[HttpMcpServer(name="m", url="http://127.0.0.1:1/mcp", headers=headers)] + ) + assert [s.name for s in ok.mcp_servers] == ["m"] + # Incoming JSON is unchanged: the same fields as a dict parse (type defaults to "http"), + # and a malformed server is still skipped. + wire = NewSessionRequest.model_validate({ + "cwd": "/w", + "mcpServers": [{"name": "m", "url": "u", "headers": []}, {"bogus": 1}], + }) + assert [s.name for s in wire.mcp_servers] == ["m"]