airia 0.1.23__py3-none-any.whl → 0.1.24__py3-none-any.whl

airia/client/pipeline_execution/base_pipeline_execution.py

@@ -112,3 +112,112 @@ class BasePipelineExecution:
         )
 
         return request_data
+
+    def _pre_execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {},
+        async_output: bool = False,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ):
+        """
+        Prepare request data for temporary assistant execution endpoint.
+
+        This internal method constructs the URL and payload for temporary assistant execution
+        requests, validating parameters and preparing all request components.
+
+        Args:
+            model_parameters: model parameters
+            user_input: Optional user input text
+            assistant_name: Name of the temporary assistant
+            prompt_parameters: Parameters for prompt configuration (required)
+            async_output: Whether to stream the response. Default is False
+            include_tools_response: Whether to return initial LLM tool result. Default is False
+            save_history: Whether to save input and output to conversation history. Default is True
+            voice_enabled: Whether voice output is enabled. Default is False
+            debug: Whether debug mode execution is enabled. Default is False
+            additional_info: Optional additional information array
+            conversation_id: Optional conversation identifier (GUID string or UUID)
+            current_date_time: Optional current date and time in ISO format
+            data_source_files: Optional dictionary mapping data source GUIDs to file GUID arrays
+            data_source_folders: Optional dictionary mapping data source GUIDs to folder GUID arrays
+            data_store_parameters: Optional DataStore parameters
+            external_user_id: Optional external user identifier
+            files: Optional list of file identifiers
+            images: Optional list of image identifiers
+            in_memory_messages: Optional list of in-memory messages
+            output_configuration: Optional output configuration
+            prompt_variables: Optional prompt variables dictionary
+            user_id: Optional user identifier (GUID string or UUID)
+            user_input_id: Optional unique identifier for user input (GUID string or UUID)
+            variables: Optional variables dictionary
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            RequestData: Prepared request data for the temporary assistant execution endpoint
+
+        Raises:
+            ValueError: If required parameters are missing or invalid
+        """
+        # Prepare the request URL
+        url = urljoin(
+            self._request_handler.base_url,
+            f"{ApiVersion.V2.value}/PipelineExecution/TemporaryAssistant",
+        )
+
+        # Create the request payload
+        payload = {
+            "additionalInfo": additional_info,
+            "assistantName": assistant_name,
+            "asyncOutput": async_output,
+            "conversationId": conversation_id,
+            "currentDateTime": current_date_time,
+            "dataSourceFiles": data_source_files,
+            "dataSourceFolders": data_source_folders,
+            "dataStoreParameters": data_store_parameters,
+            "debug": debug,
+            "externalUserId": external_user_id,
+            "files": files,
+            "images": images,
+            "includeToolsResponse": include_tools_response,
+            "inMemoryMessages": in_memory_messages,
+            "modelParameters": model_parameters,
+            "outputConfiguration": output_configuration,
+            "promptParameters": prompt_parameters,
+            "promptVariables": prompt_variables,
+            "saveHistory": save_history,
+            "userId": user_id,
+            "userInput": user_input,
+            "userInputId": user_input_id,
+            "variables": variables,
+            "voiceEnabled": voice_enabled,
+        }
+
+        request_data = self._request_handler.prepare_request(
+            url=url,
+            payload=payload,
+            correlation_id=correlation_id,
+        )
+
+        return request_data

airia/client/pipeline_execution/sync_pipeline_execution.py

@@ -2,9 +2,10 @@ from typing import Any, Dict, List, Literal, Optional, Union, overload
 
 from ...types._api_version import ApiVersion
 from ...types.api.pipeline_execution import (
-    PipelineExecutionDebugResponse,
     PipelineExecutionResponse,
     PipelineExecutionStreamedResponse,
+    TemporaryAssistantResponse,
+    TemporaryAssistantStreamedResponse,
 )
 from .._request_handler import RequestHandler
 from .base_pipeline_execution import BasePipelineExecution
@@ -64,7 +65,7 @@ class PipelineExecution(BasePipelineExecution):
         self,
         pipeline_id: str,
         user_input: str,
-        debug: Literal[False] = False,
+        debug: bool = False,
         user_id: Optional[str] = None,
         conversation_id: Optional[str] = None,
         async_output: Literal[False] = False,
@@ -82,29 +83,6 @@ class PipelineExecution(BasePipelineExecution):
         correlation_id: Optional[str] = None,
     ) -> PipelineExecutionResponse: ...
 
-    @overload
-    def execute_pipeline(
-        self,
-        pipeline_id: str,
-        user_input: str,
-        debug: Literal[True] = True,
-        user_id: Optional[str] = None,
-        conversation_id: Optional[str] = None,
-        async_output: Literal[False] = False,
-        include_tools_response: bool = False,
-        images: Optional[List[str]] = None,
-        files: Optional[List[str]] = None,
-        data_source_folders: Optional[Dict[str, Any]] = None,
-        data_source_files: Optional[Dict[str, Any]] = None,
-        in_memory_messages: Optional[List[Dict[str, str]]] = None,
-        current_date_time: Optional[str] = None,
-        save_history: bool = True,
-        additional_info: Optional[List[Any]] = None,
-        prompt_variables: Optional[Dict[str, Any]] = None,
-        voice_enabled: bool = False,
-        correlation_id: Optional[str] = None,
-    ) -> PipelineExecutionDebugResponse: ...
-
     @overload
     def execute_pipeline(
         self,
@@ -148,11 +126,7 @@ class PipelineExecution(BasePipelineExecution):
         prompt_variables: Optional[Dict[str, Any]] = None,
         voice_enabled: bool = False,
         correlation_id: Optional[str] = None,
-    ) -> Union[
-        PipelineExecutionDebugResponse,
-        PipelineExecutionResponse,
-        PipelineExecutionStreamedResponse,
-    ]:
+    ) -> Union[PipelineExecutionResponse, PipelineExecutionStreamedResponse]:
         """
         Execute a pipeline with the provided input.
 
@@ -233,8 +207,213 @@ class PipelineExecution(BasePipelineExecution):
         )
 
         if not async_output:
-            if not debug:
-                return PipelineExecutionResponse(**resp)
-            return PipelineExecutionDebugResponse(**resp)
+            return PipelineExecutionResponse(**resp)
 
         return PipelineExecutionStreamedResponse(stream=resp)
+
+    @overload
+    def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: Literal[False] = False,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> TemporaryAssistantResponse: ...
+
+    @overload
+    def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: Literal[True] = True,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> TemporaryAssistantStreamedResponse: ...
+
+    def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: bool = False,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> Union[
+        TemporaryAssistantResponse,
+        TemporaryAssistantStreamedResponse,
+    ]:
+        """
+        Execute a temporary assistant with the provided parameters.
+
+        This method creates and executes a temporary AI assistant with custom configuration,
+        allowing for flexible assistant behavior without creating a persistent pipeline.
+
+        Args:
+            model_parameters: Model parameters (required). Must include libraryModelId,
+                            projectModelId, modelIdentifierType, and modelIsAvailableinProject
+            user_input: User input text (required)
+            assistant_name: Name of the temporary assistant. Default is ""
+            prompt_parameters: Parameters for prompt configuration. Default is {"prompt": ""}
+            async_output: Whether to stream the response. Default is False
+            include_tools_response: Whether to return initial LLM tool result. Default is False
+            save_history: Whether to save input and output to conversation history. Default is True
+            voice_enabled: Whether voice output is enabled. Default is False
+            debug: Whether debug mode execution is enabled. Default is False
+            additional_info: Optional additional information array
+            conversation_id: Optional conversation identifier (GUID string or UUID)
+            current_date_time: Optional current date and time in ISO format
+            data_source_files: Optional dictionary mapping data source GUIDs to file GUID arrays
+            data_source_folders: Optional dictionary mapping data source GUIDs to folder GUID arrays
+            data_store_parameters: Optional DataStore parameters
+            external_user_id: Optional external user identifier
+            files: Optional list of file identifiers
+            images: Optional list of image identifiers
+            in_memory_messages: Optional list of in-memory messages
+            output_configuration: Optional output configuration
+            prompt_variables: Optional prompt variables dictionary
+            user_id: Optional user identifier (GUID string or UUID)
+            user_input_id: Optional unique identifier for user input (GUID string or UUID)
+            variables: Optional variables dictionary
+            correlation_id: Optional correlation ID for request tracing. If not provided,
+                          one will be generated automatically.
+
+        Returns:
+            Response containing the result of the temporary assistant execution.
+
+        Raises:
+            AiriaAPIError: If the API request fails with details about the error.
+            requests.RequestException: For other request-related errors.
+            ValueError: If required parameters are missing or invalid.
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your_api_key")
+            response = client.pipeline_execution.execute_temporary_assistant(
+                model_parameters={
+                    "libraryModelId": "library-model-id",
+                    "projectModelId": None,
+                    "modelIdentifierType": "Library",
+                    "modelIsAvailableinProject": True,
+                },
+                user_input="say double bubble bath ten times fast",
+            )
+            print(response.result)
+            ```
+        """
+        # Validate required parameters
+        if not user_input:
+            raise ValueError("user_input cannot be empty")
+
+        if not model_parameters:
+            raise ValueError("model_parameters cannot be empty")
+
+        # Handle file and image uploads (local files are uploaded, URLs are passed through)
+        image_urls = None
+        file_urls = None
+
+        if images or files:
+            file_urls, image_urls = self._upload_files(files or [], images or [])
+
+        # Convert UUID objects to strings for API compatibility
+        conversation_id_str = str(conversation_id) if conversation_id else conversation_id
+        user_id_str = str(user_id) if user_id else user_id
+        user_input_id_str = str(user_input_id) if user_input_id else user_input_id
+
+        request_data = self._pre_execute_temporary_assistant(
+            model_parameters=model_parameters,
+            user_input=user_input,
+            assistant_name=assistant_name,
+            prompt_parameters=prompt_parameters,
+            async_output=async_output,
+            include_tools_response=include_tools_response,
+            save_history=save_history,
+            voice_enabled=voice_enabled,
+            debug=debug,
+            additional_info=additional_info,
+            conversation_id=conversation_id_str,
+            current_date_time=current_date_time,
+            data_source_files=data_source_files,
+            data_source_folders=data_source_folders,
+            data_store_parameters=data_store_parameters,
+            external_user_id=external_user_id,
+            files=file_urls,
+            images=image_urls,
+            in_memory_messages=in_memory_messages,
+            output_configuration=output_configuration,
+            prompt_variables=prompt_variables,
+            user_id=user_id_str,
+            user_input_id=user_input_id_str,
+            variables=variables,
+            correlation_id=correlation_id,
+        )
+
+        resp = (
+            self._request_handler.make_request_stream("POST", request_data)
+            if async_output
+            else self._request_handler.make_request("POST", request_data)
+        )
+
+        if async_output:
+            return TemporaryAssistantStreamedResponse(stream=resp)
+
+        return TemporaryAssistantResponse(**resp)

airia/client/sync_client.py

@@ -14,6 +14,7 @@ from .base_client import AiriaBaseClient
 from .conversations import Conversations
 from .data_vector_search import DataVectorSearch
 from .deployments import Deployments
+from .library import Library
 from .pipeline_execution import PipelineExecution
 from .pipelines_config import PipelinesConfig
 from .project import Project
@@ -68,6 +69,7 @@ class AiriaClient(AiriaBaseClient):
         self.store = Store(self._request_handler)
         self.deployments = Deployments(self._request_handler)
         self.data_vector_search = DataVectorSearch(self._request_handler)
+        self.library = Library(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/types/api/library/__init__.py

@@ -0,0 +1,11 @@
+from ._library_models import (
+    GetLibraryModelsResponse,
+    LibraryModel,
+    TokenPriceConversion,
+)
+
+__all__ = [
+    "GetLibraryModelsResponse",
+    "LibraryModel",
+    "TokenPriceConversion",
+]

airia/types/api/library/_library_models.py

@@ -0,0 +1,208 @@
+from datetime import datetime
+from typing import List, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class TokenPriceConversion(BaseModel):
+    """
+    Common conversion values for token prices.
+
+    Attributes:
+        input_token_price_1k: Cost per 1,000 input tokens in USD. Pre-calculated for convenience when comparing pricing across models.
+        output_token_price_1k: Cost per 1,000 output tokens in USD. Pre-calculated for convenience when comparing pricing across models.
+        input_token_price_1m: Cost per 1 million input tokens in USD. Useful for large-scale usage estimation and enterprise planning.
+        output_token_price_1m: Cost per 1 million output tokens in USD. Useful for large-scale usage estimation and enterprise planning.
+    """
+
+    input_token_price_1k: Optional[str] = Field(
+        None, alias="inputTokenPrice1K", description="Gets or sets the input token cost."
+    )
+    output_token_price_1k: Optional[str] = Field(
+        None,
+        alias="outputTokenPrice1K",
+        description="Gets or sets the output token cost.",
+    )
+    input_token_price_1m: Optional[str] = Field(
+        None,
+        alias="inputTokenPrice1M",
+        description="Gets or sets the input token cost per million tokens.",
+    )
+    output_token_price_1m: Optional[str] = Field(
+        None,
+        alias="outputTokenPrice1M",
+        description="Gets or sets the output token cost per million tokens.",
+    )
+
+
+class LibraryModel(BaseModel):
+    """
+    Models response for the library.
+
+    Attributes:
+        credentials_id: UUID of the required credentials to use this model. None if no specific credentials needed.
+        id: Unique identifier for the library model. Used in API calls to specify which model to use.
+        category: Model category (e.g., "Multimodal", "NLP", "ComputerVision"). Helps classify model capabilities.
+        description: Detailed description of the model's purpose, capabilities, and use cases.
+        downloads: Number of times this model has been downloaded. Indicates popularity and usage.
+        type: Input type the model accepts (e.g., "text", "image", "audio", "video").
+        languages: List of languages the model supports. Important for international applications.
+        license_type: License under which the model is distributed (e.g., "MIT", "Apache20", "Commercial").
+        name: Internal name of the model. Used for identification and API references.
+        display_name: Human-readable name for display in UIs. More user-friendly than internal name.
+        price: General pricing information as a string. May include currency and billing details.
+        input_token_price: Cost per input token. Used for precise cost calculation.
+        output_token_price: Cost per output token. Used for precise cost calculation.
+        price_type: Type of pricing model (e.g., "AITextOutputModelPrice", "AIImageOutputModelPrice").
+        prompt_id: UUID of associated prompt template if applicable.
+        url: URL to model documentation, homepage, or additional information.
+        provider: Company or organization that provides the model (e.g., "OpenAI", "Anthropic", "Google").
+        rating: Average user rating of the model (typically 1-5 scale). Indicates user satisfaction.
+        tags: List of descriptive tags for categorization and search. Helps discovery and filtering.
+        available: Whether the model is currently available for use. False if deprecated or temporarily unavailable.
+        token_price_conversion: Pre-calculated pricing conversions for different token quantities.
+        allow_airia_credentials: Whether the model can be used with Airia-managed credentials.
+        allow_byok_credentials: Whether the model supports Bring Your Own Key (BYOK) credentials.
+        author: Person or organization who created or maintains the model.
+        license_link: Direct URL to the full license text or terms of service.
+        released_at: Date when the model was first released or made available.
+        deprecated_at: Date when the model was deprecated. None if still active.
+        is_open_source: Whether the model is open source. Important for compliance and transparency.
+        chat_specialized: Whether the model is optimized for conversational/chat use cases.
+        industry: Primary industry or domain the model is designed for.
+        commercial_use: Whether the model can be used for commercial purposes.
+        certifications: List of compliance certifications (e.g., "SOC2", "HIPAA", "ISO 27001").
+        has_tool_support: Whether the model supports tool calling/function calling capabilities.
+        has_stream_support: Whether the model supports streaming responses for real-time output.
+        context_window: Maximum number of tokens the model can process in a single request.
+        max_output_tokens: Maximum number of tokens the model can generate in a single response.
+        state: Current operational state of the model (e.g., "active", "deprecated", "beta").
+    """
+
+    credentials_id: Optional[UUID] = Field(
+        None,
+        alias="credentialsId",
+        description="Gets or sets the required Credentials ID for the model.",
+    )
+    id: Optional[UUID] = Field(
+        None, description="Gets or sets the library model identifier."
+    )
+    category: Optional[str] = Field(None, description="Gets or sets the category.")
+    description: Optional[str] = Field(
+        None, description="Gets or sets the description of the library model."
+    )
+    downloads: int = Field(
+        description="Gets or sets the number of times this model has been downloaded."
+    )
+    type: str = Field(description="Gets the input type of the model.")
+    languages: List[str] = Field(
+        description="Gets or sets the languages this model supports."
+    )
+    license_type: Optional[str] = Field(
+        None, alias="licenseType", description="Gets or sets the license of this model."
+    )
+    name: Optional[str] = Field(
+        None,
+        description="Gets the name of the library model.",
+        examples=["CHATGPT-4o, CHATGPT-4Turbo."],
+    )
+    display_name: Optional[str] = Field(
+        None, alias="displayName", description="Gets the display name of the library model."
+    )
+    price: str = Field(description="Gets or sets the price.")
+    input_token_price: Optional[str] = Field(
+        None, alias="inputTokenPrice", description="Gets or sets the input token cost."
+    )
+    output_token_price: Optional[str] = Field(
+        None, alias="outputTokenPrice", description="Gets or sets the output token cost."
+    )
+    price_type: str = Field(alias="priceType", description="Gets the price type.")
+    prompt_id: Optional[UUID] = Field(
+        None, alias="promptId", description="Gets the PromptId."
+    )
+    url: Optional[str] = Field(None, description="Gets the Url.")
+    provider: Optional[str] = Field(
+        None, description="Gets the provider of the model."
+    )
+    rating: int = Field(description="Gets or sets the average user rating of the model.")
+    tags: List[str] = Field(description="Gets or sets the related tags.")
+    available: bool = Field(
+        description="Gets or sets a value indicating whether the model is available."
+    )
+    token_price_conversion: Optional[TokenPriceConversion] = Field(
+        None,
+        alias="tokenPriceConversion",
+        description="Gets or sets common token price conversion values.",
+    )
+    allow_airia_credentials: bool = Field(
+        alias="allowAiriaCredentials",
+        description="Gets or sets a value indicating whether the model is allowed to use the Airia Credentials.",
+    )
+    allow_byok_credentials: bool = Field(
+        alias="allowBYOKCredentials",
+        description="Gets or sets a value indicating whether the model is allowed to use BYOK Credentials.",
+    )
+    author: str = Field(description="Gets or sets the author of the model.")
+    license_link: Optional[str] = Field(
+        None,
+        alias="licenseLink",
+        description="Gets or sets a direct link to the license for the model.",
+    )
+    released_at: Optional[datetime] = Field(
+        None, alias="releasedAt", description="Gets or sets the date the model was released."
+    )
+    deprecated_at: Optional[datetime] = Field(
+        None,
+        alias="deprecatedAt",
+        description="Gets or sets the date the model was deprecated.",
+    )
+    is_open_source: bool = Field(
+        alias="isOpenSource",
+        description="Gets or sets a value indicating whether the model is open source.",
+    )
+    chat_specialized: bool = Field(
+        alias="chatSpecialized",
+        description="Gets or sets a value indicating whether the model is chat specialized.",
+    )
+    industry: str = Field(description="Gets or sets the industry.")
+    commercial_use: bool = Field(
+        alias="commercialUse",
+        description="Gets or sets a value indicating whether the model is for commercial use.",
+    )
+    certifications: Optional[List[str]] = Field(
+        None, description="Gets or sets the certifications."
+    )
+    has_tool_support: bool = Field(
+        alias="hasToolSupport",
+        description="Gets a value indicating whether the model has tool support.",
+    )
+    has_stream_support: bool = Field(
+        alias="hasStreamSupport",
+        description="Gets a value indicating whether the model supports response streaming.",
+    )
+    context_window: int = Field(
+        alias="contextWindow", description="Gets the context window size for this model."
+    )
+    max_output_tokens: int = Field(
+        alias="maxOutputTokens",
+        description="Gets the maximum number of tokens that can be generated by the model.",
+    )
+    state: str = Field(description="Gets or sets the state of the model.")
+
+
+class GetLibraryModelsResponse(BaseModel):
+    """
+    A response for getting library models.
+
+    Attributes:
+        models: List of LibraryModel objects containing detailed information about each available model.
+        total_count: Total number of models matching the query criteria, useful for pagination calculations.
+    """
+
+    models: List[LibraryModel] = Field(
+        description="Gets or sets Models that the library allows provisioning."
+    )
+    total_count: int = Field(
+        alias="totalCount", description="Gets or sets the total count of models in the library."
+    )

airia/types/api/pipeline_execution/__init__.py

@@ -1,13 +1,23 @@
 from ._pipeline_execution import (
+    AgentBaseStepResult,
     PipelineExecutionAsyncStreamedResponse,
-    PipelineExecutionDebugResponse,
     PipelineExecutionResponse,
     PipelineExecutionStreamedResponse,
+    PipelineStepResult,
+    TemporaryAssistantAsyncStreamedResponse,
+    TemporaryAssistantResponse,
+    TemporaryAssistantStreamedResponse,
+    TimeTrackingData,
 )
 
 __all__ = [
-    "PipelineExecutionDebugResponse",
+    "AgentBaseStepResult",
+    "PipelineExecutionAsyncStreamedResponse",
     "PipelineExecutionResponse",
     "PipelineExecutionStreamedResponse",
-    "PipelineExecutionAsyncStreamedResponse",
+    "PipelineStepResult",
+    "TemporaryAssistantAsyncStreamedResponse",
+    "TemporaryAssistantResponse",
+    "TemporaryAssistantStreamedResponse",
+    "TimeTrackingData",
 ]