Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

fix(reindex): bound failed batch recovery (#2251)

Raghav Chamadiyafbfe6dec2a1c
diff --git a/packages/cli/src/repowise/cli/commands/reindex_cmd.py b/packages/cli/src/repowise/cli/commands/reindex_cmd.py
index 30d26c652..ff964b132 100644
--- a/packages/cli/src/repowise/cli/commands/reindex_cmd.py
+++ b/packages/cli/src/repowise/cli/commands/reindex_cmd.py
@@ -14,6 +14,9 @@ from repowise.cli.helpers import (
)
from repowise.cli.ui import BRAND_STYLE, OWL_SPINNER
+_PROVIDER_FAILURE_CIRCUIT_SLICES = 2
+_INPUT_TOO_LONG_RETRIES = 4
+
@click.command("reindex")
@click.argument("path", required=False, default=None)
@@ -23,7 +26,12 @@ from repowise.cli.ui import BRAND_STYLE, OWL_SPINNER
default="auto",
help="Embedder to use. 'auto' detects from env vars / config.",
)
[email protected]("--batch-size", type=int, default=32, help="Pages per embedding batch.")
+ "--batch-size",
+ type=click.IntRange(min=1),
+ default=32,
+ help="Pages per embedding batch.",
+)
def reindex_command(path: str | None, embedder: str, batch_size: int) -> None:
"""Rebuild vector search index from existing wiki pages.
@@ -131,6 +139,8 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
indexed = 0
failed = 0
below_floor = 0
+ consecutive_provider_failures = 0
+ provider_circuit_error: Exception | None = None
with Progress(
SpinnerColumn(spinner_name=OWL_SPINNER, style=BRAND_STYLE),
@@ -144,24 +154,36 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
warned = 0
- async def _embed_slice(items: list[tuple[str, str, dict]]) -> None:
- """Embed one slice batched; on failure retry per item.
+ async def _embed_slice(items: list[tuple[str, str, dict]]) -> Exception | None:
+ """Embed one slice with bounded recovery for input-specific failures.
The batched call is the fast path (one embedder request per
- chunk). A raised error falls back to per-item embedding so one
- poison item can't sink its neighbours, and the indexed/failed
- counters stay per-item accurate.
+ chunk). The store reports exactly which internal chunks failed and
+ whether embedding or persistence raised. Only an input-shaped HTTP
+ error is isolated per item: retrying timeouts, rate limits, server
+ errors, or failed writes one page at a time multiplies an outage
+ into hours of duplicate work.
"""
nonlocal indexed, failed, warned
try:
await vector_store.embed_batch(items)
indexed += len(items)
- return
- except Exception:
- pass
- for page_id, text, meta in items:
+ return None
+ except Exception as exc:
+ successful, retry_items, terminal = _batch_recovery_plan(exc, items)
+ indexed += successful
+
+ for (page_id, _text, _meta), stage, exc in terminal:
+ failed += 1
+ warned += 1
+ if warned <= 3:
+ console.print(
+ f"[yellow] Warning: failed to embed {page_id} during {stage}: {exc}[/yellow]"
+ )
+
+ for page_id, text, meta in retry_items:
try:
- await vector_store.embed_and_upsert(page_id, text, meta)
+ await _embed_one_with_input_recovery(vector_store, (page_id, text, meta))
indexed += 1
except Exception as exc:
failed += 1
@@ -170,6 +192,7 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
console.print(
f"[yellow] Warning: failed to embed {page_id}: {exc}[/yellow]"
)
+ return next((exc for _item, stage, exc in terminal if stage == "embedding"), None)
# Pages — one batched embed per slice instead of one embedder
# round-trip per page (a large wiki paid thousands of serial calls).
@@ -206,8 +229,15 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
below_floor += 1
continue
items.append(item)
- await _embed_slice(items)
+ provider_failure = await _embed_slice(items)
progress.advance(task, advance=len(batch))
+ if provider_failure is None:
+ consecutive_provider_failures = 0
+ else:
+ consecutive_provider_failures += 1
+ if consecutive_provider_failures >= _PROVIDER_FAILURE_CIRCUIT_SLICES:
+ provider_circuit_error = provider_failure
+ break
# Decision records — embedded into the shared page store under the
# decision: namespace, batched like the pages. Uses embed_batch
@@ -217,9 +247,9 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
# that had just finished the pages, so a repo with no decisions ended
# its reindex reading "Indexing decisions... 186/186" — 186 pages
# reported as decisions that were never indexed.
- if decisions:
+ if decisions and provider_circuit_error is None:
progress.update(task, description="Indexing decisions...")
- for i in range(0, len(decisions), batch_size):
+ for i in range(0, len(decisions) if provider_circuit_error is None else 0, batch_size):
batch = decisions[i : i + batch_size]
items = [
item
@@ -234,12 +264,25 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
)
is not None
]
- await _embed_slice(items)
+ provider_failure = await _embed_slice(items)
progress.advance(task, advance=len(batch))
+ if provider_failure is None:
+ consecutive_provider_failures = 0
+ else:
+ consecutive_provider_failures += 1
+ if consecutive_provider_failures >= _PROVIDER_FAILURE_CIRCUIT_SLICES:
+ provider_circuit_error = provider_failure
+ break
await vector_store.close()
await engine.dispose()
+ if provider_circuit_error is not None:
+ raise click.ClickException(
+ "Embedding provider failed in two consecutive batches; stopped the reindex "
+ f"before the outage multiplied across the corpus. Last error: {provider_circuit_error}"
+ )
+
# Record the embedder we actually built the table with. Without this, a
# repo indexed keyless keeps `embedder: mock` in config.yaml, and the next
# `repowise update` builds a mock store, writes 8-wide vectors into the
@@ -272,3 +315,89 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:
# failure is visible in the exit status, not just in the printed count.
if indexed == 0 and failed > 0:
raise click.Abort()
+
+
+def _batch_recovery_plan(
+ exc: Exception,
+ items: list[tuple[str, str, dict]],
+) -> tuple[
+ int,
+ list[tuple[str, str, dict]],
+ list[tuple[tuple[str, str, dict], str, Exception]],
+]:
+ """Return successful, individually retryable, and terminal batch items."""
+
+ from repowise.core.persistence.vector_store import BatchEmbeddingError
+
+ if isinstance(exc, BatchEmbeddingError):
+ retry_items: list[tuple[str, str, dict]] = []
+ terminal: list[tuple[tuple[str, str, dict], str, Exception]] = []
+ for failure in exc.failures:
+ if failure.stage == "embedding" and _is_input_specific_error(failure.cause):
+ retry_items.extend(failure.items)
+ else:
+ terminal.extend((item, failure.stage, failure.cause) for item in failure.items)
+ return exc.successful_count, retry_items, terminal
+
+ if _is_input_specific_error(exc):
+ return 0, items, []
+ return 0, [], [(item, "embedding", exc) for item in items]
+
+
+def _is_input_specific_error(exc: Exception) -> bool:
+ """Whether splitting a failed provider request can plausibly isolate one input."""
+
+ seen: set[int] = set()
+ current: BaseException | None = exc
+ while current is not None and id(current) not in seen:
+ seen.add(id(current))
+ if getattr(current, "status_code", None) in {400, 413, 422}:
+ return True
+ current = current.__cause__ or current.__context__
+ return False
+
+
+async def _embed_one_with_input_recovery(
+ vector_store: object,
+ item: tuple[str, str, dict],
+) -> None:
+ """Retry one confirmed oversized input with bounded adaptive truncation."""
+
+ from repowise.core.persistence.vector_store import cap_embed_text
+
+ page_id, text, metadata = item
+ candidate = cap_embed_text(page_id, text)
+ for attempt in range(_INPUT_TOO_LONG_RETRIES + 1):
+ try:
+ await vector_store.embed_and_upsert(page_id, candidate, metadata) # type: ignore[attr-defined]
+ return
+ except Exception as exc:
+ if (
+ attempt >= _INPUT_TOO_LONG_RETRIES
+ or len(candidate) <= 1
+ or not _is_input_too_long_error(exc)
+ ):
+ raise
+ candidate = candidate[: max(1, len(candidate) // 2)]
+
+
+def _is_input_too_long_error(exc: Exception) -> bool:
+ """Whether a provider explicitly rejected one input for token length."""
+
+ markers = (
+ "maximum input length",
+ "maximum context length",
+ "input is too long",
+ "too many tokens",
+ "token limit",
+ )
+ seen: set[int] = set()
+ current: BaseException | None = exc
+ while current is not None and id(current) not in seen:
+ seen.add(id(current))
+ status = getattr(current, "status_code", None)
+ message = str(current).lower()
+ if status in {400, 413, 422} and any(marker in message for marker in markers):
+ return True
+ current = current.__cause__ or current.__context__
+ return False
diff --git a/packages/core/src/repowise/core/persistence/vector_store/__init__.py b/packages/core/src/repowise/core/persistence/vector_store/__init__.py
index 9c7ec11a0..f83f059d6 100644
--- a/packages/core/src/repowise/core/persistence/vector_store/__init__.py
+++ b/packages/core/src/repowise/core/persistence/vector_store/__init__.py
@@ -26,16 +26,26 @@ to avoid one embedding round-trip per page; the single-item
from __future__ import annotations
-from ._base import VectorStore, cosine_similarity, embed_item
+from ._base import (
+ BatchChunkFailure,
+ BatchEmbeddingError,
+ VectorStore,
+ cap_embed_text,
+ cosine_similarity,
+ embed_item,
+)
from .in_memory import InMemoryVectorStore
from .lancedb_store import LanceDBVectorStore
from .pgvector_store import PgVectorStore
__all__ = [
+ "BatchChunkFailure",
+ "BatchEmbeddingError",
"InMemoryVectorStore",
"LanceDBVectorStore",
"PgVectorStore",
"VectorStore",
+ "cap_embed_text",
"cosine_similarity",
"embed_item",
]
diff --git a/packages/core/src/repowise/core/persistence/vector_store/_base.py b/packages/core/src/repowise/core/persistence/vector_store/_base.py
index 301177d80..acc6b31fb 100644
--- a/packages/core/src/repowise/core/persistence/vector_store/_base.py
+++ b/packages/core/src/repowise/core/persistence/vector_store/_base.py
@@ -12,6 +12,8 @@ import logging
import math
from abc import ABC, abstractmethod
from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import Literal
from ..information_floor import count_page_denied_a_vector, meets_information_floor
from ..search import SearchResult
@@ -20,12 +22,49 @@ __all__ = [
"EMBED_BATCH_MAX_ITEMS",
"EMBED_TEXT_MAX_CHARS",
"STORED_SNIPPET_CHARS",
+ "BatchChunkFailure",
+ "BatchEmbeddingError",
"VectorStore",
+ "cap_embed_text",
"cosine_similarity",
"embed_item",
"iter_embed_chunks",
]
+EmbeddingItem = tuple[str, str, dict]
+
+
+@dataclass(frozen=True)
+class BatchChunkFailure:
+ """One request-sized chunk that a batch vector write could not persist."""
+
+ items: tuple[EmbeddingItem, ...]
+ stage: Literal["embedding", "persistence"]
+ cause: Exception
+
+
+class BatchEmbeddingError(RuntimeError):
+ """Partial batch failure with enough detail for bounded caller recovery.
+
+ Stores used to raise only an aggregate count. A caller could not tell which
+ chunks had already committed, so reindex retried the entire outer slice one
+ item at a time. Under a provider timeout that multiplied one failed request
+ into minutes of duplicate work.
+ """
+
+ def __init__(self, *, failures: list[BatchChunkFailure], total_items: int) -> None:
+ self.failures = tuple(failures)
+ self.total_items = total_items
+ self.failed_items = tuple(item for failure in failures for item in failure.items)
+ self.successful_count = total_items - len(self.failed_items)
+ last = failures[-1]
+ detail = f"{type(last.cause).__name__}: {last.cause}"
+ super().__init__(
+ f"embed_batch: {len(self.failed_items)}/{total_items} items failed during "
+ f"{last.stage} ({detail})"
+ )
+
+
logger = logging.getLogger(__name__)
# One embedder call per chunk of this many items. OpenAI rejects embedding
@@ -37,9 +76,14 @@ logger = logging.getLogger(__name__)
# (a 16-page chunk measured at 0.6s against OpenAI).
EMBED_BATCH_MAX_ITEMS = 16
-# Per-input cap (~7.5k tokens): embedding models reject a single input past
-# ~8,192 tokens, and one oversized page must not sink its whole chunk.
-EMBED_TEXT_MAX_CHARS = 30_000
+# Per-input cap sized conservatively for code-heavy text. The old 30,000-char
+# cap assumed roughly four characters per token, but generated SCC pages in a
+# real repository exceeded OpenAI's 8,192-token input limit even after that
+# cut. Code and punctuation tokenize more densely than prose. Keep enough of
+# each page for useful semantic coverage while leaving substantial headroom
+# across providers and tokenizers; confirmed provider rejections can still be
+# recovered by a bounded, smaller retry in the reindex command.
+EMBED_TEXT_MAX_CHARS = 16_000
# How much of a page's content a vector row keeps for its evidence snippet.
#
@@ -52,6 +96,28 @@ EMBED_TEXT_MAX_CHARS = 30_000
STORED_SNIPPET_CHARS = 2_000
+def cap_embed_text(page_id: str, text: str) -> str:
+ """Return text bounded for one embedding input and report any loss.
+
+ Both batch and single-item writers use this helper. Previously only the
+ batch path applied the cap, so a page could succeed during generation but
+ fail during ``doctor --repair`` or reindex's per-item isolation depending
+ solely on which writer happened to touch it.
+ """
+ if len(text) <= EMBED_TEXT_MAX_CHARS:
+ return text
+ logger.error(
+ # ``page_id`` is empty for the raw ``embed_texts`` path, which embeds
+ # loose strings belonging to no page.
+ "embed_text_truncated page_id=%s chars=%d chars_dropped=%d cap=%d",
+ page_id,
+ len(text),
+ len(text) - EMBED_TEXT_MAX_CHARS,
+ EMBED_TEXT_MAX_CHARS,
+ )
+ return text[:EMBED_TEXT_MAX_CHARS]
+
+
def embed_item(
page_id: str,
*,
@@ -144,18 +210,7 @@ def iter_embed_chunks(
"""
for start in range(0, len(items), EMBED_BATCH_MAX_ITEMS):
chunk = items[start : start + EMBED_BATCH_MAX_ITEMS]
- for page_id, text, _meta in chunk:
- if len(text) > EMBED_TEXT_MAX_CHARS:
- logger.error(
- # ``page_id`` is empty for the raw ``embed_texts`` path,
- # which embeds loose strings belonging to no page.
- "embed_text_truncated page_id=%s chars=%d chars_dropped=%d cap=%d",
- page_id,
- len(text),
- len(text) - EMBED_TEXT_MAX_CHARS,
- EMBED_TEXT_MAX_CHARS,
- )
- yield chunk, [text[:EMBED_TEXT_MAX_CHARS] for _, text, _ in chunk]
+ yield chunk, [cap_embed_text(page_id, text) for page_id, text, _ in chunk]
def cosine_similarity(a: list[float], b: list[float]) -> float:
diff --git a/packages/core/src/repowise/core/persistence/vector_store/in_memory.py b/packages/core/src/repowise/core/persistence/vector_store/in_memory.py
index 559693417..bd95bc9ad 100644
--- a/packages/core/src/repowise/core/persistence/vector_store/in_memory.py
+++ b/packages/core/src/repowise/core/persistence/vector_store/in_memory.py
@@ -5,7 +5,7 @@ from __future__ import annotations
from repowise.core.providers.embedding.base import Embedder
from ..search import SearchResult
-from ._base import VectorStore, cosine_similarity, iter_embed_chunks
+from ._base import VectorStore, cap_embed_text, cosine_similarity, iter_embed_chunks
__all__ = ["InMemoryVectorStore"]
@@ -23,7 +23,7 @@ class InMemoryVectorStore(VectorStore):
self._store: dict[str, tuple[list[float], dict]] = {}
async def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:
- vectors = await self._embedder.embed([text])
+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])
self._store[page_id] = (vectors[0], dict(metadata))
async def embed_batch(self, items: list[tuple[str, str, dict]]) -> None:
diff --git a/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py b/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py
index 21d5ce742..cfaca4baa 100644
--- a/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py
+++ b/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py
@@ -5,7 +5,14 @@ from __future__ import annotations
from repowise.core.providers.embedding.base import Embedder
from ..search import _SNIPPET_LEN, SearchResult, snippet_around
-from ._base import STORED_SNIPPET_CHARS, VectorStore, iter_embed_chunks
+from ._base import (
+ STORED_SNIPPET_CHARS,
+ BatchChunkFailure,
+ BatchEmbeddingError,
+ VectorStore,
+ cap_embed_text,
+ iter_embed_chunks,
+)
__all__ = ["STORED_SNIPPET_CHARS", "LanceDBVectorStore"]
@@ -189,7 +196,7 @@ class LanceDBVectorStore(VectorStore):
async def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:
await self._ensure_connected()
- vectors = await self._embedder.embed([text])
+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])
vector = vectors[0]
await self._ensure_table(vector)
meta = {"content": text, **metadata}
@@ -207,24 +214,24 @@ class LanceDBVectorStore(VectorStore):
if not items:
return
await self._ensure_connected()
- failed = 0
- last_exc: Exception | None = None
+ failures: list[BatchChunkFailure] = []
for chunk, texts in iter_embed_chunks(items):
try:
vectors = await self._embedder.embed(texts)
+ except Exception as exc: # isolate per provider request
+ failures.append(BatchChunkFailure(tuple(chunk), "embedding", exc))
+ continue
+ try:
await self._ensure_table(vectors[0])
rows = [
self._row(page_id, vector, {"content": text, **metadata})
for (page_id, text, metadata), vector in zip(chunk, vectors, strict=True)
]
await self._upsert_rows(rows)
- except Exception as exc: # isolate per chunk
- failed += len(chunk)
- last_exc = exc
- if failed:
- raise RuntimeError(
- f"embed_batch: {failed}/{len(items)} items failed to embed"
- ) from last_exc
+ except Exception as exc: # preserve vectors' failure stage for callers
+ failures.append(BatchChunkFailure(tuple(chunk), "persistence", exc))
+ if failures:
+ raise BatchEmbeddingError(failures=failures, total_items=len(items))
async def _search_by_vector(
self, q_vec: list[float], limit: int, query: str | None = None
diff --git a/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py b/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py
index 07ccc56cb..19a1c015d 100644
--- a/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py
+++ b/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py
@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
from repowise.core.providers.embedding.base import Embedder
from ..search import SearchResult
-from ._base import VectorStore, iter_embed_chunks
+from ._base import VectorStore, cap_embed_text, iter_embed_chunks
if TYPE_CHECKING:
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
@@ -60,7 +60,7 @@ class PgVectorStore(VectorStore):
self._embedder = embedder
async def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:
- vectors = await self._embedder.embed([text])
+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])
vec_str = _encode(vectors[0])
from sqlalchemy.sql import text as sa_text
diff --git a/tests/unit/cli/test_reindex_cmd.py b/tests/unit/cli/test_reindex_cmd.py
index 0fd2b5aa8..fa4a0e41f 100644
--- a/tests/unit/cli/test_reindex_cmd.py
+++ b/tests/unit/cli/test_reindex_cmd.py
@@ -107,10 +107,15 @@ async def test_reindex_aborts_when_every_item_failed(
# Force the failure path: every item fails to embed. Patch the vector
# store's embed_batch to raise, and give the store a page to process.
class _FailingStore:
+ batch_calls = 0
+ single_calls = 0
+
async def embed_batch(self, items: list[Any]) -> None:
+ self.batch_calls += 1
raise RuntimeError("embedder down")
async def embed_and_upsert(self, *args: Any, **kwargs: Any) -> None:
+ self.single_calls += 1
raise RuntimeError("embedder down")
async def close(self) -> None:
@@ -153,13 +158,117 @@ async def test_reindex_aborts_when_every_item_failed(
return _FailingSession2
monkeypatch.setattr("sqlalchemy.ext.asyncio.async_sessionmaker", _failing_sessionmaker)
+ store = _FailingStore()
monkeypatch.setattr(
"repowise.core.persistence.vector_store.LanceDBVectorStore",
- lambda *a, **k: _FailingStore(),
+ lambda *a, **k: store,
)
- with pytest.raises(click.Abort):
+ with pytest.raises(click.ClickException, match="failed in two consecutive batches"):
await reindex_cmd._reindex(tmp_path, "openai", batch_size=20)
+ assert store.batch_calls == 2
+ assert store.single_calls == 0
+
+
+def test_batch_recovery_retries_only_failed_input_chunk() -> None:
+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError
+
+ class _BadRequest(Exception):
+ status_code = 400
+
+ items = [(f"p{i}", "text", {}) for i in range(32)]
+ cause = _BadRequest("one input is invalid")
+ exc = BatchEmbeddingError(
+ failures=[BatchChunkFailure(tuple(items[16:]), "embedding", cause)],
+ total_items=len(items),
+ )
+
+ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)
+
+ assert successful == 16
+ assert retry_items == items[16:]
+ assert terminal == []
+
+
[email protected]("status_code", [429, 500, 503])
+def test_batch_recovery_does_not_fan_out_provider_failure(status_code: int) -> None:
+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError
+
+ class _ProviderError(Exception):
+ pass
+
+ items = [(f"p{i}", "text", {}) for i in range(32)]
+ cause = _ProviderError("provider unavailable")
+ cause.status_code = status_code # type: ignore[attr-defined]
+ exc = BatchEmbeddingError(
+ failures=[BatchChunkFailure(tuple(items[:16]), "embedding", cause)],
+ total_items=len(items),
+ )
+
+ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)
+
+ assert successful == 16
+ assert retry_items == []
+ assert [item[0][0] for item in terminal] == [f"p{i}" for i in range(16)]
+
+
+def test_batch_recovery_never_reembeds_persistence_failure() -> None:
+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError
+
+ items = [(f"p{i}", "text", {}) for i in range(16)]
+ cause = RuntimeError("lancedb write failed")
+ exc = BatchEmbeddingError(
+ failures=[BatchChunkFailure(tuple(items), "persistence", cause)],
+ total_items=len(items),
+ )
+
+ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)
+
+ assert successful == 0
+ assert retry_items == []
+ assert len(terminal) == len(items)
+ assert {stage for _item, stage, _exc in terminal} == {"persistence"}
+
+
+async def test_single_recovery_adaptively_truncates_confirmed_oversized_input() -> None:
+ from repowise.core.persistence.vector_store._base import EMBED_TEXT_MAX_CHARS
+
+ class _TooLong(Exception):
+ status_code = 400
+
+ class _Store:
+ def __init__(self) -> None:
+ self.text_lengths: list[int] = []
+
+ async def embed_and_upsert(self, _page_id: str, text: str, _metadata: dict) -> None:
+ self.text_lengths.append(len(text))
+ if len(text) > EMBED_TEXT_MAX_CHARS // 2:
+ raise _TooLong("maximum input length is 8192 tokens")
+
+ store = _Store()
+ await reindex_cmd._embed_one_with_input_recovery(
+ store,
+ ("oversized", "x" * (EMBED_TEXT_MAX_CHARS * 3), {}),
+ )
+
+ assert store.text_lengths == [EMBED_TEXT_MAX_CHARS, EMBED_TEXT_MAX_CHARS // 2]
+
+
+async def test_single_recovery_does_not_retry_other_bad_requests() -> None:
+ class _BadRequest(Exception):
+ status_code = 400
+
+ class _Store:
+ calls = 0
+
+ async def embed_and_upsert(self, _page_id: str, _text: str, _metadata: dict) -> None:
+ self.calls += 1
+ raise _BadRequest("invalid dimensions")
+
+ store = _Store()
+ with pytest.raises(_BadRequest, match="invalid dimensions"):
+ await reindex_cmd._embed_one_with_input_recovery(store, ("bad", "text", {}))
+ assert store.calls == 1
async def test_reindex_auto_honours_the_repo_pinned_embedder(
diff --git a/tests/unit/persistence/test_vector_store.py b/tests/unit/persistence/test_vector_store.py
index c0e47f66d..2987dca67 100644
--- a/tests/unit/persistence/test_vector_store.py
+++ b/tests/unit/persistence/test_vector_store.py
@@ -461,19 +461,38 @@ async def test_in_memory_embed_batch_caps_text_length():
assert len(emb.calls[0][0]) == EMBED_TEXT_MAX_CHARS
+async def test_in_memory_single_upsert_caps_text_length():
+ from repowise.core.persistence.vector_store import InMemoryVectorStore
+ from repowise.core.persistence.vector_store._base import EMBED_TEXT_MAX_CHARS
+
+ emb = _RecordingEmbedder()
+ store = InMemoryVectorStore(emb)
+ await store.embed_and_upsert(
+ "p0", "x" * (EMBED_TEXT_MAX_CHARS + 5_000), {"target_path": "f0.py"}
+ )
+ assert len(emb.calls[0][0]) == EMBED_TEXT_MAX_CHARS
+
+
@pytest.mark.asyncio
async def test_lancedb_embed_batch_isolates_failed_chunk(tmp_path):
# One failing chunk must not sink the rest of the level, but the loss
# must surface as an error (the old code swallowed it entirely).
pytest.importorskip("lancedb")
- from repowise.core.persistence.vector_store import LanceDBVectorStore
+ from repowise.core.persistence.vector_store import BatchEmbeddingError, LanceDBVectorStore
from repowise.core.persistence.vector_store._base import EMBED_BATCH_MAX_ITEMS
emb = _RecordingEmbedder(fail_on_call=2)
store = LanceDBVectorStore(str(tmp_path / "lance"), emb)
try:
- with pytest.raises(RuntimeError, match="failed to embed"):
+ with pytest.raises(BatchEmbeddingError, match="failed during embedding") as caught:
await store.embed_batch(_items(EMBED_BATCH_MAX_ITEMS * 3))
+ assert caught.value.successful_count == EMBED_BATCH_MAX_ITEMS * 2
+ assert [item[0] for item in caught.value.failed_items] == [
+ f"p{i}" for i in range(EMBED_BATCH_MAX_ITEMS, EMBED_BATCH_MAX_ITEMS * 2)
+ ]
+ assert len(caught.value.failures) == 1
+ assert caught.value.failures[0].stage == "embedding"
ids = await store.list_page_ids()
# Chunks 1 and 3 persisted; only chunk 2 was lost.
assert len(ids) == EMBED_BATCH_MAX_ITEMS * 2