airia 0.1.31__py3-none-any.whl → 0.1.33__py3-none-any.whl

airia/client/data_vector_search/async_data_vector_search.py

@@ -11,7 +11,12 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         super().__init__(request_handler)
 
     async def get_file_chunks(
-        self, data_store_id: str, file_id: str, correlation_id: Optional[str] = None
+        self,
+        data_store_id: str,
+        file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
+        correlation_id: Optional[str] = None,
     ) -> GetFileChunksResponse:
         """
         Retrieve chunks from a specific file in a data store.
@@ -21,6 +26,8 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         Args:
             data_store_id: The unique identifier of the data store (GUID format)
             file_id: The unique identifier of the file (GUID format)
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for request tracing
 
         Returns:
@@ -49,6 +56,14 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
                     file_id="your_file_id"
                 )
 
+                # Get file chunks with custom pagination
+                chunks_response = await client.data_vector_search.get_file_chunks(
+                    data_store_id="your_data_store_id",
+                    file_id="your_file_id",
+                    page_number=2,
+                    page_size=100
+                )
+
                 # Access the chunks
                 for chunk in chunks_response.chunks:
                     print(f"Chunk: {chunk.chunk}")
@@ -64,6 +79,8 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         request_data = self._pre_get_file_chunks(
             data_store_id=data_store_id,
             file_id=file_id,
+            page_number=page_number,
+            page_size=page_size,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )

airia/client/data_vector_search/base_data_vector_search.py

@@ -13,6 +13,8 @@ class BaseDataVectorSearch:
         self,
         data_store_id: str,
         file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ):
@@ -24,6 +26,8 @@ class BaseDataVectorSearch:
         Args:
             data_store_id: ID of the data store
             file_id: ID of the file
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for tracing
             api_version: API version to use for the request
 
@@ -44,7 +48,7 @@ class BaseDataVectorSearch:
         )
 
         request_data = self._request_handler.prepare_request(
-            url, correlation_id=correlation_id, params={"pageNumber": 1, "pageSize": 50}
+            url, correlation_id=correlation_id, params={"pageNumber": page_number, "pageSize": page_size}
         )
 
         return request_data

airia/client/data_vector_search/sync_data_vector_search.py

@@ -11,7 +11,12 @@ class DataVectorSearch(BaseDataVectorSearch):
         super().__init__(request_handler)
 
     def get_file_chunks(
-        self, data_store_id: str, file_id: str, correlation_id: Optional[str] = None
+        self,
+        data_store_id: str,
+        file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
+        correlation_id: Optional[str] = None,
     ) -> GetFileChunksResponse:
         """
         Retrieve chunks from a specific file in a data store.
@@ -21,6 +26,8 @@ class DataVectorSearch(BaseDataVectorSearch):
         Args:
             data_store_id: The unique identifier of the data store (GUID format)
             file_id: The unique identifier of the file (GUID format)
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for request tracing
 
         Returns:
@@ -47,6 +54,14 @@ class DataVectorSearch(BaseDataVectorSearch):
                 file_id="your_file_id"
             )
 
+            # Get file chunks with custom pagination
+            chunks_response = client.data_vector_search.get_file_chunks(
+                data_store_id="your_data_store_id",
+                file_id="your_file_id",
+                page_number=2,
+                page_size=100
+            )
+
             # Access the chunks
             for chunk in chunks_response.chunks:
                 print(f"Chunk: {chunk.chunk}")
@@ -58,6 +73,8 @@ class DataVectorSearch(BaseDataVectorSearch):
         request_data = self._pre_get_file_chunks(
             data_store_id=data_store_id,
             file_id=file_id,
+            page_number=page_number,
+            page_size=page_size,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )

airia/client/deployments/async_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from ...types._api_version import ApiVersion
 from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
@@ -12,6 +12,11 @@ class AsyncDeployments(BaseDeployments):
 
     async def get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         project_id: Optional[str] = None,
@@ -26,6 +31,11 @@ class AsyncDeployments(BaseDeployments):
         about each deployment including associated pipelines, data sources, and user prompts.
 
         Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             project_id: Optional filter by project id
@@ -42,16 +52,33 @@ class AsyncDeployments(BaseDeployments):
         Example:
             ```python
             client = AiriaAsyncClient(api_key="your-api-key")
+
+            # Basic usage with filtering
             deployments = await client.deployments.get_deployments(
                 tags=["production", "nlp"],
                 is_recommended=True
             )
+
+            # With pagination and sorting
+            deployments = await client.deployments.get_deployments(
+                page_number=1,
+                page_size=20,
+                sort_by="deploymentName",
+                sort_direction="ASC",
+                filter="text-analysis"
+            )
+
             print(f"Found {deployments.total_count} deployments")
             for deployment in deployments.items:
                 print(f"- {deployment.deployment_name}")
             ```
         """
         request_data = self._pre_get_deployments(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter=filter,
             tags=tags,
             is_recommended=is_recommended,
             correlation_id=correlation_id,

airia/client/deployments/base_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 from urllib.parse import urljoin
 
 from ...types._api_version import ApiVersion
@@ -11,6 +11,11 @@ class BaseDeployments:
 
     def _pre_get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         correlation_id: Optional[str] = None,
@@ -23,6 +28,11 @@ class BaseDeployments:
         retrieval requests, including optional filtering by tags and recommendation status.
 
         Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             correlation_id: Optional correlation ID for tracing
@@ -45,6 +55,16 @@ class BaseDeployments:
 
         # Build query parameters
         params = {}
+        if page_number is not None:
+            params["PageNumber"] = page_number
+        if page_size is not None:
+            params["PageSize"] = page_size
+        if sort_by is not None:
+            params["SortBy"] = sort_by
+        if sort_direction is not None:
+            params["SortDirection"] = sort_direction
+        if filter is not None:
+            params["Filter"] = filter
         if tags is not None:
             params["tags"] = tags
         if is_recommended is not None:

airia/client/deployments/sync_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from ...types._api_version import ApiVersion
 from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
@@ -12,6 +12,11 @@ class Deployments(BaseDeployments):
 
     def get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         project_id: Optional[str] = None,
@@ -26,6 +31,11 @@ class Deployments(BaseDeployments):
         about each deployment including associated pipelines, data sources, and user prompts.
 
         Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             project_id: Optional filter by project id
@@ -42,16 +52,33 @@ class Deployments(BaseDeployments):
         Example:
             ```python
             client = AiriaClient(api_key="your-api-key")
+
+            # Basic usage with filtering
             deployments = client.deployments.get_deployments(
                 tags=["production", "nlp"],
                 is_recommended=True
             )
+
+            # With pagination and sorting
+            deployments = client.deployments.get_deployments(
+                page_number=1,
+                page_size=20,
+                sort_by="deploymentName",
+                sort_direction="ASC",
+                filter="text-analysis"
+            )
+
             print(f"Found {deployments.total_count} deployments")
             for deployment in deployments.items:
                 print(f"- {deployment.deployment_name}")
             ```
         """
         request_data = self._pre_get_deployments(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter=filter,
             tags=tags,
             is_recommended=is_recommended,
             correlation_id=correlation_id,

airia/client/pipeline_execution/async_pipeline_execution.py

@@ -3,8 +3,12 @@ from typing import Any, Dict, List, Literal, Optional, Type, Union, overload
 from pydantic import BaseModel
 
 from ...types._api_version import ApiVersion
-from ...types._structured_output import create_schema_system_message, parse_response_to_model
+from ...types._structured_output import (
+    create_schema_system_message,
+    parse_response_to_model,
+)
 from ...types.api.pipeline_execution import (
+    GetPipelineExecutionResponse,
     PipelineExecutionAsyncStreamedResponse,
     PipelineExecutionResponse,
     TemporaryAssistantAsyncStreamedResponse,
@@ -209,7 +213,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -246,7 +252,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
             response = PipelineExecutionResponse(**resp)
             # Parse response to Pydantic model if output_schema was provided
             if output_schema is not None and response.result:
-                response.result = parse_response_to_model(response.result, output_schema)
+                response.result = parse_response_to_model(
+                    response.result, output_schema
+                )
             return response
 
         return PipelineExecutionAsyncStreamedResponse(stream=resp)
@@ -256,8 +264,8 @@ class AsyncPipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: Literal[False] = False,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -287,8 +295,8 @@ class AsyncPipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: Literal[True] = True,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -317,8 +325,8 @@ class AsyncPipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: bool = False,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -355,8 +363,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
             model_parameters: Model parameters (required). Must include libraryModelId,
                             projectModelId, modelIdentifierType, and modelIsAvailableinProject
             user_input: User input text (required)
+            prompt_parameters: Parameters for prompt configuration (required). Must include
+                            a 'prompt' key with the system prompt text
             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
@@ -403,6 +412,7 @@ class AsyncPipelineExecution(BasePipelineExecution):
                     "modelIsAvailableinProject": True,
                 },
                 user_input="say double bubble bath ten times fast",
+                prompt_parameters={"prompt": "You are a helpful assistant."},
             )
             print(response.result)
             ```
@@ -418,6 +428,7 @@ class AsyncPipelineExecution(BasePipelineExecution):
             response = await client.pipeline_execution.execute_temporary_assistant(
                 model_parameters={...},
                 user_input="What's the weather?",
+                prompt_parameters={"prompt": "You are a weather information assistant."},
                 output_schema=WeatherInfo
             )
             ```
@@ -440,7 +451,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -487,5 +500,52 @@ class AsyncPipelineExecution(BasePipelineExecution):
         response = TemporaryAssistantResponse(**resp)
         # Parse response to Pydantic model if output_schema was provided
         if output_schema is not None and response.result:
-            response.result = parse_response_to_model(str(response.result), output_schema)
+            response.result = parse_response_to_model(
+                str(response.result), output_schema
+            )
         return response
+
+    async def get_pipeline_execution(
+        self, execution_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineExecutionResponse:
+        """
+        Retrieve a pipeline execution result by execution ID asynchronously.
+
+        This method fetches the details of a specific pipeline execution using its
+        unique identifier. The response includes execution logs, step execution records,
+        timing information, and any errors that occurred during execution.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetPipelineExecutionResponse: Pipeline execution details including logs and step records
+
+        Raises:
+            AiriaAPIError: If the API request fails or execution is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaAsyncClient(api_key="your-api-key")
+            execution = await client.pipeline_execution.get_pipeline_execution("execution-id-123")
+            print(f"Execution ID: {execution.execution_id}")
+            print(f"Success: {execution.log_record_details.success}")
+            print(f"Duration: {execution.log_record_details.duration}")
+
+            # Iterate through step execution logs
+            if execution.step_execution_log_records:
+                for step in execution.step_execution_log_records:
+                    print(f"Step: {step.step_title} - Success: {step.success}")
+            ```
+        """
+        request_data = self._pre_get_pipeline_execution(
+            execution_id=execution_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = await self._request_handler.make_request("GET", request_data)
+
+        return GetPipelineExecutionResponse(**response)

airia/client/pipeline_execution/base_pipeline_execution.py

@@ -120,8 +120,8 @@ class BasePipelineExecution:
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {},
         async_output: bool = False,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -153,8 +153,9 @@ class BasePipelineExecution:
         Args:
             model_parameters: model parameters
             user_input: Optional user input text
+            prompt_parameters: Parameters for prompt configuration (required). Must include
+                            a 'prompt' key with the system prompt 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
@@ -224,3 +225,42 @@ class BasePipelineExecution:
         )
 
         return request_data
+
+    def _pre_get_pipeline_execution(
+        self,
+        execution_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for retrieving a pipeline execution.
+
+        This internal method constructs the URL for pipeline execution retrieval
+        by ID using the specified API version.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline execution endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+
+        url = urljoin(
+            self._request_handler.base_url,
+            f"{api_version}/PipelineExecution/{execution_id}",
+        )
+
+        request_data = self._request_handler.prepare_request(
+            url=url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipeline_execution/sync_pipeline_execution.py

@@ -3,8 +3,12 @@ from typing import Any, Dict, List, Literal, Optional, Type, Union, overload
 from pydantic import BaseModel
 
 from ...types._api_version import ApiVersion
-from ...types._structured_output import create_schema_system_message, parse_response_to_model
+from ...types._structured_output import (
+    create_schema_system_message,
+    parse_response_to_model,
+)
 from ...types.api.pipeline_execution import (
+    GetPipelineExecutionResponse,
     PipelineExecutionResponse,
     PipelineExecutionStreamedResponse,
     TemporaryAssistantResponse,
@@ -208,7 +212,9 @@ class PipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -245,7 +251,9 @@ class PipelineExecution(BasePipelineExecution):
             response = PipelineExecutionResponse(**resp)
             # Parse response to Pydantic model if output_schema was provided
             if output_schema is not None and response.result:
-                response.result = parse_response_to_model(response.result, output_schema)
+                response.result = parse_response_to_model(
+                    response.result, output_schema
+                )
             return response
 
         return PipelineExecutionStreamedResponse(stream=resp)
@@ -255,8 +263,8 @@ class PipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: Literal[False] = False,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -286,8 +294,8 @@ class PipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: Literal[True] = True,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -316,8 +324,8 @@ class PipelineExecution(BasePipelineExecution):
         self,
         model_parameters: Dict[str, Any],
         user_input: str,
+        prompt_parameters: Dict[str, Any],
         assistant_name: str = "",
-        prompt_parameters: Dict[str, Any] = {"prompt": ""},
         async_output: bool = False,
         include_tools_response: bool = False,
         save_history: bool = True,
@@ -354,8 +362,9 @@ class PipelineExecution(BasePipelineExecution):
             model_parameters: Model parameters (required). Must include libraryModelId,
                             projectModelId, modelIdentifierType, and modelIsAvailableinProject
             user_input: User input text (required)
+            prompt_parameters: Parameters for prompt configuration (required). Must include
+                            a 'prompt' key with the system prompt text
             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
@@ -401,6 +410,7 @@ class PipelineExecution(BasePipelineExecution):
                     "modelIsAvailableinProject": True,
                 },
                 user_input="say double bubble bath ten times fast",
+                prompt_parameters={"prompt": "You are a helpful assistant."},
             )
             print(response.result)
             ```
@@ -417,6 +427,7 @@ class PipelineExecution(BasePipelineExecution):
             response = client.pipeline_execution.execute_temporary_assistant(
                 model_parameters={...},
                 user_input="What's the weather like?",
+                prompt_parameters={"prompt": "You are a weather information assistant."},
                 output_schema=WeatherInfo
             )
             # Response will conform to WeatherInfo schema
@@ -440,7 +451,9 @@ class PipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -448,7 +461,9 @@ class PipelineExecution(BasePipelineExecution):
             output_configuration = None
 
         # Convert UUID objects to strings for API compatibility
-        conversation_id_str = str(conversation_id) if conversation_id else conversation_id
+        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
 
@@ -492,5 +507,52 @@ class PipelineExecution(BasePipelineExecution):
         response = TemporaryAssistantResponse(**resp)
         # Parse response to Pydantic model if output_schema was provided
         if output_schema is not None and response.result:
-            response.result = parse_response_to_model(str(response.result), output_schema)
+            response.result = parse_response_to_model(
+                str(response.result), output_schema
+            )
         return response
+
+    def get_pipeline_execution(
+        self, execution_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineExecutionResponse:
+        """
+        Retrieve a pipeline execution result by execution ID.
+
+        This method fetches the details of a specific pipeline execution using its
+        unique identifier. The response includes execution logs, step execution records,
+        timing information, and any errors that occurred during execution.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetPipelineExecutionResponse: Pipeline execution details including logs and step records
+
+        Raises:
+            AiriaAPIError: If the API request fails or execution is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your-api-key")
+            execution = client.pipeline_execution.get_pipeline_execution("execution-id-123")
+            print(f"Execution ID: {execution.execution_id}")
+            print(f"Success: {execution.log_record_details.success}")
+            print(f"Duration: {execution.log_record_details.duration}")
+
+            # Iterate through step execution logs
+            if execution.step_execution_log_records:
+                for step in execution.step_execution_log_records:
+                    print(f"Step: {step.step_title} - Success: {step.success}")
+            ```
+        """
+        request_data = self._pre_get_pipeline_execution(
+            execution_id=execution_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = self._request_handler.make_request("GET", request_data)
+
+        return GetPipelineExecutionResponse(**response)