test(search): add metadata-filter poll_until to fix flaky filter tests

## Purpose

CI-0058: `test_search_with_filter_rest` failed with `assert 0 > 0` because
the test only waited for vector indexing (unfiltered search returns >= 3 hits)
but did not wait for the backend's metadata filter index to be ready. Vector
indexing and metadata filter indexing are separate backend processes with
different propagation latencies.

## Solution

- Added a second `poll_until` in `test_search_with_filter_rest` and
  `test_search_with_filter_grpc` that specifically waits for the filtered
  search to return results before asserting. This converts a cryptic
  `AssertionError` into a clear `TimeoutError` if the backend never indexes
  metadata, and eliminates the race for the normal timing-dependent case.
- Added `test_upsert_records_preserves_metadata_fields` to confirm at the
  SDK level that non-`field_map` fields (e.g. `category`) are forwarded in
  the NDJSON payload — ruling out SDK-side metadata stripping as a root cause.

Code analysis ruled out the two other hypotheses:
- H1 (SDK strips non-field_map fields): `upsert_records` shallow-copies all
  fields and serializes them verbatim to NDJSON. New unit test confirms this.
- H2 (filter dropped from search request): `Index.search` puts `filter` in
  `body["query"]["filter"]` per the API spec. Existing unit test confirms this.

Fixes CI-0058.

Author: jhamon

tests/integration/test_search.py

@@ -396,7 +396,7 @@ def test_search_with_filter_rest(client: Pinecone, api_key: str) -> None:
             ],
         )
 
-        # Wait for records to be searchable (eventual consistency)
+        # Wait for records to be searchable (eventual consistency — vector indexing)
         poll_until(
             query_fn=lambda: index.search(
                 namespace=namespace,
@@ -408,7 +408,23 @@ def test_search_with_filter_rest(client: Pinecone, api_key: str) -> None:
             description="all records searchable before filter test",
         )
 
-        # Search with category=science filter, requesting category field in hits
+        # Wait for metadata filter indexing — may lag behind vector indexing.
+        # poll_until raises TimeoutError (not AssertionError) if it never converges,
+        # giving a clear signal that the backend hasn't indexed the category field.
+        response = poll_until(
+            query_fn=lambda: index.search(
+                namespace=namespace,
+                top_k=5,
+                inputs={"text": "science and research"},
+                filter={"category": {"$eq": "science"}},
+                fields=["category"],
+            ),
+            check_fn=lambda r: len(r.result.hits) > 0,
+            timeout=60,
+            description="filtered search returns science records",
+        )
+
+        # Re-fetch with the same params so the final response is used for assertions
         response = index.search(
             namespace=namespace,
             top_k=5,
@@ -504,7 +520,7 @@ def test_search_with_filter_grpc(client: Pinecone, api_key: str) -> None:
             ],
         )
 
-        # Wait for records to be searchable
+        # Wait for records to be searchable (vector indexing)
         poll_until(
             query_fn=lambda: index.search(
                 namespace=namespace,
@@ -516,6 +532,19 @@ def test_search_with_filter_grpc(client: Pinecone, api_key: str) -> None:
             description="records searchable (gRPC) before filter test",
         )
 
+        # Wait for metadata filter indexing — may lag behind vector indexing.
+        poll_until(
+            query_fn=lambda: index.search(
+                namespace=namespace,
+                top_k=5,
+                inputs={"text": "science research"},
+                filter={"category": {"$eq": "science"}},
+            ),
+            check_fn=lambda r: len(r.result.hits) > 0,
+            timeout=60,
+            description="filtered search (gRPC) returns science records",
+        )
+
         # Search with filter via gRPC index (delegates to REST internally)
         response = index.search(
             namespace=namespace,

tests/unit/test_upsert_records.py

@@ -169,6 +169,36 @@ def test_upsert_records_keyword_only(self) -> None:
         with pytest.raises(TypeError):
             idx.upsert_records([{"_id": "r1"}], "test-ns")  # type: ignore[misc]
 
+    @respx.mock
+    def test_upsert_records_preserves_metadata_fields(self) -> None:
+        """Non-field_map fields (e.g. 'category') are forwarded in the NDJSON payload.
+
+        Regression guard for CI-0058: if the SDK were to strip non-embedded fields
+        before sending, metadata filters would silently return zero hits because the
+        backend would have nothing to filter on.
+        """
+        route = respx.post(UPSERT_URL).mock(
+            return_value=httpx.Response(201),
+        )
+        idx = _make_index()
+        idx.upsert_records(
+            namespace="test-ns",
+            records=[
+                {"_id": "sci-1", "text": "Quantum mechanics.", "category": "science"},
+                {"_id": "hist-1", "text": "The Roman Empire.", "category": "history"},
+            ],
+        )
+
+        body = route.calls.last.request.content.decode("utf-8")
+        lines = body.strip().split("\n")
+        assert len(lines) == 2
+        parsed_0 = json.loads(lines[0])
+        parsed_1 = json.loads(lines[1])
+        assert parsed_0["category"] == "science"
+        assert parsed_0["text"] == "Quantum mechanics."
+        assert parsed_1["category"] == "history"
+        assert parsed_1["text"] == "The Roman Empire."
+
     @respx.mock
     def test_upsert_records_response_bracket_access(self) -> None:
         respx.post(UPSERT_URL).mock(