synap-git 1.2.3__tar.gz → 2.0.0__tar.gz

{synap_git-1.2.3 → synap_git-2.0.0}/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] - 2026-05-29
+
+### Added
+- **.synapignore Support**: Implemented context-aware filtering to prevent traversing symlinks, binary files, and files listed in `.synapignore` or `.gitignore`.
+- **FTS5 Integration**: Shifted semantic full-text search directly to SQLite FTS5 with bounding limits (`LIMIT 50`) for `O(1)` lexical retrieval scaling on 10,000+ file monorepos.
+
+### Fixed
+- **LLM Hangs in Test Suite**: Isolated testing environment by strictly bypassing real LLM provider configs (`SYNAP_LLM_PROVIDER=""`) preventing test CI suite hangs.
+- **Repository Path Scoping in Hybrid Engine**: Fixed a bug where `repo_path` initialization mistakenly truncated the path to `/tmp` in tests, failing contextual snippet aggregation.
+- **Unbounded BM25 Expansion**: Bounded full-text search token extraction and BM25 results, preventing out-of-memory cascading in CTE traversal during monorepo indexing.
+
 ## [1.2.3] - 2026-05-28
 
 ### Added

{synap_git-1.2.3 → synap_git-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synap-git
-Version: 1.2.3
+Version: 2.0.0
 Summary: Persistent structural context infrastructure for AI coding agents.
 Project-URL: Homepage, https://github.com/saahilpal/synap-git
 Project-URL: Repository, https://github.com/saahilpal/synap-git
@@ -52,10 +52,10 @@ Description-Content-Type: text/markdown
 
 Local Git-aware structural context engine for AI coding agents.
 
-[![CI Status](https://github.com/saahilpal/synap-git/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synap-git/actions)
-[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://img.shields.io/project/synap-git/)
-[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://img.shields.io/project/synap-git/)
-[![License](https://img.shields.io/github/license/saahilpal/synap-git?color=cbd5e1)](LICENSE.md)
+[![CI Status](https://github.com/saahilpal/synapse/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synapse/actions)
+[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://pypi.org/project/synap-git/)
+[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://pypi.org/project/synap-git/)
+[![License](https://img.shields.io/github/license/saahilpal/synapse?color=cbd5e1)](LICENSE.md)
 
 ## The Problem
 

{synap_git-1.2.3 → synap_git-2.0.0}/README.md

@@ -2,10 +2,10 @@
 
 Local Git-aware structural context engine for AI coding agents.
 
-[![CI Status](https://github.com/saahilpal/synap-git/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synap-git/actions)
-[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://img.shields.io/project/synap-git/)
-[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://img.shields.io/project/synap-git/)
-[![License](https://img.shields.io/github/license/saahilpal/synap-git?color=cbd5e1)](LICENSE.md)
+[![CI Status](https://github.com/saahilpal/synapse/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synapse/actions)
+[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://pypi.org/project/synap-git/)
+[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://pypi.org/project/synap-git/)
+[![License](https://img.shields.io/github/license/saahilpal/synapse?color=cbd5e1)](LICENSE.md)
 
 ## The Problem
 

{synap_git-1.2.3 → synap_git-2.0.0}/src/synap_git/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.2.3"
+__version__ = "2.0.0"

{synap_git-1.2.3 → synap_git-2.0.0}/src/synap_git/indexer/engine.py

@@ -69,6 +69,7 @@ class SynapRuntime:
         self.parser_registry = CodeParserRegistry()
         self.llm_provider = get_llm_provider(settings)
         self.retrieval_engine = HybridRetrievalEngine(
+            repo_path=self.settings.repository_path,
             store=self.store,
             llm_provider=self.llm_provider,
             trace_store=self.trace_store,
@@ -244,6 +245,44 @@ class SynapRuntime:
 
         return commit
 
+    def _schedule_embedding(
+        self, file_id: str, symbols: list[dict[str, Any]], content_hash: str
+    ) -> None:
+        provider = self.llm_provider
+        if not provider:
+            return
+
+        def _worker() -> None:
+            import structlog
+
+            logger = structlog.get_logger()
+            try:
+                batches = [symbols[i : i + 50] for i in range(0, len(symbols), 50)]
+                model_name = getattr(provider, "default_model", "unknown")
+                for batch in batches:
+                    for sym in batch:
+                        try:
+                            # Avoid re-embedding if unchanged?
+                            text = sym["name"] + " " + sym.get("metadata", {}).get("docstring", "")
+                            vector = provider.embed(text)
+                            self.store.put_embedding(
+                                sym["symbol_id"], model_name, "1.0", "1.0", vector, content_hash
+                            )
+                        except Exception as e:
+                            logger.warning("background_embed_failed_for_symbol", error=str(e))
+            except Exception as e:
+                logger.warning("background_embed_failed", error=str(e))
+
+        try:
+            import asyncio
+
+            loop = asyncio.get_running_loop()
+            loop.create_task(asyncio.to_thread(_worker))
+        except RuntimeError:
+            import threading
+
+            threading.Thread(target=_worker, daemon=True).start()
+
     def _first_run_index(self, git_state: GitState) -> str | None:
         self.logger.info("first_run_indexing_started", branch=git_state.effective_branch)
         import time
@@ -254,16 +293,9 @@ class SynapRuntime:
             repository_path=self.settings.repository_path,
             max_file_bytes=self.settings.max_file_bytes,
         )
-        scan = scanner.scan()
-
-        files_to_parse = []
-        for file_info in scan.files:
-            files_to_parse.append((file_info.path, file_info.relative_path, file_info.content))
-
-        num_files = len(files_to_parse)
+        num_files = scanner.count_files()
         chunk_size = 500
         parsed_results = []
-
         # Parallel parsing using ProcessPoolExecutor
         import multiprocessing
         from concurrent.futures import ProcessPoolExecutor
@@ -301,16 +333,22 @@ class SynapRuntime:
                 task = progress.add_task("[yellow]Parsing codebase...[/yellow]", total=num_files)
 
                 with ProcessPoolExecutor(max_workers=num_workers) as executor:
-                    for chunk_idx in range(0, num_files, chunk_size):
-                        chunk = files_to_parse[chunk_idx : chunk_idx + chunk_size]
+                    from itertools import islice
+
+                    file_iterator = scanner.scan()
+                    while True:
+                        chunk_files = list(islice(file_iterator, chunk_size))
+                        if not chunk_files:
+                            break
+
+                        file_info_map = {f.relative_path: f for f in chunk_files}
+                        chunk = [(f.path, f.relative_path, f.content) for f in chunk_files]
                         futures = [executor.submit(_parse_worker, item) for item in chunk]
                         chunk_results = [f.result() for f in futures]
 
                         for res in chunk_results:
                             rel_path = res["path"]
-                            matching_info = next(
-                                (f for f in scan.files if f.relative_path == rel_path), None
-                            )
+                            matching_info = file_info_map.get(rel_path)
                             git_oid = matching_info.git_oid if matching_info else ""
                             content_hash = matching_info.content_hash if matching_info else ""
 
@@ -328,6 +366,7 @@ class SynapRuntime:
                                 language=res["language"],
                                 symbols=res["symbols"],
                             )
+                            self._schedule_embedding(file_id_hash, res["symbols"], content_hash)
                             self.store.enqueue_wiki(rel_path)
                             parsed_results.append((file_id_hash, rel_path, res["imports"]))
 
@@ -336,20 +375,26 @@ class SynapRuntime:
                             self._resolve_and_insert_edges(parsed_results)
                             parsed_results.clear()
 
-                        progress.advance(task, len(chunk))
+                        progress.advance(task, len(chunk_files))
                         del chunk_results
         else:
             with ProcessPoolExecutor(max_workers=num_workers) as executor:
-                for chunk_idx in range(0, num_files, chunk_size):
-                    chunk = files_to_parse[chunk_idx : chunk_idx + chunk_size]
+                from itertools import islice
+
+                file_iterator = scanner.scan()
+                while True:
+                    chunk_files = list(islice(file_iterator, chunk_size))
+                    if not chunk_files:
+                        break
+
+                    file_info_map = {f.relative_path: f for f in chunk_files}
+                    chunk = [(f.path, f.relative_path, f.content) for f in chunk_files]
                     futures = [executor.submit(_parse_worker, item) for item in chunk]
                     chunk_results = [f.result() for f in futures]
 
                     for res in chunk_results:
                         rel_path = res["path"]
-                        matching_info = next(
-                            (f for f in scan.files if f.relative_path == rel_path), None
-                        )
+                        matching_info = file_info_map.get(rel_path)
                         git_oid = matching_info.git_oid if matching_info else ""
                         content_hash = matching_info.content_hash if matching_info else ""
 
@@ -367,6 +412,7 @@ class SynapRuntime:
                             language=res["language"],
                             symbols=res["symbols"],
                         )
+                        self._schedule_embedding(file_id_hash, res["symbols"], content_hash)
                         self.store.enqueue_wiki(rel_path)
                         parsed_results.append((file_id_hash, rel_path, res["imports"]))
 
@@ -426,6 +472,7 @@ class SynapRuntime:
 
         added_or_modified = []
         deleted = []
+        renames = []
         for line in res.stdout.splitlines():
             if not line.strip():
                 continue
@@ -433,13 +480,41 @@ class SynapRuntime:
             if len(parts) >= 2:
                 status = parts[0]
                 if status.startswith("R"):
-                    deleted.append(parts[1])
+                    renames.append((parts[1], parts[2]))
                     added_or_modified.append(parts[2])
                 elif status == "D":
                     deleted.append(parts[1])
                 else:
                     added_or_modified.append(parts[1])
 
+        import hashlib
+
+        # Apply renames to preserve identity
+        with self.store.connect() as conn:
+            for old_path, new_path in renames:
+                file_row = conn.execute(
+                    "SELECT file_id, content_hash FROM files WHERE path = ?", (old_path,)
+                ).fetchone()
+                if file_row:
+                    old_file_id = file_row["file_id"]
+                    content_hash = file_row["content_hash"]
+                    new_file_id = hashlib.sha256(
+                        (new_path + content_hash).encode("utf-8")
+                    ).hexdigest()
+
+                    conn.execute("PRAGMA foreign_keys=OFF")
+                    try:
+                        conn.execute(
+                            "UPDATE files SET file_id = ?, path = ? WHERE file_id = ?",
+                            (new_file_id, new_path, old_file_id),
+                        )
+                        conn.execute(
+                            "UPDATE symbols SET file_id = ? WHERE file_id = ?",
+                            (new_file_id, old_file_id),
+                        )
+                    finally:
+                        conn.execute("PRAGMA foreign_keys=ON")
+
         # Filter added/modified files
         scanner = RepositoryScanner(
             repository_path=self.settings.repository_path,
@@ -549,6 +624,7 @@ class SynapRuntime:
                 language=parse_result.language,
                 symbols=symbols_list,
             )
+            self._schedule_embedding(file_id_hash, symbols_list, content_hash)
 
             self.store.set_wiki_status(rel_path, None, "stale")
             self.store.enqueue_wiki(rel_path)
@@ -701,11 +777,23 @@ class SynapRuntime:
                     for row in rows:
                         fts_symbols_by_name.setdefault(row["name"], []).append(dict(row))
 
+            target_symbols_dict: dict[str, dict[str, list[dict[str, Any]]]] = {}
+            for t_file_id, syms in target_symbols_by_file.items():
+                name_map: dict[str, Any] = {}
+                for sym in syms:
+                    name_map.setdefault(sym["name"], []).append(sym)
+                target_symbols_dict[t_file_id] = name_map
+
             for file_id, rel_path, imports in parsed_results:
                 file_symbols = file_symbols_map.get(file_id, [])
                 current_path = Path(rel_path)
+                edges_added_for_file = 0
+                max_edges_per_file = 1000
 
                 for imp in imports:
+                    if edges_added_for_file >= max_edges_per_file:
+                        break
+
                     target_file_id = None
                     if ":" in imp:
                         module_part, target_name = imp.split(":", 1)
@@ -728,15 +816,27 @@ class SynapRuntime:
                     else:
                         target_file_id = module_key_to_file_id.get(module_part)
 
+                        # Fuzzy fallback
+                        if not target_file_id:
+                            for mk, fid in module_key_to_file_id.items():
+                                if mk.endswith(module_part) or mk.endswith(f".{module_part}"):
+                                    target_file_id = fid
+                                    break
+
                     target_symbols = []
                     if target_file_id:
-                        all_target_syms = target_symbols_by_file.get(target_file_id, [])
-                        target_symbols = [ts for ts in all_target_syms if ts["name"] == target_name]
+                        target_symbols = target_symbols_dict.get(target_file_id, {}).get(
+                            target_name, []
+                        )
                     else:
                         target_symbols = fts_symbols_by_name.get(target_name, [])
 
                     for ts in target_symbols:
+                        if edges_added_for_file >= max_edges_per_file:
+                            break
                         for fs in file_symbols:
+                            if edges_added_for_file >= max_edges_per_file:
+                                break
                             if fs["symbol_id"] == ts["symbol_id"]:
                                 continue
                             edge_id = stable_hash(
@@ -747,6 +847,7 @@ class SynapRuntime:
                                 }
                             )
                             edges_to_insert.append((edge_id, fs["symbol_id"], ts["symbol_id"]))
+                            edges_added_for_file += 1
 
             if edges_to_insert:
                 conn.executemany(

{synap_git-1.2.3 → synap_git-2.0.0}/src/synap_git/indexer/scanner.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import asyncio
 import hashlib
 import json
 import re
 import subprocess
 import tomllib
+from collections.abc import Iterator
 from dataclasses import dataclass, field
 from enum import StrEnum
 from pathlib import Path
@@ -196,6 +196,7 @@ class RepositoryScanner:
         self.excludes = excludes or DEFAULT_EXCLUDES
         self.max_file_bytes = max_file_bytes
         self.gitignore = None
+        self.synapignore = None
 
         gitignore_path = self.repository_path / ".gitignore"
         if gitignore_path.exists():
@@ -205,13 +206,15 @@ class RepositoryScanner:
             except Exception as e:
                 logger.warning("failed_to_load_gitignore", error=str(e))
 
-    async def scan_async(self) -> RepositoryScan:
-        return await asyncio.to_thread(self.scan)
-
-    def scan(self) -> RepositoryScan:
-        files: list[FileObservation] = []
-        manifests: list[ManifestObservation] = []
+        synapignore_path = self.repository_path / ".synapignore"
+        if synapignore_path.exists():
+            try:
+                lines = synapignore_path.read_text(encoding="utf-8").splitlines()
+                self.synapignore = GitIgnoreSpec(self.repository_path, lines)
+            except Exception as e:
+                logger.warning("failed_to_load_synapignore", error=str(e))
 
+    def _get_paths(self) -> list[Path]:
         paths: list[Path] = []
         try:
             result = subprocess.run(  # noqa: S603
@@ -227,10 +230,29 @@ class RepositoryScanner:
                     except UnicodeDecodeError:
                         pass
         except (subprocess.CalledProcessError, FileNotFoundError):
-            # Fallback to rglob if not a git repository
             paths = list(self.repository_path.rglob("*"))
+        return paths
+
+    def count_files(self) -> int:
+        count = 0
+        for path in self._get_paths():
+            if not path.is_file():
+                continue
+            if self._excluded(path):
+                continue
+            try:
+                stat = path.stat()
+                if stat.st_size > self.max_file_bytes:
+                    continue
+            except OSError:
+                continue
+            if _is_binary_file(path):
+                continue
+            count += 1
+        return count
 
-        for path in paths:
+    def scan(self) -> Iterator[FileObservation]:
+        for path in self._get_paths():
             if not path.is_file():
                 continue
             if self._excluded(path):
@@ -250,11 +272,13 @@ class RepositoryScanner:
                 path.resolve().relative_to(self.repository_path)
             except (ValueError, OSError):
                 continue
+
             content_hash, content_text = _read_and_hash_file(path)
             language = LANGUAGE_BY_SUFFIX.get(path.suffix.lower())
             folder_role = self._classify_folder(relative_path)
             is_manifest = path.name in MANIFEST_NAMES
-            observation = FileObservation(
+
+            yield FileObservation(
                 path=path,
                 relative_path=relative_path,
                 size_bytes=stat.st_size,
@@ -264,23 +288,6 @@ class RepositoryScanner:
                 content=content_text,
                 is_manifest=is_manifest,
             )
-            files.append(observation)
-            if is_manifest:
-                manifests.append(self._read_manifest(path, relative_path))
-
-        language_counts: dict[str, int] = {}
-        folder_counts: dict[str, int] = {}
-        for file in files:
-            if file.language:
-                language_counts[file.language] = language_counts.get(file.language, 0) + 1
-            folder_counts[file.folder_role.value] = folder_counts.get(file.folder_role.value, 0) + 1
-        return RepositoryScan(
-            repository_path=self.repository_path,
-            files=tuple(files),
-            manifests=tuple(manifests),
-            language_counts=dict(sorted(language_counts.items())),
-            folder_counts=dict(sorted(folder_counts.items())),
-        )
 
     def _excluded(self, path: Path) -> bool:
         try:
@@ -289,6 +296,8 @@ class RepositoryScanner:
             return True
         if any(part in self.excludes for part in parts):
             return True
+        if self.synapignore and self.synapignore.matches(path, is_dir=path.is_dir()):
+            return True
         if self.gitignore and self.gitignore.matches(path, is_dir=path.is_dir()):
             return True
         return False

{synap_git-1.2.3 → synap_git-2.0.0}/src/synap_git/parser/registry.py

@@ -55,28 +55,38 @@ class CodeParserRegistry:
         return self._parsers[lang_name]
 
     def parse(self, path: Path, *, relative_path: str, text: str | None = None) -> CodeParseResult:
-        suffix = path.suffix.lower()
-        if text is None:
-            text = path.read_text(encoding="utf-8", errors="replace")
-
-        if suffix in PYTHON_SUFFIXES:
-            return self._parse_tree_sitter(text, "python", relative_path)
-        if suffix in JAVASCRIPT_SUFFIXES:
-            return self._parse_tree_sitter(text, "javascript", relative_path)
-        if suffix in TYPESCRIPT_SUFFIXES:
-            return self._parse_tree_sitter(text, "tsx", relative_path)
-        if suffix in GO_SUFFIXES:
-            return self._parse_tree_sitter(text, "go", relative_path)
-        if suffix in RUST_SUFFIXES:
-            return self._parse_tree_sitter(text, "rust", relative_path)
-        if suffix in JAVA_SUFFIXES:
-            return self._parse_tree_sitter(text, "java", relative_path)
-        if suffix in CPP_SUFFIXES:
-            return self._parse_tree_sitter(text, "cpp", relative_path)
-        if suffix in RUBY_SUFFIXES:
-            return self._parse_tree_sitter(text, "ruby", relative_path)
-
-        return CodeParseResult(path=relative_path, language="unknown", symbols=())
+        try:
+            suffix = path.suffix.lower()
+            if text is None:
+                text = path.read_text(encoding="utf-8", errors="replace")
+
+            if suffix in PYTHON_SUFFIXES:
+                return self._parse_tree_sitter(text, "python", relative_path)
+            if suffix in JAVASCRIPT_SUFFIXES:
+                return self._parse_tree_sitter(text, "javascript", relative_path)
+            if suffix in TYPESCRIPT_SUFFIXES:
+                return self._parse_tree_sitter(text, "tsx", relative_path)
+            if suffix in GO_SUFFIXES:
+                return self._parse_tree_sitter(text, "go", relative_path)
+            if suffix in RUST_SUFFIXES:
+                return self._parse_tree_sitter(text, "rust", relative_path)
+            if suffix in JAVA_SUFFIXES:
+                return self._parse_tree_sitter(text, "java", relative_path)
+            if suffix in CPP_SUFFIXES:
+                return self._parse_tree_sitter(text, "cpp", relative_path)
+            if suffix in RUBY_SUFFIXES:
+                return self._parse_tree_sitter(text, "ruby", relative_path)
+
+            return CodeParseResult(path=relative_path, language="unknown", symbols=())
+        except Exception as e:
+            import structlog
+
+            structlog.get_logger(__name__).warning(
+                "parser_failed", path=relative_path, error=str(e)
+            )
+            return CodeParseResult(
+                path=relative_path, language="unknown", symbols=(), syntax_error=str(e)
+            )
 
     def _parse_tree_sitter(self, text: str, lang_name: str, relative_path: str) -> CodeParseResult:
         parser = self._get_parser(lang_name)

{synap_git-1.2.3 → synap_git-2.0.0}/src/synap_git/provider/gemini.py

@@ -1,20 +1,46 @@
 from __future__ import annotations
 
-import json
-import urllib.request
-from collections.abc import Iterator
+import time
+from collections.abc import Callable, Iterator
 from typing import Any
 
+import httpx
+
 from synap_git.provider.base import LLMProvider, LLMResponse
 
 
+def _with_retries(func: Callable[..., Any]) -> Callable[..., Any]:
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        attempts = 3
+        backoff = 1.0
+        for i in range(attempts):
+            try:
+                return func(*args, **kwargs)
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code in (429, 500, 502, 503, 504) and i < attempts - 1:
+                    time.sleep(backoff)
+                    backoff *= 2.0
+                    continue
+                raise RuntimeError(f"API request failed: {e}") from e
+            except httpx.RequestError as e:
+                if i < attempts - 1:
+                    time.sleep(backoff)
+                    backoff *= 2.0
+                    continue
+                raise RuntimeError(f"API request failed: {e}") from e
+
+    return wrapper
+
+
 class GeminiProvider(LLMProvider):
     """Gemini API provider implementation."""
 
     def __init__(self, api_key: str, default_model: str = "gemini-1.5-flash") -> None:
         self.api_key = api_key
         self.default_model = default_model
+        self.client = httpx.Client(timeout=30.0)
 
+    @_with_retries
     def generate(
         self,
         system_prompt: str,
@@ -25,47 +51,32 @@ class GeminiProvider(LLMProvider):
         temperature: float = 0.2,
     ) -> LLMResponse:
         model_name = model or self.default_model
-        # Strip models/ prefix if present
         if model_name.startswith("models/"):
             model_name = model_name[7:]
         url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent?key={self.api_key}"
-        headers = {
-            "Content-Type": "application/json",
-        }
+        headers = {"Content-Type": "application/json"}
         payload: dict[str, Any] = {
-            "contents": [
-                {
-                    "role": "user",
-                    "parts": [{"text": user_prompt}],
-                }
-            ],
+            "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
             "systemInstruction": {"parts": [{"text": system_prompt}]},
-            "generationConfig": {
-                "temperature": temperature,
-            },
+            "generationConfig": {"temperature": temperature},
         }
         if max_tokens:
             payload["generationConfig"]["maxOutputTokens"] = max_tokens
 
-        req = urllib.request.Request(
-            url, data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST"
+        resp = self.client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        data = resp.json()
+
+        candidates = data.get("candidates", [])
+        if not candidates:
+            raise RuntimeError(f"Gemini API returned no candidates: {data}")
+        text_val = candidates[0]["content"]["parts"][0]["text"]
+        usage = data.get("usageMetadata", {})
+        return LLMResponse(
+            content=str(text_val),
+            prompt_tokens=int(usage.get("promptTokenCount", 0)),
+            completion_tokens=int(usage.get("candidatesTokenCount", 0)),
         )
-        try:
-            with urllib.request.urlopen(req, timeout=30.0) as resp:  # nosec B310
-                data = json.loads(resp.read().decode("utf-8"))
-            candidates = data.get("candidates", [])
-            if not candidates:
-                raise RuntimeError(f"Gemini API returned no candidates: {data}")
-            text_val = candidates[0]["content"]["parts"][0]["text"]
-            # Gemini does not always provide exact token counts in basic responses, or they might be in usageMetadata
-            usage = data.get("usageMetadata", {})
-            return LLMResponse(
-                content=str(text_val),
-                prompt_tokens=int(usage.get("promptTokenCount", 0)),
-                completion_tokens=int(usage.get("candidatesTokenCount", 0)),
-            )
-        except Exception as exc:
-            raise RuntimeError(f"Gemini generate failed: {exc}") from exc
 
     def generate_stream(
         self,
@@ -81,6 +92,7 @@ class GeminiProvider(LLMProvider):
         )
         yield res.content
 
+    @_with_retries
     def embed(
         self,
         text: str,
@@ -91,20 +103,14 @@ class GeminiProvider(LLMProvider):
         if not model_name.startswith("models/"):
             model_name = f"models/{model_name}"
         url = f"https://generativelanguage.googleapis.com/v1beta/{model_name}:embedContent?key={self.api_key}"
-        headers = {
-            "Content-Type": "application/json",
-        }
+        headers = {"Content-Type": "application/json"}
         payload = {"model": model_name, "content": {"parts": [{"text": text}]}}
-        req = urllib.request.Request(
-            url, data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST"
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=30.0) as resp:  # nosec B310
-                data = json.loads(resp.read().decode("utf-8"))
-            embedding = data["embedding"]["values"]
-            return [float(x) for x in embedding]
-        except Exception as exc:
-            raise RuntimeError(f"Gemini embed failed: {exc}") from exc
+
+        resp = self.client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        data = resp.json()
+        embedding = data["embedding"]["values"]
+        return [float(x) for x in embedding]
 
     def count_tokens(self, text: str) -> int:
         import tiktoken