airia 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

airia/types/api/pipelines_config/get_pipeline_config.py

@@ -1,401 +1,554 @@
-"""
-Pydantic models for pipeline configuration API responses.
+"""Types for the get_pipeline_config API response.
 
-This module defines comprehensive data structures for pipeline configuration exports,
-including all components like agents, models, tools, data sources, and deployment settings.
+This module defines comprehensive data structures for pipeline configuration
+responses, including pipeline definitions, versions, steps, deployments, and
+all associated metadata required for pipeline management and execution.
 """
 
+from __future__ import annotations
+
+from datetime import datetime
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
 
-class Metadata(BaseModel):
-    """Pipeline metadata and export configuration.
+class PipelineStepPosition(BaseModel):
+    """Represents the graphical position of a pipeline step within a visual representation of a pipeline.
 
-    Contains version information, export settings, and descriptive metadata
-    about the pipeline configuration.
+    Used for positioning pipeline steps in the visual pipeline editor interface.
 
     Attributes:
-        id: Unique identifier for the pipeline metadata
-        export_version: Version of the export format
-        tagline: Optional tagline describing the pipeline
-        agent_description: Optional description of the agent
-        industry: Optional industry classification
-        tasks: Optional description of tasks the pipeline performs
-        credential_export_option: Export option for credentials
-        data_source_export_option: Export option for data sources
-        version_information: Information about the pipeline version
-        state: Current state of the pipeline
+        x: The X-coordinate of the pipeline step in a 2D space
+        y: The Y-coordinate of the pipeline step in a 2D space
     """
 
-    id: str
-    export_version: str = Field(alias="exportVersion")
-    tagline: Optional[str] = None
-    agent_description: Optional[str] = Field(alias="agentDescription", default=None)
-    industry: Optional[str] = None
-    tasks: Optional[str] = None
-    credential_export_option: str = Field(alias="credentialExportOption")
-    data_source_export_option: str = Field(alias="dataSourceExportOption")
-    version_information: str = Field(alias="versionInformation")
-    state: str
+    x: float = Field(description="The X-coordinate of the pipeline step in a 2D space")
+    y: float = Field(description="The Y-coordinate of the pipeline step in a 2D space")
 
 
-class Agent(BaseModel):
-    """AI agent configuration and workflow definition.
+class PipelineStepHandle(BaseModel):
+    """Represents a handle for a pipeline step.
 
-    Represents the core agent that executes the pipeline, including its
-    identity, industry specialization, and step-by-step workflow configuration.
+    Handles are connection points on pipeline steps that allow data flow between
+    steps. They can be either source handles (output) or target handles (input).
 
     Attributes:
-        name: Display name of the agent
-        execution_name: Name used during execution
-        agent_description: Optional description of the agent's capabilities
-        video_link: Optional link to demonstration video
-        industry: Optional industry the agent specializes in
-        sub_industries: List of sub-industry specializations
-        agent_details: Dictionary containing additional agent configuration
-        id: Unique identifier for the agent
-        agent_icon: Optional icon identifier or URL
-        steps: List of workflow steps the agent executes
+        pipeline_step_id: The PipelineStepId this handle belongs to
+        uuid: The UUID of the handle
+        type: The type of the handle (source or target)
+        label: The label of the handle for display purposes
+        tooltip: The tooltip text shown when hovering over the handle
+        x: The X-coordinate of the handle within the pipeline step
+        y: The Y-coordinate of the handle within the pipeline step
     """
 
-    name: str
-    execution_name: str = Field(alias="executionName")
-    agent_description: Optional[str] = Field(alias="agentDescription", default=None)
-    video_link: Optional[str] = Field(alias="videoLink", default=None)
-    industry: Optional[str] = None
-    sub_industries: List[str] = Field(alias="subIndustries", default_factory=list)
-    agent_details: Dict[str, Any] = Field(alias="agentDetails", default_factory=dict)
-    id: str
-    agent_icon: Optional[str] = Field(alias="agentIcon", default=None)
-    steps: List[Dict[str, Any]]
+    pipeline_step_id: str = Field(
+        alias="pipelineStepId", description="The PipelineStepId this handle belongs to"
+    )
+    uuid: str = Field(description="The UUID of the handle")
+    type: str = Field(description="The type of the handle (source or target)")
+    label: Optional[str] = Field(default=None, description="The label of the handle")
+    tooltip: Optional[str] = Field(
+        default=None, description="The tooltip of the handle"
+    )
+    x: Optional[float] = Field(
+        default=None, description="The X-coordinate of the pipeline step in a 2D space"
+    )
+    y: Optional[float] = Field(
+        default=None, description="The Y-coordinate of the pipeline step in a 2D space"
+    )
+
 
+class PipelineStepDependency(BaseModel):
+    """Represents a dependency between pipeline steps.
 
-class PromptMessage(BaseModel):
-    """Individual message within a prompt template.
+    Dependencies define the flow of data between pipeline steps by connecting
+    output handles of parent steps to input handles of child steps.
 
     Attributes:
-        text: The message content
-        order: Order of the message in the prompt sequence
+        pipeline_step_id: The PipelineStepId this dependency belongs to
+        parent_id: The UUID of the parent pipeline step that provides input
+        parent_handle_id: The UUID of the parent handle (source output)
+        handle_id: The UUID of this handle (target input)
     """
 
-    text: str
-    order: int
+    pipeline_step_id: str = Field(
+        alias="pipelineStepId", description="The PipelineStepId this handle belongs to"
+    )
+    parent_id: str = Field(
+        alias="parentId", description="The UUID of the parent pipeline step"
+    )
+    parent_handle_id: str = Field(
+        alias="parentHandleId", description="The UUID of the parent handle (source)"
+    )
+    handle_id: str = Field(
+        alias="handleId", description="The UUID of this handle (target)"
+    )
+
 
+class PipelineStep(BaseModel):
+    """Represents a step within a pipeline.
 
-class Prompt(BaseModel):
-    """Prompt template configuration.
+    Pipeline steps are individual processing units that perform specific tasks
+    within a pipeline workflow. Each step has a type, position, and connection
+    points for data flow.
 
     Attributes:
-        name: Name of the prompt template
-        version_change_description: Description of changes in this version
-        prompt_message_list: List of messages in the prompt
-        id: Unique identifier for the prompt
+        position: The graphical position of this step within the pipeline editor
+        position_id: The identifier of the position for layout management
+        handles: The connection points (handles) of this step for data flow
+        dependencies_object: The input dependencies of this step from other steps
+        step_type: The type of processing this step performs
+        pipeline_version_id: The Pipeline Version Id this step belongs to
+        step_title: The human-readable title/name of the step
     """
 
-    name: str
-    version_change_description: str = Field(alias="versionChangeDescription")
-    prompt_message_list: List[PromptMessage] = Field(alias="promptMessageList")
-    id: str
+    position: Optional[PipelineStepPosition] = Field(
+        default=None, description="The position of this step within the pipeline"
+    )
+    position_id: Optional[str] = Field(
+        alias="positionId", default=None, description="The identifier of the position"
+    )
+    handles: Optional[List[PipelineStepHandle]] = Field(
+        default=None, description="The handles of this step within the pipeline"
+    )
+    dependencies_object: Optional[List[PipelineStepDependency]] = Field(
+        alias="dependenciesObject",
+        default=None,
+        description="The dependencies of this step within the pipeline",
+    )
+    step_type: str = Field(alias="stepType", description="The type of this step")
+    pipeline_version_id: str = Field(
+        alias="pipelineVersionId", description="The Pipeline Version Id"
+    )
+    step_title: str = Field(alias="stepTitle", description="The Step Title")
+
 
+class PipelineVersion(BaseModel):
+    """Represents a specific version of a pipeline.
 
-class CredentialData(BaseModel):
-    """Individual credential key-value pair.
+    Pipeline versions allow for iteration and deployment management of pipelines.
+    Each version contains a complete definition of the pipeline structure and steps.
 
     Attributes:
-        key: The credential key name
-        value: The credential value
+        pipeline_id: The identifier of the parent pipeline this version belongs to
+        major_version: The major version number for significant changes
+        minor_version: The minor version number for incremental changes
+        version_number: The complete version number in string format (e.g., "1.2")
+        is_draft_version: Whether this is a draft version or a released production version
+        is_latest: Whether this version is the latest/current version of the pipeline
+        steps: The list of processing steps that make up this pipeline version
+        alignment: The UI alignment setting for pipeline visualization
     """
 
-    key: str
-    value: str
+    pipeline_id: str = Field(
+        alias="pipelineId", description="The identifier of the parent pipeline"
+    )
+    major_version: int = Field(
+        alias="majorVersion", description="The major version number"
+    )
+    minor_version: int = Field(
+        alias="minorVersion", description="The minor version number"
+    )
+    version_number: str = Field(
+        alias="versionNumber", description="The version number in string format"
+    )
+    is_draft_version: bool = Field(
+        alias="isDraftVersion",
+        description="Whether the version is a draft or a major production version",
+    )
+    is_latest: bool = Field(
+        alias="isLatest",
+        description="Whether this version is the latest version of the pipeline",
+    )
+    steps: Optional[List[PipelineStep]] = Field(
+        default=None, description="The list of steps that make up the pipeline"
+    )
+    alignment: str = Field(description="The alignment of the pipeline in UI")
+
 
+class PipelineExecutionStats(BaseModel):
+    """Represents the execution statistics for a pipeline.
 
-class CredentialsDefinition(BaseModel):
-    """Credentials configuration and authentication settings.
+    Tracks the historical performance and reliability metrics of pipeline executions
+    to provide insights into pipeline health and success rates.
 
     Attributes:
-        name: Name of the credentials definition
-        credential_type: Type of credentials (API key, OAuth, etc.)
-        source_type: Source where credentials are stored
-        credential_data_list: List of credential key-value pairs
-        id: Unique identifier for the credentials definition
+        success_count: The total number of successful executions
+        failure_count: The total number of failed executions
     """
 
-    name: str
-    credential_type: str = Field(alias="credentialType")
-    source_type: str = Field(alias="sourceType")
-    credential_data_list: List[CredentialData] = Field(alias="credentialDataList")
-    id: str
+    success_count: int = Field(
+        alias="successCount", description="The total number of successful executions"
+    )
+    failure_count: int = Field(
+        alias="failureCount", description="The total number of failed executions"
+    )
+
 
+class AgentDetailsEntry(BaseModel):
+    """Represents a single agent details entry.
 
-class HeaderDefinition(BaseModel):
-    """HTTP header definition for API requests.
+    Agent details entries define configurable parameters and metadata for
+    agent behavior, including input types, default values, and available options.
 
     Attributes:
-        key: Header name
-        value: Header value
+        type: The input type (e.g., text, select, multiselect, number)
+        name: The parameter name for this configuration entry
+        value: The current value of this parameter
+        options: Available options for select or multiselect input types
     """
 
-    key: str
-    value: str
+    type: str = Field(description="The input type")
+    name: str = Field(description="The input name")
+    value: Any = Field(description="The input value")
+    options: Optional[List[str]] = Field(
+        default=None, description="The options for select or multiselect"
+    )
+
 
+class AboutDeploymentMetadata(BaseModel):
+    """Represents metadata about a deployment for the About tab.
 
-class ParameterDefinition(BaseModel):
-    """Parameter definition for tool configuration.
+    Contains versioned metadata that appears in the About section of a deployment,
+    including educational and descriptive content.
 
     Attributes:
-        name: Name of the parameter
-        parameter_type: Type of the parameter (string, integer, etc.)
-        parameter_description: Description of the parameter's purpose
-        default: Default value for the parameter
-        valid_options: List of valid options for the parameter
-        id: Unique identifier for the parameter definition
+        version: The version of the About Deployment metadata schema
+        video_url: The URL of the instructional or demonstration video
     """
 
-    name: str
-    parameter_type: str = Field(alias="parameterType")
-    parameter_description: str = Field(alias="parameterDescription")
-    default: str
-    valid_options: List[str] = Field(alias="validOptions", default_factory=list)
-    id: str
+    version: int = Field(description="The version of the About Deployment metadata")
+    video_url: str = Field(alias="videoUrl", description="The video url")
+
 
+class DeploymentAssignment(BaseModel):
+    """Represents a deployment assignment.
 
-class Tool(BaseModel):
-    """Tool configuration for external API integrations.
+    Deployment assignments link deployments to specific entities (users, groups, etc.)
+    to control access and visibility of deployed pipelines.
 
     Attributes:
-        tool_type: Type of tool (API, function, etc.)
-        name: Display name of the tool
-        standardized_name: Standardized name for the tool
-        tool_description: Description of the tool's functionality
-        purpose: Purpose or use case for the tool
-        api_endpoint: API endpoint URL
-        credentials_definition: Optional credentials required for the tool
-        headers_definition: List of HTTP headers for API requests
-        body: Request body template
-        parameters_definition: List of parameter definitions
-        method_type: HTTP method type (GET, POST, etc.)
-        route_through_acc: Whether to route through ACC
-        use_user_credentials: Whether to use user credentials
-        use_user_credentials_type: Type of user credentials to use
-        id: Unique identifier for the tool
+        deployment_id: The ID of the deployment being assigned
+        id: The unique identifier of this assignment
+        entity_id: The ID of the entity (user, group) receiving the assignment
+        entity_type: The type of entity being assigned (user, group, etc.)
+        created_at: Timestamp when the assignment was created
+        updated_at: Timestamp when the assignment was last modified
+        user_id: The ID of the user who created this assignment
     """
 
-    tool_type: str = Field(alias="toolType")
-    name: str
-    standardized_name: str = Field(alias="standardizedName")
-    tool_description: str = Field(alias="toolDescription")
-    purpose: str
-    api_endpoint: str = Field(alias="apiEndpoint")
-    credentials_definition: Optional[CredentialsDefinition] = Field(
-        alias="credentialsDefinition"
+    deployment_id: str = Field(alias="deploymentId", description="The deployment ID")
+    id: str = Field(description="The ID")
+    entity_id: str = Field(alias="entityId", description="The entity ID")
+    entity_type: str = Field(alias="entityType", description="The entity type")
+    created_at: Optional[datetime] = Field(
+        alias="createdAt", default=None, description="The created at timestamp"
     )
-    headers_definition: List[HeaderDefinition] = Field(alias="headersDefinition")
-    body: str
-    parameters_definition: List[ParameterDefinition] = Field(
-        alias="parametersDefinition"
+    updated_at: Optional[datetime] = Field(
+        alias="updatedAt", default=None, description="The updated at timestamp"
+    )
+    user_id: Optional[str] = Field(
+        alias="userId", default=None, description="The user ID"
     )
-    method_type: str = Field(alias="methodType")
-    route_through_acc: bool = Field(alias="routeThroughACC")
-    use_user_credentials: bool = Field(alias="useUserCredentials")
-    use_user_credentials_type: str = Field(alias="useUserCredentialsType")
-    id: str
 
 
-class Model(BaseModel):
-    """Language model configuration and deployment settings.
+class DeploymentUserPrompt(BaseModel):
+    """A join entity that represents a user prompt associated with a deployment.
 
-    Defines an AI model used in the pipeline, including its deployment details,
-    pricing configuration, authentication settings, and capabilities.
+    Links deployments with predefined user prompts to provide template
+    interactions and guided user experiences.
 
     Attributes:
-        id: Unique identifier for the model
-        display_name: Display name of the model
-        model_name: Technical name of the model
-        prompt_id: Optional ID of associated prompt template
-        system_prompt_definition: Optional system prompt configuration
-        url: Model endpoint URL
-        input_type: Type of input the model accepts
-        provider: Model provider (OpenAI, Anthropic, etc.)
-        credentials_definition: Optional credentials for model access
-        deployment_type: Type of deployment (cloud, on-premise, etc.)
-        source_type: Source type of the model
-        connection_string: Optional connection string for deployment
-        container_name: Optional container name for deployment
-        deployed_key: Optional key for deployed model
-        deployed_url: Optional URL for deployed model
-        state: Optional current state of the model
-        uploaded_container_id: Optional ID of uploaded container
-        library_model_id: Optional ID from model library
-        input_token_price: Price per input token
-        output_token_price: Price per output token
-        token_units: Number of token units
-        has_tool_support: Whether the model supports tool calling
-        allow_airia_credentials: Whether Airia credentials are allowed
-        allow_byok_credentials: Whether bring-your-own-key credentials are allowed
-        author: Optional author of the model
-        price_type: Type of pricing model
+        deployment_id: The ID of the deployment this prompt is associated with
+        user_prompt_id: The ID of the user prompt template
     """
 
-    id: str
-    display_name: str = Field(alias="displayName")
-    model_name: str = Field(alias="modelName")
-    prompt_id: Optional[str] = Field(alias="promptId", default=None)
-    system_prompt_definition: Optional[Any] = Field(
-        alias="systemPromptDefinition", default=None
-    )
-    url: str
-    input_type: str = Field(alias="inputType")
-    provider: str
-    credentials_definition: Optional[CredentialsDefinition] = Field(
-        alias="credentialsDefinition"
-    )
-    deployment_type: str = Field(alias="deploymentType")
-    source_type: str = Field(alias="sourceType")
-    connection_string: Optional[str] = Field(alias="connectionString", default=None)
-    container_name: Optional[str] = Field(alias="containerName", default=None)
-    deployed_key: Optional[str] = Field(alias="deployedKey", default=None)
-    deployed_url: Optional[str] = Field(alias="deployedUrl", default=None)
-    state: Optional[str] = None
-    uploaded_container_id: Optional[str] = Field(
-        alias="uploadedContainerId", default=None
-    )
-    library_model_id: Optional[str] = Field(alias="libraryModelId")
-    input_token_price: str = Field(alias="inputTokenPrice")
-    output_token_price: str = Field(alias="outputTokenPrice")
-    token_units: int = Field(alias="tokenUnits")
-    has_tool_support: bool = Field(alias="hasToolSupport")
-    allow_airia_credentials: bool = Field(alias="allowAiriaCredentials")
-    allow_byok_credentials: bool = Field(alias="allowBYOKCredentials")
-    author: Optional[str]
-    price_type: str = Field(alias="priceType")
-
-
-class PythonCodeBlock(BaseModel):
-    """Python code block for custom functionality.
-
-    Attributes:
-        id: Unique identifier for the code block
-        code: Python code content
-    """
+    deployment_id: str = Field(alias="deploymentId", description="The deployment ID")
+    user_prompt_id: str = Field(alias="userPromptId", description="The user prompt ID")
 
-    id: str
-    code: str
 
+class Deployment(BaseModel):
+    """Represents a deployment.
 
-class Router(BaseModel):
-    """Router configuration for model selection and routing.
+    Deployments make pipelines available to end users with specific configurations,
+    branding, and access controls. They define how users interact with pipelines
+    in production environments.
 
     Attributes:
-        id: Unique identifier for the router
-        model_id: ID of the associated model
-        model: Optional model object
-        router_config: Dictionary containing router configuration
+        pipeline_id: The ID of the pipeline being deployed
+        name: The human-readable name of the deployment
+        description: A detailed description of the deployment's purpose and functionality
+        deployment_user_prompts: List of predefined prompts available to users
+        deployment_prompt: Optional system prompt that configures the deployment behavior
+        project_id: The ID of the project containing this deployment
+        is_recommended: Whether this deployment is featured/recommended to users
+        tags: Categorization tags for discovery and organization
+        conversation_type: The type of conversation interface (chat, form, etc.)
+        about: Optional metadata for the About/help section
+        assignments: Optional list of user/group assignments for access control
     """
 
-    id: str
-    model_id: str = Field(alias="modelId")
-    model: Optional[Any] = None
-    router_config: Dict[str, Dict[str, Any]] = Field(alias="routerConfig")
-
-
-class ChunkingConfig(BaseModel):
-    """Configuration for text chunking in data processing.
-
-    Attributes:
-        id: Unique identifier for the chunking configuration
-        chunk_size: Size of each text chunk
-        chunk_overlap: Number of characters to overlap between chunks
-        strategy_type: Type of chunking strategy to use
-    """
+    pipeline_id: str = Field(
+        alias="pipelineId",
+        description="The pipeline ID associated with this deployment",
+    )
+    name: str = Field(description="The Deployment Name")
+    description: str = Field(description="A description of the deployment")
+    deployment_user_prompts: Optional[List[DeploymentUserPrompt]] = Field(
+        alias="deploymentUserPrompts",
+        default=None,
+        description="The DeploymentUserPrompts",
+    )
+    deployment_prompt: Optional[str] = Field(
+        alias="deploymentPrompt", default=None, description="The DeploymentPrompt"
+    )
+    project_id: str = Field(alias="projectId", description="The Project Id")
+    is_recommended: bool = Field(
+        alias="isRecommended",
+        description="Whether this is a recommended/featured deployment",
+    )
+    tags: List[str] = Field(description="The Tags")
+    conversation_type: str = Field(
+        alias="conversationType", description="The Conversation Start Type"
+    )
+    about: Optional[AboutDeploymentMetadata] = Field(
+        default=None, description="Metadata about the deployment"
+    )
+    assignments: Optional[List[DeploymentAssignment]] = Field(
+        default=None, description="The Assignments"
+    )
 
-    id: str
-    chunk_size: int = Field(alias="chunkSize")
-    chunk_overlap: int = Field(alias="chunkOverlap")
-    strategy_type: str = Field(alias="strategyType")
 
+class AgentTrigger(BaseModel):
+    """Represents a trigger used to start a pipeline execution.
 
-class DataSourceFile(BaseModel):
-    """File reference within a data source.
+    Agent triggers enable automatic pipeline execution based on external events,
+    particularly email-based triggers for document processing and workflow automation.
 
     Attributes:
-        data_source_id: ID of the data source containing this file
-        file_path: Optional path to the file
-        input_token: Optional input token for file access
-        file_count: Optional count of files
+        email_id: The email address that can trigger this agent
+        allowed_type: The type of content allowed to trigger execution
+        allowed_values: The specific values that are permitted for triggering
+        pipeline_id: The ID of the pipeline to execute when triggered
+        data_source_id: Optional ID of the data source for input data
+        store_connector_id: Optional ID of the storage connector for file handling
+        email_action: The action to perform when the email trigger activates
+        forward_to: Optional email address to forward results to after execution
     """
 
-    data_source_id: str = Field(alias="dataSourceId")
-    file_path: Optional[str] = Field(None, alias="filePath")
-    input_token: Optional[str] = Field(None, alias="inputToken")
-    file_count: Optional[int] = Field(None, alias="fileCount")
+    email_id: str = Field(
+        alias="emailId", description="The email id corresponding to the Agent"
+    )
+    allowed_type: str = Field(
+        alias="allowedType", description="The allowed type for the agent trigger"
+    )
+    allowed_values: str = Field(
+        alias="allowedValues", description="The allowed values for the agent trigger"
+    )
+    pipeline_id: str = Field(
+        alias="pipelineId", description="The Pipeline Version identifier"
+    )
+    data_source_id: Optional[str] = Field(
+        alias="dataSourceId", default=None, description="The Data Source identifier"
+    )
+    store_connector_id: Optional[str] = Field(
+        alias="storeConnectorId",
+        default=None,
+        description="The datastore connector identifier",
+    )
+    email_action: str = Field(
+        alias="emailAction", description="The email action to be performed"
+    )
+    forward_to: Optional[str] = Field(
+        alias="forwardTo",
+        default=None,
+        description="The recipient to forward to",
+        max_length=4000,
+    )
+
 
+class Pipeline(BaseModel):
+    """Represents a processing pipeline.
 
-class DataSource(BaseModel):
-    """Data source configuration for pipeline data input.
+    Pipelines are the core workflow definition in the Airia platform, containing
+    a series of connected steps that process data and execute AI tasks. Each pipeline
+    can have multiple versions and can be deployed for end-user access.
 
     Attributes:
-        id: Unique identifier for the data source
-        name: Optional name of the data source
-        execution_name: Optional name used during execution
-        chunking_config: Configuration for text chunking
-        data_source_type: Type of data source (file, database, etc.)
-        database_type: Type of database if applicable
-        embedding_provider: Provider for text embeddings
-        is_user_specific: Whether the data source is user-specific
-        files: Optional list of files in the data source
-        configuration_json: Optional JSON configuration string
-        credentials: Optional credentials for data source access
-        is_image_processing_enabled: Whether image processing is enabled
+        id: The unique identifier of the pipeline
+        tenant_id: The tenant ID this pipeline belongs to
+        project_id: The project ID this pipeline belongs to
+        created_at: Timestamp when the pipeline was created
+        updated_at: Timestamp when the pipeline was last modified
+        user_id: The ID of the user who created this pipeline
+        active_version_id: The ID of the currently active version for execution
+        name: The human-readable name of the pipeline
+        execution_name: The name used when executing the pipeline programmatically
+        description: A detailed description of the pipeline's purpose and functionality
+        video_link: Optional URL to a video demonstration or tutorial
+        agent_icon_id: The ID of the icon used to represent this pipeline
+        versions: All available versions of this pipeline
+        execution_stats: Historical execution performance statistics
+        industry: The primary industry or domain this pipeline serves
+        sub_industries: Additional industry classifications and tags
+        agent_details: Configurable parameters and metadata for agent behavior
+        agent_details_tags: Tags for categorizing agent capabilities
+        active_version: The complete active version object (if loaded)
+        backup_pipeline_id: ID of a fallback pipeline in case of failure
+        deployment: The deployment configuration for end-user access
+        library_agent_id: ID of the library agent this pipeline is based on
+        library_imported_hash: Hash of the imported library agent for version tracking
+        library_imported_version: Version of the imported library agent
+        is_deleted: Whether this pipeline is marked for deletion
+        agent_trigger: Optional trigger configuration for automatic execution
+        api_key_id: ID of the API key used for external service authentication
+        is_seeded: Whether this pipeline comes from the platform's seed data
+        behaviours: List of capabilities and behaviors this agent can perform
     """
 
-    id: str = Field(alias="id")
-    name: Optional[str] = None
-    execution_name: Optional[str] = Field(None, alias="executionName")
-    chunking_config: ChunkingConfig = Field(alias="chunkingConfig")
-    data_source_type: str = Field(alias="dataSourceType")
-    database_type: str = Field(alias="databaseType")
-    embedding_provider: str = Field(alias="embeddingProvider")
-    is_user_specific: bool = Field(alias="isUserSpecific")
-    files: Optional[List[DataSourceFile]] = None
-    configuration_json: Optional[str] = Field(None, alias="configurationJson")
-    credentials: Optional[CredentialsDefinition]
-    is_image_processing_enabled: bool = Field(alias="isImageProcessingEnabled")
+    id: str = Field(description="The unique identifier of the pipeline")
+    tenant_id: Optional[str] = Field(
+        alias="tenantId", default=None, description="The Tenant Id"
+    )
+    project_id: Optional[str] = Field(
+        alias="projectId", default=None, description="The project Id"
+    )
+    created_at: Optional[datetime] = Field(
+        alias="createdAt", default=None, description="The created at timestamp"
+    )
+    updated_at: Optional[datetime] = Field(
+        alias="updatedAt", default=None, description="The updated at timestamp"
+    )
+    user_id: Optional[str] = Field(
+        alias="userId", default=None, description="The user ID"
+    )
+    active_version_id: Optional[str] = Field(
+        alias="activeVersionId",
+        default=None,
+        description="The unique identifier of pipeline's active version",
+    )
+    name: Optional[str] = Field(default=None, description="The name of the pipeline")
+    execution_name: Optional[str] = Field(
+        alias="executionName",
+        default=None,
+        description="The execution name of the pipeline",
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="The optional description of the pipeline",
+        max_length=2000,
+    )
+    video_link: Optional[str] = Field(
+        alias="videoLink", default=None, description="The video link of the pipeline"
+    )
+    agent_icon_id: Optional[str] = Field(
+        alias="agentIconId", default=None, description="The Agent Icon Id"
+    )
+    versions: Optional[List[PipelineVersion]] = Field(
+        default=None, description="The versions of this pipeline"
+    )
+    execution_stats: Optional[PipelineExecutionStats] = Field(
+        alias="executionStats", default=None, description="The execution statistics"
+    )
+    industry: Optional[str] = Field(
+        default=None, description="The main industry of the pipeline"
+    )
+    sub_industries: Optional[List[str]] = Field(
+        alias="subIndustries", default=None, description="The agent sub-industries tags"
+    )
+    agent_details: Optional[Dict[str, List[AgentDetailsEntry]]] = Field(
+        alias="agentDetails", default=None, description="The agent details properties"
+    )
+    agent_details_tags: Optional[List[str]] = Field(
+        alias="agentDetailsTags", default=None, description="The agent details tags"
+    )
+    active_version: Optional[PipelineVersion] = Field(
+        alias="activeVersion",
+        default=None,
+        description="The active version of this pipeline",
+    )
+    backup_pipeline_id: Optional[str] = Field(
+        alias="backupPipelineId",
+        default=None,
+        description="The unique identifier of the backup pipeline",
+    )
+    deployment: Optional[Deployment] = Field(
+        default=None, description="The associated Deployment for this pipeline"
+    )
+    library_agent_id: Optional[str] = Field(
+        alias="libraryAgentId",
+        default=None,
+        description="The library agent id associated with the pipeline",
+    )
+    library_imported_hash: Optional[str] = Field(
+        alias="libraryImportedHash", default=None, description="The library agent hash"
+    )
+    library_imported_version: Optional[str] = Field(
+        alias="libraryImportedVersion",
+        default=None,
+        description="The library imported version",
+    )
+    is_deleted: Optional[bool] = Field(
+        alias="isDeleted",
+        default=None,
+        description="Whether this entity is marked for deletion",
+    )
+    agent_trigger: Optional[AgentTrigger] = Field(
+        alias="agentTrigger",
+        default=None,
+        description="The Agent trigger associated with the pipeline",
+    )
+    api_key_id: Optional[str] = Field(
+        alias="apiKeyId", default=None, description="The Api Key navigation property"
+    )
+    is_seeded: Optional[bool] = Field(
+        alias="isSeeded", default=None, description="Whether the pipeline is seeded"
+    )
+    behaviours: Optional[List[str]] = Field(
+        default=None, description="The behaviours that the agent can perform"
+    )
 
 
-class GetPipelineConfigResponse(BaseModel):
-    """Complete pipeline configuration export response.
+class PipelineConfigResponse(Pipeline):
+    """Represents a complete pipeline configuration response.
 
-    This is the root response model containing all components of a pipeline
-    configuration, including the agent definition, associated resources,
-    and deployment settings.
+    Extends the base Pipeline model with additional deployment and access control
+    information. This is the primary response model for pipeline configuration
+    endpoints that need full context including deployment details and user permissions.
 
     Attributes:
-        metadata: Pipeline metadata and export configuration
-        agent: AI agent configuration and workflow definition
-        data_sources: Optional list of data sources for the pipeline
-        prompts: Optional list of prompt templates
-        tools: Optional list of external tools and integrations
-        models: Optional list of AI models used in the pipeline
-        memories: Optional memory/context storage configurations
-        python_code_blocks: Optional list of custom Python code blocks
-        routers: Optional list of model routing configurations
-        deployment: Optional deployment configuration
+        deployment_id: The ID of the associated deployment (if deployed)
+        deployment_name: The name of the associated deployment
+        deployment_description: The description of the associated deployment
+        user_keys: Dictionary mapping user roles to user IDs for access control
+        group_keys: Dictionary mapping group roles to group IDs for access control
+        agent_icon: Base64 encoded agent icon image data
+        external: Whether this is an external agent imported via Agent-to-Agent (A2A)
     """
 
-    metadata: Metadata
-    agent: Agent
-    data_sources: Optional[List[DataSource]] = Field(
-        alias="dataSources", default_factory=list
+    deployment_id: Optional[str] = Field(
+        alias="deploymentId", default=None, description="The Deployment Id"
+    )
+    deployment_name: Optional[str] = Field(
+        alias="deploymentName", default=None, description="The Deployment Name"
+    )
+    deployment_description: Optional[str] = Field(
+        alias="deploymentDescription",
+        default=None,
+        description="The Deployment Description",
+    )
+    user_keys: Optional[Dict[str, str]] = Field(
+        alias="userKeys", default=None, description="The User Ids"
+    )
+    group_keys: Optional[Dict[str, str]] = Field(
+        alias="groupKeys", default=None, description="The Group Ids"
+    )
+    agent_icon: Optional[str] = Field(
+        alias="agentIcon", default=None, description="The Agent icon"
     )
-    prompts: Optional[List[Prompt]] = Field(default_factory=list)
-    tools: Optional[List[Tool]] = Field(default_factory=list)
-    models: Optional[List[Model]] = Field(default_factory=list)
-    memories: Optional[Any] = None
-    python_code_blocks: Optional[List[PythonCodeBlock]] = Field(
-        alias="pythonCodeBlocks", default_factory=list
+    external: Optional[bool] = Field(
+        default=None,
+        description="Whether the agent is an external agent imported using A2A",
     )
-    routers: Optional[List[Router]] = Field(default_factory=list)
-    deployment: Optional[Any] = None