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

{llama_stack/apis → llama_stack_api}/common/type_system.py

@@ -8,7 +8,7 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, Field
 
-from llama_stack.schema_utils import json_schema_type, register_schema
+from llama_stack_api.schema_utils import json_schema_type, register_schema
 
 
 @json_schema_type
@@ -103,17 +103,6 @@ class CompletionInputType(BaseModel):
     type: Literal["completion_input"] = "completion_input"
 
 
-@json_schema_type
-class AgentTurnInputType(BaseModel):
-    """Parameter type for agent turn input.
-
-    :param type: Discriminator type. Always "agent_turn_input"
-    """
-
-    # expects List[Message] for messages (may also include attachments?)
-    type: Literal["agent_turn_input"] = "agent_turn_input"
-
-
 @json_schema_type
 class DialogType(BaseModel):
     """Parameter type for dialog data with semantic output labels.
@@ -135,8 +124,7 @@ ParamType = Annotated[
     | JsonType
     | UnionType
     | ChatCompletionInputType
-    | CompletionInputType
-    | AgentTurnInputType,
+    | CompletionInputType,
     Field(discriminator="type"),
 ]
 register_schema(ParamType, name="ParamType")

llama_stack_api/connectors.py

@@ -0,0 +1,146 @@
+# 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.
+
+from enum import StrEnum
+from typing import Literal, Protocol
+
+from pydantic import BaseModel, Field
+from typing_extensions import runtime_checkable
+
+from llama_stack_api.resource import Resource, ResourceType
+from llama_stack_api.schema_utils import json_schema_type, webmethod
+from llama_stack_api.tools import ToolDef
+from llama_stack_api.version import LLAMA_STACK_API_V1ALPHA
+
+
+@json_schema_type
+class ConnectorType(StrEnum):
+    """Type of connector."""
+
+    MCP = "mcp"
+
+
+class CommonConnectorFields(BaseModel):
+    """Common fields for all connectors.
+
+    :param connector_type: Type of connector
+    :param connector_id: Identifier for the connector
+    :param url: URL of the connector
+    :param server_label: (Optional) Label of the server
+    """
+
+    connector_type: ConnectorType = Field(default=ConnectorType.MCP)
+    connector_id: str = Field(..., description="Identifier for the connector")
+    url: str = Field(..., description="URL of the connector")
+    server_label: str | None = Field(default=None, description="Label of the server")
+
+
+@json_schema_type
+class Connector(CommonConnectorFields, Resource):
+    """A connector resource representing a connector registered in Llama Stack.
+
+    :param type: Type of resource, always 'connector' for connectors
+    :param server_name: (Optional) Name of the server
+    :param server_description: (Optional) Description of the server
+    """
+
+    model_config = {"populate_by_name": True}
+    type: Literal[ResourceType.connector] = ResourceType.connector
+    server_name: str | None = Field(default=None, description="Name of the server")
+    server_description: str | None = Field(default=None, description="Description of the server")
+
+
+@json_schema_type
+class ConnectorInput(CommonConnectorFields):
+    """Input for creating a connector
+
+    :param type: Type of resource, always 'connector' for connectors
+    """
+
+    type: Literal[ResourceType.connector] = ResourceType.connector
+
+
+@json_schema_type
+class ListConnectorsResponse(BaseModel):
+    """Response containing a list of connectors.
+
+    :param data: List of connectors
+    """
+
+    data: list[Connector]
+
+
+@json_schema_type
+class ListToolsResponse(BaseModel):
+    """Response containing a list of tools.
+
+    :param data: List of tools
+    """
+
+    data: list[ToolDef]
+
+
+@runtime_checkable
+class Connectors(Protocol):
+    # NOTE: Route order matters! More specific routes must come before less specific ones.
+    # Routes with {param:path} are greedy and will match everything including slashes.
+
+    @webmethod(route="/connectors", method="GET", level=LLAMA_STACK_API_V1ALPHA)
+    async def list_connectors(
+        self,
+    ) -> ListConnectorsResponse:
+        """List all configured connectors.
+
+        :returns: A ListConnectorsResponse.
+        """
+        ...
+
+    @webmethod(route="/connectors/{connector_id}/tools/{tool_name}", method="GET", level=LLAMA_STACK_API_V1ALPHA)
+    async def get_connector_tool(
+        self,
+        connector_id: str,
+        tool_name: str,
+        authorization: str | None = None,
+    ) -> ToolDef:
+        """Get a tool definition by its name from a connector.
+
+        :param connector_id: The ID of the connector to get the tool from.
+        :param tool_name: The name of the tool to get.
+        :param authorization: (Optional) OAuth access token for authenticating with the MCP server.
+
+        :returns: A ToolDef.
+        """
+        ...
+
+    @webmethod(route="/connectors/{connector_id}/tools", method="GET", level=LLAMA_STACK_API_V1ALPHA)
+    async def list_connector_tools(
+        self,
+        connector_id: str,
+        authorization: str | None = None,
+    ) -> ListToolsResponse:
+        """List tools available from a connector.
+
+        :param connector_id: The ID of the connector to list tools for.
+        :param authorization: (Optional) OAuth access token for authenticating with the MCP server.
+
+        :returns: A ListToolsResponse.
+        """
+        ...
+
+    @webmethod(route="/connectors/{connector_id}", method="GET", level=LLAMA_STACK_API_V1ALPHA)
+    async def get_connector(
+        self,
+        connector_id: str,
+        authorization: str | None = None,
+    ) -> Connector:
+        """Get a connector by its ID.
+
+        :param connector_id: The ID of the connector to get.
+        :param authorization: (Optional) OAuth access token for authenticating with the MCP server.
+
+        :returns: A Connector.
+        """
+        ...

{llama_stack/apis/conversations → llama_stack_api}/conversations.py

@@ -4,14 +4,12 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
+from enum import StrEnum
 from typing import Annotated, Literal, Protocol, runtime_checkable
 
-from openai import NOT_GIVEN
-from openai._types import NotGiven
-from openai.types.responses.response_includable import ResponseIncludable
 from pydantic import BaseModel, Field
 
-from llama_stack.apis.agents.openai_responses import (
+from llama_stack_api.openai_responses import (
     OpenAIResponseInputFunctionToolCallOutput,
     OpenAIResponseMCPApprovalRequest,
     OpenAIResponseMCPApprovalResponse,
@@ -22,9 +20,8 @@ from llama_stack.apis.agents.openai_responses import (
     OpenAIResponseOutputMessageMCPListTools,
     OpenAIResponseOutputMessageWebSearchToolCall,
 )
-from llama_stack.apis.version import LLAMA_STACK_API_V1
-from llama_stack.providers.utils.telemetry.trace_protocol import trace_protocol
-from llama_stack.schema_utils import json_schema_type, register_schema, webmethod
+from llama_stack_api.schema_utils import json_schema_type, register_schema, webmethod
+from llama_stack_api.version import LLAMA_STACK_API_V1
 
 Metadata = dict[str, str]
 
@@ -104,32 +101,6 @@ register_schema(ConversationItem, name="ConversationItem")
 # ]
 
 
-@json_schema_type
-class ConversationCreateRequest(BaseModel):
-    """Request body for creating a conversation."""
-
-    items: list[ConversationItem] | None = Field(
-        default=[],
-        description="Initial items to include in the conversation context. You may add up to 20 items at a time.",
-        max_length=20,
-    )
-    metadata: Metadata | None = Field(
-        default={},
-        description="Set of 16 key-value pairs that can be attached to an object. Useful for storing additional information",
-        max_length=16,
-    )
-
-
-@json_schema_type
-class ConversationUpdateRequest(BaseModel):
-    """Request body for updating a conversation."""
-
-    metadata: Metadata = Field(
-        ...,
-        description="Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.",
-    )
-
-
 @json_schema_type
 class ConversationDeletedResource(BaseModel):
     """Response for deleted conversation."""
@@ -150,6 +121,20 @@ class ConversationItemCreateRequest(BaseModel):
     )
 
 
+class ConversationItemInclude(StrEnum):
+    """
+    Specify additional output data to include in the model response.
+    """
+
+    web_search_call_action_sources = "web_search_call.action.sources"
+    code_interpreter_call_outputs = "code_interpreter_call.outputs"
+    computer_call_output_output_image_url = "computer_call_output.output.image_url"
+    file_search_call_results = "file_search_call.results"
+    message_input_image_image_url = "message.input_image.image_url"
+    message_output_text_logprobs = "message.output_text.logprobs"
+    reasoning_encrypted_content = "reasoning.encrypted_content"
+
+
 @json_schema_type
 class ConversationItemList(BaseModel):
     """List of conversation items with pagination."""
@@ -171,7 +156,6 @@ class ConversationItemDeletedResource(BaseModel):
 
 
 @runtime_checkable
-@trace_protocol
 class Conversations(Protocol):
     """Conversations
 
@@ -250,13 +234,13 @@ class Conversations(Protocol):
         ...
 
     @webmethod(route="/conversations/{conversation_id}/items", method="GET", level=LLAMA_STACK_API_V1)
-    async def list(
+    async def list_items(
         self,
         conversation_id: str,
-        after: str | NotGiven = NOT_GIVEN,
-        include: list[ResponseIncludable] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | None = None,
+        include: list[ConversationItemInclude] | None = None,
+        limit: int | None = None,
+        order: Literal["asc", "desc"] | None = None,
     ) -> ConversationItemList:
         """List items.
 

{llama_stack/apis/datasetio → llama_stack_api}/datasetio.py

@@ -6,10 +6,10 @@
 
 from typing import Any, Protocol, runtime_checkable
 
-from llama_stack.apis.common.responses import PaginatedResponse
-from llama_stack.apis.datasets import Dataset
-from llama_stack.apis.version import LLAMA_STACK_API_V1, LLAMA_STACK_API_V1BETA
-from llama_stack.schema_utils import webmethod
+from llama_stack_api.common.responses import PaginatedResponse
+from llama_stack_api.datasets import Dataset
+from llama_stack_api.schema_utils import webmethod
+from llama_stack_api.version import LLAMA_STACK_API_V1BETA
 
 
 class DatasetStore(Protocol):
@@ -21,7 +21,6 @@ class DatasetIO(Protocol):
     # keeping for aligning with inference/safety, but this is not used
     dataset_store: DatasetStore
 
-    @webmethod(route="/datasetio/iterrows/{dataset_id:path}", method="GET", deprecated=True, level=LLAMA_STACK_API_V1)
     @webmethod(route="/datasetio/iterrows/{dataset_id:path}", method="GET", level=LLAMA_STACK_API_V1BETA)
     async def iterrows(
         self,
@@ -46,9 +45,6 @@ class DatasetIO(Protocol):
         """
         ...
 
-    @webmethod(
-        route="/datasetio/append-rows/{dataset_id:path}", method="POST", deprecated=True, level=LLAMA_STACK_API_V1
-    )
     @webmethod(route="/datasetio/append-rows/{dataset_id:path}", method="POST", level=LLAMA_STACK_API_V1BETA)
     async def append_rows(self, dataset_id: str, rows: list[dict[str, Any]]) -> None:
         """Append rows to a dataset.

llama_stack_api/datasets/__init__.py

@@ -0,0 +1,61 @@
+# 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.
+
+"""Datasets API protocol and models.
+
+This module contains the Datasets protocol definition.
+Pydantic models are defined in llama_stack_api.datasets.models.
+The FastAPI router is defined in llama_stack_api.datasets.fastapi_routes.
+"""
+
+# Import fastapi_routes for router factory access
+from . import fastapi_routes
+
+# Import new protocol for FastAPI router
+from .api import Datasets
+
+# Import models for re-export
+from .models import (
+    CommonDatasetFields,
+    Dataset,
+    DatasetPurpose,
+    DatasetType,
+    DataSource,
+    GetDatasetRequest,
+    ListDatasetsResponse,
+    RegisterDatasetRequest,
+    RowsDataSource,
+    UnregisterDatasetRequest,
+    URIDataSource,
+)
+
+
+# Define DatasetInput for backward compatibility
+class DatasetInput(CommonDatasetFields):
+    """Input parameters for dataset operations.
+
+    :param dataset_id: Unique identifier for the dataset
+    """
+
+    dataset_id: str
+
+
+__all__ = [
+    "Datasets",
+    "Dataset",
+    "CommonDatasetFields",
+    "DatasetPurpose",
+    "DataSource",
+    "DatasetInput",
+    "DatasetType",
+    "RowsDataSource",
+    "URIDataSource",
+    "ListDatasetsResponse",
+    "RegisterDatasetRequest",
+    "GetDatasetRequest",
+    "UnregisterDatasetRequest",
+    "fastapi_routes",
+]

llama_stack_api/datasets/api.py

@@ -0,0 +1,35 @@
+# 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.
+
+"""Datasets API protocol definition.
+
+This module contains the Datasets protocol definition.
+Pydantic models are defined in llama_stack_api.datasets.models.
+The FastAPI router is defined in llama_stack_api.datasets.fastapi_routes.
+"""
+
+from typing import Protocol, runtime_checkable
+
+from .models import (
+    Dataset,
+    GetDatasetRequest,
+    ListDatasetsResponse,
+    RegisterDatasetRequest,
+    UnregisterDatasetRequest,
+)
+
+
+@runtime_checkable
+class Datasets(Protocol):
+    """Protocol for dataset management operations."""
+
+    async def register_dataset(self, request: RegisterDatasetRequest) -> Dataset: ...
+
+    async def get_dataset(self, request: GetDatasetRequest) -> Dataset: ...
+
+    async def list_datasets(self) -> ListDatasetsResponse: ...
+
+    async def unregister_dataset(self, request: UnregisterDatasetRequest) -> None: ...

llama_stack_api/datasets/fastapi_routes.py

@@ -0,0 +1,104 @@
+# 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.
+
+"""FastAPI router for the Datasets API.
+
+This module defines the FastAPI router for the Datasets API using standard
+FastAPI route decorators.
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Body, Depends
+
+from llama_stack_api.router_utils import create_path_dependency, standard_responses
+from llama_stack_api.version import LLAMA_STACK_API_V1BETA
+
+from .api import Datasets
+from .models import (
+    Dataset,
+    GetDatasetRequest,
+    ListDatasetsResponse,
+    RegisterDatasetRequest,
+    UnregisterDatasetRequest,
+)
+
+# Path parameter dependencies for single-field models
+get_dataset_request = create_path_dependency(GetDatasetRequest)
+unregister_dataset_request = create_path_dependency(UnregisterDatasetRequest)
+
+
+def create_router(impl: Datasets) -> APIRouter:
+    """Create a FastAPI router for the Datasets API.
+
+    Args:
+        impl: The Datasets implementation instance
+
+    Returns:
+        APIRouter configured for the Datasets API
+    """
+    router = APIRouter(
+        prefix=f"/{LLAMA_STACK_API_V1BETA}",
+        tags=["Datasets"],
+        responses=standard_responses,
+    )
+
+    @router.post(
+        "/datasets",
+        response_model=Dataset,
+        summary="Register a new dataset.",
+        description="Register a new dataset.",
+        responses={
+            200: {"description": "The registered dataset object."},
+        },
+        deprecated=True,
+    )
+    async def register_dataset(
+        request: Annotated[RegisterDatasetRequest, Body(...)],
+    ) -> Dataset:
+        return await impl.register_dataset(request)
+
+    @router.get(
+        "/datasets/{dataset_id:path}",
+        response_model=Dataset,
+        summary="Get a dataset by its ID.",
+        description="Get a dataset by its ID.",
+        responses={
+            200: {"description": "The dataset object."},
+        },
+    )
+    async def get_dataset(
+        request: Annotated[GetDatasetRequest, Depends(get_dataset_request)],
+    ) -> Dataset:
+        return await impl.get_dataset(request)
+
+    @router.get(
+        "/datasets",
+        response_model=ListDatasetsResponse,
+        summary="List all datasets.",
+        description="List all datasets.",
+        responses={
+            200: {"description": "A list of dataset objects."},
+        },
+    )
+    async def list_datasets() -> ListDatasetsResponse:
+        return await impl.list_datasets()
+
+    @router.delete(
+        "/datasets/{dataset_id:path}",
+        summary="Unregister a dataset by its ID.",
+        description="Unregister a dataset by its ID.",
+        responses={
+            200: {"description": "The dataset was successfully unregistered."},
+        },
+        deprecated=True,
+    )
+    async def unregister_dataset(
+        request: Annotated[UnregisterDatasetRequest, Depends(unregister_dataset_request)],
+    ) -> None:
+        return await impl.unregister_dataset(request)
+
+    return router

llama_stack_api/datasets/models.py

@@ -0,0 +1,152 @@
+# 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.
+
+"""Pydantic models for Datasets API requests and responses.
+
+This module defines the request and response models for the Datasets API
+using Pydantic with Field descriptions for OpenAPI schema generation.
+"""
+
+from enum import Enum, StrEnum
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field
+
+from llama_stack_api.resource import Resource, ResourceType
+from llama_stack_api.schema_utils import json_schema_type, register_schema
+
+
+class DatasetPurpose(StrEnum):
+    """Purpose of the dataset. Each purpose has a required input data schema."""
+
+    post_training_messages = "post-training/messages"
+    """The dataset contains messages used for post-training."""
+    eval_question_answer = "eval/question-answer"
+    """The dataset contains a question column and an answer column."""
+    eval_messages_answer = "eval/messages-answer"
+    """The dataset contains a messages column with list of messages and an answer column."""
+
+
+class DatasetType(Enum):
+    """Type of the dataset source."""
+
+    uri = "uri"
+    """The dataset can be obtained from a URI."""
+    rows = "rows"
+    """The dataset is stored in rows."""
+
+
+@json_schema_type
+class URIDataSource(BaseModel):
+    """A dataset that can be obtained from a URI."""
+
+    type: Literal["uri"] = Field(default="uri", description="The type of data source.")
+    uri: str = Field(
+        ...,
+        description='The dataset can be obtained from a URI. E.g. "https://mywebsite.com/mydata.jsonl", "lsfs://mydata.jsonl", "data:csv;base64,{base64_content}"',
+    )
+
+
+@json_schema_type
+class RowsDataSource(BaseModel):
+    """A dataset stored in rows."""
+
+    type: Literal["rows"] = Field(default="rows", description="The type of data source.")
+    rows: list[dict[str, Any]] = Field(
+        ...,
+        description='The dataset is stored in rows. E.g. [{"messages": [{"role": "user", "content": "Hello, world!"}, {"role": "assistant", "content": "Hello, world!"}]}]',
+    )
+
+
+DataSource = Annotated[
+    URIDataSource | RowsDataSource,
+    Field(discriminator="type"),
+]
+register_schema(DataSource, name="DataSource")
+
+
+class CommonDatasetFields(BaseModel):
+    """Common fields for a dataset."""
+
+    purpose: DatasetPurpose = Field(..., description="Purpose of the dataset indicating its intended use")
+    source: DataSource = Field(..., description="Data source configuration for the dataset")
+    metadata: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Any additional metadata for this dataset",
+    )
+
+
+@json_schema_type
+class Dataset(CommonDatasetFields, Resource):
+    """Dataset resource for storing and accessing training or evaluation data."""
+
+    type: Literal[ResourceType.dataset] = Field(
+        default=ResourceType.dataset,
+        description="Type of resource, always 'dataset' for datasets",
+    )
+
+    @property
+    def dataset_id(self) -> str:
+        return self.identifier
+
+    @property
+    def provider_dataset_id(self) -> str | None:
+        return self.provider_resource_id
+
+
+@json_schema_type
+class ListDatasetsResponse(BaseModel):
+    """Response from listing datasets."""
+
+    data: list[Dataset] = Field(..., description="List of datasets")
+
+
+# Request models for each endpoint
+
+
+@json_schema_type
+class RegisterDatasetRequest(BaseModel):
+    """Request model for registering a dataset."""
+
+    purpose: DatasetPurpose = Field(..., description="The purpose of the dataset.")
+    source: DataSource = Field(..., description="The data source of the dataset.")
+    metadata: dict[str, Any] | None = Field(
+        default=None,
+        description="The metadata for the dataset.",
+    )
+    dataset_id: str | None = Field(
+        default=None,
+        description="The ID of the dataset. If not provided, an ID will be generated.",
+    )
+
+
+@json_schema_type
+class GetDatasetRequest(BaseModel):
+    """Request model for getting a dataset by ID."""
+
+    dataset_id: str = Field(..., description="The ID of the dataset to get.")
+
+
+@json_schema_type
+class UnregisterDatasetRequest(BaseModel):
+    """Request model for unregistering a dataset."""
+
+    dataset_id: str = Field(..., description="The ID of the dataset to unregister.")
+
+
+__all__ = [
+    "CommonDatasetFields",
+    "Dataset",
+    "DatasetPurpose",
+    "DatasetType",
+    "DataSource",
+    "RowsDataSource",
+    "URIDataSource",
+    "ListDatasetsResponse",
+    "RegisterDatasetRequest",
+    "GetDatasetRequest",
+    "UnregisterDatasetRequest",
+]