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.

feat: verify returned vector width across all embedding providers (#1305)

Akshat malikd9c9092e9256
diff --git a/packages/core/src/repowise/core/providers/embedding/gemini.py b/packages/core/src/repowise/core/providers/embedding/gemini.py
index a54c14507..849e3c121 100644
--- a/packages/core/src/repowise/core/providers/embedding/gemini.py
+++ b/packages/core/src/repowise/core/providers/embedding/gemini.py
@@ -121,6 +121,15 @@ class GeminiEmbedder:
)
raw_vectors = [list(e.values) for e in result.embeddings]
+ widths = {len(v) for v in raw_vectors}
+ if widths and widths != {output_dimensionality}:
+ actual = min(widths - {output_dimensionality})
+ raise ValueError(
+ f"GeminiEmbedder declared {output_dimensionality}-dimensional vectors but"
+ f" the API returned {actual} (model={model!r}). The API ignored"
+ f" 'output_dimensionality'. Verify the model supports {output_dimensionality}"
+ f" dimensions, or construct GeminiEmbedder with output_dimensionality={actual}."
+ )
return [_l2_normalize(v) for v in raw_vectors]
return await asyncio.to_thread(_embed_sync)
diff --git a/packages/core/src/repowise/core/providers/embedding/ollama.py b/packages/core/src/repowise/core/providers/embedding/ollama.py
index bf09ceabd..865977062 100644
--- a/packages/core/src/repowise/core/providers/embedding/ollama.py
+++ b/packages/core/src/repowise/core/providers/embedding/ollama.py
@@ -113,6 +113,24 @@ class OllamaEmbedder:
raise ValueError(
f"Ollama returned {len(raw_vectors)} embeddings for {len(texts)} inputs."
)
+ widths = {len(v) for v in raw_vectors}
+ if widths and widths != {self._dimensions}:
+ actual = min(widths - {self._dimensions})
+ if self._requested_dimensions is not None:
+ hint = (
+ f"Set OLLAMA_EMBEDDING_DIMS={actual} (or REPOWISE_EMBEDDING_DIMS={actual})"
+ f" to match the server's native output."
+ )
+ else:
+ hint = (
+ f"The dimension was inferred from the model name ({self._model!r})."
+ f" Set OLLAMA_EMBEDDING_DIMS={actual} to override the inferred value."
+ )
+ raise ValueError(
+ f"OllamaEmbedder declared {self._dimensions}-dimensional vectors but the "
+ f"server returned {actual} (model={self._model!r}). "
+ f"The server likely ignored the 'dimensions' parameter. {hint}"
+ )
return [_l2_normalize([float(value) for value in vector]) for vector in raw_vectors]
diff --git a/packages/core/src/repowise/core/providers/embedding/openai.py b/packages/core/src/repowise/core/providers/embedding/openai.py
index 5852603a6..668445387 100644
--- a/packages/core/src/repowise/core/providers/embedding/openai.py
+++ b/packages/core/src/repowise/core/providers/embedding/openai.py
@@ -136,6 +136,7 @@ class OpenAIEmbedder:
model = self._model
timeout = self._timeout
request_dimensions = self._request_dimensions
+ expected_dimensions = self._dimensions
def _embed_sync() -> list[list[float]]:
import openai # type: ignore[import-untyped]
@@ -152,6 +153,25 @@ class OpenAIEmbedder:
create_kwargs["dimensions"] = request_dimensions
response = self._client.embeddings.create(**create_kwargs) # type: ignore[union-attr]
raw_vectors = [list(item.embedding) for item in response.data]
+ widths = {len(v) for v in raw_vectors}
+ if widths and widths != {expected_dimensions}:
+ actual = min(widths - {expected_dimensions})
+ if request_dimensions is not None:
+ hint = (
+ f"Set REPOWISE_EMBEDDING_DIMS={actual} to match the server's"
+ f" native output, or remove the override to use the model's default."
+ )
+ else:
+ hint = (
+ f"The width {expected_dimensions} came from the built-in _DIMS table for"
+ f" {model!r}. Add or update OpenAIEmbedder._DIMS[{model!r}] = {actual},"
+ f" or set REPOWISE_EMBEDDING_DIMS={actual}."
+ )
+ raise ValueError(
+ f"OpenAIEmbedder declared {expected_dimensions}-dimensional vectors but the"
+ f" API returned {actual} (model={model!r}). The endpoint likely ignored"
+ f" the 'dimensions' parameter. {hint}"
+ )
return [_l2_normalize(v) for v in raw_vectors]
return await asyncio.to_thread(_embed_sync)
diff --git a/packages/core/src/repowise/core/providers/embedding/openrouter.py b/packages/core/src/repowise/core/providers/embedding/openrouter.py
index d264fc1be..8e3a3930b 100644
--- a/packages/core/src/repowise/core/providers/embedding/openrouter.py
+++ b/packages/core/src/repowise/core/providers/embedding/openrouter.py
@@ -24,8 +24,16 @@ class OpenRouterEmbedder:
"""OpenRouter embedding adapter implementing the repowise Embedder protocol.
Args:
- api_key: OpenRouter API key. Falls back to OPENROUTER_API_KEY env var.
- model: Embedding model name. Default: "google/gemini-embedding-001".
+ api_key: OpenRouter API key. Falls back to OPENROUTER_API_KEY env var.
+ model: Embedding model name. Default: "google/gemini-embedding-001".
+ dimensions: Override the declared output width. Useful when an
+ OpenRouter-compatible endpoint returns a different number of
+ dimensions than the built-in ``_DIMS`` table records for that
+ model. Falls back to REPOWISE_EMBEDDING_DIMS, then ``_DIMS``.
+ Note: this overrides only the *declared* width that the vector
+ store trusts — it does not add a ``dimensions`` parameter to the
+ API request. Use it to correct a wrong ``_DIMS`` entry when the
+ model's real output differs.
"""
_DIMS: ClassVar[dict[str, int]] = {
@@ -41,6 +49,7 @@ class OpenRouterEmbedder:
api_key: str | None = None,
model: str = "google/gemini-embedding-001",
timeout: float = _DEFAULT_TIMEOUT,
+ dimensions: int | None = None,
) -> None:
self._api_key = api_key or os.environ.get("OPENROUTER_API_KEY")
if not self._api_key:
@@ -57,11 +66,20 @@ class OpenRouterEmbedder:
)
self._model = model
self._timeout = timeout
+ # Resolve declared width: explicit arg > REPOWISE_EMBEDDING_DIMS > _DIMS table.
+ if dimensions is None:
+ env = os.environ.get("REPOWISE_EMBEDDING_DIMS")
+ if env:
+ try:
+ dimensions = int(env)
+ except ValueError:
+ raise ValueError("dimensions must be a positive integer") from None
+ self._dimensions = dimensions if dimensions is not None else self._DIMS[model]
self._client: object | None = None
@property
def dimensions(self) -> int:
- return self._DIMS[self._model]
+ return self._dimensions
async def embed(self, texts: list[str]) -> list[list[float]]:
"""Embed a batch of texts using OpenRouter.
@@ -74,6 +92,7 @@ class OpenRouterEmbedder:
model = self._model
timeout = self._timeout
+ expected_dimensions = self._dimensions
def _embed_sync() -> list[list[float]]:
import openai
@@ -86,6 +105,15 @@ class OpenRouterEmbedder:
)
response = self._client.embeddings.create(model=model, input=texts) # type: ignore[union-attr]
raw_vectors = [list(item.embedding) for item in response.data]
+ widths = {len(v) for v in raw_vectors}
+ if widths and widths != {expected_dimensions}:
+ actual = min(widths - {expected_dimensions})
+ raise ValueError(
+ f"OpenRouterEmbedder declared {expected_dimensions}-dimensional vectors but the API"
+ f" returned {actual} (model={model!r}). Update"
+ f" OpenRouterEmbedder._DIMS[{model!r}] = {actual} to match the server's"
+ f" real output."
+ )
return [_l2_normalize(v) for v in raw_vectors]
return await asyncio.to_thread(_embed_sync)
diff --git a/tests/unit/test_persistence/test_gemini_embedder.py b/tests/unit/test_persistence/test_gemini_embedder.py
new file mode 100644
index 000000000..a3b28e9a4
--- /dev/null
+++ b/tests/unit/test_persistence/test_gemini_embedder.py
@@ -0,0 +1,137 @@
+"""Unit tests for GeminiEmbedder.
+
+All tests patch google.genai.Client — no real API key or network call is made.
+The pattern mirrors the other embedder suites: mock the external SDK, run the real embed().
+"""
+
+from __future__ import annotations
+
+import math
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from repowise.core.providers.embedding.gemini import GeminiEmbedder
+
+# ---------------------------------------------------------------------------
+# Shared fake-SDK helpers
+# ---------------------------------------------------------------------------
+
+
+def _fake_client(vectors: list[list[float]]) -> MagicMock:
+ """Build a minimal google.genai.Client double that returns *vectors*."""
+ embeddings = [SimpleNamespace(values=v) for v in vectors]
+ result = SimpleNamespace(embeddings=embeddings)
+
+ client = MagicMock()
+ client.models.embed_content.return_value = result
+ return client
+
+
+# ---------------------------------------------------------------------------
+# Construction
+# ---------------------------------------------------------------------------
+
+
+def test_missing_api_key_raises(monkeypatch):
+ monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+ monkeypatch.delenv("GOOGLE_API_KEY", raising=False)
+ with pytest.raises(ValueError, match="Gemini API key required"):
+ GeminiEmbedder(api_key=None)
+
+
+def test_api_key_from_gemini_env(monkeypatch):
+ monkeypatch.setenv("GEMINI_API_KEY", "gemini-test-key")
+ emb = GeminiEmbedder()
+ assert emb._api_key == "gemini-test-key"
+
+
+def test_api_key_from_google_env(monkeypatch):
+ monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+ monkeypatch.setenv("GOOGLE_API_KEY", "google-test-key")
+ emb = GeminiEmbedder()
+ assert emb._api_key == "google-test-key"
+
+
+def test_default_dimensions():
+ emb = GeminiEmbedder(api_key="k")
+ assert emb.dimensions == 768
+
+
+def test_custom_dimensions():
+ emb = GeminiEmbedder(api_key="k", output_dimensionality=2048)
+ assert emb.dimensions == 2048
+
+
+# ---------------------------------------------------------------------------
+# Embedding — happy path
+# ---------------------------------------------------------------------------
+
+
+async def test_embed_empty_returns_empty():
+ emb = GeminiEmbedder(api_key="k")
+ assert await emb.embed([]) == []
+
+
+async def test_embed_returns_normalized_vectors(monkeypatch):
+ # 3-4-5 right triangle → L2 norm = 5 → normalised = [0.6, 0.8]
+ monkeypatch.setattr("google.genai.Client", lambda **kw: _fake_client([[3.0, 4.0]]))
+ emb = GeminiEmbedder(api_key="k", output_dimensionality=2)
+ result = await emb.embed(["hello"])
+
+ assert len(result) == 1
+ norm = math.sqrt(sum(x * x for x in result[0]))
+ assert abs(norm - 1.0) < 1e-6
+
+
+async def test_embed_batch_returns_correct_count(monkeypatch):
+ monkeypatch.setattr(
+ "google.genai.Client",
+ lambda **kw: _fake_client([[1.0, 0.0], [0.0, 1.0], [0.707, 0.707]]),
+ )
+ emb = GeminiEmbedder(api_key="k", output_dimensionality=2)
+ result = await emb.embed(["a", "b", "c"])
+
+ assert len(result) == 3
+
+
+# ---------------------------------------------------------------------------
+# Width verification — the check added in fix/embedder-width-verification
+# ---------------------------------------------------------------------------
+
+
+async def test_embed_raises_when_api_returns_wrong_width(monkeypatch):
+ """API ignores output_dimensionality and returns a different-width vector.
+
+ The error must name both the declared width and the actual width, and
+ reference 'output_dimensionality' so the user knows what to change.
+ """
+ # Declared: 768. Fake SDK returns 3-wide vectors.
+ monkeypatch.setattr("google.genai.Client", lambda **kw: _fake_client([[1.0, 0.0, 0.0]]))
+ emb = GeminiEmbedder(api_key="k", output_dimensionality=768)
+ with pytest.raises(ValueError, match="768") as exc_info:
+ await emb.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg # actual width named
+ assert "output_dimensionality" in msg # tells user which parameter to fix
+
+
+async def test_embed_raises_when_api_returns_wrong_width_custom_dim(monkeypatch):
+ """Same check holds for a non-default output_dimensionality."""
+ monkeypatch.setattr("google.genai.Client", lambda **kw: _fake_client([[1.0, 0.0, 0.0]]))
+ emb = GeminiEmbedder(api_key="k", output_dimensionality=2048)
+ with pytest.raises(ValueError, match="2048") as exc_info:
+ await emb.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg
+ assert "output_dimensionality" in msg
+
+
+async def test_embed_width_check_not_triggered_on_empty():
+ # embed([]) returns early without touching the SDK.
+ emb = GeminiEmbedder(api_key="k")
+ assert await emb.embed([]) == []
+
diff --git a/tests/unit/test_persistence/test_ollama_embedder.py b/tests/unit/test_persistence/test_ollama_embedder.py
index f0ff13c09..3f02616a9 100644
--- a/tests/unit/test_persistence/test_ollama_embedder.py
+++ b/tests/unit/test_persistence/test_ollama_embedder.py
@@ -70,7 +70,13 @@ async def test_embed_empty_returns_empty() -> None:
async def test_embed_posts_batch_to_native_endpoint() -> None:
- _FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0], [0.0, 2.0]]}
+ # Response vectors must be 1024-wide to match the declared dimensions=1024.
+ _FakeAsyncClient.response_data = {
+ "embeddings": [
+ [1.0] + [0.0] * 1023,
+ [0.0, 1.0] + [0.0] * 1022,
+ ]
+ }
embedder = OllamaEmbedder(
model="qwen3-embedding:0.6b",
base_url="http://localhost:11434/",
@@ -95,8 +101,9 @@ async def test_embed_posts_batch_to_native_endpoint() -> None:
async def test_embed_supports_legacy_single_embedding_response() -> None:
+ # dimensions=2 so the declared width matches the 2-wide legacy response.
_FakeAsyncClient.response_data = {"embedding": [3.0, 4.0]}
- embedder = OllamaEmbedder(model="embeddinggemma")
+ embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
result = await embedder.embed(["one"])
@@ -144,8 +151,52 @@ def test_explicit_timeout_overrides_env(monkeypatch: pytest.MonkeyPatch) -> None
async def test_env_timeout_is_applied_to_the_request(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "300")
- embedder = OllamaEmbedder(model="embeddinggemma")
+ # dimensions=2 so the default 2-wide fixture response passes the width guard.
+ embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
await embedder.embed(["one"])
assert _FakeAsyncClient.calls[0]["timeout"] == 300.0
+
+
+# ---------------------------------------------------------------------------
+# Width verification — the check added in fix/embedder-width-verification
+# ---------------------------------------------------------------------------
+
+
+async def test_embed_raises_when_server_returns_wrong_width_inferred() -> None:
+ # embeddinggemma → _infer_dimensions() → 768.
+ # Server returns 3-wide vectors (ignores 'dimensions' parameter).
+ # Hint should reference OLLAMA_EMBEDDING_DIMS because the user never set it.
+ _FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0, 0.0]]}
+ embedder = OllamaEmbedder(model="embeddinggemma")
+ assert embedder.dimensions == 768
+
+ with pytest.raises(ValueError, match="768") as exc_info:
+ await embedder.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg # actual width named
+ assert "OLLAMA_EMBEDDING_DIMS" in msg # points at the env var fix
+
+
+async def test_embed_raises_when_server_returns_wrong_width_explicit() -> None:
+ # User set dimensions=1024 explicitly; server returns 3-wide vectors.
+ # Hint should also reference OLLAMA_EMBEDDING_DIMS / REPOWISE_EMBEDDING_DIMS.
+ _FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0, 0.0]]}
+ embedder = OllamaEmbedder(model="qwen3-embedding:0.6b", dimensions=1024)
+ assert embedder.dimensions == 1024
+
+ with pytest.raises(ValueError, match="1024") as exc_info:
+ await embedder.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg
+ assert "OLLAMA_EMBEDDING_DIMS" in msg
+
+
+async def test_embed_width_check_not_triggered_on_empty() -> None:
+ # embed([]) short-circuits and returns [] without calling the server.
+ embedder = OllamaEmbedder(model="embeddinggemma")
+ assert await embedder.embed([]) == []
+
diff --git a/tests/unit/test_persistence/test_openai_embedder.py b/tests/unit/test_persistence/test_openai_embedder.py
index 73c18c7d0..54252c6aa 100644
--- a/tests/unit/test_persistence/test_openai_embedder.py
+++ b/tests/unit/test_persistence/test_openai_embedder.py
@@ -106,8 +106,9 @@ async def test_embed_empty_returns_empty():
async def test_embed_returns_normalized_vectors():
+ # dimensions=3 so the declared width matches the 3-wide fake vector.
raw = [1.0, 0.0, 0.0]
- emb = OpenAIEmbedder(api_key="k")
+ emb = OpenAIEmbedder(api_key="k", dimensions=3)
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.return_value = _make_mock_response([raw])
@@ -119,9 +120,10 @@ async def test_embed_returns_normalized_vectors():
async def test_embed_batch_returns_correct_count():
+ # dimensions=2 so the declared width matches the 2-wide fake vectors.
texts = ["a", "b", "c"]
raw_vecs = [[1.0, 0.0], [0.0, 1.0], [0.707, 0.707]]
- emb = OpenAIEmbedder(api_key="k")
+ emb = OpenAIEmbedder(api_key="k", dimensions=2)
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.return_value = _make_mock_response(raw_vecs)
@@ -131,11 +133,12 @@ async def test_embed_batch_returns_correct_count():
async def test_embed_passes_model_and_input():
- emb = OpenAIEmbedder(api_key="k", model="text-embedding-3-large")
+ # dimensions=2 so the fake 2-wide response passes the width guard.
+ emb = OpenAIEmbedder(api_key="k", model="text-embedding-3-large", dimensions=2)
captured: list = []
- def fake_create(model, input):
- captured.append({"model": model, "input": input})
+ def fake_create(**kwargs):
+ captured.append({"model": kwargs["model"], "input": kwargs["input"]})
return _make_mock_response([[1.0, 0.0]])
with patch("openai.OpenAI") as mock_client:
@@ -156,7 +159,8 @@ async def _capture_create_kwargs(emb: OpenAIEmbedder) -> dict:
def fake_create(**kwargs):
captured.update(kwargs)
- return _make_mock_response([[1.0, 0.0]])
+ # Return a vector of the declared width so the new width guard doesn't fire.
+ return _make_mock_response([[1.0] + [0.0] * (emb.dimensions - 1)])
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.side_effect = fake_create
@@ -185,3 +189,54 @@ async def test_default_request_omits_dimensions():
OpenAIEmbedder(api_key="k", model="text-embedding-3-small")
)
assert "dimensions" not in kwargs
+
+
+# ---------------------------------------------------------------------------
+# Width verification — the check added in fix/embedder-width-verification
+# ---------------------------------------------------------------------------
+
+
+async def test_embed_raises_when_api_returns_wrong_width_from_dims_table():
+ # Declared via _DIMS (user never chose the number). The error message should
+ # mention _DIMS so the user knows where to look.
+ emb = OpenAIEmbedder(api_key="k", model="text-embedding-3-small")
+ assert emb.dimensions == 1536 # from _DIMS table
+
+ with patch("openai.OpenAI") as mock_client:
+ # Fake API silently ignores 'dimensions' and returns its native 3-wide vector.
+ mock_client.return_value.embeddings.create.return_value = _make_mock_response(
+ [[1.0, 0.0, 0.0]]
+ )
+ with pytest.raises(ValueError, match="1536") as exc_info:
+ await emb.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg # actual width named
+ assert "_DIMS" in msg # points at the table, not the user
+
+
+async def test_embed_raises_when_api_returns_wrong_width_with_user_override(monkeypatch):
+ # Declared via REPOWISE_EMBEDDING_DIMS (user explicitly set it). The error
+ # message should reference REPOWISE_EMBEDDING_DIMS so they know what to change.
+ monkeypatch.setenv("REPOWISE_EMBEDDING_DIMS", "512")
+ emb = OpenAIEmbedder(api_key="k", model="text-embedding-3-small")
+ assert emb.dimensions == 512 # from env override
+
+ with patch("openai.OpenAI") as mock_client:
+ mock_client.return_value.embeddings.create.return_value = _make_mock_response(
+ [[1.0, 0.0, 0.0]]
+ )
+ with pytest.raises(ValueError, match="512") as exc_info:
+ await emb.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg
+ assert "REPOWISE_EMBEDDING_DIMS" in msg
+
+
+async def test_embed_width_check_is_skipped_for_empty_response():
+ # embed([]) short-circuits before the API call and returns []; the guard
+ # must not fire on the empty list itself.
+ emb = OpenAIEmbedder(api_key="k")
+ assert await emb.embed([]) == []
+
diff --git a/tests/unit/test_persistence/test_openrouter_embedder.py b/tests/unit/test_persistence/test_openrouter_embedder.py
index d6fe0d0d7..0107a08a6 100644
--- a/tests/unit/test_persistence/test_openrouter_embedder.py
+++ b/tests/unit/test_persistence/test_openrouter_embedder.py
@@ -57,6 +57,12 @@ def test_unknown_model_raises_at_construction():
OpenRouterEmbedder(api_key="k", model="some/future-model")
+def test_malformed_env_raises_the_same_message(monkeypatch):
+ monkeypatch.setenv("REPOWISE_EMBEDDING_DIMS", "abc")
+ with pytest.raises(ValueError, match="dimensions must be a positive integer"):
+ OpenRouterEmbedder(api_key="k")
+
+
# ---------------------------------------------------------------------------
# Embedding
# ---------------------------------------------------------------------------
@@ -81,8 +87,9 @@ async def test_embed_empty_returns_empty():
async def test_embed_returns_normalized_vectors():
+ # dimensions=3 so the declared width matches the 3-wide mock — original vector preserved.
raw = [1.0, 0.0, 0.0]
- emb = OpenRouterEmbedder(api_key="k")
+ emb = OpenRouterEmbedder(api_key="k", dimensions=3)
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.return_value = _make_mock_response([raw])
@@ -94,9 +101,10 @@ async def test_embed_returns_normalized_vectors():
async def test_embed_batch_returns_correct_count():
+ # dimensions=2 so the declared width matches the 2-wide mock — original vectors preserved.
texts = ["a", "b", "c"]
raw_vecs = [[1.0, 0.0], [0.0, 1.0], [0.707, 0.707]]
- emb = OpenRouterEmbedder(api_key="k")
+ emb = OpenRouterEmbedder(api_key="k", dimensions=2)
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.return_value = _make_mock_response(raw_vecs)
@@ -106,11 +114,12 @@ async def test_embed_batch_returns_correct_count():
async def test_embed_passes_model_and_input():
- emb = OpenRouterEmbedder(api_key="k", model="openai/text-embedding-3-large")
+ # dimensions=2 so the 2-wide mock response passes the width guard — original intent preserved.
+ emb = OpenRouterEmbedder(api_key="k", model="openai/text-embedding-3-large", dimensions=2)
captured: list = []
- def fake_create(model, input):
- captured.append({"model": model, "input": input})
+ def fake_create(**kwargs):
+ captured.append({"model": kwargs["model"], "input": kwargs["input"]})
return _make_mock_response([[1.0, 0.0]])
with patch("openai.OpenAI") as mock_client:
@@ -123,7 +132,8 @@ async def test_embed_passes_model_and_input():
async def test_embed_uses_openrouter_base_url():
"""Verify the client is created with the OpenRouter base URL."""
- emb = OpenRouterEmbedder(api_key="sk-or-test")
+ # dimensions=1 so the 1-wide mock response passes the width guard — original mock preserved.
+ emb = OpenRouterEmbedder(api_key="sk-or-test", dimensions=1)
with patch("openai.OpenAI") as mock_client:
mock_client.return_value.embeddings.create.return_value = _make_mock_response([[1.0]])
@@ -131,3 +141,33 @@ async def test_embed_uses_openrouter_base_url():
call_kwargs = mock_client.call_args
assert call_kwargs.kwargs.get("base_url") == "https://openrouter.ai/api/v1"
+
+
+# ---------------------------------------------------------------------------
+# Width verification — the check added in fix/embedder-width-verification
+# ---------------------------------------------------------------------------
+
+
+async def test_embed_raises_when_api_returns_wrong_width():
+ # google/gemini-embedding-001 is declared as 768 in _DIMS.
+ # Fake API returns 3-wide vectors (wrong width).
+ # Error message should name both numbers and mention _DIMS.
+ emb = OpenRouterEmbedder(api_key="k", model="google/gemini-embedding-001")
+ assert emb.dimensions == 768
+
+ with patch("openai.OpenAI") as mock_client:
+ mock_client.return_value.embeddings.create.return_value = _make_mock_response(
+ [[1.0, 0.0, 0.0]]
+ )
+ with pytest.raises(ValueError, match="768") as exc_info:
+ await emb.embed(["hello"])
+
+ msg = str(exc_info.value)
+ assert "3" in msg # actual width named
+ assert "_DIMS" in msg # points at the table entry
+
+
+async def test_embed_width_check_not_triggered_on_empty():
+ emb = OpenRouterEmbedder(api_key="k")
+ assert await emb.embed([]) == []
+