Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
feat(embedder): Gemini Embedding 2 multimodal support (text + image/video/audio/PDF) (#607)
chethanuk95bd19797f27
diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.mdindex 7c2779b60..15609f402 100644--- a/docs/en/guides/01-configuration.md+++ b/docs/en/guides/01-configuration.md@@ -87,6 +87,32 @@ 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@@ -115,7 +141,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"`, or `"voyage"` |+| `provider` | str | `"volcengine"`, `"openai"`, `"vikingdb"`, `"jina"`, `"gemini"` or `"gemini"` || `api_key` | str | API key || `model` | str | Model name || `dimension` | int | Vector dimension. For Voyage, this maps to `output_dimension` |@@ -136,6 +162,7 @@ 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:**@@ -176,6 +203,22 @@ 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:**```jsondiff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.mdindex 889c737ab..02b551b1f 100644--- a/docs/zh/guides/01-configuration.md+++ b/docs/zh/guides/01-configuration.md@@ -92,6 +92,32 @@ 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@@ -121,7 +147,7 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支| 参数 | 类型 | 说明 ||------|------|------|| `max_concurrent` | int | 最大并发 Embedding 请求数(`embedding.max_concurrent`,默认:`10`) |-| `provider` | str | `"volcengine"`、`"openai"`、`"vikingdb"` 或 `"jina"` |+| `provider` | str | `"volcengine"`、`"openai"`、`"vikingdb"`、`"jina"` 或 `"gemini"` || `api_key` | str | API Key || `model` | str | 模型名称 || `dimension` | int | 向量维度 |@@ -142,6 +168,7 @@ OpenViking 使用 JSON 配置文件(`ov.conf`)进行设置。配置文件支- `volcengine`: 火山引擎 Embedding API- `vikingdb`: VikingDB Embedding API- `jina`: Jina AI Embedding API+- `gemini`: Google Gemini Embedding API**vikingdb provider 配置示例:**@@ -179,6 +206,22 @@ 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` 指向本地端点:```jsondiff --git a/examples/ov.conf.gemini.example b/examples/ov.conf.gemini.examplenew file mode 100644index 000000000..0aa36cb6e--- /dev/null+++ b/examples/ov.conf.gemini.example@@ -0,0 +1,16 @@+{+ "_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.pyindex 763085703..530a4dd96 100644--- a/openviking/core/context.py+++ b/openviking/core/context.py@@ -2,6 +2,7 @@# SPDX-License-Identifier: Apache-2.0"""Unified context class for OpenViking."""+from dataclasses import dataclass, fieldfrom datetime import datetime, timezonefrom enum import Enumfrom typing import Any, Dict, List, Optional@@ -37,14 +38,27 @@ 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 = ""):+ def __init__(self, text: str = "", media: Optional[ModalContent] = None):self.text = text+ self.media = mediaclass Context:diff --git a/openviking/models/embedder/__init__.py b/openviking/models/embedder/__init__.pyindex b418b8091..3fc66a060 100644--- a/openviking/models/embedder/__init__.py+++ b/openviking/models/embedder/__init__.py@@ -12,6 +12,7 @@ Supported providers:- OpenAI: Dense only- Volcengine: Dense, Sparse, Hybrid- Jina AI: Dense only+- Google Gemini: Dense only (multimodal)- Voyage AI: Dense only"""@@ -23,6 +24,7 @@ from openviking.models.embedder.base import (HybridEmbedderBase,SparseEmbedderBase,)+from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedderfrom openviking.models.embedder.jina_embedders import JinaDenseEmbedderfrom openviking.models.embedder.openai_embedders import OpenAIDenseEmbedderfrom openviking.models.embedder.voyage_embedders import VoyageDenseEmbedder@@ -45,6 +47,8 @@ __all__ = ["SparseEmbedderBase","HybridEmbedderBase","CompositeHybridEmbedder",+ # Google Gemini implementations+ "GeminiDenseEmbedder",# Jina AI implementations"JinaDenseEmbedder",# OpenAI implementationsdiff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.pyindex 858325d5f..77db335ad 100644--- a/openviking/models/embedder/base.py+++ b/openviking/models/embedder/base.py@@ -319,6 +319,15 @@ 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 vectorsdiff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.pynew file mode 100644index 000000000..2f003717e--- /dev/null+++ b/openviking/models/embedder/gemini_embedders.py@@ -0,0 +1,155 @@+# 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:+ passdiff --git a/openviking/storage/collection_schemas.py b/openviking/storage/collection_schemas.pyindex c46f2d769..d5cbd11ca 100644--- a/openviking/storage/collection_schemas.py+++ b/openviking/storage/collection_schemas.py@@ -11,6 +11,7 @@ import asyncioimport hashlibimport jsonimport threading+import tracebackfrom contextlib import nullcontextfrom dataclasses import dataclassfrom typing import Any, Dict, List, Optional@@ -25,6 +26,7 @@ from openviking.storage.viking_vector_index_backend import VikingVectorIndexBackfrom openviking.telemetry import bind_telemetry, resolve_telemetryfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils import get_logger+from openviking_cli.utils.config import get_openviking_configfrom openviking_cli.utils.config.open_viking_config import OpenVikingConfiglogger = get_logger(__name__)@@ -119,8 +121,6 @@ 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.namevector_dim = config.embedding.dimension@@ -154,8 +154,6 @@ class TextEmbeddingHandler(DequeueHandlerBase):Args:vikingdb: VikingVectorIndexBackend instance for writing to vector database"""- from openviking_cli.utils.config import get_openviking_config-self._vikingdb = vikingdbself._embedder = Noneconfig = get_openviking_config()@@ -246,11 +244,58 @@ class TextEmbeddingHandler(DequeueHandlerBase):# Generate embedding vector(s)if self._embedder:try:- # 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- )+ # 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+ )except Exception as embed_err:error_msg = f"Failed to generate embedding: {embed_err}"logger.error(error_msg)@@ -333,8 +378,6 @@ class TextEmbeddingHandler(DequeueHandlerBase):self.report_success()return Nonelogger.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)@@ -346,8 +389,6 @@ 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.pyindex af0e95eea..868aba3ce 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.0import json-from dataclasses import asdict, dataclass+from dataclasses import asdict, dataclass, fieldfrom typing import Any, Dict, List, Optional, Unionfrom uuid import uuid4@@ -11,6 +11,9 @@ 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] = Nonedef __init__(@@ -41,9 +44,11 @@ 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@classmethoddiff --git a/openviking/storage/queuefs/embedding_msg_converter.py b/openviking/storage/queuefs/embedding_msg_converter.pyindex 133d0de6b..acdb3805b 100644--- a/openviking/storage/queuefs/embedding_msg_converter.py+++ b/openviking/storage/queuefs/embedding_msg_converter.py@@ -24,6 +24,9 @@ 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@@ -69,9 +72,17 @@ 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_msgdiff --git a/openviking/storage/queuefs/semantic_processor.py b/openviking/storage/queuefs/semantic_processor.pyindex b4c9ac5c6..c393c2669 100644--- a/openviking/storage/queuefs/semantic_processor.py+++ b/openviking/storage/queuefs/semantic_processor.py@@ -1022,6 +1022,14 @@ 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_ctxawait vectorize_file(file_path=file_path,@@ -1029,5 +1037,6 @@ 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.pyindex 9a2f9d2d5..77f377192 100644--- a/openviking/utils/embedding_utils.py+++ b/openviking/utils/embedding_utils.py@@ -19,6 +19,52 @@ from openviking_cli.utils import VikingURI, get_loggerlogger = 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:@@ -212,6 +258,7 @@ 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:"""@@ -247,7 +294,8 @@ async def vectorize_file()content_type = get_resource_content_type(file_name)- if content_type is None:+ is_pdf = os.path.splitext(file_name.lower())[1] == ".pdf"+ if content_type is None and not is_pdf:# Unsupported file type: fall back to summary if availableif summary:logger.warning(@@ -268,15 +316,26 @@ 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}"+ f"Failed to read file content for {file_path}, falling back to summary: {e}",+ exc_info=True,)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")+ returnelif summary:- # For non-text files, use summary+ # Fallback for unrecognized non-text filescontext.set_vectorize(Vectorize(text=summary))else:logger.debug(f"Skipping file {file_path} (no text content or summary)")@@ -301,6 +360,7 @@ 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.@@ -349,7 +409,11 @@ 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+ file_path=file_uri,+ summary_dict={"name": file_name},+ parent_uri=uri,+ ctx=ctx,+ embedding_provider=embedding_provider,)except Exception as e:diff --git a/openviking/utils/resource_processor.py b/openviking/utils/resource_processor.pyindex bd56a2eae..3e0d03b99 100644--- a/openviking/utils/resource_processor.py+++ b/openviking/utils/resource_processor.py@@ -84,8 +84,17 @@ 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 = Nonefor uri in resource_uris:- await index_resource(uri, ctx)+ await index_resource(uri, ctx, embedding_provider=embedding_provider)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.pyindex 55dd2a6c2..bf5839744 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', 'voyage'. "+ "Provider type: 'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'gemini'", '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'",+ description="Backend type (Deprecated, use 'provider' instead): 'openai', 'volcengine', 'vikingdb', 'voyage'", 'gemini'",)version: Optional[str] = Field(default=None, description="Model version")ak: Optional[str] = Field(default=None, description="Access Key ID for VikingDB API")@@ -59,6 +59,9 @@ 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=(@@ -103,10 +106,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"]:+ if self.provider not in ["openai", "volcengine", "vikingdb", "jina", "ollama", "voyage", "gemini"]:raise ValueError(f"Invalid embedding provider: '{self.provider}'. Must be one of: "- "'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage'"+ "'openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage'", 'gemini'")# Provider-specific validation@@ -141,6 +144,9 @@ 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")@@ -165,7 +171,7 @@ class EmbeddingModelConfig(BaseModel):class EmbeddingConfig(BaseModel):"""- Embedding configuration, supports OpenAI or VolcEngine compatible APIs.+ Embedding configuration, supports OpenAI, VolcEngine, VikingDB, Jina, or Gemini APIs.Structure:- dense: Configuration for dense embedder@@ -204,7 +210,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')+ provider: Provider type ('openai', 'volcengine', 'vikingdb', 'jina', 'ollama', 'voyage', 'gemini'))embedder_type: Embedder type ('dense', 'sparse', 'hybrid')config: EmbeddingModelConfig instancecontext: Optional embedding context ('query' or 'document') for non-symmetric models.@@ -228,6 +234,7 @@ class EmbeddingConfig(BaseModel):VolcengineSparseEmbedder,VoyageDenseEmbedder,)+ from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder# Factory registry: (provider, type) -> (embedder_class, param_builder)factory_registry = {@@ -323,6 +330,15 @@ 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.tomlindex c26aa7cfc..471085a56 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -70,6 +70,7 @@ 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]@@ -84,7 +85,9 @@ 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",@@ -208,6 +211,9 @@ 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@@ -246,4 +252,6 @@ 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.pynew file mode 100644index 000000000..37e4c75ad--- /dev/null+++ b/tests/integration/test_gemini_e2e.py@@ -0,0 +1,154 @@+# 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.pyindex 1ab715170..c5a64d3c1 100644--- a/tests/misc/test_config_validation.py+++ b/tests/misc/test_config_validation.py@@ -250,6 +250,52 @@ 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.pyindex c25dbbda6..0d6aff6c9 100644--- a/tests/storage/test_collection_schemas.py+++ b/tests/storage/test_collection_schemas.py@@ -3,6 +3,7 @@import jsonfrom types import SimpleNamespace+from unittest.mock import patchimport pytest@@ -52,7 +53,7 @@ async def test_embedding_handler_skip_all_work_when_manager_is_closing(monkeypatembedder = _DummyEmbedder()monkeypatch.setattr(- "openviking_cli.utils.config.get_openviking_config",+ "openviking.storage.collection_schemas.get_openviking_config",lambda: _DummyConfig(embedder),)@@ -85,7 +86,7 @@ async def test_embedding_handler_treats_shutdown_write_lock_as_success(monkeypatembedder = _DummyEmbedder()monkeypatch.setattr(- "openviking_cli.utils.config.get_openviking_config",+ "openviking.storage.collection_schemas.get_openviking_config",lambda: _DummyConfig(embedder),)@@ -104,3 +105,146 @@ async def test_embedding_handler_treats_shutdown_write_lock_as_success(monkeypatassert embedder.calls == 1assert status["success"] == 1assert 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 == 1diff --git a/tests/storage/test_embedding_msg_converter_tenant.py b/tests/storage/test_embedding_msg_converter_tenant.pyindex 047c13cc6..05ca59143 100644--- a/tests/storage/test_embedding_msg_converter_tenant.py+++ b/tests/storage/test_embedding_msg_converter_tenant.py@@ -5,7 +5,8 @@import pytest-from openviking.core.context import Context+from openviking.core.context import Context, ModalContent, Vectorize+from openviking.storage.queuefs.embedding_msg import EmbeddingMsgfrom openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverterfrom openviking_cli.session.user_id import UserIdentifier@@ -40,3 +41,66 @@ def test_embedding_msg_converter_backfills_account_and_owner_space(uri, expectedassert msg is not Noneassert 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-emptydiff --git a/tests/unit/test_context_vectorize.py b/tests/unit/test_context_vectorize.pynew file mode 100644index 000000000..9191ebe2f--- /dev/null+++ b/tests/unit/test_context_vectorize.py@@ -0,0 +1,35 @@+# 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.pynew file mode 100644index 000000000..f3ae93911--- /dev/null+++ b/tests/unit/test_embedder_base_multimodal.py@@ -0,0 +1,35 @@+# 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.pynew file mode 100644index 000000000..afb408134--- /dev/null+++ b/tests/unit/test_embedding_msg.py@@ -0,0 +1,34 @@+# 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.pynew file mode 100644index 000000000..ec82aa889--- /dev/null+++ b/tests/unit/test_embedding_utils_mime.py@@ -0,0 +1,120 @@+# 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"),+ ("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.pynew file mode 100644index 000000000..dc37df828--- /dev/null+++ b/tests/unit/test_gemini_embedder.py@@ -0,0 +1,219 @@+# 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.lockindex 59e6638e3..195a75bba 100644--- a/uv.lock+++ b/uv.lock@@ -1,5 +1,5 @@version = 1-revision = 2+revision = 3requires-python = ">=3.10"resolution-markers = ["python_full_version >= '3.14' and sys_platform == 'win32'",@@ -1375,6 +1375,45 @@ 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"@@ -3246,6 +3285,7 @@ dependencies = [{ name = "apscheduler" },{ name = "ebooklib" },{ name = "fastapi" },+ { name = "google-genai" },{ name = "httpx" },{ name = "jinja2" },{ name = "json-repair" },@@ -3406,6 +3446,8 @@ test = [[package.dev-dependencies]dev = [{ name = "pytest" },+ { name = "pytest-asyncio" },+ { name = "pytest-cov" },][package.metadata]@@ -3424,6 +3466,7 @@ 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" },@@ -3505,7 +3548,11 @@ 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" }]+dev = [+ { name = "pytest", specifier = ">=9.0.2" },+ { name = "pytest-asyncio", specifier = ">=1.3.0" },+ { name = "pytest-cov", specifier = ">=7.0.0" },+][[package]]name = "orjson"@@ -4191,6 +4238,27 @@ 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"