Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

refactor(model): 统一 VLM 与 Embedding 重试策略 (#5950)

hezhang-1216b15426b28571
diff --git a/openviking/config/embedding.py b/openviking/config/embedding.py
index d68397097..656bfaa73 100644
--- a/openviking/config/embedding.py
+++ b/openviking/config/embedding.py
@@ -13,6 +13,7 @@ from openviking.concurrency import AsyncSemaphore
from openviking.config.scope import ScopeKind
from openviking.config.vector import AccountVectorConfigResolver, VectorRuntimeSettings
from openviking.models.embedder.base import EmbedderBase
+from openviking.models.embedder.retry_embedder import RetryEmbedder
from openviking.models.vlm.token_usage import TokenUsageTracker
from openviking.service.task_tracker_concurrency import KeyedAsyncLockPool
from 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__.py
index 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 installed
from openviking.models.embedder.minimax_embedders import MinimaxDenseEmbedder
from openviking.models.embedder.openai_embedders import OpenAIDenseEmbedder
+from openviking.models.embedder.retry_embedder import RetryEmbedder
from 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.py
index efb9ec136..329ede0b8 100644
--- a/openviking/models/embedder/base.py
+++ b/openviking/models/embedder/base.py
@@ -21,8 +21,6 @@ from openviking.utils.exceptions import AllCredentialsFailedError
from 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()
@property
def is_dense(self) -> bool:
diff --git a/openviking/models/embedder/cohere_embedders.py b/openviking/models/embedder/cohere_embedders.py
index 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 usage
estimated_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.py
index 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: httpx
self._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.py
index 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 usage
estimated_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.py
index 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.py
index 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.py
index 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.py
index 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, Optional
import httpx
import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
from openviking.models.embedder.base import DenseEmbedderBase, EmbedResult
from 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 usage
estimated_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.py
index 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.py
new file mode 100644
index 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.py
index 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.py
index 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"] = 0
http_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"] = 0
http_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.py
index 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.py
index 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_params
from openviking.telemetry import tracer
from openviking.utils.message_format import format_messages, sanitize_openai_messages
-from openviking.utils.model_retry import retry_async, retry_sync
from openviking.utils.multimodal import redact_image_data_urls
from 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_tokens
if 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.py
index 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, VLMResponse
from ..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"] = 0
if 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.py
index 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 tracer
from openviking.utils.message_format import format_messages, sanitize_openai_messages
-from openviking.utils.model_retry import retry_async
from openviking.utils.multimodal import redact_image_data_urls
from 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.py
index 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.py
new file mode 100644
index 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.py
index 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.py
index 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:
return
if hasattr(instance, "_token_tracker"):
instance._token_tracker = tracker
+ inner = getattr(instance, "inner", None)
+ if inner is not None:
+ _bind_token_usage_tracker(inner, tracker)
+ return
if 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.py
index 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.py
index 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, VoyageDenseEmbedder
from 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() == 1024
diff --git a/tests/unit/test_encoding_format_embedding.py b/tests/unit/test_encoding_format_embedding.py
index 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, patch
import pytest
from pydantic import ValidationError
-from openviking.models.embedder import OpenAIDenseEmbedder
+from openviking.models.embedder import OpenAIDenseEmbedder, RetryEmbedder
from 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 None
diff --git a/tests/unit/test_extra_headers_vlm.py b/tests/unit/test_extra_headers_vlm.py
index 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 == 1
call_kwargs = mock_async_ark_class.call_args.kwargs
assert call_kwargs["timeout"] == 12.0
assert 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.py
index 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.py
index 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.py
index 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 RetryEmbedder
from openviking.models.embedder.litellm_embedders import LiteLLMDenseEmbedder
cfg = 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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",
+ ]