llama-stack 0.4.3__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

llama_stack/providers/utils/memory/openai_vector_store_mixin.py

@@ -671,6 +671,19 @@ class OpenAIVectorStoreMixin(ABC):
             search_query = query
 
         try:
+            # Validate neural ranker requires model parameter
+            if ranking_options is not None:
+                if getattr(ranking_options, "ranker", None) == "neural":
+                    model_value = getattr(ranking_options, "model", None)
+                    if model_value is None or (isinstance(model_value, str) and model_value.strip() == ""):
+                        # Return empty results when model is missing for neural ranker
+                        logger.warning("model parameter is required when ranker='neural', returning empty results")
+                        return VectorStoreSearchResponsePage(
+                            search_query=query if isinstance(query, list) else [query],
+                            data=[],
+                            has_more=False,
+                            next_page=None,
+                        )
             score_threshold = (
                 ranking_options.score_threshold
                 if ranking_options and ranking_options.score_threshold is not None
@@ -681,7 +694,10 @@ class OpenAIVectorStoreMixin(ABC):
                 "score_threshold": score_threshold,
                 "mode": search_mode,
             }
-            # TODO: Add support for ranking_options.ranker
+
+            # Use VectorStoresConfig defaults when ranking_options values are not provided
+            config = self.vector_stores_config or VectorStoresConfig()
+            params.update(self._build_reranker_params(ranking_options, config))
 
             response = await self.query_chunks(
                 vector_store_id=vector_store_id,
@@ -722,8 +738,8 @@ class OpenAIVectorStoreMixin(ABC):
             )
 
         except Exception as e:
+            # Log the error and return empty results
             logger.error(f"Error searching vector store {vector_store_id}: {e}")
-            # Return empty results on error
             return VectorStoreSearchResponsePage(
                 search_query=query if isinstance(query, list) else [query],
                 data=[],
@@ -731,6 +747,62 @@ class OpenAIVectorStoreMixin(ABC):
                 next_page=None,
             )
 
+    def _build_reranker_params(
+        self,
+        ranking_options: SearchRankingOptions | None,
+        config: VectorStoresConfig,
+    ) -> dict[str, Any]:
+        reranker_params: dict[str, Any] = {}
+        params: dict[str, Any] = {}
+
+        if ranking_options and ranking_options.ranker:
+            reranker_type = ranking_options.ranker
+
+            if ranking_options.ranker == "weighted":
+                alpha = ranking_options.alpha
+                if alpha is None:
+                    alpha = config.chunk_retrieval_params.weighted_search_alpha
+                reranker_params["alpha"] = alpha
+                if ranking_options.weights:
+                    reranker_params["weights"] = ranking_options.weights
+            elif ranking_options.ranker == "rrf":
+                # For RRF ranker, use impact_factor from request if provided, otherwise use VectorStoresConfig default
+                impact_factor = ranking_options.impact_factor
+                if impact_factor is None:
+                    impact_factor = config.chunk_retrieval_params.rrf_impact_factor
+                reranker_params["impact_factor"] = impact_factor
+                # If weights dict is provided (for neural combination), store it
+                if ranking_options.weights:
+                    reranker_params["weights"] = ranking_options.weights
+            elif ranking_options.ranker == "neural":
+                reranker_params["model"] = ranking_options.model
+            else:
+                logger.debug(f"Unknown ranker value: {ranking_options.ranker}, passing through")
+
+            params["reranker_type"] = reranker_type
+            params["reranker_params"] = reranker_params
+
+            # Store model and weights for neural reranking (TODO: implemented in Part II)
+            if ranking_options.model:
+                params["neural_model"] = ranking_options.model
+            if ranking_options.weights:
+                params["neural_weights"] = ranking_options.weights
+        elif ranking_options is None or ranking_options.ranker is None:
+            # No ranker specified in request - use VectorStoresConfig default
+            default_strategy = config.chunk_retrieval_params.default_reranker_strategy
+            if default_strategy in ("weighted", "rrf"):
+                params["reranker_type"] = default_strategy
+                reranker_params = {}
+
+                if default_strategy == "weighted":
+                    reranker_params["alpha"] = config.chunk_retrieval_params.weighted_search_alpha
+                elif default_strategy == "rrf":
+                    reranker_params["impact_factor"] = config.chunk_retrieval_params.rrf_impact_factor
+
+                params["reranker_params"] = reranker_params
+
+        return params
+
     def _matches_filters(self, metadata: dict[str, Any], filters: dict[str, Any]) -> bool:
         """Check if metadata matches the provided filters."""
         if not filters:
@@ -738,15 +810,29 @@ class OpenAIVectorStoreMixin(ABC):
 
         filter_type = filters.get("type")
 
+        if filter_type is None:
+            if "key" not in filters and "value" not in filters and "filters" not in filters:
+                for key, value in filters.items():
+                    if key not in metadata:
+                        return False
+                    if metadata[key] != value:
+                        return False
+                return True
+            else:
+                raise ValueError("Unsupported filter structure: missing 'type' field")
+
         if filter_type in ["eq", "ne", "gt", "gte", "lt", "lte"]:
             # Comparison filter
-            key = filters.get("key")
+            filter_key = filters.get("key")
             value = filters.get("value")
 
-            if key not in metadata:
+            if filter_key is None or not isinstance(filter_key, str):
+                return False
+
+            if filter_key not in metadata:
                 return False
 
-            metadata_value = metadata[key]
+            metadata_value = metadata[filter_key]
 
             if filter_type == "eq":
                 return bool(metadata_value == value)
@@ -901,6 +987,7 @@ class OpenAIVectorStoreMixin(ABC):
                 params = OpenAIEmbeddingsRequestWithExtraBody(
                     model=embedding_model,
                     input=[interleaved_content_as_str(c.content) for c in chunks],
+                    dimensions=embedding_dimension,
                 )
                 resp = await self.inference_api.openai_embeddings(params)
 

llama_stack/providers/utils/memory/vector_store.py

@@ -297,37 +297,64 @@ class VectorStoreWithIndex:
         mode = params.get("mode")
         score_threshold = params.get("score_threshold", 0.0)
 
-        ranker = params.get("ranker")
-        if ranker is None:
+        # Get reranker configuration from params (set by openai_vector_store_mixin)
+        # NOTE: Breaking change - removed support for old nested "ranker" format.
+        #       Now uses flattened format: reranker_type and reranker_params.
+        reranker_type = params.get("reranker_type")
+        reranker_params = params.get("reranker_params", {})
+
+        # If no ranker specified, use VectorStoresConfig default
+        if reranker_type is None:
             reranker_type = (
                 RERANKER_TYPE_RRF
                 if config.chunk_retrieval_params.default_reranker_strategy == "rrf"
                 else config.chunk_retrieval_params.default_reranker_strategy
             )
             reranker_params = {"impact_factor": config.chunk_retrieval_params.rrf_impact_factor}
+
+        # Normalize reranker_type to use constants
+        if reranker_type == "weighted":
+            reranker_type = RERANKER_TYPE_WEIGHTED
+            # Ensure alpha is set (use default if not provided)
+            if "alpha" not in reranker_params:
+                reranker_params["alpha"] = config.chunk_retrieval_params.weighted_search_alpha
+        elif reranker_type == "rrf":
+            reranker_type = RERANKER_TYPE_RRF
+            # Ensure impact_factor is set (use default if not provided)
+            if "impact_factor" not in reranker_params:
+                reranker_params["impact_factor"] = config.chunk_retrieval_params.rrf_impact_factor
+        elif reranker_type == "neural":
+            # TODO: Implement neural reranking
+            log.warning(
+                "TODO: Neural reranking for vector stores is not implemented yet; "
+                "using configured reranker params without algorithm fallback."
+            )
+        elif reranker_type == "normalized":
+            reranker_type = RERANKER_TYPE_NORMALIZED
         else:
-            strategy = ranker.get("strategy", config.chunk_retrieval_params.default_reranker_strategy)
-            if strategy == "weighted":
-                weights = ranker.get("params", {}).get("weights", [0.5, 0.5])
-                reranker_type = RERANKER_TYPE_WEIGHTED
-                reranker_params = {
-                    "alpha": weights[0] if len(weights) > 0 else config.chunk_retrieval_params.weighted_search_alpha
-                }
-            elif strategy == "normalized":
-                reranker_type = RERANKER_TYPE_NORMALIZED
-            else:
-                reranker_type = RERANKER_TYPE_RRF
-                k_value = ranker.get("params", {}).get("k", config.chunk_retrieval_params.rrf_impact_factor)
-                reranker_params = {"impact_factor": k_value}
+            # Default to RRF for unknown strategies
+            reranker_type = RERANKER_TYPE_RRF
+            if "impact_factor" not in reranker_params:
+                reranker_params["impact_factor"] = config.chunk_retrieval_params.rrf_impact_factor
+
+        # Store neural model and weights from params if provided (for future neural reranking in Part II)
+        if "neural_model" in params:
+            reranker_params["neural_model"] = params["neural_model"]
+        if "neural_weights" in params:
+            reranker_params["neural_weights"] = params["neural_weights"]
 
         query_string = interleaved_content_as_str(query)
         if mode == "keyword":
             return await self.index.query_keyword(query_string, k, score_threshold)
 
-        params = OpenAIEmbeddingsRequestWithExtraBody(
-            model=self.vector_store.embedding_model,
-            input=[query_string],
-        )
+        if "embedding_dimensions" in params:
+            params = OpenAIEmbeddingsRequestWithExtraBody(
+                model=self.vector_store.embedding_model,
+                input=[query_string],
+                dimensions=params.get("embedding_dimensions"),
+            )
+        else:
+            params = OpenAIEmbeddingsRequestWithExtraBody(model=self.vector_store.embedding_model, input=[query_string])
         embeddings_response = await self.inference_api.openai_embeddings(params)
         query_vector = np.array(embeddings_response.data[0].embedding, dtype=np.float32)
         if mode == "hybrid":

llama_stack/providers/utils/responses/responses_store.py

@@ -57,7 +57,7 @@ class ResponsesStore:
         self.sql_store = AuthorizedSqlStore(base_store, self.policy)
 
         await self.sql_store.create_table(
-            "openai_responses",
+            self.reference.table_name,
             {
                 "id": ColumnDefinition(type=ColumnType.STRING, primary_key=True),
                 "created_at": ColumnType.INTEGER,
@@ -89,6 +89,40 @@ class ResponsesStore:
     ) -> None:
         await self._write_response_object(response_object, input, messages)
 
+    async def upsert_response_object(
+        self,
+        response_object: OpenAIResponseObject,
+        input: list[OpenAIResponseInput],
+        messages: list[OpenAIMessageParam],
+    ) -> None:
+        """Upsert response object using INSERT on first call, UPDATE on subsequent calls.
+
+        This method enables incremental persistence during streaming, allowing clients
+        to poll GET /v1/responses/{response_id} and see in-progress turn state.
+
+        :param response_object: The response object to store/update.
+        :param input: The input items for the response.
+        :param messages: The chat completion messages (for conversation continuity).
+        """
+        if self.sql_store is None:
+            raise ValueError("Responses store is not initialized")
+
+        data = response_object.model_dump()
+        data["input"] = [input_item.model_dump() for input_item in input]
+        data["messages"] = [msg.model_dump() for msg in messages]
+
+        await self.sql_store.upsert(
+            table=self.reference.table_name,
+            data={
+                "id": data["id"],
+                "created_at": data["created_at"],
+                "model": data["model"],
+                "response_object": data,
+            },
+            conflict_columns=["id"],
+            update_columns=["response_object"],
+        )
+
     async def _write_response_object(
         self,
         response_object: OpenAIResponseObject,
@@ -103,7 +137,7 @@ class ResponsesStore:
         data["messages"] = [msg.model_dump() for msg in messages]
 
         await self.sql_store.insert(
-            "openai_responses",
+            self.reference.table_name,
             {
                 "id": data["id"],
                 "created_at": data["created_at"],
@@ -138,7 +172,7 @@ class ResponsesStore:
             where_conditions["model"] = model
 
         paginated_result = await self.sql_store.fetch_all(
-            table="openai_responses",
+            table=self.reference.table_name,
             where=where_conditions if where_conditions else None,
             order_by=[("created_at", order.value)],
             cursor=("id", after) if after else None,
@@ -161,7 +195,7 @@ class ResponsesStore:
             raise ValueError("Responses store is not initialized")
 
         row = await self.sql_store.fetch_one(
-            "openai_responses",
+            self.reference.table_name,
             where={"id": response_id},
         )
 
@@ -176,10 +210,10 @@ class ResponsesStore:
         if not self.sql_store:
             raise ValueError("Responses store is not initialized")
 
-        row = await self.sql_store.fetch_one("openai_responses", where={"id": response_id})
+        row = await self.sql_store.fetch_one(self.reference.table_name, where={"id": response_id})
         if not row:
             raise ValueError(f"Response with id {response_id} not found")
-        await self.sql_store.delete("openai_responses", where={"id": response_id})
+        await self.sql_store.delete(self.reference.table_name, where={"id": response_id})
         return OpenAIDeleteResponseObject(id=response_id)
 
     async def list_response_input_items(

llama_stack/providers/utils/safety.py

@@ -0,0 +1,114 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+import uuid
+from typing import TYPE_CHECKING
+
+from llama_stack_api import (
+    ModerationObject,
+    ModerationObjectResults,
+    OpenAIUserMessageParam,
+    RunModerationRequest,
+    RunShieldRequest,
+    RunShieldResponse,
+)
+
+if TYPE_CHECKING:
+    # Type stub for mypy - actual implementation provided by provider class
+    class _RunShieldProtocol:
+        async def run_shield(self, request: RunShieldRequest) -> RunShieldResponse: ...
+
+
+class ShieldToModerationMixin:
+    """
+    Mixin that provides run_moderation implementation by delegating to run_shield.
+
+    Providers must implement run_shield(request: RunShieldRequest) for this mixin to work.
+    Providers with custom run_moderation implementations will override this automatically.
+    """
+
+    if TYPE_CHECKING:
+        # Type hint for mypy - run_shield is provided by the mixed-in class
+        async def run_shield(self, request: RunShieldRequest) -> RunShieldResponse: ...
+
+    async def run_moderation(self, request: RunModerationRequest) -> ModerationObject:
+        """
+        Run moderation by converting input to messages and delegating to run_shield.
+
+        Args:
+            request: RunModerationRequest with input and model
+
+        Returns:
+            ModerationObject with results for each input
+
+        Raises:
+            ValueError: If model is None
+        """
+        if request.model is None:
+            raise ValueError(f"{self.__class__.__name__} moderation requires a model identifier")
+
+        inputs = request.input if isinstance(request.input, list) else [request.input]
+        results = []
+
+        for text_input in inputs:
+            # Convert string to OpenAI message format
+            message = OpenAIUserMessageParam(content=text_input)
+
+            # Call run_shield (must be implemented by the provider)
+            shield_request = RunShieldRequest(
+                shield_id=request.model,
+                messages=[message],
+            )
+            shield_response = await self.run_shield(shield_request)
+
+            # Convert RunShieldResponse to ModerationObjectResults
+            results.append(self._shield_response_to_moderation_result(shield_response))
+
+        return ModerationObject(
+            id=f"modr-{uuid.uuid4()}",
+            model=request.model,
+            results=results,
+        )
+
+    def _shield_response_to_moderation_result(
+        self,
+        shield_response: RunShieldResponse,
+    ) -> ModerationObjectResults:
+        """Convert RunShieldResponse to ModerationObjectResults.
+
+        Args:
+            shield_response: The response from run_shield
+
+        Returns:
+            ModerationObjectResults with appropriate fields set
+        """
+        if shield_response.violation is None:
+            # Safe content
+            return ModerationObjectResults(
+                flagged=False,
+                categories={},
+                category_scores={},
+                category_applied_input_types={},
+                user_message=None,
+                metadata={},
+            )
+
+        # Unsafe content - extract violation details
+        v = shield_response.violation
+        violation_type = v.metadata.get("violation_type", "unsafe")
+
+        # Ensure violation_type is a string (metadata values can be Any)
+        if not isinstance(violation_type, str):
+            violation_type = "unsafe"
+
+        return ModerationObjectResults(
+            flagged=True,
+            categories={violation_type: True},
+            category_scores={violation_type: 1.0},
+            category_applied_input_types={violation_type: ["text"]},
+            user_message=v.user_message,
+            metadata=v.metadata,
+        )

llama_stack/providers/utils/tools/mcp.py

@@ -8,6 +8,7 @@ import asyncio
 import hashlib
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from dataclasses import dataclass
 from enum import Enum
 from typing import Any, cast
 
@@ -241,10 +242,12 @@ class MCPSessionManager:
             raise last_exception
         raise RuntimeError(f"Failed to create MCP session for {endpoint}")
 
-    async def close_all(self) -> None:
-        """Close all cached sessions.
+    async def __aenter__(self):
+        """Enter the async context manager."""
+        return self
 
-        Should be called at the end of a request to clean up resources.
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the async context manager and cleanup all sessions.
 
         Note: We catch BaseException (not just Exception) because:
         1. CancelledError is a BaseException and can occur during cleanup
@@ -275,6 +278,8 @@ class MCPSessionManager:
         if errors:
             logger.debug(f"Encountered {len(errors)} errors while closing MCP sessions (expected in streaming)")
 
+        return False
+
 
 @asynccontextmanager
 async def client_wrapper(endpoint: str, headers: dict[str, str]) -> AsyncGenerator[ClientSession, Any]:
@@ -470,3 +475,39 @@ async def invoke_mcp_tool(
     async with client_wrapper(endpoint, final_headers) as session:
         result = await session.call_tool(tool_name, kwargs)
         return _parse_mcp_result(result)
+
+
+@dataclass
+class MCPServerInfo:
+    """Server information from an MCP server."""
+
+    name: str
+    version: str
+    title: str | None = None
+    description: str | None = None
+
+
+async def get_mcp_server_info(
+    endpoint: str,
+    headers: dict[str, str] | None = None,
+    authorization: str | None = None,
+) -> MCPServerInfo:
+    """Get server info from an MCP server.
+    Args:
+        endpoint: MCP server endpoint URL
+        headers: Optional base headers to include
+        authorization: Optional OAuth access token (just the token, not "Bearer <token>")
+    Returns:
+        MCPServerInfo containing name, version, title, and description
+    """
+    final_headers = prepare_mcp_headers(headers, authorization)
+
+    async with client_wrapper(endpoint, final_headers) as session:
+        init_result = await session.initialize()
+
+        return MCPServerInfo(
+            name=init_result.serverInfo.name,
+            version=init_result.serverInfo.version,
+            title=init_result.serverInfo.title,
+            description=init_result.instructions,
+        )

llama_stack/testing/api_recorder.py

@@ -77,11 +77,14 @@ def _normalize_numeric_literal_strings(value: str) -> str:
     return _FLOAT_IN_STRING_PATTERN.sub(_replace, value)
 
 
-def _normalize_body_for_hash(value: Any) -> Any:
+def _normalize_body_for_hash(value: Any, exclude_stream_options: bool = False) -> Any:
     """Recursively normalize a JSON-like value to improve hash stability."""
 
     if isinstance(value, dict):
-        return {key: _normalize_body_for_hash(item) for key, item in value.items()}
+        normalized = {key: _normalize_body_for_hash(item) for key, item in value.items()}
+        if exclude_stream_options and "stream_options" in normalized:
+            del normalized["stream_options"]
+        return normalized
     if isinstance(value, list):
         return [_normalize_body_for_hash(item) for item in value]
     if isinstance(value, tuple):
@@ -146,7 +149,10 @@ def normalize_inference_request(method: str, url: str, headers: dict[str, Any],
 
     parsed = urlparse(url)
 
-    body_for_hash = _normalize_body_for_hash(body)
+    # Bedrock's OpenAI-compatible endpoint includes stream_options that vary between
+    # runs but don't affect the logical request. Exclude it for stable hashing.
+    is_bedrock = "bedrock" in parsed.netloc
+    body_for_hash = _normalize_body_for_hash(body, exclude_stream_options=is_bedrock)
 
     test_id = get_test_context()
     normalized: dict[str, Any] = {

{llama_stack-0.4.3.dist-info → llama_stack-0.5.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llama_stack
-Version: 0.4.3
+Version: 0.5.0rc1
 Summary: Llama Stack
 Author-email: Meta Llama <llama-oss@meta.com>
 License: MIT
@@ -45,8 +45,12 @@ Requires-Dist: starlette>=0.49.1
 Requires-Dist: psycopg2-binary
 Requires-Dist: tornado>=6.5.3
 Requires-Dist: urllib3>=2.6.3
+Requires-Dist: oracledb>=3.4.1
+Requires-Dist: oci>=2.165.0
+Requires-Dist: numpy>=2.3.2
+Requires-Dist: mcp>=1.23.0
 Provides-Extra: client
-Requires-Dist: llama-stack-client==0.4.3; extra == "client"
+Requires-Dist: llama-stack-client>=0.4.0.dev0; extra == "client"
 Dynamic: license-file
 
 # Llama Stack
@@ -158,6 +162,7 @@ Please checkout our [Documentation](https://llamastack.github.io/docs) page for
     * A [Zero-to-Hero Guide](https://github.com/meta-llama/llama-stack/tree/main/docs/zero_to_hero_guide) that guide you through all the key components of llama stack with code samples.
 * [Contributing](CONTRIBUTING.md)
     * [Adding a new API Provider](https://llamastack.github.io/docs/contributing/new_api_provider) to walk-through how to add a new API provider.
+    * [Release Process](RELEASE_PROCESS.md) for information about release schedules and versioning.
 
 ### Llama Stack Client SDKs
 
@@ -172,6 +177,13 @@ Check out our client SDKs for connecting to a Llama Stack server in your preferr
 
 You can find more example scripts with client SDKs to talk with the Llama Stack server in our [llama-stack-apps](https://github.com/meta-llama/llama-stack-apps/tree/main/examples) repo.
 
+## Community
+
+We hold regular community calls to discuss the latest developments and get feedback from the community.
+
+- Date: every Thursday
+- Time: 09:00 AM PST (check the [Community Event on Discord](https://discord.com/events/1257833999603335178/1413266296748900513) for the latest details)
+
 ## 🌟 GitHub Star History
 ## Star History