airia 0.1.25__py3-none-any.whl → 0.1.26__py3-none-any.whl

airia/client/pipeline_import/async_pipeline_import.py

@@ -0,0 +1,147 @@
+from typing import Any, Dict, Literal, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipeline_import import CreateAgentFromPipelineDefinitionResponse
+from .._request_handler import AsyncRequestHandler
+from .base_pipeline_import import BasePipelineImport
+
+
+class AsyncPipelineImport(BasePipelineImport):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateAgentFromPipelineDefinitionResponse:
+        """
+        Create an agent from a pipeline definition (async).
+
+        This method imports a complete pipeline from a definition dictionary,
+        creating all necessary components including data sources, prompts, tools,
+        models, and pipeline steps. The definition structure should match the
+        format returned by export_pipeline_definition(), but use JSON-compatible
+        types (no enums or Pydantic classes).
+
+        Args:
+            pipeline_definition (dict): The pipeline definition to import. This should
+                be a dictionary with the same structure as the response from
+                pipelines_config.export_pipeline_definition(), but using only
+                JSON-compatible types (strings, numbers, dicts, lists).
+            agent_import_source (str, optional): The source of the agent import.
+                Valid values: "PlatformApi", "ChatCommunity", "PlatformCommunity",
+                "PlatformJson", "Marketplace". If not provided, the import source
+                will not be specified.
+            conflict_resolution_strategy (str): Strategy for handling conflicting entities.
+                Valid values:
+                - "SkipConflictingEntities" (default): Skip entities that already exist
+                - "RecreateExistingEntities": Recreate entities that already exist
+                - "SeededAgent": Use seeded agent strategy
+            credential_mappings (dict, optional): Mapping of exported credential IDs
+                to existing credential GUIDs in the database. Key: Exported credential
+                ID from agent definition. Value: Existing credential GUID in database
+                (must belong to tenant/project).
+            default_project_behavior (str, optional): The default project behavior
+                if project_id is null. Valid values: "Library", "BrainFreezeThenDefault",
+                "DefaultProject".
+            project_id (str, optional): The project ID where the pipeline should be
+                imported. If null, the provision will happen in a library project
+                according to default_project_behavior.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateAgentFromPipelineDefinitionResponse: A response object containing the
+                import result, including pipeline ID, department ID, pipeline name,
+                deployment ID (if deployed), and lists of created, updated, and
+                skipped entities. If the import failed, error_message and error_details
+                will contain information about what went wrong.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline definition is invalid (400)
+                - A referenced project_id doesn't exist (404)
+                - Credential mappings are invalid (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+            import asyncio
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # First, export a pipeline definition
+                exported = await client.pipelines_config.export_pipeline_definition(
+                    pipeline_id="source_pipeline_id"
+                )
+
+                # Convert the exported definition to a JSON-compatible dictionary
+                # (Pydantic models have a .model_dump() method for this)
+                pipeline_def = exported.model_dump(by_alias=True, exclude_none=True)
+
+                # Import the pipeline into a new project
+                result = await client.pipeline_import.create_agent_from_pipeline_definition(
+                    pipeline_definition=pipeline_def,
+                    project_id="target_project_id",
+                    conflict_resolution_strategy="SkipConflictingEntities"
+                )
+
+                if result.error_message:
+                    print(f"Import failed: {result.error_message}")
+                    if result.error_details:
+                        for detail in result.error_details:
+                            print(f"  - {detail}")
+                else:
+                    print(f"Pipeline imported successfully!")
+                    print(f"Pipeline ID: {result.pipeline_id}")
+                    print(f"Pipeline Name: {result.pipeline_name}")
+                    print(f"Created {len(result.created_entities or [])} entities")
+                    print(f"Updated {len(result.updated_entities or [])} entities")
+                    print(f"Skipped {len(result.skipped_entities or [])} entities")
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            - The pipeline_definition must use JSON-compatible types only
+            - Use model_dump(by_alias=True) on Pydantic models to get the correct format
+            - Credential mappings must reference existing credentials in the target system
+            - The import process will create new GUIDs for most entities
+        """
+        request_data = self._pre_create_agent_from_pipeline_definition(
+            pipeline_definition=pipeline_definition,
+            agent_import_source=agent_import_source,
+            conflict_resolution_strategy=conflict_resolution_strategy,
+            credential_mappings=credential_mappings,
+            default_project_behavior=default_project_behavior,
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = await self._request_handler.make_request("POST", request_data)
+
+        return CreateAgentFromPipelineDefinitionResponse(**resp)

airia/client/pipeline_import/base_pipeline_import.py

@@ -0,0 +1,95 @@
+from typing import Any, Dict, Literal, Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BasePipelineImport:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for creating an agent from a pipeline definition.
+
+        This internal method constructs the URL and payload for importing
+        a pipeline from a definition.
+
+        Args:
+            pipeline_definition: The pipeline definition to import (dictionary structure
+                matching ExportPipelineDefinitionResponse format, but using JSON-compatible types)
+            agent_import_source: The source of the agent import (PlatformApi, ChatCommunity,
+                PlatformCommunity, PlatformJson, or Marketplace)
+            conflict_resolution_strategy: Strategy for handling conflicting entities
+                (SkipConflictingEntities, RecreateExistingEntities, or SeededAgent)
+            credential_mappings: Optional mapping of exported credential IDs to existing
+                credential GUIDs in the database
+            default_project_behavior: The default project behavior if project_id is null
+                (Library, BrainFreezeThenDefault, or DefaultProject)
+            project_id: Optional project ID. If null, provision happens in a library project
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline import 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}/PipelineImport/definition",
+        )
+
+        payload = {
+            "pipelineDefinition": pipeline_definition,
+            "conflictResolutionStrategy": conflict_resolution_strategy,
+        }
+
+        # Add optional fields only if they are not None
+        if agent_import_source is not None:
+            payload["agentImportSource"] = agent_import_source
+
+        if credential_mappings is not None:
+            payload["credentialMappings"] = credential_mappings
+
+        if default_project_behavior is not None:
+            payload["defaultProjectBehavior"] = default_project_behavior
+
+        if project_id is not None:
+            payload["projectId"] = project_id
+
+        request_data = self._request_handler.prepare_request(
+            url=url, payload=payload, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipeline_import/sync_pipeline_import.py

@@ -0,0 +1,143 @@
+from typing import Any, Dict, Literal, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipeline_import import CreateAgentFromPipelineDefinitionResponse
+from .._request_handler import RequestHandler
+from .base_pipeline_import import BasePipelineImport
+
+
+class PipelineImport(BasePipelineImport):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateAgentFromPipelineDefinitionResponse:
+        """
+        Create an agent from a pipeline definition.
+
+        This method imports a complete pipeline from a definition dictionary,
+        creating all necessary components including data sources, prompts, tools,
+        models, and pipeline steps. The definition structure should match the
+        format returned by export_pipeline_definition(), but use JSON-compatible
+        types (no enums or Pydantic classes).
+
+        Args:
+            pipeline_definition (dict): The pipeline definition to import. This should
+                be a dictionary with the same structure as the response from
+                pipelines_config.export_pipeline_definition(), but using only
+                JSON-compatible types (strings, numbers, dicts, lists).
+            agent_import_source (str, optional): The source of the agent import.
+                Valid values: "PlatformApi", "ChatCommunity", "PlatformCommunity",
+                "PlatformJson", "Marketplace". If not provided, the import source
+                will not be specified.
+            conflict_resolution_strategy (str): Strategy for handling conflicting entities.
+                Valid values:
+                - "SkipConflictingEntities" (default): Skip entities that already exist
+                - "RecreateExistingEntities": Recreate entities that already exist
+                - "SeededAgent": Use seeded agent strategy
+            credential_mappings (dict, optional): Mapping of exported credential IDs
+                to existing credential GUIDs in the database. Key: Exported credential
+                ID from agent definition. Value: Existing credential GUID in database
+                (must belong to tenant/project).
+            default_project_behavior (str, optional): The default project behavior
+                if project_id is null. Valid values: "Library", "BrainFreezeThenDefault",
+                "DefaultProject".
+            project_id (str, optional): The project ID where the pipeline should be
+                imported. If null, the provision will happen in a library project
+                according to default_project_behavior.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateAgentFromPipelineDefinitionResponse: A response object containing the
+                import result, including pipeline ID, department ID, pipeline name,
+                deployment ID (if deployed), and lists of created, updated, and
+                skipped entities. If the import failed, error_message and error_details
+                will contain information about what went wrong.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline definition is invalid (400)
+                - A referenced project_id doesn't exist (404)
+                - Credential mappings are invalid (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # First, export a pipeline definition
+            exported = client.pipelines_config.export_pipeline_definition(
+                pipeline_id="source_pipeline_id"
+            )
+
+            # Convert the exported definition to a JSON-compatible dictionary
+            # (Pydantic models have a .model_dump() method for this)
+            pipeline_def = exported.model_dump(by_alias=True, exclude_none=True)
+
+            # Import the pipeline into a new project
+            result = client.pipeline_import.create_agent_from_pipeline_definition(
+                pipeline_definition=pipeline_def,
+                project_id="target_project_id",
+                conflict_resolution_strategy="SkipConflictingEntities"
+            )
+
+            if result.error_message:
+                print(f"Import failed: {result.error_message}")
+                if result.error_details:
+                    for detail in result.error_details:
+                        print(f"  - {detail}")
+            else:
+                print(f"Pipeline imported successfully!")
+                print(f"Pipeline ID: {result.pipeline_id}")
+                print(f"Pipeline Name: {result.pipeline_name}")
+                print(f"Created {len(result.created_entities or [])} entities")
+                print(f"Updated {len(result.updated_entities or [])} entities")
+                print(f"Skipped {len(result.skipped_entities or [])} entities")
+            ```
+
+        Note:
+            - The pipeline_definition must use JSON-compatible types only
+            - Use model_dump(by_alias=True) on Pydantic models to get the correct format
+            - Credential mappings must reference existing credentials in the target system
+            - The import process will create new GUIDs for most entities
+        """
+        request_data = self._pre_create_agent_from_pipeline_definition(
+            pipeline_definition=pipeline_definition,
+            agent_import_source=agent_import_source,
+            conflict_resolution_strategy=conflict_resolution_strategy,
+            credential_mappings=credential_mappings,
+            default_project_behavior=default_project_behavior,
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = self._request_handler.make_request("POST", request_data)
+
+        return CreateAgentFromPipelineDefinitionResponse(**resp)

airia/client/sync_client.py

@@ -15,7 +15,9 @@ from .conversations import Conversations
 from .data_vector_search import DataVectorSearch
 from .deployments import Deployments
 from .library import Library
+from .models import Models
 from .pipeline_execution import PipelineExecution
+from .pipeline_import import PipelineImport
 from .pipelines_config import PipelinesConfig
 from .project import Project
 from .store import Store
@@ -63,6 +65,7 @@ class AiriaClient(AiriaBaseClient):
         )
         self.attachments = Attachments(self._request_handler)
         self.pipeline_execution = PipelineExecution(self._request_handler)
+        self.pipeline_import = PipelineImport(self._request_handler)
         self.pipelines_config = PipelinesConfig(self._request_handler)
         self.project = Project(self._request_handler)
         self.conversations = Conversations(self._request_handler)
@@ -70,6 +73,7 @@ class AiriaClient(AiriaBaseClient):
         self.deployments = Deployments(self._request_handler)
         self.data_vector_search = DataVectorSearch(self._request_handler)
         self.library = Library(self._request_handler)
+        self.models = Models(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/exceptions.py

@@ -11,7 +11,7 @@ class AiriaAPIError(Exception):
         message (str): The error message describing what went wrong
     """
 
-    def __init__(self, status_code: int, message: str):
+    def __init__(self, status_code: int, message: str, detailed_message: str):
         """
         Initialize the exception with a status code and error message.
 
@@ -19,9 +19,10 @@ class AiriaAPIError(Exception):
             status_code (int): The HTTP status code of the failed request
             message (str): A descriptive error message
         """
-        super().__init__(f"{status_code}: {message}")
+        super().__init__(f"{status_code}: {message} - {detailed_message}")
         self.status_code = status_code
         self.message = message
+        self.detailed_message = detailed_message
 
     def __str__(self) -> str:
         """
@@ -30,4 +31,4 @@ class AiriaAPIError(Exception):
         Returns:
             str: A formatted string containing the status code and message
         """
-        return f"{self.status_code}: {self.message}"
+        return f"{self.status_code}: {self.message} - {self.detailed_message}"

airia/types/api/__init__.py

@@ -1 +1,3 @@
 from . import attachments as attachments
+from . import models as models
+from . import pipeline_import as pipeline_import

airia/types/api/models/__init__.py

@@ -0,0 +1,13 @@
+from .list_models import (
+    ModelItem,
+    ModelProject,
+    ModelSystemPrompt,
+    ModelUserProvidedDetails,
+)
+
+__all__ = [
+    "ModelItem",
+    "ModelProject",
+    "ModelSystemPrompt",
+    "ModelUserProvidedDetails",
+]

airia/types/api/models/list_models.py

@@ -0,0 +1,129 @@
+"""
+Pydantic models for models management API responses.
+
+This module defines the data structures returned by models-related endpoints,
+including model listings and associated configuration information.
+"""
+
+from datetime import datetime
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ModelProject(BaseModel):
+    """
+    Basic project information associated with a model.
+
+    Represents a simplified view of project data within model contexts,
+    containing only essential identification information.
+    """
+
+    id: str
+    name: str
+
+
+class ModelSystemPrompt(BaseModel):
+    """
+    System prompt information associated with a model.
+
+    Contains details about the system prompt template used by the model,
+    including version tracking and project associations.
+    """
+
+    id: str
+    name: str
+    active_version_id: Optional[str] = Field(None, alias="activeVersionId")
+    active_version: Optional[Any] = Field(None, alias="activeVersion")
+    created_at: datetime = Field(alias="createdAt")
+    updated_at: datetime = Field(alias="updatedAt")
+    project_id: Optional[str] = Field(None, alias="projectId")
+    project_name: Optional[str] = Field(None, alias="projectName")
+    project: Optional[Any] = None
+    latest_version_number: Optional[int] = Field(None, alias="latestVersionNumber")
+    is_agent_specific: bool = Field(alias="isAgentSpecific")
+
+
+class ModelUserProvidedDetails(BaseModel):
+    """
+    User-provided configuration details for a model.
+
+    Contains authentication, pricing, and deployment information
+    for models configured by users.
+    """
+
+    url: str
+    credentials_id: Optional[str] = Field(None, alias="credentialsId")
+    deployment_type: str = Field(alias="deploymentType")
+    connection_string: Optional[str] = Field(None, alias="connectionString")
+    container_name: Optional[str] = Field(None, alias="containerName")
+    deployed_key: Optional[str] = Field(None, alias="deployedKey")
+    deployed_url: Optional[str] = Field(None, alias="deployedUrl")
+    state: Optional[Any] = None
+    uploaded_container_id: Optional[str] = Field(None, alias="uploadedContainerId")
+    input_token_price: float = Field(alias="inputTokenPrice")
+    output_token_price: float = Field(alias="outputTokenPrice")
+    token_units: int = Field(alias="tokenUnits")
+
+
+class ModelItem(BaseModel):
+    """
+    Comprehensive model information and metadata.
+
+    This model represents a complete model entity with all associated configuration,
+    pricing information, capabilities, and organizational details. Models can be
+    either library-provided or user-configured.
+
+    Attributes:
+        category: Model category (e.g., "Multimodal", "NLP", "ImageGeneration")
+        id: Unique model identifier
+        display_name: Human-readable model name
+        model_name: Technical model identifier/name
+        prompt_id: Optional system prompt identifier
+        system_prompt: Optional system prompt configuration
+        source_type: Model source ("Library" or "UserProvided")
+        type: Model type (e.g., "Text", "Image")
+        provider: AI provider (e.g., "OpenAI", "Anthropic", "Google")
+        tenant_id: Tenant/organization identifier
+        project_id: Optional project identifier
+        project_name: Optional project name
+        project: Optional project details
+        created_at: Model creation timestamp
+        updated_at: Last modification timestamp
+        user_id: User who created/configured the model
+        has_tool_support: Whether model supports tool calling
+        has_stream_support: Whether model supports streaming responses
+        library_model_id: Optional library model identifier
+        user_provided_details: Configuration details for user-provided models
+        allow_airia_credentials: Whether Airia-managed credentials are allowed
+        allow_byok_credentials: Whether bring-your-own-key credentials are allowed
+        price_type: Pricing model type
+        model_parameters: Additional model parameters
+        route_through_acc: Whether to route through Airia Credentials Controller
+    """
+
+    category: Optional[str] = None
+    id: str
+    display_name: str = Field(alias="displayName")
+    model_name: str = Field(alias="modelName")
+    prompt_id: Optional[str] = Field(None, alias="promptId")
+    system_prompt: Optional[ModelSystemPrompt] = Field(None, alias="systemPrompt")
+    source_type: str = Field(alias="sourceType")
+    type: str
+    provider: str
+    tenant_id: str = Field(alias="tenantId")
+    project_id: Optional[str] = Field(None, alias="projectId")
+    project_name: Optional[str] = Field(None, alias="projectName")
+    project: Optional[ModelProject] = None
+    created_at: datetime = Field(alias="createdAt")
+    updated_at: datetime = Field(alias="updatedAt")
+    user_id: str = Field(alias="userId")
+    has_tool_support: bool = Field(alias="hasToolSupport")
+    has_stream_support: bool = Field(alias="hasStreamSupport")
+    library_model_id: Optional[str] = Field(None, alias="libraryModelId")
+    user_provided_details: ModelUserProvidedDetails = Field(alias="userProvidedDetails")
+    allow_airia_credentials: bool = Field(alias="allowAiriaCredentials")
+    allow_byok_credentials: bool = Field(alias="allowBYOKCredentials")
+    price_type: str = Field(alias="priceType")
+    model_parameters: List[Any] = Field(alias="modelParameters")
+    route_through_acc: bool = Field(alias="routeThroughACC")

airia/types/api/pipeline_import/__init__.py

@@ -0,0 +1,11 @@
+"""Pipeline import API response types."""
+
+from .create_agent_from_pipeline_definition import (
+    CreateAgentFromPipelineDefinitionResponse,
+    PipelineImportedEntity,
+)
+
+__all__ = [
+    "CreateAgentFromPipelineDefinitionResponse",
+    "PipelineImportedEntity",
+]