diff --git a/src/llama_stack_client/_base_client.py b/src/llama_stack_client/_base_client.py index a0c4ea5b..4d199940 100644 --- a/src/llama_stack_client/_base_client.py +++ b/src/llama_stack_client/_base_client.py @@ -960,6 +960,9 @@ def request( if self.custom_auth is not None: kwargs["auth"] = self.custom_auth + if options.follow_redirects is not None: + kwargs["follow_redirects"] = options.follow_redirects + log.debug("Sending HTTP Request: %s %s", request.method, request.url) response = None @@ -1460,6 +1463,9 @@ async def request( if self.custom_auth is not None: kwargs["auth"] = self.custom_auth + if options.follow_redirects is not None: + kwargs["follow_redirects"] = options.follow_redirects + log.debug("Sending HTTP Request: %s %s", request.method, request.url) response = None diff --git a/src/llama_stack_client/_client.py b/src/llama_stack_client/_client.py index e2e2c1e5..5ea3c7dc 100644 --- a/src/llama_stack_client/_client.py +++ b/src/llama_stack_client/_client.py @@ -33,7 +33,6 @@ datasets, inference, providers, - responses, telemetry, vector_io, benchmarks, @@ -53,6 +52,7 @@ from .resources.chat import chat from .resources.eval import eval from .resources.agents import agents +from .resources.responses import responses from .resources.tool_runtime import tool_runtime from .resources.post_training import post_training diff --git a/src/llama_stack_client/_models.py b/src/llama_stack_client/_models.py index 798956f1..4f214980 100644 --- a/src/llama_stack_client/_models.py +++ b/src/llama_stack_client/_models.py @@ -737,6 +737,7 @@ class FinalRequestOptionsInput(TypedDict, total=False): idempotency_key: str json_data: Body extra_json: AnyMapping + follow_redirects: bool @final @@ -750,6 +751,7 @@ class FinalRequestOptions(pydantic.BaseModel): files: Union[HttpxRequestFiles, None] = None idempotency_key: Union[str, None] = None post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven() + follow_redirects: Union[bool, None] = None # It should be noted that we cannot use `json` here as that would override # a BaseModel method in an incompatible fashion. diff --git a/src/llama_stack_client/_types.py b/src/llama_stack_client/_types.py index ed5b188d..63631322 100644 --- a/src/llama_stack_client/_types.py +++ b/src/llama_stack_client/_types.py @@ -100,6 +100,7 @@ class RequestOptions(TypedDict, total=False): params: Query extra_json: AnyMapping idempotency_key: str + follow_redirects: bool # Sentinel class used until PEP 0661 is accepted @@ -215,3 +216,4 @@ class _GenericAlias(Protocol): class HttpxSendArgs(TypedDict, total=False): auth: httpx.Auth + follow_redirects: bool diff --git a/src/llama_stack_client/resources/responses/__init__.py b/src/llama_stack_client/resources/responses/__init__.py new file mode 100644 index 00000000..230ef765 --- /dev/null +++ b/src/llama_stack_client/resources/responses/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .responses import ( + ResponsesResource, + AsyncResponsesResource, + ResponsesResourceWithRawResponse, + AsyncResponsesResourceWithRawResponse, + ResponsesResourceWithStreamingResponse, + AsyncResponsesResourceWithStreamingResponse, +) +from .input_items import ( + InputItemsResource, + AsyncInputItemsResource, + InputItemsResourceWithRawResponse, + AsyncInputItemsResourceWithRawResponse, + InputItemsResourceWithStreamingResponse, + AsyncInputItemsResourceWithStreamingResponse, +) + +__all__ = [ + "InputItemsResource", + "AsyncInputItemsResource", + "InputItemsResourceWithRawResponse", + "AsyncInputItemsResourceWithRawResponse", + "InputItemsResourceWithStreamingResponse", + "AsyncInputItemsResourceWithStreamingResponse", + "ResponsesResource", + "AsyncResponsesResource", + "ResponsesResourceWithRawResponse", + "AsyncResponsesResourceWithRawResponse", + "ResponsesResourceWithStreamingResponse", + "AsyncResponsesResourceWithStreamingResponse", +] diff --git a/src/llama_stack_client/resources/responses/input_items.py b/src/llama_stack_client/resources/responses/input_items.py new file mode 100644 index 00000000..5379ad4d --- /dev/null +++ b/src/llama_stack_client/resources/responses/input_items.py @@ -0,0 +1,226 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.responses import input_item_list_params +from ...types.responses.input_item_list_response import InputItemListResponse + +__all__ = ["InputItemsResource", "AsyncInputItemsResource"] + + +class InputItemsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> InputItemsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/llama-stack-python#accessing-raw-response-data-eg-headers + """ + return InputItemsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> InputItemsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/llama-stack-python#with_streaming_response + """ + return InputItemsResourceWithStreamingResponse(self) + + def list( + self, + response_id: str, + *, + after: str | NotGiven = NOT_GIVEN, + before: str | NotGiven = NOT_GIVEN, + include: List[str] | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN, + # 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, + ) -> InputItemListResponse: + """ + List input items for a given OpenAI response. + + Args: + after: An item ID to list items after, used for pagination. + + before: An item ID to list items before, used for pagination. + + include: Additional fields to include in the response. + + limit: A limit on the number of objects to be returned. Limit can range between 1 and + 100, and the default is 20. + + order: The order to return the input items in. Default is desc. + + 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 response_id: + raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}") + return self._get( + f"/v1/openai/v1/responses/{response_id}/input_items", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "after": after, + "before": before, + "include": include, + "limit": limit, + "order": order, + }, + input_item_list_params.InputItemListParams, + ), + ), + cast_to=InputItemListResponse, + ) + + +class AsyncInputItemsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncInputItemsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/stainless-sdks/llama-stack-python#accessing-raw-response-data-eg-headers + """ + return AsyncInputItemsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncInputItemsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/stainless-sdks/llama-stack-python#with_streaming_response + """ + return AsyncInputItemsResourceWithStreamingResponse(self) + + async def list( + self, + response_id: str, + *, + after: str | NotGiven = NOT_GIVEN, + before: str | NotGiven = NOT_GIVEN, + include: List[str] | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN, + # 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, + ) -> InputItemListResponse: + """ + List input items for a given OpenAI response. + + Args: + after: An item ID to list items after, used for pagination. + + before: An item ID to list items before, used for pagination. + + include: Additional fields to include in the response. + + limit: A limit on the number of objects to be returned. Limit can range between 1 and + 100, and the default is 20. + + order: The order to return the input items in. Default is desc. + + 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 response_id: + raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}") + return await self._get( + f"/v1/openai/v1/responses/{response_id}/input_items", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "after": after, + "before": before, + "include": include, + "limit": limit, + "order": order, + }, + input_item_list_params.InputItemListParams, + ), + ), + cast_to=InputItemListResponse, + ) + + +class InputItemsResourceWithRawResponse: + def __init__(self, input_items: InputItemsResource) -> None: + self._input_items = input_items + + self.list = to_raw_response_wrapper( + input_items.list, + ) + + +class AsyncInputItemsResourceWithRawResponse: + def __init__(self, input_items: AsyncInputItemsResource) -> None: + self._input_items = input_items + + self.list = async_to_raw_response_wrapper( + input_items.list, + ) + + +class InputItemsResourceWithStreamingResponse: + def __init__(self, input_items: InputItemsResource) -> None: + self._input_items = input_items + + self.list = to_streamed_response_wrapper( + input_items.list, + ) + + +class AsyncInputItemsResourceWithStreamingResponse: + def __init__(self, input_items: AsyncInputItemsResource) -> None: + self._input_items = input_items + + self.list = async_to_streamed_response_wrapper( + input_items.list, + ) diff --git a/src/llama_stack_client/resources/responses.py b/src/llama_stack_client/resources/responses/responses.py similarity index 73% rename from src/llama_stack_client/resources/responses.py rename to src/llama_stack_client/resources/responses/responses.py index bb7fcdc6..ba147335 100644 --- a/src/llama_stack_client/resources/responses.py +++ b/src/llama_stack_client/resources/responses/responses.py @@ -7,26 +7,39 @@ import httpx -from ..types import response_create_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from .._utils import required_args, maybe_transform, async_maybe_transform -from .._compat import cached_property -from .._resource import SyncAPIResource, AsyncAPIResource -from .._response import ( +from ...types import response_list_params, response_create_params +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import required_args, maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from .._streaming import Stream, AsyncStream -from .._base_client import make_request_options -from ..types.response_object import ResponseObject -from ..types.response_object_stream import ResponseObjectStream +from .input_items import ( + InputItemsResource, + AsyncInputItemsResource, + InputItemsResourceWithRawResponse, + AsyncInputItemsResourceWithRawResponse, + InputItemsResourceWithStreamingResponse, + AsyncInputItemsResourceWithStreamingResponse, +) +from ..._streaming import Stream, AsyncStream +from ..._base_client import make_request_options +from ...types.response_object import ResponseObject +from ...types.response_list_response import ResponseListResponse +from ...types.response_object_stream import ResponseObjectStream __all__ = ["ResponsesResource", "AsyncResponsesResource"] class ResponsesResource(SyncAPIResource): + @cached_property + def input_items(self) -> InputItemsResource: + return InputItemsResource(self._client) + @cached_property def with_raw_response(self) -> ResponsesResourceWithRawResponse: """ @@ -53,10 +66,12 @@ def create( input: Union[str, Iterable[response_create_params.InputUnionMember1]], model: str, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, stream: Literal[False] | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -95,9 +110,11 @@ def create( model: str, stream: Literal[True], instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -136,9 +153,11 @@ def create( model: str, stream: bool, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -176,10 +195,12 @@ def create( input: Union[str, Iterable[response_create_params.InputUnionMember1]], model: str, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, stream: Literal[False] | Literal[True] | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -195,10 +216,12 @@ def create( "input": input, "model": model, "instructions": instructions, + "max_infer_iters": max_infer_iters, "previous_response_id": previous_response_id, "store": store, "stream": stream, "temperature": temperature, + "text": text, "tools": tools, }, response_create_params.ResponseCreateParamsStreaming @@ -246,8 +269,66 @@ def retrieve( cast_to=ResponseObject, ) + def list( + self, + *, + after: str | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + model: str | NotGiven = NOT_GIVEN, + order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN, + # 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, + ) -> ResponseListResponse: + """ + List all OpenAI responses. + + Args: + after: The ID of the last response to return. + + limit: The number of responses to return. + + model: The model to filter responses by. + + order: The order to sort responses by when sorted by created_at ('asc' or 'desc'). + + 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._get( + "/v1/openai/v1/responses", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "after": after, + "limit": limit, + "model": model, + "order": order, + }, + response_list_params.ResponseListParams, + ), + ), + cast_to=ResponseListResponse, + ) + class AsyncResponsesResource(AsyncAPIResource): + @cached_property + def input_items(self) -> AsyncInputItemsResource: + return AsyncInputItemsResource(self._client) + @cached_property def with_raw_response(self) -> AsyncResponsesResourceWithRawResponse: """ @@ -274,10 +355,12 @@ async def create( input: Union[str, Iterable[response_create_params.InputUnionMember1]], model: str, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, stream: Literal[False] | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -316,9 +399,11 @@ async def create( model: str, stream: Literal[True], instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -357,9 +442,11 @@ async def create( model: str, stream: bool, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -397,10 +484,12 @@ async def create( input: Union[str, Iterable[response_create_params.InputUnionMember1]], model: str, instructions: str | NotGiven = NOT_GIVEN, + max_infer_iters: int | NotGiven = NOT_GIVEN, previous_response_id: str | NotGiven = NOT_GIVEN, store: bool | NotGiven = NOT_GIVEN, stream: Literal[False] | Literal[True] | NotGiven = NOT_GIVEN, temperature: float | NotGiven = NOT_GIVEN, + text: response_create_params.Text | NotGiven = NOT_GIVEN, tools: Iterable[response_create_params.Tool] | NotGiven = NOT_GIVEN, # 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. @@ -416,10 +505,12 @@ async def create( "input": input, "model": model, "instructions": instructions, + "max_infer_iters": max_infer_iters, "previous_response_id": previous_response_id, "store": store, "stream": stream, "temperature": temperature, + "text": text, "tools": tools, }, response_create_params.ResponseCreateParamsStreaming @@ -467,6 +558,60 @@ async def retrieve( cast_to=ResponseObject, ) + async def list( + self, + *, + after: str | NotGiven = NOT_GIVEN, + limit: int | NotGiven = NOT_GIVEN, + model: str | NotGiven = NOT_GIVEN, + order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN, + # 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, + ) -> ResponseListResponse: + """ + List all OpenAI responses. + + Args: + after: The ID of the last response to return. + + limit: The number of responses to return. + + model: The model to filter responses by. + + order: The order to sort responses by when sorted by created_at ('asc' or 'desc'). + + 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._get( + "/v1/openai/v1/responses", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "after": after, + "limit": limit, + "model": model, + "order": order, + }, + response_list_params.ResponseListParams, + ), + ), + cast_to=ResponseListResponse, + ) + class ResponsesResourceWithRawResponse: def __init__(self, responses: ResponsesResource) -> None: @@ -478,6 +623,13 @@ def __init__(self, responses: ResponsesResource) -> None: self.retrieve = to_raw_response_wrapper( responses.retrieve, ) + self.list = to_raw_response_wrapper( + responses.list, + ) + + @cached_property + def input_items(self) -> InputItemsResourceWithRawResponse: + return InputItemsResourceWithRawResponse(self._responses.input_items) class AsyncResponsesResourceWithRawResponse: @@ -490,6 +642,13 @@ def __init__(self, responses: AsyncResponsesResource) -> None: self.retrieve = async_to_raw_response_wrapper( responses.retrieve, ) + self.list = async_to_raw_response_wrapper( + responses.list, + ) + + @cached_property + def input_items(self) -> AsyncInputItemsResourceWithRawResponse: + return AsyncInputItemsResourceWithRawResponse(self._responses.input_items) class ResponsesResourceWithStreamingResponse: @@ -502,6 +661,13 @@ def __init__(self, responses: ResponsesResource) -> None: self.retrieve = to_streamed_response_wrapper( responses.retrieve, ) + self.list = to_streamed_response_wrapper( + responses.list, + ) + + @cached_property + def input_items(self) -> InputItemsResourceWithStreamingResponse: + return InputItemsResourceWithStreamingResponse(self._responses.input_items) class AsyncResponsesResourceWithStreamingResponse: @@ -514,3 +680,10 @@ def __init__(self, responses: AsyncResponsesResource) -> None: self.retrieve = async_to_streamed_response_wrapper( responses.retrieve, ) + self.list = async_to_streamed_response_wrapper( + responses.list, + ) + + @cached_property + def input_items(self) -> AsyncInputItemsResourceWithStreamingResponse: + return AsyncInputItemsResourceWithStreamingResponse(self._responses.input_items) diff --git a/src/llama_stack_client/resources/vector_io.py b/src/llama_stack_client/resources/vector_io.py index 7ec4691e..3d985e71 100644 --- a/src/llama_stack_client/resources/vector_io.py +++ b/src/llama_stack_client/resources/vector_io.py @@ -57,12 +57,17 @@ def insert( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> None: - """ - Insert chunks into a vector database. + """Insert chunks into a vector database. Args: chunks: The chunks to insert. + Each `Chunk` should contain content which can be + interleaved text, images, or other types. `metadata`: `dict[str, Any]` and + `embedding`: `List[float]` are optional. If `metadata` is provided, you + configure how Llama Stack formats the chunk during generation. If `embedding` is + not provided, it will be computed later. + vector_db_id: The identifier of the vector database to insert the chunks into. ttl_seconds: The time to live of the chunks. @@ -173,12 +178,17 @@ async def insert( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> None: - """ - Insert chunks into a vector database. + """Insert chunks into a vector database. Args: chunks: The chunks to insert. + Each `Chunk` should contain content which can be + interleaved text, images, or other types. `metadata`: `dict[str, Any]` and + `embedding`: `List[float]` are optional. If `metadata` is provided, you + configure how Llama Stack formats the chunk during generation. If `embedding` is + not provided, it will be computed later. + vector_db_id: The identifier of the vector database to insert the chunks into. ttl_seconds: The time to live of the chunks. diff --git a/src/llama_stack_client/types/__init__.py b/src/llama_stack_client/types/__init__.py index 815f95a1..c5788546 100644 --- a/src/llama_stack_client/types/__init__.py +++ b/src/llama_stack_client/types/__init__.py @@ -68,6 +68,7 @@ from .list_models_response import ListModelsResponse as ListModelsResponse from .list_routes_response import ListRoutesResponse as ListRoutesResponse from .query_spans_response import QuerySpansResponse as QuerySpansResponse +from .response_list_params import ResponseListParams as ResponseListParams from .scoring_score_params import ScoringScoreParams as ScoringScoreParams from .shield_list_response import ShieldListResponse as ShieldListResponse from .agent_create_response import AgentCreateResponse as AgentCreateResponse @@ -83,6 +84,7 @@ from .list_datasets_response import ListDatasetsResponse as ListDatasetsResponse from .provider_list_response import ProviderListResponse as ProviderListResponse from .response_create_params import ResponseCreateParams as ResponseCreateParams +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 diff --git a/src/llama_stack_client/types/query_chunks_response.py b/src/llama_stack_client/types/query_chunks_response.py index d90e464e..f668ecac 100644 --- a/src/llama_stack_client/types/query_chunks_response.py +++ b/src/llama_stack_client/types/query_chunks_response.py @@ -1,6 +1,6 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Dict, List, Union +from typing import Dict, List, Union, Optional from .._models import BaseModel from .shared.interleaved_content import InterleavedContent @@ -10,9 +10,18 @@ class Chunk(BaseModel): content: InterleavedContent - """A image content item""" + """ + The content of the chunk, which can be interleaved text, images, or other types. + """ metadata: Dict[str, Union[bool, float, str, List[object], object, None]] + """ + Metadata associated with the chunk, such as document ID, source, or other + relevant information. + """ + + embedding: Optional[List[float]] = None + """Optional embedding for the chunk. If not provided, it will be computed later.""" class QueryChunksResponse(BaseModel): diff --git a/src/llama_stack_client/types/response_create_params.py b/src/llama_stack_client/types/response_create_params.py index 53cb6b62..7c0a2539 100644 --- a/src/llama_stack_client/types/response_create_params.py +++ b/src/llama_stack_client/types/response_create_params.py @@ -16,6 +16,8 @@ "InputUnionMember1OpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", "InputUnionMember1OpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", "InputUnionMember1OpenAIResponseMessageContentUnionMember2", + "Text", + "TextFormat", "Tool", "ToolOpenAIResponseInputToolWebSearch", "ToolOpenAIResponseInputToolFileSearch", @@ -40,6 +42,8 @@ class ResponseCreateParamsBase(TypedDict, total=False): instructions: str + max_infer_iters: int + previous_response_id: str """ (Optional) if specified, the new response will be a continuation of the previous @@ -51,6 +55,8 @@ class ResponseCreateParamsBase(TypedDict, total=False): temperature: float + text: Text + tools: Iterable[Tool] @@ -63,18 +69,18 @@ class InputUnionMember1OpenAIResponseOutputMessageWebSearchToolCall(TypedDict, t class InputUnionMember1OpenAIResponseOutputMessageFunctionToolCall(TypedDict, total=False): - id: Required[str] - arguments: Required[str] call_id: Required[str] name: Required[str] - status: Required[str] - type: Required[Literal["function_call"]] + id: str + + status: str + class InputUnionMember1OpenAIResponseInputFunctionToolCallOutput(TypedDict, total=False): call_id: Required[str] @@ -144,6 +150,34 @@ class InputUnionMember1OpenAIResponseMessage(TypedDict, total=False): ] +class TextFormat(TypedDict, total=False): + type: Required[Literal["text", "json_schema", "json_object"]] + """Must be "text", "json_schema", or "json_object" to identify the format type""" + + description: str + """(Optional) A description of the response format. Only used for json_schema.""" + + name: str + """The name of the response format. Only used for json_schema.""" + + schema: Dict[str, Union[bool, float, str, Iterable[object], object, None]] + """The JSON schema the response should conform to. + + In a Python SDK, this is often a `pydantic` model. Only used for json_schema. + """ + + strict: bool + """(Optional) Whether to strictly enforce the JSON schema. + + If true, the response must match the schema exactly. Only used for json_schema. + """ + + +class Text(TypedDict, total=False): + format: TextFormat + """Configuration for Responses API text format.""" + + class ToolOpenAIResponseInputToolWebSearch(TypedDict, total=False): type: Required[Literal["web_search", "web_search_preview_2025_03_11"]] diff --git a/src/llama_stack_client/types/response_list_params.py b/src/llama_stack_client/types/response_list_params.py new file mode 100644 index 00000000..ca13adfa --- /dev/null +++ b/src/llama_stack_client/types/response_list_params.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, TypedDict + +__all__ = ["ResponseListParams"] + + +class ResponseListParams(TypedDict, total=False): + after: str + """The ID of the last response to return.""" + + limit: int + """The number of responses to return.""" + + model: str + """The model to filter responses by.""" + + order: Literal["asc", "desc"] + """The order to sort responses by when sorted by created_at ('asc' or 'desc').""" diff --git a/src/llama_stack_client/types/response_list_response.py b/src/llama_stack_client/types/response_list_response.py new file mode 100644 index 00000000..72c555be --- /dev/null +++ b/src/llama_stack_client/types/response_list_response.py @@ -0,0 +1,317 @@ +# 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, Annotated, TypeAlias + +from pydantic import Field as FieldInfo + +from .._utils import PropertyInfo +from .._models import BaseModel + +__all__ = [ + "ResponseListResponse", + "Data", + "DataInput", + "DataInputOpenAIResponseOutputMessageWebSearchToolCall", + "DataInputOpenAIResponseOutputMessageFunctionToolCall", + "DataInputOpenAIResponseInputFunctionToolCallOutput", + "DataInputOpenAIResponseMessage", + "DataInputOpenAIResponseMessageContentUnionMember1", + "DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", + "DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", + "DataInputOpenAIResponseMessageContentUnionMember2", + "DataOutput", + "DataOutputOpenAIResponseMessage", + "DataOutputOpenAIResponseMessageContentUnionMember1", + "DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", + "DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", + "DataOutputOpenAIResponseMessageContentUnionMember2", + "DataOutputOpenAIResponseOutputMessageWebSearchToolCall", + "DataOutputOpenAIResponseOutputMessageFunctionToolCall", + "DataOutputOpenAIResponseOutputMessageMcpCall", + "DataOutputOpenAIResponseOutputMessageMcpListTools", + "DataOutputOpenAIResponseOutputMessageMcpListToolsTool", + "DataText", + "DataTextFormat", + "DataError", +] + + +class DataInputOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): + id: str + + status: str + + type: Literal["web_search_call"] + + +class DataInputOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataInputOpenAIResponseInputFunctionToolCallOutput(BaseModel): + call_id: str + + output: str + + type: Literal["function_call_output"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText(BaseModel): + text: str + + type: Literal["input_text"] + + +class DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage(BaseModel): + detail: Literal["low", "high", "auto"] + + type: Literal["input_image"] + + image_url: Optional[str] = None + + +DataInputOpenAIResponseMessageContentUnionMember1: TypeAlias = Annotated[ + Union[ + DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText, + DataInputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage, + ], + PropertyInfo(discriminator="type"), +] + + +class DataInputOpenAIResponseMessageContentUnionMember2(BaseModel): + text: str + + type: Literal["output_text"] + + +class DataInputOpenAIResponseMessage(BaseModel): + content: Union[ + str, + List[DataInputOpenAIResponseMessageContentUnionMember1], + List[DataInputOpenAIResponseMessageContentUnionMember2], + ] + + role: Literal["system", "developer", "user", "assistant"] + + type: Literal["message"] + + id: Optional[str] = None + + status: Optional[str] = None + + +DataInput: TypeAlias = Union[ + DataInputOpenAIResponseOutputMessageWebSearchToolCall, + DataInputOpenAIResponseOutputMessageFunctionToolCall, + DataInputOpenAIResponseInputFunctionToolCallOutput, + DataInputOpenAIResponseMessage, +] + + +class DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText(BaseModel): + text: str + + type: Literal["input_text"] + + +class DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage(BaseModel): + detail: Literal["low", "high", "auto"] + + type: Literal["input_image"] + + image_url: Optional[str] = None + + +DataOutputOpenAIResponseMessageContentUnionMember1: TypeAlias = Annotated[ + Union[ + DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText, + DataOutputOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage, + ], + PropertyInfo(discriminator="type"), +] + + +class DataOutputOpenAIResponseMessageContentUnionMember2(BaseModel): + text: str + + type: Literal["output_text"] + + +class DataOutputOpenAIResponseMessage(BaseModel): + content: Union[ + str, + List[DataOutputOpenAIResponseMessageContentUnionMember1], + List[DataOutputOpenAIResponseMessageContentUnionMember2], + ] + + role: Literal["system", "developer", "user", "assistant"] + + type: Literal["message"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataOutputOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): + id: str + + status: str + + type: Literal["web_search_call"] + + +class DataOutputOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataOutputOpenAIResponseOutputMessageMcpCall(BaseModel): + id: str + + arguments: str + + name: str + + server_label: str + + type: Literal["mcp_call"] + + error: Optional[str] = None + + output: Optional[str] = None + + +class DataOutputOpenAIResponseOutputMessageMcpListToolsTool(BaseModel): + input_schema: Dict[str, Union[bool, float, str, List[object], object, None]] + + name: str + + description: Optional[str] = None + + +class DataOutputOpenAIResponseOutputMessageMcpListTools(BaseModel): + id: str + + server_label: str + + tools: List[DataOutputOpenAIResponseOutputMessageMcpListToolsTool] + + type: Literal["mcp_list_tools"] + + +DataOutput: TypeAlias = Annotated[ + Union[ + DataOutputOpenAIResponseMessage, + DataOutputOpenAIResponseOutputMessageWebSearchToolCall, + DataOutputOpenAIResponseOutputMessageFunctionToolCall, + DataOutputOpenAIResponseOutputMessageMcpCall, + DataOutputOpenAIResponseOutputMessageMcpListTools, + ], + PropertyInfo(discriminator="type"), +] + + +class DataTextFormat(BaseModel): + type: Literal["text", "json_schema", "json_object"] + """Must be "text", "json_schema", or "json_object" to identify the format type""" + + description: Optional[str] = None + """(Optional) A description of the response format. Only used for json_schema.""" + + name: Optional[str] = None + """The name of the response format. Only used for json_schema.""" + + schema_: Optional[Dict[str, Union[bool, float, str, List[object], object, None]]] = FieldInfo( + alias="schema", default=None + ) + """The JSON schema the response should conform to. + + In a Python SDK, this is often a `pydantic` model. Only used for json_schema. + """ + + strict: Optional[bool] = None + """(Optional) Whether to strictly enforce the JSON schema. + + If true, the response must match the schema exactly. Only used for json_schema. + """ + + +class DataText(BaseModel): + format: Optional[DataTextFormat] = None + """Configuration for Responses API text format.""" + + +class DataError(BaseModel): + code: str + + message: str + + +class Data(BaseModel): + id: str + + created_at: int + + input: List[DataInput] + + model: str + + object: Literal["response"] + + output: List[DataOutput] + + parallel_tool_calls: bool + + status: str + + text: DataText + + error: Optional[DataError] = None + + previous_response_id: Optional[str] = None + + temperature: Optional[float] = None + + top_p: Optional[float] = None + + truncation: Optional[str] = None + + user: Optional[str] = None + + +class ResponseListResponse(BaseModel): + data: List[Data] + + first_id: str + + has_more: bool + + last_id: str + + object: Literal["list"] diff --git a/src/llama_stack_client/types/response_object.py b/src/llama_stack_client/types/response_object.py index 207c58ff..4ce248b1 100644 --- a/src/llama_stack_client/types/response_object.py +++ b/src/llama_stack_client/types/response_object.py @@ -1,8 +1,10 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List, Union, Optional +from typing import Dict, List, Union, Optional from typing_extensions import Literal, Annotated, TypeAlias +from pydantic import Field as FieldInfo + from .._utils import PropertyInfo from .._models import BaseModel @@ -16,6 +18,11 @@ "OutputOpenAIResponseMessageContentUnionMember2", "OutputOpenAIResponseOutputMessageWebSearchToolCall", "OutputOpenAIResponseOutputMessageFunctionToolCall", + "OutputOpenAIResponseOutputMessageMcpCall", + "OutputOpenAIResponseOutputMessageMcpListTools", + "OutputOpenAIResponseOutputMessageMcpListToolsTool", + "Text", + "TextFormat", "Error", ] @@ -72,17 +79,51 @@ class OutputOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): class OutputOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class OutputOpenAIResponseOutputMessageMcpCall(BaseModel): id: str arguments: str - call_id: str + name: str + + server_label: str + + type: Literal["mcp_call"] + + error: Optional[str] = None + + output: Optional[str] = None + + +class OutputOpenAIResponseOutputMessageMcpListToolsTool(BaseModel): + input_schema: Dict[str, Union[bool, float, str, List[object], object, None]] name: str - status: str + description: Optional[str] = None - type: Literal["function_call"] + +class OutputOpenAIResponseOutputMessageMcpListTools(BaseModel): + id: str + + server_label: str + + tools: List[OutputOpenAIResponseOutputMessageMcpListToolsTool] + + type: Literal["mcp_list_tools"] Output: TypeAlias = Annotated[ @@ -90,11 +131,43 @@ class OutputOpenAIResponseOutputMessageFunctionToolCall(BaseModel): OutputOpenAIResponseMessage, OutputOpenAIResponseOutputMessageWebSearchToolCall, OutputOpenAIResponseOutputMessageFunctionToolCall, + OutputOpenAIResponseOutputMessageMcpCall, + OutputOpenAIResponseOutputMessageMcpListTools, ], PropertyInfo(discriminator="type"), ] +class TextFormat(BaseModel): + type: Literal["text", "json_schema", "json_object"] + """Must be "text", "json_schema", or "json_object" to identify the format type""" + + description: Optional[str] = None + """(Optional) A description of the response format. Only used for json_schema.""" + + name: Optional[str] = None + """The name of the response format. Only used for json_schema.""" + + schema_: Optional[Dict[str, Union[bool, float, str, List[object], object, None]]] = FieldInfo( + alias="schema", default=None + ) + """The JSON schema the response should conform to. + + In a Python SDK, this is often a `pydantic` model. Only used for json_schema. + """ + + strict: Optional[bool] = None + """(Optional) Whether to strictly enforce the JSON schema. + + If true, the response must match the schema exactly. Only used for json_schema. + """ + + +class Text(BaseModel): + format: Optional[TextFormat] = None + """Configuration for Responses API text format.""" + + class Error(BaseModel): code: str @@ -126,6 +199,8 @@ def output_text(self) -> str: status: str + text: Text + error: Optional[Error] = None previous_response_id: Optional[str] = None diff --git a/src/llama_stack_client/types/response_object_stream.py b/src/llama_stack_client/types/response_object_stream.py index 023b8f9d..ef140814 100644 --- a/src/llama_stack_client/types/response_object_stream.py +++ b/src/llama_stack_client/types/response_object_stream.py @@ -1,6 +1,6 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Union +from typing import Dict, List, Union, Optional from typing_extensions import Literal, Annotated, TypeAlias from .._utils import PropertyInfo @@ -10,6 +10,45 @@ __all__ = [ "ResponseObjectStream", "OpenAIResponseObjectStreamResponseCreated", + "OpenAIResponseObjectStreamResponseOutputItemAdded", + "OpenAIResponseObjectStreamResponseOutputItemAddedItem", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessage", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember2", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageWebSearchToolCall", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageFunctionToolCall", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpCall", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListTools", + "OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListToolsTool", + "OpenAIResponseObjectStreamResponseOutputItemDone", + "OpenAIResponseObjectStreamResponseOutputItemDoneItem", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessage", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember2", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageWebSearchToolCall", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageFunctionToolCall", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpCall", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListTools", + "OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListToolsTool", + "OpenAIResponseObjectStreamResponseOutputTextDelta", + "OpenAIResponseObjectStreamResponseOutputTextDone", + "OpenAIResponseObjectStreamResponseFunctionCallArgumentsDelta", + "OpenAIResponseObjectStreamResponseFunctionCallArgumentsDone", + "OpenAIResponseObjectStreamResponseWebSearchCallInProgress", + "OpenAIResponseObjectStreamResponseWebSearchCallSearching", + "OpenAIResponseObjectStreamResponseWebSearchCallCompleted", + "OpenAIResponseObjectStreamResponseMcpListToolsInProgress", + "OpenAIResponseObjectStreamResponseMcpListToolsFailed", + "OpenAIResponseObjectStreamResponseMcpListToolsCompleted", + "OpenAIResponseObjectStreamResponseMcpCallArgumentsDelta", + "OpenAIResponseObjectStreamResponseMcpCallArgumentsDone", + "OpenAIResponseObjectStreamResponseMcpCallInProgress", + "OpenAIResponseObjectStreamResponseMcpCallFailed", + "OpenAIResponseObjectStreamResponseMcpCallCompleted", "OpenAIResponseObjectStreamResponseCompleted", ] @@ -20,6 +59,420 @@ class OpenAIResponseObjectStreamResponseCreated(BaseModel): type: Literal["response.created"] +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText( + BaseModel +): + text: str + + type: Literal["input_text"] + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage( + BaseModel +): + detail: Literal["low", "high", "auto"] + + type: Literal["input_image"] + + image_url: Optional[str] = None + + +OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1: TypeAlias = Annotated[ + Union[ + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText, + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage, + ], + PropertyInfo(discriminator="type"), +] + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember2(BaseModel): + text: str + + type: Literal["output_text"] + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessage(BaseModel): + content: Union[ + str, + List[OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember1], + List[OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessageContentUnionMember2], + ] + + role: Literal["system", "developer", "user", "assistant"] + + type: Literal["message"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): + id: str + + status: str + + type: Literal["web_search_call"] + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpCall(BaseModel): + id: str + + arguments: str + + name: str + + server_label: str + + type: Literal["mcp_call"] + + error: Optional[str] = None + + output: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListToolsTool(BaseModel): + input_schema: Dict[str, Union[bool, float, str, List[object], object, None]] + + name: str + + description: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListTools(BaseModel): + id: str + + server_label: str + + tools: List[OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListToolsTool] + + type: Literal["mcp_list_tools"] + + +OpenAIResponseObjectStreamResponseOutputItemAddedItem: TypeAlias = Annotated[ + Union[ + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseMessage, + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageWebSearchToolCall, + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageFunctionToolCall, + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpCall, + OpenAIResponseObjectStreamResponseOutputItemAddedItemOpenAIResponseOutputMessageMcpListTools, + ], + PropertyInfo(discriminator="type"), +] + + +class OpenAIResponseObjectStreamResponseOutputItemAdded(BaseModel): + item: OpenAIResponseObjectStreamResponseOutputItemAddedItem + """Corresponds to the various Message types in the Responses API. + + They are all under one type because the Responses API gives them all the same + "type" value, and there is no way to tell them apart in certain scenarios. + """ + + output_index: int + + response_id: str + + sequence_number: int + + type: Literal["response.output_item.added"] + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText( + BaseModel +): + text: str + + type: Literal["input_text"] + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage( + BaseModel +): + detail: Literal["low", "high", "auto"] + + type: Literal["input_image"] + + image_url: Optional[str] = None + + +OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1: TypeAlias = Annotated[ + Union[ + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText, + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage, + ], + PropertyInfo(discriminator="type"), +] + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember2(BaseModel): + text: str + + type: Literal["output_text"] + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessage(BaseModel): + content: Union[ + str, + List[OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember1], + List[OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessageContentUnionMember2], + ] + + role: Literal["system", "developer", "user", "assistant"] + + type: Literal["message"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): + id: str + + status: str + + type: Literal["web_search_call"] + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpCall(BaseModel): + id: str + + arguments: str + + name: str + + server_label: str + + type: Literal["mcp_call"] + + error: Optional[str] = None + + output: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListToolsTool(BaseModel): + input_schema: Dict[str, Union[bool, float, str, List[object], object, None]] + + name: str + + description: Optional[str] = None + + +class OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListTools(BaseModel): + id: str + + server_label: str + + tools: List[OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListToolsTool] + + type: Literal["mcp_list_tools"] + + +OpenAIResponseObjectStreamResponseOutputItemDoneItem: TypeAlias = Annotated[ + Union[ + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseMessage, + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageWebSearchToolCall, + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageFunctionToolCall, + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpCall, + OpenAIResponseObjectStreamResponseOutputItemDoneItemOpenAIResponseOutputMessageMcpListTools, + ], + PropertyInfo(discriminator="type"), +] + + +class OpenAIResponseObjectStreamResponseOutputItemDone(BaseModel): + item: OpenAIResponseObjectStreamResponseOutputItemDoneItem + """Corresponds to the various Message types in the Responses API. + + They are all under one type because the Responses API gives them all the same + "type" value, and there is no way to tell them apart in certain scenarios. + """ + + output_index: int + + response_id: str + + sequence_number: int + + type: Literal["response.output_item.done"] + + +class OpenAIResponseObjectStreamResponseOutputTextDelta(BaseModel): + content_index: int + + delta: str + + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.output_text.delta"] + + +class OpenAIResponseObjectStreamResponseOutputTextDone(BaseModel): + content_index: int + + item_id: str + + output_index: int + + sequence_number: int + + text: str + + type: Literal["response.output_text.done"] + + +class OpenAIResponseObjectStreamResponseFunctionCallArgumentsDelta(BaseModel): + delta: str + + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.function_call_arguments.delta"] + + +class OpenAIResponseObjectStreamResponseFunctionCallArgumentsDone(BaseModel): + arguments: str + + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.function_call_arguments.done"] + + +class OpenAIResponseObjectStreamResponseWebSearchCallInProgress(BaseModel): + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.web_search_call.in_progress"] + + +class OpenAIResponseObjectStreamResponseWebSearchCallSearching(BaseModel): + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.web_search_call.searching"] + + +class OpenAIResponseObjectStreamResponseWebSearchCallCompleted(BaseModel): + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.web_search_call.completed"] + + +class OpenAIResponseObjectStreamResponseMcpListToolsInProgress(BaseModel): + sequence_number: int + + type: Literal["response.mcp_list_tools.in_progress"] + + +class OpenAIResponseObjectStreamResponseMcpListToolsFailed(BaseModel): + sequence_number: int + + type: Literal["response.mcp_list_tools.failed"] + + +class OpenAIResponseObjectStreamResponseMcpListToolsCompleted(BaseModel): + sequence_number: int + + type: Literal["response.mcp_list_tools.completed"] + + +class OpenAIResponseObjectStreamResponseMcpCallArgumentsDelta(BaseModel): + delta: str + + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.mcp_call.arguments.delta"] + + +class OpenAIResponseObjectStreamResponseMcpCallArgumentsDone(BaseModel): + arguments: str + + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.mcp_call.arguments.done"] + + +class OpenAIResponseObjectStreamResponseMcpCallInProgress(BaseModel): + item_id: str + + output_index: int + + sequence_number: int + + type: Literal["response.mcp_call.in_progress"] + + +class OpenAIResponseObjectStreamResponseMcpCallFailed(BaseModel): + sequence_number: int + + type: Literal["response.mcp_call.failed"] + + +class OpenAIResponseObjectStreamResponseMcpCallCompleted(BaseModel): + sequence_number: int + + type: Literal["response.mcp_call.completed"] + + class OpenAIResponseObjectStreamResponseCompleted(BaseModel): response: ResponseObject @@ -27,6 +480,26 @@ class OpenAIResponseObjectStreamResponseCompleted(BaseModel): ResponseObjectStream: TypeAlias = Annotated[ - Union[OpenAIResponseObjectStreamResponseCreated, OpenAIResponseObjectStreamResponseCompleted], + Union[ + OpenAIResponseObjectStreamResponseCreated, + OpenAIResponseObjectStreamResponseOutputItemAdded, + OpenAIResponseObjectStreamResponseOutputItemDone, + OpenAIResponseObjectStreamResponseOutputTextDelta, + OpenAIResponseObjectStreamResponseOutputTextDone, + OpenAIResponseObjectStreamResponseFunctionCallArgumentsDelta, + OpenAIResponseObjectStreamResponseFunctionCallArgumentsDone, + OpenAIResponseObjectStreamResponseWebSearchCallInProgress, + OpenAIResponseObjectStreamResponseWebSearchCallSearching, + OpenAIResponseObjectStreamResponseWebSearchCallCompleted, + OpenAIResponseObjectStreamResponseMcpListToolsInProgress, + OpenAIResponseObjectStreamResponseMcpListToolsFailed, + OpenAIResponseObjectStreamResponseMcpListToolsCompleted, + OpenAIResponseObjectStreamResponseMcpCallArgumentsDelta, + OpenAIResponseObjectStreamResponseMcpCallArgumentsDone, + OpenAIResponseObjectStreamResponseMcpCallInProgress, + OpenAIResponseObjectStreamResponseMcpCallFailed, + OpenAIResponseObjectStreamResponseMcpCallCompleted, + OpenAIResponseObjectStreamResponseCompleted, + ], PropertyInfo(discriminator="type"), ] diff --git a/src/llama_stack_client/types/responses/__init__.py b/src/llama_stack_client/types/responses/__init__.py new file mode 100644 index 00000000..cb934712 --- /dev/null +++ b/src/llama_stack_client/types/responses/__init__.py @@ -0,0 +1,6 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .input_item_list_params import InputItemListParams as InputItemListParams +from .input_item_list_response import InputItemListResponse as InputItemListResponse diff --git a/src/llama_stack_client/types/responses/input_item_list_params.py b/src/llama_stack_client/types/responses/input_item_list_params.py new file mode 100644 index 00000000..a78bd215 --- /dev/null +++ b/src/llama_stack_client/types/responses/input_item_list_params.py @@ -0,0 +1,28 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["InputItemListParams"] + + +class InputItemListParams(TypedDict, total=False): + after: str + """An item ID to list items after, used for pagination.""" + + before: str + """An item ID to list items before, used for pagination.""" + + include: List[str] + """Additional fields to include in the response.""" + + limit: int + """A limit on the number of objects to be returned. + + Limit can range between 1 and 100, and the default is 20. + """ + + order: Literal["asc", "desc"] + """The order to return the input items in. Default is desc.""" diff --git a/src/llama_stack_client/types/responses/input_item_list_response.py b/src/llama_stack_client/types/responses/input_item_list_response.py new file mode 100644 index 00000000..1d8f5a76 --- /dev/null +++ b/src/llama_stack_client/types/responses/input_item_list_response.py @@ -0,0 +1,111 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Union, Optional +from typing_extensions import Literal, Annotated, TypeAlias + +from ..._utils import PropertyInfo +from ..._models import BaseModel + +__all__ = [ + "InputItemListResponse", + "Data", + "DataOpenAIResponseOutputMessageWebSearchToolCall", + "DataOpenAIResponseOutputMessageFunctionToolCall", + "DataOpenAIResponseInputFunctionToolCallOutput", + "DataOpenAIResponseMessage", + "DataOpenAIResponseMessageContentUnionMember1", + "DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText", + "DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage", + "DataOpenAIResponseMessageContentUnionMember2", +] + + +class DataOpenAIResponseOutputMessageWebSearchToolCall(BaseModel): + id: str + + status: str + + type: Literal["web_search_call"] + + +class DataOpenAIResponseOutputMessageFunctionToolCall(BaseModel): + arguments: str + + call_id: str + + name: str + + type: Literal["function_call"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataOpenAIResponseInputFunctionToolCallOutput(BaseModel): + call_id: str + + output: str + + type: Literal["function_call_output"] + + id: Optional[str] = None + + status: Optional[str] = None + + +class DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText(BaseModel): + text: str + + type: Literal["input_text"] + + +class DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage(BaseModel): + detail: Literal["low", "high", "auto"] + + type: Literal["input_image"] + + image_url: Optional[str] = None + + +DataOpenAIResponseMessageContentUnionMember1: TypeAlias = Annotated[ + Union[ + DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentText, + DataOpenAIResponseMessageContentUnionMember1OpenAIResponseInputMessageContentImage, + ], + PropertyInfo(discriminator="type"), +] + + +class DataOpenAIResponseMessageContentUnionMember2(BaseModel): + text: str + + type: Literal["output_text"] + + +class DataOpenAIResponseMessage(BaseModel): + content: Union[ + str, List[DataOpenAIResponseMessageContentUnionMember1], List[DataOpenAIResponseMessageContentUnionMember2] + ] + + role: Literal["system", "developer", "user", "assistant"] + + type: Literal["message"] + + id: Optional[str] = None + + status: Optional[str] = None + + +Data: TypeAlias = Union[ + DataOpenAIResponseOutputMessageWebSearchToolCall, + DataOpenAIResponseOutputMessageFunctionToolCall, + DataOpenAIResponseInputFunctionToolCallOutput, + DataOpenAIResponseMessage, +] + + +class InputItemListResponse(BaseModel): + data: List[Data] + + object: Literal["list"] diff --git a/src/llama_stack_client/types/tool.py b/src/llama_stack_client/types/tool.py index 59e9300f..6beb8764 100644 --- a/src/llama_stack_client/types/tool.py +++ b/src/llama_stack_client/types/tool.py @@ -29,8 +29,6 @@ class Tool(BaseModel): provider_id: str - tool_host: Literal["distribution", "client", "model_context_protocol"] - toolgroup_id: str type: Literal["tool"] diff --git a/src/llama_stack_client/types/vector_io_insert_params.py b/src/llama_stack_client/types/vector_io_insert_params.py index adc1642e..2dded485 100644 --- a/src/llama_stack_client/types/vector_io_insert_params.py +++ b/src/llama_stack_client/types/vector_io_insert_params.py @@ -12,7 +12,14 @@ class VectorIoInsertParams(TypedDict, total=False): chunks: Required[Iterable[Chunk]] - """The chunks to insert.""" + """The chunks to insert. + + Each `Chunk` should contain content which can be interleaved text, images, or + other types. `metadata`: `dict[str, Any]` and `embedding`: `List[float]` are + optional. If `metadata` is provided, you configure how Llama Stack formats the + chunk during generation. If `embedding` is not provided, it will be computed + later. + """ vector_db_id: Required[str] """The identifier of the vector database to insert the chunks into.""" @@ -23,6 +30,15 @@ class VectorIoInsertParams(TypedDict, total=False): class Chunk(TypedDict, total=False): content: Required[InterleavedContent] - """A image content item""" + """ + The content of the chunk, which can be interleaved text, images, or other types. + """ metadata: Required[Dict[str, Union[bool, float, str, Iterable[object], object, None]]] + """ + Metadata associated with the chunk, such as document ID, source, or other + relevant information. + """ + + embedding: Iterable[float] + """Optional embedding for the chunk. If not provided, it will be computed later.""" diff --git a/tests/api_resources/responses/__init__.py b/tests/api_resources/responses/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/responses/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/responses/test_input_items.py b/tests/api_resources/responses/test_input_items.py new file mode 100644 index 00000000..c1b25556 --- /dev/null +++ b/tests/api_resources/responses/test_input_items.py @@ -0,0 +1,122 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient +from llama_stack_client.types.responses import InputItemListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestInputItems: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_list(self, client: LlamaStackClient) -> None: + input_item = client.responses.input_items.list( + response_id="response_id", + ) + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + def test_method_list_with_all_params(self, client: LlamaStackClient) -> None: + input_item = client.responses.input_items.list( + response_id="response_id", + after="after", + before="before", + include=["string"], + limit=0, + order="asc", + ) + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: LlamaStackClient) -> None: + response = client.responses.input_items.with_raw_response.list( + response_id="response_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + input_item = response.parse() + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: LlamaStackClient) -> None: + with client.responses.input_items.with_streaming_response.list( + response_id="response_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + input_item = response.parse() + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_list(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"): + client.responses.input_items.with_raw_response.list( + response_id="", + ) + + +class TestAsyncInputItems: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_list(self, async_client: AsyncLlamaStackClient) -> None: + input_item = await async_client.responses.input_items.list( + response_id="response_id", + ) + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + input_item = await async_client.responses.input_items.list( + response_id="response_id", + after="after", + before="before", + include=["string"], + limit=0, + order="asc", + ) + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.responses.input_items.with_raw_response.list( + response_id="response_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + input_item = await response.parse() + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.responses.input_items.with_streaming_response.list( + response_id="response_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + input_item = await response.parse() + assert_matches_type(InputItemListResponse, input_item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_list(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"): + await async_client.responses.input_items.with_raw_response.list( + response_id="", + ) diff --git a/tests/api_resources/test_responses.py b/tests/api_resources/test_responses.py index 74e13e8d..e3343d3e 100644 --- a/tests/api_resources/test_responses.py +++ b/tests/api_resources/test_responses.py @@ -9,7 +9,7 @@ from tests.utils import assert_matches_type from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient -from llama_stack_client.types import ResponseObject +from llama_stack_client.types import ResponseObject, ResponseListResponse base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -31,10 +31,20 @@ def test_method_create_with_all_params_overload_1(self, client: LlamaStackClient input="string", model="model", instructions="instructions", + max_infer_iters=0, previous_response_id="previous_response_id", store=True, stream=False, temperature=0, + text={ + "format": { + "type": "text", + "description": "description", + "name": "name", + "schema": {"foo": True}, + "strict": True, + } + }, tools=[ { "type": "web_search", @@ -86,9 +96,19 @@ def test_method_create_with_all_params_overload_2(self, client: LlamaStackClient model="model", stream=True, instructions="instructions", + max_infer_iters=0, previous_response_id="previous_response_id", store=True, temperature=0, + text={ + "format": { + "type": "text", + "description": "description", + "name": "name", + "schema": {"foo": True}, + "strict": True, + } + }, tools=[ { "type": "web_search", @@ -163,6 +183,41 @@ def test_path_params_retrieve(self, client: LlamaStackClient) -> None: "", ) + @parametrize + def test_method_list(self, client: LlamaStackClient) -> None: + response = client.responses.list() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + def test_method_list_with_all_params(self, client: LlamaStackClient) -> None: + response = client.responses.list( + after="after", + limit=0, + model="model", + order="asc", + ) + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: LlamaStackClient) -> None: + http_response = client.responses.with_raw_response.list() + + assert http_response.is_closed is True + assert http_response.http_request.headers.get("X-Stainless-Lang") == "python" + response = http_response.parse() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: LlamaStackClient) -> None: + with client.responses.with_streaming_response.list() as http_response: + assert not http_response.is_closed + assert http_response.http_request.headers.get("X-Stainless-Lang") == "python" + + response = http_response.parse() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + assert cast(Any, http_response.is_closed) is True + class TestAsyncResponses: parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) @@ -181,10 +236,20 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn input="string", model="model", instructions="instructions", + max_infer_iters=0, previous_response_id="previous_response_id", store=True, stream=False, temperature=0, + text={ + "format": { + "type": "text", + "description": "description", + "name": "name", + "schema": {"foo": True}, + "strict": True, + } + }, tools=[ { "type": "web_search", @@ -236,9 +301,19 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn model="model", stream=True, instructions="instructions", + max_infer_iters=0, previous_response_id="previous_response_id", store=True, temperature=0, + text={ + "format": { + "type": "text", + "description": "description", + "name": "name", + "schema": {"foo": True}, + "strict": True, + } + }, tools=[ { "type": "web_search", @@ -312,3 +387,38 @@ async def test_path_params_retrieve(self, async_client: AsyncLlamaStackClient) - await async_client.responses.with_raw_response.retrieve( "", ) + + @parametrize + async def test_method_list(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.responses.list() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.responses.list( + after="after", + limit=0, + model="model", + order="asc", + ) + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncLlamaStackClient) -> None: + http_response = await async_client.responses.with_raw_response.list() + + assert http_response.is_closed is True + assert http_response.http_request.headers.get("X-Stainless-Lang") == "python" + response = await http_response.parse() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.responses.with_streaming_response.list() as http_response: + assert not http_response.is_closed + assert http_response.http_request.headers.get("X-Stainless-Lang") == "python" + + response = await http_response.parse() + assert_matches_type(ResponseListResponse, response, path=["response"]) + + assert cast(Any, http_response.is_closed) is True diff --git a/tests/api_resources/test_vector_io.py b/tests/api_resources/test_vector_io.py index 6e1cd5e0..dada826d 100644 --- a/tests/api_resources/test_vector_io.py +++ b/tests/api_resources/test_vector_io.py @@ -37,6 +37,7 @@ def test_method_insert_with_all_params(self, client: LlamaStackClient) -> None: { "content": "string", "metadata": {"foo": True}, + "embedding": [0], } ], vector_db_id="vector_db_id", @@ -147,6 +148,7 @@ async def test_method_insert_with_all_params(self, async_client: AsyncLlamaStack { "content": "string", "metadata": {"foo": True}, + "embedding": [0], } ], vector_db_id="vector_db_id", diff --git a/tests/test_client.py b/tests/test_client.py index 7ad6e189..b3d169b0 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -836,6 +836,33 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: assert response.http_request.headers.get("x-stainless-retry-count") == "42" + @pytest.mark.respx(base_url=base_url) + def test_follow_redirects(self, respx_mock: MockRouter) -> None: + # Test that the default follow_redirects=True allows following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) + + response = self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + + @pytest.mark.respx(base_url=base_url) + def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + # Test that follow_redirects=False prevents following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + + with pytest.raises(APIStatusError) as exc_info: + self.client.post( + "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response + ) + + assert exc_info.value.response.status_code == 302 + assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected" + class TestAsyncLlamaStackClient: client = AsyncLlamaStackClient(base_url=base_url, _strict_response_validation=True) @@ -1674,3 +1701,30 @@ async def test_main() -> None: raise AssertionError("calling get_platform using asyncify resulted in a hung process") time.sleep(0.1) + + @pytest.mark.respx(base_url=base_url) + async def test_follow_redirects(self, respx_mock: MockRouter) -> None: + # Test that the default follow_redirects=True allows following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"})) + + response = await self.client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response) + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + + @pytest.mark.respx(base_url=base_url) + async def test_follow_redirects_disabled(self, respx_mock: MockRouter) -> None: + # Test that follow_redirects=False prevents following redirects + respx_mock.post("/redirect").mock( + return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"}) + ) + + with pytest.raises(APIStatusError) as exc_info: + await self.client.post( + "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response + ) + + assert exc_info.value.response.status_code == 302 + assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected"