Add direct client implementation

src/llama_stack_client/lib/agents/agent.py

@@ -36,7 +36,10 @@ def create_session(self, session_name: str) -> int:
         return self.session_id
 
     async def create_turn(
-        self, messages: List[Union[UserMessage, ToolResponseMessage]], attachments: Optional[List[Attachment]] = None, session_id: Optional[str] = None,
+        self,
+        messages: List[Union[UserMessage, ToolResponseMessage]],
+        attachments: Optional[List[Attachment]] = None,
+        session_id: Optional[str] = None,
     ):
         response = self.client.agents.turn.create(
             agent_id=self.agent_id,

src/llama_stack_client/lib/agents/custom_tool.py

@@ -9,10 +9,11 @@
 from abc import abstractmethod
 from typing import Dict, List, Union
 
-from llama_stack_client.types.tool_param_definition_param import ToolParamDefinitionParam
 from llama_stack_client.types import ToolResponseMessage, UserMessage
 from llama_stack_client.types.agent_create_params import AgentConfigToolFunctionCallToolDefinition
 
+from llama_stack_client.types.tool_param_definition_param import ToolParamDefinitionParam
+
 
 class CustomTool:
     """

src/llama_stack_client/lib/cli/configure.py

@@ -9,10 +9,9 @@
 
 import yaml
 
-from llama_stack_client.lib.cli.constants import get_config_file_path
+from llama_stack_client.lib.cli.constants import get_config_file_path, LLAMA_STACK_CLIENT_CONFIG_DIR
 from llama_stack_client.lib.cli.subcommand import Subcommand
 
-from llama_stack_client.lib.cli.constants import LLAMA_STACK_CLIENT_CONFIG_DIR
 
 def get_config():
     config_file = get_config_file_path()

src/llama_stack_client/lib/cli/llama_stack_client.py

@@ -40,13 +40,11 @@ def parse_args(self) -> argparse.Namespace:
         return self.parser.parse_args()
 
     def command_requires_config(self, args: argparse.Namespace) -> bool:
-        return not (hasattr(args.func, '__self__') and isinstance(args.func.__self__, ConfigureParser))
+        return not (hasattr(args.func, "__self__") and isinstance(args.func.__self__, ConfigureParser))
 
     def run(self, args: argparse.Namespace) -> None:
         if self.command_requires_config(args) and not get_config_file_path().exists():
-            print(
-                "Config file not found. Please run 'llama-stack-client configure' to create one."
-            )
+            print("Config file not found. Please run 'llama-stack-client configure' to create one.")
             return
 
         args.func(args)

src/llama_stack_client/lib/direct/direct.py

@@ -0,0 +1,105 @@
+import inspect
+from typing import Any, cast, get_args, get_origin, Type
+
+from llama_stack.distribution.datatypes import StackRunConfig
+from llama_stack.distribution.distribution import get_provider_registry
+from llama_stack.distribution.resolver import resolve_impls
+from llama_stack.distribution.server.endpoints import get_all_api_endpoints
+from llama_stack.distribution.server.server import is_streaming_request
+
+from llama_stack.distribution.store.registry import create_dist_registry
+from pydantic import BaseModel
+
+from ..._base_client import ResponseT
+from ..._client import LlamaStackClient
+from ..._streaming import Stream
+from ..._types import Body, NOT_GIVEN, RequestFiles, RequestOptions
+
+
+class LlamaStackDirectClient(LlamaStackClient):
+    def __init__(self, config: StackRunConfig, **kwargs):
+        super().__init__(**kwargs)
+        self.endpoints = get_all_api_endpoints()
+        self.config = config
+        self.dist_registry = None
+        self.impls = None
+
+    async def initialize(self) -> None:
+        self.dist_registry, _ = await create_dist_registry(self.config)
+        self.impls = await resolve_impls(self.config, get_provider_registry(), self.dist_registry)
+
+    def _convert_param(self, param_type: Any, value: Any) -> Any:
+        origin = get_origin(param_type)
+        if origin == list:
+            item_type = get_args(param_type)[0]
+            if isinstance(item_type, type) and issubclass(item_type, BaseModel):
+                return [item_type(**item) for item in value]
+            return value
+
+        elif origin == dict:
+            _, val_type = get_args(param_type)
+            if isinstance(val_type, type) and issubclass(val_type, BaseModel):
+                return {k: val_type(**v) for k, v in value.items()}
+            return value
+
+        elif isinstance(param_type, type) and issubclass(param_type, BaseModel):
+            return param_type(**value)
+
+        # Return as-is for primitive types
+        return value
+
+    async def _call_endpoint(self, path: str, method: str, body: dict = None) -> Any:
+        for api, endpoints in self.endpoints.items():
+            for endpoint in endpoints:
+                if endpoint.route == path:
+                    impl = self.impls[api]
+                    func = getattr(impl, endpoint.name)
+                    sig = inspect.signature(func)  #
+
+                    if body:
+                        # Strip NOT_GIVENs to use the defaults in signature
+                        body = {k: v for k, v in body.items() if v is not NOT_GIVEN}
+
+                        # Convert parameters to Pydantic models where needed
+                        converted_body = {}
+                        for param_name, param in sig.parameters.items():
+                            if param_name in body:
+                                value = body.get(param_name)
+                                converted_body[param_name] = self._convert_param(param.annotation, value)
+                        body = converted_body
+
+                    if is_streaming_request(endpoint.name, body):
+                        async for chunk in func(**(body or {})):
+                            yield chunk
+                    else:
+                        yield await func(**(body or {}))
+
+        raise ValueError(f"No endpoint found for {path}")
+
+    async def get(
+        self,
+        path: str,
+        *,
+        cast_to: Type[ResponseT],
+        options: RequestOptions = None,
+        stream: bool = False,
+        stream_cls: type[Stream[Any]] | None = None,
+    ) -> ResponseT:
+        options = options or {}
+        async for response in self._call_endpoint(path, "GET"):
+            return cast(ResponseT, response)
+
+    async def post(
+        self,
+        path: str,
+        *,
+        cast_to: Type[ResponseT],
+        body: Body | None = None,
+        options: RequestOptions = None,
+        files: RequestFiles | None = None,
+        stream: bool = False,
+        stream_cls: type[Stream[Any]] | None = None,
+    ) -> ResponseT:
+        options = options or {}
+        async for response in self._call_endpoint(path, "POST", body):
+            return cast(ResponseT, response)

src/llama_stack_client/lib/direct/test.py

@@ -0,0 +1,36 @@
+import argparse
+
+import yaml
+from llama_stack.distribution.configure import parse_and_maybe_upgrade_config
+from llama_stack_client.lib.direct.direct import LlamaStackDirectClient
+from llama_stack_client.types import UserMessage
+
+
+async def main(config_path: str):
+    with open(config_path, "r") as f:
+        config_dict = yaml.safe_load(f)
+
+    run_config = parse_and_maybe_upgrade_config(config_dict)
+
+    client = LlamaStackDirectClient(config=run_config)
+    await client.initialize()
+
+    response = await client.models.list()
+    print(response)
+
+    response = await client.inference.chat_completion(
+        messages=[UserMessage(content="What is the capital of France?", role="user")],
+        model="Llama3.1-8B-Instruct",
+        stream=False,
+    )
+    print("\nChat completion response:")
+    print(response)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("config_path", help="Path to the config YAML file")
+    args = parser.parse_args()
+    asyncio.run(main(args.config_path))