benchmax 0.1.2.dev30__py3-none-any.whl → 0.1.2.dev33__py3-none-any.whl

benchmax/bundle.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 import inspect
 import io
 import json
@@ -76,6 +77,7 @@ def dump_bundle(
     pip_dependencies: list[str] | None = None,
     local_modules: list[ModuleType] | None = None,
     env_class_source: str | None = None,
+    auto_local_modules: bool = True,
 ) -> Bundle:
     """Pickle ``(env_class, constructor_args)`` and stamp metadata.
 
@@ -90,6 +92,10 @@ def dump_bundle(
             recover it — e.g. a class produced by ``exec()`` into an in-memory
             namespace, which has no source file on disk. When ``None``
             (default), source is introspected from ``env_class``.
+        auto_local_modules: When True (default), any local module the pickle
+            references but that wasn't passed in ``local_modules`` is imported
+            and pickled by value automatically (a warning names them). When
+            False, such a reference raises ``BundlingError`` instead.
 
     Raises:
         BundlingError: bad env_class, cloudpickle failure, or pickle references
@@ -124,6 +130,46 @@ def dump_bundle(
                 except Exception:
                     pass
 
+    if auto_local_modules and _unregistered_local_refs(pickled):
+        # Import each referenced local module and re-dump with it pickled by
+        # value. Loop because a by-value module can surface further local refs;
+        # registrations accumulate (and are torn down once at the end) so an
+        # earlier module stays by-value while we resolve the ones it pulled in.
+        seen: set[str] = {m.__name__ for m in local_modules}
+        registered: list[ModuleType] = []
+        with _BUNDLE_LOCK:
+            try:
+                for _ in range(10):
+                    pending = [
+                        m for m in _unregistered_local_refs(pickled) if m not in seen
+                    ]
+                    if not pending:
+                        break
+                    new_mods: list[ModuleType] = []
+                    for name in pending:
+                        seen.add(name)  # unimportable names fall through to the guard
+                        try:
+                            new_mods.append(importlib.import_module(name))
+                        except Exception:
+                            pass
+                    if not new_mods:
+                        break
+                    logger.warning(
+                        "[bundle] %s: auto-bundling local module(s): %s ",
+                        env_class.__name__,
+                        ", ".join(sorted(m.__name__ for m in new_mods)),
+                    )
+                    for mod in new_mods:
+                        cloudpickle.register_pickle_by_value(mod)
+                        registered.append(mod)
+                    pickled = cloudpickle.dumps((env_class, constructor_args))
+            finally:
+                for mod in registered:
+                    try:
+                        cloudpickle.unregister_pickle_by_value(mod)
+                    except Exception:
+                        pass
+
     risky = _unregistered_local_refs(pickled)
     if risky:
         msg = (
@@ -259,6 +305,15 @@ def _referenced_modules(pickled: bytes) -> set[str]:
     # Hooks find_class so we see every (module, name) the unpickler would import —
     # i.e. exactly what'd raise ModuleNotFoundError on a fresh interpreter. The stub
     # lets unpickling proceed past missing classes so we collect every ref.
+    #
+    # find_class alone has a blind spot: a bare ``import foo`` that leaves a
+    # module *object* in the env's globals is pickled as
+    # ``cloudpickle.subimport("foo")`` — the module name is a REDUCE argument,
+    # not a find_class path, so we'd only see ``cloudpickle.cloudpickle`` (which
+    # looks installed) and miss ``foo``. We shim subimport to record its arg and
+    # return a stub instead of importing, so a missing module is captured rather
+    # than aborting the whole load early. (``dynamic_subimport`` is by-value /
+    # self-contained — leave it to the real find_class so we don't flag it.)
     refs: set[str] = set()
 
     class _Stub:
@@ -271,9 +326,28 @@ def _referenced_modules(pickled: bytes) -> set[str]:
         def __reduce__(self) -> tuple:
             return (type(self), ())
 
+    def _recording_subimport(name: str, *a: Any, **kw: Any) -> ModuleType:
+        refs.add(name)
+        return ModuleType(str(name))
+
+    def _noop_setstate(obj: Any, *a: Any, **kw: Any) -> Any:
+        # cloudpickle's _make_skeleton_class resolves the class_tracker_id back
+        # to the *live* class (it was tracked when env_class was dumped), so the
+        # real ``_class_setstate``/``_function_setstate`` would setattr the
+        # reconstructed (stub-globals) members onto the live class/function —
+        # mutating the caller's class mid-bundle and poisoning any later dump.
+        # We only need the refs from ``state``, which are already recorded while
+        # it's unpickled; the setter itself is a no-op here.
+        return obj
+
     class _Recorder(pickle.Unpickler):
         def find_class(self, module: str, name: str) -> Any:
             refs.add(module)
+            if module.startswith("cloudpickle"):
+                if name == "subimport":
+                    return _recording_subimport
+                if name in ("_class_setstate", "_function_setstate"):
+                    return _noop_setstate
             try:
                 return super().find_class(module, name)
             except Exception:

benchmax/envs/postgres_search/search_env.py

@@ -285,14 +285,8 @@ tags. Cite your sources inline using [Source: <source_id>] next to each claim.
             if not text.strip():
                 return zeros
 
-            # No final <answer> block → no answer to score. Return all-zero
-            # rewards so conciseness / citations / efficiency can't accrue
-            # from reasoning or tool-call text alone.
-            answer = extract_answer_block(text)
-            if not answer:
-                return zeros
-
             t = task or {}
+            answer = extract_answer_block(text)
             prompt = str(t.get("question") or t.get("prompt") or "")
             gt_str = str(t.get("ground_truth") or "")
             reference_chunks = t.get("reference_chunks", [])

benchmax/envs/reward_helpers.py

@@ -82,16 +82,9 @@ def extract_completion_text(completion: str | list[dict[str, Any]]) -> str:
 
 
 def extract_answer_block(text: str) -> str:
-    """Extract content from ``<answer>`` tags.
-
-    Returns the (stripped) tag contents when an ``<answer>…</answer>`` block
-    is present, otherwise ``""``. A missing answer block is treated as "no
-    final answer" rather than silently falling back to the full completion —
-    consumers can gate rewards on a non-empty result. ``<answer></answer>``
-    likewise yields ``""``.
-    """
+    """Extract content from <answer> tags, or return full text."""
     match = _ANSWER_TAG_RE.search(text or "")
-    return match.group(1).strip() if match else ""
+    return (match.group(1) if match else text).strip()
 
 
 def clip01(value: Any) -> float:
@@ -169,10 +162,8 @@ def citation_score(
                 ref_ids.add(norm_sid)
             break
 
-    if not cited:
+    if not cited or not ref_ids:
         return {"precision": 0.0, "recall": 0.0}
-    if not ref_ids:
-        return {"precision": 1.0, "recall": 0.0}
 
     precision = len(cited & ref_ids) / len(cited)
     recall = len(cited & ref_ids) / len(ref_ids)

benchmax/envs/telestich/example.py

@@ -12,10 +12,12 @@ Run it from the benchmax project root (the ``telestich`` extra pulls in the
 env's word-list / rhyme dependencies):
 
     cd core/benchmax
-    CASTFORM_API_KEY=sk_... \
-        uv run --extra telestich python -m benchmax.envs.telestich.example
+    uv run --extra telestich python -m benchmax.envs.telestich.example
 
-(``CASTFORM_LLM_API_KEY`` is optional — it defaults to ``CASTFORM_API_KEY``.)
+Auth is the device-auth session (``ensure_session()`` opens a browser login if
+``~/.castform`` has no valid session) — no API key needed. ``CASTFORM_API_KEY``
+/ ``CASTFORM_LLM_API_KEY`` are only consulted by the offline dataset-generation
+helpers, not the launch path.
 
 This launches a real training run on the full committed seed dataset
 (~90/10 train/eval split).
@@ -63,6 +65,8 @@ CONCURRENCY = 15
 # pool) server-side. Supported: "Qwen/Qwen3.5-4B" (gpu4) or "Qwen/Qwen3.5-35B-A3B"
 # (gpu8). Override via TELESTICH_MODEL.
 MODEL = os.environ.get("TELESTICH_MODEL", "Qwen/Qwen3.5-4B")
+# Run name — defaults to a unique telestich-full-<uuid>. Override via TELESTICH_RUN_NAME.
+RUN_NAME = os.environ.get("TELESTICH_RUN_NAME", "")
 
 # (model, weight). Weights reflect observed reliability on our checks:
 # - Both grok models leak banned example words and rubber-stamp the CoT self-check.
@@ -558,12 +562,15 @@ def get_dataset():
 if __name__ == "__main__":
     import uuid
 
+    from benchmax.platform import ensure_session
     from benchmax.platform.client import TrainerClient
     from benchmax.platform.training_run import upload_training_run
     from benchmax.platform.validation import validate_env
 
-    if not API_KEY:
-        raise SystemExit("Set CASTFORM_API_KEY before running this example.")
+    # Device-auth session bootstrap: browser login if no credential resolves.
+    # After this the platform bearer comes from ~/.castform — no API key needed,
+    # so we pass api_key="" to the platform calls below (resolves via the seam).
+    ensure_session()
 
     print(f"Platform URL: {BASE_URL}")
     print(f"LLM URL:      {LLM_BASE_URL}\n")
@@ -603,7 +610,7 @@ if __name__ == "__main__":
         eval_dataset=eval_data[:2],
         local_modules=local_modules,
         pip_dependencies=pip_dependencies,
-        api_key=API_KEY,
+        api_key="",  # session bearer via ensure_session()
         base_url=BASE_URL,
         llm_base_url=LLM_BASE_URL,
         llm_api_key="",
@@ -614,14 +621,14 @@ if __name__ == "__main__":
         )
 
     # 3. Bundle the env class and upload everything to platform storage.
-    run_name = f"telestich-full-{uuid.uuid4().hex[:8]}"
+    run_name = RUN_NAME or f"telestich-full-{uuid.uuid4().hex[:8]}"
     print(f"\nUploading bundle + datasets as {run_name!r} ...")
     uploaded = upload_training_run(
         env_class=TelestichEnv,
         train_dataset=train_data,
         eval_dataset=eval_data,
         run_name=run_name,
-        api_key=API_KEY,
+        api_key="",  # session bearer via ensure_session()
         base_url=BASE_URL,
         local_modules=local_modules,
         constructor_args=constructor_args,
@@ -638,7 +645,7 @@ if __name__ == "__main__":
     # 4. Launch the training run. training_run_type="simple" + the `model` arg select
     #    the trainer YAML/pool server-side (Qwen3.5-4B→gpu4, Qwen3.5-35B-A3B→gpu8).
     print(f"\nLaunching training run (model={MODEL}) ...")
-    with TrainerClient(api_key=API_KEY, base_url=BASE_URL) as trainer:
+    with TrainerClient(api_key="", base_url=BASE_URL) as trainer:
         run_id = trainer.launch_training_run(
             training_run_type="simple",
             env_cls_path=uploaded.env_cls_path,
@@ -647,10 +654,10 @@ if __name__ == "__main__":
             eval_dataset_path=uploaded.eval_dataset_path,
             name=run_name,
             # num_epochs: passes over the train set (platform default is 5).
-            # max_response_len 3000: a brief reason + 1-2 tool rounds + poem fits well
+            # max_rollout_len 3000: a brief reason + 1-2 tool rounds + poem fits well
             # under this; lowered from 4000 to cut off in-head enumeration rambles
             # sooner (they truncate to a 0-reward anyway).
-            launcher_args={"model": MODEL, "max_response_len": 3000, "num_epochs": 10},
+            launcher_args={"model": MODEL, "max_rollout_len": 3000, "num_epochs": 10},
         )
 
     print(f"\n✓ Launched run_id={run_id}")

benchmax/platform/client.py

@@ -7,6 +7,7 @@ import hashlib
 import json
 import logging
 import textwrap
+import warnings
 from collections.abc import Iterator
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -404,7 +405,7 @@ class TrainerClient:
             eval_dataset_path: Path to the evaluation dataset
             name: Optional name for the training run
             launcher_args: Extra launcher args forwarded to the server
-                (e.g. {"max_response_len": 4000}). The 4 required paths
+                (e.g. {"max_rollout_len": 4000}). The 4 required paths
                 above always take precedence.
 
         Returns:
@@ -431,8 +432,11 @@ class TrainerClient:
         )
         self._handle_response_errors(response)
         body = response.json()
+        # Surface soft-cap / OOM-risk warnings via the warnings module (shown by
+        # default in notebooks/REPL) — a bare logger.warning is swallowed unless
+        # the caller configured logging.
         for warning in body.get("warnings", []) or []:
-            logger.warning("launch warning: %s", warning)
+            warnings.warn(f"launch warning: {warning}", stacklevel=2)
         return body["runId"]
 
     def list_launch_args(self) -> list[LaunchArgSpec]:

benchmax/platform/validation.py

@@ -7,6 +7,7 @@ the env class contract matches what the trainer expects.
 from __future__ import annotations
 
 import asyncio
+import importlib
 import json
 import math
 import tempfile
@@ -578,6 +579,41 @@ def _run_local_checks(
             from benchmax.bundle import unregistered_local_refs
 
             risky = unregistered_local_refs(cloudpickle.dumps(env_class))
+            # Mirror dump_bundle's auto_local_modules: import + pickle-by-value
+            # any local refs the user didn't list, so validation reflects what
+            # the bundle will actually contain. Only genuinely unimportable refs
+            # (which the trainer also couldn't load) remain to be flagged.
+            auto: list[ModuleType] = []
+            if risky:
+                seen: set[str] = set()
+                try:
+                    for _ in range(10):
+                        pending = [
+                            m
+                            for m in unregistered_local_refs(cloudpickle.dumps(env_class))
+                            if m not in seen
+                        ]
+                        if not pending:
+                            break
+                        new_mods: list[ModuleType] = []
+                        for name in pending:
+                            seen.add(name)
+                            try:
+                                new_mods.append(importlib.import_module(name))
+                            except Exception:
+                                pass
+                        if not new_mods:
+                            break
+                        for mod in new_mods:
+                            cloudpickle.register_pickle_by_value(mod)
+                            auto.append(mod)
+                    risky = unregistered_local_refs(cloudpickle.dumps(env_class))
+                finally:
+                    for mod in auto:
+                        try:
+                            cloudpickle.unregister_pickle_by_value(mod)
+                        except Exception:
+                            pass
             if risky:
                 print(
                     f"  \u2717 {env_class.__name__}: missing "
@@ -589,7 +625,13 @@ def _run_local_checks(
                 )
                 failed += 1
             else:
-                print("  \u2713 no unregistered local-module references")
+                if auto:
+                    names = ", ".join(sorted(m.__name__ for m in auto))
+                    print(
+                        f"  \u2713 auto-bundled local module(s): {names} "
+                    )
+                else:
+                    print("  \u2713 no unregistered local-module references")
                 passed += 1
         except Exception as exc:
             print(f"  \u2717 local-modules check failed: {type(exc).__name__}: {exc}")

benchmax/rag/corpus/chroma/client.py

@@ -16,6 +16,13 @@ from typing import Any
 # Sparse-key name used when setting up BM25 schema
 BM25_KEY = "bm25_embedding"
 
+# Embedding functions that run server-side on Chroma Cloud (embed.trychroma.com)
+# — querying a collection that uses one never downloads a model. Everything else
+# (default all-MiniLM, sentence-transformers / HF / Ollama / ONNX locals,
+# third-party API EFs, or no EF) is treated as unsafe. Add hosted names here as
+# they are verified server-side.
+_SERVER_SIDE_EF_NAMES = frozenset({"chroma-cloud-qwen"})
+
 
 def has_search_api() -> bool:
     """Return True when the chromadb package exposes the Search API."""
@@ -176,6 +183,29 @@ class ChromaClient:
 
         return self._collection
 
+    def dense_embed_is_safe(self) -> bool:
+        """True when a dense (vector) query embeds WITHOUT downloading a model.
+
+        Safe only when we can produce vectors without a client-side model
+        download: either a caller-supplied ``embed_fn``, or a Chroma-hosted
+        server-side embedding function (embeds at embed.trychroma.com). Every
+        other embedder — chromadb's default all-MiniLM, sentence-transformers /
+        HuggingFace / Ollama / ONNX locals, third-party API EFs we lack keys
+        for, or no EF at all — is treated as UNSAFE, so callers refuse the dense
+        path rather than trigger a model download. Conservative by design: an
+        unknown embedder is unsafe.
+        """
+        if self.embed_fn is not None:
+            return True
+        col = self._collection
+        if col is None:
+            return False
+        try:
+            ef = (col._model.configuration_json or {}).get("embedding_function") or {}
+        except Exception:
+            return False
+        return ef.get("name") in _SERVER_SIDE_EF_NAMES
+
     @staticmethod
     def _repair_cloud_embedding_function(collection: Any) -> None:
         """Attach a working EF when chromadb can't rebuild a Cloud hosted one.

benchmax/rag/corpus/chroma/search.py

@@ -10,6 +10,9 @@ from collections.abc import Callable
 from typing import Any
 
 from benchmax.platform.credentials import TokenProvider, as_token_provider, env_token
+from benchmax.rag.corpus.search_schema.search_exceptions import (
+    LocalEmbeddingDownloadDisallowedError,
+)
 
 
 class ChromaSearch:
@@ -113,19 +116,33 @@ class ChromaSearch:
     ) -> list[dict[str, Any]]:
         """Search and return structured results."""
         client = self._get_client()
-
-        if mode == "auto":
-            modes = client.modes
+        # Initialize the collection first so capabilities reflect the real index
+        # (BM25 downgrade) and the embedder config is readable below.
+        client.get_collection()
+        modes = client.modes
+        has_lexical = "lexical" in modes
+
+        # Never download a client-side embedding model at inference/rollout time.
+        # When a dense embed isn't safe — no embed_fn and no Chroma-hosted
+        # server-side embedding function — use the BM25 lexical index if the
+        # collection has one, otherwise refuse rather than fetch all-MiniLM.
+        if not client.dense_embed_is_safe():
+            if not has_lexical:
+                raise LocalEmbeddingDownloadDisallowedError(
+                    "chroma", self._collection_name
+                )
+            mode = "lexical"
+        elif mode == "auto":
             if "hybrid" in modes:
                 mode = "hybrid"
-            elif "lexical" in modes:
+            elif has_lexical:
                 mode = "lexical"
             else:
                 mode = "vector"
-        elif mode not in client.modes:
+        elif mode not in modes:
             raise ValueError(
                 f"ChromaSearch does not support mode '{mode}'. "
-                f"Available modes: {sorted(client.modes)}"
+                f"Available modes: {sorted(modes)}"
             )
 
         if client.search_api and mode in ("lexical", "hybrid"):

benchmax/rag/corpus/chroma/source.py

@@ -17,6 +17,7 @@ from tqdm.auto import tqdm
 from benchmax.rag.chunkers.models import Chunk, ChunkCollection
 from benchmax.rag.corpus.search_schema.search_exceptions import (
     InvalidSearchSpecError,
+    LocalEmbeddingDownloadDisallowedError,
     UnsupportedSearchModeError,
 )
 from benchmax.rag.corpus.search_schema.search_types import (
@@ -642,23 +643,30 @@ class ChromaChunkSource:
         # lack a BM25 index, in which case modes was downgraded to vector-only.
         modes = self._current_modes()
 
-        # Pick mode. "hybrid"/None use the best available strategy and KEEP
-        # lexical enabled as a fallback: hybrid = dense + sparse, and when we
-        # can't produce dense query vectors (no embed_fn, the usual remote case)
-        # the per-query loop below degrades to the sparse/lexical leg — which
-        # needs no embedding. Only an explicit "vector" disables lexical; that's
-        # the dense-only recovery path a caller uses after a lexical/hybrid
-        # failure. (Disabling lexical for "hybrid" silently forced vector search,
-        # which made remote collections dense-embed every query — slow, and on a
-        # default-EF collection it pulls the all-MiniLM model.)
-        if mode == "vector":
-            use_hybrid = use_lexical = False
+        has_lexical = "lexical" in modes
+        has_hybrid = "hybrid" in modes
+
+        # Hard rule: never let chromadb embed a query with a client-side model
+        # (it downloads all-MiniLM and crawls in constrained executors). When a
+        # dense embed isn't safe — no embed_fn and no Chroma-hosted server-side
+        # embedding function — use the BM25 lexical index if the collection has
+        # one, otherwise refuse. This covers every requested mode, including the
+        # linker's "inference" preference for vector.
+        if not self._chroma.dense_embed_is_safe():
+            if not has_lexical:
+                raise LocalEmbeddingDownloadDisallowedError(
+                    "chroma", self._chroma.collection_name
+                )
+            use_hybrid = False
+            use_lexical = True
         elif mode == "lexical":
             use_hybrid = False
-            use_lexical = "lexical" in modes
+            use_lexical = has_lexical
+        elif mode == "vector":
+            use_hybrid = use_lexical = False
         else:  # "hybrid", None, or unrecognized -> best available
-            use_hybrid = "hybrid" in modes
-            use_lexical = "lexical" in modes
+            use_hybrid = has_hybrid
+            use_lexical = has_lexical
 
         # Batch-embed all queries when embed_fn available and vectors needed
         vectors: list[list[float]] | None = None

benchmax/rag/corpus/pinecone/index_client.py

@@ -60,9 +60,17 @@ class PineconeIndexClient:
         embed_model: Pinecone hosted embedding model name.  Ignored when
             ``embed_fn`` is provided.  Defaults to
             ``"multilingual-e5-large"``.
-        field_mapping: Maps *Pinecone metadata field names* → *internal
-            field names*.  Useful for "bring your own index" scenarios where
-            the user's metadata schema differs from the default.
+        field_mapping: Low-level escape hatch — maps *Pinecone metadata
+            field names* → *internal field names* for schemas that also
+            relocate structural fields (``file_path``, ``chunk_index``,
+            headers).  For the common "my text is under a different key"
+            case, prefer ``content_field``.
+        content_field: Pinecone metadata key holding the chunk text, for
+            "bring your own index" schemas that don't use ``content`` (e.g.
+            ``"summary"`` or ``"passage"``).  The canonical way to point at
+            your text column.  Empty / None means the default ``content``
+            key.  Raises if ``field_mapping`` already maps a *different*
+            key to ``content``.
     """
 
     def __init__(
@@ -75,15 +83,35 @@ class PineconeIndexClient:
         embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
         embed_model: str = "multilingual-e5-large",
         field_mapping: dict[str, str] | None = None,
+        content_field: str | None = None,
     ) -> None:
         # Store config for lazy init / pickle safety.
         self._api_key = api_key
         self._index_name = index_name
         self._index_host = index_host
-        self._namespace = namespace
+        # Platform codegen may pass None for an unset namespace; Pinecone's
+        # default namespace is "".
+        self._namespace = namespace or ""
         self._embed_model = embed_model
         self.embed_fn = embed_fn or self._build_pinecone_embed_fn()
-        self._field_mapping = field_mapping or dict(DEFAULT_FIELD_MAPPING)
+        mapping = dict(field_mapping) if field_mapping else dict(DEFAULT_FIELD_MAPPING)
+        if content_field and content_field != "content":
+            conflicting = [
+                k
+                for k, v in mapping.items()
+                if v == "content" and k not in ("content", content_field)
+            ]
+            if field_mapping and conflicting:
+                raise ValueError(
+                    f"content_field={content_field!r} conflicts with field_mapping "
+                    f"entries {conflicting} that already map to 'content'. "
+                    "Specify the text column one way or the other."
+                )
+            # Drop the default content→content entry so the reverse mapping
+            # resolves "content" to the custom key unambiguously.
+            mapping.pop("content", None)
+            mapping[content_field] = "content"
+        self._field_mapping = mapping
         # Reverse mapping: internal name → pinecone metadata key
         self._reverse_mapping = {v: k for k, v in self._field_mapping.items()}
         self._index: Any | None = None
@@ -91,6 +119,8 @@ class PineconeIndexClient:
         self._known_ids: list[str] | None = None
         # Cached vector dimension (detected on first embed or describe_index).
         self._vector_dim: int | None = None
+        # Cached index vector type ("dense" | "sparse"), probed lazily.
+        self._vector_type: str | None = None
 
     def _build_pinecone_embed_fn(self) -> Callable[[list[str]], list[list[float]]]:
         """Build an embed_fn using Pinecone's hosted Inference API.
@@ -157,6 +187,35 @@ class PineconeIndexClient:
                 self._index = pc.Index(self._index_name)
         return self._index
 
+    def vector_type(self) -> str:
+        """Return the index vector type, ``"dense"`` or ``"sparse"``.
+
+        Probes the index via ``describe_index_stats`` on first call and
+        caches the result.
+        """
+        if self._vector_type is None:
+            index = self._get_index()
+            stats = index.describe_index_stats()
+            self._vector_type = getattr(stats, "vector_type", None) or "dense"
+        return self._vector_type
+
+    def namespace_vector_count(self) -> int:
+        """Return the vector count for this client's namespace.
+
+        Scoped to the namespace, NOT the index-wide total — an index-wide
+        count would disagree with what list/fetch/query in this namespace
+        can actually see.  The SDK keys the default namespace as
+        ``"__default__"`` (the REST API uses ``""``).
+        """
+        stats = self._get_index().describe_index_stats()
+        namespaces = getattr(stats, "namespaces", None) or {}
+        ns_stats = namespaces.get(self._namespace or "__default__")
+        if ns_stats is None and not self._namespace:
+            ns_stats = namespaces.get("")
+        if ns_stats is None:
+            return 0
+        return int(getattr(ns_stats, "vector_count", 0) or 0)
+
     def zero_vector(self) -> list[float]:
         """Return a zero-vector with the correct dimension for this index.
 
@@ -168,6 +227,12 @@ class PineconeIndexClient:
             index = self._get_index()
             stats = index.describe_index_stats()
             self._vector_dim = stats.dimension
+        if self._vector_dim is None:
+            # Sparse indexes have no fixed dimension.
+            raise ValueError(
+                f"Pinecone index '{self._index_name}' has no dimension — it is "
+                "a sparse index, which has no dense zero-vector."
+            )
         return [0.0] * self._vector_dim
 
     # ------------------------------------------------------------------
@@ -305,6 +370,14 @@ class PineconeIndexClient:
         include_metadata: bool = True,
     ) -> Any:
         """Run a vector query against the index."""
+        if self.vector_type() == "sparse":
+            # A dense query vector against a sparse index is rejected by
+            # Pinecone with an opaque error; fail with an actionable one.
+            raise ValueError(
+                f"Pinecone index '{self._index_name}' is a sparse index — "
+                "search against sparse indexes is not supported yet. "
+                "Use a dense index."
+            )
         index = self._get_index()
         kwargs: dict[str, Any] = {
             "vector": vector,

benchmax/rag/corpus/pinecone/search.py

@@ -36,6 +36,8 @@ class PineconeSearch:
         embed_model: Pinecone hosted embedding model name. Ignored
             when ``embed_fn`` is provided.
         field_mapping: Maps Pinecone metadata keys to internal names.
+        content_field: Pinecone metadata key holding the chunk text — sugar
+            over ``field_mapping`` for BYO indexes that don't use ``content``.
         token_provider: Optional override — a callable resolving the key per
             call, or a literal key (string sugar). Defaults to reading
             ``PINECONE_API_KEY``.
@@ -50,6 +52,7 @@ class PineconeSearch:
         embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
         embed_model: str = "multilingual-e5-large",
         field_mapping: dict[str, str] | None = None,
+        content_field: str | None = None,
         token_provider: str | TokenProvider | None = None,
     ) -> None:
         self._index_name = index_name
@@ -58,6 +61,7 @@ class PineconeSearch:
         self._embed_fn = embed_fn
         self._embed_model = embed_model
         self._field_mapping = field_mapping
+        self._content_field = content_field
         self._token_provider = as_token_provider(
             token_provider, env_token("PINECONE_API_KEY")
         )
@@ -75,6 +79,7 @@ class PineconeSearch:
                 embed_fn=self._embed_fn,
                 embed_model=self._embed_model,
                 field_mapping=self._field_mapping,
+                content_field=self._content_field,
             )
         return self._client
 

benchmax/rag/corpus/pinecone/source.py

@@ -26,6 +26,9 @@ from .index_client import PineconeIndexClient
 
 logger = logging.getLogger(__name__)
 
+#: Max IDs per vectors/fetch call — Pinecone caps fetch batches at 100.
+_FETCH_BATCH_SIZE = 100
+
 
 def _raw_to_chunk(raw: dict[str, Any]) -> Chunk:
     """Convert a raw dict from PineconeIndexClient to a Chunk."""
@@ -64,8 +67,13 @@ class PineconeChunkSource:
         embed_model: Pinecone hosted embedding model name.  Ignored when
             ``embed_fn`` is provided.  Defaults to
             ``"multilingual-e5-large"``.
-        field_mapping: Maps Pinecone metadata field names to internal names.
-            Useful for "bring your own index" scenarios.
+        field_mapping: Low-level escape hatch — maps Pinecone metadata field
+            names to internal names when structural fields (``file_path``,
+            ``chunk_index``, headers) are also relocated.  For the common
+            case, prefer ``content_field``.
+        content_field: Pinecone metadata key holding the chunk text — the
+            canonical way to point at your text column for pre-existing
+            indexes that don't use ``content``.
 
     Example:
         >>> # Using Pinecone's built-in embeddings (simplest)
@@ -82,12 +90,12 @@ class PineconeChunkSource:
         ...     embed_fn=my_embed_fn,
         ... )
 
-        >>> # Pre-existing index with custom field names
+        >>> # Pre-existing index whose text lives under another key
         >>> source = PineconeChunkSource(
         ...     api_key="pcsk_...",
         ...     index_name="product-catalog",
         ...     embed_model="llama-text-embed-v2",
-        ...     field_mapping={"description": "content", "path": "file_path"},
+        ...     content_field="description",
         ... )
     """
 
@@ -101,6 +109,7 @@ class PineconeChunkSource:
         embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
         embed_model: str = "multilingual-e5-large",
         field_mapping: dict[str, str] | None = None,
+        content_field: str | None = None,
     ) -> None:
         self._client = PineconeIndexClient(
             api_key=api_key,
@@ -110,6 +119,7 @@ class PineconeChunkSource:
             embed_fn=embed_fn,
             embed_model=embed_model,
             field_mapping=field_mapping,
+            content_field=content_field,
         )
         self._files = FileAwareness(self._client)
 
@@ -237,40 +247,56 @@ class PineconeChunkSource:
     # ------------------------------------------------------------------
 
     def get_chunk_count(self) -> int:
-        """Return the total number of vectors in the index."""
-        index = self._client._get_index()
-        stats = index.describe_index_stats()
-        return int(stats.total_vector_count or 0)
+        """Return the number of vectors in the configured namespace.
+
+        Scoped to the namespace this source reads from — an index-wide
+        total would disagree with what sampling/search can actually see.
+        """
+        return self._client.namespace_vector_count()
 
     def sample_chunks(self, n: int, min_chars: int = 0) -> list[Chunk]:
         """Return n randomly sampled chunks, optionally filtered by
         minimum length.
 
-        Uses a random vector query to get pseudo-random results
-        efficiently in a single API call.
+        Samples uniformly from the paginated ID listing and hydrates the
+        sample via fetch — no query vector involved, so the draw is
+        genuinely uniform (not nearest-to-a-random-point) and works for
+        dense and sparse indexes alike.
         """
-        # Generate a random vector for pseudo-random sampling
-        dim = len(self._client.zero_vector())
-        rand_vec = [random.gauss(0, 1) for _ in range(dim)]
-
-        # Fetch more than needed to allow for min_chars filtering
-        fetch_k = min(n * 3, 10000) if min_chars > 0 else min(n, 10000)
-        result = self._client.query(
-            vector=rand_vec,
-            top_k=fetch_k,
-            include_metadata=True,
-        )
-
-        matches = result.matches or []
-        if not matches:
+        # Oversample when a length filter will discard part of the draw
+        fetch_n = min(n * 3, 10000) if min_chars > 0 else min(n, 10000)
+        ids = self._client.sample_ids(fetch_n)
+        if not ids:
             return []
 
-        chunks = [_raw_to_chunk(self._client.match_to_raw(m)) for m in matches]
+        raws: list[dict[str, Any]] = []
+        for batch_start in range(0, len(ids), _FETCH_BATCH_SIZE):
+            raws.extend(
+                self._client.fetch_by_ids_raw(
+                    ids[batch_start : batch_start + _FETCH_BATCH_SIZE]
+                )
+            )
+        chunks = [_raw_to_chunk(r) for r in raws]
+
+        # Every fetched record decoding to empty content means the text key
+        # is wrong (BYO index whose schema doesn't use the configured field),
+        # not that the corpus is empty. Without this, the pipeline dies later
+        # with an unactionable "No eligible chunks were found".
+        if chunks and all(not c.content for c in chunks):
+            content_key = self._client._pc_field("content")
+            seen_keys = sorted(
+                {k for r in raws for k in r.get("metadata", {}) if not k.startswith("_")}
+            )
+            raise ValueError(
+                f"No text found under metadata field '{content_key}' in any "
+                f"sampled record. This index's metadata fields are: "
+                f"{seen_keys}. Set content_field to the one holding the "
+                f"chunk text."
+            )
 
         if min_chars > 0:
             chunks = [c for c in chunks if len(c.content) >= min_chars]
 
-        # Shuffle to avoid bias from similarity ordering
         random.shuffle(chunks)
         return chunks[:n]
 

benchmax/rag/corpus/search_schema/search_exceptions.py

@@ -43,3 +43,21 @@ class UnsupportedSearchModeError(ValueError):
             f"[{backend}] unsupported search mode '{mode}'. "
             f"Supported modes: {sorted(supported_modes)}"
         )
+
+
+class LocalEmbeddingDownloadDisallowedError(RuntimeError):
+    """Raised when serving a search would download a client-side embedding model.
+
+    The collection has no server-side (hosted) embedding function and no BM25
+    index, and the caller supplied no ``embed_fn`` — so embedding a text query
+    would make chromadb download and run a local model (e.g. all-MiniLM). We
+    refuse rather than trigger that download.
+    """
+
+    def __init__(self, backend: str, collection: str):
+        super().__init__(
+            f"[{backend}] collection {collection!r} has no server-side embedding "
+            "function and no BM25 index, so search would download a local "
+            "embedding model. Re-ingest the corpus with a hosted embedder "
+            "(chroma-cloud-qwen) or a BM25 index, or supply an embed_fn."
+        )

benchmax/rag/corpus/turbopuffer/namespace.py

@@ -19,6 +19,27 @@ from benchmax.rag.corpus.search_schema.search_types import (
 )
 
 
+def resolve_content_attr(
+    content_attr: list[str] | None, content_field: str | None
+) -> list[str] | None:
+    """Resolve the ``content_field`` sugar against an explicit ``content_attr``.
+
+    ``content_field`` is the canonical single-column param; ``content_attr``
+    is the low-level multi-field escape hatch.  Specifying the text column
+    both ways with different values raises instead of silently picking a
+    winner.
+    """
+    if not content_field:
+        return content_attr
+    if content_attr is not None and content_attr != [content_field]:
+        raise ValueError(
+            f"content_field={content_field!r} conflicts with "
+            f"content_attr={content_attr!r}. Specify the text column one way "
+            "or the other."
+        )
+    return [content_field]
+
+
 class TpufNamespace:
     """Thin wrapper around a Turbopuffer namespace.
 

benchmax/rag/corpus/turbopuffer/search.py

@@ -30,7 +30,12 @@ class TpufSearch:
     Args:
         namespace: Turbopuffer namespace name.
         region: Turbopuffer region (default ``"aws-us-east-1"``).
-        content_attr: List of BM25-indexed content fields.
+        content_attr: Low-level escape hatch — list of BM25-indexed content
+            fields for multi-field schemas. Prefer ``content_field``.
+        content_field: Turbopuffer attribute holding the chunk text — the
+            canonical single-column param. Must be BM25-indexed for lexical
+            search. Raises if ``content_attr`` is also supplied with a
+            different value.
         embed_fn: Custom embedding function. Required for vector/hybrid.
         vector_attr: Vector attribute name (default ``"vector"``).
         distance_metric: Distance metric (default ``"cosine_distance"``).
@@ -48,11 +53,14 @@ class TpufSearch:
         embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
         vector_attr: str = "vector",
         distance_metric: str = "cosine_distance",
+        content_field: str | None = None,
         token_provider: str | TokenProvider | None = None,
     ) -> None:
+        from .namespace import resolve_content_attr
+
         self._namespace = namespace
         self._region = region
-        self._content_attr = content_attr
+        self._content_attr = resolve_content_attr(content_attr, content_field)
         self._embed_fn = embed_fn
         self._vector_attr = vector_attr
         self._distance_metric = distance_metric
@@ -92,7 +100,6 @@ class TpufSearch:
         top_k: int = 10,
     ) -> list[dict[str, Any]]:
         """Search and return structured results."""
-        ns = self._get_client()
         modes = self.available_modes
         content_fields = self._content_attr or ["content"]
 
@@ -111,6 +118,11 @@ class TpufSearch:
                 f"{'Provide embed_fn for vector/hybrid.' if mode in ('vector', 'hybrid') else ''}"
             )
 
+        # Validate the request before constructing the client — an invalid
+        # mode should fail as such, not as a missing-credential error from
+        # the token provider.
+        ns = self._get_client()
+
         if mode == "lexical":
             rank_by = [content_fields[0], "BM25", query]
             result = ns.query(rank_by=rank_by, top_k=top_k, include_attributes=True)

benchmax/rag/corpus/turbopuffer/source.py

@@ -23,7 +23,7 @@ from benchmax.rag.corpus.search_schema.search_types import (
 
 from .files import FileAwareness
 from .filter_mapper import to_turbopuffer_filters
-from .namespace import TpufNamespace
+from .namespace import TpufNamespace, resolve_content_attr
 
 _DEFAULT_RELATED_SEARCH_MODE: SearchMode = "lexical"
 _HYBRID_FUSION_RRF_K = 60.0
@@ -50,10 +50,15 @@ class TpufChunkSource:
         api_key: Turbopuffer API key
         namespace: Turbopuffer namespace name
         region: Turbopuffer region (default "aws-us-east-1")
-        content_attr: List of Turbopuffer attribute names to use as the chunk's
-            searchable text content. Defaults to ["content"]. For pre-existing
-            namespaces, supply the BM25-indexed field(s), e.g. ["description"]
-            or ["title", "content"].
+        content_attr: Low-level escape hatch — list of Turbopuffer attribute
+            names to use as the chunk's searchable text content (multi-field
+            schemas, e.g. ["title", "content"]). For the common single-column
+            case, prefer ``content_field``. Defaults to ["content"].
+        content_field: Turbopuffer attribute holding the chunk text — the
+            canonical way to point at your text column for pre-existing
+            namespaces that don't use ``content``. Must be BM25-indexed for
+            lexical search. Raises if ``content_attr`` is also supplied with
+            a different value.
         vector_attr: Name of the vector attribute in the namespace. Defaults to
             "vector". Set this if your namespace stores embeddings under a
             different attribute name.
@@ -64,11 +69,11 @@ class TpufChunkSource:
         >>> source.populate_from_folder("./docs", embed_fn=my_embed_fn)
         >>> chunks = source.sample_chunks(n=10, min_chars=400)
 
-        >>> # Pre-existing namespace with known BM25-indexed fields
+        >>> # Pre-existing namespace whose text lives under another key
         >>> source = TpufChunkSource(
         ...     api_key="tpuf_...",
         ...     namespace="product-catalog",
-        ...     content_attr=["description"],
+        ...     content_field="description",
         ... )
     """
 
@@ -81,12 +86,13 @@ class TpufChunkSource:
         embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
         vector_attr: str = "vector",
         distance_metric: str = "cosine_distance",
+        content_field: str | None = None,
     ) -> None:
         self._client = TpufNamespace(
             api_key=api_key,
             namespace=namespace,
             region=region,
-            content_attr=content_attr,
+            content_attr=resolve_content_attr(content_attr, content_field),
             embed_fn=embed_fn,
             vector_attr=vector_attr,
             distance_metric=distance_metric,

{benchmax-0.1.2.dev30.dist-info → benchmax-0.1.2.dev33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: benchmax
-Version: 0.1.2.dev30
+Version: 0.1.2.dev33
 Summary: Framework-Agnostic RL Environments for LLM Fine-Tuning
 Author: castie@castform.com
 Classifier: Programming Language :: Python :: 3

{benchmax-0.1.2.dev30.dist-info → benchmax-0.1.2.dev33.dist-info}/RECORD

@@ -1,11 +1,11 @@
-benchmax/bundle.py,sha256=Fr0gEWPRMPKVaHwHuxCN_UWWNxLxVPUqE1idKd3fgVE,9999
+benchmax/bundle.py,sha256=HJ0ZCojI6DRSGqgF6uMNazDsQJM6o5rqsfoTKV0kZAU,13879
 benchmax/cli.py,sha256=N9gC_ilTutbF7nNplWo7-e-hw674PbBsw_iuCtt0xyA,2366
 benchmax/config.py,sha256=qTtr8-VO0XjjxKfXh0jE58bmpuw0UnirYI_8aH2gb3g,2112
 benchmax/envs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/envs/base_env.py,sha256=FoUgWsNGeNpTHeOop0bklRjLfHA90Yi7MW8zCaNh_V0,8976
 benchmax/envs/example_id.py,sha256=WU967Pt2kFvn-W4k5BC6BvKyrTEqioLr7IyWZ3RjGgU,5685
 benchmax/envs/logging.py,sha256=QnXADCp0vWoV_-MK91yX5OFu6GwgIE98dvhaQTPawqQ,5053
-benchmax/envs/reward_helpers.py,sha256=lKbyTvJYU2JoiFItFkUPX6aWwp6JmmgXC76FBaf2rBQ,7740
+benchmax/envs/reward_helpers.py,sha256=-pDqYBazvum8cc8KX7Q_Z0C-Daf3_4TVZuWt-ywhqyY,7364
 benchmax/envs/types.py,sha256=sGKKibQJZQj9RYkFpB3vaUY75tdoHet8yUmdzpZ0SVk,4389
 benchmax/envs/crm/crm_env.py,sha256=ltUtpA45YB_A_hYEpjFTp0nZKwkUvvLSLOAVkaUNz9E,4707
 benchmax/envs/crm/workdir/reward_fn.py,sha256=RY_iy347j79xX4gyCGI7WS0qPmut8Th2rqOiErVbDro,5439
@@ -32,8 +32,8 @@ benchmax/envs/mcp/provisioners/skypilot_provisioner.py,sha256=ACHnzNZE7GfL1WIWf7
 benchmax/envs/mcp/provisioners/utils.py,sha256=ORWJKtPzeS-IdD35p8aZyLMG2RxiB9BAFmU-0pVqiWw,3467
 benchmax/envs/postgres_search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/envs/postgres_search/linker_env.py,sha256=B3cn0TpiqgrYL5NvOQYW3Yxy5DdxPw1kmIgqDs-8Buo,8535
-benchmax/envs/postgres_search/search_env.py,sha256=ldfSNCQonbQZimO7rCO1Jc6im7ff2d0-TLvwryXUOXQ,20181
-benchmax/envs/telestich/example.py,sha256=zojsKPQEVoYx0ElKcpU4vnQuW02zfbIgsCx0rnDWVvg,28092
+benchmax/envs/postgres_search/search_env.py,sha256=IWpqbFr4hjaN_DzdeRchvwvf9qVj5Ut5D-eOsGPyWKQ,19917
+benchmax/envs/telestich/example.py,sha256=cqHIBjD8g7H4-nmspWSKRB2rxeKPOIwkLn136Y04KfQ,28680
 benchmax/envs/telestich/telestich_env.py,sha256=6p6GeyV-9ZIXrAX8zssMFjJgevkV5PfDLMZlslqO8js,61966
 benchmax/envs/wikipedia/utils.py,sha256=YDlxpMfwiVpfMpiZet4kWoeKqNbgTBxeWVEYg5QY3Qs,2879
 benchmax/envs/wikipedia/wiki_env.py,sha256=FigVZ0P0WVJG66CUZHOXq8tbSHWz8gNFr9cdeDePqfI,9288
@@ -45,13 +45,13 @@ benchmax/multi_model/inspector.py,sha256=j730w35YpZ4tGpzoVHza763GkUjyRxmqzRTwXqI
 benchmax/multi_model/models.py,sha256=bYLBJ0uybsB_tg2jkWHQGhyqakb21bHgstnZZCcAq58,3218
 benchmax/multi_model/pricing.py,sha256=x6Gz9dET7hBvQJb2SvQ8IVPvH-xenmoHrqp3Wpa4dI8,2122
 benchmax/platform/__init__.py,sha256=GI4U-qPyU-lPCQDxA1mw6Lnqj58gP5PptxSts_h7uPo,926
-benchmax/platform/client.py,sha256=6U9ojbSIHPFvn2Qg1roKMonwoQVt3WTJcLUWiY6KvDg,54687
+benchmax/platform/client.py,sha256=mA0bQiIPrkimaBkW4Zv1byPJyEPnc_O7-E2dossWy4k,54919
 benchmax/platform/credentials.py,sha256=ABn44ChybWT9UQNd9_sc4yvfTdkw93521u9ZRI3H4Kk,15151
 benchmax/platform/device_auth.py,sha256=OCWCzTdQLNeB57cBFNpqDea2YV846r_ukDDIWRDDER4,2670
 benchmax/platform/exceptions.py,sha256=rkGrsSL2efqr3k15LOVv4k8mVfTXxjIDbWnKBKKz7Hk,1018
 benchmax/platform/login.py,sha256=aQJ9_QJir4pq_pWl85_LoyMKtOAs3ZVjE7TtulwEQbg,3471
 benchmax/platform/training_run.py,sha256=lzcUaigASRheASLN48BueCDu2fyESrWZdUejd0ZueIs,7000
-benchmax/platform/validation.py,sha256=JF2XRaNLkeVrEWvFpw8TuhG6xZJX9a0cuhtbc9E8s4g,34799
+benchmax/platform/validation.py,sha256=ZmQkhEyeBuAKT_ViCycQnyfaA2fAgmzQFxjIDzVRK3U,36736
 benchmax/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/prompts/tools.py,sha256=dhUkLfqNuFhwsZ3etNc_xiOIn_7CC8HhZatr657Rmq4,2978
 benchmax/rag/chunkers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -64,17 +64,17 @@ benchmax/rag/corpus/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKV
 benchmax/rag/corpus/search_client.py,sha256=171IqQriU6kuQqvSCDgNwOT8SR5pxUPMfCifarrgrFg,1859
 benchmax/rag/corpus/source.py,sha256=dnmReLC8mccHDkg8ZytfXa4AFXrRMCg9v8E2UuVxt8E,4183
 benchmax/rag/corpus/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-benchmax/rag/corpus/chroma/client.py,sha256=TGf_YEgVBH8p-PLF7QcuSIHkkifrChXPKJB2ENR9OiM,19361
+benchmax/rag/corpus/chroma/client.py,sha256=cYZZKQG09u_VfyjsP6UdCBh-RRNGKa9XisBN4OEejQk,20839
 benchmax/rag/corpus/chroma/files.py,sha256=hSP-J2osPNBAvMZHOWipMVXaWN4tila_tsQaTEPNzgc,5567
 benchmax/rag/corpus/chroma/filter_mapper.py,sha256=Y1FzDwDDg15LZ0-Uh1jzOVcSORiVUy5f1qiaVky3pJI,5074
-benchmax/rag/corpus/chroma/search.py,sha256=4kU1WMwsWQrN03ctVIPdXZoHyZa3jso2fKzcsc5uYr0,6824
-benchmax/rag/corpus/chroma/source.py,sha256=ZOLj_VfixBcB_VE8YLF6X3sKY6XHYupprHNHVxy1hH8,30295
+benchmax/rag/corpus/chroma/search.py,sha256=iO8fBPk50vG3NmkCmAJ2tKnjP_wKnymV3fbfLjkIAJ8,7688
+benchmax/rag/corpus/chroma/source.py,sha256=0azMLUvZS9g4jvxv_KxsPa3-ArQW5WHCq77CQh-qmqY,30440
 benchmax/rag/corpus/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/corpus/pinecone/files.py,sha256=lhas7-mQ622Ku36QvOavXguBweJyYl78wXIeb_LNqig,5728
 benchmax/rag/corpus/pinecone/filter_mapper.py,sha256=exJ3G34QKeQo1rQ8Pu-iGL0XDXVxCW5dc3q0QoYfCo0,6454
-benchmax/rag/corpus/pinecone/index_client.py,sha256=3mI_gUu3s_h8PGIf08Ln6DnJgbq45v8hOKot4HAcJqE,14454
-benchmax/rag/corpus/pinecone/search.py,sha256=AySKV_2LQxMOe0_qvgeDjLnkEC5GU0aEz68VlK80EdA,4634
-benchmax/rag/corpus/pinecone/source.py,sha256=s8qyVkMP9j23qNK2YIOWsn_-PTT6sst6Fern4WzjDdg,19838
+benchmax/rag/corpus/pinecone/index_client.py,sha256=eZ6LzBg82X9HCvs9HUrgLRuuHPVtM_hoICYYvznC2dg,18045
+benchmax/rag/corpus/pinecone/search.py,sha256=XoDKouj5Y-THW0cG00zUIgcpbJxRKv1y5mM5z2a-ZdA,4928
+benchmax/rag/corpus/pinecone/source.py,sha256=aJey4d5Pz_FB-G9MXusODAnszun57HAztFVzu8RWC_8,21305
 benchmax/rag/corpus/postgres/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/corpus/postgres/client.py,sha256=JbRUelHpXlZhDlXdEUWooF7UpqrHmf0uAjWoweJ-Dio,19821
 benchmax/rag/corpus/postgres/exceptions.py,sha256=tykCt_4H9ewe5Qh_qzIg_PoSmuJpY-aox1QCku9PVmI,1572
@@ -85,14 +85,14 @@ benchmax/rag/corpus/postgres/source.py,sha256=6ptGHatOscYih42MZ9Wt8MQOrcIEQiJ1X5
 benchmax/rag/corpus/search_schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/corpus/search_schema/builders.py,sha256=qAMiEOGOLR7xSXWFf12KqzYlrwBZchU_78vkRcOKa8k,1764
 benchmax/rag/corpus/search_schema/dsl_parser.py,sha256=vMijm_nRKztIrsVQP-0OySuCKnrBsbUzet_pwwlU1T8,1586
-benchmax/rag/corpus/search_schema/search_exceptions.py,sha256=vxhJQa7UFHduXDt225onA_R_UWcvGlj3NiS5TFR3M7w,1578
+benchmax/rag/corpus/search_schema/search_exceptions.py,sha256=1ccbLnDAuSMxUnjtyBt-5iXwoKjI3xaZvk9xplCyNFw,2413
 benchmax/rag/corpus/search_schema/search_types.py,sha256=UTkteugSx5OigDRZ8Xqe6itxLUXj2sVeIVxtYbnXGSg,5831
 benchmax/rag/corpus/turbopuffer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/corpus/turbopuffer/files.py,sha256=DP80-3NmdyOD34fyQxlzovpLRs_UU1ezQ7PItpY2Nlk,5807
 benchmax/rag/corpus/turbopuffer/filter_mapper.py,sha256=r9YRn1A3XfoFUaD6KDRtUr-ufvMhGBA6VoR-YTuCvcY,4676
-benchmax/rag/corpus/turbopuffer/namespace.py,sha256=H60aaVd9sCToC1puXq0K_3Q0Fl2l5JqKtDdfKPke3mo,11507
-benchmax/rag/corpus/turbopuffer/search.py,sha256=WpoWtNNA8Y4rTc5n4yqAjeBYU0d3SpbxKHh1Awau03Y,7637
-benchmax/rag/corpus/turbopuffer/source.py,sha256=KN0T4-IJX5ES3GyvMCea2Mie-qy_5-qk3Fcz06GSOgU,28113
+benchmax/rag/corpus/turbopuffer/namespace.py,sha256=LP0Gpwv91ZzgRhHaUBI0ITvutmS-er0W4o07QNyqSU8,12303
+benchmax/rag/corpus/turbopuffer/search.py,sha256=MF0E3kWzAQf5C2fjWV3TyyFWpy_-3DwOBM0XBIkgZqM,8293
+benchmax/rag/corpus/turbopuffer/source.py,sha256=f0G3RzJkdCxM0TSoyI_eB_JH-wFhHiPgl8SmINj3XbQ,28577
 benchmax/rag/preprocess/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/preprocess/email/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmax/rag/preprocess/email/clean_bodies.py,sha256=OQ1fwsB3Dfy9iyzjX5ZpaHweB33Cs6hfwsULm8xeBZk,18097
@@ -160,9 +160,9 @@ benchmax/traces/braintrust/adapter.py,sha256=KTeN9qKLwZJJ8TY-KtSudd4J3_nySz1bRts
 benchmax/traces/braintrust/message_extraction.py,sha256=seh3eM_qd9FUPmGOEMChUq_UAMtaIQHYSYDttMgY1go,8409
 benchmax/utils/__init__.py,sha256=FWJVm6jt0m57HS-84bgrb2M-c_EFhf60rWayioUGges,402
 benchmax/utils/checkpoint.py,sha256=htIw9iYjUUHpJqLLZ0y6K4_UYYAkZIx3vdQVY7juKDw,3148
-benchmax-0.1.2.dev30.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-benchmax-0.1.2.dev30.dist-info/METADATA,sha256=jGUiou-RTND1ZTmey7cVJT9uRQR_TCTjHaGAVXYjNHc,2775
-benchmax-0.1.2.dev30.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-benchmax-0.1.2.dev30.dist-info/entry_points.txt,sha256=qtjqAQsHIwRIaLzwAhGTiRvI91CynwcUO5G95uQuDR4,47
-benchmax-0.1.2.dev30.dist-info/top_level.txt,sha256=ryj4zoahvAKL3BnxOpfJNfyIzhvlED9KJ3Q3k4bb9jc,9
-benchmax-0.1.2.dev30.dist-info/RECORD,,
+benchmax-0.1.2.dev33.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+benchmax-0.1.2.dev33.dist-info/METADATA,sha256=X5P1IBK9INVKaO8xzBqoW8CQYQ2VIVD9IkaQV4tVjFQ,2775
+benchmax-0.1.2.dev33.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+benchmax-0.1.2.dev33.dist-info/entry_points.txt,sha256=qtjqAQsHIwRIaLzwAhGTiRvI91CynwcUO5G95uQuDR4,47
+benchmax-0.1.2.dev33.dist-info/top_level.txt,sha256=ryj4zoahvAKL3BnxOpfJNfyIzhvlED9KJ3Q3k4bb9jc,9
+benchmax-0.1.2.dev33.dist-info/RECORD,,