llama-stack 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

llama_stack/core/resolver.py

@@ -3,60 +3,66 @@
 #
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
+
 import importlib
 import importlib.metadata
 import inspect
 from typing import Any
 
-from llama_stack.apis.agents import Agents
-from llama_stack.apis.batches import Batches
-from llama_stack.apis.benchmarks import Benchmarks
-from llama_stack.apis.conversations import Conversations
-from llama_stack.apis.datasetio import DatasetIO
-from llama_stack.apis.datasets import Datasets
-from llama_stack.apis.datatypes import ExternalApiSpec
-from llama_stack.apis.eval import Eval
-from llama_stack.apis.files import Files
-from llama_stack.apis.inference import Inference, InferenceProvider
-from llama_stack.apis.inspect import Inspect
-from llama_stack.apis.models import Models
-from llama_stack.apis.post_training import PostTraining
-from llama_stack.apis.prompts import Prompts
-from llama_stack.apis.providers import Providers as ProvidersAPI
-from llama_stack.apis.safety import Safety
-from llama_stack.apis.scoring import Scoring
-from llama_stack.apis.scoring_functions import ScoringFunctions
-from llama_stack.apis.shields import Shields
-from llama_stack.apis.telemetry import Telemetry
-from llama_stack.apis.tools import ToolGroups, ToolRuntime
-from llama_stack.apis.vector_io import VectorIO
-from llama_stack.apis.vector_stores import VectorStore
-from llama_stack.apis.version import LLAMA_STACK_API_V1ALPHA
 from llama_stack.core.client import get_client_impl
 from llama_stack.core.datatypes import (
     AccessRule,
     AutoRoutedProviderSpec,
     Provider,
     RoutingTableProviderSpec,
-    StackRunConfig,
+    StackConfig,
 )
 from llama_stack.core.distribution import builtin_automatically_routed_apis
 from llama_stack.core.external import load_external_apis
 from llama_stack.core.store import DistributionRegistry
 from llama_stack.core.utils.dynamic import instantiate_class_type
 from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import (
+from llama_stack_api import (
+    LLAMA_STACK_API_V1ALPHA,
+    Admin,
+    Agents,
     Api,
+    Batches,
+    Benchmarks,
     BenchmarksProtocolPrivate,
+    Connectors,
+    Conversations,
+    DatasetIO,
+    Datasets,
     DatasetsProtocolPrivate,
-    InlineProviderSpec,
+    Eval,
+    ExternalApiSpec,
+    FileProcessors,
+    Files,
+    Inference,
+    InferenceProvider,
+    Inspect,
+    Models,
     ModelsProtocolPrivate,
+    PostTraining,
+    Prompts,
     ProviderSpec,
     RemoteProviderConfig,
     RemoteProviderSpec,
+    Safety,
+    Scoring,
+    ScoringFunctions,
     ScoringFunctionsProtocolPrivate,
+    Shields,
     ShieldsProtocolPrivate,
+    ToolGroups,
     ToolGroupsProtocolPrivate,
+    ToolRuntime,
+    VectorIO,
+    VectorStore,
+)
+from llama_stack_api import (
+    Providers as ProvidersAPI,
 )
 
 logger = get_logger(name=__name__, category="core")
@@ -76,6 +82,7 @@ def api_protocol_map(external_apis: dict[Api, ExternalApiSpec] | None = None) ->
         Dictionary mapping API types to their protocol classes
     """
     protocols = {
+        Api.admin: Admin,
         Api.providers: ProvidersAPI,
         Api.agents: Agents,
         Api.inference: Inference,
@@ -98,7 +105,8 @@ def api_protocol_map(external_apis: dict[Api, ExternalApiSpec] | None = None) ->
         Api.files: Files,
         Api.prompts: Prompts,
         Api.conversations: Conversations,
-        Api.telemetry: Telemetry,
+        Api.file_processors: FileProcessors,
+        Api.connectors: Connectors,
     }
 
     if external_apis:
@@ -146,7 +154,7 @@ ProviderRegistry = dict[Api, dict[str, ProviderSpec]]
 
 
 async def resolve_impls(
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     provider_registry: ProviderRegistry,
     dist_registry: DistributionRegistry,
     policy: list[AccessRule],
@@ -198,6 +206,13 @@ def specs_for_autorouted_apis(apis_to_serve: list[str] | set[str]) -> dict[str,
             )
         }
 
+        # Add inference as an optional dependency for vector_io to enable query rewriting
+        optional_deps = []
+        deps_list = [info.routing_table_api.value]
+        if info.router_api == Api.vector_io:
+            optional_deps = [Api.inference]
+            deps_list.append(Api.inference.value)
+
         specs[info.router_api.value] = {
             "__builtin__": ProviderWithSpec(
                 provider_id="__autorouted__",
@@ -208,7 +223,8 @@ def specs_for_autorouted_apis(apis_to_serve: list[str] | set[str]) -> dict[str,
                     module="llama_stack.core.routers",
                     routing_table_api=info.routing_table_api,
                     api_dependencies=[info.routing_table_api],
-                    deps__=([info.routing_table_api.value]),
+                    optional_api_dependencies=optional_deps,
+                    deps__=deps_list,
                 ),
             )
         }
@@ -216,7 +232,7 @@ def specs_for_autorouted_apis(apis_to_serve: list[str] | set[str]) -> dict[str,
 
 
 def validate_and_prepare_providers(
-    run_config: StackRunConfig, provider_registry: ProviderRegistry, routing_table_apis: set[Api], router_apis: set[Api]
+    run_config: StackConfig, provider_registry: ProviderRegistry, routing_table_apis: set[Api], router_apis: set[Api]
 ) -> dict[str, dict[str, ProviderWithSpec]]:
     """Validates providers, handles deprecations, and organizes them into a spec dictionary."""
     providers_with_specs: dict[str, dict[str, ProviderWithSpec]] = {}
@@ -241,24 +257,6 @@ def validate_and_prepare_providers(
         key = api_str if api not in router_apis else f"inner-{api_str}"
         providers_with_specs[key] = specs
 
-    # TODO: remove this logic, telemetry should not have providers.
-    # if telemetry has been enabled in the config initialize our internal impl
-    # telemetry is not an external API so it SHOULD NOT be auto-routed.
-    if run_config.telemetry.enabled:
-        specs = {}
-        p = InlineProviderSpec(
-            api=Api.telemetry,
-            provider_type="inline::meta-reference",
-            pip_packages=[],
-            optional_api_dependencies=[Api.datasetio],
-            module="llama_stack.providers.inline.telemetry.meta_reference",
-            config_class="llama_stack.providers.inline.telemetry.meta_reference.config.TelemetryConfig",
-            description="Meta's reference implementation of telemetry and observability using OpenTelemetry.",
-        )
-        spec = ProviderWithSpec(spec=p, provider_type="inline::meta-reference", provider_id="meta-reference")
-        specs["meta-reference"] = spec
-        providers_with_specs["telemetry"] = specs
-
     return providers_with_specs
 
 
@@ -278,7 +276,7 @@ def validate_provider(provider: Provider, api: Api, provider_registry: ProviderR
 
 
 def sort_providers_by_deps(
-    providers_with_specs: dict[str, dict[str, ProviderWithSpec]], run_config: StackRunConfig
+    providers_with_specs: dict[str, dict[str, ProviderWithSpec]], run_config: StackConfig
 ) -> list[tuple[str, ProviderWithSpec]]:
     """Sorts providers based on their dependencies."""
     sorted_providers: list[tuple[str, ProviderWithSpec]] = topological_sort(
@@ -295,7 +293,7 @@ async def instantiate_providers(
     sorted_providers: list[tuple[str, ProviderWithSpec]],
     router_apis: set[Api],
     dist_registry: DistributionRegistry,
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     policy: list[AccessRule],
     internal_impls: dict[Api, Any] | None = None,
 ) -> dict[Api, Any]:
@@ -332,6 +330,13 @@ async def instantiate_providers(
             api = Api(api_str)
             impls[api] = impl
 
+    # Post-instantiation: Inject VectorIORouter into VectorStoresRoutingTable
+    if Api.vector_io in impls and Api.vector_stores in impls:
+        vector_io_router = impls[Api.vector_io]
+        vector_stores_routing_table = impls[Api.vector_stores]
+        if hasattr(vector_stores_routing_table, "vector_io_router"):
+            vector_stores_routing_table.vector_io_router = vector_io_router
+
     return impls
 
 
@@ -374,7 +379,7 @@ async def instantiate_provider(
     deps: dict[Api, Any],
     inner_impls: dict[str, Any],
     dist_registry: DistributionRegistry,
-    run_config: StackRunConfig,
+    run_config: StackConfig,
     policy: list[AccessRule],
 ):
     provider_spec = provider.spec
@@ -406,15 +411,19 @@ async def instantiate_provider(
         args = [provider_spec.api, inner_impls, deps, dist_registry, policy]
     else:
         method = "get_provider_impl"
+        provider_config = provider.config.copy()
 
+        # Inject vector_stores_config for providers that need it (introspection-based)
         config_type = instantiate_class_type(provider_spec.config_class)
-        config = config_type(**provider.config)
+        if hasattr(config_type, "__fields__") and "vector_stores_config" in config_type.__fields__:
+            # Only inject if vector_stores is provided, otherwise let default_factory handle it
+            if run_config.vector_stores is not None:
+                provider_config["vector_stores_config"] = run_config.vector_stores
+
+        config = config_type(**provider_config)
         args = [config, deps]
         if "policy" in inspect.signature(getattr(module, method)).parameters:
             args.append(policy)
-        if "telemetry_enabled" in inspect.signature(getattr(module, method)).parameters and run_config.telemetry:
-            args.append(run_config.telemetry.enabled)
-
     fn = getattr(module, method)
     impl = await fn(*args)
     impl.__provider_id__ = provider.provider_id

llama_stack/core/routers/__init__.py

@@ -9,11 +9,11 @@ from typing import Any
 from llama_stack.core.datatypes import (
     AccessRule,
     RoutedProtocol,
+    StackConfig,
 )
-from llama_stack.core.stack import StackRunConfig
 from llama_stack.core.store import DistributionRegistry
-from llama_stack.providers.datatypes import Api, RoutingTable
 from llama_stack.providers.utils.inference.inference_store import InferenceStore
+from llama_stack_api import Api, RoutingTable
 
 
 async def get_routing_table_impl(
@@ -45,12 +45,13 @@ async def get_routing_table_impl(
         raise ValueError(f"API {api.value} not found in router map")
 
     impl = api_to_tables[api.value](impls_by_provider_id, dist_registry, policy)
+
     await impl.initialize()
     return impl
 
 
 async def get_auto_router_impl(
-    api: Api, routing_table: RoutingTable, deps: dict[str, Any], run_config: StackRunConfig, policy: list[AccessRule]
+    api: Api, routing_table: RoutingTable, deps: dict[str, Any], run_config: StackConfig, policy: list[AccessRule]
 ) -> Any:
     from .datasets import DatasetIORouter
     from .eval_scoring import EvalRouter, ScoringRouter
@@ -72,14 +73,6 @@ async def get_auto_router_impl(
         raise ValueError(f"API {api.value} not found in router map")
 
     api_to_dep_impl = {}
-    if run_config.telemetry.enabled:
-        api_to_deps = {
-            "inference": {"telemetry": Api.telemetry},
-        }
-        for dep_name, dep_api in api_to_deps.get(api.value, {}).items():
-            if dep_api in deps:
-                api_to_dep_impl[dep_name] = deps[dep_api]
-
     # TODO: move pass configs to routers instead
     if api == Api.inference:
         inference_ref = run_config.storage.stores.inference
@@ -92,10 +85,13 @@ async def get_auto_router_impl(
         )
         await inference_store.initialize()
         api_to_dep_impl["store"] = inference_store
-
     elif api == Api.vector_io:
         api_to_dep_impl["vector_stores_config"] = run_config.vector_stores
+        api_to_dep_impl["inference_api"] = deps.get(Api.inference)
+    elif api == Api.safety:
+        api_to_dep_impl["safety_config"] = run_config.safety
 
     impl = api_to_routers[api.value](routing_table, **api_to_dep_impl)
+
     await impl.initialize()
     return impl

llama_stack/core/routers/datasets.py

@@ -6,11 +6,8 @@
 
 from typing import Any
 
-from llama_stack.apis.common.responses import PaginatedResponse
-from llama_stack.apis.datasetio import DatasetIO
-from llama_stack.apis.datasets import DatasetPurpose, DataSource
 from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import RoutingTable
+from llama_stack_api import DatasetIO, DatasetPurpose, DataSource, PaginatedResponse, RoutingTable
 
 logger = get_logger(name=__name__, category="core::routers")
 

llama_stack/core/routers/eval_scoring.py

@@ -6,15 +6,18 @@
 
 from typing import Any
 
-from llama_stack.apis.eval import BenchmarkConfig, Eval, EvaluateResponse, Job
-from llama_stack.apis.scoring import (
+from llama_stack.log import get_logger
+from llama_stack_api import (
+    BenchmarkConfig,
+    Eval,
+    EvaluateResponse,
+    Job,
+    RoutingTable,
     ScoreBatchResponse,
     ScoreResponse,
     Scoring,
     ScoringFnParams,
 )
-from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import RoutingTable
 
 logger = get_logger(name=__name__, category="core::routers")