Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
refactor(model): 统一 VLM 与 Embedding 重试策略 (#5950)
hezhang-1216b15426b28571
diff --git a/openviking/config/embedding.py b/openviking/config/embedding.pyindex d68397097..656bfaa73 100644--- a/openviking/config/embedding.py+++ b/openviking/config/embedding.py@@ -13,6 +13,7 @@ from openviking.concurrency import AsyncSemaphorefrom openviking.config.scope import ScopeKindfrom openviking.config.vector import AccountVectorConfigResolver, VectorRuntimeSettingsfrom openviking.models.embedder.base import EmbedderBase+from openviking.models.embedder.retry_embedder import RetryEmbedderfrom openviking.models.vlm.token_usage import TokenUsageTrackerfrom openviking.service.task_tracker_concurrency import KeyedAsyncLockPoolfrom openviking.utils.circuit_breaker import CircuitBreaker, CircuitBreakerOpen@@ -114,6 +115,8 @@ def _bind_account_state(child = getattr(embedder, name, None)if child is not None:children.append(child)+ if isinstance(embedder, RetryEmbedder):+ children.append(embedder.inner)for child in children:_bind_account_state(child, semaphore, tracker, account_id)diff --git a/openviking/models/embedder/__init__.py b/openviking/models/embedder/__init__.pyindex 229c35b94..8b8670ee0 100644--- a/openviking/models/embedder/__init__.py+++ b/openviking/models/embedder/__init__.py@@ -44,6 +44,7 @@ except ImportError:LiteLLMDenseEmbedder = None # litellm not installedfrom openviking.models.embedder.minimax_embedders import MinimaxDenseEmbedderfrom openviking.models.embedder.openai_embedders import OpenAIDenseEmbedder+from openviking.models.embedder.retry_embedder import RetryEmbedderfrom openviking.models.embedder.vikingdb_embedders import (VikingDBDenseEmbedder,VikingDBHybridEmbedder,@@ -69,6 +70,7 @@ __all__ = ["HybridEmbedderBase","CompositeHybridEmbedder","FailoverEmbedder",+ "RetryEmbedder","AllCredentialsFailedError",# Google Gemini implementations"GeminiDenseEmbedder",diff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.pyindex efb9ec136..329ede0b8 100644--- a/openviking/models/embedder/base.py+++ b/openviking/models/embedder/base.py@@ -21,8 +21,6 @@ from openviking.utils.exceptions import AllCredentialsFailedErrorfrom openviking.utils.model_retry import (OrderedCredentialSwitcher,classify_api_error,- retry_async,- retry_sync,)from openviking_cli.utils import get_logger@@ -377,66 +375,58 @@ class EmbedderBase(ABC):"""Release resources, subclasses can override as needed"""pass- def _run_with_retry(self, func: Callable[[], T], *, logger=None, operation_name: str) -> T:- def _wrapped() -> T:- previous_started_at = self._active_call_started_at- self._active_call_started_at = time.monotonic()- try:- return func()- finally:- self._active_call_started_at = previous_started_at-- return retry_sync(- _wrapped,- max_retries=self.max_retries,- logger=logger,- operation_name=operation_name,- )+ def _run_once(+ self,+ func: Callable[[], T],+ *,+ logger=None,+ operation_name: str = "embedding",+ ) -> T:+ """Run one provider request with per-attempt timing state."""+ previous_started_at = self._active_call_started_at+ self._active_call_started_at = time.monotonic()+ try:+ return func()+ finally:+ self._active_call_started_at = previous_started_at- async def _run_with_async_retry(+ async def _run_once_async(self,func: Callable[[], Awaitable[T]],*,logger=None,operation_name: str,) -> T:- async def _wrapped() -> T:- semaphore = getattr(self, "_account_semaphore", None)- if semaphore is None:- semaphore = _get_async_embed_semaphore(self.max_concurrent)- wait_started = time.monotonic()- await semaphore.acquire()- wait_elapsed = time.monotonic() - wait_started- telemetry = get_current_telemetry()- telemetry.set("embedding.async.max_concurrent", self.max_concurrent)- telemetry.set("embedding.async.wait_ms", round(wait_elapsed * 1000, 3))-- started = time.monotonic()- previous_started_at = self._active_call_started_at- self._active_call_started_at = started- try:- return await func()- finally:- elapsed = time.monotonic() - started- telemetry.set("embedding.async.duration_ms", round(elapsed * 1000, 3))- if logger and elapsed >= 3.0:- logger.warning(- "%s slow call provider=%s model=%s wait_ms=%.2f duration_ms=%.2f",- operation_name,- self.provider,- self.model_name,- wait_elapsed * 1000,- elapsed * 1000,- )- self._active_call_started_at = previous_started_at- semaphore.release()-- return await retry_async(- _wrapped,- max_retries=self.max_retries,- logger=logger,- operation_name=operation_name,- )+ """Run one async provider request with concurrency and telemetry guards."""+ semaphore = getattr(self, "_account_semaphore", None)+ if semaphore is None:+ semaphore = _get_async_embed_semaphore(self.max_concurrent)+ wait_started = time.monotonic()+ await semaphore.acquire()+ wait_elapsed = time.monotonic() - wait_started+ telemetry = get_current_telemetry()+ telemetry.set("embedding.async.max_concurrent", self.max_concurrent)+ telemetry.set("embedding.async.wait_ms", round(wait_elapsed * 1000, 3))++ started = time.monotonic()+ previous_started_at = self._active_call_started_at+ self._active_call_started_at = started+ try:+ return await func()+ finally:+ elapsed = time.monotonic() - started+ telemetry.set("embedding.async.duration_ms", round(elapsed * 1000, 3))+ if logger and elapsed >= 3.0:+ logger.warning(+ "%s slow call provider=%s model=%s wait_ms=%.2f duration_ms=%.2f",+ operation_name,+ self.provider,+ self.model_name,+ wait_elapsed * 1000,+ elapsed * 1000,+ )+ self._active_call_started_at = previous_started_at+ semaphore.release()@propertydef is_dense(self) -> bool:diff --git a/openviking/models/embedder/cohere_embedders.py b/openviking/models/embedder/cohere_embedders.pyindex f31e676c6..43bdabe86 100644--- a/openviking/models/embedder/cohere_embedders.py+++ b/openviking/models/embedder/cohere_embedders.py@@ -135,7 +135,11 @@ class CohereDenseEmbedder(DenseEmbedderBase):def embed(self, text: str, is_query: bool = False) -> EmbedResult:input_type = "search_query" if is_query else "search_document"try:- vectors = self._call_api([text], input_type)+ vectors = self._run_once(+ lambda: self._call_api([text], input_type),+ logger=logger,+ operation_name="Cohere embedding",+ )result = EmbedResult(dense_vector=self._normalize_vector(vectors[0]))# Estimate token usageestimated_tokens = self._estimate_tokens(text)@@ -161,7 +165,7 @@ class CohereDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=self._normalize_vector(vectors[0]))try:- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="Cohere async embedding",diff --git a/openviking/models/embedder/dashscope_embedders.py b/openviking/models/embedder/dashscope_embedders.pyindex 0ad338b19..44e3d3c95 100644--- a/openviking/models/embedder/dashscope_embedders.py+++ b/openviking/models/embedder/dashscope_embedders.py@@ -89,6 +89,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):self._openai_client = openai.OpenAI(api_key=self.api_key,base_url=f"{self.api_base}/compatible-mode/v1",+ max_retries=0,)# Multimodal mode: httpxself._httpx_client = httpx.Client(@@ -208,6 +209,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):lambda: openai.AsyncOpenAI(api_key=self.api_key,base_url=f"{self.api_base}/compatible-mode/v1",+ max_retries=0,))@@ -246,7 +248,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))try:- return self._run_with_retry(_call, logger=logger, operation_name="DashScope embedding")+ return self._run_once(_call, logger=logger, operation_name="DashScope embedding")except Exception as e:raise RuntimeError(f"DashScope embedding failed: {e}") from e@@ -279,7 +281,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))try:- return await self._run_with_async_retry(+ return await self._run_once_async(_call, logger=logger, operation_name="DashScope async embedding")except Exception as e:@@ -318,7 +320,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))try:- return self._run_with_retry(+ return self._run_once(_call, logger=logger, operation_name="DashScope content embedding")except Exception as e:@@ -348,7 +350,7 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))try:- return await self._run_with_async_retry(+ return await self._run_once_async(_call, logger=logger, operation_name="DashScope async content embedding")except Exception as e:diff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.pyindex 3ab1cd937..a81dbf665 100644--- a/openviking/models/embedder/gemini_embedders.py+++ b/openviking/models/embedder/gemini_embedders.py@@ -52,7 +52,7 @@ _ERROR_HINTS: Dict[int, str] = {401: "Invalid API key. Verify your GOOGLE_API_KEY or api_key in config.",403: "Permission denied. API key may lack access to this model.",404: "Model not found: '{model}'. Check spelling (e.g. 'gemini-embedding-2-preview').",- 429: "Quota exceeded. Wait and retry, or increase your Google API quota.",+ 429: "Resource exhausted. Wait and retry.",500: "Gemini service error (Google-side). Retry after a delay.",503: "Gemini service unavailable. Retry after a delay.",}@@ -139,12 +139,7 @@ class GeminiDenseEmbedder(DenseEmbedderBase):self._client_kwargs: Dict[str, Any] = {"api_key": api_key}if _HTTP_RETRY_AVAILABLE:self._client_kwargs["http_options"] = HttpOptions(- retry_options=HttpRetryOptions(- attempts=max(self.max_retries + 1, 1),- initial_delay=0.5,- max_delay=8.0,- exp_base=2.0,- )+ retry_options=HttpRetryOptions(attempts=1))self.client = genai.Client(**self._client_kwargs)self.task_type = task_type@@ -213,14 +208,10 @@ class GeminiDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- result = (- _call()- if _HTTP_RETRY_AVAILABLE- else self._run_with_retry(- _call,- logger=logger,- operation_name="Gemini embedding",- )+ result = self._run_once(+ _call,+ logger=logger,+ operation_name="Gemini embedding",)# Estimate token usageestimated_tokens = self._estimate_tokens(text)@@ -262,7 +253,7 @@ class GeminiDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="Gemini async embedding",diff --git a/openviking/models/embedder/jina_embedders.py b/openviking/models/embedder/jina_embedders.pyindex 91bbf6911..74629dd81 100644--- a/openviking/models/embedder/jina_embedders.py+++ b/openviking/models/embedder/jina_embedders.py@@ -126,6 +126,7 @@ class JinaDenseEmbedder(DenseEmbedderBase):self.client = openai.OpenAI(api_key=self.api_key,base_url=self.api_base,+ max_retries=0,)self._async_client_cache = LoopScopedAsyncClientCache()@@ -168,6 +169,7 @@ class JinaDenseEmbedder(DenseEmbedderBase):lambda: openai.AsyncOpenAI(api_key=self.api_key,base_url=self.api_base,+ max_retries=0,))@@ -202,7 +204,7 @@ class JinaDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- result = self._run_with_retry(+ result = self._run_once(_call,logger=logger,operation_name="Jina embedding",@@ -230,7 +232,7 @@ class JinaDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=response.data[0].embedding)try:- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="Jina async embedding",diff --git a/openviking/models/embedder/litellm_embedders.py b/openviking/models/embedder/litellm_embedders.pyindex 2630ee0b8..2c0365ed8 100644--- a/openviking/models/embedder/litellm_embedders.py+++ b/openviking/models/embedder/litellm_embedders.py@@ -101,7 +101,7 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):def _build_kwargs(self, is_query: bool = False) -> Dict[str, Any]:"""Build kwargs dict for litellm.embedding() call."""- kwargs: Dict[str, Any] = {"model": self.model_name}+ kwargs: Dict[str, Any] = {"model": self.model_name, "num_retries": 0}if self.api_key:kwargs["api_key"] = self.api_key@@ -191,7 +191,7 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- return self._run_with_retry(+ return self._run_once(_call,logger=logger,operation_name="LiteLLM embedding",@@ -210,7 +210,7 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- return await self._run_with_async_retry(+ return await self._run_once_async(_call,logger=logger,operation_name="LiteLLM async embedding",diff --git a/openviking/models/embedder/local_embedders.py b/openviking/models/embedder/local_embedders.pyindex 350f5b8e0..d4cb56eab 100644--- a/openviking/models/embedder/local_embedders.py+++ b/openviking/models/embedder/local_embedders.py@@ -202,7 +202,7 @@ class LocalDenseEmbedder(DenseEmbedderBase):formatted = self._format_text(text, is_query=is_query)try:- result = self._run_with_retry(+ result = self._run_once(lambda: self._embed_formatted_text(formatted),logger=logger,operation_name="local embedding",diff --git a/openviking/models/embedder/minimax_embedders.py b/openviking/models/embedder/minimax_embedders.pyindex f9ce0b624..9c46f38ea 100644--- a/openviking/models/embedder/minimax_embedders.py+++ b/openviking/models/embedder/minimax_embedders.py@@ -6,8 +6,6 @@ from typing import Any, Dict, List, Optionalimport httpximport requests-from requests.adapters import HTTPAdapter-from urllib3.util.retry import Retryfrom openviking.models.embedder.base import DenseEmbedderBase, EmbedResultfrom openviking.utils.async_client_cache import LoopScopedAsyncClientCache@@ -78,8 +76,7 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):if not self.api_key:raise ValueError("api_key is required for MiniMax embedder")- # Initialize session with retry logic- self.session = self._create_session()+ self.session = requests.Session()self._async_client_cache = LoopScopedAsyncClientCache()# Auto-detect dimension if not provided@@ -90,20 +87,6 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):logger.warning(f"Failed to detect MiniMax dimension: {e}. Defaulting to 1536.")self._dimension = 1536- def _create_session(self) -> requests.Session:- """Create a requests session with retry logic"""- session = requests.Session()- retry_strategy = Retry(- total=self.max_retries,- backoff_factor=0.5,- status_forcelist=[429, 500, 502, 503, 504],- allowed_methods=["POST"],- )- adapter = HTTPAdapter(max_retries=retry_strategy)- session.mount("https://", adapter)- session.mount("http://", adapter)- return session-def _detect_dimension(self) -> int:"""Detect dimension by making an actual API call"""result = self.embed("test")@@ -200,7 +183,11 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):def embed(self, text: str, is_query: bool = False) -> EmbedResult:"""Perform dense embedding on text"""- vectors = self._call_api([text], is_query=is_query)+ vectors = self._run_once(+ lambda: self._call_api([text], is_query=is_query),+ logger=logger,+ operation_name="MiniMax embedding",+ )result = EmbedResult(dense_vector=vectors[0])# Estimate token usageestimated_tokens = self._estimate_tokens(text)@@ -217,7 +204,7 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):vectors = await self._call_api_async([text], is_query=is_query)return EmbedResult(dense_vector=vectors[0])- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="MiniMax async embedding",diff --git a/openviking/models/embedder/openai_embedders.py b/openviking/models/embedder/openai_embedders.pyindex c4c122d20..eec981220 100644--- a/openviking/models/embedder/openai_embedders.py+++ b/openviking/models/embedder/openai_embedders.py@@ -390,7 +390,7 @@ class OpenAIDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- return self._run_with_retry(+ return self._run_once(_call,logger=logger,operation_name="OpenAI embedding",@@ -412,7 +412,7 @@ class OpenAIDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=self._truncate_vector(response.data[0].embedding))try:- return await self._run_with_async_retry(+ return await self._run_once_async(_call,logger=logger,operation_name="OpenAI async embedding",diff --git a/openviking/models/embedder/retry_embedder.py b/openviking/models/embedder/retry_embedder.pynew file mode 100644index 000000000..b7b04aa43--- /dev/null+++ b/openviking/models/embedder/retry_embedder.py@@ -0,0 +1,93 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Retry decorator for one concrete embedding provider."""++from typing import Any, Dict++from openviking.models.embedder.base import EmbedderBase, EmbeddingInput, EmbedResult+from openviking.utils.model_retry import retry_async, retry_sync+from openviking_cli.utils import get_logger++logger = get_logger(__name__)+++class RetryEmbedder(EmbedderBase):+ """Own retries for one concrete embedding target."""++ def __init__(self, inner: EmbedderBase):+ if isinstance(inner, RetryEmbedder):+ raise ValueError("Embedder is already wrapped with RetryEmbedder")+ super().__init__(inner.model_name, inner.config)+ self.inner = inner+ self.provider = inner.provider++ @property+ def query_param(self) -> Any:+ return getattr(self.inner, "query_param", None)++ @property+ def document_param(self) -> Any:+ return getattr(self.inner, "document_param", None)++ def embed(+ self,+ content: EmbeddingInput,+ is_query: bool = False,+ **kwargs: Any,+ ) -> EmbedResult:+ return retry_sync(+ lambda: self.inner.embed(content, is_query=is_query, **kwargs),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} embedding",+ )++ async def embed_async(+ self,+ content: EmbeddingInput,+ is_query: bool = False,+ **kwargs: Any,+ ) -> EmbedResult:+ return await retry_async(+ lambda: self.inner.embed_async(content, is_query=is_query, **kwargs),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} async embedding",+ )++ def prepare_embedding_input(self, content: EmbeddingInput) -> EmbeddingInput:+ return self.inner.prepare_embedding_input(content)++ @property+ def supports_multimodal(self) -> bool:+ return self.inner.supports_multimodal++ @property+ def is_dense(self) -> bool:+ return self.inner.is_dense++ @property+ def is_sparse(self) -> bool:+ return self.inner.is_sparse++ @property+ def is_hybrid(self) -> bool:+ return self.inner.is_hybrid++ def get_dimension(self) -> int:+ dimension_getter = getattr(self.inner, "get_dimension", None)+ if dimension_getter is None:+ raise AttributeError(+ f"{type(self.inner).__name__} has no get_dimension "+ "(sparse embedders have no fixed dimension)"+ )+ return dimension_getter()++ def close(self) -> None:+ self.inner.close()++ def get_token_usage(self) -> Dict[str, Any]:+ return self.inner.get_token_usage()++ def reset_token_usage(self) -> None:+ self.inner.reset_token_usage()diff --git a/openviking/models/embedder/vikingdb_embedders.py b/openviking/models/embedder/vikingdb_embedders.pyindex 5feff642b..c98b41efa 100644--- a/openviking/models/embedder/vikingdb_embedders.py+++ b/openviking/models/embedder/vikingdb_embedders.py@@ -197,7 +197,7 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):return EmbedResult(dense_vector=dense_vector)- result = self._run_with_retry(+ result = self._run_once(_call,logger=logger,operation_name="VikingDB embedding",@@ -224,7 +224,7 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):dense_vector = self._truncate_and_normalize(item["dense_embedding"], self.dimension)return EmbedResult(dense_vector=dense_vector)- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="VikingDB async embedding",@@ -277,7 +277,7 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):return EmbedResult(sparse_vector=sparse_vector)- result = self._run_with_retry(+ result = self._run_once(_call,logger=logger,operation_name="VikingDB sparse embedding",@@ -306,7 +306,7 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):sparse_vector = self._process_sparse_embedding(item["sparse_embedding"])return EmbedResult(sparse_vector=sparse_vector)- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="VikingDB async sparse embedding",@@ -383,7 +383,7 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):return EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector)- result = self._run_with_retry(+ result = self._run_once(_call,logger=logger,operation_name="VikingDB hybrid embedding",@@ -419,7 +419,7 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):sparse_vector = self._process_sparse_embedding(item["sparse_embedding"])return EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector)- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="VikingDB async hybrid embedding",diff --git a/openviking/models/embedder/volcengine_embedders.py b/openviking/models/embedder/volcengine_embedders.pyindex 6149caa77..86b9c0fc0 100644--- a/openviking/models/embedder/volcengine_embedders.py+++ b/openviking/models/embedder/volcengine_embedders.py@@ -81,6 +81,7 @@ async def _measure_embedding_call_async(def _create_sync_ark(kwargs: Dict[str, Any]):client_kwargs = dict(kwargs)+ client_kwargs["max_retries"] = 0http_client = create_optional_sync_httpx_client(client_kwargs.get("base_url"),timeout=60.0,@@ -92,6 +93,7 @@ def _create_sync_ark(kwargs: Dict[str, Any]):def _create_async_ark(kwargs: Dict[str, Any]):client_kwargs = dict(kwargs)+ client_kwargs["max_retries"] = 0http_client = create_optional_async_httpx_client(client_kwargs.get("base_url"),timeout=60.0,@@ -302,7 +304,7 @@ class VolcengineDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- return self._run_with_retry(+ return self._run_once(_embed_call,logger=logger,operation_name="Volcengine embedding",@@ -350,7 +352,7 @@ class VolcengineDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=truncate_and_normalize(vector, self.dimension))try:- return await self._run_with_async_retry(+ return await self._run_once_async(_embed_call,logger=logger,operation_name="Volcengine async embedding",@@ -471,7 +473,7 @@ class VolcengineSparseEmbedder(SparseEmbedderBase):return EmbedResult(sparse_vector=process_sparse_embedding(sparse_vector))try:- return self._run_with_retry(+ return self._run_once(_embed_call,logger=logger,operation_name="Volcengine sparse embedding",@@ -505,7 +507,7 @@ class VolcengineSparseEmbedder(SparseEmbedderBase):return EmbedResult(sparse_vector=process_sparse_embedding(sparse_vector))try:- return await self._run_with_async_retry(+ return await self._run_once_async(_embed_call,logger=logger,operation_name="Volcengine async sparse embedding",@@ -656,7 +658,7 @@ class VolcengineHybridEmbedder(HybridEmbedderBase):)try:- return self._run_with_retry(+ return self._run_once(_embed_call,logger=logger,operation_name="Volcengine hybrid embedding",@@ -694,7 +696,7 @@ class VolcengineHybridEmbedder(HybridEmbedderBase):)try:- return await self._run_with_async_retry(+ return await self._run_once_async(_embed_call,logger=logger,operation_name="Volcengine async hybrid embedding",diff --git a/openviking/models/embedder/voyage_embedders.py b/openviking/models/embedder/voyage_embedders.pyindex e47310b0e..67708efd3 100644--- a/openviking/models/embedder/voyage_embedders.py+++ b/openviking/models/embedder/voyage_embedders.py@@ -82,6 +82,7 @@ class VoyageDenseEmbedder(DenseEmbedderBase):self.client = openai.OpenAI(api_key=self.api_key,base_url=self.api_base,+ max_retries=0,)self._async_client_cache = LoopScopedAsyncClientCache()@@ -98,6 +99,7 @@ class VoyageDenseEmbedder(DenseEmbedderBase):lambda: openai.AsyncOpenAI(api_key=self.api_key,base_url=self.api_base,+ max_retries=0,))@@ -110,7 +112,7 @@ class VoyageDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=vector)try:- result = self._run_with_retry(+ result = self._run_once(_call,logger=logger,operation_name="Voyage embedding",@@ -137,7 +139,7 @@ class VoyageDenseEmbedder(DenseEmbedderBase):return EmbedResult(dense_vector=response.data[0].embedding)try:- result = await self._run_with_async_retry(+ result = await self._run_once_async(_call,logger=logger,operation_name="Voyage async embedding",diff --git a/openviking/models/vlm/backends/litellm_vlm.py b/openviking/models/vlm/backends/litellm_vlm.pyindex ea8ea7dbc..699ad343f 100644--- a/openviking/models/vlm/backends/litellm_vlm.py+++ b/openviking/models/vlm/backends/litellm_vlm.py@@ -18,7 +18,6 @@ from litellm.types.utils import all_litellm_paramsfrom openviking.telemetry import tracerfrom openviking.utils.message_format import format_messages, sanitize_openai_messages-from openviking.utils.model_retry import retry_async, retry_syncfrom openviking.utils.multimodal import redact_image_data_urlsfrom openviking_cli.utils import get_logger@@ -293,6 +292,7 @@ class LiteLLMVLMProvider(VLMBase):"messages": sanitize_openai_messages(messages),"temperature": self.temperature,"timeout": self.timeout,+ "num_retries": 0,}effective_max_tokens = max_tokens if max_tokens is not None else self.max_tokensif effective_max_tokens is not None:@@ -475,12 +475,7 @@ class LiteLLMVLMProvider(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._clean_response(self._extract_content_from_response(response))- return retry_sync(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="LiteLLM VLM completion",- )+ return _call()async def get_completion_async(self,@@ -511,12 +506,7 @@ class LiteLLMVLMProvider(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._clean_response(self._extract_content_from_response(response))- return await retry_async(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="LiteLLM VLM async completion",- )+ return await _call()def get_vision_completion(self,@@ -539,12 +529,7 @@ class LiteLLMVLMProvider(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._clean_response(self._extract_content_from_response(response))- return retry_sync(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="LiteLLM VLM vision completion",- )+ return _call()async def get_vision_completion_async(self,@@ -567,12 +552,7 @@ class LiteLLMVLMProvider(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._clean_response(self._extract_content_from_response(response))- return await retry_async(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="LiteLLM VLM async vision completion",- )+ return await _call()def _update_token_usage_from_response(self,diff --git a/openviking/models/vlm/backends/openai_vlm.py b/openviking/models/vlm/backends/openai_vlm.pyindex 6d3f86b85..7f6023ead 100644--- a/openviking/models/vlm/backends/openai_vlm.py+++ b/openviking/models/vlm/backends/openai_vlm.py@@ -27,8 +27,6 @@ try:except ImportError:openai = None-from openviking.utils.model_retry import retry_async, retry_sync-from ..base import ToolCall, VLMBase, VLMResponsefrom ..registry import DEFAULT_AZURE_API_VERSION@@ -67,7 +65,7 @@ def _build_openai_client_kwargs(else:kwargs = {"api_key": api_key, "base_url": api_base}kwargs["timeout"] = timeout- # OpenViking owns provider retry/backoff via retry_sync/retry_async.+ # RetryVLM owns retry/backoff; the SDK performs exactly one request.kwargs["max_retries"] = 0if extra_headers:kwargs["default_headers"] = extra_headers@@ -358,12 +356,7 @@ class OpenAIVLM(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._extract_completion_content(response, elapsed)- return retry_sync(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="OpenAI VLM completion",- )+ return _call()async def get_completion_async(self,@@ -396,12 +389,7 @@ class OpenAIVLM(VLMBase):+ format_messages(redact_image_data_urls(kwargs.get("messages", []))))- return await retry_async(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="OpenAI VLM async completion",- )+ return await _call()def _detect_image_format(self, data: bytes) -> str:"""Detect image format from magic bytes.@@ -479,12 +467,7 @@ class OpenAIVLM(VLMBase):return self._build_vlm_response(response, has_tools=True)return self._extract_completion_content(response, elapsed)- return retry_sync(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="OpenAI VLM vision completion",- )+ return _call()async def get_vision_completion_async(self,@@ -511,9 +494,4 @@ class OpenAIVLM(VLMBase):return self._build_vlm_response(response, has_tools=True)return await self._extract_completion_content_async(response, elapsed)- return await retry_async(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="OpenAI VLM async vision completion",- )+ return await _call()diff --git a/openviking/models/vlm/backends/volcengine_vlm.py b/openviking/models/vlm/backends/volcengine_vlm.pyindex c62713c31..7ec667c78 100644--- a/openviking/models/vlm/backends/volcengine_vlm.py+++ b/openviking/models/vlm/backends/volcengine_vlm.py@@ -15,7 +15,6 @@ from openviking.models.network import ()from openviking.telemetry import tracerfrom openviking.utils.message_format import format_messages, sanitize_openai_messages-from openviking.utils.model_retry import retry_asyncfrom openviking.utils.multimodal import redact_image_data_urlsfrom openviking_cli.utils import get_logger@@ -294,12 +293,7 @@ class VolcEngineVLM(OpenAIVLM):tracer.info(f"message.content={content}")return content- return await retry_async(- _call,- max_retries=self.max_retries,- logger=logger,- operation_name="VolcEngine VLM async completion",- )+ return await _call()def _detect_image_format(self, data: bytes) -> str:"""Detect image format from magic bytes.diff --git a/openviking/models/vlm/base.py b/openviking/models/vlm/base.pyindex ec52d012d..930b41cee 100644--- a/openviking/models/vlm/base.py+++ b/openviking/models/vlm/base.py@@ -346,8 +346,8 @@ class VLMFactory:"""VLM factory class, creates corresponding VLM instance based on config"""@staticmethod- def create(config: Dict[str, Any]) -> VLMBase:- """Create VLM instance+ def _create_provider(config: Dict[str, Any]) -> VLMBase:+ """Create one concrete VLM provider without an outer retry decorator.Args:config: VLM config, must contain 'provider' field@@ -391,6 +391,13 @@ class VLMFactory:return LiteLLMVLMProvider(config)+ @staticmethod+ def create(config: Dict[str, Any]) -> VLMBase:+ """Create one VLM target with the standard retry owner."""+ from .retry_vlm import RetryVLM++ return RetryVLM(VLMFactory._create_provider(config))+def _annotate_vlm_error(exc: Exception, vlm_instance: "VLMBase") -> None:"""Attach model and api_base info to an exception for better error diagnostics.diff --git a/openviking/models/vlm/retry_vlm.py b/openviking/models/vlm/retry_vlm.pynew file mode 100644index 000000000..d8b01d708--- /dev/null+++ b/openviking/models/vlm/retry_vlm.py@@ -0,0 +1,174 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: AGPL-3.0+"""Retry decorator for ordinary VLM requests."""++from pathlib import Path+from typing import Any, Dict, List, Optional, Union++from openviking.utils.model_retry import retry_async, retry_sync+from openviking_cli.utils import get_logger++from .base import VLMBase, VLMResponse++logger = get_logger(__name__)+++class RetryVLM(VLMBase):+ """Own ordinary request retries for one concrete VLM target."""++ def __init__(self, inner: VLMBase):+ if isinstance(inner, RetryVLM):+ raise ValueError("VLM is already wrapped with RetryVLM")+ super().__init__(inner.config)+ self.inner = inner++ def __getattr__(self, name: str) -> Any:+ return getattr(self.inner, name)++ @property+ def token_tracker(self):+ return self.inner.token_tracker++ def get_token_usage(self) -> Dict[str, Any]:+ return self.inner.get_token_usage()++ def reset_token_usage(self) -> None:+ self.inner.reset_token_usage()++ def update_token_usage(self, *args, **kwargs) -> None:+ self.inner.update_token_usage(*args, **kwargs)++ def record_failed_call(self, *, duration_seconds: float, error: Exception) -> None:+ self.inner.record_failed_call(duration_seconds=duration_seconds, error=error)++ def get_completion(+ self,+ prompt: str = "",+ thinking: Optional[bool] = None,+ tools: Optional[List[Dict[str, Any]]] = None,+ tool_choice: Optional[str] = None,+ messages: Optional[List[Dict[str, Any]]] = None,+ **kwargs: Any,+ ) -> Union[str, VLMResponse]:+ return retry_sync(+ lambda: self.inner.get_completion(+ prompt=prompt,+ thinking=thinking,+ tools=tools,+ tool_choice=tool_choice,+ messages=messages,+ **kwargs,+ ),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} VLM completion",+ )++ async def get_completion_async(+ self,+ prompt: str = "",+ thinking: Optional[bool] = None,+ tools: Optional[List[Dict[str, Any]]] = None,+ tool_choice: Optional[str] = None,+ messages: Optional[List[Dict[str, Any]]] = None,+ max_tokens: Optional[int] = None,+ **kwargs: Any,+ ) -> Union[str, VLMResponse]:+ return await retry_async(+ lambda: self.inner.get_completion_async(+ prompt=prompt,+ thinking=thinking,+ tools=tools,+ tool_choice=tool_choice,+ messages=messages,+ max_tokens=max_tokens,+ **kwargs,+ ),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} VLM async completion",+ )++ def get_vision_completion(+ self,+ prompt: str = "",+ images: Optional[List[Union[str, Path, bytes]]] = None,+ thinking: Optional[bool] = None,+ tools: Optional[List[Dict[str, Any]]] = None,+ tool_choice: Optional[str] = None,+ messages: Optional[List[Dict[str, Any]]] = None,+ **kwargs: Any,+ ) -> Union[str, VLMResponse]:+ return retry_sync(+ lambda: self.inner.get_vision_completion(+ prompt=prompt,+ images=images,+ thinking=thinking,+ tools=tools,+ tool_choice=tool_choice,+ messages=messages,+ **kwargs,+ ),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} VLM vision completion",+ )++ async def get_vision_completion_async(+ self,+ prompt: str = "",+ images: Optional[List[Union[str, Path, bytes]]] = None,+ thinking: Optional[bool] = None,+ tools: Optional[List[Dict[str, Any]]] = None,+ tool_choice: Optional[str] = None,+ messages: Optional[List[Dict[str, Any]]] = None,+ **kwargs: Any,+ ) -> Union[str, VLMResponse]:+ return await retry_async(+ lambda: self.inner.get_vision_completion_async(+ prompt=prompt,+ images=images,+ thinking=thinking,+ tools=tools,+ tool_choice=tool_choice,+ messages=messages,+ **kwargs,+ ),+ max_retries=self.max_retries,+ logger=logger,+ operation_name=f"{self.provider} VLM async vision completion",+ )++ def supports_media(+ self,+ *,+ media_type: str,+ filename: str,+ size_bytes: int,+ ) -> bool:+ return self.inner.supports_media(+ media_type=media_type,+ filename=filename,+ size_bytes=size_bytes,+ )++ async def get_media_completion_async(+ self,+ *,+ prompt: str,+ media_path: Path,+ filename: str,+ media_type: str,+ ) -> str:+ return await self.inner.get_media_completion_async(+ prompt=prompt,+ media_path=media_path,+ filename=filename,+ media_type=media_type,+ )++ def is_available(self) -> bool:+ return self.inner.is_available()++ def close(self) -> None:+ self.inner.close()diff --git a/openviking_cli/utils/config/embedding_config.py b/openviking_cli/utils/config/embedding_config.pyindex 723d30639..5f773c86d 100644--- a/openviking_cli/utils/config/embedding_config.py+++ b/openviking_cli/utils/config/embedding_config.py@@ -744,6 +744,7 @@ class EmbeddingConfig(BaseModel):LocalDenseEmbedder,MinimaxDenseEmbedder,OpenAIDenseEmbedder,+ RetryEmbedder,VikingDBDenseEmbedder,VikingDBHybridEmbedder,VikingDBSparseEmbedder,@@ -1021,7 +1022,12 @@ class EmbeddingConfig(BaseModel):"google-genai is not installed. Install it with: pip install openviking[gemini]")params = param_builder(config)- return embedder_class(**params)+ embedder = embedder_class(**params)+ if provider == "local":+ return embedder+ if isinstance(embedder, RetryEmbedder):+ return embedder+ return RetryEmbedder(embedder)def get_embedder(self):"""Get embedder instance based on configuration.diff --git a/openviking_cli/utils/config/vlm_config.py b/openviking_cli/utils/config/vlm_config.pyindex eed0c6ae1..efd452c6e 100644--- a/openviking_cli/utils/config/vlm_config.py+++ b/openviking_cli/utils/config/vlm_config.py@@ -45,6 +45,10 @@ def _bind_token_usage_tracker(instance: Any, tracker: Any) -> None:returnif hasattr(instance, "_token_tracker"):instance._token_tracker = tracker+ inner = getattr(instance, "inner", None)+ if inner is not None:+ _bind_token_usage_tracker(inner, tracker)+ returnif hasattr(instance, "_vlm_instances"):for child in instance._vlm_instances:_bind_token_usage_tracker(child, tracker)diff --git a/tests/unit/test_codex_vlm.py b/tests/unit/test_codex_vlm.pyindex 0808af565..2b1c108a2 100644--- a/tests/unit/test_codex_vlm.py+++ b/tests/unit/test_codex_vlm.py@@ -219,10 +219,14 @@ async def test_codex_async_stream_uses_text_deltas_when_completed_output_is_none@patch("openviking.models.vlm.backends.codex_auth.has_codex_auth_available", return_value=True)def test_vlm_config_accepts_codex_without_api_key(_mock_auth_available):+ from openviking.models.vlm.retry_vlm import RetryVLM+config = VLMConfig(provider="openai-codex", model="gpt-5.3-codex")assert config.is_available() is True- assert config.get_vlm_instance().__class__.__name__ == "CodexVLM"+ instance = config.get_vlm_instance()+ assert isinstance(instance, RetryVLM)+ assert instance.inner.__class__.__name__ == "CodexVLM"@patch("openviking.models.vlm.backends.codex_auth.has_codex_auth_available", return_value=True)diff --git a/tests/unit/test_embedding_config_voyage.py b/tests/unit/test_embedding_config_voyage.pyindex eef0f0f27..701cc3633 100644--- a/tests/unit/test_embedding_config_voyage.py+++ b/tests/unit/test_embedding_config_voyage.py@@ -4,7 +4,7 @@import pytest-from openviking.models.embedder import VoyageDenseEmbedder+from openviking.models.embedder import RetryEmbedder, VoyageDenseEmbedderfrom openviking_cli.utils.config.embedding_config import EmbeddingConfig, EmbeddingModelConfig@@ -48,5 +48,6 @@ def test_voyage_get_embedder_returns_voyage_dense_embedder():)embedder = config.get_embedder()- assert isinstance(embedder, VoyageDenseEmbedder)+ assert isinstance(embedder, RetryEmbedder)+ assert isinstance(embedder.inner, VoyageDenseEmbedder)assert embedder.get_dimension() == 1024diff --git a/tests/unit/test_encoding_format_embedding.py b/tests/unit/test_encoding_format_embedding.pyindex 278a3b7df..520b5d2f4 100644--- a/tests/unit/test_encoding_format_embedding.py+++ b/tests/unit/test_encoding_format_embedding.py@@ -15,7 +15,7 @@ from unittest.mock import MagicMock, patchimport pytestfrom pydantic import ValidationError-from openviking.models.embedder import OpenAIDenseEmbedder+from openviking.models.embedder import OpenAIDenseEmbedder, RetryEmbedderfrom openviking_cli.utils.config.embedding_config import EmbeddingConfig, EmbeddingModelConfig@@ -109,8 +109,9 @@ class TestEncodingFormatFactory:encoding_format="float",)embedder = EmbeddingConfig(dense=cfg)._create_embedder("openai", "dense", cfg)- assert isinstance(embedder, OpenAIDenseEmbedder)- assert embedder.encoding_format == "float"+ assert isinstance(embedder, RetryEmbedder)+ assert isinstance(embedder.inner, OpenAIDenseEmbedder)+ assert embedder.inner.encoding_format == "float"@patch("openai.AzureOpenAI")def test_azure_factory_forwards(self, mock_azure_class):@@ -125,8 +126,9 @@ class TestEncodingFormatFactory:encoding_format="float",)embedder = EmbeddingConfig(dense=cfg)._create_embedder("azure", "dense", cfg)- assert isinstance(embedder, OpenAIDenseEmbedder)- assert embedder.encoding_format == "float"+ assert isinstance(embedder, RetryEmbedder)+ assert isinstance(embedder.inner, OpenAIDenseEmbedder)+ assert embedder.inner.encoding_format == "float"@patch("openai.OpenAI")def test_factory_omits_when_unset(self, mock_openai_class):@@ -138,5 +140,6 @@ class TestEncodingFormatFactory:api_key="sk-test",)embedder = EmbeddingConfig(dense=cfg)._create_embedder("openai", "dense", cfg)- assert isinstance(embedder, OpenAIDenseEmbedder)- assert embedder.encoding_format is None+ assert isinstance(embedder, RetryEmbedder)+ assert isinstance(embedder.inner, OpenAIDenseEmbedder)+ assert embedder.inner.encoding_format is Nonediff --git a/tests/unit/test_extra_headers_vlm.py b/tests/unit/test_extra_headers_vlm.pyindex 1eaebcb53..d8c86108e 100644--- a/tests/unit/test_extra_headers_vlm.py+++ b/tests/unit/test_extra_headers_vlm.py@@ -349,17 +349,17 @@ class TestOpenAIVLMClientRetries:assert call_kwargs["max_retries"] == 0@pytest.mark.parametrize(- ("status_code", "message", "expected_attempts"),+ ("status_code", "message"),[- (400, "Total tokens of multi-modal content and text exceed max message tokens.", 1),- (400, "The parameter model is invalid.", 1),- (401, "Unauthorized", 1),- (503, "Service Unavailable", 6),+ (400, "Total tokens of multi-modal content and text exceed max message tokens."),+ (400, "The parameter model is invalid."),+ (401, "Unauthorized"),+ (503, "Service Unavailable"),],)@patch("volcenginesdkarkruntime.AsyncArk")- def test_volcengine_async_client_uses_shared_retry_policy(- self, mock_async_ark_class, status_code, message, expected_attempts+ def test_volcengine_async_client_performs_single_request(+ self, mock_async_ark_class, status_code, message):error = ArkAPIStatusError(f"Error code: {status_code} - {message}",@@ -382,12 +382,11 @@ class TestOpenAIVLMClientRetries:})- with patch("openviking.utils.model_retry.asyncio.sleep", new=AsyncMock()):- with pytest.raises(ArkAPIStatusError) as raised:- asyncio.run(vlm.get_completion_async("hello"))+ with pytest.raises(ArkAPIStatusError) as raised:+ asyncio.run(vlm.get_completion_async("hello"))assert raised.value is error- assert mock_client.chat.completions.create.await_count == expected_attempts+ assert mock_client.chat.completions.create.await_count == 1call_kwargs = mock_async_ark_class.call_args.kwargsassert call_kwargs["timeout"] == 12.0assert call_kwargs["max_retries"] == 0@@ -531,7 +530,7 @@ class TestVLMExtraRequestBody:api_key="sk-test",http_client=httpx.Client(transport=httpx.MockTransport(send)),) as client:- monkeypatch.setattr(vlm, "get_client", lambda: client)+ monkeypatch.setattr(vlm.inner, "get_client", lambda: client)assert vlm.get_completion("hello") == "ok"assert vlm.get_vision_completion("describe", images=[b"\x89PNG\r\n\x1a\n"]) == "ok"@@ -539,7 +538,7 @@ class TestVLMExtraRequestBody:api_key="sk-test",http_client=httpx.AsyncClient(transport=httpx.MockTransport(send)),) as async_client:- monkeypatch.setattr(vlm, "get_async_client", lambda: async_client)+ monkeypatch.setattr(vlm.inner, "get_async_client", lambda: async_client)assert await vlm.get_completion_async("hello") == "ok"assert (await vlm.get_vision_completion_async("describe", images=[b"\x89PNG\r\n\x1a\n"])diff --git a/tests/unit/test_gemini_embedder.py b/tests/unit/test_gemini_embedder.pyindex d0ed804b4..ff33eefb9 100644--- a/tests/unit/test_gemini_embedder.py+++ b/tests/unit/test_gemini_embedder.py@@ -143,6 +143,37 @@ class TestGeminiDenseEmbedderEmbed:with pytest.raises(RuntimeError, match="Gemini embedding failed"):embedder.embed("hello")+ @patch("openviking.models.embedder.gemini_embedders.genai.Client")+ def test_retry_embedder_retries_transient_429(self, mock_client_class, monkeypatch):+ from google.genai.errors import APIError++ from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder+ from openviking.models.embedder.retry_embedder import RetryEmbedder++ monkeypatch.setattr("openviking.utils.model_retry.time.sleep", lambda _delay: None)+ mock_client = mock_client_class.return_value+ mock_response = MagicMock()+ mock_response.status_code = 429+ mock_client.models.embed_content.side_effect = [+ APIError(+ 429,+ {"error": {"message": "Rate limit exceeded. Please retry."}},+ response=mock_response,+ ),+ _make_mock_result([[0.1, 0.2, 0.3]]),+ ]+ inner = GeminiDenseEmbedder(+ "gemini-embedding-2-preview",+ api_key="key",+ dimension=3,+ config={"max_retries": 1},+ )++ result = RetryEmbedder(inner).embed("hello")++ assert result.dense_vector == [0.1, 0.2, 0.3]+ assert mock_client.models.embed_content.call_count == 2+@patch("openviking.models.embedder.gemini_embedders.genai.Client")def test_embed_empty_string_returns_zero_vector(self, mock_client_class):from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder@@ -198,7 +229,7 @@ class TestGeminiErrorMessages:(401, "Invalid API key"),(403, "Permission denied"),(404, "Model not found"),- (429, "Quota exceeded"),+ (429, "Resource exhausted"),(500, "service error"),],)diff --git a/tests/unit/test_kimi_glm_vlm.py b/tests/unit/test_kimi_glm_vlm.pyindex a33d11f19..a4e63e421 100644--- a/tests/unit/test_kimi_glm_vlm.py+++ b/tests/unit/test_kimi_glm_vlm.py@@ -71,8 +71,8 @@ def test_vlm_factory_routes_first_class_kimi_and_glm_providers():kimi_vlm = VLMFactory.create({"provider": "kimi", "api_key": "kimi-key", "model": "kimi-code"})glm_vlm = VLMFactory.create({"provider": "glm", "api_key": "glm-key", "model": "glm-4.6v"})- assert kimi_vlm.__class__.__name__ == "KimiVLM"- assert glm_vlm.__class__.__name__ == "GLMVLM"+ assert kimi_vlm.inner.__class__.__name__ == "KimiVLM"+ assert glm_vlm.inner.__class__.__name__ == "GLMVLM"def test_vlm_config_uses_canonical_provider_names():diff --git a/tests/unit/test_litellm_embedder.py b/tests/unit/test_litellm_embedder.pyindex aded09e9c..cc341897d 100644--- a/tests/unit/test_litellm_embedder.py+++ b/tests/unit/test_litellm_embedder.py@@ -206,6 +206,7 @@ class TestLiteLLMEmbeddingFactory:"""EmbeddingConfig factory should create LiteLLMDenseEmbedder for provider='litellm'."""mock_litellm.embedding.return_value = _mock_litellm_response()+ from openviking.models.embedder import RetryEmbedderfrom openviking.models.embedder.litellm_embedders import LiteLLMDenseEmbeddercfg = EmbeddingModelConfig(@@ -217,10 +218,11 @@ class TestLiteLLMEmbeddingFactory:)embedder = EmbeddingConfig(dense=cfg)._create_embedder("litellm", "dense", cfg)- assert isinstance(embedder, LiteLLMDenseEmbedder)+ assert isinstance(embedder, RetryEmbedder)+ assert isinstance(embedder.inner, LiteLLMDenseEmbedder)assert embedder.model_name == "openai/text-embedding-3-small"- assert embedder.api_key == "test-key"- assert embedder.api_base == "https://openrouter.ai/api/v1"+ assert embedder.inner.api_key == "test-key"+ assert embedder.inner.api_base == "https://openrouter.ai/api/v1"@patch("openviking.models.embedder.litellm_embedders.litellm")def test_factory_forwards_query_document_params(self, mock_litellm):diff --git a/tests/unit/test_retry_embedder.py b/tests/unit/test_retry_embedder.pynew file mode 100644index 000000000..6ce38860b--- /dev/null+++ b/tests/unit/test_retry_embedder.py@@ -0,0 +1,297 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0++import asyncio++import pytest++from openviking.concurrency import AsyncSemaphore+from openviking.config.embedding import _bind_account_state+from openviking.models.embedder.base import (+ CompositeHybridEmbedder,+ DenseEmbedderBase,+ EmbedResult,+ FailoverEmbedder,+ SparseEmbedderBase,+)+from openviking.models.embedder.retry_embedder import RetryEmbedder+from openviking.models.vlm.token_usage import TokenUsageTracker+from openviking_cli.utils.config.embedding_config import (+ EmbeddingConfig,+ EmbeddingCredential,+ EmbeddingModelConfig,+)+++class ProviderError(RuntimeError):+ def __init__(self, status_code: int):+ super().__init__(f"HTTP {status_code}")+ self.status_code = status_code+++class FakeDenseEmbedder(DenseEmbedderBase):+ def __init__(self, outcomes, *, max_retries: int = 2):+ super().__init__(+ "fake-dense",+ {"provider": "fake", "max_retries": max_retries, "max_concurrent": 1},+ )+ self.provider = "fake"+ self.outcomes = list(outcomes)+ self.calls = 0+ self.closed = False++ def _next(self):+ self.calls += 1+ outcome = self.outcomes.pop(0)+ if isinstance(outcome, BaseException):+ raise outcome+ return EmbedResult(dense_vector=outcome)++ def embed(self, content, is_query=False, **kwargs):+ return self._run_once(self._next)++ async def embed_async(self, content, is_query=False, **kwargs):+ return await self._run_once_async(+ self._next_async,+ operation_name="fake embedding",+ )++ async def _next_async(self):+ return self._next()++ def get_dimension(self):+ return 2++ @property+ def supports_multimodal(self):+ return True++ def close(self):+ self.closed = True+++class FakeSparseEmbedder(SparseEmbedderBase):+ def __init__(self, outcomes, *, max_retries: int = 2):+ super().__init__("fake-sparse", {"provider": "fake", "max_retries": max_retries})+ self.provider = "fake"+ self.outcomes = list(outcomes)+ self.calls = 0++ def _next(self):+ self.calls += 1+ outcome = self.outcomes.pop(0)+ if isinstance(outcome, BaseException):+ raise outcome+ return EmbedResult(sparse_vector=outcome)++ def embed(self, content, is_query=False, **kwargs):+ return self._next()++ async def embed_async(self, content, is_query=False, **kwargs):+ return self._next()++[email protected](autouse=True)+def no_retry_sleep(monkeypatch):+ monkeypatch.setattr("openviking.utils.model_retry.time.sleep", lambda _delay: None)+++def test_retry_embedder_retries_transient_and_preserves_capabilities():+ inner = FakeDenseEmbedder([ProviderError(503), [0.1, 0.2]])+ embedder = RetryEmbedder(inner)++ result = embedder.embed("query", is_query=True)++ assert result.dense_vector == [0.1, 0.2]+ assert inner.calls == 2+ assert embedder.provider == "fake"+ assert embedder.get_dimension() == 2+ assert embedder.is_dense is True+ assert embedder.is_sparse is False+ assert embedder.is_hybrid is False+ assert embedder.supports_multimodal is True++[email protected]("status_code", [400, 401])+def test_retry_embedder_does_not_retry_permanent_or_auth_errors(status_code):+ error = ProviderError(status_code)+ inner = FakeDenseEmbedder([error, [0.1, 0.2]])++ with pytest.raises(ProviderError) as raised:+ RetryEmbedder(inner).embed("query")++ assert raised.value is error+ assert inner.calls == 1+++def test_retry_embedder_uses_max_retries_as_additional_attempts():+ errors = [ProviderError(503) for _ in range(3)]+ inner = FakeDenseEmbedder(errors, max_retries=2)++ with pytest.raises(ProviderError) as raised:+ RetryEmbedder(inner).embed("query")++ assert raised.value is errors[-1]+ assert inner.calls == 3+++def test_retry_embedder_sparse_dimension_remains_unsupported():+ embedder = RetryEmbedder(FakeSparseEmbedder([{"term": 1.0}]))++ assert embedder.is_sparse is True+ with pytest.raises(AttributeError, match="no get_dimension"):+ embedder.get_dimension()+++async def test_retry_releases_semaphore_before_backoff(monkeypatch):+ inner = FakeDenseEmbedder([ProviderError(503), [0.1, 0.2]], max_retries=1)+ semaphore = AsyncSemaphore(1)+ inner._account_semaphore = semaphore+ observed_values = []++ async def observe_backoff(_delay):+ observed_values.append(semaphore._value)++ monkeypatch.setattr("openviking.utils.model_retry.asyncio.sleep", observe_backoff)++ result = await RetryEmbedder(inner).embed_async("query")++ assert result.dense_vector == [0.1, 0.2]+ assert inner.calls == 2+ assert observed_values == [1]+ assert semaphore._value == 1+++async def test_cancelled_attempt_releases_semaphore():+ started = asyncio.Event()++ class BlockingDenseEmbedder(FakeDenseEmbedder):+ async def _next_async(self):+ self.calls += 1+ started.set()+ await asyncio.Event().wait()++ inner = BlockingDenseEmbedder([], max_retries=2)+ semaphore = AsyncSemaphore(1)+ inner._account_semaphore = semaphore+ task = asyncio.create_task(RetryEmbedder(inner).embed_async("query"))+ await started.wait()+ task.cancel()++ with pytest.raises(asyncio.CancelledError):+ await task++ assert inner.calls == 1+ assert semaphore._value == 1+++async def test_composite_retries_only_failed_branch(monkeypatch):+ async def no_sleep(_delay):+ return None++ monkeypatch.setattr("openviking.utils.model_retry.asyncio.sleep", no_sleep)+ dense = FakeDenseEmbedder([[0.1, 0.2]])+ sparse = FakeSparseEmbedder([ProviderError(503), {"term": 1.0}], max_retries=1)+ composite = CompositeHybridEmbedder(RetryEmbedder(dense), RetryEmbedder(sparse))++ result = await composite.embed_async("query")++ assert result.dense_vector == [0.1, 0.2]+ assert result.sparse_vector == {"term": 1.0}+ assert dense.calls == 1+ assert sparse.calls == 2+++def test_failover_runs_after_current_credential_retry_exhaustion():+ primary = FakeDenseEmbedder([ProviderError(503), ProviderError(503)], max_retries=1)+ backup = FakeDenseEmbedder([[0.3, 0.4]], max_retries=1)+ failover = FailoverEmbedder(+ [RetryEmbedder(primary), RetryEmbedder(backup)],+ ["primary", "backup"],+ )++ result = failover.embed("query")++ assert result.dense_vector == [0.3, 0.4]+ assert primary.calls == 2+ assert backup.calls == 1+++def test_account_state_reaches_retry_inner_and_close_is_delegated_once():+ inner = FakeDenseEmbedder([[0.1, 0.2]])+ embedder = RetryEmbedder(inner)+ semaphore = AsyncSemaphore(2)+ tracker = TokenUsageTracker()++ _bind_account_state(embedder, semaphore, tracker, "account-a")++ assert embedder._account_semaphore is semaphore+ assert inner._account_semaphore is semaphore+ assert inner._token_tracker is tracker+ assert inner._account_id == "account-a"+ embedder.close()+ assert inner.closed is True+++def test_factory_wraps_single_remote_provider(monkeypatch):+ monkeypatch.setattr("openai.OpenAI", lambda **_kwargs: object())+ config = EmbeddingConfig(+ dense=EmbeddingModelConfig(+ provider="openai",+ model="text-embedding-3-small",+ api_key="key",+ dimension=2,+ )+ )++ embedder = config.get_embedder()++ assert isinstance(embedder, RetryEmbedder)+ assert embedder.inner.__class__.__name__ == "OpenAIDenseEmbedder"+++def test_factory_places_retry_inside_failover(monkeypatch):+ monkeypatch.setattr("openai.OpenAI", lambda **_kwargs: object())+ config = EmbeddingConfig(+ dense=EmbeddingModelConfig(+ provider="openai",+ model="text-embedding-3-small",+ dimension=2,+ credentials=[+ EmbeddingCredential(id="primary", api_key="key-a"),+ EmbeddingCredential(id="backup", api_key="key-b"),+ ],+ )+ )++ embedder = config.get_embedder()++ assert isinstance(embedder, FailoverEmbedder)+ assert all(isinstance(child, RetryEmbedder) for child in embedder._embedders)+++def test_factory_places_retry_inside_composite(monkeypatch):+ monkeypatch.setattr("openai.OpenAI", lambda **_kwargs: object())+ monkeypatch.setattr("volcenginesdkarkruntime.Ark", lambda **_kwargs: object())+ config = EmbeddingConfig(+ dense=EmbeddingModelConfig(+ provider="openai",+ model="text-embedding-3-small",+ api_key="openai-key",+ dimension=2,+ ),+ sparse=EmbeddingModelConfig(+ provider="volcengine",+ model="doubao-embedding",+ api_key="ark-key",+ ),+ )++ embedder = config.get_embedder()++ assert isinstance(embedder, CompositeHybridEmbedder)+ assert isinstance(embedder.dense_embedder, RetryEmbedder)+ assert isinstance(embedder.sparse_embedder, RetryEmbedder)diff --git a/tests/unit/test_retry_vlm.py b/tests/unit/test_retry_vlm.pynew file mode 100644index 000000000..c14a21e02--- /dev/null+++ b/tests/unit/test_retry_vlm.py@@ -0,0 +1,232 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0++import asyncio+from pathlib import Path++import pytest++from openviking.models.vlm.base import MultiCredentialVLM, VLMBase, VLMFactory+from openviking.models.vlm.retry_vlm import RetryVLM+from openviking_cli.utils.config.vlm_config import VLMConfig+++class ProviderError(RuntimeError):+ def __init__(self, status_code: int):+ messages = {+ 400: "400 invalid parameter",+ 401: "401 unauthorized",+ 503: "503 service unavailable",+ }+ super().__init__(messages[status_code])+ self.status_code = status_code+++class FakeVLM(VLMBase):+ def __init__(self, outcomes, *, media_outcomes=None):+ super().__init__({"provider": "fake", "model": "fake-model", "max_retries": 2})+ self.outcomes = list(outcomes)+ self.media_outcomes = list(media_outcomes or ["media"])+ self.calls = []+ self.closed = False++ def _next(self, method, kwargs):+ self.calls.append((method, kwargs))+ outcome = self.outcomes.pop(0)+ if isinstance(outcome, Exception):+ raise outcome+ return outcome++ def get_completion(self, **kwargs):+ return self._next("text", kwargs)++ async def get_completion_async(self, **kwargs):+ return self._next("async_text", kwargs)++ def get_vision_completion(self, **kwargs):+ return self._next("vision", kwargs)++ async def get_vision_completion_async(self, **kwargs):+ return self._next("async_vision", kwargs)++ def supports_media(self, **kwargs):+ return True++ async def get_media_completion_async(self, **kwargs):+ self.calls.append(("media", kwargs))+ outcome = self.media_outcomes.pop(0)+ if isinstance(outcome, Exception):+ raise outcome+ return outcome++ def close(self):+ self.closed = True++[email protected](autouse=True)+def no_retry_sleep(monkeypatch):+ async def _no_sleep(_delay):+ return None++ monkeypatch.setattr("openviking.utils.model_retry.time.sleep", lambda _delay: None)+ monkeypatch.setattr("openviking.utils.model_retry.asyncio.sleep", _no_sleep)+++ ("method", "expected_method"),+ [+ ("get_completion", "text"),+ ("get_vision_completion", "vision"),+ ],+)+def test_retry_vlm_retries_sync_transient_failures(method, expected_method):+ inner = FakeVLM([ProviderError(503), "ok"])+ vlm = RetryVLM(inner)++ result = getattr(vlm, method)(prompt="hello")++ assert result == "ok"+ assert [name for name, _kwargs in inner.calls] == [expected_method, expected_method]+++ ("method", "expected_method"),+ [+ ("get_completion_async", "async_text"),+ ("get_vision_completion_async", "async_vision"),+ ],+)+async def test_retry_vlm_retries_async_transient_failures(method, expected_method):+ inner = FakeVLM([ProviderError(503), "ok"])+ vlm = RetryVLM(inner)++ result = await getattr(vlm, method)(prompt="hello")++ assert result == "ok"+ assert [name for name, _kwargs in inner.calls] == [expected_method, expected_method]++[email protected]("status_code", [400, 401])+def test_retry_vlm_does_not_retry_permanent_or_auth_errors(status_code):+ error = ProviderError(status_code)+ inner = FakeVLM([error, "unexpected"])++ with pytest.raises(ProviderError) as raised:+ RetryVLM(inner).get_completion(prompt="hello")++ assert raised.value is error+ assert len(inner.calls) == 1+++def test_retry_vlm_honors_zero_retries():+ inner = FakeVLM([ProviderError(503), "unexpected"])+ inner.max_retries = 0+ vlm = RetryVLM(inner)+ vlm.max_retries = 0++ with pytest.raises(ProviderError):+ vlm.get_completion(prompt="hello")++ assert len(inner.calls) == 1+++def test_retry_vlm_uses_max_retries_as_additional_attempts():+ errors = [ProviderError(503) for _ in range(3)]+ inner = FakeVLM(errors)++ with pytest.raises(ProviderError) as raised:+ RetryVLM(inner).get_completion(prompt="hello")++ assert raised.value is errors[-1]+ assert len(inner.calls) == 3+++async def test_retry_vlm_does_not_retry_cancelled_request():+ started = asyncio.Event()++ class BlockingVLM(FakeVLM):+ async def get_completion_async(self, **kwargs):+ self.calls.append(("async_text", kwargs))+ started.set()+ await asyncio.Event().wait()++ inner = BlockingVLM([])+ task = asyncio.create_task(RetryVLM(inner).get_completion_async(prompt="hello"))+ await started.wait()+ task.cancel()++ with pytest.raises(asyncio.CancelledError):+ await task++ assert len(inner.calls) == 1+++async def test_retry_vlm_forwards_extension_kwargs_and_does_not_retry_media(tmp_path):+ media_error = ProviderError(503)+ inner = FakeVLM(["ok"], media_outcomes=[media_error, "unexpected"])+ vlm = RetryVLM(inner)++ assert await vlm.get_completion_async(prompt="hello", reasoning_effort="high") == "ok"+ assert inner.calls[0][1]["reasoning_effort"] == "high"++ media_path = tmp_path / "clip.mp4"+ media_path.write_bytes(b"media")+ with pytest.raises(ProviderError) as raised:+ await vlm.get_media_completion_async(+ prompt="describe",+ media_path=Path(media_path),+ filename="clip.mp4",+ media_type="video/mp4",+ )++ assert raised.value is media_error+ assert [name for name, _kwargs in inner.calls].count("media") == 1+++def test_retry_vlm_delegates_token_tracker_and_close():+ inner = FakeVLM(["ok"])+ vlm = RetryVLM(inner)++ assert vlm.token_tracker is inner.token_tracker+ vlm.close()+ assert inner.closed is True+++def test_vlm_factory_wraps_provider_with_standard_retry():+ config = {"provider": "kimi", "api_key": "key", "model": "kimi-code"}++ standard = VLMFactory.create(config)++ assert isinstance(standard, RetryVLM)+ assert standard.inner.__class__.__name__ == "KimiVLM"+++def test_vlm_config_wraps_each_credential_inside_failover():+ config = VLMConfig(+ model="kimi-code",+ credentials=[+ {+ "id": "primary",+ "provider": "kimi",+ "api_key": "primary-key",+ },+ {+ "id": "backup",+ "provider": "glm",+ "api_key": "backup-key",+ "model": "glm-4.6v",+ },+ ],+ )++ instance = config.get_vlm_instance()++ assert isinstance(instance, MultiCredentialVLM)+ assert all(isinstance(child, RetryVLM) for child in instance._vlm_instances)+ assert [child.inner.__class__.__name__ for child in instance._vlm_instances] == [+ "KimiVLM",+ "GLMVLM",+ ]