diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ad4ec2d1..b9887e0e 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.4.0-alpha.6" + ".": "0.4.0-alpha.7" } diff --git a/.stats.yml b/.stats.yml index f4dfa902..6388bfde 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 89 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/llamastack%2Fllama-stack-client-af20fa1866f461e9fef4f7fd226d757b0dddee907e2a083fa582ac0580735e20.yml -openapi_spec_hash: 68caf264f8ade02c34456c526d7300b1 +configured_endpoints: 96 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/llamastack%2Fllama-stack-client-ec32c74fc91569d09bb78aa3cdd8ebc65ed6c83bbd845fb79676e37c1711eda2.yml +openapi_spec_hash: 88f8449f767bd696985306c5dda5d026 config_hash: e8a35d9d37cb4774b4b0fe1b167dc156 diff --git a/CHANGELOG.md b/CHANGELOG.md index 7f4bdcf0..98ca3cd4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.4.0-alpha.7 (2025-11-13) + +Full Changelog: [v0.4.0-alpha.6...v0.4.0-alpha.7](https://github.com/llamastack/llama-stack-client-python/compare/v0.4.0-alpha.6...v0.4.0-alpha.7) + +### Bug Fixes + +* **api:** ensure openapi spec has deprecated routes ([44f2d4e](https://github.com/llamastack/llama-stack-client-python/commit/44f2d4e613a4f7ace0a874c4cd2cf18a28dabed4)) + ## 0.4.0-alpha.6 (2025-11-12) Full Changelog: [v0.4.0-alpha.5...v0.4.0-alpha.6](https://github.com/llamastack/llama-stack-client-python/compare/v0.4.0-alpha.5...v0.4.0-alpha.6) diff --git a/README.md b/README.md index a3f81a38..985b7a72 100644 --- a/README.md +++ b/README.md @@ -33,15 +33,10 @@ from llama_stack_client import LlamaStackClient client = LlamaStackClient() -completion = client.chat.completions.create( - messages=[ - { - "content": "string", - "role": "user", - } - ], - model="model", +response = client.models.register( + model_id="model_id", ) +print(response.identifier) ``` While you can provide an `api_key` keyword argument, we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/) to add `LLAMA_STACK_CLIENT_API_KEY="My API Key"` to your `.env` file so that your API Key is not stored in source control. @@ -98,15 +93,10 @@ client = AsyncLlamaStackClient( async def main() -> None: - completion = await client.chat.completions.create( - messages=[ - { - "content": "string", - "role": "user", - } - ], - model="model", + response = await client.models.register( + model_id="model_id", ) + print(response.identifier) asyncio.run(main()) @@ -137,15 +127,10 @@ async def main() -> None: async with AsyncLlamaStackClient( http_client=DefaultAioHttpClient(), ) as client: - completion = await client.chat.completions.create( - messages=[ - { - "content": "string", - "role": "user", - } - ], - model="model", + response = await client.models.register( + model_id="model_id", ) + print(response.identifier) asyncio.run(main()) @@ -213,10 +198,11 @@ from llama_stack_client import LlamaStackClient client = LlamaStackClient() -tool_defs = client.tool_runtime.list_tools( +client.toolgroups.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", mcp_endpoint={"uri": "uri"}, ) -print(tool_defs.mcp_endpoint) ``` ## File uploads diff --git a/api.md b/api.md index caca03e0..7f8501e6 100644 --- a/api.md +++ b/api.md @@ -4,6 +4,7 @@ from llama_stack_client.types import ( InterleavedContent, InterleavedContentItem, + ParamType, SafetyViolation, SamplingParams, ScoringResult, @@ -23,6 +24,8 @@ Methods: - client.toolgroups.list() -> ToolgroupListResponse - client.toolgroups.get(toolgroup_id) -> ToolGroup +- client.toolgroups.register(\*\*params) -> None +- client.toolgroups.unregister(toolgroup_id) -> None # Tools @@ -285,6 +288,7 @@ from llama_stack_client.types import ( Model, ModelRetrieveResponse, ModelListResponse, + ModelRegisterResponse, ) ``` @@ -292,6 +296,8 @@ Methods: - client.models.retrieve(model_id) -> ModelRetrieveResponse - client.models.list() -> ModelListResponse +- client.models.register(\*\*params) -> ModelRegisterResponse +- client.models.unregister(model_id) -> None ## OpenAI @@ -360,6 +366,8 @@ Methods: - client.shields.retrieve(identifier) -> Shield - client.shields.list() -> ShieldListResponse +- client.shields.delete(identifier) -> None +- client.shields.register(\*\*params) -> Shield # Scoring @@ -391,6 +399,7 @@ Methods: - client.scoring_functions.retrieve(scoring_fn_id) -> ScoringFn - client.scoring_functions.list() -> ScoringFunctionListResponse +- client.scoring_functions.register(\*\*params) -> None # Files diff --git a/pyproject.toml b/pyproject.toml index 28d0553a..bf8b64c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "llama_stack_client" -version = "0.4.0-alpha.6" +version = "0.4.0-alpha.7" description = "The official Python library for the llama-stack-client API" dynamic = ["readme"] license = "MIT" diff --git a/src/llama_stack_client/resources/models/models.py b/src/llama_stack_client/resources/models/models.py index 71e0ad4e..7592e0b1 100644 --- a/src/llama_stack_client/resources/models/models.py +++ b/src/llama_stack_client/resources/models/models.py @@ -8,7 +8,9 @@ from __future__ import annotations -from typing import Type, cast +import typing_extensions +from typing import Dict, Type, Union, Iterable, cast +from typing_extensions import Literal import httpx @@ -20,7 +22,9 @@ OpenAIResourceWithStreamingResponse, AsyncOpenAIResourceWithStreamingResponse, ) -from ..._types import Body, Query, Headers, NotGiven, not_given +from ...types import model_register_params +from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from ..._utils import maybe_transform, async_maybe_transform from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource from ..._response import ( @@ -32,6 +36,7 @@ from ..._wrappers import DataWrapper from ..._base_client import make_request_options from ...types.model_list_response import ModelListResponse +from ...types.model_register_response import ModelRegisterResponse from ...types.model_retrieve_response import ModelRetrieveResponse __all__ = ["ModelsResource", "AsyncModelsResource"] @@ -118,6 +123,99 @@ def list( cast_to=cast(Type[ModelListResponse], DataWrapper[ModelListResponse]), ) + @typing_extensions.deprecated("deprecated") + def register( + self, + *, + model_id: str, + metadata: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + model_type: Literal["llm", "embedding", "rerank"] | Omit = omit, + provider_id: str | Omit = omit, + provider_model_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> ModelRegisterResponse: + """Register model. + + Register a model. + + Args: + model_id: The identifier of the model to register. + + metadata: Any additional metadata for this model. + + model_type: The type of model to register. + + provider_id: The identifier of the provider. + + provider_model_id: The identifier of the model in the provider. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/models", + body=maybe_transform( + { + "model_id": model_id, + "metadata": metadata, + "model_type": model_type, + "provider_id": provider_id, + "provider_model_id": provider_model_id, + }, + model_register_params.ModelRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ModelRegisterResponse, + ) + + @typing_extensions.deprecated("deprecated") + def unregister( + self, + model_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """Unregister model. + + Unregister a model. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not model_id: + raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._delete( + f"/v1/models/{model_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class AsyncModelsResource(AsyncAPIResource): @cached_property @@ -200,6 +298,99 @@ async def list( cast_to=cast(Type[ModelListResponse], DataWrapper[ModelListResponse]), ) + @typing_extensions.deprecated("deprecated") + async def register( + self, + *, + model_id: str, + metadata: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + model_type: Literal["llm", "embedding", "rerank"] | Omit = omit, + provider_id: str | Omit = omit, + provider_model_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> ModelRegisterResponse: + """Register model. + + Register a model. + + Args: + model_id: The identifier of the model to register. + + metadata: Any additional metadata for this model. + + model_type: The type of model to register. + + provider_id: The identifier of the provider. + + provider_model_id: The identifier of the model in the provider. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/models", + body=await async_maybe_transform( + { + "model_id": model_id, + "metadata": metadata, + "model_type": model_type, + "provider_id": provider_id, + "provider_model_id": provider_model_id, + }, + model_register_params.ModelRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ModelRegisterResponse, + ) + + @typing_extensions.deprecated("deprecated") + async def unregister( + self, + model_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """Unregister model. + + Unregister a model. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not model_id: + raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._delete( + f"/v1/models/{model_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class ModelsResourceWithRawResponse: def __init__(self, models: ModelsResource) -> None: @@ -211,6 +402,16 @@ def __init__(self, models: ModelsResource) -> None: self.list = to_raw_response_wrapper( models.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + models.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + models.unregister, # pyright: ignore[reportDeprecated], + ) + ) @cached_property def openai(self) -> OpenAIResourceWithRawResponse: @@ -227,6 +428,16 @@ def __init__(self, models: AsyncModelsResource) -> None: self.list = async_to_raw_response_wrapper( models.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + models.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + models.unregister, # pyright: ignore[reportDeprecated], + ) + ) @cached_property def openai(self) -> AsyncOpenAIResourceWithRawResponse: @@ -243,6 +454,16 @@ def __init__(self, models: ModelsResource) -> None: self.list = to_streamed_response_wrapper( models.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + models.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + models.unregister, # pyright: ignore[reportDeprecated], + ) + ) @cached_property def openai(self) -> OpenAIResourceWithStreamingResponse: @@ -259,6 +480,16 @@ def __init__(self, models: AsyncModelsResource) -> None: self.list = async_to_streamed_response_wrapper( models.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + models.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + models.unregister, # pyright: ignore[reportDeprecated], + ) + ) @cached_property def openai(self) -> AsyncOpenAIResourceWithStreamingResponse: diff --git a/src/llama_stack_client/resources/scoring_functions.py b/src/llama_stack_client/resources/scoring_functions.py index 916cb852..2a391a4f 100644 --- a/src/llama_stack_client/resources/scoring_functions.py +++ b/src/llama_stack_client/resources/scoring_functions.py @@ -8,11 +8,14 @@ from __future__ import annotations +import typing_extensions from typing import Type, cast import httpx -from .._types import Body, Query, Headers, NotGiven, not_given +from ..types import scoring_function_register_params +from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -24,6 +27,7 @@ from .._wrappers import DataWrapper from .._base_client import make_request_options from ..types.scoring_fn import ScoringFn +from ..types.scoring_fn_params_param import ScoringFnParamsParam from ..types.scoring_function_list_response import ScoringFunctionListResponse __all__ = ["ScoringFunctionsResource", "AsyncScoringFunctionsResource"] @@ -105,6 +109,66 @@ def list( cast_to=cast(Type[ScoringFunctionListResponse], DataWrapper[ScoringFunctionListResponse]), ) + @typing_extensions.deprecated("deprecated") + def register( + self, + *, + description: str, + return_type: scoring_function_register_params.ReturnType, + scoring_fn_id: str, + params: ScoringFnParamsParam | Omit = omit, + provider_id: str | Omit = omit, + provider_scoring_fn_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Register a scoring function. + + Args: + description: The description of the scoring function. + + scoring_fn_id: The ID of the scoring function to register. + + params: The parameters for the scoring function for benchmark eval, these can be + overridden for app eval. + + provider_id: The ID of the provider to use for the scoring function. + + provider_scoring_fn_id: The ID of the provider scoring function to use for the scoring function. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._post( + "/v1/scoring-functions", + body=maybe_transform( + { + "description": description, + "return_type": return_type, + "scoring_fn_id": scoring_fn_id, + "params": params, + "provider_id": provider_id, + "provider_scoring_fn_id": provider_scoring_fn_id, + }, + scoring_function_register_params.ScoringFunctionRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class AsyncScoringFunctionsResource(AsyncAPIResource): @cached_property @@ -182,6 +246,66 @@ async def list( cast_to=cast(Type[ScoringFunctionListResponse], DataWrapper[ScoringFunctionListResponse]), ) + @typing_extensions.deprecated("deprecated") + async def register( + self, + *, + description: str, + return_type: scoring_function_register_params.ReturnType, + scoring_fn_id: str, + params: ScoringFnParamsParam | Omit = omit, + provider_id: str | Omit = omit, + provider_scoring_fn_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Register a scoring function. + + Args: + description: The description of the scoring function. + + scoring_fn_id: The ID of the scoring function to register. + + params: The parameters for the scoring function for benchmark eval, these can be + overridden for app eval. + + provider_id: The ID of the provider to use for the scoring function. + + provider_scoring_fn_id: The ID of the provider scoring function to use for the scoring function. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._post( + "/v1/scoring-functions", + body=await async_maybe_transform( + { + "description": description, + "return_type": return_type, + "scoring_fn_id": scoring_fn_id, + "params": params, + "provider_id": provider_id, + "provider_scoring_fn_id": provider_scoring_fn_id, + }, + scoring_function_register_params.ScoringFunctionRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class ScoringFunctionsResourceWithRawResponse: def __init__(self, scoring_functions: ScoringFunctionsResource) -> None: @@ -193,6 +317,11 @@ def __init__(self, scoring_functions: ScoringFunctionsResource) -> None: self.list = to_raw_response_wrapper( scoring_functions.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + scoring_functions.register, # pyright: ignore[reportDeprecated], + ) + ) class AsyncScoringFunctionsResourceWithRawResponse: @@ -205,6 +334,11 @@ def __init__(self, scoring_functions: AsyncScoringFunctionsResource) -> None: self.list = async_to_raw_response_wrapper( scoring_functions.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + scoring_functions.register, # pyright: ignore[reportDeprecated], + ) + ) class ScoringFunctionsResourceWithStreamingResponse: @@ -217,6 +351,11 @@ def __init__(self, scoring_functions: ScoringFunctionsResource) -> None: self.list = to_streamed_response_wrapper( scoring_functions.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + scoring_functions.register, # pyright: ignore[reportDeprecated], + ) + ) class AsyncScoringFunctionsResourceWithStreamingResponse: @@ -229,3 +368,8 @@ def __init__(self, scoring_functions: AsyncScoringFunctionsResource) -> None: self.list = async_to_streamed_response_wrapper( scoring_functions.list, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + scoring_functions.register, # pyright: ignore[reportDeprecated], + ) + ) diff --git a/src/llama_stack_client/resources/shields.py b/src/llama_stack_client/resources/shields.py index 8186a67d..ee548579 100644 --- a/src/llama_stack_client/resources/shields.py +++ b/src/llama_stack_client/resources/shields.py @@ -8,11 +8,14 @@ from __future__ import annotations -from typing import Type, cast +import typing_extensions +from typing import Dict, Type, Union, Iterable, cast import httpx -from .._types import Body, Query, Headers, NotGiven, not_given +from ..types import shield_register_params +from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -105,6 +108,93 @@ def list( cast_to=cast(Type[ShieldListResponse], DataWrapper[ShieldListResponse]), ) + @typing_extensions.deprecated("deprecated") + def delete( + self, + identifier: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Unregister a shield. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not identifier: + raise ValueError(f"Expected a non-empty value for `identifier` but received {identifier!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._delete( + f"/v1/shields/{identifier}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + @typing_extensions.deprecated("deprecated") + def register( + self, + *, + shield_id: str, + params: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + provider_id: str | Omit = omit, + provider_shield_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> Shield: + """ + Register a shield. + + Args: + shield_id: The identifier of the shield to register. + + params: The parameters of the shield. + + provider_id: The identifier of the provider. + + provider_shield_id: The identifier of the shield in the provider. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/shields", + body=maybe_transform( + { + "shield_id": shield_id, + "params": params, + "provider_id": provider_id, + "provider_shield_id": provider_shield_id, + }, + shield_register_params.ShieldRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Shield, + ) + class AsyncShieldsResource(AsyncAPIResource): @cached_property @@ -182,6 +272,93 @@ async def list( cast_to=cast(Type[ShieldListResponse], DataWrapper[ShieldListResponse]), ) + @typing_extensions.deprecated("deprecated") + async def delete( + self, + identifier: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Unregister a shield. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not identifier: + raise ValueError(f"Expected a non-empty value for `identifier` but received {identifier!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._delete( + f"/v1/shields/{identifier}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + @typing_extensions.deprecated("deprecated") + async def register( + self, + *, + shield_id: str, + params: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + provider_id: str | Omit = omit, + provider_shield_id: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> Shield: + """ + Register a shield. + + Args: + shield_id: The identifier of the shield to register. + + params: The parameters of the shield. + + provider_id: The identifier of the provider. + + provider_shield_id: The identifier of the shield in the provider. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/shields", + body=await async_maybe_transform( + { + "shield_id": shield_id, + "params": params, + "provider_id": provider_id, + "provider_shield_id": provider_shield_id, + }, + shield_register_params.ShieldRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Shield, + ) + class ShieldsResourceWithRawResponse: def __init__(self, shields: ShieldsResource) -> None: @@ -193,6 +370,16 @@ def __init__(self, shields: ShieldsResource) -> None: self.list = to_raw_response_wrapper( shields.list, ) + self.delete = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + shields.delete, # pyright: ignore[reportDeprecated], + ) + ) + self.register = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + shields.register, # pyright: ignore[reportDeprecated], + ) + ) class AsyncShieldsResourceWithRawResponse: @@ -205,6 +392,16 @@ def __init__(self, shields: AsyncShieldsResource) -> None: self.list = async_to_raw_response_wrapper( shields.list, ) + self.delete = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + shields.delete, # pyright: ignore[reportDeprecated], + ) + ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + shields.register, # pyright: ignore[reportDeprecated], + ) + ) class ShieldsResourceWithStreamingResponse: @@ -217,6 +414,16 @@ def __init__(self, shields: ShieldsResource) -> None: self.list = to_streamed_response_wrapper( shields.list, ) + self.delete = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + shields.delete, # pyright: ignore[reportDeprecated], + ) + ) + self.register = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + shields.register, # pyright: ignore[reportDeprecated], + ) + ) class AsyncShieldsResourceWithStreamingResponse: @@ -229,3 +436,13 @@ def __init__(self, shields: AsyncShieldsResource) -> None: self.list = async_to_streamed_response_wrapper( shields.list, ) + self.delete = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + shields.delete, # pyright: ignore[reportDeprecated], + ) + ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + shields.register, # pyright: ignore[reportDeprecated], + ) + ) diff --git a/src/llama_stack_client/resources/toolgroups.py b/src/llama_stack_client/resources/toolgroups.py index 25f14a37..41e3ca42 100644 --- a/src/llama_stack_client/resources/toolgroups.py +++ b/src/llama_stack_client/resources/toolgroups.py @@ -8,11 +8,14 @@ from __future__ import annotations -from typing import Type, cast +import typing_extensions +from typing import Dict, Type, Union, Iterable, cast import httpx -from .._types import Body, Query, Headers, NotGiven, not_given +from ..types import toolgroup_register_params +from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -105,6 +108,94 @@ def get( cast_to=ToolGroup, ) + @typing_extensions.deprecated("deprecated") + def register( + self, + *, + provider_id: str, + toolgroup_id: str, + args: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + mcp_endpoint: toolgroup_register_params.McpEndpoint | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Register a tool group. + + Args: + provider_id: The ID of the provider to use for the tool group. + + toolgroup_id: The ID of the tool group to register. + + args: A dictionary of arguments to pass to the tool group. + + mcp_endpoint: The MCP endpoint to use for the tool group. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._post( + "/v1/toolgroups", + body=maybe_transform( + { + "provider_id": provider_id, + "toolgroup_id": toolgroup_id, + "args": args, + "mcp_endpoint": mcp_endpoint, + }, + toolgroup_register_params.ToolgroupRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + @typing_extensions.deprecated("deprecated") + def unregister( + self, + toolgroup_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Unregister a tool group. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not toolgroup_id: + raise ValueError(f"Expected a non-empty value for `toolgroup_id` but received {toolgroup_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._delete( + f"/v1/toolgroups/{toolgroup_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class AsyncToolgroupsResource(AsyncAPIResource): @cached_property @@ -182,6 +273,94 @@ async def get( cast_to=ToolGroup, ) + @typing_extensions.deprecated("deprecated") + async def register( + self, + *, + provider_id: str, + toolgroup_id: str, + args: Dict[str, Union[bool, float, str, Iterable[object], object, None]] | Omit = omit, + mcp_endpoint: toolgroup_register_params.McpEndpoint | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Register a tool group. + + Args: + provider_id: The ID of the provider to use for the tool group. + + toolgroup_id: The ID of the tool group to register. + + args: A dictionary of arguments to pass to the tool group. + + mcp_endpoint: The MCP endpoint to use for the tool group. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._post( + "/v1/toolgroups", + body=await async_maybe_transform( + { + "provider_id": provider_id, + "toolgroup_id": toolgroup_id, + "args": args, + "mcp_endpoint": mcp_endpoint, + }, + toolgroup_register_params.ToolgroupRegisterParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + @typing_extensions.deprecated("deprecated") + async def unregister( + self, + toolgroup_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> None: + """ + Unregister a tool group. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not toolgroup_id: + raise ValueError(f"Expected a non-empty value for `toolgroup_id` but received {toolgroup_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._delete( + f"/v1/toolgroups/{toolgroup_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + class ToolgroupsResourceWithRawResponse: def __init__(self, toolgroups: ToolgroupsResource) -> None: @@ -193,6 +372,16 @@ def __init__(self, toolgroups: ToolgroupsResource) -> None: self.get = to_raw_response_wrapper( toolgroups.get, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + toolgroups.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + toolgroups.unregister, # pyright: ignore[reportDeprecated], + ) + ) class AsyncToolgroupsResourceWithRawResponse: @@ -205,6 +394,16 @@ def __init__(self, toolgroups: AsyncToolgroupsResource) -> None: self.get = async_to_raw_response_wrapper( toolgroups.get, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + toolgroups.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + toolgroups.unregister, # pyright: ignore[reportDeprecated], + ) + ) class ToolgroupsResourceWithStreamingResponse: @@ -217,6 +416,16 @@ def __init__(self, toolgroups: ToolgroupsResource) -> None: self.get = to_streamed_response_wrapper( toolgroups.get, ) + self.register = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + toolgroups.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + toolgroups.unregister, # pyright: ignore[reportDeprecated], + ) + ) class AsyncToolgroupsResourceWithStreamingResponse: @@ -229,3 +438,13 @@ def __init__(self, toolgroups: AsyncToolgroupsResource) -> None: self.get = async_to_streamed_response_wrapper( toolgroups.get, ) + self.register = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + toolgroups.register, # pyright: ignore[reportDeprecated], + ) + ) + self.unregister = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + toolgroups.unregister, # pyright: ignore[reportDeprecated], + ) + ) diff --git a/src/llama_stack_client/types/__init__.py b/src/llama_stack_client/types/__init__.py index 678401ed..26f7f9a0 100644 --- a/src/llama_stack_client/types/__init__.py +++ b/src/llama_stack_client/types/__init__.py @@ -12,6 +12,7 @@ from .model import Model as Model from .prompt import Prompt as Prompt from .shared import ( + ParamType as ParamType, ScoringResult as ScoringResult, SystemMessage as SystemMessage, SamplingParams as SamplingParams, @@ -53,6 +54,7 @@ from .chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk from .list_prompts_response import ListPromptsResponse as ListPromptsResponse from .list_shields_response import ListShieldsResponse as ListShieldsResponse +from .model_register_params import ModelRegisterParams as ModelRegisterParams from .query_chunks_response import QueryChunksResponse as QueryChunksResponse from .prompt_retrieve_params import PromptRetrieveParams as PromptRetrieveParams from .provider_list_response import ProviderListResponse as ProviderListResponse @@ -60,10 +62,12 @@ from .response_list_response import ResponseListResponse as ResponseListResponse from .response_object_stream import ResponseObjectStream as ResponseObjectStream from .scoring_score_response import ScoringScoreResponse as ScoringScoreResponse +from .shield_register_params import ShieldRegisterParams as ShieldRegisterParams from .tool_invocation_result import ToolInvocationResult as ToolInvocationResult from .vector_io_query_params import VectorIoQueryParams as VectorIoQueryParams from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams from .list_providers_response import ListProvidersResponse as ListProvidersResponse +from .model_register_response import ModelRegisterResponse as ModelRegisterResponse from .model_retrieve_response import ModelRetrieveResponse as ModelRetrieveResponse from .scoring_fn_params_param import ScoringFnParamsParam as ScoringFnParamsParam from .toolgroup_list_response import ToolgroupListResponse as ToolgroupListResponse @@ -74,6 +78,7 @@ from .safety_run_shield_params import SafetyRunShieldParams as SafetyRunShieldParams from .vector_store_list_params import VectorStoreListParams as VectorStoreListParams from .list_tool_groups_response import ListToolGroupsResponse as ListToolGroupsResponse +from .toolgroup_register_params import ToolgroupRegisterParams as ToolgroupRegisterParams from .completion_create_response import CompletionCreateResponse as CompletionCreateResponse from .conversation_create_params import ConversationCreateParams as ConversationCreateParams from .conversation_update_params import ConversationUpdateParams as ConversationUpdateParams @@ -91,5 +96,6 @@ from .tool_runtime_list_tools_params import ToolRuntimeListToolsParams as ToolRuntimeListToolsParams from .list_scoring_functions_response import ListScoringFunctionsResponse as ListScoringFunctionsResponse from .tool_runtime_invoke_tool_params import ToolRuntimeInvokeToolParams as ToolRuntimeInvokeToolParams +from .scoring_function_register_params import ScoringFunctionRegisterParams as ScoringFunctionRegisterParams from .tool_runtime_list_tools_response import ToolRuntimeListToolsResponse as ToolRuntimeListToolsResponse from .prompt_set_default_version_params import PromptSetDefaultVersionParams as PromptSetDefaultVersionParams diff --git a/src/llama_stack_client/types/model_register_params.py b/src/llama_stack_client/types/model_register_params.py new file mode 100644 index 00000000..a13382a8 --- /dev/null +++ b/src/llama_stack_client/types/model_register_params.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["ModelRegisterParams"] + + +class ModelRegisterParams(TypedDict, total=False): + model_id: Required[str] + """The identifier of the model to register.""" + + metadata: Dict[str, Union[bool, float, str, Iterable[object], object, None]] + """Any additional metadata for this model.""" + + model_type: Literal["llm", "embedding", "rerank"] + """The type of model to register.""" + + provider_id: str + """The identifier of the provider.""" + + provider_model_id: str + """The identifier of the model in the provider.""" diff --git a/src/llama_stack_client/types/model_register_response.py b/src/llama_stack_client/types/model_register_response.py new file mode 100644 index 00000000..08b0e8d6 --- /dev/null +++ b/src/llama_stack_client/types/model_register_response.py @@ -0,0 +1,30 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Union, Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from .._models import BaseModel + +__all__ = ["ModelRegisterResponse"] + + +class ModelRegisterResponse(BaseModel): + identifier: str + """Unique identifier for this resource in llama stack""" + + metadata: Dict[str, Union[bool, float, str, List[object], object, None]] + """Any additional metadata for this model""" + + api_model_type: Literal["llm", "embedding", "rerank"] = FieldInfo(alias="model_type") + """The type of model (LLM or embedding model)""" + + provider_id: str + """ID of the provider that owns this resource""" + + type: Literal["model"] + """The resource type, always 'model' for model resources""" + + provider_resource_id: Optional[str] = None + """Unique identifier for this resource in the provider""" diff --git a/src/llama_stack_client/types/scoring_function_register_params.py b/src/llama_stack_client/types/scoring_function_register_params.py new file mode 100644 index 00000000..bf58bc33 --- /dev/null +++ b/src/llama_stack_client/types/scoring_function_register_params.py @@ -0,0 +1,48 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, TypedDict + +from .scoring_fn_params_param import ScoringFnParamsParam + +__all__ = ["ScoringFunctionRegisterParams", "ReturnType"] + + +class ScoringFunctionRegisterParams(TypedDict, total=False): + description: Required[str] + """The description of the scoring function.""" + + return_type: Required[ReturnType] + + scoring_fn_id: Required[str] + """The ID of the scoring function to register.""" + + params: ScoringFnParamsParam + """ + The parameters for the scoring function for benchmark eval, these can be + overridden for app eval. + """ + + provider_id: str + """The ID of the provider to use for the scoring function.""" + + provider_scoring_fn_id: str + """The ID of the provider scoring function to use for the scoring function.""" + + +class ReturnType(TypedDict, total=False): + type: Required[ + Literal[ + "string", + "number", + "boolean", + "array", + "object", + "json", + "union", + "chat_completion_input", + "completion_input", + "agent_turn_input", + ] + ] diff --git a/src/llama_stack_client/types/shared/__init__.py b/src/llama_stack_client/types/shared/__init__.py index 19dffde4..fdeee5aa 100644 --- a/src/llama_stack_client/types/shared/__init__.py +++ b/src/llama_stack_client/types/shared/__init__.py @@ -6,6 +6,7 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. +from .param_type import ParamType as ParamType from .scoring_result import ScoringResult as ScoringResult from .system_message import SystemMessage as SystemMessage from .sampling_params import SamplingParams as SamplingParams diff --git a/src/llama_stack_client/types/shared/param_type.py b/src/llama_stack_client/types/shared/param_type.py new file mode 100644 index 00000000..a45a31db --- /dev/null +++ b/src/llama_stack_client/types/shared/param_type.py @@ -0,0 +1,81 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Union +from typing_extensions import Literal, Annotated, TypeAlias + +from ..._utils import PropertyInfo +from ..._models import BaseModel + +__all__ = [ + "ParamType", + "StringType", + "NumberType", + "BooleanType", + "ArrayType", + "ObjectType", + "JsonType", + "UnionType", + "ChatCompletionInputType", + "CompletionInputType", +] + + +class StringType(BaseModel): + type: Literal["string"] + """Discriminator type. Always "string" """ + + +class NumberType(BaseModel): + type: Literal["number"] + """Discriminator type. Always "number" """ + + +class BooleanType(BaseModel): + type: Literal["boolean"] + """Discriminator type. Always "boolean" """ + + +class ArrayType(BaseModel): + type: Literal["array"] + """Discriminator type. Always "array" """ + + +class ObjectType(BaseModel): + type: Literal["object"] + """Discriminator type. Always "object" """ + + +class JsonType(BaseModel): + type: Literal["json"] + """Discriminator type. Always "json" """ + + +class UnionType(BaseModel): + type: Literal["union"] + """Discriminator type. Always "union" """ + + +class ChatCompletionInputType(BaseModel): + type: Literal["chat_completion_input"] + """Discriminator type. Always "chat_completion_input" """ + + +class CompletionInputType(BaseModel): + type: Literal["completion_input"] + """Discriminator type. Always "completion_input" """ + + +ParamType: TypeAlias = Annotated[ + Union[ + StringType, + NumberType, + BooleanType, + ArrayType, + ObjectType, + JsonType, + UnionType, + ChatCompletionInputType, + CompletionInputType, + ], + PropertyInfo(discriminator="type"), +] diff --git a/src/llama_stack_client/types/shield_register_params.py b/src/llama_stack_client/types/shield_register_params.py new file mode 100644 index 00000000..7ae0b2c1 --- /dev/null +++ b/src/llama_stack_client/types/shield_register_params.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable +from typing_extensions import Required, TypedDict + +__all__ = ["ShieldRegisterParams"] + + +class ShieldRegisterParams(TypedDict, total=False): + shield_id: Required[str] + """The identifier of the shield to register.""" + + params: Dict[str, Union[bool, float, str, Iterable[object], object, None]] + """The parameters of the shield.""" + + provider_id: str + """The identifier of the provider.""" + + provider_shield_id: str + """The identifier of the shield in the provider.""" diff --git a/src/llama_stack_client/types/toolgroup_register_params.py b/src/llama_stack_client/types/toolgroup_register_params.py new file mode 100644 index 00000000..2aa79960 --- /dev/null +++ b/src/llama_stack_client/types/toolgroup_register_params.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict, Union, Iterable +from typing_extensions import Required, TypedDict + +__all__ = ["ToolgroupRegisterParams", "McpEndpoint"] + + +class ToolgroupRegisterParams(TypedDict, total=False): + provider_id: Required[str] + """The ID of the provider to use for the tool group.""" + + toolgroup_id: Required[str] + """The ID of the tool group to register.""" + + args: Dict[str, Union[bool, float, str, Iterable[object], object, None]] + """A dictionary of arguments to pass to the tool group.""" + + mcp_endpoint: McpEndpoint + """The MCP endpoint to use for the tool group.""" + + +class McpEndpoint(TypedDict, total=False): + uri: Required[str] + """The URL string pointing to the resource""" diff --git a/tests/api_resources/test_models.py b/tests/api_resources/test_models.py index a50d3905..7f7b834f 100644 --- a/tests/api_resources/test_models.py +++ b/tests/api_resources/test_models.py @@ -15,7 +15,13 @@ from tests.utils import assert_matches_type from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient -from llama_stack_client.types import ModelListResponse, ModelRetrieveResponse +from llama_stack_client.types import ( + ModelListResponse, + ModelRegisterResponse, + ModelRetrieveResponse, +) + +# pyright: reportDeprecated=false base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -86,6 +92,97 @@ def test_streaming_response_list(self, client: LlamaStackClient) -> None: assert cast(Any, response.is_closed) is True + @parametrize + def test_method_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = client.models.register( + model_id="model_id", + ) + + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + def test_method_register_with_all_params(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = client.models.register( + model_id="model_id", + metadata={"foo": True}, + model_type="llm", + provider_id="provider_id", + provider_model_id="provider_model_id", + ) + + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + def test_raw_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.models.with_raw_response.register( + model_id="model_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + model = response.parse() + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + def test_streaming_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.models.with_streaming_response.register( + model_id="model_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + model = response.parse() + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = client.models.unregister( + "model_id", + ) + + assert model is None + + @parametrize + def test_raw_response_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.models.with_raw_response.unregister( + "model_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + model = response.parse() + assert model is None + + @parametrize + def test_streaming_response_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.models.with_streaming_response.unregister( + "model_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + model = response.parse() + assert model is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `model_id` but received ''"): + client.models.with_raw_response.unregister( + "", + ) + class TestAsyncModels: parametrize = pytest.mark.parametrize( @@ -154,3 +251,94 @@ async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient assert_matches_type(ModelListResponse, model, path=["response"]) assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = await async_client.models.register( + model_id="model_id", + ) + + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = await async_client.models.register( + model_id="model_id", + metadata={"foo": True}, + model_type="llm", + provider_id="provider_id", + provider_model_id="provider_model_id", + ) + + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + async def test_raw_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.models.with_raw_response.register( + model_id="model_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + model = await response.parse() + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + @parametrize + async def test_streaming_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.models.with_streaming_response.register( + model_id="model_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + model = await response.parse() + assert_matches_type(ModelRegisterResponse, model, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + model = await async_client.models.unregister( + "model_id", + ) + + assert model is None + + @parametrize + async def test_raw_response_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.models.with_raw_response.unregister( + "model_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + model = await response.parse() + assert model is None + + @parametrize + async def test_streaming_response_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.models.with_streaming_response.unregister( + "model_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + model = await response.parse() + assert model is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `model_id` but received ''"): + await async_client.models.with_raw_response.unregister( + "", + ) diff --git a/tests/api_resources/test_scoring_functions.py b/tests/api_resources/test_scoring_functions.py index de9e2bc7..22470900 100644 --- a/tests/api_resources/test_scoring_functions.py +++ b/tests/api_resources/test_scoring_functions.py @@ -15,7 +15,12 @@ from tests.utils import assert_matches_type from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient -from llama_stack_client.types import ScoringFn, ScoringFunctionListResponse +from llama_stack_client.types import ( + ScoringFn, + ScoringFunctionListResponse, +) + +# pyright: reportDeprecated=false base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -86,6 +91,67 @@ def test_streaming_response_list(self, client: LlamaStackClient) -> None: assert cast(Any, response.is_closed) is True + @parametrize + def test_method_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + scoring_function = client.scoring_functions.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) + + assert scoring_function is None + + @parametrize + def test_method_register_with_all_params(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + scoring_function = client.scoring_functions.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + params={ + "aggregation_functions": ["average"], + "judge_model": "judge_model", + "judge_score_regexes": ["string"], + "type": "llm_as_judge", + "prompt_template": "prompt_template", + }, + provider_id="provider_id", + provider_scoring_fn_id="provider_scoring_fn_id", + ) + + assert scoring_function is None + + @parametrize + def test_raw_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.scoring_functions.with_raw_response.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + scoring_function = response.parse() + assert scoring_function is None + + @parametrize + def test_streaming_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.scoring_functions.with_streaming_response.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + scoring_function = response.parse() + assert scoring_function is None + + assert cast(Any, response.is_closed) is True + class TestAsyncScoringFunctions: parametrize = pytest.mark.parametrize( @@ -154,3 +220,64 @@ async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient assert_matches_type(ScoringFunctionListResponse, scoring_function, path=["response"]) assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + scoring_function = await async_client.scoring_functions.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) + + assert scoring_function is None + + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + scoring_function = await async_client.scoring_functions.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + params={ + "aggregation_functions": ["average"], + "judge_model": "judge_model", + "judge_score_regexes": ["string"], + "type": "llm_as_judge", + "prompt_template": "prompt_template", + }, + provider_id="provider_id", + provider_scoring_fn_id="provider_scoring_fn_id", + ) + + assert scoring_function is None + + @parametrize + async def test_raw_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.scoring_functions.with_raw_response.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + scoring_function = await response.parse() + assert scoring_function is None + + @parametrize + async def test_streaming_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.scoring_functions.with_streaming_response.register( + description="description", + return_type={"type": "string"}, + scoring_fn_id="scoring_fn_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + scoring_function = await response.parse() + assert scoring_function is None + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_shields.py b/tests/api_resources/test_shields.py index f03e6185..d2b12f1a 100644 --- a/tests/api_resources/test_shields.py +++ b/tests/api_resources/test_shields.py @@ -17,6 +17,8 @@ from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient from llama_stack_client.types import Shield, ShieldListResponse +# pyright: reportDeprecated=false + base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -86,6 +88,96 @@ def test_streaming_response_list(self, client: LlamaStackClient) -> None: assert cast(Any, response.is_closed) is True + @parametrize + def test_method_delete(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = client.shields.delete( + "identifier", + ) + + assert shield is None + + @parametrize + def test_raw_response_delete(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.shields.with_raw_response.delete( + "identifier", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + shield = response.parse() + assert shield is None + + @parametrize + def test_streaming_response_delete(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.shields.with_streaming_response.delete( + "identifier", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + shield = response.parse() + assert shield is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_delete(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `identifier` but received ''"): + client.shields.with_raw_response.delete( + "", + ) + + @parametrize + def test_method_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = client.shields.register( + shield_id="shield_id", + ) + + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + def test_method_register_with_all_params(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = client.shields.register( + shield_id="shield_id", + params={"foo": True}, + provider_id="provider_id", + provider_shield_id="provider_shield_id", + ) + + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + def test_raw_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.shields.with_raw_response.register( + shield_id="shield_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + shield = response.parse() + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + def test_streaming_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.shields.with_streaming_response.register( + shield_id="shield_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + shield = response.parse() + assert_matches_type(Shield, shield, path=["response"]) + + assert cast(Any, response.is_closed) is True + class TestAsyncShields: parametrize = pytest.mark.parametrize( @@ -154,3 +246,93 @@ async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient assert_matches_type(ShieldListResponse, shield, path=["response"]) assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_delete(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = await async_client.shields.delete( + "identifier", + ) + + assert shield is None + + @parametrize + async def test_raw_response_delete(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.shields.with_raw_response.delete( + "identifier", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + shield = await response.parse() + assert shield is None + + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.shields.with_streaming_response.delete( + "identifier", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + shield = await response.parse() + assert shield is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_delete(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `identifier` but received ''"): + await async_client.shields.with_raw_response.delete( + "", + ) + + @parametrize + async def test_method_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = await async_client.shields.register( + shield_id="shield_id", + ) + + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + shield = await async_client.shields.register( + shield_id="shield_id", + params={"foo": True}, + provider_id="provider_id", + provider_shield_id="provider_shield_id", + ) + + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + async def test_raw_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.shields.with_raw_response.register( + shield_id="shield_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + shield = await response.parse() + assert_matches_type(Shield, shield, path=["response"]) + + @parametrize + async def test_streaming_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.shields.with_streaming_response.register( + shield_id="shield_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + shield = await response.parse() + assert_matches_type(Shield, shield, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_toolgroups.py b/tests/api_resources/test_toolgroups.py index 73db1e46..060d6b3f 100644 --- a/tests/api_resources/test_toolgroups.py +++ b/tests/api_resources/test_toolgroups.py @@ -17,6 +17,8 @@ from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient from llama_stack_client.types import ToolGroup, ToolgroupListResponse +# pyright: reportDeprecated=false + base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -86,6 +88,99 @@ def test_path_params_get(self, client: LlamaStackClient) -> None: "", ) + @parametrize + def test_method_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = client.toolgroups.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) + + assert toolgroup is None + + @parametrize + def test_method_register_with_all_params(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = client.toolgroups.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + args={"foo": True}, + mcp_endpoint={"uri": "uri"}, + ) + + assert toolgroup is None + + @parametrize + def test_raw_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.toolgroups.with_raw_response.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + toolgroup = response.parse() + assert toolgroup is None + + @parametrize + def test_streaming_response_register(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.toolgroups.with_streaming_response.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + toolgroup = response.parse() + assert toolgroup is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = client.toolgroups.unregister( + "toolgroup_id", + ) + + assert toolgroup is None + + @parametrize + def test_raw_response_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = client.toolgroups.with_raw_response.unregister( + "toolgroup_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + toolgroup = response.parse() + assert toolgroup is None + + @parametrize + def test_streaming_response_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with client.toolgroups.with_streaming_response.unregister( + "toolgroup_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + toolgroup = response.parse() + assert toolgroup is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_unregister(self, client: LlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `toolgroup_id` but received ''"): + client.toolgroups.with_raw_response.unregister( + "", + ) + class TestAsyncToolgroups: parametrize = pytest.mark.parametrize( @@ -154,3 +249,96 @@ async def test_path_params_get(self, async_client: AsyncLlamaStackClient) -> Non await async_client.toolgroups.with_raw_response.get( "", ) + + @parametrize + async def test_method_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = await async_client.toolgroups.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) + + assert toolgroup is None + + @parametrize + async def test_method_register_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = await async_client.toolgroups.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + args={"foo": True}, + mcp_endpoint={"uri": "uri"}, + ) + + assert toolgroup is None + + @parametrize + async def test_raw_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.toolgroups.with_raw_response.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + toolgroup = await response.parse() + assert toolgroup is None + + @parametrize + async def test_streaming_response_register(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.toolgroups.with_streaming_response.register( + provider_id="provider_id", + toolgroup_id="toolgroup_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + toolgroup = await response.parse() + assert toolgroup is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + toolgroup = await async_client.toolgroups.unregister( + "toolgroup_id", + ) + + assert toolgroup is None + + @parametrize + async def test_raw_response_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + response = await async_client.toolgroups.with_raw_response.unregister( + "toolgroup_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + toolgroup = await response.parse() + assert toolgroup is None + + @parametrize + async def test_streaming_response_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + async with async_client.toolgroups.with_streaming_response.unregister( + "toolgroup_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + toolgroup = await response.parse() + assert toolgroup is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_unregister(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `toolgroup_id` but received ''"): + await async_client.toolgroups.with_raw_response.unregister( + "", + )