Merge branch 'main' into ci/pin-actions-sha

Author: chopmob-cloud

src/a2a/server/routes/jsonrpc_dispatcher.py

@@ -233,9 +233,11 @@ async def handle_requests(self, request: Request) -> Response:  # noqa: PLR0911,
             body = await request.json()
             if isinstance(body, dict):
                 request_id = body.get('id')
-                # Ensure request_id is valid for JSON-RPC response (str/int/None only)
-                if request_id is not None and not isinstance(
-                    request_id, str | int
+                # Ensure request_id is valid for JSON-RPC response (str/int/None only;
+                # exclude bool since bool is a subclass of int in Python)
+                if isinstance(request_id, bool) or (
+                    request_id is not None
+                    and not isinstance(request_id, str | int)
                 ):
                     request_id = None
             logger.debug('Request body: %s', body)
@@ -257,6 +259,13 @@ async def handle_requests(self, request: Request) -> Response:  # noqa: PLR0911,
                             message="Invalid request: 'jsonrpc' must be exactly '2.0'"
                         ),
                     )
+                if isinstance(base_request._id, bool):  # noqa: SLF001
+                    return self._generate_error_response(
+                        request_id,
+                        InvalidRequestError(
+                            message='Invalid request: id must be a string, integer, or null'
+                        ),
+                    )
             except Exception as e:
                 logger.exception('Failed to validate base JSON-RPC request')
                 return self._generate_error_response(

src/a2a/server/tasks/database_task_store.py

@@ -25,6 +25,7 @@
 from google.protobuf.json_format import MessageToDict, ParseDict
 from google.protobuf.timestamp_pb2 import Timestamp
 
+from a2a.compat.v0_3.conversions import to_compat_task_status
 from a2a.compat.v0_3.model_conversions import (
     compat_task_model_to_core,
 )
@@ -259,8 +260,16 @@ async def list(
                 )
             if params.status:
                 base_stmt = base_stmt.where(
-                    self.task_model.status['state'].as_string()
-                    == a2a_pb2.TaskState.Name(params.status)
+                    self.task_model.status['state']
+                    .as_string()
+                    .in_(
+                        [
+                            a2a_pb2.TaskState.Name(params.status),
+                            to_compat_task_status(
+                                a2a_pb2.TaskStatus(state=params.status)
+                            ).state.value,
+                        ]
+                    )
                 )
             if params.HasField('status_timestamp_after'):
                 last_updated_after = params.status_timestamp_after.ToDatetime()

tests/server/routes/test_jsonrpc_dispatcher.py

@@ -94,6 +94,41 @@ def _make_send_message_request(
     }
 
 
+class TestJsonRpcRequestIds:
+    """JSON booleans are not numeric JSON-RPC request identifiers."""
+
+    @pytest.mark.parametrize('request_id', [True, False])
+    def test_boolean_id_is_rejected(
+        self, client: TestClient, mock_handler: AsyncMock, request_id: bool
+    ) -> None:
+        request = _make_send_message_request()
+        request['id'] = request_id
+
+        response = client.post('/', json=request)
+        body = response.json()
+
+        assert response.status_code == 200
+        assert body['id'] is None
+        assert body['error']['code'] == -32600
+        mock_handler.on_message_send.assert_not_awaited()
+
+    @pytest.mark.parametrize('request_id', [0, 1, '', 'request'])
+    def test_integer_and_string_ids_are_preserved(
+        self, client: TestClient, mock_handler: AsyncMock, request_id: int | str
+    ) -> None:
+        request = _make_send_message_request()
+        request['id'] = request_id
+
+        response = client.post('/', json=request)
+        body = response.json()
+
+        assert response.status_code == 200
+        assert body['id'] == request_id
+        assert type(body['id']) is type(request_id)
+        assert 'result' in body
+        mock_handler.on_message_send.assert_awaited_once()
+
+
 class TestUnrecognizedFields:
     """Unrecognized fields are ignored, for forward compatibility."""
 

tests/server/tasks/test_database_task_store.py

@@ -407,6 +407,82 @@ def capture_bound_datetimes(
     assert all(value.year >= 1000 for value in bound_datetimes)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'state, legacy_state',
+    [
+        (TaskState.TASK_STATE_SUBMITTED, 'submitted'),
+        (TaskState.TASK_STATE_WORKING, 'working'),
+        (TaskState.TASK_STATE_COMPLETED, 'completed'),
+        (TaskState.TASK_STATE_FAILED, 'failed'),
+        (TaskState.TASK_STATE_CANCELED, 'canceled'),
+        (TaskState.TASK_STATE_INPUT_REQUIRED, 'input-required'),
+        (TaskState.TASK_STATE_REJECTED, 'rejected'),
+        (TaskState.TASK_STATE_AUTH_REQUIRED, 'auth-required'),
+    ],
+)
+async def test_list_tasks_filters_mixed_protocol_states(
+    db_store_parameterized: DatabaseTaskStore,
+    state: TaskState.ValueType,
+    legacy_state: str,
+) -> None:
+    store = db_store_parameterized
+    other_context = ServerCallContext(user=SampleUser('other_user'))
+    for owner_context in (TEST_CONTEXT, other_context):
+        owner = store.owner_resolver(owner_context)
+        for prefix, core_state, stored_state in (
+            ('match', state, legacy_state),
+            ('nonmatch', TaskState.TASK_STATE_UNSPECIFIED, 'unknown'),
+        ):
+            await store.save(
+                Task(
+                    id=f'{owner}-{prefix}-modern',
+                    context_id='mixed-context',
+                    status=TaskStatus(state=core_state),
+                ),
+                owner_context,
+            )
+            async with store.async_session_maker.begin() as session:
+                for version in (None, '0.3'):
+                    await session.execute(
+                        insert(store.task_model).values(
+                            id=f'{owner}-{prefix}-legacy-{version}',
+                            context_id='mixed-context',
+                            owner=owner,
+                            status={'state': stored_state},
+                            protocol_version=version,
+                        )
+                    )
+
+    owner = store.owner_resolver(TEST_CONTEXT)
+    expected_ids = [
+        f'{owner}-match-modern',
+        f'{owner}-match-legacy-None',
+        f'{owner}-match-legacy-0.3',
+    ]
+    for params in (
+        ListTasksRequest(),
+        ListTasksRequest(status=TaskState.TASK_STATE_UNSPECIFIED),
+    ):
+        unfiltered = await store.list(params, TEST_CONTEXT)
+        assert unfiltered.total_size == 6
+        assert {task.id for task in unfiltered.tasks} == {
+            task_id.replace('-match-', f'-{prefix}-')
+            for task_id in expected_ids
+            for prefix in ('match', 'nonmatch')
+        }
+
+    params = ListTasksRequest(status=state, page_size=1)
+    for index, expected_id in enumerate(expected_ids):
+        page = await store.list(params, TEST_CONTEXT)
+        assert page.total_size == 3
+        assert [task.id for task in page.tasks] == [expected_id]
+        assert page.tasks[0].status.state == state
+        assert page.page_size == 1
+        assert bool(page.next_page_token) == (index < len(expected_ids) - 1)
+        params.page_token = page.next_page_token
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     'params, expected_error_message',