Skip to content

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

Revert "feat(embedder): Gemini Embedding 2 multimodal support (text + image/video/audio/PDF) (#607)" (#703)

Qin Haojieae35f46c7582
diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.md
index 15609f402..7c2779b60 100644
--- a/docs/en/guides/01-configuration.md
+++ b/docs/en/guides/01-configuration.md
@@ -87,32 +87,6 @@ Create `~/.openviking/ov.conf` in your project directory:
</details>
-<details>
-<summary><b>Google Gemini (Multimodal)</b></summary>
-
-```json
-{
- "embedding": {
- "dense": {
- "provider": "gemini",
- "api_key": "your-google-api-key",
- "model": "gemini-embedding-2-preview",
- "dimension": 3072,
- "task_type": "RETRIEVAL_DOCUMENT"
- }
- }
-}
-```
-
-Supports text, images (PNG/JPEG/GIF/WebP), video (MP4/MOV/AVI/MKV/FLV/WMV/MPEG), audio (WAV/MP3/AIFF/AAC/OGG/FLAC), and PDF.
-Get your API key at https://aistudio.google.com/app/apikey
-
-| Model | Dimension | Input Types | Token Limit |
-|-------|-----------|-------------|-------------|
-| `gemini-embedding-2-preview` | 128–3072 (default 3072) | text + image + video + audio + PDF | 8192 |
-
-</details>
-
## Configuration Sections
### embedding
@@ -141,7 +115,7 @@ Embedding model configuration for vector search, supporting dense, sparse, and h
| Parameter | Type | Description |
|-----------|------|-------------|
| `max_concurrent` | int | Maximum concurrent embedding requests (`embedding.max_concurrent`, default: `10`) |
-| `provider` | str | `"volcengine"`, `"openai"`, `"vikingdb"`, `"jina"`, `"gemini"` or `"gemini"` |
+| `provider` | str | `"volcengine"`, `"openai"`, `"vikingdb"`, `"jina"`, or `"voyage"` |
| `api_key` | str | API key |
| `model` | str | Model name |
| `dimension` | int | Vector dimension. For Voyage, this maps to `output_dimension` |
@@ -162,7 +136,6 @@ With `input: "multimodal"`, OpenViking can embed text, images (PNG, JPG, etc.),
- `volcengine`: Volcengine Embedding API
- `vikingdb`: VikingDB Embedding API
- `jina`: Jina AI Embedding API
-- `gemini`: Google Gemini Embedding API
- `voyage`: Voyage AI Embedding API
**vikingdb provider example:**
@@ -203,22 +176,6 @@ Available Jina models:
Get your API key at https://jina.ai
-**gemini provider example:**
-
-```json
-{
- "embedding": {
- "dense": {
- "provider": "gemini",
- "api_key": "your-google-api-key",
- "model": "gemini-embedding-2-preview",
- "dimension": 3072,
- "task_type": "RETRIEVAL_DOCUMENT"
- }
- }
-}
-```
-
**voyage provider example:**
```json
diff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.md
index 02b551b1f..889c737ab 100644
--- a/docs/zh/guides/01-configuration.md
+++ b/docs/zh/guides/01-configuration.md
@@ -92,32 +92,6 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支
</details>
-<details>
-<summary><b>Google Gemini (Multimodal)</b></summary>
-
-```json
-{
- "embedding": {
- "dense": {
- "provider": "gemini",
- "api_key": "your-google-api-key",
- "model": "gemini-embedding-2-preview",
- "dimension": 3072,
- "task_type": "RETRIEVAL_DOCUMENT"
- }
- }
-}
-```
-
-支持文本、图片(PNG/JPEG/GIF/WebP)、视频(MP4/MOV/AVI/MKV/FLV/WMV/MPEG)、音频(WAV/MP3/AIFF/AAC/OGG/FLAC)和 PDF 文件。
-在 https://aistudio.google.com/app/apikey 获取您的 API 密钥。
-
-| Model | Dimension | Input Types | Token Limit |
-|-------|-----------|-------------|-------------|
-| `gemini-embedding-2-preview` | 128–3072 (default 3072) | text + image + video + audio + PDF | 8192 |
-
-</details>
-
## 配置部分
### embedding
@@ -147,7 +121,7 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支
| 参数 | 类型 | 说明 |
|------|------|------|
| `max_concurrent` | int | 最大并发 Embedding 请求数(`embedding.max_concurrent`,默认:`10`) |
-| `provider` | str | `"volcengine"`、`"openai"`、`"vikingdb"`、`"jina"` 或 `"gemini"` |
+| `provider` | str | `"volcengine"`、`"openai"`、`"vikingdb"` 或 `"jina"` |
| `api_key` | str | API Key |
| `model` | str | 模型名称 |
| `dimension` | int | 向量维度 |
@@ -168,7 +142,6 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支
- `volcengine`: 火山引擎 Embedding API
- `vikingdb`: VikingDB Embedding API
- `jina`: Jina AI Embedding API
-- `gemini`: Google Gemini Embedding API
**vikingdb provider 配置示例:**
@@ -206,22 +179,6 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支
- `jina-embeddings-v5-text-small`: 677M 参数, 1024 维, 最大序列长度 32768 (默认)
- `jina-embeddings-v5-text-nano`: 239M 参数, 768 维, 最大序列长度 8192
-**gemini provider 配置示例:**
-
-```json
-{
- "embedding": {
- "dense": {
- "provider": "gemini",
- "api_key": "your-google-api-key",
- "model": "gemini-embedding-2-preview",
- "dimension": 3072,
- "task_type": "RETRIEVAL_DOCUMENT"
- }
- }
-}
-```
-
**本地部署 (GGUF/MLX):** Jina 嵌入模型是开源的, 在 [Hugging Face](https://huggingface.co/jinaai) 上提供 GGUF 和 MLX 格式。可以使用任何 OpenAI 兼容的推理服务器 (如 llama.cpp、MLX、vLLM) 本地运行, 并将 `api_base` 指向本地端点:
```json
diff --git a/examples/ov.conf.gemini.example b/examples/ov.conf.gemini.example
deleted file mode 100644
index 0aa36cb6e..000000000
--- a/examples/ov.conf.gemini.example
+++ /dev/null
@@ -1,16 +0,0 @@
-{
- "_comment": [
- "Gemini Embedding 2 alternative configuration for OpenViking.",
- "Set GEMINI_API_KEY in your environment before starting the server.",
- "// Supported: 128–3072 (recommended: 768, 1536, 3072). Default: 3072"
- ],
- "embedding": {
- "dense": {
- "model": "gemini-embedding-2-preview",
- "api_key": "${GEMINI_API_KEY}",
- "dimension": 3072,
- "provider": "gemini",
- "task_type": "RETRIEVAL_DOCUMENT"
- }
- }
-}
diff --git a/openviking/core/context.py b/openviking/core/context.py
index 530a4dd96..763085703 100644
--- a/openviking/core/context.py
+++ b/openviking/core/context.py
@@ -2,7 +2,6 @@
# SPDX-License-Identifier: Apache-2.0
"""Unified context class for OpenViking."""
-from dataclasses import dataclass, field
from datetime import datetime, timezone
from enum import Enum
from typing import Any, Dict, List, Optional
@@ -38,27 +37,14 @@ class ContextLevel(int, Enum):
DETAIL = 2 # L2: detail/content
-@dataclass
-class ModalContent:
- """Media reference for native multimodal embedding.
- uri travels through the queue; data is injected by the handler
- at dequeue time by reading from viking_fs. Never serialized to JSON.
- """
-
- mime_type: str
- uri: str
- data: Optional[bytes] = field(default=None, repr=False)
-
-
class Vectorize:
text: str = ""
# image: str = ""
# video: str = ""
# audio: str = ""
- def __init__(self, text: str = "", media: Optional[ModalContent] = None):
+ def __init__(self, text: str = ""):
self.text = text
- self.media = media
class Context:
diff --git a/openviking/models/embedder/__init__.py b/openviking/models/embedder/__init__.py
index 3fc66a060..b418b8091 100644
--- a/openviking/models/embedder/__init__.py
+++ b/openviking/models/embedder/__init__.py
@@ -12,7 +12,6 @@ Supported providers:
- OpenAI: Dense only
- Volcengine: Dense, Sparse, Hybrid
- Jina AI: Dense only
-- Google Gemini: Dense only (multimodal)
- Voyage AI: Dense only
"""
@@ -24,7 +23,6 @@ from openviking.models.embedder.base import (
HybridEmbedderBase,
SparseEmbedderBase,
)
-from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
from openviking.models.embedder.jina_embedders import JinaDenseEmbedder
from openviking.models.embedder.openai_embedders import OpenAIDenseEmbedder
from openviking.models.embedder.voyage_embedders import VoyageDenseEmbedder
@@ -47,8 +45,6 @@ __all__ = [
"SparseEmbedderBase",
"HybridEmbedderBase",
"CompositeHybridEmbedder",
- # Google Gemini implementations
- "GeminiDenseEmbedder",
# Jina AI implementations
"JinaDenseEmbedder",
# OpenAI implementations
diff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.py
index 77db335ad..858325d5f 100644
--- a/openviking/models/embedder/base.py
+++ b/openviking/models/embedder/base.py
@@ -319,15 +319,6 @@ class DenseEmbedderBase(EmbedderBase):
"""
pass
- @property
- def supports_multimodal(self) -> bool:
- """True when this embedder natively embeds image/audio bytes."""
- return False
-
- def embed_multimodal(self, vectorize: "Vectorize") -> "EmbedResult":
- """Default implementation falls back to text — no breaking change."""
- return self.embed(getattr(vectorize, "text", str(vectorize)))
-
class SparseEmbedderBase(EmbedderBase):
"""Sparse embedder base class that returns sparse vectors
diff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.py
deleted file mode 100644
index 2f003717e..000000000
--- a/openviking/models/embedder/gemini_embedders.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""Gemini Embedding 2 provider using the official google-genai SDK."""
-
-from typing import Any, Dict, List, Optional
-
-from google import genai
-from google.genai import types
-from google.genai.errors import APIError
-
-import logging
-
-try:
- import anyio
- _ANYIO_AVAILABLE = True
-except ImportError:
- _ANYIO_AVAILABLE = False
-
-from openviking.models.embedder.base import (
- DenseEmbedderBase,
- EmbedResult,
- truncate_and_normalize,
-)
-
-logger = logging.getLogger("gemini_embedders")
-
-_TEXT_BATCH_SIZE = 100
-
-# Maximum input tokens per Gemini embedding request (model hard limit).
-_GEMINI_INPUT_TOKEN_LIMIT = 8192
-
-
-class GeminiDenseEmbedder(DenseEmbedderBase):
- """Dense embedder backed by Google's Gemini Embedding 2 model.
-
- Input token limit: 8,192 tokens per request.
- Output dimension: 128–3072 (recommended: 768, 1536, 3072; default: 3072).
- """
-
- KNOWN_DIMENSIONS: Dict[str, int] = {
- "gemini-embedding-2-preview": 3072,
- "gemini-embedding-001": 3072,
- "text-embedding-004": 768,
- }
-
- def __init__(
- self,
- model_name: str = "gemini-embedding-2-preview",
- api_key: Optional[str] = None,
- dimension: Optional[int] = None,
- task_type: Optional[str] = None,
- max_concurrent_batches: int = 10,
- config: Optional[Dict[str, Any]] = None,
- ):
- super().__init__(model_name, config)
- if not api_key:
- raise ValueError("Gemini provider requires api_key")
- self.client = genai.Client(api_key=api_key)
- self.task_type = task_type
- self._dimension = dimension or self.KNOWN_DIMENSIONS.get(model_name, 3072)
- self._max_concurrent_batches = max_concurrent_batches
- config_kwargs: Dict[str, Any] = {"output_dimensionality": self._dimension}
- if self.task_type:
- config_kwargs["task_type"] = self.task_type
- self._embed_config = types.EmbedContentConfig(**config_kwargs)
-
- def embed(self, text: str) -> EmbedResult:
- try:
- result = self.client.models.embed_content(
- model=self.model_name,
- contents=text,
- config=self._embed_config,
- )
- vector = truncate_and_normalize(list(result.embeddings[0].values), self._dimension)
- return EmbedResult(dense_vector=vector)
- except APIError as e:
- raise RuntimeError(f"Gemini embedding failed (code={e.code}): {e}") from e
-
- def embed_batch(self, texts: List[str]) -> List[EmbedResult]:
- if not texts:
- return []
- results: List[EmbedResult] = []
- for i in range(0, len(texts), _TEXT_BATCH_SIZE):
- batch = texts[i : i + _TEXT_BATCH_SIZE]
- try:
- response = self.client.models.embed_content(
- model=self.model_name,
- contents=batch,
- config=self._embed_config,
- )
- for emb in response.embeddings:
- vector = truncate_and_normalize(list(emb.values), self._dimension)
- results.append(EmbedResult(dense_vector=vector))
- except APIError as e:
- logger.warning(
- f"Gemini batch embed failed (code={e.code}) for batch of {len(batch)}, "
- "falling back to individual calls"
- )
- for text in batch:
- results.append(self.embed(text))
- return results
-
- async def async_embed_batch(self, texts: List[str]) -> List[EmbedResult]:
- """Concurrent batch embedding via client.aio — requires anyio to be installed.
-
- Dispatches all 100-text chunks in parallel, bounded by max_concurrent_batches.
- Per-batch APIError falls back to individual embed() calls via thread pool.
- Raises ImportError if anyio is not installed.
- """
- if not _ANYIO_AVAILABLE:
- raise ImportError(
- "anyio is required for async_embed_batch: pip install 'openviking[gemini-async]'"
- )
- if not texts:
- return []
- batches = [texts[i : i + _TEXT_BATCH_SIZE] for i in range(0, len(texts), _TEXT_BATCH_SIZE)]
- results: List[Optional[List[EmbedResult]]] = [None] * len(batches)
- sem = anyio.Semaphore(self._max_concurrent_batches)
-
- async def _embed_one(idx: int, batch: List[str]) -> None:
- async with sem:
- try:
- response = await self.client.aio.models.embed_content(
- model=self.model_name, contents=batch, config=self._embed_config
- )
- results[idx] = [
- EmbedResult(
- dense_vector=truncate_and_normalize(list(emb.values), self._dimension)
- )
- for emb in response.embeddings
- ]
- except APIError as e:
- logger.warning(
- f"Gemini batch embed failed (code={e.code}) for batch of {len(batch)}, "
- "falling back to individual calls"
- )
- results[idx] = [
- await anyio.to_thread.run_sync(self.embed, text) for text in batch
- ]
-
- async with anyio.create_task_group() as tg:
- for idx, batch in enumerate(batches):
- tg.start_soon(_embed_one, idx, batch)
-
- return [r for batch_results in results for r in (batch_results or [])]
-
- def get_dimension(self) -> int:
- return self._dimension
-
- def close(self):
- if hasattr(self.client, "_http_client"):
- try:
- self.client._http_client.close()
- except Exception:
- pass
diff --git a/openviking/storage/collection_schemas.py b/openviking/storage/collection_schemas.py
index d5cbd11ca..c46f2d769 100644
--- a/openviking/storage/collection_schemas.py
+++ b/openviking/storage/collection_schemas.py
@@ -11,7 +11,6 @@ import asyncio
import hashlib
import json
import threading
-import traceback
from contextlib import nullcontext
from dataclasses import dataclass
from typing import Any, Dict, List, Optional
@@ -26,7 +25,6 @@ from openviking.storage.viking_vector_index_backend import VikingVectorIndexBack
from openviking.telemetry import bind_telemetry, resolve_telemetry
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils import get_logger
-from openviking_cli.utils.config import get_openviking_config
from openviking_cli.utils.config.open_viking_config import OpenVikingConfig
logger = get_logger(__name__)
@@ -121,6 +119,8 @@ async def init_context_collection(storage) -> bool:
Returns:
True if collection was created, False if already exists
"""
+ from openviking_cli.utils.config import get_openviking_config
+
config = get_openviking_config()
name = config.storage.vectordb.name
vector_dim = config.embedding.dimension
@@ -154,6 +154,8 @@ class TextEmbeddingHandler(DequeueHandlerBase):
Args:
vikingdb: VikingVectorIndexBackend instance for writing to vector database
"""
+ from openviking_cli.utils.config import get_openviking_config
+
self._vikingdb = vikingdb
self._embedder = None
config = get_openviking_config()
@@ -244,58 +246,11 @@ class TextEmbeddingHandler(DequeueHandlerBase):
# Generate embedding vector(s)
if self._embedder:
try:
- # Multimodal path: read bytes from viking_fs and call embed_multimodal()
- if (
- embedding_msg.media_uri
- and embedding_msg.media_mime_type
- and getattr(self._embedder, "supports_multimodal", False)
- ):
- # Security: validate media_uri matches the record's own URI to prevent
- # forged queue messages from reading arbitrary files.
- expected_uri = embedding_msg.context_data.get("uri", "")
- if embedding_msg.media_uri != expected_uri:
- logger.warning(
- f"media_uri {embedding_msg.media_uri!r} does not match context uri "
- f"{expected_uri!r}, falling back to text embedding"
- )
- result: EmbedResult = await asyncio.to_thread(
- self._embedder.embed, embedding_msg.message
- )
- else:
- # TODO(security): reconstruct a tenant-scoped RequestContext from
- # context_data["account_id"] to prevent ROOT-context file reads.
- try:
- from openviking.core.context import ModalContent, Vectorize
- from openviking.storage.viking_fs import get_viking_fs
-
- viking_fs = get_viking_fs()
- raw_bytes = await viking_fs.read_file_bytes(
- embedding_msg.media_uri, ctx=None
- )
- vectorize = Vectorize(
- text=embedding_msg.message,
- media=ModalContent(
- mime_type=embedding_msg.media_mime_type,
- uri=embedding_msg.media_uri,
- data=raw_bytes,
- ),
- )
- result: EmbedResult = await asyncio.to_thread(
- self._embedder.embed_multimodal, vectorize
- )
- except Exception as e:
- logger.warning(
- f"Multimodal embed failed for {embedding_msg.media_uri!r}: {e}, "
- "falling back to text embedding"
- )
- result: EmbedResult = await asyncio.to_thread(
- self._embedder.embed, embedding_msg.message
- )
- else:
- # Text embed path: blocking HTTP call offloaded to thread pool
- result: EmbedResult = await asyncio.to_thread(
- self._embedder.embed, embedding_msg.message
- )
+ # embed() is a blocking HTTP call; offload to thread pool to avoid
+ # blocking the event loop and allow real concurrency.
+ result: EmbedResult = await asyncio.to_thread(
+ self._embedder.embed, embedding_msg.message
+ )
except Exception as embed_err:
error_msg = f"Failed to generate embedding: {embed_err}"
logger.error(error_msg)
@@ -378,6 +333,8 @@ class TextEmbeddingHandler(DequeueHandlerBase):
self.report_success()
return None
logger.error(f"Failed to write to vector database: {db_err}")
+ import traceback
+
traceback.print_exc()
self._merge_request_stats(embedding_msg.telemetry_id, error_count=1)
self.report_error(str(db_err), data)
@@ -389,6 +346,8 @@ class TextEmbeddingHandler(DequeueHandlerBase):
except Exception as e:
logger.error(f"Error processing embedding message: {e}")
+ import traceback
+
traceback.print_exc()
if embedding_msg is not None:
self._merge_request_stats(embedding_msg.telemetry_id, error_count=1)
diff --git a/openviking/storage/queuefs/embedding_msg.py b/openviking/storage/queuefs/embedding_msg.py
index 868aba3ce..af0e95eea 100644
--- a/openviking/storage/queuefs/embedding_msg.py
+++ b/openviking/storage/queuefs/embedding_msg.py
@@ -1,7 +1,7 @@
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: Apache-2.0
import json
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass
from typing import Any, Dict, List, Optional, Union
from uuid import uuid4
@@ -11,9 +11,6 @@ class EmbeddingMsg:
message: Union[str, List[Dict[str, Any]]]
context_data: Dict[str, Any]
telemetry_id: str = ""
- media_uri: Optional[str] = None
- media_mime_type: Optional[str] = None
- id: str = field(default_factory=lambda: str(uuid4()))
semantic_msg_id: Optional[str] = None
def __init__(
@@ -44,11 +41,9 @@ class EmbeddingMsg:
message=data["message"],
context_data=data["context_data"],
telemetry_id=data.get("telemetry_id", ""),
- media_uri=data.get("media_uri"),
- media_mime_type=data.get("media_mime_type"),
- id=data.get("id", str(uuid4())),
semantic_msg_id=data.get("semantic_msg_id"),
)
+ obj.id = data.get("id", obj.id)
return obj
@classmethod
diff --git a/openviking/storage/queuefs/embedding_msg_converter.py b/openviking/storage/queuefs/embedding_msg_converter.py
index acdb3805b..133d0de6b 100644
--- a/openviking/storage/queuefs/embedding_msg_converter.py
+++ b/openviking/storage/queuefs/embedding_msg_converter.py
@@ -24,9 +24,6 @@ class EmbeddingMsgConverter:
Convert a Context object to EmbeddingMsg.
"""
vectorization_text = context.get_vectorization_text()
- # If text is empty but media is present, use URI as fallback so the message isn't dropped
- if not vectorization_text and getattr(context.vectorize, "media", None) is not None:
- vectorization_text = context.uri or ""
if not vectorization_text:
return None
@@ -72,17 +69,9 @@ class EmbeddingMsgConverter:
resolved_level = int(resolved_level.value)
context_data["level"] = int(resolved_level)
- media_uri = None
- media_mime_type = None
- if getattr(context.vectorize, "media", None) is not None:
- media_uri = context.vectorize.media.uri
- media_mime_type = context.vectorize.media.mime_type
-
embedding_msg = EmbeddingMsg(
message=vectorization_text,
context_data=context_data,
telemetry_id=get_current_telemetry().telemetry_id,
- media_uri=media_uri,
- media_mime_type=media_mime_type,
)
return embedding_msg
diff --git a/openviking/storage/queuefs/semantic_processor.py b/openviking/storage/queuefs/semantic_processor.py
index c393c2669..b4c9ac5c6 100644
--- a/openviking/storage/queuefs/semantic_processor.py
+++ b/openviking/storage/queuefs/semantic_processor.py
@@ -1022,14 +1022,6 @@ class SemanticProcessor(DequeueHandlerBase):
"""Vectorize a single file using its content or summary."""
from openviking.utils.embedding_utils import vectorize_file
- try:
- embedding_provider = getattr(
- getattr(get_openviking_config().embedding, "dense", None), "provider", None
- )
- except Exception as e:
- logger.warning("Failed to resolve embedding provider; multimodal path disabled: %s", e, exc_info=True)
- embedding_provider = None
-
active_ctx = ctx or self._current_ctx
await vectorize_file(
file_path=file_path,
@@ -1037,6 +1029,5 @@ class SemanticProcessor(DequeueHandlerBase):
parent_uri=parent_uri,
context_type=context_type,
ctx=active_ctx,
- embedding_provider=embedding_provider,
semantic_msg_id=semantic_msg_id,
)
diff --git a/openviking/utils/embedding_utils.py b/openviking/utils/embedding_utils.py
index 77f377192..9a2f9d2d5 100644
--- a/openviking/utils/embedding_utils.py
+++ b/openviking/utils/embedding_utils.py
@@ -19,52 +19,6 @@ from openviking_cli.utils import VikingURI, get_logger
logger = get_logger(__name__)
-_IMAGE_MIME_MAP = {
- ".jpg": "image/jpeg",
- ".jpeg": "image/jpeg",
- ".png": "image/png",
- ".gif": "image/gif",
- ".webp": "image/webp",
- ".bmp": "image/bmp",
- ".svg": "image/svg+xml",
-}
-
-_MIME_MAP_VIDEO = {
- ".mp4": "video/mp4",
- ".mpeg": "video/mpeg",
- ".mov": "video/mov",
- ".avi": "video/avi",
- ".webm": "video/webm",
- ".wmv": "video/wmv",
- ".3gpp": "video/3gpp",
-}
-_MIME_MAP_AUDIO = {
- ".mp3": "audio/mp3",
- ".mpeg": "audio/mpeg",
- ".wav": "audio/wav",
- ".ogg": "audio/ogg",
- ".flac": "audio/flac",
-}
-_MIME_MAP_PDF = {
- ".pdf": "application/pdf",
-}
-
-def _infer_image_mime(file_name: str) -> Optional[str]:
- """Return MIME type for image file by extension, or None if unknown."""
- ext = os.path.splitext(file_name.lower())[1]
- return _IMAGE_MIME_MAP.get(ext)
-
-
-def _infer_media_mime(file_name: str) -> Optional[str]:
- """Return MIME type for any Gemini-supported media (image/video/audio/PDF), or None."""
- ext = os.path.splitext(file_name.lower())[1]
- return (
- _IMAGE_MIME_MAP.get(ext)
- or _MIME_MAP_VIDEO.get(ext)
- or _MIME_MAP_AUDIO.get(ext)
- or _MIME_MAP_PDF.get(ext)
- )
-
async def _decrement_embedding_tracker(semantic_msg_id: Optional[str], count: int) -> None:
if not semantic_msg_id or count <= 0:
@@ -258,7 +212,6 @@ async def vectorize_file(
parent_uri: str,
context_type: str = "resource",
ctx: Optional[RequestContext] = None,
- embedding_provider: Optional[str] = None,
semantic_msg_id: Optional[str] = None,
) -> None:
"""
@@ -294,8 +247,7 @@ async def vectorize_file(
)
content_type = get_resource_content_type(file_name)
- is_pdf = os.path.splitext(file_name.lower())[1] == ".pdf"
- if content_type is None and not is_pdf:
+ if content_type is None:
# Unsupported file type: fall back to summary if available
if summary:
logger.warning(
@@ -316,26 +268,15 @@ async def vectorize_file(
context.set_vectorize(Vectorize(text=content))
except Exception as e:
logger.warning(
- f"Failed to read file content for {file_path}, falling back to summary: {e}",
- exc_info=True,
+ f"Failed to read file content for {file_path}, falling back to summary: {e}"
)
if summary:
context.set_vectorize(Vectorize(text=summary))
else:
logger.warning(f"No summary available for {file_path}, skipping vectorization")
return
- elif content_type in (
- ResourceContentType.IMAGE,
- ResourceContentType.VIDEO,
- ResourceContentType.AUDIO,
- ) or is_pdf:
- if summary:
- context.set_vectorize(Vectorize(text=summary))
- else:
- logger.debug(f"Skipping media file {file_path}: no summary available")
- return
elif summary:
- # Fallback for unrecognized non-text files
+ # For non-text files, use summary
context.set_vectorize(Vectorize(text=summary))
else:
logger.debug(f"Skipping file {file_path} (no text content or summary)")
@@ -360,7 +301,6 @@ async def vectorize_file(
async def index_resource(
uri: str,
ctx: RequestContext,
- embedding_provider: Optional[str] = None,
) -> None:
"""
Build vector index for a resource directory.
@@ -409,11 +349,7 @@ async def index_resource(
# For direct indexing, we might not have summaries.
# We pass empty summary_dict, vectorize_file will try to read content for text files.
await vectorize_file(
- file_path=file_uri,
- summary_dict={"name": file_name},
- parent_uri=uri,
- ctx=ctx,
- embedding_provider=embedding_provider,
+ file_path=file_uri, summary_dict={"name": file_name}, parent_uri=uri, ctx=ctx
)
except Exception as e:
diff --git a/openviking/utils/resource_processor.py b/openviking/utils/resource_processor.py
index 3e0d03b99..bd56a2eae 100644
--- a/openviking/utils/resource_processor.py
+++ b/openviking/utils/resource_processor.py
@@ -84,17 +84,8 @@ class ResourceProcessor:
self, resource_uris: List[str], ctx: RequestContext, **kwargs
) -> Dict[str, Any]:
"""Expose index building as a standalone method."""
- from openviking_cli.utils.config import get_openviking_config
- try:
- ov_config = get_openviking_config()
- embedding_provider = (
- getattr(getattr(getattr(ov_config, "embedding", None), "dense", None), "provider", None)
- )
- except Exception as e:
- logger.warning("Failed to resolve embedding provider; multimodal path disabled: %s", e, exc_info=True)
- embedding_provider = None
for uri in resource_uris:
- await index_resource(uri, ctx, embedding_provider=embedding_provider)
+ await index_resource(uri, ctx)
return {"status": "success", "message": f"Indexed {len(resource_uris)} resources"}
async def summarize(
diff --git a/openviking_cli/utils/config/embedding_config.py b/openviking_cli/utils/config/embedding_config.py
index bf5839744..55dd2a6c2 100644
--- a/openviking_cli/utils/config/embedding_config.py
+++ b/openviking_cli/utils/config/embedding_config.py
@@ -41,14 +41,14 @@ class EmbeddingModelConfig(BaseModel):
provider: Optional[str] = Field(
default="volcengine",
description=(
- "Provider type: 'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'gemini'", 'voyage'. "
+ "Provider type: 'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage'. "
"For OpenRouter or other OpenAI-compatible providers, use 'openai' with "
"api_base and extra_headers."
),
)
backend: Optional[str] = Field(
default="volcengine",
- description="Backend type (Deprecated, use 'provider' instead): 'openai', 'volcengine', 'vikingdb', 'voyage'", 'gemini'",
+ description="Backend type (Deprecated, use 'provider' instead): 'openai', 'volcengine', 'vikingdb', 'voyage'",
)
version: Optional[str] = Field(default=None, description="Model version")
ak: Optional[str] = Field(default=None, description="Access Key ID for VikingDB API")
@@ -59,9 +59,6 @@ class EmbeddingModelConfig(BaseModel):
default=None,
description="Maximum token count per embedding request. If None, uses model default (e.g., 8000 for OpenAI).",
)
- task_type: Optional[str] = Field(
- default=None,
- description="Gemini task type: RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, SEMANTIC_SIMILARITY",
extra_headers: Optional[dict[str, str]] = Field(
default=None,
description=(
@@ -106,10 +103,10 @@ class EmbeddingModelConfig(BaseModel):
if not self.provider:
raise ValueError("Embedding provider is required")
- if self.provider not in ["openai", "volcengine", "vikingdb", "jina", "ollama", "voyage", "gemini"]:
+ if self.provider not in ["openai", "volcengine", "vikingdb", "jina", "ollama", "voyage"]:
raise ValueError(
f"Invalid embedding provider: '{self.provider}'. Must be one of: "
- "'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage'", 'gemini'"
+ "'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage'"
)
# Provider-specific validation
@@ -144,9 +141,6 @@ class EmbeddingModelConfig(BaseModel):
if not self.api_key:
raise ValueError("Jina provider requires 'api_key' to be set")
- elif self.provider == "gemini":
- if not self.api_key:
- raise ValueError("Gemini provider requires 'api_key' to be set")
elif self.provider == "voyage":
if not self.api_key:
raise ValueError("Voyage provider requires 'api_key' to be set")
@@ -171,7 +165,7 @@ class EmbeddingModelConfig(BaseModel):
class EmbeddingConfig(BaseModel):
"""
- Embedding configuration, supports OpenAI, VolcEngine, VikingDB, Jina, or Gemini APIs.
+ Embedding configuration, supports OpenAI or VolcEngine compatible APIs.
Structure:
- dense: Configuration for dense embedder
@@ -210,7 +204,7 @@ class EmbeddingConfig(BaseModel):
"""Factory method to create embedder instance based on provider and type.
Args:
- provider: Provider type ('openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage', 'gemini'))
+ provider: Provider type ('openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage')
embedder_type: Embedder type ('dense', 'sparse', 'hybrid')
config: EmbeddingModelConfig instance
context: Optional embedding context ('query' or 'document') for non-symmetric models.
@@ -234,7 +228,6 @@ class EmbeddingConfig(BaseModel):
VolcengineSparseEmbedder,
VoyageDenseEmbedder,
)
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
# Factory registry: (provider, type) -> (embedder_class, param_builder)
factory_registry = {
@@ -330,15 +323,6 @@ class EmbeddingConfig(BaseModel):
**({"document_param": cfg.document_param} if cfg.document_param else {}),
},
),
- ("gemini", "dense"): (
- GeminiDenseEmbedder,
- lambda cfg: {
- "model_name": cfg.model,
- "api_key": cfg.api_key,
- "dimension": cfg.dimension,
- "task_type": cfg.task_type,
- },
- ),
# Ollama: local OpenAI-compatible embedding server, no real API key needed
("ollama", "dense"): (
OpenAIDenseEmbedder,
diff --git a/pyproject.toml b/pyproject.toml
index 471085a56..c26aa7cfc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -70,7 +70,6 @@ dependencies = [
"tree-sitter-go>=0.23.0",
"tree-sitter-c-sharp>=0.23.0",
"loguru>=0.7.3",
- "google-genai>=0.8.0",
]
[tool.uv.sources]
@@ -85,9 +84,7 @@ test = [
"ragas>=0.1.0",
"datasets>=2.0.0",
"pandas>=2.0.0",
- "anyio>=4.0",
]
-gemini-async = ["anyio>=4.0"]
dev = [
"mypy>=1.0.0",
"ruff>=0.1.0",
@@ -211,9 +208,6 @@ python_classes = ["Test*"]
python_functions = ["test_*"]
asyncio_mode = "auto"
addopts = "-v --cov=openviking --cov-report=term-missing"
-markers = [
- "integration: tests that call real external APIs (require env vars)",
-]
[tool.ruff]
line-length = 100
@@ -252,6 +246,4 @@ line-ending = "auto"
[dependency-groups]
dev = [
"pytest>=9.0.2",
- "pytest-asyncio>=1.3.0",
- "pytest-cov>=7.0.0",
]
diff --git a/tests/integration/test_gemini_e2e.py b/tests/integration/test_gemini_e2e.py
deleted file mode 100644
index 37e4c75ad..000000000
--- a/tests/integration/test_gemini_e2e.py
+++ /dev/null
@@ -1,154 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""
-End-to-end integration tests for GeminiDenseEmbedder.
-Calls the real Gemini API — requires GEMINI_API_KEY env var.
-Run: pytest tests/integration/test_gemini_e2e.py -v -m integration
-"""
-import math
-import os
-import struct
-import zlib
-
-import pytest
-
-from openviking.core.context import ModalContent, Vectorize
-from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
-
-_API_KEY = os.getenv("GEMINI_API_KEY")
-pytestmark = [
- pytest.mark.integration,
- pytest.mark.skipif(not _API_KEY, reason="GEMINI_API_KEY not set"),
-]
-
-
-def _make_tiny_png() -> bytes:
- """Create a minimal valid 1x1 white PNG (89 bytes)."""
-
- def chunk(name, data):
- c = struct.pack(">I", len(data)) + name + data
- return c + struct.pack(">I", zlib.crc32(name + data) & 0xFFFFFFFF)
-
- sig = b"\x89PNG\r\n\x1a\n"
- ihdr = chunk(b"IHDR", struct.pack(">IIBBBBB", 1, 1, 8, 2, 0, 0, 0))
- idat = chunk(b"IDAT", zlib.compress(b"\x00\xff\xff\xff"))
- iend = chunk(b"IEND", b"")
- return sig + ihdr + idat + iend
-
-
-def _cosine_similarity(a: list, b: list) -> float:
- dot = sum(x * y for x, y in zip(a, b))
- norm_a = math.sqrt(sum(x * x for x in a))
- norm_b = math.sqrt(sum(x * x for x in b))
- return dot / (norm_a * norm_b) if norm_a and norm_b else 0.0
-
-
[email protected](scope="module")
-def embedder():
- e = GeminiDenseEmbedder(
- "gemini-embedding-2-preview",
- api_key=_API_KEY,
- # dimension defaults to 3072 — test the actual default
- task_type="RETRIEVAL_DOCUMENT",
- )
- yield e
- e.close()
-
-
-def test_default_dimension_is_3072(embedder):
- """Default output dimension must match model's native 3072."""
- assert embedder.get_dimension() == 3072
- result = embedder.embed("hello")
- assert len(result.dense_vector) == 3072
-
-
-class TestGeminiE2ETextEmbedding:
- def test_embed_text_returns_correct_dimension(self, embedder):
- result = embedder.embed("OpenViking is a knowledge management system")
- assert result.dense_vector is not None
- assert len(result.dense_vector) == 3072
-
- def test_embed_text_vector_is_normalized(self, embedder):
- result = embedder.embed("test normalization")
- norm = math.sqrt(sum(x * x for x in result.dense_vector))
- assert abs(norm - 1.0) < 0.01, f"Vector norm {norm} not close to 1.0"
-
- def test_embed_batch_matches_individual(self, embedder):
- texts = ["hello world", "foo bar", "test embed"]
- batch_results = embedder.embed_batch(texts)
- individual_results = [embedder.embed(t) for t in texts]
- assert len(batch_results) == 3
- for br, ir in zip(batch_results, individual_results):
- sim = _cosine_similarity(br.dense_vector, ir.dense_vector)
- assert sim > 0.99, f"Batch vs individual similarity {sim} too low"
-
- def test_semantic_similarity_related_texts(self, embedder):
- r1 = embedder.embed("a golden retriever playing in the park")
- r2 = embedder.embed("a dog running outside in a field")
- r3 = embedder.embed("quantum computing and cryptography")
- sim_related = _cosine_similarity(r1.dense_vector, r2.dense_vector)
- sim_unrelated = _cosine_similarity(r1.dense_vector, r3.dense_vector)
- assert sim_related > sim_unrelated
-
-
-class TestGeminiE2EMultimodalEmbedding:
- @pytest.mark.xfail(reason="gemini-embedding-2-preview may not support multimodal on free tier")
- def test_embed_multimodal_image_returns_correct_dimension(self, embedder):
- v = Vectorize(
- text="a tiny white pixel",
- media=ModalContent(mime_type="image/png", uri="test.png", data=_make_tiny_png()),
- )
- result = embedder.embed_multimodal(v)
- assert result.dense_vector is not None
- assert len(result.dense_vector) == 3072
-
- def test_multimodal_fallback_on_no_media(self, embedder):
- v = Vectorize(text="just text, no image")
- result = embedder.embed_multimodal(v)
- text_result = embedder.embed("just text, no image")
- sim = _cosine_similarity(result.dense_vector, text_result.dense_vector)
- assert sim > 0.99, f"Fallback similarity {sim:.3f} too low"
-
-
-class TestGeminiE2EAsyncBatch:
- @pytest.mark.anyio
- async def test_async_embed_batch_concurrent(self):
- try:
- import anyio # noqa: F401
- except ImportError:
- pytest.skip("anyio not installed")
- import time
- embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview", api_key=_API_KEY, dimension=128
- )
- texts = [f"sentence {i}" for i in range(300)] # 3 batches of 100
- t0 = time.monotonic()
- results = await embedder.async_embed_batch(texts)
- elapsed = time.monotonic() - t0
- assert len(results) == 300
- assert all(len(r.dense_vector) == 128 for r in results)
- assert elapsed < 15 # concurrent should be << 3× serial RTT
- embedder.close()
-
-
-class TestGeminiE2ETaskType:
- def test_query_vs_document_task_types(self):
- doc_embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview",
- api_key=_API_KEY,
- task_type="RETRIEVAL_DOCUMENT",
- )
- query_embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview",
- api_key=_API_KEY,
- task_type="RETRIEVAL_QUERY",
- )
- text = "machine learning algorithms"
- doc_result = doc_embedder.embed(text)
- query_result = query_embedder.embed(text)
- sim = _cosine_similarity(doc_result.dense_vector, query_result.dense_vector)
- # gemini-embedding-2-preview may return identical vectors for same text
- # across task types; assert vectors are at least highly correlated
- assert sim > 0.8, f"Task type similarity {sim:.3f} unexpectedly low"
- doc_embedder.close()
- query_embedder.close()
diff --git a/tests/misc/test_config_validation.py b/tests/misc/test_config_validation.py
index c5a64d3c1..1ab715170 100644
--- a/tests/misc/test_config_validation.py
+++ b/tests/misc/test_config_validation.py
@@ -250,52 +250,6 @@ def test_vlm_validation():
print(f" Fail (provider='volcengine' should have priority, got '{config_b.provider}')")
-import pytest
-
-
-def test_gemini_provider_valid():
- from openviking_cli.utils.config.embedding_config import EmbeddingModelConfig
- cfg = EmbeddingModelConfig(
- model="gemini-embedding-2-preview", provider="gemini", api_key="test-key", dimension=3072
- )
- assert cfg.provider == "gemini"
- assert cfg.dimension == 3072
-
-
-def test_gemini_provider_requires_api_key():
- from openviking_cli.utils.config.embedding_config import EmbeddingModelConfig
- with pytest.raises(ValueError, match="api_key"):
- EmbeddingModelConfig(model="gemini-embedding-2-preview", provider="gemini")
-
-
-def test_gemini_task_type_field():
- from openviking_cli.utils.config.embedding_config import EmbeddingModelConfig
- cfg = EmbeddingModelConfig(
- model="gemini-embedding-2-preview",
- provider="gemini",
- api_key="test-key",
- task_type="RETRIEVAL_DOCUMENT",
- )
- assert cfg.task_type == "RETRIEVAL_DOCUMENT"
-
-
-def test_gemini_factory_creates_gemini_embedder():
- from unittest.mock import patch
- from openviking_cli.utils.config.embedding_config import EmbeddingConfig
- with patch("openviking.models.embedder.gemini_embedders.genai.Client"):
- cfg = EmbeddingConfig(
- dense={
- "model": "gemini-embedding-2-preview",
- "provider": "gemini",
- "api_key": "test-key",
- "task_type": "RETRIEVAL_DOCUMENT",
- }
- )
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = cfg.get_embedder()
- assert isinstance(embedder, GeminiDenseEmbedder)
-
-
if __name__ == "__main__":
print("\nStarting config validator tests...\n")
diff --git a/tests/storage/test_collection_schemas.py b/tests/storage/test_collection_schemas.py
index 0d6aff6c9..c25dbbda6 100644
--- a/tests/storage/test_collection_schemas.py
+++ b/tests/storage/test_collection_schemas.py
@@ -3,7 +3,6 @@
import json
from types import SimpleNamespace
-from unittest.mock import patch
import pytest
@@ -53,7 +52,7 @@ async def test_embedding_handler_skip_all_work_when_manager_is_closing(monkeypat
embedder = _DummyEmbedder()
monkeypatch.setattr(
- "openviking.storage.collection_schemas.get_openviking_config",
+ "openviking_cli.utils.config.get_openviking_config",
lambda: _DummyConfig(embedder),
)
@@ -86,7 +85,7 @@ async def test_embedding_handler_treats_shutdown_write_lock_as_success(monkeypat
embedder = _DummyEmbedder()
monkeypatch.setattr(
- "openviking.storage.collection_schemas.get_openviking_config",
+ "openviking_cli.utils.config.get_openviking_config",
lambda: _DummyConfig(embedder),
)
@@ -105,146 +104,3 @@ async def test_embedding_handler_treats_shutdown_write_lock_as_success(monkeypat
assert embedder.calls == 1
assert status["success"] == 1
assert status["error"] == 0
-
-
-# ---------------------------------------------------------------------------
-# Multimodal path tests
-# ---------------------------------------------------------------------------
-
-
-class _MultimodalEmbedder:
- def __init__(self):
- self.embed_calls = 0
- self.embed_multimodal_calls = 0
-
- @property
- def supports_multimodal(self):
- return True
-
- def embed(self, text: str) -> EmbedResult:
- self.embed_calls += 1
- return EmbedResult(dense_vector=[0.1, 0.2])
-
- def embed_multimodal(self, vectorize) -> EmbedResult:
- self.embed_multimodal_calls += 1
- return EmbedResult(dense_vector=[0.9, 0.8])
-
-
-class _DummyMultimodalConfig:
- def __init__(self, embedder):
- self.storage = SimpleNamespace(vectordb=SimpleNamespace(name="context"))
- self.embedding = SimpleNamespace(dimension=2, get_embedder=lambda: embedder)
-
-
-def _build_media_payload(media_uri: str, media_mime_type: str) -> dict:
- msg = EmbeddingMsg(
- message="a dashboard screenshot",
- context_data={
- "id": "id-2",
- "uri": media_uri,
- "account_id": "default",
- "abstract": "screenshot",
- },
- media_uri=media_uri,
- media_mime_type=media_mime_type,
- )
- return {"data": json.dumps(msg.to_dict())}
-
-
-async def test_handler_uses_embed_multimodal_when_media_uri_present(monkeypatch):
- embedder = _MultimodalEmbedder()
- monkeypatch.setattr(
- "openviking.storage.collection_schemas.get_openviking_config",
- lambda: _DummyMultimodalConfig(embedder),
- )
-
- class _FakeVikingDB:
- is_closing = False
-
- async def upsert(self, data):
- pass
-
- class _FakeVikingFS:
- async def read_file_bytes(self, uri, ctx=None):
- return b"\x89PNG\r\n"
-
- with patch("openviking.storage.viking_fs.get_viking_fs", return_value=_FakeVikingFS()):
- handler = TextEmbeddingHandler(_FakeVikingDB())
- handler.set_callbacks(on_success=lambda: None, on_error=lambda *_: None)
-
- await handler.on_dequeue(
- _build_media_payload(
- media_uri="viking://agent/resources/shot.png",
- media_mime_type="image/png",
- )
- )
-
- assert embedder.embed_multimodal_calls == 1
- assert embedder.embed_calls == 0
-
-
-async def test_handler_falls_back_to_text_when_read_file_fails(monkeypatch):
- embedder = _MultimodalEmbedder()
- monkeypatch.setattr(
- "openviking.storage.collection_schemas.get_openviking_config",
- lambda: _DummyMultimodalConfig(embedder),
- )
-
- class _FakeVikingDB:
- is_closing = False
-
- async def upsert(self, data):
- pass
-
- class _FailingVikingFS:
- async def read_file_bytes(self, uri, ctx=None):
- raise OSError("file not found")
-
- with patch("openviking.storage.viking_fs.get_viking_fs", return_value=_FailingVikingFS()):
- handler = TextEmbeddingHandler(_FakeVikingDB())
- handler.set_callbacks(on_success=lambda: None, on_error=lambda *_: None)
-
- await handler.on_dequeue(
- _build_media_payload(
- media_uri="viking://agent/resources/shot.png",
- media_mime_type="image/png",
- )
- )
-
- assert embedder.embed_calls == 1
- assert embedder.embed_multimodal_calls == 0
-
-
-async def test_handler_rejects_media_uri_not_matching_context_uri(monkeypatch):
- """media_uri that differs from context_data['uri'] must fall back to text embed (security)."""
- embedder = _MultimodalEmbedder()
- monkeypatch.setattr(
- "openviking.storage.collection_schemas.get_openviking_config",
- lambda: _DummyMultimodalConfig(embedder),
- )
-
- class _FakeVikingDB:
- is_closing = False
-
- async def upsert(self, data):
- pass
-
- # media_uri points to a DIFFERENT file than context_data["uri"]
- msg = EmbeddingMsg(
- message="caption",
- context_data={"id": "x", "uri": "viking://owner/legit.png", "account_id": "default", "abstract": "a"},
- media_uri="viking://attacker/secret.png", # DIFFERENT from uri
- media_mime_type="image/png",
- )
- payload = {"data": json.dumps(msg.to_dict())}
-
- handler = TextEmbeddingHandler(_FakeVikingDB())
- handler.set_callbacks(on_success=lambda: None, on_error=lambda *_: None)
- await handler.on_dequeue(payload)
-
- # Must fall back to text — NOT call embed_multimodal
- assert embedder.embed_multimodal_calls == 0
- assert embedder.embed_calls == 1
diff --git a/tests/storage/test_embedding_msg_converter_tenant.py b/tests/storage/test_embedding_msg_converter_tenant.py
index 05ca59143..047c13cc6 100644
--- a/tests/storage/test_embedding_msg_converter_tenant.py
+++ b/tests/storage/test_embedding_msg_converter_tenant.py
@@ -5,8 +5,7 @@
import pytest
-from openviking.core.context import Context, ModalContent, Vectorize
-from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
+from openviking.core.context import Context
from openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter
from openviking_cli.session.user_id import UserIdentifier
@@ -41,66 +40,3 @@ def test_embedding_msg_converter_backfills_account_and_owner_space(uri, expected
assert msg is not None
assert msg.context_data["account_id"] == "acme"
assert msg.context_data["owner_space"] == expected_space(user)
-
-
-def test_embedding_msg_media_fields_default_none():
- msg = EmbeddingMsg(message="hello", context_data={"uri": "viking://x"})
- assert msg.media_uri is None
- assert msg.media_mime_type is None
-
-
-def test_embedding_msg_media_round_trip():
- """media_uri and media_mime_type survive to_dict/from_dict serialization."""
- msg = EmbeddingMsg(
- message="a photo",
- context_data={"uri": "viking://agent/resources/img.jpg"},
- media_uri="viking://agent/resources/img.jpg",
- media_mime_type="image/jpeg",
- )
- restored = EmbeddingMsg.from_dict(msg.to_dict())
- assert restored.media_uri == "viking://agent/resources/img.jpg"
- assert restored.media_mime_type == "image/jpeg"
-
-
-def test_embedding_msg_legacy_message_missing_media_fields():
- """Old queue messages without media fields deserialize cleanly (None defaults)."""
- old_payload = {"message": "old text", "context_data": {"uri": "viking://x"}, "id": "abc"}
- msg = EmbeddingMsg.from_dict(old_payload)
- assert msg.media_uri is None
- assert msg.media_mime_type is None
-
-
-def test_converter_passes_media_uri_when_vectorize_has_media():
- context = Context(uri="viking://agent/resources/shot.png", abstract="screenshot")
- mc = ModalContent(mime_type="image/png", uri="viking://agent/resources/shot.png")
- context.set_vectorize(Vectorize(text="screenshot of dashboard", media=mc))
-
- msg = EmbeddingMsgConverter.from_context(context)
-
- assert msg.media_uri == "viking://agent/resources/shot.png"
- assert msg.media_mime_type == "image/png"
-
-
-def test_converter_media_fields_none_for_text_only():
- context = Context(uri="viking://agent/memories/notes.md", abstract="some note")
- context.set_vectorize(Vectorize(text="some note text"))
-
- msg = EmbeddingMsgConverter.from_context(context)
-
- assert msg.media_uri is None
- assert msg.media_mime_type is None
-
-
-def test_converter_allows_media_even_with_empty_text():
- """If media is present but text is empty, use URI as fallback — don't drop the message."""
- context = Context(uri="viking://agent/resources/img.png", abstract="")
- mc = ModalContent(mime_type="image/png", uri="viking://agent/resources/img.png")
- context.set_vectorize(Vectorize(text="", media=mc))
-
- msg = EmbeddingMsgConverter.from_context(context)
-
- # Should NOT be None — media-only messages must pass through
- assert msg is not None
- assert msg.media_uri == "viking://agent/resources/img.png"
- # Text should be the URI as fallback (or some non-empty string)
- assert msg.message # non-empty
diff --git a/tests/unit/test_context_vectorize.py b/tests/unit/test_context_vectorize.py
deleted file mode 100644
index 9191ebe2f..000000000
--- a/tests/unit/test_context_vectorize.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""Tests for ModalContent and Vectorize media extension."""
-from openviking.core.context import ModalContent, Vectorize
-
-
-def test_modal_content_fields():
- mc = ModalContent(mime_type="image/jpeg", uri="viking://agent/resources/img.jpg")
- assert mc.mime_type == "image/jpeg"
- assert mc.uri == "viking://agent/resources/img.jpg"
- assert mc.data is None
-
-
-def test_vectorize_default_no_media():
- v = Vectorize(text="hello")
- assert v.text == "hello"
- assert v.media is None
-
-
-def test_vectorize_with_media():
- mc = ModalContent(mime_type="image/png", uri="viking://agent/resources/shot.png")
- v = Vectorize(text="screenshot of dashboard", media=mc)
- assert v.text == "screenshot of dashboard"
- assert v.media is mc
- assert v.media.mime_type == "image/png"
-
-
-def test_vectorize_get_vectorization_text_still_works():
- v = Vectorize(text="doc text", media=ModalContent(mime_type="image/png", uri="img.png"))
- assert v.text == "doc text"
-
-
-def test_modal_content_with_data_bytes():
- mc = ModalContent(mime_type="image/jpeg", uri="viking://img.jpg", data=b"\xff\xd8\xff")
- assert mc.data == b"\xff\xd8\xff"
diff --git a/tests/unit/test_embedder_base_multimodal.py b/tests/unit/test_embedder_base_multimodal.py
deleted file mode 100644
index f3ae93911..000000000
--- a/tests/unit/test_embedder_base_multimodal.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""Tests for multimodal protocol on EmbedderBase."""
-from openviking.core.context import ModalContent, Vectorize
-from openviking.models.embedder.base import DenseEmbedderBase, EmbedResult
-
-
-class _TextOnlyEmbedder(DenseEmbedderBase):
- def embed(self, text: str) -> EmbedResult:
- return EmbedResult(dense_vector=[0.1, 0.2])
-
- def get_dimension(self) -> int:
- return 2
-
-
-def test_supports_multimodal_default_false():
- e = _TextOnlyEmbedder("test-model")
- assert e.supports_multimodal is False
-
-
-def test_embed_multimodal_falls_back_to_text():
- e = _TextOnlyEmbedder("test-model")
- v = Vectorize(
- text="a dog photo",
- media=ModalContent(mime_type="image/jpeg", uri="viking://img.jpg"),
- )
- result = e.embed_multimodal(v)
- assert result.dense_vector == [0.1, 0.2]
-
-
-def test_embed_multimodal_text_only_vectorize():
- e = _TextOnlyEmbedder("test-model")
- v = Vectorize(text="just text")
- result = e.embed_multimodal(v)
- assert result.dense_vector == [0.1, 0.2]
diff --git a/tests/unit/test_embedding_msg.py b/tests/unit/test_embedding_msg.py
deleted file mode 100644
index afb408134..000000000
--- a/tests/unit/test_embedding_msg.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
-
-
-def test_embedding_msg_roundtrip_preserves_id():
- """EmbeddingMsg.id must survive to_dict() → from_dict() round-trip."""
- msg = EmbeddingMsg(
- message="hello",
- context_data={"collection_id": "c1", "uri": "u1"},
- )
- assert msg.id, "id should be non-empty"
- restored = EmbeddingMsg.from_dict(msg.to_dict())
- assert msg.id == restored.id, f"ID lost in round-trip: {msg.id!r} → {restored.id!r}"
-
-
-def test_embedding_msg_id_in_to_dict():
- """to_dict() must include the id field."""
- msg = EmbeddingMsg(message="test", context_data={"uri": "u2"})
- d = msg.to_dict()
- assert "id" in d, "id key missing from to_dict() output"
- assert d["id"] == msg.id
-
-
-def test_embedding_msg_backward_compat_missing_id():
- """from_dict() must generate a fresh id when the data has no 'id' key (backward compat)."""
- data = {
- "message": "hello",
- "context_data": {"uri": "u3"},
- "media_uri": None,
- "media_mime_type": None,
- }
- obj = EmbeddingMsg.from_dict(data)
- assert obj.id, "id should be non-empty even when missing from source dict"
diff --git a/tests/unit/test_embedding_utils_mime.py b/tests/unit/test_embedding_utils_mime.py
deleted file mode 100644
index ec82aa889..000000000
--- a/tests/unit/test_embedding_utils_mime.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""Tests for _infer_image_mime / _infer_media_mime helpers and vectorize_file multimodal coverage."""
-import asyncio
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-
- "filename,expected",
- [
- ("photo.jpg", "image/jpeg"),
- ("photo.jpeg", "image/jpeg"),
- ("photo.JPG", "image/jpeg"),
- ("screenshot.png", "image/png"),
- ("anim.gif", "image/gif"),
- ("hero.webp", "image/webp"),
- ("icon.bmp", "image/bmp"),
- ("logo.svg", "image/svg+xml"),
- ("unknown.tiff", None),
- ("noext", None),
- ],
-)
-def test_infer_image_mime(filename, expected):
- from openviking.utils.embedding_utils import _infer_image_mime
- assert _infer_image_mime(filename) == expected
-
-
- "filename,expected_mime",
- [
- # Images
- ("photo.png", "image/png"),
- ("photo.jpg", "image/jpeg"),
- ("anim.gif", "image/gif"),
- ("hero.webp", "image/webp"),
- # Video (Gemini-specific MIME strings, not RFC standard)
- ("clip.mp4", "video/mp4"),
- ("movie.mov", "video/mov"),
- ("film.avi", "video/avi"),
- ("video.wmv", "video/wmv"),
- ("video.mpeg", "video/mpeg"),
- ("clip.webm", "video/webm"),
- # Audio (Gemini uses audio/mp3, audio/wav etc.)
- ("song.mp3", "audio/mp3"),
- ("sound.wav", "audio/wav"),
- ("track.ogg", "audio/ogg"),
- ("music.flac", "audio/flac"),
- # PDF
- ("doc.pdf", "application/pdf"),
- # Unknown / not in Gemini's supported list
- ("file.xyz", None),
- ("film.mkv", None), # mkv not in Gemini MIME map
- ],
-)
-def test_infer_media_mime(filename, expected_mime):
- from openviking.utils.embedding_utils import _infer_media_mime
- assert _infer_media_mime(filename) == expected_mime
-
-
-
- "fname,provider,expect_media",
- [
- ("photo.png", "gemini", False), # text-only embedder → no media
- ("clip.mp4", "gemini", False), # text-only embedder → no media
- ("song.mp3", "gemini", False), # text-only embedder → no media
- ("doc.pdf", "gemini", False), # text-only embedder → no media
- ("photo.png", "openai", False), # non-gemini → no media
- ("clip.mp4", None, False), # no provider → no media
- ],
-)
-def test_vectorize_file_multimodal_coverage(fname, provider, expect_media):
- """vectorize_file sets Vectorize.media for all Gemini-supported types iff provider==gemini."""
- captured = {}
-
- def fake_set_vectorize(v):
- captured["vectorize"] = v
-
- mock_ctx = MagicMock()
- mock_ctx.user = "test_user"
- mock_ctx.account_id = "test_account"
-
- mock_queue = AsyncMock()
- mock_queue_manager = MagicMock()
- mock_queue_manager.get_queue.return_value = mock_queue
- mock_queue_manager.EMBEDDING = "embedding"
-
- mock_context = MagicMock()
- mock_context.set_vectorize = fake_set_vectorize
-
- mock_msg = MagicMock()
-
- with (
- patch("openviking.utils.embedding_utils.get_queue_manager", return_value=mock_queue_manager),
- patch("openviking.utils.embedding_utils.get_viking_fs", return_value=MagicMock()),
- patch("openviking.utils.embedding_utils.Context", return_value=mock_context),
- patch("openviking.utils.embedding_utils.EmbeddingMsgConverter") as mock_converter,
- patch("openviking.utils.embedding_utils._owner_space_for_uri", return_value="space"),
- ):
- mock_converter.from_context.return_value = mock_msg
-
- from openviking.utils.embedding_utils import vectorize_file
- asyncio.run(
- vectorize_file(
- file_path=f"/fake/path/{fname}",
- summary_dict={"name": fname, "summary": "A test file"},
- parent_uri="/fake/path",
- ctx=mock_ctx,
- embedding_provider=provider,
- )
- )
-
- v = captured.get("vectorize")
- assert v is not None, "set_vectorize was never called"
- if expect_media:
- assert v.media is not None, f"Expected media to be set for {fname} with provider={provider!r}"
- else:
- assert v.media is None, f"Expected no media for {fname} with provider={provider!r}"
diff --git a/tests/unit/test_gemini_embedder.py b/tests/unit/test_gemini_embedder.py
deleted file mode 100644
index dc37df828..000000000
--- a/tests/unit/test_gemini_embedder.py
+++ /dev/null
@@ -1,219 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: Apache-2.0
-"""
-Tests for GeminiDenseEmbedder.
-Pattern: patch at module import path, use MagicMock, never make real API calls.
-"""
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-def _make_mock_embedding(values):
- emb = MagicMock()
- emb.values = values
- return emb
-
-
-def _make_mock_result(values_list):
- result = MagicMock()
- result.embeddings = [_make_mock_embedding(v) for v in values_list]
- return result
-
-
-def test_input_token_limit_constant():
- from openviking.models.embedder.gemini_embedders import _GEMINI_INPUT_TOKEN_LIMIT
- assert _GEMINI_INPUT_TOKEN_LIMIT == 8192
-
-
-class TestGeminiDenseEmbedderInit:
- def test_requires_api_key(self):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- with pytest.raises(ValueError, match="api_key"):
- GeminiDenseEmbedder("gemini-embedding-2-preview")
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_init_stores_fields(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview",
- api_key="test-key",
- dimension=1536,
- task_type="RETRIEVAL_DOCUMENT",
- )
- assert embedder.model_name == "gemini-embedding-2-preview"
- assert embedder.task_type == "RETRIEVAL_DOCUMENT"
- assert embedder.get_dimension() == 1536
- mock_client_class.assert_called_once_with(api_key="test-key")
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_default_dimension_3072(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- assert embedder.get_dimension() == 3072
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_supports_multimodal_false(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- assert embedder.supports_multimodal is False
-
-
-class TestGeminiDenseEmbedderEmbed:
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_text(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.models.embed_content.return_value = _make_mock_result([[0.1, 0.2, 0.3]])
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=3)
- result = embedder.embed("hello world")
- assert result.dense_vector is not None
- assert len(result.dense_vector) == 3
- mock_client.models.embed_content.assert_called_once()
- _, kwargs = mock_client.models.embed_content.call_args
- assert kwargs["model"] == "gemini-embedding-2-preview"
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_passes_task_type_in_config(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.models.embed_content.return_value = _make_mock_result([[0.1]])
- embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview", api_key="key", dimension=1, task_type="RETRIEVAL_QUERY"
- )
- embedder.embed("query text")
- _, kwargs = mock_client.models.embed_content.call_args
- assert kwargs["config"].task_type == "RETRIEVAL_QUERY"
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_raises_runtime_error_on_api_error(self, mock_client_class):
- from google.genai.errors import APIError
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_response = MagicMock()
- mock_response.status_code = 401
- mock_client.models.embed_content.side_effect = APIError(401, {}, response=mock_response)
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- with pytest.raises(RuntimeError, match="Gemini embedding failed"):
- embedder.embed("hello")
-
-
-class TestGeminiDenseEmbedderBatch:
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_batch_empty(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- results = embedder.embed_batch([])
- assert results == []
- mock_client.models.embed_content.assert_not_called()
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_batch_single_chunk(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.models.embed_content.return_value = _make_mock_result([[0.1], [0.2], [0.3]])
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)
- results = embedder.embed_batch(["a", "b", "c"])
- assert len(results) == 3
- mock_client.models.embed_content.assert_called_once()
- _, kwargs = mock_client.models.embed_content.call_args
- assert kwargs["contents"] == ["a", "b", "c"]
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_batch_chunks_at_100(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.models.embed_content.side_effect = [
- _make_mock_result([[0.1]] * 100),
- _make_mock_result([[0.2]] * 10),
- ]
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)
- results = embedder.embed_batch([f"text{i}" for i in range(110)])
- assert len(results) == 110
- assert mock_client.models.embed_content.call_count == 2
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- def test_embed_batch_falls_back_to_individual_on_error(self, mock_client_class):
- from google.genai.errors import APIError
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_response = MagicMock()
- mock_response.status_code = 500
- mock_client.models.embed_content.side_effect = [
- APIError(500, {}, response=mock_response),
- _make_mock_result([[0.1]]),
- _make_mock_result([[0.2]]),
- ]
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)
- results = embedder.embed_batch(["a", "b"])
- assert len(results) == 2
- assert mock_client.models.embed_content.call_count == 3
-
-
-class TestGeminiDenseEmbedderAsyncBatch:
- """Unit tests for async_embed_batch (uses AsyncMock, no real API)."""
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- @pytest.mark.anyio
- async def test_async_embed_batch_dispatches_all_chunks(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.aio.models.embed_content = AsyncMock(side_effect=[
- _make_mock_result([[0.1]] * 100),
- _make_mock_result([[0.2]] * 10),
- ])
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)
- results = await embedder.async_embed_batch([f"t{i}" for i in range(110)])
- assert len(results) == 110
- assert mock_client.aio.models.embed_content.call_count == 2
-
- @patch("openviking.models.embedder.gemini_embedders._TEXT_BATCH_SIZE", 1)
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- @pytest.mark.anyio
- async def test_async_embed_batch_preserves_order(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_client.aio.models.embed_content = AsyncMock(side_effect=[
- _make_mock_result([[1.0]]),
- _make_mock_result([[2.0]]),
- _make_mock_result([[3.0]]),
- ])
- embedder = GeminiDenseEmbedder(
- "gemini-embedding-2-preview", api_key="key", dimension=1, max_concurrent_batches=3
- )
- results = await embedder.async_embed_batch(["a", "b", "c"])
- # Order must match input regardless of task completion order
- assert [r.dense_vector[0] for r in results] == [1.0, 2.0, 3.0]
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- @pytest.mark.anyio
- async def test_async_embed_batch_error_fallback_to_individual(self, mock_client_class):
- from google.genai.errors import APIError
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- mock_client = mock_client_class.return_value
- mock_response = MagicMock()
- mock_response.status_code = 500
- mock_client.aio.models.embed_content = AsyncMock(
- side_effect=APIError(500, {}, response=mock_response)
- )
- mock_client.models.embed_content.return_value = _make_mock_result([[0.1]])
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)
- results = await embedder.async_embed_batch(["a", "b"])
- assert len(results) == 2
- assert mock_client.models.embed_content.call_count == 2
-
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- @pytest.mark.anyio
- async def test_async_embed_batch_empty(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- assert await embedder.async_embed_batch([]) == []
-
- @patch("openviking.models.embedder.gemini_embedders._ANYIO_AVAILABLE", False)
- @patch("openviking.models.embedder.gemini_embedders.genai.Client")
- @pytest.mark.anyio
- async def test_async_embed_batch_raises_without_anyio(self, mock_client_class):
- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder
- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")
- with pytest.raises(ImportError, match="anyio is required"):
- await embedder.async_embed_batch(["text"])
diff --git a/uv.lock b/uv.lock
index 195a75bba..59e6638e3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
version = 1
-revision = 3
+revision = 2
requires-python = ">=3.10"
resolution-markers = [
"python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -1375,45 +1375,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/ac/35/17c9141c4ae21e9a29a43acdfd848e3e468a810517f862cad07977bf8fe9/google-3.0.0-py2.py3-none-any.whl", hash = "sha256:889cf695f84e4ae2c55fbc0cfdaf4c1e729417fa52ab1db0485202ba173e4935", size = 45258, upload-time = "2020-07-11T14:49:58.287Z" },
]
-[[package]]
-name = "google-auth"
-version = "2.49.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
- { name = "cryptography" },
- { name = "pyasn1-modules" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ea/80/6a696a07d3d3b0a92488933532f03dbefa4a24ab80fb231395b9a2a1be77/google_auth-2.49.1.tar.gz", hash = "sha256:16d40da1c3c5a0533f57d268fe72e0ebb0ae1cc3b567024122651c045d879b64", size = 333825, upload-time = "2026-03-12T19:30:58.135Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/e9/eb/c6c2478d8a8d633460be40e2a8a6f8f429171997a35a96f81d3b680dec83/google_auth-2.49.1-py3-none-any.whl", hash = "sha256:195ebe3dca18eddd1b3db5edc5189b76c13e96f29e73043b923ebcf3f1a860f7", size = 240737, upload-time = "2026-03-12T19:30:53.159Z" },
-]
-
-[package.optional-dependencies]
-requests = [
- { name = "requests" },
-]
-
-[[package]]
-name = "google-genai"
-version = "1.67.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
- { name = "anyio" },
- { name = "distro" },
- { name = "google-auth", extra = ["requests"] },
- { name = "httpx" },
- { name = "pydantic" },
- { name = "requests" },
- { name = "sniffio" },
- { name = "tenacity" },
- { name = "typing-extensions" },
- { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/07/59a498f81f2c7b0649eacda2ea470b7fd8bd7149f20caba22962081bdd51/google_genai-1.67.0.tar.gz", hash = "sha256:897195a6a9742deb6de240b99227189ada8b2d901d61bdfba836c3092021eab6", size = 506972, upload-time = "2026-03-12T20:39:16.241Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/6e/c2/562aa1f086e53529ffbeb5b43d5d8bc42c1b968102b5e2163fad005ce298/google_genai-1.67.0-py3-none-any.whl", hash = "sha256:58b0484ff2d4335fa53c724b489e9f807fcca8115d9cdbd8fdf341121fbd6d2d", size = 733542, upload-time = "2026-03-12T20:39:14.615Z" },
-]
-
[[package]]
name = "googleapis-common-protos"
version = "1.73.0"
@@ -3285,7 +3246,6 @@ dependencies = [
{ name = "apscheduler" },
{ name = "ebooklib" },
{ name = "fastapi" },
- { name = "google-genai" },
{ name = "httpx" },
{ name = "jinja2" },
{ name = "json-repair" },
@@ -3446,8 +3406,6 @@ test = [
[package.dev-dependencies]
dev = [
{ name = "pytest" },
- { name = "pytest-asyncio" },
- { name = "pytest-cov" },
]
[package.metadata]
@@ -3466,7 +3424,6 @@ requires-dist = [
{ name = "ebooklib", specifier = ">=0.18.0" },
{ name = "fastapi", specifier = ">=0.128.0" },
{ name = "fusepy", marker = "extra == 'bot-fuse'", specifier = ">=3.0.1" },
- { name = "google-genai", specifier = ">=0.8.0" },
{ name = "gradio", marker = "extra == 'bot'", specifier = ">=6.6.0" },
{ name = "html2text", marker = "extra == 'bot'", specifier = ">=2020.1.16" },
{ name = "httpx", specifier = ">=0.25.0" },
@@ -3548,11 +3505,7 @@ requires-dist = [
provides-extras = ["test", "dev", "doc", "eval", "build", "bot", "bot-langfuse", "bot-telegram", "bot-feishu", "bot-dingtalk", "bot-slack", "bot-qq", "bot-sandbox", "bot-fuse", "bot-opencode", "bot-full"]
[package.metadata.requires-dev]
-dev = [
- { name = "pytest", specifier = ">=9.0.2" },
- { name = "pytest-asyncio", specifier = ">=1.3.0" },
- { name = "pytest-cov", specifier = ">=7.0.0" },
-]
+dev = [{ name = "pytest", specifier = ">=9.0.2" }]
[[package]]
name = "orjson"
@@ -4238,27 +4191,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/50/f2/c0e76a0b451ffdf0cf788932e182758eb7558953f4f27f1aff8e2518b653/pyarrow-23.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:527e8d899f14bd15b740cd5a54ad56b7f98044955373a17179d5956ddb93d9ce", size = 28365807, upload-time = "2026-02-16T10:14:03.892Z" },
]
-[[package]]
-name = "pyasn1"
-version = "0.6.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/b6/6e630dff89739fcd427e3f72b3d905ce0acb85a45d4ec3e2678718a3487f/pyasn1-0.6.2.tar.gz", hash = "sha256:9b59a2b25ba7e4f8197db7686c09fb33e658b98339fadb826e9512629017833b", size = 146586, upload-time = "2026-01-16T18:04:18.534Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/44/b5/a96872e5184f354da9c84ae119971a0a4c221fe9b27a4d94bd43f2596727/pyasn1-0.6.2-py3-none-any.whl", hash = "sha256:1eb26d860996a18e9b6ed05e7aae0e9fc21619fcee6af91cca9bad4fbea224bf", size = 83371, upload-time = "2026-01-16T18:04:17.174Z" },
-]
-
-[[package]]
-name = "pyasn1-modules"
-version = "0.4.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
- { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
-]
-
[[package]]
name = "pybind11"
version = "3.0.2"