crewplus 0.2.99__tar.gz → 0.3.2__tar.gz

{crewplus-0.2.99 → crewplus-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.2.99
+Version: 0.3.2
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/your-org/crewplus-base/issues
 Requires-Python: <4.0,>=3.11
 Requires-Dist: langchain<1.0.0,>=0.3.25
 Requires-Dist: langchain-openai>=0.3.24
-Requires-Dist: google-genai>=1.21.1
+Requires-Dist: google-genai>=1.51.0
 Requires-Dist: anthropic[vertex]>=0.76.0
 Requires-Dist: langchain-milvus<0.3.0,>=0.2.1
 Requires-Dist: langfuse<4.0.0,>=3.1.3

{crewplus-0.2.99 → crewplus-0.3.2}/crewplus/services/gemini_chat_model.py

@@ -257,6 +257,17 @@ class GeminiChatModel(BaseChatModel):
     max_tokens: Optional[int] = Field(default=None, description="Maximum tokens to generate")
     top_p: Optional[float] = Field(default=None, description="Top-p sampling parameter")
     top_k: Optional[int] = Field(default=None, description="Top-k sampling parameter")
+
+    # Thinking configuration. All optional: when none of the three is set, no
+    # thinking_config is sent at all and the model's own default applies.
+    # Gemini 3.x takes thinking_level, Gemini 2.5 takes thinking_budget; sending
+    # both is rejected by the API, so _build_thinking_config picks one by model family.
+    thinking_level: Optional[str] = Field(
+        default=None, description="MINIMAL/LOW/MEDIUM/HIGH, Gemini 3.x only")
+    thinking_budget: Optional[int] = Field(
+        default=None, description="Thinking token budget, Gemini 2.5 only")
+    include_thoughts: Optional[bool] = Field(
+        default=None, description="Whether thought parts are returned in the response")
     
     # Vertex AI specific configuration
     use_vertex_ai: bool = Field(default=False, description="Use Vertex AI instead of Google AI Platform")
@@ -804,6 +815,33 @@ class GeminiChatModel(BaseChatModel):
             except Exception as e:
                 self.logger.error(f"Failed to process message part at index {i}: {part_spec}. Error: {e}", exc_info=True)
 
+    def _build_thinking_config(self) -> Optional[types.ThinkingConfig]:
+        """Builds the thinking config for the current model family.
+
+        Gemini 3.x accepts ``thinking_level`` (MINIMAL/LOW/MEDIUM/HIGH), Gemini 2.5
+        accepts ``thinking_budget`` (an integer). Passing both is rejected by the
+        service, so the parameter for the other family is ignored rather than being
+        an error -- that is what lets a single model config entry serve both
+        generations, so switching models only means changing deployment_name.
+
+        Returns None when nothing is configured, in which case the caller omits
+        thinking_config entirely and the model's default behaviour applies.
+        """
+        is_gemini3 = self.model_name.startswith("gemini-3")
+        kwargs: Dict[str, Any] = {}
+
+        value = self.thinking_level if is_gemini3 else self.thinking_budget
+        if value is not None:
+            if is_gemini3:
+                kwargs["thinking_level"] = str(value).upper()
+            else:
+                kwargs["thinking_budget"] = int(value)
+
+        if self.include_thoughts is not None:
+            kwargs["include_thoughts"] = self.include_thoughts
+
+        return types.ThinkingConfig(**kwargs) if kwargs else None
+
     def _prepare_generation_config(
         self,
         messages: List[BaseMessage],
@@ -826,6 +864,12 @@ class GeminiChatModel(BaseChatModel):
         if stop:
             config_params["stop_sequences"] = stop
 
+        # Omit thinking_config entirely when nothing is configured, so the model
+        # default applies instead of us pinning a tier.
+        thinking_config = self._build_thinking_config()
+        if thinking_config is not None:
+            config_params["thinking_config"] = thinking_config
+
         # Handle system instructions
         system_prompts = [msg.content for msg in messages if isinstance(msg, SystemMessage) and msg.content]
         if system_prompts:

{crewplus-0.2.99 → crewplus-0.3.2}/crewplus/services/model_load_balancer.py

@@ -57,6 +57,13 @@ class ModelLoadBalancer:
         "code_execution": None,
         "url_context": None,
     }
+
+    # Gemini thinking parameters. Passed through only when present in the model
+    # config, so an entry that omits them leaves the model fields at None and no
+    # thinking_config reaches the API. GeminiChatModel picks thinking_level for
+    # Gemini 3.x and thinking_budget for Gemini 2.5, ignoring the other one.
+    GEMINI_THINKING_KEYS = ("thinking_level", "thinking_budget", "include_thoughts")
+
     def __init__(self,
                  config_path: Optional[str] = "config/models_config.json",
                  config_data: Optional[Dict] = None,
@@ -267,6 +274,9 @@ class ModelLoadBalancer:
                 kwargs['temperature'] = model_config['temperature']
             if 'max_tokens' in model_config:
                 kwargs['max_tokens'] = model_config['max_tokens']
+            for key in self.GEMINI_THINKING_KEYS:
+                if key in model_config:
+                    kwargs[key] = model_config[key]
             if disable_streaming:
                 kwargs['disable_streaming'] = True
             return GeminiChatModel(**kwargs)
@@ -334,6 +344,9 @@ class ModelLoadBalancer:
                     kwargs['temperature'] = model_config['temperature']
                 if 'max_tokens' in model_config:
                     kwargs['max_tokens'] = model_config['max_tokens']
+                for key in self.GEMINI_THINKING_KEYS:
+                    if key in model_config:
+                        kwargs[key] = model_config[key]
                 if disable_streaming:
                     kwargs['disable_streaming'] = True
                 return GeminiChatModel(**kwargs)

crewplus-0.3.2/crewplus/services/runtime_model_factory.py

@@ -0,0 +1,400 @@
+import hashlib
+import json
+import logging
+import random
+import time
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+from langchain_openai import AzureOpenAIEmbeddings, ChatOpenAI, OpenAIEmbeddings
+
+from .azure_chat_model import TracedAzureChatOpenAI
+from .claude_chat_model import ClaudeChatModel
+from .gemini_chat_model import GeminiChatModel
+from .oai_claude_chat_model import OAIClaudeChatModel
+
+
+class RuntimeModelConfigError(ValueError):
+    """Raised when a runtime model policy is missing required fields."""
+
+
+def _first_present(data: Dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        value = data.get(key)
+        if value is not None and value != "":
+            return value
+    return None
+
+
+def _credentials(config: Dict[str, Any]) -> Dict[str, Any]:
+    creds = config.get("credentials") or {}
+    if not isinstance(creds, dict):
+        raise RuntimeModelConfigError("model credentials must be a dictionary")
+    return creds
+
+
+def _api_key(config: Dict[str, Any]) -> str:
+    creds = _credentials(config)
+    value = _first_present(config, "api_key", "apiKey") or _first_present(creds, "api_key", "apiKey")
+    if not value:
+        raise RuntimeModelConfigError("model apiKey is required")
+    return str(value)
+
+
+def _provider_type(config: Dict[str, Any]) -> str:
+    provider = _first_present(config, "providerType", "provider_type", "provider")
+    if not provider:
+        raise RuntimeModelConfigError("model providerType is required")
+    return str(provider).strip().lower().replace("-", "_")
+
+
+def _model_id(config: Dict[str, Any]) -> str:
+    value = _first_present(config, "modelId", "model_id", "model", "modelName", "model_name")
+    if not value:
+        raise RuntimeModelConfigError("modelId is required")
+    return str(value)
+
+
+def _deployment_name(config: Dict[str, Any]) -> str:
+    return str(_first_present(config, "deploymentName", "deployment_name", "deployment") or _model_id(config))
+
+
+def _base_url(config: Dict[str, Any]) -> Optional[str]:
+    value = _first_present(config, "baseUrl", "base_url", "apiBase", "api_base", "azureEndpoint", "azure_endpoint")
+    return str(value).rstrip("/") if value else None
+
+
+def _api_version(config: Dict[str, Any]) -> Optional[str]:
+    value = _first_present(config, "apiVersion", "api_version", "openaiApiVersion", "openai_api_version")
+    return str(value) if value else None
+
+
+def _dimensions(config: Dict[str, Any]) -> Optional[int]:
+    value = _first_present(config, "dimensions", "embeddingDimensions", "embedding_dims")
+    if value is None:
+        return None
+    return int(value)
+
+
+def _with_v1(base_url: str) -> str:
+    normalized = base_url.rstrip("/")
+    if normalized.endswith("/v1"):
+        return normalized
+    return f"{normalized}/v1"
+
+
+def model_config_fingerprint(config: Dict[str, Any]) -> str:
+    """Return a stable fingerprint that avoids storing secrets in cache keys."""
+    redacted = dict(config)
+    creds = _credentials(config) if isinstance(config.get("credentials"), dict) else {}
+    if creds:
+        secret_payload = json.dumps(creds, sort_keys=True, default=str)
+        redacted["credentials"] = {
+            "secret_hash": hashlib.sha256(secret_payload.encode("utf-8")).hexdigest()
+        }
+    payload = json.dumps(redacted, sort_keys=True, default=str)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+class RuntimeModelFactory:
+    """
+    Creates model instances from runtime dictionaries without modifying the
+    process-wide ModelLoadBalancer or environment variables.
+    """
+
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.logger = logger or logging.getLogger(__name__)
+        self._cache: Dict[str, Any] = {}
+
+    def create_embedding_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "embedding", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_embedding(model_config)
+        return self._cache[cache_key]
+
+    def create_vision_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "vision", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_chat_model(model_config)
+        return self._cache[cache_key]
+
+    def create_chat_model(self, model_config: Dict[str, Any], *, cache_scope: str = "runtime"):
+        cache_key = self._cache_key(cache_scope, "chat", model_config)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self._instantiate_chat_model(model_config)
+        return self._cache[cache_key]
+
+    def _cache_key(self, scope: str, capability: str, model_config: Dict[str, Any]) -> str:
+        tenant = _first_present(model_config, "tenantId", "tenant_id") or scope
+        connection_id = _first_present(model_config, "connectionId", "connection_id") or "no-connection"
+        return f"{tenant}:{connection_id}:{capability}:{model_config_fingerprint(model_config)}"
+
+    def _instantiate_embedding(self, model_config: Dict[str, Any]):
+        provider = _provider_type(model_config)
+        model = _model_id(model_config)
+        api_key = _api_key(model_config)
+        dimensions = _dimensions(model_config)
+
+        if provider in {"azure_openai", "azure_openai_embeddings"}:
+            api_version = _api_version(model_config)
+            base_url = _base_url(model_config)
+            if not api_version:
+                raise RuntimeModelConfigError("apiVersion is required for Azure OpenAI embeddings")
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Azure OpenAI embeddings")
+
+            kwargs = {
+                "model": model,
+                "azure_deployment": _deployment_name(model_config),
+                "openai_api_version": api_version,
+                "api_key": api_key,
+                "azure_endpoint": base_url,
+                "chunk_size": int(model_config.get("chunk_size", 16)),
+                "request_timeout": int(model_config.get("request_timeout", 60)),
+                "max_retries": int(model_config.get("max_retries", 2)),
+            }
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return AzureOpenAIEmbeddings(**kwargs)
+
+        if provider == "openai":
+            kwargs = {"model": model, "api_key": api_key}
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return OpenAIEmbeddings(**kwargs)
+
+        if provider == "openai_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for OpenAI-compatible embeddings")
+            kwargs = {"model": model, "api_key": api_key, "base_url": _with_v1(base_url)}
+            if dimensions is not None:
+                kwargs["dimensions"] = dimensions
+            return OpenAIEmbeddings(**kwargs)
+
+        raise RuntimeModelConfigError(f"Unsupported runtime embedding provider: {provider}")
+
+    def _instantiate_chat_model(self, model_config: Dict[str, Any]):
+        provider = _provider_type(model_config)
+        model = _model_id(model_config)
+        api_key = _api_key(model_config) if provider not in {"vertex_google", "vertex_anthropic", "vertex_ai"} else None
+        temperature = float(model_config.get("temperature", 0.0))
+        max_tokens = model_config.get("max_tokens")
+        disable_streaming = bool(model_config.get("disable_streaming", False))
+
+        if provider == "azure_openai":
+            api_version = _api_version(model_config)
+            base_url = _base_url(model_config)
+            if not api_version:
+                raise RuntimeModelConfigError("apiVersion is required for Azure OpenAI models")
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Azure OpenAI models")
+            kwargs = {
+                "azure_deployment": _deployment_name(model_config),
+                "openai_api_version": api_version,
+                "azure_endpoint": base_url,
+                "openai_api_key": api_key,
+                "temperature": temperature,
+            }
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return TracedAzureChatOpenAI(**kwargs)
+
+        if provider == "openai":
+            kwargs = {"model": model, "openai_api_key": api_key, "temperature": temperature}
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ChatOpenAI(**kwargs)
+
+        if provider == "openai_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for OpenAI-compatible models")
+            kwargs = {
+                "model": model,
+                "openai_api_key": api_key,
+                "base_url": _with_v1(base_url),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ChatOpenAI(**kwargs)
+
+        if provider == "google":
+            kwargs = {
+                "google_api_key": api_key,
+                "model_name": _deployment_name(model_config),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return GeminiChatModel(**kwargs)
+
+        if provider in {"vertex_google", "vertex_ai"}:
+            project_id = _first_present(model_config, "projectId", "project_id", "gcpProjectId", "gcp_project_id")
+            location = _first_present(model_config, "location", "region", "gcpRegion", "gcp_region")
+            if not project_id or not location:
+                raise RuntimeModelConfigError("projectId and location are required for Vertex AI models")
+            kwargs = {
+                "use_vertex_ai": True,
+                "model_name": _deployment_name(model_config).split("@")[0],
+                "project_id": str(project_id),
+                "location": str(location),
+                "temperature": temperature,
+            }
+            service_account_file = _first_present(model_config, "serviceAccountFile", "service_account_file")
+            if service_account_file:
+                kwargs["service_account_file"] = str(service_account_file)
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return GeminiChatModel(**kwargs)
+
+        if provider == "vertex_anthropic":
+            project_id = _first_present(model_config, "projectId", "project_id", "gcpProjectId", "gcp_project_id")
+            location = _first_present(model_config, "location", "region", "gcpRegion", "gcp_region")
+            if not project_id or not location:
+                raise RuntimeModelConfigError("projectId and location are required for Vertex Anthropic models")
+            kwargs = {
+                "model_name": _deployment_name(model_config).split("@")[0],
+                "project_id": str(project_id),
+                "location": str(location),
+                "temperature": temperature,
+            }
+            service_account_file = _first_present(model_config, "serviceAccountFile", "service_account_file")
+            if service_account_file:
+                kwargs["service_account_file"] = str(service_account_file)
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ClaudeChatModel(**kwargs)
+
+        if provider == "anthropic_compat":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for Anthropic-compatible models")
+            kwargs = {
+                "model_name": _deployment_name(model_config),
+                "use_custom_endpoint": True,
+                "api_key": api_key,
+                "base_url": base_url,
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["disable_streaming"] = True
+            return ClaudeChatModel(**kwargs)
+
+        if provider == "custom_openai":
+            base_url = _base_url(model_config)
+            if not base_url:
+                raise RuntimeModelConfigError("baseUrl is required for custom OpenAI-compatible Claude models")
+            kwargs = {
+                "model": _deployment_name(model_config),
+                "api_key": api_key,
+                "base_url": _with_v1(base_url),
+                "capabilities_config": model_config.get("capabilities", {}),
+                "temperature": temperature,
+            }
+            if max_tokens is not None:
+                kwargs["max_tokens"] = int(max_tokens)
+            if disable_streaming:
+                kwargs["streaming"] = False
+            return OAIClaudeChatModel(**kwargs)
+
+        raise RuntimeModelConfigError(f"Unsupported runtime chat provider: {provider}")
+
+
+class RuntimeModelPool:
+    """Selects runtime models from a capability-specific model pool."""
+
+    RETRYABLE_STATUS_MARKERS = ("429", "408", "500", "502", "503", "504", "timeout", "temporarily", "rate limit")
+
+    def __init__(
+        self,
+        factory: Optional[RuntimeModelFactory] = None,
+        logger: Optional[logging.Logger] = None,
+        cooldown_seconds: int = 60,
+        max_cooldown_seconds: int = 300,
+    ):
+        self.factory = factory or RuntimeModelFactory(logger=logger)
+        self.logger = logger or logging.getLogger(__name__)
+        self.cooldown_seconds = cooldown_seconds
+        self.max_cooldown_seconds = max_cooldown_seconds
+        self._cooldowns: Dict[str, float] = {}
+        self._failures: Dict[str, int] = {}
+
+    def select_model(self, policy: Dict[str, Any], capability: str) -> Dict[str, Any]:
+        candidates = self._active_candidates(policy, capability)
+        strategy = str((policy.get(capability) or {}).get("selectionStrategy") or policy.get("selectionStrategy") or "random")
+        if strategy == "weighted_random":
+            return self._weighted_random(candidates)
+        return random.choice(candidates)
+
+    def get_model(self, policy: Dict[str, Any], capability: str, *, cache_scope: str = "runtime") -> Tuple[Any, Dict[str, Any]]:
+        selected = self.select_model(policy, capability)
+        if capability == "embedding":
+            model = self.factory.create_embedding_model(selected, cache_scope=cache_scope)
+        elif capability == "vision":
+            model = self.factory.create_vision_model(selected, cache_scope=cache_scope)
+        else:
+            model = self.factory.create_chat_model(selected, cache_scope=cache_scope)
+        return model, selected
+
+    def report_success(self, model_key: str) -> None:
+        self._failures.pop(model_key, None)
+
+    def report_failure(self, model_key: str, error: Exception) -> None:
+        self._failures[model_key] = self._failures.get(model_key, 0) + 1
+        if self.is_retryable_error(error):
+            retry_after = self._retry_after_seconds(error)
+            cooldown = retry_after if retry_after is not None else self.cooldown_seconds
+            cooldown = min(cooldown, self.max_cooldown_seconds)
+            self._cooldowns[model_key] = time.time() + cooldown
+
+    def model_key(self, model_config: Dict[str, Any]) -> str:
+        connection_id = _first_present(model_config, "connectionId", "connection_id") or "no-connection"
+        return f"{connection_id}:{_provider_type(model_config)}:{_deployment_name(model_config)}:{model_config_fingerprint(model_config)}"
+
+    def is_retryable_error(self, error: Exception) -> bool:
+        text = str(error).lower()
+        return any(marker in text for marker in self.RETRYABLE_STATUS_MARKERS)
+
+    def _active_candidates(self, policy: Dict[str, Any], capability: str) -> List[Dict[str, Any]]:
+        section = policy.get(capability) or {}
+        models = section.get("models")
+        if not isinstance(models, list) or not models:
+            raise RuntimeModelConfigError(f"No runtime models configured for capability: {capability}")
+
+        now = time.time()
+        active = [model for model in models if self._cooldowns.get(self.model_key(model), 0) <= now]
+        return active or models
+
+    def _weighted_random(self, candidates: Iterable[Dict[str, Any]]) -> Dict[str, Any]:
+        items = list(candidates)
+        weights = [max(float(item.get("weight", 1) or 1), 0.0) for item in items]
+        if not any(weights):
+            return random.choice(items)
+        return random.choices(items, weights=weights, k=1)[0]
+
+    def _retry_after_seconds(self, error: Exception) -> Optional[int]:
+        retry_after = getattr(error, "retry_after", None)
+        if retry_after is None:
+            response = getattr(error, "response", None)
+            headers = getattr(response, "headers", None)
+            if headers:
+                retry_after = headers.get("Retry-After") or headers.get("retry-after")
+        if retry_after is None:
+            return None
+        try:
+            return int(float(retry_after))
+        except (TypeError, ValueError):
+            return None

{crewplus-0.2.99 → crewplus-0.3.2}/crewplus/vectorstores/milvus/vdb_service.py

@@ -9,7 +9,7 @@ import logging
 import time
 import uuid
 from collections import defaultdict
-from typing import List, Dict, Optional
+from typing import AsyncIterator, List, Dict, Optional, Any
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
@@ -797,6 +797,81 @@ class VDBService(object):
         except Exception as e:
             raise RuntimeError(f"delete collection data failed: {str(e)}")
 
+    async def aquery_rows(
+        self,
+        *,
+        collection_name: str,
+        filter_expr: str,
+        output_fields: List[str],
+        limit: int,
+        offset: int = 0,
+    ) -> List[dict[str, Any]]:
+        if not collection_name:
+            raise ValueError("collection_name must be provided.")
+        if limit <= 0:
+            return []
+        store = await self.aget_vector_store(collection_name)
+        collection = getattr(store, "col", None)
+        if collection is None:
+            raise RuntimeError(
+                "The vector store instance does not expose a pymilvus Collection via `.col`."
+            )
+        return await asyncio.to_thread(
+            collection.query,
+            expr=filter_expr,
+            output_fields=output_fields,
+            limit=limit,
+            offset=offset,
+        )
+
+    async def aiter_query_rows(
+        self,
+        *,
+        collection_name: str,
+        filter_expr: str,
+        output_fields: List[str],
+        batch_size: int,
+    ) -> AsyncIterator[List[dict[str, Any]]]:
+        if not collection_name:
+            raise ValueError("collection_name must be provided.")
+        if batch_size <= 0:
+            return
+        store = await self.aget_vector_store(collection_name)
+        collection = getattr(store, "col", None)
+        if collection is None:
+            raise RuntimeError(
+                "The vector store instance does not expose a pymilvus Collection via `.col`."
+            )
+        iterator = await asyncio.to_thread(
+            collection.query_iterator,
+            expr=filter_expr,
+            output_fields=output_fields,
+            batch_size=batch_size,
+        )
+        try:
+            while True:
+                batch_rows = await asyncio.to_thread(iterator.next)
+                if not batch_rows:
+                    break
+                yield batch_rows
+        finally:
+            await asyncio.to_thread(iterator.close)
+
+    async def asimilarity_search_with_score(
+        self,
+        *,
+        collection_name: str,
+        query: str,
+        k: int,
+        expr: str | None = None,
+        embeddings: Embeddings | None = None,
+    ) -> list[tuple[Document, float]]:
+        store = await self.aget_vector_store(collection_name, embeddings)
+        kwargs: dict[str, Any] = {"k": k}
+        if expr:
+            kwargs["expr"] = expr
+        return await asyncio.to_thread(store.similarity_search_with_score, query, **kwargs)
+
     async def aget_docs_by_ids(self, collection_names: List[str], ids: List[str], embeddings: Embeddings, output_fields: List[str] = None) -> List[Document]:
         """
         Retrieves documents from multiple collections by their primary key IDs using a direct query.

{crewplus-0.2.99 → crewplus-0.3.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "crewplus"
-version = "0.2.99"
+version = "0.3.2"
 description = "Base services for CrewPlus AI applications"
 authors = [
     { name = "Tim Liu", email = "tim@opsmateai.com" },
@@ -16,7 +16,7 @@ requires-python = ">=3.11,<4.0"
 dependencies = [
     "langchain>=0.3.25, <1.0.0",
     "langchain-openai>=0.3.24",
-    "google-genai>=1.21.1",
+    "google-genai>=1.51.0",
     "anthropic[vertex]>=0.76.0",
     "langchain-milvus (>=0.2.1,<0.3.0)",
     "langfuse (>=3.1.3,<4.0.0)",